Skip to content

Commit

Permalink
Main: EdgeListBuilder - use fixed size types as stored on disk
Browse files Browse the repository at this point in the history
  • Loading branch information
@paroj
paroj committed May 25, 2024
1 parent caa7a3d commit 07ebe10
Show file tree
Hide file tree
Showing 2 changed files with 36 additions and 38 deletions.
44 changes: 22 additions & 22 deletions OgreMain/include/OgreEdgeListBuilder.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -59,14 +59,14 @@ namespace Ogre {
struct Triangle {
/** The set of indexes this triangle came from (NB it is possible that the triangles on
one side of an edge are using a different vertex buffer from those on the other side.) */
size_t indexSet;
uint32 indexSet;
/** The vertex set these vertices came from. */
size_t vertexSet;
uint32 vertexSet;
/// Vertex indexes, relative to the original buffer
size_t vertIndex[3];
uint32 vertIndex[3];
/** Vertex indexes, relative to a shared vertex buffer with
duplicates eliminated (this buffer is not exposed) */
size_t sharedVertIndex[3];
uint32 sharedVertIndex[3];

Triangle() :indexSet(0), vertexSet(0) {}
};
Expand All @@ -75,12 +75,12 @@ namespace Ogre {
/** The indexes of the 2 tris attached, note that tri 0 is the one where the
indexes run _anti_ clockwise along the edge. Indexes must be
reversed for tri 1. */
size_t triIndex[2];
uint32 triIndex[2];
/** The vertex indices for this edge. Note that both vertices will be in the vertex
set as specified in 'vertexSet', which will also be the same as tri 0 */
size_t vertIndex[2];
uint32 vertIndex[2];
/** Vertex indices as used in the shared vertex list, not exposed. */
size_t sharedVertIndex[2];
uint32 sharedVertIndex[2];
/** Indicates if this is a degenerate edge, ie it does not have 2 triangles */
bool degenerate;
};
Expand All @@ -102,16 +102,16 @@ namespace Ogre {
struct EdgeGroup
{
/** The vertex set index that contains the vertices for this edge group. */
size_t vertexSet;
uint32 vertexSet;
/** Pointer to vertex data used by this edge group. */
const VertexData* vertexData;
/** Index to main triangles array, indicate the first triangle of this edge
group, and all triangles of this edge group are stored continuous in
main triangles array.
*/
size_t triStart;
uint32 triStart;
/** Number triangles of this edge group. */
size_t triCount;
uint32 triCount;
/** The edges themselves. */
EdgeList edges;

Expand Down Expand Up @@ -207,16 +207,16 @@ namespace Ogre {
and the faces hold the detail of the duplicated vertices.
*/
struct CommonVertex {
Vector3 position; /// Location of point in euclidean space
size_t index; /// Place of vertex in common vertex list
size_t vertexSet; /// The vertex set this came from
size_t indexSet; /// The index set this was referenced (first) from
size_t originalIndex; /// Place of vertex in original vertex set
Vector3f position; /// Location of point in euclidean space
uint32 index; /// Place of vertex in common vertex list
uint32 vertexSet; /// The vertex set this came from
uint32 indexSet; /// The index set this was referenced (first) from
uint32 originalIndex; /// Place of vertex in original vertex set
};
/** A set of indexed geometry data */
struct Geometry {
size_t vertexSet; /// The vertex data set this geometry data refers to
size_t indexSet; /// The index data set this geometry data refers to
uint32 vertexSet; /// The vertex data set this geometry data refers to
uint32 indexSet; /// The index data set this geometry data refers to
const IndexData* indexData; /// The index information which describes the triangles.
RenderOperation::OperationType opType; /// The operation type used to render this geometry
};
Expand Down Expand Up @@ -255,17 +255,17 @@ namespace Ogre {
/** Edge map, used to connect edges. Note we allow many triangles on an edge,
after connected an existing edge, we will remove it and never used again.
*/
typedef std::multimap< std::pair<size_t, size_t>, std::pair<size_t, size_t> > EdgeMap;
typedef std::multimap< std::pair<uint32, uint32>, std::pair<uint32, uint32> > EdgeMap;
EdgeMap mEdgeMap;

void buildTrianglesEdges(const Geometry &geometry);

/// Finds an existing common vertex, or inserts a new one
size_t findOrCreateCommonVertex(const Vector3& vec, size_t vertexSet,
size_t indexSet, size_t originalIndex);
uint32 findOrCreateCommonVertex(const Vector3f& vec, uint32 vertexSet,
uint32 indexSet, uint32 originalIndex);
/// Connect existing edge or create a new edge - utility method during building
void connectOrCreateEdge(size_t vertexSet, size_t triangleIndex, size_t vertIndex0, size_t vertIndex1,
size_t sharedVertIndex0, size_t sharedVertIndex1);
void connectOrCreateEdge(uint32 vertexSet, uint32 triangleIndex, uint32 vertIndex0, uint32 vertIndex1,
uint32 sharedVertIndex0, uint32 sharedVertIndex1);
};
/** @} */
/** @} */
Expand Down
30 changes: 14 additions & 16 deletions OgreMain/src/OgreEdgeListBuilder.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -190,8 +190,8 @@ namespace Ogre {
//---------------------------------------------------------------------
void EdgeListBuilder::buildTrianglesEdges(const Geometry &geometry)
{
size_t indexSet = geometry.indexSet;
size_t vertexSet = geometry.vertexSet;
uint32 indexSet = geometry.indexSet;
uint32 vertexSet = geometry.vertexSet;
const IndexData* indexData = geometry.indexData;
RenderOperation::OperationType opType = geometry.opType;

Expand Down Expand Up @@ -232,7 +232,7 @@ namespace Ogre {
unsigned int index[3];
// Get the triangle start, if we have more than one index set then this
// will not be zero
size_t triangleIndex = mEdgeData->triangles.size();
uint32 triangleIndex = mEdgeData->triangles.size();
// If it's first time dealing with the edge group, setup triStart for it.
// Note that we are assume geometries sorted by vertex set.
if (!eg.triCount)
Expand Down Expand Up @@ -282,7 +282,7 @@ namespace Ogre {
index[2] = *p16Idx++;
}

Vector3 v[3];
Vector3f v[3];
for (size_t i = 0; i < 3; ++i)
{
// Populate tri original vertex index
Expand All @@ -292,9 +292,7 @@ namespace Ogre {
unsigned char* pVertex = pBaseVertex + (index[i] * vbuf->getVertexSize());
float* pFloat;
posElem->baseVertexPointerToElement(pVertex, &pFloat);
v[i].x = *pFloat++;
v[i].y = *pFloat++;
v[i].z = *pFloat++;
memcpy(v[i].ptr(), pFloat, sizeof(Vector3f));
// find this vertex in the existing vertex map, or create it
tri.sharedVertIndex[i] =
findOrCreateCommonVertex(v[i], vertexSet, indexSet, index[i]);
Expand Down Expand Up @@ -330,12 +328,12 @@ namespace Ogre {
eg.triCount = triangleIndex - eg.triStart;
}
//---------------------------------------------------------------------
void EdgeListBuilder::connectOrCreateEdge(size_t vertexSet, size_t triangleIndex,
size_t vertIndex0, size_t vertIndex1, size_t sharedVertIndex0,
size_t sharedVertIndex1)
void EdgeListBuilder::connectOrCreateEdge(uint32 vertexSet, uint32 triangleIndex,
uint32 vertIndex0, uint32 vertIndex1, uint32 sharedVertIndex0,
uint32 sharedVertIndex1)
{
// Find the existing edge (should be reversed order) on shared vertices
EdgeMap::iterator emi = mEdgeMap.find(std::pair<size_t, size_t>(sharedVertIndex1, sharedVertIndex0));
EdgeMap::iterator emi = mEdgeMap.find(std::make_pair(sharedVertIndex1, sharedVertIndex0));
if (emi != mEdgeMap.end())
{
// The edge already exist, connect it
Expand All @@ -350,14 +348,14 @@ namespace Ogre {
else
{
// Not found, create new edge
mEdgeMap.emplace(std::pair<size_t, size_t>(sharedVertIndex0, sharedVertIndex1),
std::pair<size_t, size_t>(vertexSet, mEdgeData->edgeGroups[vertexSet].edges.size()));
mEdgeMap.emplace(std::make_pair(sharedVertIndex0, sharedVertIndex1),
std::make_pair(vertexSet, uint32(mEdgeData->edgeGroups[vertexSet].edges.size())));
EdgeData::Edge e;
e.degenerate = true; // initialise as degenerate

// Set only first tri, the other will be completed in connect existing edge
e.triIndex[0] = triangleIndex;
e.triIndex[1] = static_cast<size_t>(~0);
e.triIndex[1] = static_cast<uint32>(~0);
e.sharedVertIndex[0] = sharedVertIndex0;
e.sharedVertIndex[1] = sharedVertIndex1;
e.vertIndex[0] = vertIndex0;
Expand All @@ -366,8 +364,8 @@ namespace Ogre {
}
}
//---------------------------------------------------------------------
size_t EdgeListBuilder::findOrCreateCommonVertex(const Vector3& vec,
size_t vertexSet, size_t indexSet, size_t originalIndex)
uint32 EdgeListBuilder::findOrCreateCommonVertex(const Vector3f& vec,
uint32 vertexSet, uint32 indexSet, uint32 originalIndex)
{
// Because the algorithm doesn't care about manifold or not, we just identifying
// the common vertex by EXACT same position.
Expand Down

0 comments on commit 07ebe10

Please sign in to comment.