#include "SurfacePatch.h"
#include "Constants.h"

#include "SurfaceVertex.h"
#include "SurfaceTriangle.h"
#include "SurfaceEdge.h"

#include "OgreLogManager.h"
#include "OgreStringConverter.h"

#include <algorithm>

namespace Ogre
{
	SurfacePatch::SurfacePatch()
	{
		m_listVertices.clear();
		m_listTriangles.clear();
		m_listEdges.clear();

		m_uTrianglesAdded = 0;
		m_uVerticesAdded = 0;

		vertexIndices = 0;

		//beginDefinition(); //FIXME - we shouldn't really be calling this from the constructor.
	}

	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 added = " + StringConverter::toString(m_uVerticesAdded)); 
		//LogManager::getSingleton().logMessage("No of vertices present = " + StringConverter::toString(m_setVertices.size())); 

		/*m_listVertices.clear();
		m_listTriangles.clear();
		m_listEdges.clear();*/

		//addTriangle(SurfaceVertex(UIntVector3(40 ,40 ,15)),SurfaceVertex(UIntVector3(42 ,42 ,15)),SurfaceVertex(UIntVector3(40 ,42 ,15)));
		//addTriangle(SurfaceVertex(UIntVector3(40 ,40 ,15)),SurfaceVertex(UIntVector3(42 ,42 ,15)),SurfaceVertex(UIntVector3(42 ,40 ,15)));

		computeOtherHalfEdges();

		/*for(SurfaceTriangleIterator triangleIter = m_listTriangles.begin(); triangleIter != m_listTriangles.end(); triangleIter++)
		{
			LogManager::getSingleton().logMessage(triangleIter->toString());
		}*/
	}

	void SurfacePatch::addTriangle(const SurfaceVertex& v0,const SurfaceVertex& v1,const SurfaceVertex& v2)
	{
		/*if(v0.position.x > 16)
			return;
		if(v0.position.y > 16)
			return;
		if(v1.position.x > 16)
			return;
		if(v1.position.y > 16)
			return;
		if(v2.position.x > 16)
			return;
		if(v2.position.y > 16)
			return;*/


		//if(m_uTrianglesAdded > 1) return;
		//LogManager::getSingleton().logMessage("Adding Triangle " + StringConverter::toString(m_uTrianglesAdded));
		m_uTrianglesAdded++;
		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;

		v0v1Iter->previousHalfEdge = v2v0Iter;
		v1v2Iter->previousHalfEdge = v0v1Iter;
		v2v0Iter->previousHalfEdge = v1v2Iter;

		SurfaceTriangle triangle;

		triangle.edge = v0v1Iter;	

		m_listTriangles.push_back(triangle);
		SurfaceTriangleIterator iterTriangle = m_listTriangles.end();
		iterTriangle--;

		v0v1Iter->triangle = iterTriangle;
		v1v2Iter->triangle = iterTriangle;
		v2v0Iter->triangle = iterTriangle;
	}

	void SurfacePatch::computeNormalsFromVolume(VolumeIterator volIter)
	{
		//LogManager::getSingleton().logMessage("In SurfacePatch::computeNormalsFromVolume");
		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;
			const float posY = (vertexIter->position.y + m_v3dOffset.y) / 2.0f;
			const float posZ = (vertexIter->position.z + m_v3dOffset.z) / 2.0f;

			const uint floorX = static_cast<uint>(posX);
			const uint floorY = static_cast<uint>(posY);
			const uint floorZ = static_cast<uint>(posZ);

			NormalGenerationMethod normalGenerationMethod = CENTRAL_DIFFERENCE;

			switch(normalGenerationMethod)
			{
			case SIMPLE:
				{
					volIter.setPosition(static_cast<uint>(posX),static_cast<uint>(posY),static_cast<uint>(posZ));
					const uchar uFloor = volIter.getVoxel() > 0 ? 1 : 0;
					if((posX - floorX) > 0.25) //The result should be 0.0 or 0.5
					{					
						uchar uCeil = volIter.peekVoxel1px0py0pz() > 0 ? 1 : 0;
						vertexIter->normal = Vector3(uFloor - uCeil,0.0,0.0);
					}
					else if((posY - floorY) > 0.25) //The result should be 0.0 or 0.5
					{
						uchar uCeil = volIter.peekVoxel0px1py0pz() > 0 ? 1 : 0;
						vertexIter->normal = Vector3(0.0,uFloor - uCeil,0.0);
					}
					else if((posZ - floorZ) > 0.25) //The result should be 0.0 or 0.5
					{
						uchar uCeil = volIter.peekVoxel0px0py1pz() > 0 ? 1 : 0;
						vertexIter->normal = Vector3(0.0, 0.0,uFloor - uCeil);					
					}
					vertexIter->normal.normalise();
					break;
				}
			case CENTRAL_DIFFERENCE:
				{
					volIter.setPosition(static_cast<uint>(posX),static_cast<uint>(posY),static_cast<uint>(posZ));
					const Vector3 gradFloor = volIter.getCentralDifferenceGradient();
					if((posX - floorX) > 0.25) //The result should be 0.0 or 0.5
					{			
						volIter.setPosition(static_cast<uint>(posX+1.0),static_cast<uint>(posY),static_cast<uint>(posZ));
					}
					if((posY - floorY) > 0.25) //The result should be 0.0 or 0.5
					{			
						volIter.setPosition(static_cast<uint>(posX),static_cast<uint>(posY+1.0),static_cast<uint>(posZ));
					}
					if((posZ - floorZ) > 0.25) //The result should be 0.0 or 0.5
					{			
						volIter.setPosition(static_cast<uint>(posX),static_cast<uint>(posY),static_cast<uint>(posZ+1.0));					
					}
					const Vector3 gradCeil = volIter.getCentralDifferenceGradient();
					vertexIter->normal = gradFloor + gradCeil;
					vertexIter->normal *= -1;
					vertexIter->normal.normalise();
					break;
				}
			case SOBEL:
				{
					volIter.setPosition(static_cast<uint>(posX),static_cast<uint>(posY),static_cast<uint>(posZ));
					const Vector3 gradFloor = volIter.getSobelGradient();
					if((posX - floorX) > 0.25) //The result should be 0.0 or 0.5
					{			
						volIter.setPosition(static_cast<uint>(posX+1.0),static_cast<uint>(posY),static_cast<uint>(posZ));
					}
					if((posY - floorY) > 0.25) //The result should be 0.0 or 0.5
					{			
						volIter.setPosition(static_cast<uint>(posX),static_cast<uint>(posY+1.0),static_cast<uint>(posZ));
					}
					if((posZ - floorZ) > 0.25) //The result should be 0.0 or 0.5
					{			
						volIter.setPosition(static_cast<uint>(posX),static_cast<uint>(posY),static_cast<uint>(posZ+1.0));					
					}
					const Vector3 gradCeil = volIter.getSobelGradient();
					vertexIter->normal = gradFloor + gradCeil;
					vertexIter->normal *= -1;
					vertexIter->normal.normalise();
					break;
				}
			}
		}
	}

	void SurfacePatch::getVertexAndIndexData(std::vector<SurfaceVertex>& vertexData, std::vector<uint>& indexData)
	{
		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::computeOtherHalfEdges(void)
	{
		//Clear all other edges
		for(SurfaceEdgeIterator edgeIter = m_listEdges.begin(); edgeIter != m_listEdges.end(); ++edgeIter)
		{
			edgeIter->otherHalfEdge = m_listEdges.end();
			edgeIter->hasOtherHalfEdge = false;
		}

		//FIXME - speed this up by storing edges in a container which sorts by edge 'target'.

		//Assign all other edges
		for(SurfaceEdgeIterator outerEdgeIter = m_listEdges.begin(); outerEdgeIter != m_listEdges.end(); ++outerEdgeIter)
		{
			for(SurfaceEdgeIterator innerEdgeIter = m_listEdges.begin(); innerEdgeIter != m_listEdges.end(); ++innerEdgeIter)
			{
				if((innerEdgeIter->target == outerEdgeIter->previousHalfEdge->target) && (outerEdgeIter->target == innerEdgeIter->previousHalfEdge->target))
				{
					innerEdgeIter->otherHalfEdge = outerEdgeIter;
					outerEdgeIter->otherHalfEdge = innerEdgeIter;

					innerEdgeIter->hasOtherHalfEdge = true;
					outerEdgeIter->hasOtherHalfEdge = true;
				}
			}
		}
	}

	/*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());

		for(SurfaceTriangleIterator iterTriangles = m_setTriangles.begin(); iterTriangles != m_setTriangles.end(); ++iterTriangles)
		{
			std::vector<SurfaceVertex>::iterator iterVertex;

			iterVertex = lower_bound(vertexData.begin(), vertexData.end(),(*(iterTriangles->v0)));
			indexData.push_back(iterVertex - vertexData.begin());

			iterVertex = lower_bound(vertexData.begin(), vertexData.end(),(*(iterTriangles->v1)));
			indexData.push_back(iterVertex - vertexData.begin());

			iterVertex = lower_bound(vertexData.begin(), vertexData.end(),(*(iterTriangles->v2)));
			indexData.push_back(iterVertex - vertexData.begin());			
		}
	}*/

	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)*/)
			{
				//LogManager::getSingleton().logMessage("    Collapsing Edge");
				for(SurfaceEdgeIterator innerEdgeIter = m_listEdges.begin(); innerEdgeIter != m_listEdges.end(); ++innerEdgeIter)
				{
					if(innerEdgeIter->target == targetVertexIter)
					{
						//LogManager::getSingleton().logMessage("    Reset Edge Target");
						innerEdgeIter->target = otherVertexIter;
					}
				}
				
				if(edgeIter->hasOtherHalfEdge)
				{
					//LogManager::getSingleton().logMessage("    Has Other Edge");
					SurfaceEdgeIterator otherEdgeIter = edgeIter->otherHalfEdge;

					//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;
						}
						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;
					}
					m_listEdges.erase(previousIter);
				}
				//LogManager::getSingleton().logMessage("    Removing Triangle");
				m_listTriangles.erase(triangleIter);

				//LogManager::getSingleton().logMessage("    Removing Vertex");
				m_listVertices.erase(targetVertexIter);

				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;
	}

#ifdef BLAH

	void SurfacePatch::decimate(void)
	{
		LogManager::getSingleton().logMessage("Vertices before decimation = " + StringConverter::toString(m_setVertices.size()));
		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)
		{
			vertexIter->listConnectedVertices.clear();

			for(std::list<SurfaceTriangleIterator>::iterator triangleIter = vertexIter->listTrianglesUsingThisVertex.begin(); triangleIter != vertexIter->listTrianglesUsingThisVertex.end(); ++triangleIter) 
			{
				SurfaceVertexIterator connectedVertex;

				connectedVertex = (*triangleIter)->v0;
				if(find(vertexIter->listConnectedVertices.begin(),vertexIter->listConnectedVertices.end(),connectedVertex) == vertexIter->listConnectedVertices.end())
					vertexIter->listConnectedVertices.push_back(connectedVertex);

				connectedVertex = (*triangleIter)->v1;
				if(find(vertexIter->listConnectedVertices.begin(),vertexIter->listConnectedVertices.end(),connectedVertex) == vertexIter->listConnectedVertices.end())
					vertexIter->listConnectedVertices.push_back(connectedVertex);

				connectedVertex = (*triangleIter)->v2;
				if(find(vertexIter->listConnectedVertices.begin(),vertexIter->listConnectedVertices.end(),connectedVertex) == vertexIter->listConnectedVertices.end())
					vertexIter->listConnectedVertices.push_back(connectedVertex);
			}

			//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(uint ct = 0; ct < 500; ++ct)
		{
			SurfaceVertexIterator currentVertexIter;
			for(currentVertexIter = m_setVertices.begin(); currentVertexIter != m_setVertices.end(); ++currentVertexIter)
			{

				//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;
			}

			//Remove the vertex from other connected vertex lists
			/*for(std::list<SurfaceVertexIterator>::iterator connectedVertexIter = currentVertex.listConnectedVertices.begin(); connectedVertexIter != currentVertex.listConnectedVertices.end(); ++connectedVertexIter)
			{
				for(std::list<SurfaceVertexIterator>::iterator secondLevelConnectedIter = (*connectedVertexIter)->listConnectedVertices.begin(); secondLevelConnectedIter != (*connectedVertexIter)->listConnectedVertices.end(); ++secondLevelConnectedIter)
				{
					if((*(*secondLevelConnectedIter)) == currentVertex)
					{
						(*connectedVertexIter)->listConnectedVertices.remove(secondLevelConnected);
						break;
					}
				}
			}*/

			//Now remove the vertex as nothing should point to it.
			m_setVertices.erase(currentVertexIter);
		}
	}

	/*bool SurfacePatch::verticesArePlanar(SurfaceVertexIterator iterCurrentVertex)
	{
		//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;

		std::list<SurfaceVertexIterator> listConnectedVertices = iterCurrentVertex->listConnectedVertices;
		std::list<SurfaceVertexIterator>::iterator iterConnectedVertices;
		for(iterConnectedVertices = listConnectedVertices.begin(); iterConnectedVertices != listConnectedVertices.end(); ++iterConnectedVertices)
		{
			if(iterCurrentVertex->position.x != (*iterConnectedVertices)->position.x)
			{
				allXMatch = false;
			}
			if(iterCurrentVertex->position.y != (*iterConnectedVertices)->position.y)
			{
				allYMatch = false;
			}
			if(iterCurrentVertex->position.z != (*iterConnectedVertices)->position.z)
			{
				allZMatch = false;
			}
			//FIXME - are these already normalised? We should make sure they are...
			if(iterCurrentVertex->normal.normalisedCopy().dotProduct((*iterConnectedVertices)->normal.normalisedCopy()) < 0.99)
			{
				return false;				
			}
		}

		return allXMatch || allYMatch || allZMatch;
	}*/
#endif

}