Refactoring work... working on meshes

include/SurfacePatch.h

@@ -15,6 +15,7 @@ namespace Ogre
 	   SurfacePatch();
 	   ~SurfacePatch();
 
+	   void beginDefinition(void);
 	   void endDefinition(void);
 
 	   void addTriangle(const SurfaceVertex& v0,const SurfaceVertex& v1,const SurfaceVertex& v2);	   
@@ -22,13 +23,14 @@ namespace Ogre
 	   void getVertexAndIndexData(std::vector<SurfaceVertex>& vertexData, std::vector<uint>& indexData);
 
 	private:
-		std::list<SurfaceVertex> m_listVertices;
+		std::set<SurfaceVertex> m_setVertices;
 		std::list<SurfaceTriangle> m_listTriangles;
 
 		std::vector<SurfaceVertex> m_vecVertexData;
 		std::vector<uint> m_vecIndexData;
 
 		uint m_uTrianglesAdded;
+		uint m_uVerticesAdded;
 	};	
 }
 

include/SurfaceTriangle.h

@@ -36,13 +36,13 @@ namespace Ogre
 		/*ulong v0;
 		ulong v1;
 		ulong v2;*/
-		std::list<SurfaceVertex>::iterator v0;
+		std::set<SurfaceVertex>::iterator v0;
-		std::list<SurfaceVertex>::iterator v1;
+		std::set<SurfaceVertex>::iterator v1;
-		std::list<SurfaceVertex>::iterator v2;
+		std::set<SurfaceVertex>::iterator v2;
 
 		SurfaceTriangle();
 
-		SurfaceTriangle(std::list<SurfaceVertex>::iterator v0ToSet, std::list<SurfaceVertex>::iterator v1ToSet, std::list<SurfaceVertex>::iterator v2ToSet);
+		SurfaceTriangle(std::set<SurfaceVertex>::iterator v0ToSet, std::set<SurfaceVertex>::iterator v1ToSet, std::set<SurfaceVertex>::iterator v2ToSet);
 
 		//bool operator < (const SurfaceTriangle& rhs) const;
 	};

include/SurfaceVertex.h

@@ -45,7 +45,7 @@ namespace Ogre
 
 		bool operator==(const SurfaceVertex& rhs) const;
 
-		//bool operator < (const SurfaceVertex& rhs) const;
+		bool operator < (const SurfaceVertex& rhs) const;
 	};
 }
 

source/SurfacePatch.cpp

@@ -9,21 +9,27 @@ namespace Ogre
 {
 	SurfacePatch::SurfacePatch()
 	{
-		m_listVertices.clear();
+		m_setVertices.clear();
 		m_listTriangles.clear();
 
 		m_uTrianglesAdded = 0;
+		m_uVerticesAdded = 0;
 	}
 
 	SurfacePatch::~SurfacePatch()
 	{
 	}
 
+	void SurfacePatch::beginDefinition(void)
+	{
+	}
+
 	void SurfacePatch::endDefinition(void)
 	{
 		//LogManager::getSingleton().logMessage("No of triangles added = " + StringConverter::toString(m_uTrianglesAdded)); 
 		//LogManager::getSingleton().logMessage("No of triangles present = " + StringConverter::toString(m_listTriangles.size())); 
-		//LogManager::getSingleton().logMessage("No of vertices present = " + StringConverter::toString(m_listVertices.size())); 
+		//LogManager::getSingleton().logMessage("No of vertices added = " + StringConverter::toString(m_uVerticesAdded)); 
+		//LogManager::getSingleton().logMessage("No of vertices present = " + StringConverter::toString(m_setVertices.size())); 
 	}
 
 	void SurfacePatch::addTriangle(const SurfaceVertex& v0,const SurfaceVertex& v1,const SurfaceVertex& v2)
@@ -31,8 +37,19 @@ namespace Ogre
 		m_uTrianglesAdded++;
 
 		SurfaceTriangle triangle;
+
+		m_setVertices.insert(v0);
+		m_uVerticesAdded++;
+		m_setVertices.insert(v1);
+		m_uVerticesAdded++;
+		m_setVertices.insert(v2);
+		m_uVerticesAdded++;
+
+		triangle.v0 = std::find(m_setVertices.begin(), m_setVertices.end(), v0);
+		triangle.v1 = std::find(m_setVertices.begin(), m_setVertices.end(), v1);
+		triangle.v2 = std::find(m_setVertices.begin(), m_setVertices.end(), v2);
 		
-		triangle.v0 = std::find(m_listVertices.begin(), m_listVertices.end(), v0);
+		/*triangle.v0 = std::find(m_listVertices.begin(), m_listVertices.end(), v0);
 		if(triangle.v0 == m_listVertices.end()) //We have to add it
 		{
 			m_listVertices.push_back(v0);
@@ -56,38 +73,25 @@ namespace Ogre
 			m_listVertices.push_back(v2);
 			triangle.v2 = m_listVertices.end();
 			triangle.v2--;
-		}	
+		}*/	
 
 		m_listTriangles.push_back(triangle);
 
-		triangle.v0->listTrianglesUsingThisVertex.push_back(m_listTriangles.end());
+		/*triangle.v0->listTrianglesUsingThisVertex.push_back(m_listTriangles.end());
 		triangle.v1->listTrianglesUsingThisVertex.push_back(m_listTriangles.end());
-		triangle.v2->listTrianglesUsingThisVertex.push_back(m_listTriangles.end());
+		triangle.v2->listTrianglesUsingThisVertex.push_back(m_listTriangles.end());*/
 	}
 
-	/*const std::vector<SurfaceVertex> SurfacePatch::getVertexArray()
-	{
-		std::vector<SurfaceVertex> vertexArray;
-		vertexArray.resize(m_listVertices.size());
-		std::copy(m_listVertices.begin(), m_listVertices.end(), vertexArray.begin());
-		return vertexArray;
-	}
-
-	const std::vector<SurfaceTriangle> SurfacePatch::getTriangleArray()
-	{
-		std::vector<SurfaceTriangle> triangleArray;
-		triangleArray.resize(m_listTriangles.size());
-		std::copy(m_listTriangles.begin(), m_listTriangles.end(), triangleArray.begin());
-		return triangleArray;
-	}*/
-
 	void SurfacePatch::getVertexAndIndexData(std::vector<SurfaceVertex>& vertexData, std::vector<uint>& indexData)
 	{
 		vertexData.clear();
 		indexData.clear();
 
-		vertexData.resize(m_listVertices.size());
+		vertexData.resize(m_setVertices.size());
-		std::copy(m_listVertices.begin(), m_listVertices.end(), vertexData.begin());
+		std::copy(m_setVertices.begin(), m_setVertices.end(), vertexData.begin());
+
+		sort(vertexData.begin(),vertexData.end());
+		//reverse(vertexData.begin(),vertexData.end());
 
 		for(std::list<SurfaceTriangle>::iterator iterTriangles = m_listTriangles.begin(); iterTriangles != m_listTriangles.end(); ++iterTriangles)
 		{
@@ -96,21 +100,51 @@ namespace Ogre
 			vertexData.push_back(*(iterTriangles->v1));
 			indexData.push_back(vertexData.size()-1);
 			vertexData.push_back(*(iterTriangles->v2));
-			indexData.push_back(vertexData.size()-1);*/
+			indexData.push_back(vertexData.size()-1);*/		
 
-			for(uint ct = 0; ct < vertexData.size(); ++ct)
+			/*std::set<SurfaceVertex>::iterator iterVertex = m_setVertices.find((*(iterTriangles->v0)));
+			indexData.push_back(iterVertex - m_setVertices.begin());
+			iterVertex = m_setVertices.find((*(iterTriangles->v1)));
+			indexData.push_back(iterVertex - m_setVertices.begin());
+			iterVertex = m_setVertices.find((*(iterTriangles->v2)));
+			indexData.push_back(iterVertex - m_setVertices.begin());*/
+
+			/*for(uint ct = 0; ct < vertexData.size(); ++ct)
 			{
 				if(vertexData[ct] == (*(iterTriangles->v0)))
 				{
 					indexData.push_back(ct);
-				}
+					break;
-			}
+				}				
+			}*/
 
-			for(uint ct = 0; ct < vertexData.size(); ++ct)
+			std::vector<SurfaceVertex>::iterator iterVertex = find(vertexData.begin(), vertexData.end(),(*(iterTriangles->v0)));
+			if(iterVertex == vertexData.end())
+			{
+				LogManager::getSingleton().logMessage("Vertex 0 Not Found");
+			}
+			indexData.push_back(iterVertex - vertexData.begin());
+
+			iterVertex = find(vertexData.begin(), vertexData.end(),(*(iterTriangles->v1)));
+			if(iterVertex == vertexData.end())
+			{
+				LogManager::getSingleton().logMessage("Vertex 1 Not Found");
+			}
+			indexData.push_back(iterVertex - vertexData.begin());
+
+			iterVertex = find(vertexData.begin(), vertexData.end(),(*(iterTriangles->v2)));
+			if(iterVertex == vertexData.end())
+			{
+				LogManager::getSingleton().logMessage("Vertex 2 Not Found");
+			}
+			indexData.push_back(iterVertex - vertexData.begin());
+
+			/*for(uint ct = 0; ct < vertexData.size(); ++ct)
 			{
 				if(vertexData[ct] == (*(iterTriangles->v1)))
 				{
 					indexData.push_back(ct);
+					break;
 				}
 			}
 
@@ -119,8 +153,9 @@ namespace Ogre
 				if(vertexData[ct] == (*(iterTriangles->v2)))
 				{
 					indexData.push_back(ct);
+					break;
 				}
-			}
+			}*/
 		}
 
 		/*vertexData = m_vecVertexData;

source/SurfaceTriangle.cpp

@@ -6,7 +6,7 @@ namespace Ogre
 	{
 	}
 
-	SurfaceTriangle::SurfaceTriangle(std::list<SurfaceVertex>::iterator v0ToSet, std::list<SurfaceVertex>::iterator v1ToSet, std::list<SurfaceVertex>::iterator v2ToSet)
+	SurfaceTriangle::SurfaceTriangle(std::set<SurfaceVertex>::iterator v0ToSet, std::set<SurfaceVertex>::iterator v1ToSet, std::set<SurfaceVertex>::iterator v2ToSet)
 		:v0(v0ToSet)
 		,v1(v1ToSet)
 		,v2(v2ToSet)

source/SurfaceVertex.cpp

@@ -20,32 +20,46 @@ namespace Ogre
 	bool SurfaceVertex::operator==(const SurfaceVertex& rhs) const
 	{
 		//We dont't check the normal here as it may not have been set. But if two vertices have the same position they should have the same normal too.
-		return ((position.positionEquals(rhs.position)) && (abs(alpha - rhs.alpha) < 0.01));
+		return
+		(
+			(abs(position.x - rhs.position.x) <= 0.01) && 
+			(abs(position.y - rhs.position.y) <= 0.01) &&
+			(abs(position.z - rhs.position.z) <= 0.01) &&
+			(abs(alpha - rhs.alpha) <= 0.01)
+		);
+
+		/*return
+		(
+			(position.x == rhs.position.x) && 
+			(position.x == rhs.position.y) && 
+			(position.x == rhs.position.z) && 
+			(alpha == rhs.alpha)
+		);*/
 	}
 
-	/*bool SurfaceVertex::operator < (const SurfaceVertex& rhs) const
+	bool SurfaceVertex::operator < (const SurfaceVertex& rhs) const
 	{
-	if(position.z < rhs.position.z)
+		if((*this) == rhs)
-	{
+		{
-	return true;
+			return false;
+		}
+		if(alpha < rhs.alpha)
+		{
+			return true;
+		}
+		if(position.z < rhs.position.z)
+		{
+			return true;
+		}
+		if(position.y < rhs.position.y)
+		{
+			return true;
+		}
+		if(position.x < rhs.position.x)
+		{
+			return true;
+		}
+		
+		return false;
 	}
-	else
-	{
-	if(position.y < rhs.position.y)
-	{
-	return true;
-	}
-	else
-	{
-	if(position.x < rhs.position.x)
-	{
-	return true;
-	}
-	else
-	{
-	return false;
-	}
-	}
-	}
-	}*/
 }