119 lines
4.8 KiB
C++
119 lines
4.8 KiB
C++
/********************************************************************************
|
|
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
|
|
* Copyright (c) 2010-2016 Daniel Chappuis *
|
|
*********************************************************************************
|
|
* *
|
|
* This software is provided 'as-is', without any express or implied warranty. *
|
|
* In no event will the authors be held liable for any damages arising from the *
|
|
* use of this software. *
|
|
* *
|
|
* Permission is granted to anyone to use this software for any purpose, *
|
|
* including commercial applications, and to alter it and redistribute it *
|
|
* freely, subject to the following restrictions: *
|
|
* *
|
|
* 1. The origin of this software must not be misrepresented; you must not claim *
|
|
* that you wrote the original software. If you use this software in a *
|
|
* product, an acknowledgment in the product documentation would be *
|
|
* appreciated but is not required. *
|
|
* *
|
|
* 2. Altered source versions must be plainly marked as such, and must not be *
|
|
* misrepresented as being the original software. *
|
|
* *
|
|
* 3. This notice may not be removed or altered from any source distribution. *
|
|
* *
|
|
********************************************************************************/
|
|
|
|
// Libraries
|
|
#include "HalfEdgeStructure.h"
|
|
#include <map>
|
|
|
|
using namespace reactphysics3d;
|
|
|
|
// Initialize the structure
|
|
void HalfEdgeStructure::init(std::vector<Vector3> vertices, std::vector<std::vector<uint>> faces) {
|
|
|
|
using edgeKey = std::pair<uint, uint>;
|
|
|
|
std::map<edgeKey, Edge> edges;
|
|
std::map<edgeKey, edgeKey> nextEdges;
|
|
std::map<edgeKey, uint> mapEdgeToStartVertex;
|
|
std::map<edgeKey, uint> mapEdgeToIndex;
|
|
|
|
// For each vertices
|
|
for (uint v=0; v<vertices.size(); v++) {
|
|
Vertex vertex(vertices[v]);
|
|
mVertices.push_back(vertex);
|
|
}
|
|
|
|
// For each face
|
|
for (uint f=0; f<faces.size(); f++) {
|
|
|
|
// Create a new face
|
|
Face face;
|
|
mFaces.push_back(face);
|
|
|
|
// Vertices of the current face
|
|
std::vector<uint>& faceVertices = faces[f];
|
|
|
|
std::vector<edgeKey> currentFaceEdges;
|
|
|
|
edgeKey firstEdgeKey;
|
|
|
|
// For each vertex of the face
|
|
for (uint v=0; v < faceVertices.size(); v++) {
|
|
uint v1Index = faceVertices[v];
|
|
uint v2Index = faceVertices[v == (faceVertices.size() - 1) ? 0 : v + 1];
|
|
|
|
const edgeKey pairV1V2 = std::make_pair(v1Index, v2Index);
|
|
|
|
// Create a new half-edge
|
|
Edge edge;
|
|
edge.faceIndex = f;
|
|
edge.vertexIndex = v1Index;
|
|
if (v == 0) {
|
|
firstEdgeKey = pairV1V2;
|
|
}
|
|
else if (v >= 1) {
|
|
nextEdges.insert(std::make_pair(currentFaceEdges[currentFaceEdges.size() - 1], pairV1V2));
|
|
}
|
|
if (v == (faceVertices.size() - 1)) {
|
|
nextEdges.insert(std::make_pair(pairV1V2, firstEdgeKey));
|
|
}
|
|
edges.insert(std::make_pair(pairV1V2, edge));
|
|
|
|
const edgeKey pairV2V1 = std::make_pair(v2Index, v1Index);
|
|
|
|
mapEdgeToStartVertex.insert(std::make_pair(pairV1V2, v1Index));
|
|
mapEdgeToStartVertex.insert(std::make_pair(pairV2V1, v2Index));
|
|
|
|
auto itEdge = edges.find(pairV2V1);
|
|
if (itEdge != edges.end()) {
|
|
|
|
const uint edgeIndex = mEdges.size();
|
|
mEdges.push_back(itEdge->second);
|
|
mEdges.push_back(edge);
|
|
|
|
itEdge->second.twinEdgeIndex = edgeIndex + 1;
|
|
|
|
edge.twinEdgeIndex = edgeIndex;
|
|
|
|
mVertices[v1Index].edgeIndex = edgeIndex;
|
|
mVertices[v2Index].edgeIndex = edgeIndex + 1;
|
|
|
|
mapEdgeToIndex.insert(std::make_pair(pairV1V2, edgeIndex + 1));
|
|
mapEdgeToIndex.insert(std::make_pair(pairV2V1, edgeIndex));
|
|
|
|
face.edgeIndex = edgeIndex + 1;
|
|
}
|
|
|
|
currentFaceEdges.push_back(pairV1V2);
|
|
}
|
|
}
|
|
|
|
// Set next edges
|
|
std::map<edgeKey, Edge>::iterator it;
|
|
for (it = edges.begin(); it != edges.end(); ++it) {
|
|
it->second.nextEdgeIndex = mapEdgeToIndex[nextEdges[it->first]];
|
|
}
|
|
}
|