Cleaning up decimation.

include/SurfaceEdge.h

@@ -39,13 +39,6 @@ namespace Ogre
 		friend bool operator == (const SurfaceEdge& lhs, const SurfaceEdge& rhs);
 		friend bool operator < (const SurfaceEdge& lhs, const SurfaceEdge& rhs);
 
-		//int crud;		
-
-		SurfaceTriangleIterator triangle;
-
-		
-
-		//FIXME - could use boost::optional for this?
 
 		std::string toString(void);
 
@@ -56,9 +49,11 @@ namespace Ogre
 		const SurfaceEdgeIterator& getOtherHalfEdge(void);
 		const SurfaceEdgeIterator& getPreviousHalfEdge(void);
 		const SurfaceEdgeIterator& getNextHalfEdge(void);
+		const SurfaceTriangleIterator& getTriangle(void);
 
 		void setPreviousHalfEdge(const SurfaceEdgeIterator& previousHalfEdgeToSet);
 		void setNextHalfEdge(const SurfaceEdgeIterator& nextHalfEdgeToSet);
+		void setTriangle(const SurfaceTriangleIterator& triangleToSet);
 
 		void pairWithOtherHalfEdge(const SurfaceEdgeIterator& otherHalfEdgeToPair);
 
@@ -69,6 +64,8 @@ namespace Ogre
 		SurfaceEdgeIterator previousHalfEdge;
 		SurfaceEdgeIterator nextHalfEdge;
 		SurfaceEdgeIterator otherHalfEdge;
+
+		SurfaceTriangleIterator triangle;
 	};	
 }
 

source/SurfaceEdge.cpp

@@ -19,10 +19,12 @@ namespace Ogre
 
 	bool operator == (const SurfaceEdge& lhs, const SurfaceEdge& rhs)
 	{
+		//Vertices are unique in the set, so if the two positions are the same the 
+		//two iterators must also be the same. So we just check the iterators.
 		return
 		(
-			((*lhs.target) == (*rhs.target)) &&
-			((*lhs.source) == (*rhs.source))
+			(lhs.target == rhs.target) &&
+			(lhs.source == rhs.source)
 		);
 	}
 
@@ -33,6 +35,8 @@ namespace Ogre
 
 	bool operator < (const SurfaceEdge& lhs, const SurfaceEdge& rhs)
 	{
+		//Unlike the equality operator, we can't compare iterators.
+		//So dereference and compare the results.
 		if ((*lhs.target) < (*rhs.target))
 			return true;
 		if ((*rhs.target) < (*lhs.target))
@@ -78,6 +82,11 @@ namespace Ogre
 		return nextHalfEdge;
 	}
 
+	const SurfaceTriangleIterator& SurfaceEdge::getTriangle(void)
+	{
+		return triangle;
+	}
+
 	void SurfaceEdge::setPreviousHalfEdge(const SurfaceEdgeIterator& previousHalfEdgeToSet)
 	{
 		previousHalfEdge = previousHalfEdgeToSet;
@@ -87,4 +96,9 @@ namespace Ogre
 	{
 		nextHalfEdge = nextHalfEdgeToSet;
 	}
+
+	void SurfaceEdge::setTriangle(const SurfaceTriangleIterator& triangleToSet)
+	{
+		triangle = triangleToSet;
+	}
 }

source/SurfacePatch.cpp

@@ -95,9 +95,9 @@ namespace Ogre
 
 		SurfaceTriangleIterator iterTriangle = m_listTriangles.insert(triangle).first;
 
-		v0v1Iter->triangle = iterTriangle;
-		v1v2Iter->triangle = iterTriangle;
-		v2v0Iter->triangle = iterTriangle;
+		v0v1Iter->setTriangle(iterTriangle);
+		v1v2Iter->setTriangle(iterTriangle);
+		v2v0Iter->setTriangle(iterTriangle);
 	}
 
 	SurfaceVertexIterator SurfacePatch::findOrAddVertex(const SurfaceVertex& vertex)
@@ -447,7 +447,7 @@ namespace Ogre
 
 				if(edgeToDelete->getNextHalfEdge() != edgeToDelete->getOtherHalfEdge())
 				{
-					m_listTriangles.erase(edgeToDelete->triangle);
+					m_listTriangles.erase(edgeToDelete->getTriangle());
 				}
 
 				//LogManager::getSingleton().logMessage("Removing edge " + edgeToDelete->toString());				

source/SurfaceTriangle.cpp

@@ -45,11 +45,15 @@ namespace Ogre
 
 	bool operator == (const SurfaceTriangle& lhs, const SurfaceTriangle& rhs)
 	{
-		return (*lhs.edge == *rhs.edge);
+		//Edges are unique in the set, so if the two positions are the same the 
+		//two iterators must also be the same. So we just check the iterators.
+		return (lhs.edge == rhs.edge);
 	}
 
 	bool operator < (const SurfaceTriangle& lhs, const SurfaceTriangle& rhs)
 	{
+		//Unlike the equality operator, we can't compare iterators.
+		//So dereference and compare the results.
 		return (*lhs.edge < *rhs.edge);
 	}
 }