Switched to Half-Edge based data structure for meshes.

CMakeLists.txt

@@ -8,6 +8,7 @@ SET(SRC_FILES
 	source/MaterialMapManager.cpp
 	source/MaterialMapSerializer.cpp
 	source/PolyVoxSceneManager.cpp
+        source/SurfaceEdge.cpp
         source/SurfacePatch.cpp
         source/SurfacePatchRenderable.cpp
 	source/SurfaceTriangle.cpp

include/SurfaceEdge.h

@@ -0,0 +1,53 @@
+/******************************************************************************
+This file is part of a voxel plugin for OGRE
+Copyright (C) 2006  David Williams
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+******************************************************************************/
+
+#ifndef __SurfaceEdge_H__
+#define __SurfaceEdge_H__
+
+#include "OgrePrerequisites.h"
+
+namespace Ogre
+{
+	class SurfaceVertex;
+	typedef std::list<SurfaceVertex>::iterator SurfaceVertexIterator;
+	class SurfaceTriangle;
+	typedef std::list<SurfaceTriangle>::iterator SurfaceTriangleIterator;
+	class SurfaceEdge;
+	typedef std::list<SurfaceEdge>::iterator SurfaceEdgeIterator;
+
+	class SurfaceEdge
+	{
+	public:
+
+		SurfaceVertexIterator target;
+
+		SurfaceTriangleIterator triangle;
+
+		SurfaceEdgeIterator nextHalfEdge;
+
+		SurfaceEdgeIterator otherHalfEdge;
+
+		SurfaceEdge();
+	};
+
+	bool operator == (const SurfaceEdge& lhs, const SurfaceEdge& rhs);
+	bool operator < (const SurfaceEdge& lhs, const SurfaceEdge& rhs);
+}
+
+#endif

include/SurfacePatch.h

@@ -19,9 +19,11 @@ namespace Ogre
 	};
 
 	class SurfaceVertex;
-	typedef std::set<SurfaceVertex>::iterator SurfaceVertexIterator;
+	typedef std::list<SurfaceVertex>::iterator SurfaceVertexIterator;
 	class SurfaceTriangle;
-	typedef std::set<SurfaceTriangle>::iterator SurfaceTriangleIterator;
+	typedef std::list<SurfaceTriangle>::iterator SurfaceTriangleIterator;
+	class SurfaceEdge;
+	typedef std::list<SurfaceEdge>::iterator SurfaceEdgeIterator;
 
 	class SurfacePatch
 	{
@@ -38,15 +40,16 @@ namespace Ogre
 
 	   void computeNormalsFromVolume(VolumeIterator volIter);
 
-	   void decimate(void);
+	   //void decimate(void);
 
 	   //bool verticesArePlanar(SurfaceVertexIterator iterCurrentVertex);
 
 	   UIntVector3 m_v3dOffset;
 
 	private:
-		std::set<SurfaceVertex> m_setVertices;
+		std::list<SurfaceVertex> m_listVertices;
-		std::set<SurfaceTriangle> m_setTriangles;
+		std::list<SurfaceTriangle> m_listTriangles;
+		std::list<SurfaceEdge> m_listEdges;
 
 		//std::vector<SurfaceVertex> m_vecVertexData;
 		//std::vector<uint> m_vecIndexData;

include/SurfaceTriangle.h

@@ -25,25 +25,21 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 namespace Ogre
 {
 	class SurfaceVertex;
-	typedef std::set<SurfaceVertex>::iterator SurfaceVertexIterator;
+	typedef std::list<SurfaceVertex>::iterator SurfaceVertexIterator;
 	class SurfaceTriangle;
-	typedef std::set<SurfaceTriangle>::iterator SurfaceTriangleIterator;
+	typedef std::list<SurfaceTriangle>::iterator SurfaceTriangleIterator;
+	class SurfaceEdge;
+	typedef std::list<SurfaceEdge>::iterator SurfaceEdgeIterator;
 
 	class SurfaceTriangle
 	{
 	public:
 
-		SurfaceVertexIterator v0;
+		SurfaceEdgeIterator edge;
-		SurfaceVertexIterator v1;
-		SurfaceVertexIterator v2;
 
 		SurfaceTriangle();
-
-		SurfaceTriangle(SurfaceVertexIterator v0ToSet, SurfaceVertexIterator v1ToSet, SurfaceVertexIterator v2ToSet);
 	};
 
-	typedef std::set<SurfaceTriangle>::iterator SurfaceTriangleIterator;
-
 	bool operator == (const SurfaceTriangle& lhs, const SurfaceTriangle& rhs);
 	bool operator < (const SurfaceTriangle& lhs, const SurfaceTriangle& rhs);
 

include/SurfaceVertex.h

@@ -28,9 +28,11 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 namespace Ogre
 {	
 	class SurfaceVertex;
-	typedef std::set<SurfaceVertex>::iterator SurfaceVertexIterator;
+	typedef std::list<SurfaceVertex>::iterator SurfaceVertexIterator;
 	class SurfaceTriangle;
-	typedef std::set<SurfaceTriangle>::iterator SurfaceTriangleIterator;
+	typedef std::list<SurfaceTriangle>::iterator SurfaceTriangleIterator;
+	class SurfaceEdge;
+	typedef std::list<SurfaceEdge>::iterator SurfaceEdgeIterator;
 
 	class SurfaceVertex
 	{
@@ -38,9 +40,9 @@ namespace Ogre
 		UIntVector3 position;
 		Vector3 normal;
 		float alpha;
+		uchar flags;
 
-		std::list<SurfaceTriangleIterator> listTrianglesUsingThisVertex;
+		SurfaceEdgeIterator edge;
-		std::list<SurfaceVertexIterator> listConnectedVertices;
 
 		SurfaceVertex();
 

source/PolyVoxSceneManager.cpp

@@ -20,6 +20,7 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 #include "MarchingCubesTables.h"
 #include "MaterialMapManager.h"
 #include "SurfaceVertex.h"
+#include "SurfaceEdge.h"
 #include "PolyVoxSceneManager.h"
 #include "VolumeIterator.h"
 #include "VolumeManager.h"
@@ -323,10 +324,10 @@ namespace Ogre
 			for(uint regionZ = 0; regionZ < OGRE_VOLUME_SIDE_LENGTH_IN_REGIONS; ++regionZ)
 			{		
 				//LogManager::getSingleton().logMessage("regionZ = " + StringConverter::toString(regionZ));
-				for(uint regionY = OGRE_VOLUME_SIDE_LENGTH_IN_REGIONS/2; regionY < OGRE_VOLUME_SIDE_LENGTH_IN_REGIONS/2+1; ++regionY)
+				for(uint regionY = 0; regionY < OGRE_VOLUME_SIDE_LENGTH_IN_REGIONS; ++regionY)
 				{
 					//LogManager::getSingleton().logMessage("regionY = " + StringConverter::toString(regionY));
-					for(uint regionX = OGRE_VOLUME_SIDE_LENGTH_IN_REGIONS/2; regionX < OGRE_VOLUME_SIDE_LENGTH_IN_REGIONS/2+1; ++regionX)
+					for(uint regionX = 0; regionX < OGRE_VOLUME_SIDE_LENGTH_IN_REGIONS; ++regionX)
 					{
 						//LogManager::getSingleton().logMessage("regionX = " + StringConverter::toString(regionX));
 						if(surfaceUpToDate[regionX][regionY][regionZ] == false)
@@ -1008,7 +1009,7 @@ namespace Ogre
 			iterPatch->second.m_v3dOffset = offset;
 			iterPatch->second.computeNormalsFromVolume(volIter);
 			iterPatch->second.endDefinition();
-			iterPatch->second.decimate();
+			//iterPatch->second.decimate();
 		}
 
 		//LogManager::getSingleton().logMessage("Finished Generating Mesh Data");

source/SurfaceEdge.cpp

@@ -0,0 +1,32 @@
+#include "SurfaceEdge.h"
+#include "SurfaceTriangle.h"
+#include "SurfaceVertex.h"
+
+namespace Ogre
+{
+	SurfaceEdge::SurfaceEdge()
+	{
+	}
+
+	bool operator == (const SurfaceEdge& lhs, const SurfaceEdge& rhs)
+		{
+			return
+			(
+				(lhs.target == rhs.target) &&
+				(lhs.triangle == rhs.triangle)
+			);
+		}
+
+		bool operator < (const SurfaceEdge& lhs, const SurfaceEdge& rhs)
+		{
+			if(lhs.target == rhs.target)
+			{
+				if(lhs.triangle == rhs.triangle)
+				{
+					return false;
+				}
+				return (*(lhs.triangle) < *(rhs.triangle));
+			}
+			return (*(lhs.target) < *(rhs.target));
+		}
+}

source/SurfacePatch.cpp

@@ -3,6 +3,7 @@
 
 #include "SurfaceVertex.h"
 #include "SurfaceTriangle.h"
+#include "SurfaceEdge.h"
 
 #include "OgreLogManager.h"
 #include "OgreStringConverter.h"
@@ -13,8 +14,9 @@ namespace Ogre
 {
 	SurfacePatch::SurfacePatch()
 	{
-		m_setVertices.clear();
+		m_listVertices.clear();
-		m_setTriangles.clear();
+		m_listTriangles.clear();
+		m_listEdges.clear();
 
 		m_uTrianglesAdded = 0;
 		m_uVerticesAdded = 0;
@@ -42,27 +44,88 @@ namespace Ogre
 
 	void SurfacePatch::addTriangle(const SurfaceVertex& v0,const SurfaceVertex& v1,const SurfaceVertex& v2)
 	{
+		//if(m_uTrianglesAdded > 1) return;
+		//LogManager::getSingleton().logMessage("Adding Triangle " + StringConverter::toString(m_uTrianglesAdded));
 		m_uTrianglesAdded++;
+		m_uVerticesAdded += 3;	
 
-		m_uVerticesAdded += 3;		
+		
+		SurfaceVertexIterator v0Iter = find(m_listVertices.begin(), m_listVertices.end(), v0);
+		if(v0Iter == m_listVertices.end())
+		{		
+			//LogManager::getSingleton().logMessage("Adding Vertex " + StringConverter::toString(v0.position.x) + "," + StringConverter::toString(v0.position.y) + "," + StringConverter::toString(v0.position.z));
+			m_listVertices.push_back(v0);
+			v0Iter = m_listVertices.end();
+			v0Iter--;
+		}
+		//else
+			//LogManager::getSingleton().logMessage("Already Exists " + StringConverter::toString(v0.position.x) + "," + StringConverter::toString(v0.position.y) + "," + StringConverter::toString(v0.position.z));
+
+		SurfaceVertexIterator v1Iter = find(m_listVertices.begin(), m_listVertices.end(), v1);
+		if(v1Iter == m_listVertices.end())
+		{
+			//LogManager::getSingleton().logMessage("Adding Vertex " + StringConverter::toString(v1.position.x) + "," + StringConverter::toString(v1.position.y) + "," + StringConverter::toString(v1.position.z));
+			m_listVertices.push_back(v1);
+			v1Iter = m_listVertices.end();
+			v1Iter--;
+		}
+		//else
+			//LogManager::getSingleton().logMessage("Already Exists " + StringConverter::toString(v1.position.x) + "," + StringConverter::toString(v1.position.y) + "," + StringConverter::toString(v1.position.z));
+
+		SurfaceVertexIterator v2Iter = find(m_listVertices.begin(), m_listVertices.end(), v2);
+		if(v2Iter == m_listVertices.end())
+		{
+			//LogManager::getSingleton().logMessage("Adding Vertex " + StringConverter::toString(v2.position.x) + "," + StringConverter::toString(v2.position.y) + "," + StringConverter::toString(v2.position.z));
+			m_listVertices.push_back(v2);
+			v2Iter = m_listVertices.end();
+			v2Iter--;
+		}
+		//else
+			//LogManager::getSingleton().logMessage("Already Exists " + StringConverter::toString(v2.position.x) + "," + StringConverter::toString(v2.position.y) + "," + StringConverter::toString(v2.position.z));
+
+		//LogManager::getSingleton().logMessage("Creating Edges");
+		SurfaceEdge v0v1;
+		v0v1.target = v1Iter;
+		SurfaceEdge v1v2;
+		v1v2.target = v2Iter;
+		SurfaceEdge v2v0;
+		v2v0.target = v0Iter;
+
+		m_listEdges.push_back(v0v1);
+		SurfaceEdgeIterator v0v1Iter = m_listEdges.end();
+		v0v1Iter--;
+		m_listEdges.push_back(v1v2);
+		SurfaceEdgeIterator v1v2Iter = m_listEdges.end();
+		v1v2Iter--;
+		m_listEdges.push_back(v2v0);
+		SurfaceEdgeIterator v2v0Iter = m_listEdges.end();
+		v2v0Iter--;
+
+		v0Iter->edge = v0v1Iter;
+		v1Iter->edge = v1v2Iter;
+		v2Iter->edge = v2v0Iter;
+
+		v0v1Iter->nextHalfEdge = v1v2Iter;
+		v1v2Iter->nextHalfEdge = v2v0Iter;
+		v2v0Iter->nextHalfEdge = v0v1Iter;
 
 		SurfaceTriangle triangle;
 
-		triangle.v0 = m_setVertices.insert(v0).first;		
+		triangle.edge = v0v1Iter;	
-		triangle.v1 = m_setVertices.insert(v1).first;
-		triangle.v2 = m_setVertices.insert(v2).first;	
 
-		SurfaceTriangleIterator iterTriangle = m_setTriangles.insert(triangle).first;
+		m_listTriangles.push_back(triangle);
+		SurfaceTriangleIterator iterTriangle = m_listTriangles.end();
+		iterTriangle--;
 
-		triangle.v0->listTrianglesUsingThisVertex.push_back(iterTriangle);
+		v0v1Iter->triangle = iterTriangle;
-		triangle.v1->listTrianglesUsingThisVertex.push_back(iterTriangle);
+		v1v2Iter->triangle = iterTriangle;
-		triangle.v2->listTrianglesUsingThisVertex.push_back(iterTriangle);
+		v2v0Iter->triangle = iterTriangle;
 	}
 
 	void SurfacePatch::computeNormalsFromVolume(VolumeIterator volIter)
 	{
 		//LogManager::getSingleton().logMessage("In SurfacePatch::computeNormalsFromVolume");
-		for(SurfaceVertexIterator vertexIter = m_setVertices.begin(); vertexIter != m_setVertices.end(); ++vertexIter)
+		for(SurfaceVertexIterator vertexIter = m_listVertices.begin(); vertexIter != m_listVertices.end(); ++vertexIter)
 		{
 			//LogManager::getSingleton().logMessage("In Loop");
 			const float posX = (vertexIter->position.x + m_v3dOffset.x) / 2.0f;
@@ -152,6 +215,47 @@ namespace Ogre
 		vertexData.clear();
 		indexData.clear();
 
+		vertexData.resize(m_listVertices.size());
+		std::copy(m_listVertices.begin(), m_listVertices.end(), vertexData.begin());
+
+		/*LogManager::getSingleton().logMessage("----------Vertex Data----------");
+		for(std::vector<SurfaceVertex>::iterator vertexIter = vertexData.begin(); vertexIter != vertexData.end(); ++vertexIter)
+		{
+			LogManager::getSingleton().logMessage(StringConverter::toString(vertexIter->position.x) + "," + StringConverter::toString(vertexIter->position.y) + "," + StringConverter::toString(vertexIter->position.z));
+		}
+		LogManager::getSingleton().logMessage("----------End Vertex Data----------");*/
+
+		for(SurfaceTriangleIterator iterTriangles = m_listTriangles.begin(); iterTriangles != m_listTriangles.end(); ++iterTriangles)
+		{		
+			//LogManager::getSingleton().logMessage("Begin Triangle:");
+			std::vector<SurfaceVertex>::iterator iterVertex;
+			SurfaceEdgeIterator edgeIter;
+			
+			edgeIter = iterTriangles->edge;
+			//LogManager::getSingleton().logMessage("Edge Target " + StringConverter::toString(edgeIter->target->position.x) + "," + StringConverter::toString(edgeIter->target->position.y) + "," + StringConverter::toString(edgeIter->target->position.z));
+			iterVertex = find(vertexData.begin(), vertexData.end(), *(edgeIter->target));
+			LogManager::getSingleton().logMessage("    " + StringConverter::toString(iterVertex->position.x) + "," + StringConverter::toString(iterVertex->position.y) + "," + StringConverter::toString(iterVertex->position.z));
+			indexData.push_back(iterVertex - vertexData.begin());
+
+			edgeIter = edgeIter->nextHalfEdge;
+			iterVertex = find(vertexData.begin(), vertexData.end(), *(edgeIter->target));
+			//LogManager::getSingleton().logMessage("    " + StringConverter::toString(iterVertex->position.x) + "," + StringConverter::toString(iterVertex->position.y) + "," + StringConverter::toString(iterVertex->position.z));
+			indexData.push_back(iterVertex - vertexData.begin());
+
+			edgeIter = edgeIter->nextHalfEdge;
+			iterVertex = find(vertexData.begin(), vertexData.end(), *(edgeIter->target));
+			//LogManager::getSingleton().logMessage("    " + StringConverter::toString(iterVertex->position.x) + "," + StringConverter::toString(iterVertex->position.y) + "," + StringConverter::toString(iterVertex->position.z));
+			indexData.push_back(iterVertex - vertexData.begin());
+
+			//LogManager::getSingleton().logMessage("End Triangle");
+		}
+	}
+
+	/*void SurfacePatch::getVertexAndIndexData(std::vector<SurfaceVertex>& vertexData, std::vector<uint>& indexData)
+	{
+		vertexData.clear();
+		indexData.clear();
+
 		vertexData.resize(m_setVertices.size());
 		std::copy(m_setVertices.begin(), m_setVertices.end(), vertexData.begin());
 
@@ -168,7 +272,9 @@ namespace Ogre
 			iterVertex = lower_bound(vertexData.begin(), vertexData.end(),(*(iterTriangles->v2)));
 			indexData.push_back(iterVertex - vertexData.begin());			
 		}
-	}
+	}*/
+
+#ifdef BLAH
 
 	void SurfacePatch::decimate(void)
 	{
@@ -176,7 +282,7 @@ namespace Ogre
 		LogManager::getSingleton().logMessage("Triangles before decimation = " + StringConverter::toString(m_setTriangles.size())); 		
 
 		//Build the lists of connected vertices
-		for(SurfaceVertexIterator vertexIter = m_setVertices.begin(); vertexIter != m_setVertices.end(); ++vertexIter)
+		/*for(SurfaceVertexIterator vertexIter = m_setVertices.begin(); vertexIter != m_setVertices.end(); ++vertexIter)
 		{
 			vertexIter->listConnectedVertices.clear();
 
@@ -199,49 +305,80 @@ namespace Ogre
 
 			//Remove self from own connected vertex list
 			vertexIter->listConnectedVertices.remove(vertexIter);
-		}
+		}*/
 
 		//do the vertex merging
-		for(SurfaceVertexIterator vertexIter = m_setVertices.begin(); vertexIter != m_setVertices.end(); ++vertexIter)
+		//for(SurfaceVertexIterator vertexIter = m_setVertices.begin(); vertexIter != m_setVertices.end(); ++vertexIter)
+		for(uint ct = 0; ct < 500; ++ct)
 		{
-			//LogManager::getSingleton().logMessage("Vertex Pos = " + StringConverter::toString(vertexIter->position.x) + "," + StringConverter::toString(vertexIter->position.y) + "," + StringConverter::toString(vertexIter->position.z) + " No of connected vertices = " + StringConverter::toString(vertexIter->listConnectedVertices.size()));
+			SurfaceVertexIterator currentVertexIter;
-			/*if(vertexIter->alpha < 0.9)
+			for(currentVertexIter = m_setVertices.begin(); currentVertexIter != m_setVertices.end(); ++currentVertexIter)
-				continue;*/
-			if(vertexIter->listConnectedVertices.size() != 6)
 			{
-				//LogManager::getSingleton().logMessage("Skipping edge/corner vertex");
+
-				continue;
+				//LogManager::getSingleton().logMessage("Vertex Pos = " + StringConverter::toString(vertexIter->position.x) + "," + StringConverter::toString(vertexIter->position.y) + "," + StringConverter::toString(vertexIter->position.z) + " No of connected vertices = " + StringConverter::toString(vertexIter->listConnectedVertices.size()));
+
+				/*if(vertexIter->listConnectedVertices.size() == 6)
+					break;*/
+				if(currentVertexIter->flags == 0)
+					break;
+				if(currentVertexIter->flags == 0x01)
+					break;
+				if(currentVertexIter->flags == 0x02)
+					break;
+				if(currentVertexIter->flags == 0x04)
+					break;
+				if(currentVertexIter->flags == 0x08)
+					break;
+			}
+			if(currentVertexIter == m_setVertices.end())
+				break;
+
+			SurfaceVertex& currentVertex = *currentVertexIter;
+
+			//Find a vertex to merge with
+			/*std::list<SurfaceVertexIterator>::iterator firstConnectedVertexIter = currentVertex.listConnectedVertices.begin();
+			SurfaceVertex& vertexToMergeWith = (*(*firstConnectedVertexIter));
+			SurfaceVertexIterator vertexToMergeWithIter = m_setVertices.find(vertexToMergeWith);*/
+			
+			SurfaceVertexIterator vertexToMergeWithIter = (*(currentVertex.listTrianglesUsingThisVertex.begin()))->v0;
+			SurfaceVertex vertexToMergeWith = *vertexToMergeWithIter;
+			if(currentVertex == vertexToMergeWith)
+			{
+				vertexToMergeWithIter = (*(currentVertex.listTrianglesUsingThisVertex.begin()))->v1;
+				vertexToMergeWith = *vertexToMergeWithIter;
+			}
+			for(std::list<SurfaceTriangleIterator>::iterator triangleIterIter = currentVertex.listTrianglesUsingThisVertex.begin(); triangleIterIter != currentVertex.listTrianglesUsingThisVertex.end(); ++triangleIterIter)
+			{
+				SurfaceVertex connectedVertex = (*(*triangleIterIter)->v0);
+			}
+			
+
+			//Change triangles to use new vertex
+			for(SurfaceTriangleIterator iterTriangles = m_setTriangles.begin(); iterTriangles != m_setTriangles.end(); ++iterTriangles)
+			{
+				if(*(iterTriangles->v0) == currentVertex)
+					iterTriangles->v0 = vertexToMergeWithIter;
+				if(*(iterTriangles->v1) == currentVertex)
+					iterTriangles->v1 = vertexToMergeWithIter;
+				if(*(iterTriangles->v2) == currentVertex)
+					iterTriangles->v2 = vertexToMergeWithIter;
 			}
 
-			if(true/*verticesArePlanar(vertexIter)*/)
+			//Remove the vertex from other connected vertex lists
+			/*for(std::list<SurfaceVertexIterator>::iterator connectedVertexIter = currentVertex.listConnectedVertices.begin(); connectedVertexIter != currentVertex.listConnectedVertices.end(); ++connectedVertexIter)
 			{
-				//Find a vertex to merge with
+				for(std::list<SurfaceVertexIterator>::iterator secondLevelConnectedIter = (*connectedVertexIter)->listConnectedVertices.begin(); secondLevelConnectedIter != (*connectedVertexIter)->listConnectedVertices.end(); ++secondLevelConnectedIter)
-				std::list<SurfaceVertexIterator>::iterator vertexToMergeWith = vertexIter->listConnectedVertices.begin();
-
-				//Change triangles to use new vertex
-				for(SurfaceTriangleIterator iterTriangles = m_setTriangles.begin(); iterTriangles != m_setTriangles.end(); ++iterTriangles)
 				{
-					if(iterTriangles->v0 == vertexIter)
+					if((*(*secondLevelConnectedIter)) == currentVertex)
-						iterTriangles->v0 = *vertexToMergeWith;
-					if(iterTriangles->v1 == vertexIter)
-						iterTriangles->v1 = *vertexToMergeWith;
-					if(iterTriangles->v2 == vertexIter)
-						iterTriangles->v2 = *vertexToMergeWith;
-				}
-
-				//Change connected vertices to use new vertex
-				for(std::list<SurfaceVertexIterator>::iterator connectedVertex = vertexIter->listConnectedVertices.begin(); connectedVertex != vertexIter->listConnectedVertices.end(); ++connectedVertex)
-				{
-					for(std::list<SurfaceVertexIterator>::iterator secondLevelConnected = (*connectedVertex)->listConnectedVertices.begin(); secondLevelConnected != (*connectedVertex)->listConnectedVertices.end(); ++secondLevelConnected)
 					{
-						if((*secondLevelConnected) == vertexIter)
+						(*connectedVertexIter)->listConnectedVertices.remove(secondLevelConnected);
-							(*secondLevelConnected) = *vertexToMergeWith;
+						break;
 					}
 				}
+			}*/
 
-				//Now remove the vertex as nothing should point to it.
+			//Now remove the vertex as nothing should point to it.
-				//m_setVertices.erase(vertexIter);
+			m_setVertices.erase(currentVertexIter);
-			}
 		}
 	}
 
@@ -283,4 +420,6 @@ namespace Ogre
 
 		return allXMatch || allYMatch || allZMatch;
 	}*/
+#endif
+
 }

source/SurfaceTriangle.cpp

@@ -1,5 +1,6 @@
 #include "SurfaceTriangle.h"
 #include "SurfaceVertex.h"
+#include "SurfaceEdge.h"
 
 namespace Ogre
 {
@@ -7,26 +8,21 @@ namespace Ogre
 	{
 	}
 
-	SurfaceTriangle::SurfaceTriangle(SurfaceVertexIterator v0ToSet, SurfaceVertexIterator v1ToSet, SurfaceVertexIterator v2ToSet)
-		:v0(v0ToSet)
-		,v1(v1ToSet)
-		,v2(v2ToSet)
-	{
-	}
-
 	bool operator == (const SurfaceTriangle& lhs, const SurfaceTriangle& rhs)
 		{
-			return
+			/*return
 			(
 				(lhs.v0 == rhs.v0) &&
 				(lhs.v1 == rhs.v1) &&
 				(lhs.v2 == rhs.v2)
-			);
+			);*/
+
+			return lhs.edge == rhs.edge;
 		}
 
 		bool operator < (const SurfaceTriangle& lhs, const SurfaceTriangle& rhs)
 		{
-			if(lhs.v0 == rhs.v0)
+			/*if(lhs.v0 == rhs.v0)
 			{
 				if(lhs.v1 == rhs.v1)
 				{
@@ -38,7 +34,9 @@ namespace Ogre
 				}
 				return (*(lhs.v1) < *(rhs.v1));
 			}
-			return (*(lhs.v0) < *(rhs.v0));
+			return (*(lhs.v0) < *(rhs.v0));*/
+
+			return (*lhs.edge < *rhs.edge);
 		}
 
 		/*bool operator < (const SurfaceTriangleIterator& lhs, const SurfaceTriangleIterator& rhs)

source/SurfaceVertex.cpp

@@ -1,5 +1,7 @@
 #include "Constants.h"
 #include "SurfaceVertex.h"
+#include "SurfaceTriangle.h"
+#include "SurfaceEdge.h"
 
 namespace Ogre
 {
@@ -10,12 +12,30 @@ namespace Ogre
 	SurfaceVertex::SurfaceVertex(UIntVector3 positionToSet)
 		:position(positionToSet)
 	{
+		flags = 0;
+		if(position.x == 0)
+			flags |= 0x01;
+		if(position.x == 32)
+			flags |= 0x02;
+		if(position.y == 0)
+			flags |= 0x04;
+		if(position.y == 32)
+			flags |= 0x08;
 	}
 
 	SurfaceVertex::SurfaceVertex(UIntVector3 positionToSet, Vector3 normalToSet)
 		:position(positionToSet)
 		,normal(normalToSet)
 	{
+		flags = 0;
+		if(position.x == 0)
+			flags |= 0x01;
+		if(position.x == 32)
+			flags |= 0x02;
+		if(position.y == 0)
+			flags |= 0x04;
+		if(position.y == 32)
+			flags |= 0x08;
 	}
 
 	bool operator==(const SurfaceVertex& lhs, const SurfaceVertex& rhs)
@@ -48,7 +68,7 @@ namespace Ogre
 		unsigned long lhsOffset = (lhs.position.x*(OGRE_REGION_SIDE_LENGTH*2+1)*(OGRE_REGION_SIDE_LENGTH*2+1)) + (lhs.position.y*(OGRE_REGION_SIDE_LENGTH*2+1)) + (lhs.position.z);
 		unsigned long rhsOffset = (rhs.position.x*(OGRE_REGION_SIDE_LENGTH*2+1)*(OGRE_REGION_SIDE_LENGTH*2+1)) + (rhs.position.y*(OGRE_REGION_SIDE_LENGTH*2+1)) + (rhs.position.z);
 
-		return (lhsOffset == rhsOffset) && (abs(lhs.alpha - rhs.alpha) <= 0.01);
+		return (lhsOffset == rhsOffset) /*&& (abs(lhs.alpha - rhs.alpha) <= 0.01)*/;
 	}
 
 	bool operator < (const SurfaceVertex& lhs, const SurfaceVertex& rhs)
@@ -97,15 +117,10 @@ namespace Ogre
 
 		return lhsOffset < rhsOffset;
 
-		if(lhsOffset == rhsOffset)
+		/*if(lhsOffset == rhsOffset)
 		{
 			return (lhs.alpha < rhs.alpha);
 		}
-		return (lhsOffset < rhsOffset);
+		return (lhsOffset < rhsOffset)*/;
 	}
-
-	/*bool operator < (const SurfaceVertexIterator& lhs, const SurfaceVertexIterator& rhs)
-	{
-		return (*lhs) < (*rhs);
-	}*/
 }

source/VolumeSerializer.cpp

@@ -59,15 +59,15 @@ namespace Ogre
 						LogManager::getSingleton().logMessage("Value is " + StringConverter::toString(int(value)));
 					}*/
 					volIter.setVoxelAt(x,y,z,value);
-					if(z < 24)
+					/*if(z < 24)
 					{
-						//if(x % 32 < 16)
+						if(x % 32 < 16)
 							volIter.setVoxelAt(x,y,z,4);
-						/*else
+						else
-							volIter.setVoxelAt(x,y,z,5);*/
+							volIter.setVoxelAt(x,y,z,5);
 					}
 					else
-						volIter.setVoxelAt(x,y,z,0);
+						volIter.setVoxelAt(x,y,z,0);*/
 				}
 			}