AnotherFoxGuy/polyvox
1
0
Fork 0
Code Issues Pull Requests Activity

Removed lots of old decimation code.

Browse Source
This commit is contained in:
David Williams 2007-09-21 15:01:28 +00:00
parent 2f5f179886
commit 63c5886d1d
4 changed files with 3 additions and 675 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/PolyVoxSceneManager.h
View File

@ -75,8 +75,6 @@ namespace Ogre
void generateLevelVolume(void);
std::map<uchar, SurfacePatch> generateMeshDataForRegion(uint regionX, uint regionY, uint regionZ) const;
//void mergeVertices6(std::vector< std::vector<SurfaceVertex> >& vertexData, std::vector< std::vector<SurfaceTriangle> >& indexData) const;
bool verticesArePlanar3(uint uCurrentVertex, std::set<uint> setConnectedVertices, std::vector<SurfaceVertex>& vertexData) const;
void doRegionGrowing(uint xStart, uint yStart, uint zStart, uchar value);

18
include/SurfacePatch.h
View File

@ -43,29 +43,13 @@ namespace Ogre
void computeNormalsFromVolume(VolumeIterator volIter);
#ifdef BLAH
bool decimate(void);
bool canCollapseEdge(SurfaceVertex target, SurfaceVertex other);
void collapseEdge(SurfaceEdgeIterator edgeIter);
#endif
#ifdef BLAH2
bool decimate2(void);
bool canCollapseEdge2(SurfaceVertex target, SurfaceVertex other);
void collapseEdge2(SurfaceEdgeIterator edgeIter);
bool matchesAll(uchar target, uchar other);
#endif
bool canRemoveVertex(SurfaceVertexIterator vertexIter);
bool canRemoveVertexFrom(SurfaceVertexIterator vertexIter, std::list<SurfaceVertexIterator> listConnectedIter, bool isEdge);
std::list<SurfaceVertexIterator> findConnectedVertices(SurfaceVertexIterator vertexIter, bool& isEdge);
std::list<SurfaceEdgeIterator> removeTrianglesAndFindEdges(SurfaceVertexIterator vertexIter);
bool decimate3(void);
bool decimateOneVertex(void);
//bool verticesArePlanar(SurfaceVertexIterator iterCurrentVertex);
UIntVector3 m_v3dOffset;
private:

157
source/PolyVoxSceneManager.cpp
View File

@ -1013,7 +1013,7 @@ namespace Ogre
//for(uint ct = 0; ct < 3; ct++)
do
{
removedVertex = iterPatch->second.decimate3();
removedVertex = iterPatch->second.decimateOneVertex();
}
while(removedVertex);
}
@ -1023,161 +1023,6 @@ namespace Ogre
return result;
}
#ifdef BLAH
void PolyVoxSceneManager::mergeVertices6(std::vector< std::vector<SurfaceVertex> >& vertexData, std::vector< std::vector<SurfaceTriangle> >& indexData) const
{
for(uint material = 1; material < 256; ++material)
{
if(vertexData[material].empty())
continue;
//Ogre::LogManager::getSingleton().logMessage("Material = " + Ogre::StringConverter::toString(material) + " No of vertices = " + Ogre::StringConverter::toString(vertexData[material].size()));
std::vector< std::set<uint> > connectedVertices;
connectedVertices.resize(vertexData[material].size());
for(uint vertexCt = 0; vertexCt < vertexData[material].size(); vertexCt++)
{
for(uint triangleCt = 0; triangleCt < indexData[material].size(); ++triangleCt)
{
if((indexData[material][triangleCt].v0 == vertexCt) || (indexData[material][triangleCt].v1 == vertexCt) || (indexData[material][triangleCt].v2 == vertexCt))
{
connectedVertices[vertexCt].insert(indexData[material][triangleCt].v0);
connectedVertices[vertexCt].insert(indexData[material][triangleCt].v1);
connectedVertices[vertexCt].insert(indexData[material][triangleCt].v2);
}
}
connectedVertices[vertexCt].erase(vertexCt);
}
std::vector< uint > initialConnections;
initialConnections.resize(vertexData[material].size());
for(uint vertexCt = 0; vertexCt < vertexData[material].size(); vertexCt++)
{
initialConnections[vertexCt] = connectedVertices[vertexCt].size();
}
/*std::vector<uint> noOfEdges; //0 means not on ege, 1 means edge, 2 or more means corner
noOfEdges.resize(vertexData[material].size());
for(uint vertexCt = 0; vertexCt < vertexData[material].size(); ++vertexCt)
{
noOfEdges[vertexCt] = 0;
}
for(uint vertexCt = 0; vertexCt < vertexData[material].size(); ++vertexCt)
{
if(vertexData[material][vertexCt].position.x < 0.25)
noOfEdges[vertexCt] |= 1;
if(vertexData[material][vertexCt].position.y < 0.25)
noOfEdges[vertexCt] |= 2;
if(vertexData[material][vertexCt].position.z < 0.25)
noOfEdges[vertexCt] |= 4;
if(vertexData[material][vertexCt].position.x > OGRE_REGION_SIDE_LENGTH-0.25)
noOfEdges[vertexCt] |= 8;
if(vertexData[material][vertexCt].position.y > OGRE_REGION_SIDE_LENGTH-0.25)
noOfEdges[vertexCt] |= 16;
if(vertexData[material][vertexCt].position.z > OGRE_REGION_SIDE_LENGTH-0.25)
noOfEdges[vertexCt] |= 32;
}*/
for(uint u = 0; u < 50; u++)
{
//FIXME - this is innefficient! iterating over ever vertex, even though one material might just use a few of them.
for(uint vertexCt = 0; vertexCt < vertexData[material].size(); vertexCt++)
{
//if((initialConnections[vertexCt] == 6) || (initialConnections[vertexCt] == initialConnections[*connectedIter]))
{
if(verticesArePlanar3(vertexCt, connectedVertices[vertexCt], vertexData[material]))
{
std::set<uint>::iterator connectedIter = connectedVertices[vertexCt].begin();
/*for(uint triCt = 0; triCt < indexData[material].size(); triCt++)
{
if(indexData[material][triCt].v0 == vertexCt)
{
indexData[material][triCt].v0 = *connectedIter;
}
if(indexData[material][triCt].v1 == vertexCt)
{
indexData[material][triCt].v1 = *connectedIter;
}
if(indexData[material][triCt].v2 == vertexCt)
{
indexData[material][triCt].v2 = *connectedIter;
}
}*/
for(uint innerVertexCt = 0; innerVertexCt < vertexData[material].size(); innerVertexCt++)
{
if(vertexData[material][innerVertexCt].position.distance(vertexData[material][vertexCt].position) < 0.1)
{
if((initialConnections[innerVertexCt] == 6) || (initialConnections[innerVertexCt] == initialConnections[*connectedIter]))
vertexData[material][innerVertexCt].position = vertexData[material][*connectedIter].position;
}
}
}
}
}
}
//Delete degenerate triangles
std::vector<SurfaceVertex> resultingVertexData;
std::vector<SurfaceTriangle> resultingIndexData;
for(uint triCt = 0; triCt < indexData[material].size(); triCt++)
{
if((indexData[material][triCt].v0 != indexData[material][triCt].v1) || (indexData[material][triCt].v1 != indexData[material][triCt].v2))
{
uint pos = resultingVertexData.size();
resultingVertexData.push_back(vertexData[material][indexData[material][triCt].v0]);
resultingVertexData.push_back(vertexData[material][indexData[material][triCt].v1]);
resultingVertexData.push_back(vertexData[material][indexData[material][triCt].v2]);
SurfaceTriangle triangle(pos, pos+1, pos+2);
resultingIndexData.push_back(triangle);
}
}
vertexData[material] = resultingVertexData;
indexData[material] = resultingIndexData;
}
}
#endif
bool PolyVoxSceneManager::verticesArePlanar3(uint uCurrentVertex, std::set<uint> setConnectedVertices, std::vector<SurfaceVertex>& vertexData) const
{
//FIXME - specially handle the case where they are all the same.
//This is happening a lot after many vertices have been moved round?
bool allXMatch = true;
bool allYMatch = true;
bool allZMatch = true;
bool allNormalsMatch = true;
//FIXME - reorder come of these tests based on likelyness to fail?
std::set<uint>::iterator iterConnectedVertices;
for(iterConnectedVertices = setConnectedVertices.begin(); iterConnectedVertices != setConnectedVertices.end(); ++iterConnectedVertices)
{
if(vertexData[uCurrentVertex].position.x != vertexData[*iterConnectedVertices].position.x)
{
allXMatch = false;
}
if(vertexData[uCurrentVertex].position.y != vertexData[*iterConnectedVertices].position.y)
{
allYMatch = false;
}
if(vertexData[uCurrentVertex].position.z != vertexData[*iterConnectedVertices].position.z)
{
allZMatch = false;
}
//FIXME - are these already normalised? We should make sure they are...
if(vertexData[uCurrentVertex].normal.normalisedCopy().dotProduct(vertexData[*iterConnectedVertices].normal.normalisedCopy()) < 0.99)
{
return false;
}
}
return allXMatch || allYMatch || allZMatch;
}
void PolyVoxSceneManager::markVoxelChanged(uint x, uint y, uint z)
{
//If we are not on a boundary, just mark one region.

501
source/SurfacePatch.cpp
View File

@ -279,115 +279,6 @@ namespace Ogre
}
}
bool SurfacePatch::canRemoveVertex(SurfaceVertexIterator vertexIter)
{
//LogManager::getSingleton().logMessage("Checking to remove vertex " + vertexIter->toString());
//FIXME - use bit flags
bool allXMatch = true;
bool allYMatch = true;
bool allZMatch = true;
SurfaceEdgeIterator firstEdge = vertexIter->edge;
SurfaceEdgeIterator nextEdge = firstEdge;
SurfaceEdgeIterator previousEdge = firstEdge;
int ct = 0;
do
{
ct++;
//LogManager::getSingleton().logMessage("ct = " + StringConverter::toString(ct));
if(ct > 100)
{
LogManager::getSingleton().logMessage("ct too big!!! Aborting decimation");
exit(1);
}
LogManager::getSingleton().logMessage("Edge Target = " + nextEdge->target->toString() + " Edge Source = " + nextEdge->otherHalfEdge->target->toString());
if(nextEdge->target->position.x != vertexIter->position.x)
{
allXMatch = false;
}
if(nextEdge->target->position.y != vertexIter->position.y)
{
allYMatch = false;
}
if(nextEdge->target->position.z != vertexIter->position.z)
{
allZMatch = false;
}
previousEdge = nextEdge;
nextEdge = nextEdge->previousHalfEdge->otherHalfEdge;
}while((nextEdge != firstEdge) && (nextEdge != previousEdge));
if(nextEdge == previousEdge)
{
LogManager::getSingleton().logMessage("Is edge");
//In this case vertexIter is on an edge
//return false;
SurfaceVertexIterator firstExtreme = nextEdge->target;
nextEdge = firstEdge;
previousEdge = firstEdge;
previousEdge = nextEdge;
nextEdge = nextEdge->otherHalfEdge->nextHalfEdge;
int ct2 = 0;
do
{
ct2++;
//LogManager::getSingleton().logMessage("ct2 = " + StringConverter::toString(ct2));
if(ct2 > 100)
{
LogManager::getSingleton().logMessage("ct2 too big!!! Aborting decimation");
exit(1);
}
LogManager::getSingleton().logMessage("Edge Target = " + nextEdge->target->toString() + " Edge Source = " + nextEdge->otherHalfEdge->target->toString());
if(nextEdge->isDegenerate())
{
LogManager::getSingleton().logMessage("Degenerate Edge Here!!");
}
if(nextEdge->target->position.x != vertexIter->position.x)
{
allXMatch = false;
}
if(nextEdge->target->position.y != vertexIter->position.y)
{
allYMatch = false;
}
if(nextEdge->target->position.z != vertexIter->position.z)
{
allZMatch = false;
}
previousEdge = nextEdge;
nextEdge = nextEdge->otherHalfEdge->nextHalfEdge;
}while(nextEdge != previousEdge);
SurfaceVertexIterator secondExtreme = nextEdge->target;
LogManager::getSingleton().logMessage("FirstExtreme = " + firstExtreme->toString() + ", SecondExtreme = " + secondExtreme->toString());
bool edgeXMatch = (firstExtreme->position.x == vertexIter->position.x) && (secondExtreme->position.x == vertexIter->position.x);
bool edgeYMatch = (firstExtreme->position.y == vertexIter->position.y) && (secondExtreme->position.y == vertexIter->position.y);
bool edgeZMatch = (firstExtreme->position.z == vertexIter->position.z) && (secondExtreme->position.z == vertexIter->position.z);
bool twoEdgesMatch = ((edgeXMatch&&edgeYMatch) || (edgeXMatch&&edgeZMatch) || (edgeYMatch&&edgeZMatch));
//LogManager::getSingleton().logMessage("Done checking (edge)");
return (allXMatch || allYMatch || allZMatch)
&& (twoEdgesMatch);
}
//LogManager::getSingleton().logMessage("Done checking (not edge)");
return allXMatch || allYMatch || allZMatch;
}
bool SurfacePatch::canRemoveVertexFrom(SurfaceVertexIterator vertexIter, std::list<SurfaceVertexIterator> listConnectedIter, bool isEdge)
{
bool allXMatch = true;
@ -565,7 +456,7 @@ namespace Ogre
return result;
}
bool SurfacePatch::decimate3(void)
bool SurfacePatch::decimateOneVertex(void)
{
bool didDecimation = false;
LogManager::getSingleton().logMessage("\n\nPerforming decimation");
@ -662,394 +553,4 @@ namespace Ogre
return didDecimation;
}
#ifdef BLAH
bool SurfacePatch::decimate(void)
{
bool removedEdge = false;
LogManager::getSingleton().logMessage("Performing decimation");
LogManager::getSingleton().logMessage("No of triangles = " + StringConverter::toString(m_listTriangles.size()));
for(SurfaceEdgeIterator edgeIter = m_listEdges.begin(); edgeIter != m_listEdges.end(); ++edgeIter)
{
LogManager::getSingleton().logMessage("Examining Edge " + edgeIter->toString());
SurfaceVertexIterator targetVertexIter = edgeIter->target;
SurfaceVertexIterator otherVertexIter = edgeIter->nextHalfEdge->nextHalfEdge->target;
LogManager::getSingleton().logMessage("Target Vertex = " + targetVertexIter->toString());
LogManager::getSingleton().logMessage("Other Vertex = " + otherVertexIter->toString());
//if((targetVertexIter->flags == 0) /*&& (otherVertexIter->flags == 0)*/)
if(canCollapseEdge(*targetVertexIter,*otherVertexIter))
{
collapseEdge(edgeIter);
removedEdge = true;
break;
}
else
{
LogManager::getSingleton().logMessage(" Not Collapsing Edge");
//LogManager::getSingleton().logMessage("Edge Target Vertex = " + StringConverter::toString(edgeIter->target->position.toOgreVector3()));
//LogManager::getSingleton().logMessage("Other Edge Non-Existant");
}
}
LogManager::getSingleton().logMessage("Done decimation");
LogManager::getSingleton().logMessage("No of triangles = " + StringConverter::toString(m_listTriangles.size()));
return removedEdge;
}
bool SurfacePatch::canCollapseEdge(SurfaceVertex target, SurfaceVertex other)
{
if((target.flags == 0) /*&& (other.flags == 0)*/)
{
if((other.flags == 0))
{
LogManager::getSingleton().logMessage("Both Zero");
return true;
}
else
{
LogManager::getSingleton().logMessage("Target Zero");
return false;
}
//return true;
}
else
return false;
}
void SurfacePatch::collapseEdge(SurfaceEdgeIterator edgeIter)
{
SurfaceVertexIterator targetVertexIter = edgeIter->target;
SurfaceVertexIterator otherVertexIter = edgeIter->nextHalfEdge->nextHalfEdge->target;
LogManager::getSingleton().logMessage(" Collapsing Edge");
for(SurfaceEdgeIterator innerEdgeIter = m_listEdges.begin(); innerEdgeIter != m_listEdges.end(); ++innerEdgeIter)
{
if((innerEdgeIter->target == targetVertexIter) && (innerEdgeIter != edgeIter))
{
LogManager::getSingleton().logMessage(" Reset Edge Target");
innerEdgeIter->target = otherVertexIter;
}
}
if(edgeIter->hasOtherHalfEdge)
{
LogManager::getSingleton().logMessage(" Has Other Edge");
SurfaceEdgeIterator otherEdgeIter = edgeIter->otherHalfEdge;
/*SurfaceTriangleIterator otherTriangleIter = otherEdgeIter->triangle;
m_listTriangles.erase(otherTriangleIter);*/
LogManager::getSingleton().logMessage(" Removing Other Edges");
SurfaceTriangleIterator otherTriangleIter = otherEdgeIter->triangle;
SurfaceEdgeIterator currentIter = otherTriangleIter->edge;
for(uint ct = 0; ct < 3; ++ct)
{
SurfaceEdgeIterator previousIter = currentIter;
currentIter = currentIter->nextHalfEdge;
if(previousIter->hasOtherHalfEdge)
{
previousIter->otherHalfEdge->hasOtherHalfEdge = false;
}
for(SurfaceVertexIterator vertexIter = m_listVertices.begin(); vertexIter != m_listVertices.end(); ++vertexIter)
{
if(vertexIter->edge == previousIter)
{
LogManager::getSingleton().logMessage("Error! Vertex points to dead edge!");
for(SurfaceEdgeIterator potentialNewEdge = m_listEdges.begin(); potentialNewEdge != m_listEdges.end(); ++potentialNewEdge)
{
if(potentialNewEdge->hasOtherHalfEdge)
{
if(potentialNewEdge->otherHalfEdge->target == vertexIter)
{
vertexIter->edge = potentialNewEdge;
LogManager::getSingleton().logMessage(" Fixed");
break;
}
}
}
}
}
m_listEdges.erase(previousIter);
}
LogManager::getSingleton().logMessage(" Removing Other Triangle");
m_listTriangles.erase(otherTriangleIter);
}
else
{
LogManager::getSingleton().logMessage(" Does Not Have Other Edge");
}
LogManager::getSingleton().logMessage(" Removing Edges");
SurfaceTriangleIterator triangleIter = edgeIter->triangle;
SurfaceEdgeIterator currentIter = triangleIter->edge;
for(uint ct = 0; ct < 3; ++ct)
{
SurfaceEdgeIterator previousIter = currentIter;
currentIter = currentIter->nextHalfEdge;
if(previousIter->hasOtherHalfEdge)
{
previousIter->otherHalfEdge->hasOtherHalfEdge = false;
}
for(SurfaceVertexIterator vertexIter = m_listVertices.begin(); vertexIter != m_listVertices.end(); ++vertexIter)
{
if(vertexIter->edge == previousIter)
{
LogManager::getSingleton().logMessage("Error! Vertex points to dead edge!");
for(SurfaceEdgeIterator potentialNewEdge = m_listEdges.begin(); potentialNewEdge != m_listEdges.end(); ++potentialNewEdge)
{
if(potentialNewEdge->hasOtherHalfEdge)
{
if(potentialNewEdge->otherHalfEdge->target == vertexIter)
{
vertexIter->edge = potentialNewEdge;
LogManager::getSingleton().logMessage(" Fixed");
break;
}
}
}
}
}
m_listEdges.erase(previousIter);
}
LogManager::getSingleton().logMessage(" Removing Triangle");
m_listTriangles.erase(triangleIter);
LogManager::getSingleton().logMessage(" Removing Vertex");
m_listVertices.erase(targetVertexIter);
}
#endif
#ifdef BLAH2
bool SurfacePatch::decimate2(void)
{
bool didDecimate = false;
//return false;
LogManager::getSingleton().logMessage("Performing decimation");
LogManager::getSingleton().logMessage("No of triangles = " + StringConverter::toString(m_listTriangles.size()));
std::list<SurfaceEdgeIterator> edgeList;
for(SurfaceVertexIterator vertexIter = m_listVertices.begin(); vertexIter != m_listVertices.end(); ++vertexIter)
{
vertexIter->fixed = false;
}
for(SurfaceEdgeIterator edgeIter = m_listEdges.begin(); edgeIter != m_listEdges.end(); ++edgeIter)
{
LogManager::getSingleton().logMessage("Examining Edge " + edgeIter->toString());
SurfaceVertexIterator targetVertexIter = edgeIter->target;
SurfaceVertexIterator otherVertexIter = edgeIter->nextHalfEdge->nextHalfEdge->target;
LogManager::getSingleton().logMessage("Target Vertex = " + targetVertexIter->toString());
LogManager::getSingleton().logMessage("Other Vertex = " + otherVertexIter->toString());
if(canCollapseEdge2(*targetVertexIter,*otherVertexIter))
{
LogManager::getSingleton().logMessage(" Collapsing Edge");
edgeList.push_back(edgeIter);
//collapseEdge2(edgeIter);
/*for(SurfaceVertexIterator vertexIter = m_listVertices.begin(); vertexIter != m_listVertices.end(); ++vertexIter)
{
if(vertexIter->position == targetVertexIter->position)
{
vertexIter->position = otherVertexIter->position;
vertexIter->flags = otherVertexIter->flags;
vertexIter->fixed = true;
}
}*/
}
else
{
LogManager::getSingleton().logMessage(" Not Collapsing Edge");
//LogManager::getSingleton().logMessage("Edge Target Vertex = " + StringConverter::toString(edgeIter->target->position.toOgreVector3()));
//LogManager::getSingleton().logMessage("Other Edge Non-Existant");
}
}
for(std::list<SurfaceEdgeIterator>::iterator edgeIter = edgeList.begin(); edgeIter != edgeList.end(); ++edgeIter)
{
SurfaceVertexIterator targetVertexIter = (*edgeIter)->target;
SurfaceVertexIterator otherVertexIter = (*edgeIter)->nextHalfEdge->nextHalfEdge->target;
if(targetVertexIter->fixed == true)
continue;
for(SurfaceVertexIterator vertexIter = m_listVertices.begin(); vertexIter != m_listVertices.end(); ++vertexIter)
{
if(vertexIter->position == targetVertexIter->position)
{
vertexIter->position = otherVertexIter->position;
vertexIter->flags = otherVertexIter->flags;
vertexIter->noOfUses = otherVertexIter->noOfUses;
vertexIter->fixed = true;
didDecimate = true;
}
}
}
LogManager::getSingleton().logMessage("Done decimation");
LogManager::getSingleton().logMessage("No of triangles = " + StringConverter::toString(m_listTriangles.size()));
return didDecimate;
}
bool SurfacePatch::canCollapseEdge2(SurfaceVertex target, SurfaceVertex other)
{
if(target.position == other.position)
return false;
if(target.fixed)
return false;
//FIXME - are these already normalised? We should make sure they are...
if(target.normal.normalisedCopy().dotProduct(other.normal.normalisedCopy()) < 0.999)
{
return false;
}
/*if((target.flags == 0) && (other.flags != 0))
return true;
return false;*/
/*if(target.flags == other.flags)
return true;
return false;*/
/*if(target.position == UIntVector3(0,0,15))
return false;
if(target.position == UIntVector3(0,16,15))
return false;
if(target.position == UIntVector3(16,0,15))
return false;
if(target.position == UIntVector3(16,16,15))
return false;*/
/*if(target.position.x < 3)
return false;
if(target.position.y < 3)
return false;
if(target.position.x > 13)
return false;
if(target.position.y > 13)
return false;*/
//return true;
if((target.noOfUses == 6) && (other.noOfUses != 6))
return true;
/*if((target.noOfUses == 6) && (other.noOfUses == 3))
return true;*/
return false;
/*if((matchesAll(other.flags, target.flags)) && (!matchesAll(target.flags, other.flags)))
{
return false;
}
return true;*/
}
bool SurfacePatch::matchesAll(uchar target, uchar other)
{
if(target & 1)
{
if(other & 1)
{
}
else
{
return false;
}
}
if(target & 2)
{
if(other & 2)
{
}
else
{
return false;
}
}
if(target & 4)
{
if(other & 4)
{
}
else
{
return false;
}
}
if(target & 8)
{
if(other & 8)
{
}
else
{
return false;
}
}
if(target & 16)
{
if(other & 16)
{
}
else
{
return false;
}
}
if(target & 32)
{
if(other & 32)
{
}
else
{
return false;
}
}
}
void SurfacePatch::collapseEdge2(SurfaceEdgeIterator edgeIter)
{
SurfaceVertexIterator targetVertexIter = edgeIter->target;
SurfaceVertexIterator otherVertexIter = edgeIter->nextHalfEdge->nextHalfEdge->target;
for(SurfaceVertexIterator vertexIter = m_listVertices.begin(); vertexIter != m_listVertices.end(); ++vertexIter)
{
if(vertexIter->position == targetVertexIter->position)
{
vertexIter->position = otherVertexIter->position;
}
}
}
#endif
}