Removed Polygon from Polycode, meshes now contain vertices directly

Core/Contents/CMakeLists.txt

@@ -39,7 +39,6 @@ SET(polycore_SRCS
     Source/PolyObject.cpp
     Source/PolyParticleEmitter.cpp
     Source/PolyPerlin.cpp
-    Source/PolyPolygon.cpp
     Source/PolyQuaternion.cpp
     Source/PolyQuaternionCurve.cpp
     Source/PolyRectangle.cpp
@@ -125,7 +124,6 @@ SET(polycore_HDRS
     Include/PolyObject.h
     Include/PolyParticleEmitter.h
     Include/PolyPerlin.h
-    Include/PolyPolygon.h
     Include/PolyQuaternionCurve.h
     Include/PolyQuaternion.h
     Include/PolyRectangle.h

Core/Contents/Include/PolyMesh.h

@@ -23,7 +23,6 @@ THE SOFTWARE.
 #pragma once
 #include "PolyGlobals.h"
 #include "PolyVertex.h"
-#include "PolyPolygon.h"
 
 class OSFILE;
 
@@ -111,7 +110,7 @@ namespace Polycode {
 	} Vector2_struct;
 	
 	/**
-	* A polygonal mesh. The mesh is assembled from Polygon instances, which in turn contain Vertex instances. This structure is provided for convenience and when the mesh is rendered, it is cached into vertex arrays with no notions of separate polygons. When data in the mesh changes, arrayDirtyMap must be set to true for the appropriate array types (color, position, normal, etc). Available types are defined in RenderDataArray.
+	*  A mesh comprised of vertices. When data in the mesh changes, arrayDirtyMap must be set to true for the appropriate array types (color, position, normal, etc). Available types are defined in RenderDataArray.
 	*/
 	class _PolyExport Mesh : public PolyBase {
 		public:
@@ -137,12 +136,6 @@ namespace Polycode {
 
 			virtual ~Mesh();
 			
-			/**
-			* Adds a polygon to the mesh.
-			* @param newPolygon Polygon to add.
-			*/
-			void addPolygon(Polygon *newPolygon);
-
 			/**
 			* Loads a mesh from a file.
 			* @param fileName Path to mesh file.
@@ -164,11 +157,6 @@ namespace Polycode {
 			void loadFromFile(OSFILE *inFile);
 			void saveToFile(OSFILE *outFile);
 			
-			/**
-			* Returns the number of polygons in the mesh.
-			* @return Number of polygons in the mesh.
-			*/						
-			unsigned int getPolygonCount();
 			
 			/**
 			* Returns the total vertex count in the mesh.
@@ -176,12 +164,6 @@ namespace Polycode {
 			*/
 			unsigned int getVertexCount();
 			
-			/**
-			* Returns a polygon at specified index.
-			* @param index Index of polygon.
-			* @return Polygon at index.
-			*/									
-			Polygon *getPolygon(unsigned int index);
 					
 			/**
 			* Creates a plane mesh of specified size.
@@ -261,12 +243,14 @@ namespace Polycode {
 			*/
 			Vector3 recenterMesh();
 		
-			/**
-			* Toggles the mesh between using vertex or polygon normals. 
-			* @param val If true, the mesh will use vertex normals, otherwise it will use the polygon normals.
-			*/
-			void useVertexNormals(bool val);
+            Vertex *addVertex(Number x, Number y, Number z);
 			
+            void addVertex(Vertex *vertex);
+        
+            Vertex *addVertex(Number x, Number y, Number z, Number u, Number v);
+        
+            Vertex *getVertex(unsigned int index) const;
+        
 			/**
 			* Sets the vertex buffer for the mesh.
 			* @param buffer New vertex buffer for mesh.
@@ -297,8 +281,6 @@ namespace Polycode {
 			*/ 
 			void calculateTangents();
 			
-			std::vector<Polygon*> getConnectedFaces(Vertex *v);
-			
 			/**
 			* Returns the mesh type.
 			*/ 
@@ -380,9 +362,9 @@ namespace Polycode {
 		
 		protected:
 					
-		VertexBuffer *vertexBuffer;
-		bool meshHasVertexBuffer;
-		int meshType;
-		std::vector <Polygon*> polygons;
+            VertexBuffer *vertexBuffer;
+            bool meshHasVertexBuffer;
+            int meshType;
+            std::vector <Vertex*> vertices;
 	};
 }

Core/Contents/Include/PolyPolygon.h

@@ -1,139 +0,0 @@
-/*
-Copyright (C) 2011 by Ivan Safrin
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-*/
-
-#pragma once
-#include "PolyGlobals.h"
-#include "PolyVector3.h"
-#include "PolyRectangle.h"
-#include <vector>
-
-namespace Polycode {
-
-	class Vertex;
-
-	/**
-	* A polygon structure.
-	*/ 
-	class _PolyExport Polygon : public PolyBase {
-	
-		public:
-			/**
-			* Default constructor.
-			*/
-			Polygon();
-			virtual ~Polygon();
-			
-			/**
-			* Returns the number of vertices in the polygon.
-			* @return Number of vertices in the polygon.
-			*/ 
-			unsigned int getVertexCount();
-			
-			/**
-			* Returns the vertex at specified index.
-			* @return Vertex at specified index.
-			*/ 			
-			Vertex *getVertex(unsigned int index);			
-	
-			/**
-			* Adds a new vertex with the specified position coordinates and texture coordinates.
-			* @param x X coordinate of new vertex.
-			* @param y Y coordinate of new vertex.
-			* @param z Z coordinate of new vertex.
-			* @param u Horizontal texture coordinate.
-			* @param v Vertical texture coordinate.
-			* @return Newly added vertex.
-			*/ 			
-			Vertex *addVertex(Number x, Number y, Number z, Number u, Number v);
-						
-			/**
-			* Adds a new vertex with the specified position coordinates.
-			* @param x X coordinate of new vertex.
-			* @param y Y coordinate of new vertex.
-			* @param z Z coordinate of new vertex.						
-			* @return Newly added vertex.
-			*/ 
-			Vertex *addVertex(Number x, Number y, Number z);
-		
-			
-			/**
-			* Adds a new vertex.
-			* @param vertex New vertex.
-			*/ 			
-			void addVertex(Vertex *vertex);
-
-			/**
-			* Removes and deletes the vertex at specified index. 
-			* @param index to remove vertex at.
-			*/
-			void removeVertex(int index);
-			
-			/**
-			* Calculates the average normal for the vertices.
-			*/
-			void calculateNormal();
-
-			/**
-			* Calculates the tangent space vector for the vertices.
-			*/
-			void calculateTangent();
-			
-			/**
-			* Returns the face normal.
-			* @return Face normal.
-			*/ 
-			Vector3 getFaceNormal();
-
-			/**
-			* Returns the face tangent vector.
-			* @return Face tangent vector.
-			*/ 
-			Vector3 getFaceTangent();
-
-			
-			Rectangle getBounds2D();
-			
-			/**
-			* Sets the polygon normal.
-			* @param normal The new normal.
-			*/
-			void setNormal(Vector3 normal);
-								
-			/**
-			* If true, will use vertex normals, if false will use the polygon normal.
-			*/
-			bool useVertexNormals;
-		
-			/**
-			* Flips the texture coordinate vertically.
-			*/
-			void flipUVY();
-						
-		protected:
-		
-			unsigned int vertexCount;
-			std::vector<Vertex*> vertices;
-			Vector3			normal;
-			Vector3			tangent;			
-	};
-
-}

Core/Contents/Include/PolyRay.h

@@ -24,7 +24,7 @@
 #include "PolyGlobals.h"
 #include "PolyVector3.h"
 #include "PolyMatrix4.h"
-#include "PolyPolygon.h"
+#include "PolyVertex.h"
 
 namespace Polycode {
 
@@ -41,7 +41,7 @@ namespace Polycode {
 			Vector3 planeIntersectPoint(const Vector3 &planeNormal, Number planeDistance) const;
 			Ray tranformByMatrix(const Matrix4& matrix) const;
 			
-			bool polygonIntersect(Polycode::Polygon *polygon) const;
+			bool polygonIntersect(Vertex *v1, Vertex *v2, Vertex *v3) const;
 		
 			Vector3 origin;
 			Vector3 direction;

Core/Contents/Include/Polycode.h

@@ -30,7 +30,6 @@
 #include "PolyConfig.h"
 #include "PolyPerlin.h"
 #include "PolyEntity.h"
-#include "PolyPolygon.h"
 #include "PolyEvent.h"
 #include "PolyEventDispatcher.h"
 #include "PolyEventHandler.h"

Core/Contents/Source/PolyGLRenderer.cpp

@@ -33,7 +33,6 @@
 #include "PolyMaterial.h"
 #include "PolyMesh.h"
 #include "PolyModule.h"
-#include "PolyPolygon.h"
 
 #if defined(_WINDOWS) && !defined(_MINGW)
 
@@ -878,32 +877,28 @@ RenderDataArray *OpenGLRenderer::createRenderDataArrayForMesh(Mesh *mesh, int ar
 		case RenderDataArray::VERTEX_DATA_ARRAY:
 		{		
 			buffer = (GLfloat*)malloc(1);							
-			for(int i=0; i < mesh->getPolygonCount(); i++) {
-				for(int j=0; j < mesh->getPolygon(i)->getVertexCount(); j++) {
-					newArray->count++;			
-					newBufferSize = bufferSize + 3;
-					buffer = (GLfloat*)realloc(buffer, newBufferSize * sizeof(GLfloat));
-					buffer[bufferSize+0] = mesh->getPolygon(i)->getVertex(j)->x;
-					buffer[bufferSize+1] = mesh->getPolygon(i)->getVertex(j)->y;
-					buffer[bufferSize+2] = mesh->getPolygon(i)->getVertex(j)->z;			
-					bufferSize = newBufferSize;	
-				}		   
+			for(int i=0; i < mesh->getVertexCount(); i++) {
+                newArray->count++;
+                newBufferSize = bufferSize + 3;
+                buffer = (GLfloat*)realloc(buffer, newBufferSize * sizeof(GLfloat));
+                buffer[bufferSize+0] = mesh->getVertex(i)->x;
+                buffer[bufferSize+1] = mesh->getVertex(i)->y;
+                buffer[bufferSize+2] = mesh->getVertex(i)->z;
+                bufferSize = newBufferSize;
 			}
 		}
 		break;
 		case RenderDataArray::COLOR_DATA_ARRAY:
 		{
 			buffer = (GLfloat*)malloc(1);			
-			for(int i=0; i < mesh->getPolygonCount(); i++) {
-				for(int j=0; j < mesh->getPolygon(i)->getVertexCount(); j++) {
-					newBufferSize = bufferSize + 4;			
-					buffer = (GLfloat*)realloc(buffer, newBufferSize * sizeof(GLfloat));
-					buffer[bufferSize+0] = mesh->getPolygon(i)->getVertex(j)->vertexColor.r;
-					buffer[bufferSize+1] = mesh->getPolygon(i)->getVertex(j)->vertexColor.g;
-					buffer[bufferSize+2] = mesh->getPolygon(i)->getVertex(j)->vertexColor.b;
-					buffer[bufferSize+3] = mesh->getPolygon(i)->getVertex(j)->vertexColor.a;			
-					bufferSize = newBufferSize;					
-				}		   
+			for(int i=0; i < mesh->getVertexCount(); i++) {
+                newBufferSize = bufferSize + 4;
+                buffer = (GLfloat*)realloc(buffer, newBufferSize * sizeof(GLfloat));
+                buffer[bufferSize+0] = mesh->getVertex(i)->vertexColor.r;
+                buffer[bufferSize+1] = mesh->getVertex(i)->vertexColor.g;
+                buffer[bufferSize+2] = mesh->getVertex(i)->vertexColor.b;
+                buffer[bufferSize+3] = mesh->getVertex(i)->vertexColor.a;
+                bufferSize = newBufferSize;
 			}
 		}
 		break;
@@ -911,21 +906,13 @@ RenderDataArray *OpenGLRenderer::createRenderDataArrayForMesh(Mesh *mesh, int ar
 		{
 			buffer = (GLfloat*)malloc(1);	
 			
-			for(int i=0; i < mesh->getPolygonCount(); i++) {
-				for(int j=0; j < mesh->getPolygon(i)->getVertexCount(); j++) {
-					newBufferSize = bufferSize + 3;			
-					buffer = (GLfloat*)realloc(buffer, newBufferSize * sizeof(GLfloat));		
-					if(mesh->getPolygon(i)->useVertexNormals) {
-						buffer[bufferSize+0] = mesh->getPolygon(i)->getVertex(j)->normal.x;
-						buffer[bufferSize+1] = mesh->getPolygon(i)->getVertex(j)->normal.y;
-						buffer[bufferSize+2] = mesh->getPolygon(i)->getVertex(j)->normal.z;				
-					} else {
-						buffer[bufferSize+0] = mesh->getPolygon(i)->getFaceNormal().x;
-						buffer[bufferSize+1] = mesh->getPolygon(i)->getFaceNormal().y;
-						buffer[bufferSize+2] = mesh->getPolygon(i)->getFaceNormal().z;
-					}
-					bufferSize = newBufferSize;					
-				}		   
+			for(int i=0; i < mesh->getVertexCount(); i++) {
+                newBufferSize = bufferSize + 3;
+                buffer = (GLfloat*)realloc(buffer, newBufferSize * sizeof(GLfloat));
+                buffer[bufferSize+0] = mesh->getVertex(i)->normal.x;
+                buffer[bufferSize+1] = mesh->getVertex(i)->normal.y;
+                buffer[bufferSize+2] = mesh->getVertex(i)->normal.z;
+                bufferSize = newBufferSize;
 			}			
 		}
 		break;
@@ -933,29 +920,25 @@ RenderDataArray *OpenGLRenderer::createRenderDataArrayForMesh(Mesh *mesh, int ar
 		{
 			buffer = (GLfloat*)malloc(1);	
 			
-			for(int i=0; i < mesh->getPolygonCount(); i++) {
-				for(int j=0; j < mesh->getPolygon(i)->getVertexCount(); j++) {
-					newBufferSize = bufferSize + 3;			
-					buffer = (GLfloat*)realloc(buffer, newBufferSize * sizeof(GLfloat));		
-					buffer[bufferSize+0] = mesh->getPolygon(i)->getVertex(j)->tangent.x;
-					buffer[bufferSize+1] = mesh->getPolygon(i)->getVertex(j)->tangent.y;
-					buffer[bufferSize+2] = mesh->getPolygon(i)->getVertex(j)->tangent.z;				
-					bufferSize = newBufferSize;					
-				}		   
+			for(int i=0; i < mesh->getVertexCount(); i++) {
+                newBufferSize = bufferSize + 3;
+                buffer = (GLfloat*)realloc(buffer, newBufferSize * sizeof(GLfloat));		
+                buffer[bufferSize+0] = mesh->getVertex(i)->tangent.x;
+                buffer[bufferSize+1] = mesh->getVertex(i)->tangent.y;
+                buffer[bufferSize+2] = mesh->getVertex(i)->tangent.z;
+                bufferSize = newBufferSize;
 			}			
 		}
 		break;		
 		case RenderDataArray::TEXCOORD_DATA_ARRAY:
 		{
 			buffer = (GLfloat*)malloc(1);				
-			for(int i=0; i < mesh->getPolygonCount(); i++) {
-				for(int j=0; j < mesh->getPolygon(i)->getVertexCount(); j++) {
-					newBufferSize = bufferSize + 2;			
-					buffer = (GLfloat*)realloc(buffer, newBufferSize * sizeof(GLfloat));		
-					buffer[bufferSize+0] = mesh->getPolygon(i)->getVertex(j)->getTexCoord().x;											
-					buffer[bufferSize+1] = mesh->getPolygon(i)->getVertex(j)->getTexCoord().y;							
-					bufferSize = newBufferSize;					
-				}		   
+			for(int i=0; i < mesh->getVertexCount(); i++) {
+                newBufferSize = bufferSize + 2;
+                buffer = (GLfloat*)realloc(buffer, newBufferSize * sizeof(GLfloat));		
+                buffer[bufferSize+0] = mesh->getVertex(i)->getTexCoord().x;
+                buffer[bufferSize+1] = mesh->getVertex(i)->getTexCoord().y;
+                bufferSize = newBufferSize;
 			}			
 		}
 		break;

Core/Contents/Source/PolyGLVertexBuffer.cpp

@@ -22,7 +22,6 @@
 
 #include "PolyGLHeaders.h"
 #include "PolyGLVertexBuffer.h"
-#include "PolyPolygon.h"
 
 #if defined(__APPLE__) && defined(__MACH__)
 
@@ -58,20 +57,17 @@ OpenGLVertexBuffer::OpenGLVertexBuffer(Mesh *mesh) : VertexBuffer() {
 	GLfloat *buffer = (GLfloat*)malloc(1);	
 	
 	vertexCount = 0;
-	for(int i=0; i < mesh->getPolygonCount(); i++) {
-		for(int j=0; j < mesh->getPolygon(i)->getVertexCount(); j++) {
-			vertexCount++;			
-			newBufferSize = bufferSize + 3;
-			buffer = (GLfloat*)realloc(buffer, newBufferSize * sizeof(GLfloat));			
-			buffer[bufferSize+0] = mesh->getPolygon(i)->getVertex(j)->x;
-			buffer[bufferSize+1] = mesh->getPolygon(i)->getVertex(j)->y;
-			buffer[bufferSize+2] = mesh->getPolygon(i)->getVertex(j)->z;			
-			bufferSize = newBufferSize;	
-		}		   
+	for(int i=0; i < mesh->getVertexCount(); i++) {
+        vertexCount++;
+        newBufferSize = bufferSize + 3;
+        buffer = (GLfloat*)realloc(buffer, newBufferSize * sizeof(GLfloat));			
+        buffer[bufferSize+0] = mesh->getVertex(i)->x;
+        buffer[bufferSize+1] = mesh->getVertex(i)->y;
+        buffer[bufferSize+2] = mesh->getVertex(i)->z;
+        bufferSize = newBufferSize;
 	}
 	glBufferDataARB(GL_ARRAY_BUFFER_ARB, bufferSize*sizeof(GLfloat), buffer, GL_STATIC_DRAW_ARB);	
 	free(buffer);
-	
 
 	glGenBuffersARB(1, &texCoordBufferID);
 	glBindBufferARB(GL_ARRAY_BUFFER_ARB, texCoordBufferID);
@@ -80,20 +76,17 @@ OpenGLVertexBuffer::OpenGLVertexBuffer(Mesh *mesh) : VertexBuffer() {
 	newBufferSize = 0;		
 	buffer = (GLfloat*)malloc(1);	
 	
-	for(int i=0; i < mesh->getPolygonCount(); i++) {
-		for(int j=0; j < mesh->getPolygon(i)->getVertexCount(); j++) {
-			newBufferSize = bufferSize + 2;			
-			buffer = (GLfloat*)realloc(buffer, newBufferSize * sizeof(GLfloat));		
-			buffer[bufferSize+0] = mesh->getPolygon(i)->getVertex(j)->getTexCoord().x;
-			buffer[bufferSize+1] = mesh->getPolygon(i)->getVertex(j)->getTexCoord().y;
-			bufferSize = newBufferSize;					
-		}		   
+	for(int i=0; i < mesh->getVertexCount(); i++) {
+        newBufferSize = bufferSize + 2;
+        buffer = (GLfloat*)realloc(buffer, newBufferSize * sizeof(GLfloat));		
+        buffer[bufferSize+0] = mesh->getVertex(i)->getTexCoord().x;
+        buffer[bufferSize+1] = mesh->getVertex(i)->getTexCoord().y;
+        bufferSize = newBufferSize;
 	}
 	
 	glBufferDataARB(GL_ARRAY_BUFFER_ARB, bufferSize*sizeof(GLfloat), buffer, GL_STATIC_DRAW_ARB);	
 	free(buffer);
 	
-	
 	glGenBuffersARB(1, &normalBufferID);
 	glBindBufferARB(GL_ARRAY_BUFFER_ARB, normalBufferID);
 	
@@ -101,27 +94,17 @@ OpenGLVertexBuffer::OpenGLVertexBuffer(Mesh *mesh) : VertexBuffer() {
 	newBufferSize = 0;		
 	buffer = (GLfloat*)malloc(1);	
 	
-	for(int i=0; i < mesh->getPolygonCount(); i++) {
-		for(int j=0; j < mesh->getPolygon(i)->getVertexCount(); j++) {
-			newBufferSize = bufferSize + 3;			
-			buffer = (GLfloat*)realloc(buffer, newBufferSize * sizeof(GLfloat));		
-			if(mesh->getPolygon(i)->useVertexNormals) {
-				buffer[bufferSize+0] = mesh->getPolygon(i)->getVertex(j)->normal.x;
-				buffer[bufferSize+1] = mesh->getPolygon(i)->getVertex(j)->normal.y;
-				buffer[bufferSize+2] = mesh->getPolygon(i)->getVertex(j)->normal.z;				
-			} else {
-				buffer[bufferSize+0] = mesh->getPolygon(i)->getFaceNormal().x;
-				buffer[bufferSize+1] = mesh->getPolygon(i)->getFaceNormal().y;
-				buffer[bufferSize+2] = mesh->getPolygon(i)->getFaceNormal().z;
-			}
-			bufferSize = newBufferSize;					
-		}		   
+	for(int i=0; i < mesh->getVertexCount(); i++) {
+        newBufferSize = bufferSize + 3;
+        buffer = (GLfloat*)realloc(buffer, newBufferSize * sizeof(GLfloat));
+        buffer[bufferSize+0] = mesh->getVertex(i)->normal.x;
+        buffer[bufferSize+1] = mesh->getVertex(i)->normal.y;
+        buffer[bufferSize+2] = mesh->getVertex(i)->normal.z;
+        bufferSize = newBufferSize;
 	}
 	
 	glBufferDataARB(GL_ARRAY_BUFFER_ARB, bufferSize*sizeof(GLfloat), buffer, GL_STATIC_DRAW_ARB);	
 	free(buffer);	
-		
-		
 
 	glGenBuffersARB(1, &tangentBufferID);
 	glBindBufferARB(GL_ARRAY_BUFFER_ARB, tangentBufferID);
@@ -130,15 +113,13 @@ OpenGLVertexBuffer::OpenGLVertexBuffer(Mesh *mesh) : VertexBuffer() {
 	newBufferSize = 0;		
 	buffer = (GLfloat*)malloc(1);	
 	
-	for(int i=0; i < mesh->getPolygonCount(); i++) {
-		for(int j=0; j < mesh->getPolygon(i)->getVertexCount(); j++) {
-			newBufferSize = bufferSize + 3;			
-			buffer = (GLfloat*)realloc(buffer, newBufferSize * sizeof(GLfloat));		
-			buffer[bufferSize+0] = mesh->getPolygon(i)->getVertex(j)->tangent.x;
-			buffer[bufferSize+1] = mesh->getPolygon(i)->getVertex(j)->tangent.y;
-			buffer[bufferSize+2] = mesh->getPolygon(i)->getVertex(j)->tangent.z;
-			bufferSize = newBufferSize;					
-		}		   
+	for(int i=0; i < mesh->getVertexCount(); i++) {
+        newBufferSize = bufferSize + 3;
+        buffer = (GLfloat*)realloc(buffer, newBufferSize * sizeof(GLfloat));		
+        buffer[bufferSize+0] = mesh->getVertex(i)->tangent.x;
+        buffer[bufferSize+1] = mesh->getVertex(i)->tangent.y;
+        buffer[bufferSize+2] = mesh->getVertex(i)->tangent.z;
+        bufferSize = newBufferSize;
 	}
 	
 	glBufferDataARB(GL_ARRAY_BUFFER_ARB, bufferSize*sizeof(GLfloat), buffer, GL_STATIC_DRAW_ARB);	
@@ -151,16 +132,14 @@ OpenGLVertexBuffer::OpenGLVertexBuffer(Mesh *mesh) : VertexBuffer() {
 	newBufferSize = 0;		
 	buffer = (GLfloat*)malloc(1);	
 	
-	for(int i=0; i < mesh->getPolygonCount(); i++) {
-		for(int j=0; j < mesh->getPolygon(i)->getVertexCount(); j++) {
-			newBufferSize = bufferSize + 4;			
-			buffer = (GLfloat*)realloc(buffer, newBufferSize * sizeof(GLfloat));
-			buffer[bufferSize+0] = mesh->getPolygon(i)->getVertex(j)->vertexColor.r;
-			buffer[bufferSize+1] = mesh->getPolygon(i)->getVertex(j)->vertexColor.g;
-			buffer[bufferSize+2] = mesh->getPolygon(i)->getVertex(j)->vertexColor.b;
-			buffer[bufferSize+3] = mesh->getPolygon(i)->getVertex(j)->vertexColor.a;			
-			bufferSize = newBufferSize;					
-		}		   
+	for(int i=0; i < mesh->getVertexCount(); i++) {
+        newBufferSize = bufferSize + 4;
+        buffer = (GLfloat*)realloc(buffer, newBufferSize * sizeof(GLfloat));
+        buffer[bufferSize+0] = mesh->getVertex(i)->vertexColor.r;
+        buffer[bufferSize+1] = mesh->getVertex(i)->vertexColor.g;
+        buffer[bufferSize+2] = mesh->getVertex(i)->vertexColor.b;
+        buffer[bufferSize+3] = mesh->getVertex(i)->vertexColor.a;
+        bufferSize = newBufferSize;
 	}
 	
 	glBufferDataARB(GL_ARRAY_BUFFER_ARB, bufferSize*sizeof(GLfloat), buffer, GL_STATIC_DRAW_ARB);	

Core/Contents/Source/PolyMesh.cpp

@@ -1,23 +1,23 @@
 /*
- Copyright (C) 2011 by Ivan Safrin
- 
- Permission is hereby granted, free of charge, to any person obtaining a copy
- of this software and associated documentation files (the "Software"), to deal
- in the Software without restriction, including without limitation the rights
- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- copies of the Software, and to permit persons to whom the Software is
- furnished to do so, subject to the following conditions:
- 
- The above copyright notice and this permission notice shall be included in
- all copies or substantial portions of the Software.
- 
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- THE SOFTWARE.
+Copyright (C) 2011 by Ivan Safrin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
 */
 
 #include "PolyMesh.h"
@@ -28,912 +28,733 @@ using std::min;
 using std::max;
 using std::vector;
 
-namespace Polycode {
-
-	Mesh::Mesh(const String& fileName) {
-		
-		for(int i=0; i < 16; i++) {
-			arrayDirtyMap[i] = false;
-			renderDataArrays[i] = NULL;
-		}
-
-		
-		meshType = TRI_MESH;
-		meshHasVertexBuffer = false;
-		loadMesh(fileName);
-		vertexBuffer = NULL;			
-		useVertexColors = false;
-	}
-	
-	Mesh::Mesh(int meshType) {
-		for(int i=0; i < 16; i++) {
-			arrayDirtyMap[i] = false;
-			renderDataArrays[i] = NULL;			
-		}		
-		this->meshType = meshType;
-		meshHasVertexBuffer = false;		
-		vertexBuffer = NULL;
-		useVertexColors = false;				
-	}
-	
-	Mesh *Mesh::MeshFromFileName(String& fileName) {
-		return new Mesh(fileName);
-	}
-	
-	Mesh::~Mesh() {
-		clearMesh();
-	}
-	
-	void Mesh::clearMesh() {
-		for(int i=0; i < polygons.size(); i++) {	
-			delete polygons[i];
-		}
-		polygons.clear();
-		if(vertexBuffer)
-			delete vertexBuffer;
-		vertexBuffer = NULL;
-		
-		for(int i=0; i < 16; i++) {
-			if(renderDataArrays[i]) {
-				free(renderDataArrays[i]->arrayPtr);
-				delete renderDataArrays[i];
-				renderDataArrays[i] = NULL;
-			}
-		}
-		
-		meshHasVertexBuffer = false;
-	}
-	
-	VertexBuffer *Mesh::getVertexBuffer() {
-		return vertexBuffer;
-	}
-
-	void Mesh::setVertexBuffer(VertexBuffer *buffer) {
-		vertexBuffer = buffer;
-		meshHasVertexBuffer = true;
-	}
-	
-	Number Mesh::getRadius() {
-		Number hRad = 0;
-		Number len;
-		for(int i=0; i < polygons.size(); i++) {	
-			for(int j=0; j < polygons[i]->getVertexCount(); j++) {
-				len = polygons[i]->getVertex(j)->length();
-				if(len > hRad)
-					hRad = len;
-			}
-		}
-		return hRad;
-	}
-	
-	void Mesh::saveToFile(OSFILE *outFile) {				
-		unsigned int numFaces = polygons.size();
-
-		OSBasics::write(&meshType, sizeof(unsigned int), 1, outFile);		
-		OSBasics::write(&numFaces, sizeof(unsigned int), 1, outFile);
-		for(int i=0; i < polygons.size(); i++) {
-			
-			Vector3_struct pos;
-			Vector3_struct nor;
-			Vector3_struct tan;			
-			Vector4_struct col;			
-			Vector2_struct tex;
-			
-			for(int j=0; j <  polygons[i]->getVertexCount(); j++) {
-				
-				pos.x =  polygons[i]->getVertex(j)->x;
-				pos.y =  polygons[i]->getVertex(j)->y;
-				pos.z =  polygons[i]->getVertex(j)->z;
-
-				nor.x =  polygons[i]->getVertex(j)->normal.x;
-				nor.y =  polygons[i]->getVertex(j)->normal.y;
-				nor.z =  polygons[i]->getVertex(j)->normal.z;
-
-				tan.x =  polygons[i]->getVertex(j)->tangent.x;
-				tan.y =  polygons[i]->getVertex(j)->tangent.y;
-				tan.z =  polygons[i]->getVertex(j)->tangent.z;
-
-				col.x =  polygons[i]->getVertex(j)->vertexColor.r;
-				col.y =  polygons[i]->getVertex(j)->vertexColor.g;
-				col.z =  polygons[i]->getVertex(j)->vertexColor.b;
-				col.w =  polygons[i]->getVertex(j)->vertexColor.a;
-				
-				tex.x = polygons[i]->getVertex(j)->getTexCoord().x;
-				tex.y = polygons[i]->getVertex(j)->getTexCoord().y;
-				
-				OSBasics::write(&pos, sizeof(Vector3_struct), 1, outFile);
-				OSBasics::write(&nor, sizeof(Vector3_struct), 1, outFile);
-				OSBasics::write(&tan, sizeof(Vector3_struct), 1, outFile);				
-				OSBasics::write(&col, sizeof(Vector4_struct), 1, outFile);				
-				OSBasics::write(&tex, sizeof(Vector2_struct), 1, outFile);								
-				
-				unsigned int numBoneWeights = polygons[i]->getVertex(j)->getNumBoneAssignments();
-				OSBasics::write(&numBoneWeights, sizeof(unsigned int), 1, outFile);					
-				for(int b=0; b < numBoneWeights; b++) {
-					BoneAssignment *a = polygons[i]->getVertex(j)->getBoneAssignment(b);
-					unsigned int boneID = a->boneID;
-					float weight = a->weight;
-					OSBasics::write(&boneID, sizeof(unsigned int), 1, outFile);
-					OSBasics::write(&weight, sizeof(float), 1, outFile);												
-				}
-			}
-			
-		}
-	}
-
-	
-	void Mesh::loadFromFile(OSFILE *inFile) {
-
-		unsigned int meshType;		
-		OSBasics::read(&meshType, sizeof(unsigned int), 1, inFile);				
-		setMeshType(meshType);
-		
-		int verticesPerFace;
-		switch(meshType) {
-			case TRI_MESH:
-				verticesPerFace = 3;
-			break;
-			case QUAD_MESH:
-				verticesPerFace = 4;
-			break;
-			default:
-				verticesPerFace = 1;				
-			break;
-		}
-		
-		unsigned int numFaces;		
-		OSBasics::read(&numFaces, sizeof(unsigned int), 1, inFile);
-		
-		Vector3_struct pos;
-		Vector3_struct nor;
-		Vector3_struct tan;
-		Vector4_struct col;			
-		Vector2_struct tex;
-		
-		for(int i=0; i < numFaces; i++) {	
-			Polygon *poly = new Polygon();			
-			
-			for(int j=0; j < verticesPerFace; j++) {
-				OSBasics::read(&pos, sizeof(Vector3_struct), 1, inFile);
-				OSBasics::read(&nor, sizeof(Vector3_struct), 1, inFile);
-				OSBasics::read(&tan, sizeof(Vector3_struct), 1, inFile);				
-				OSBasics::read(&col, sizeof(Vector4_struct), 1, inFile);						
-				OSBasics::read(&tex, sizeof(Vector2_struct), 1, inFile);						
-				
-				Vertex *vertex = new Vertex(pos.x, pos.y, pos.z);
-				vertex->setNormal(nor.x,nor.y, nor.z);
-				vertex->tangent = Vector3(tan.x, tan.y, tan.z);
-				vertex->restNormal.set(nor.x,nor.y, nor.z);
-				vertex->vertexColor.setColor(col.x,col.y, col.z, col.w);
-				vertex->setTexCoord(tex.x, tex.y);
-				
-				unsigned int numBoneWeights;
-				OSBasics::read(&numBoneWeights, sizeof(unsigned int), 1, inFile);								
-				for(int b=0; b < numBoneWeights; b++) {
-					float weight;
-					unsigned int boneID;
-					OSBasics::read(&boneID, sizeof(unsigned int), 1, inFile);													
-					OSBasics::read(&weight, sizeof(float), 1, inFile);																		
-					vertex->addBoneAssignment(boneID, weight);
-				}
-				
-				Number totalWeight = 0;				
-				for(int m=0; m < vertex->getNumBoneAssignments(); m++) {
-					BoneAssignment *ba = vertex->getBoneAssignment(m);					
-					totalWeight += ba->weight;
-				}				
-
-				for(int m=0; m < vertex->getNumBoneAssignments(); m++) {
-					BoneAssignment *ba = vertex->getBoneAssignment(m);					
-					ba->weight = ba->weight/totalWeight;
-				}				
-
-				
-				poly->addVertex(vertex);
-			}
-			addPolygon(poly);
-		}
-		
-		arrayDirtyMap[RenderDataArray::VERTEX_DATA_ARRAY] = true;		
-		arrayDirtyMap[RenderDataArray::COLOR_DATA_ARRAY] = true;				
-		arrayDirtyMap[RenderDataArray::TEXCOORD_DATA_ARRAY] = true;
-		arrayDirtyMap[RenderDataArray::NORMAL_DATA_ARRAY] = true;	
-		arrayDirtyMap[RenderDataArray::TANGENT_DATA_ARRAY] = true;								
-	}
-	
-	void Mesh::saveToFile(const String& fileName) {
-		OSFILE *outFile = OSBasics::open(fileName, "wb");
-		if(!outFile) {
-			Logger::log("Error opening mesh file for saving: %s", fileName.c_str());
-		}
-		saveToFile(outFile);
-		OSBasics::close(outFile);	
-	
-	}
-	
-	void Mesh::loadMesh(const String& fileName) {
-		OSFILE *inFile = OSBasics::open(fileName, "rb");
-		if(!inFile) {
-			Logger::log("Error opening mesh file %s", fileName.c_str());
-		}
-		loadFromFile(inFile);
-		OSBasics::close(inFile);	
-		arrayDirtyMap[RenderDataArray::VERTEX_DATA_ARRAY] = true;		
-		arrayDirtyMap[RenderDataArray::COLOR_DATA_ARRAY] = true;				
-		arrayDirtyMap[RenderDataArray::TEXCOORD_DATA_ARRAY] = true;						
-		arrayDirtyMap[RenderDataArray::NORMAL_DATA_ARRAY] = true;										
-		arrayDirtyMap[RenderDataArray::TANGENT_DATA_ARRAY] = true;		
-	}
-
-	void Mesh::createCircle(Number w, Number h, unsigned int numSegments) {
-		setMeshType(Mesh::TRI_MESH);
-
-        Number lastx = 0;
-		Number lasty = 0;
-		Number lastv = 0;
-
-        Polycode::Polygon *polygon;
-		for (int i=0 ; i < numSegments+1; i++) {
-			Number v = ((Number)i)/((Number)numSegments);
-			Number pos = ((PI*2.0)/((Number)numSegments)) * i;
-			Number x = sin(pos) * w * 0.5;
-			Number y = cos(pos) * h * 0.5;
-			
-			if(i > 0) {
-                polygon = new Polygon();
-                polygon->addVertex(0,0,0,0.5,0.5)->setNormal(0.0, 0.0, 1.0);
-                polygon->addVertex(x,y,0, 0.5+(y/h*0.5), 0.5+(x/w*0.5))->setNormal(0.0, 0.0, 1.0);
-                polygon->addVertex(lastx,lasty,0, 0.5+(lasty/h*0.5), 0.5+(lastx/w*0.5))->setNormal(0.0, 0.0, 1.0);
-                addPolygon(polygon);
-            }
-			lastx = x;
-			lastv = v;
-			lasty = y;
+using namespace Polycode;
+
+Mesh::Mesh(const String& fileName) {
+    
+    for(int i=0; i < 16; i++) {
+        arrayDirtyMap[i] = false;
+        renderDataArrays[i] = NULL;
+    }
+
+    
+    meshType = TRI_MESH;
+    meshHasVertexBuffer = false;
+    loadMesh(fileName);
+    vertexBuffer = NULL;			
+    useVertexColors = false;
+}
+
+Mesh::Mesh(int meshType) {
+    for(int i=0; i < 16; i++) {
+        arrayDirtyMap[i] = false;
+        renderDataArrays[i] = NULL;			
+    }		
+    this->meshType = meshType;
+    meshHasVertexBuffer = false;		
+    vertexBuffer = NULL;
+    useVertexColors = false;				
+}
+
+Mesh *Mesh::MeshFromFileName(String& fileName) {
+    return new Mesh(fileName);
+}
+
+Mesh::~Mesh() {
+    clearMesh();
+}
+
+void Mesh::clearMesh() {
+    for(int i=0; i < vertices.size(); i++) {
+        delete vertices[i];
+    }
+    vertices.clear();
+    if(vertexBuffer)
+        delete vertexBuffer;
+    vertexBuffer = NULL;
+    
+    for(int i=0; i < 16; i++) {
+        if(renderDataArrays[i]) {
+            free(renderDataArrays[i]->arrayPtr);
+            delete renderDataArrays[i];
+            renderDataArrays[i] = NULL;
         }
+    }
+    meshHasVertexBuffer = false;
+}
+
+VertexBuffer *Mesh::getVertexBuffer() {
+    return vertexBuffer;
+}
+
+void Mesh::setVertexBuffer(VertexBuffer *buffer) {
+    vertexBuffer = buffer;
+    meshHasVertexBuffer = true;
+}
+
+Number Mesh::getRadius() {
+    Number hRad = 0;
+    Number len;
+    for(int i=0; i < vertices.size(); i++) {
+        len = vertices[i]->length();
+        if(len > hRad) {
+            hRad = len;
+        }
+    }
+    return hRad;
+}
+
+void Mesh::saveToFile(OSFILE *outFile) {				
+    unsigned int numVertices = vertices.size();
+
+    OSBasics::write(&meshType, sizeof(unsigned int), 1, outFile);		
+    OSBasics::write(&numVertices, sizeof(unsigned int), 1, outFile);
+
+    Vector3_struct pos;
+    Vector3_struct nor;
+    Vector3_struct tan;
+    Vector4_struct col;
+    Vector2_struct tex;
+
+    for(int i=0; i < vertices.size(); i++) {
+        pos.x =  vertices[i]->x;
+        pos.y =  vertices[i]->y;
+        pos.z =  vertices[i]->z;
+
+        nor.x =  vertices[i]->normal.x;
+        nor.y =  vertices[i]->normal.y;
+        nor.z =  vertices[i]->normal.z;
+
+        tan.x =  vertices[i]->tangent.x;
+        tan.y =  vertices[i]->tangent.y;
+        tan.z =  vertices[i]->tangent.z;
+
+        col.x =  vertices[i]->vertexColor.r;
+        col.y =  vertices[i]->vertexColor.g;
+        col.z =  vertices[i]->vertexColor.b;
+        col.w =  vertices[i]->vertexColor.a;
         
+        tex.x = vertices[i]->getTexCoord().x;
+        tex.y = vertices[i]->getTexCoord().y;
         
-		arrayDirtyMap[RenderDataArray::VERTEX_DATA_ARRAY] = true;
-		arrayDirtyMap[RenderDataArray::COLOR_DATA_ARRAY] = true;				
-		arrayDirtyMap[RenderDataArray::TEXCOORD_DATA_ARRAY] = true;
-		arrayDirtyMap[RenderDataArray::NORMAL_DATA_ARRAY] = true;
-		arrayDirtyMap[RenderDataArray::TANGENT_DATA_ARRAY] = true;			
-	}
-
-    void Mesh::createLineCircle(Number w, Number h, unsigned int numSegments) {
-		setMeshType(Mesh::TRIFAN_MESH);
-     
-		Polygon *poly = new Polygon();
-		int step;
-		if(numSegments > 0) {
-            step = ceil(360/numSegments);
-		} else {
-            step = 1;
-		}
-		
+        OSBasics::write(&pos, sizeof(Vector3_struct), 1, outFile);
+        OSBasics::write(&nor, sizeof(Vector3_struct), 1, outFile);
+        OSBasics::write(&tan, sizeof(Vector3_struct), 1, outFile);				
+        OSBasics::write(&col, sizeof(Vector4_struct), 1, outFile);				
+        OSBasics::write(&tex, sizeof(Vector2_struct), 1, outFile);
+
+        unsigned int numBoneWeights = vertices[i]->getNumBoneAssignments();
+        OSBasics::write(&numBoneWeights, sizeof(unsigned int), 1, outFile);					
+        for(int b=0; b < numBoneWeights; b++) {
+            BoneAssignment *a = vertices[i]->getBoneAssignment(b);
+            unsigned int boneID = a->boneID;
+            float weight = a->weight;
+            OSBasics::write(&boneID, sizeof(unsigned int), 1, outFile);
+            OSBasics::write(&weight, sizeof(float), 1, outFile);												
+        }
+    }
+}
+
+
+void Mesh::loadFromFile(OSFILE *inFile) {
+
+    unsigned int meshType;		
+    OSBasics::read(&meshType, sizeof(unsigned int), 1, inFile);				
+    setMeshType(meshType);
+    
+    unsigned int numVertices;
+    OSBasics::read(&numVertices, sizeof(unsigned int), 1, inFile);
+    
+    Vector3_struct pos;
+    Vector3_struct nor;
+    Vector3_struct tan;
+    Vector4_struct col;			
+    Vector2_struct tex;
+    
+    for(int i=0; i < numVertices; i++) {
+        OSBasics::read(&pos, sizeof(Vector3_struct), 1, inFile);
+        OSBasics::read(&nor, sizeof(Vector3_struct), 1, inFile);
+        OSBasics::read(&tan, sizeof(Vector3_struct), 1, inFile);				
+        OSBasics::read(&col, sizeof(Vector4_struct), 1, inFile);						
+        OSBasics::read(&tex, sizeof(Vector2_struct), 1, inFile);						
         
-		poly->addVertex(cosf(0)*(w/2),sinf(0)*(h/2), 0, (cosf(0)*0.5) + 0.5,(sinf(0) * 0.5)+ 0.5);
-		for (int i=0; i < 361; i+= step) {
-            Number degInRad = i*TORADIANS;
-            Vertex *v = poly->addVertex(cos(degInRad)*(w/2),sin(degInRad)*(h/2), 0, (cos(degInRad) * 0.5)+ 0.5 , 1.0- ((sin(degInRad) * 0.5)+ 0.5));
-            Vector3 normal = *v;
-            normal.Normalize();
-            v->normal = normal;
-		}
-		
-		addPolygon(poly);
+        Vertex *vertex = new Vertex(pos.x, pos.y, pos.z);
+        vertex->setNormal(nor.x,nor.y, nor.z);
+        vertex->tangent = Vector3(tan.x, tan.y, tan.z);
+        vertex->restNormal.set(nor.x,nor.y, nor.z);
+        vertex->vertexColor.setColor(col.x,col.y, col.z, col.w);
+        vertex->setTexCoord(tex.x, tex.y);
         
-		arrayDirtyMap[RenderDataArray::VERTEX_DATA_ARRAY] = true;
-		arrayDirtyMap[RenderDataArray::COLOR_DATA_ARRAY] = true;
-		arrayDirtyMap[RenderDataArray::TEXCOORD_DATA_ARRAY] = true;
-		arrayDirtyMap[RenderDataArray::NORMAL_DATA_ARRAY] = true;
-    }
-	
-	void Mesh::createVPlane(Number w, Number h) {
-        setMeshType(Mesh::TRI_MESH);
+        unsigned int numBoneWeights;
+        OSBasics::read(&numBoneWeights, sizeof(unsigned int), 1, inFile);								
+        for(int b=0; b < numBoneWeights; b++) {
+            float weight;
+            unsigned int boneID;
+            OSBasics::read(&boneID, sizeof(unsigned int), 1, inFile);													
+            OSBasics::read(&weight, sizeof(float), 1, inFile);																		
+            vertex->addBoneAssignment(boneID, weight);
+        }
         
-        Polycode::Polygon *polygon = new Polygon();
-		polygon->addVertex(0,0,0,0,0)->setNormal(0.0, 0.0, 1.0);
-		polygon->addVertex(w,0,0, 1, 0)->setNormal(0.0, 0.0, 1.0);
-		polygon->addVertex(w,h,0, 1, 1)->setNormal(0.0, 0.0, 1.0);
-		addPolygon(polygon);
+        Number totalWeight = 0;				
+        for(int m=0; m < vertex->getNumBoneAssignments(); m++) {
+            BoneAssignment *ba = vertex->getBoneAssignment(m);					
+            totalWeight += ba->weight;
+        }				
+
+        for(int m=0; m < vertex->getNumBoneAssignments(); m++) {
+            BoneAssignment *ba = vertex->getBoneAssignment(m);					
+            ba->weight = ba->weight/totalWeight;
+        }				
         
-        polygon = new Polygon();
-		polygon->addVertex(0,0,0,0,0)->setNormal(0.0, 0.0, 1.0);
-		polygon->addVertex(w,h,0, 1, 1)->setNormal(0.0, 0.0, 1.0);
-		polygon->addVertex(0,h,0,0,1)->setNormal(0.0, 0.0, 1.0);
-		addPolygon(polygon);
-		
-		for(int i=0; i < polygons.size(); i++) {
-			for(int j=0; j < polygons[i]->getVertexCount(); j++) {
-				polygons[i]->getVertex(j)->x = polygons[i]->getVertex(j)->x - (w/2.0f);
-				polygons[i]->getVertex(j)->y = polygons[i]->getVertex(j)->y - (h/2.0f);
-                
-			}
-		}
-
-		arrayDirtyMap[RenderDataArray::VERTEX_DATA_ARRAY] = true;
-		arrayDirtyMap[RenderDataArray::COLOR_DATA_ARRAY] = true;				
-		arrayDirtyMap[RenderDataArray::TEXCOORD_DATA_ARRAY] = true;						
-		arrayDirtyMap[RenderDataArray::NORMAL_DATA_ARRAY] = true;										
-		arrayDirtyMap[RenderDataArray::TANGENT_DATA_ARRAY] = true;		
-	}	
-	
-	void Mesh::createPlane(Number w, Number h) {
-        setMeshType(Mesh::TRI_MESH);
+        addVertex(vertex);
+    }
+
+    arrayDirtyMap[RenderDataArray::VERTEX_DATA_ARRAY] = true;		
+    arrayDirtyMap[RenderDataArray::COLOR_DATA_ARRAY] = true;				
+    arrayDirtyMap[RenderDataArray::TEXCOORD_DATA_ARRAY] = true;
+    arrayDirtyMap[RenderDataArray::NORMAL_DATA_ARRAY] = true;	
+    arrayDirtyMap[RenderDataArray::TANGENT_DATA_ARRAY] = true;								
+}
+
+Vertex *Mesh::addVertex(Number x, Number y, Number z) {
+    Vertex *vertex = new Vertex(x,y,z);
+    vertices.push_back(vertex);
+    return vertex;
+}
+
+void Mesh::addVertex(Vertex *vertex) {
+    vertices.push_back(vertex);
+}
+
+Vertex *Mesh::addVertex(Number x, Number y, Number z, Number u, Number v) {
+    Vertex *vertex = new Vertex(x,y,z,u,v);
+    vertices.push_back(vertex);
+    return vertex;
+}
+
+void Mesh::saveToFile(const String& fileName) {
+    OSFILE *outFile = OSBasics::open(fileName, "wb");
+    if(!outFile) {
+        Logger::log("Error opening mesh file for saving: %s", fileName.c_str());
+    }
+    saveToFile(outFile);
+    OSBasics::close(outFile);	
+
+}
+
+void Mesh::loadMesh(const String& fileName) {
+    OSFILE *inFile = OSBasics::open(fileName, "rb");
+    if(!inFile) {
+        Logger::log("Error opening mesh file %s", fileName.c_str());
+    }
+    loadFromFile(inFile);
+    OSBasics::close(inFile);	
+    arrayDirtyMap[RenderDataArray::VERTEX_DATA_ARRAY] = true;		
+    arrayDirtyMap[RenderDataArray::COLOR_DATA_ARRAY] = true;				
+    arrayDirtyMap[RenderDataArray::TEXCOORD_DATA_ARRAY] = true;						
+    arrayDirtyMap[RenderDataArray::NORMAL_DATA_ARRAY] = true;										
+    arrayDirtyMap[RenderDataArray::TANGENT_DATA_ARRAY] = true;		
+}
+
+void Mesh::createCircle(Number w, Number h, unsigned int numSegments) {
+    setMeshType(Mesh::TRI_MESH);
+
+    Number lastx = 0;
+    Number lasty = 0;
+    Number lastv = 0;
+
+    for (int i=0 ; i < numSegments+1; i++) {
+        Number v = ((Number)i)/((Number)numSegments);
+        Number pos = ((PI*2.0)/((Number)numSegments)) * i;
+        Number x = sin(pos) * w * 0.5;
+        Number y = cos(pos) * h * 0.5;
         
-		Polygon *imagePolygon = new Polygon();
-		imagePolygon->addVertex(0,0,h,0,0);	
-		imagePolygon->addVertex(w,0,h, 1, 0);			
-		imagePolygon->addVertex(w,0,0, 1, 1);
-		addPolygon(imagePolygon);
+        if(i > 0) {
+            addVertex(0,0,0,0.5,0.5)->setNormal(0.0, 0.0, 1.0);
+            addVertex(x,y,0, 0.5+(y/h*0.5), 0.5+(x/w*0.5))->setNormal(0.0, 0.0, 1.0);
+            addVertex(lastx,lasty,0, 0.5+(lasty/h*0.5), 0.5+(lastx/w*0.5))->setNormal(0.0, 0.0, 1.0);
+        }
+        lastx = x;
+        lastv = v;
+        lasty = y;
+    }
+    
+    
+    arrayDirtyMap[RenderDataArray::VERTEX_DATA_ARRAY] = true;
+    arrayDirtyMap[RenderDataArray::COLOR_DATA_ARRAY] = true;				
+    arrayDirtyMap[RenderDataArray::TEXCOORD_DATA_ARRAY] = true;
+    arrayDirtyMap[RenderDataArray::NORMAL_DATA_ARRAY] = true;
+    arrayDirtyMap[RenderDataArray::TANGENT_DATA_ARRAY] = true;			
+}
+
+void Mesh::createLineCircle(Number w, Number h, unsigned int numSegments) {
+    setMeshType(Mesh::TRIFAN_MESH);
+ 
+    int step;
+    if(numSegments > 0) {
+        step = ceil(360/numSegments);
+    } else {
+        step = 1;
+    }
+    
+    
+    addVertex(cosf(0)*(w/2),sinf(0)*(h/2), 0, (cosf(0)*0.5) + 0.5,(sinf(0) * 0.5)+ 0.5);
+    
+    for (int i=0; i < 361; i+= step) {
+        Number degInRad = i*TORADIANS;
+        Vertex *v = addVertex(cos(degInRad)*(w/2),sin(degInRad)*(h/2), 0, (cos(degInRad) * 0.5)+ 0.5 , 1.0- ((sin(degInRad) * 0.5)+ 0.5));
+        Vector3 normal = *v;
+        normal.Normalize();
+        v->normal = normal;
+    }
+    
+    arrayDirtyMap[RenderDataArray::VERTEX_DATA_ARRAY] = true;
+    arrayDirtyMap[RenderDataArray::COLOR_DATA_ARRAY] = true;
+    arrayDirtyMap[RenderDataArray::TEXCOORD_DATA_ARRAY] = true;
+    arrayDirtyMap[RenderDataArray::NORMAL_DATA_ARRAY] = true;
+}
+
+void Mesh::createVPlane(Number w, Number h) {
+    setMeshType(Mesh::TRI_MESH);
+    
+    addVertex(0,0,0,0,0)->setNormal(0.0, 0.0, 1.0);
+    addVertex(w,0,0, 1, 0)->setNormal(0.0, 0.0, 1.0);
+    addVertex(w,h,0, 1, 1)->setNormal(0.0, 0.0, 1.0);
+    
+    addVertex(0,0,0,0,0)->setNormal(0.0, 0.0, 1.0);
+    addVertex(w,h,0, 1, 1)->setNormal(0.0, 0.0, 1.0);
+    addVertex(0,h,0,0,1)->setNormal(0.0, 0.0, 1.0);
+    
+    for(int i=0; i < vertices.size(); i++) {
+            vertices[i]->x = vertices[i]->x - (w/2.0f);
+            vertices[i]->y = vertices[i]->y - (h/2.0f);
+    }
+
+    arrayDirtyMap[RenderDataArray::VERTEX_DATA_ARRAY] = true;
+    arrayDirtyMap[RenderDataArray::COLOR_DATA_ARRAY] = true;				
+    arrayDirtyMap[RenderDataArray::TEXCOORD_DATA_ARRAY] = true;						
+    arrayDirtyMap[RenderDataArray::NORMAL_DATA_ARRAY] = true;										
+    arrayDirtyMap[RenderDataArray::TANGENT_DATA_ARRAY] = true;		
+}	
+
+void Mesh::createPlane(Number w, Number h) {
+    setMeshType(Mesh::TRI_MESH);
+    
+    addVertex(0,0,h,0,0);
+    addVertex(w,0,h, 1, 0);
+    addVertex(w,0,0, 1, 1);
+    
+    addVertex(0,0,h,0,0);
+    addVertex(w,0,0, 1, 1);
+    addVertex(0,0,0,0,1);
+    
+    for(int i=0; i < vertices.size(); i++) {
+        vertices[i]->x = vertices[i]->x - (w/2.0f);
+        vertices[i]->z = vertices[i]->z - (h/2.0f);
+    }
+
+    calculateNormals();
+    calculateTangents();
+    arrayDirtyMap[RenderDataArray::VERTEX_DATA_ARRAY] = true;		
+    arrayDirtyMap[RenderDataArray::COLOR_DATA_ARRAY] = true;				
+    arrayDirtyMap[RenderDataArray::TEXCOORD_DATA_ARRAY] = true;						
+    arrayDirtyMap[RenderDataArray::NORMAL_DATA_ARRAY] = true;										
+    arrayDirtyMap[RenderDataArray::TANGENT_DATA_ARRAY] = true;		
+}
+
+Vector3 Mesh::recenterMesh() {
+    Vector3 positiveOffset;
+    Vector3 negativeOffset;
+    
+    for(int i=0; i < vertices.size(); i++) {
+        positiveOffset.x = max(positiveOffset.x, vertices[i]->x);
+        positiveOffset.y = max(positiveOffset.y, vertices[i]->y);
+        positiveOffset.z = max(positiveOffset.z, vertices[i]->z);
+
+        negativeOffset.x = min(negativeOffset.x, vertices[i]->x);
+        negativeOffset.y = min(negativeOffset.y, vertices[i]->y);
+        negativeOffset.z = min(negativeOffset.z, vertices[i]->z);
+    }		
+    
+    Vector3 finalOffset;
+    
+    finalOffset.x = (positiveOffset.x + negativeOffset.x)/2.0f;
+    finalOffset.y = (positiveOffset.y + negativeOffset.y)/2.0f;
+    finalOffset.z = (positiveOffset.z + negativeOffset.z)/2.0f;		
+    
+    for(int i=0; i < vertices.size(); i++) {
+        vertices[i]->x = vertices[i]->x - finalOffset.x;
+        vertices[i]->y = vertices[i]->y - finalOffset.y;
+        vertices[i]->z = vertices[i]->z - finalOffset.z;
+    }		
+
+    
+    arrayDirtyMap[RenderDataArray::VERTEX_DATA_ARRAY] = true;
+    
+    return finalOffset;		
+}	
+
+Vector3 Mesh::calculateBBox() {
+    Vector3 retVec;
+    
+    for(int i=0; i < vertices.size(); i++) {
+        retVec.x = max(retVec.x,fabs(vertices[i]->x));
+        retVec.y = max(retVec.y,fabs(vertices[i]->y));
+        retVec.z = max(retVec.z,fabs(vertices[i]->z));
+    }
+    
+    return retVec*2;
+}
+
+void Mesh::createSphere(Number _radius, int _segmentsH, int _segmentsW) {
+
+    setMeshType(Mesh::TRI_MESH);
+
+    Vector3 **grid = (Vector3 **) malloc(sizeof(Vector3*) * (_segmentsH+1));
+    for (int i=0 ; i < _segmentsH+1; i++) {
+        grid[i] = (Vector3*) malloc(sizeof(Vector3) * _segmentsW+1);		
+    }
+    
+    for (int i = 0; i < _segmentsW; i++) {
+        grid[0][i] = Vector3(0,-_radius,0);
+    }
         
-        imagePolygon = new Polygon();
-        imagePolygon->addVertex(0,0,h,0,0);
-		imagePolygon->addVertex(w,0,0, 1, 1);
-		imagePolygon->addVertex(0,0,0,0,1);
-		addPolygon(imagePolygon);
-		
-		for(int i=0; i < polygons.size(); i++) {
-			for(int j=0; j < polygons[i]->getVertexCount(); j++) {
-				polygons[i]->getVertex(j)->x = polygons[i]->getVertex(j)->x - (w/2.0f);
-				polygons[i]->getVertex(j)->z = polygons[i]->getVertex(j)->z - (h/2.0f);
-			}
-		}
-
-		calculateNormals();
-		calculateTangents();
-		arrayDirtyMap[RenderDataArray::VERTEX_DATA_ARRAY] = true;		
-		arrayDirtyMap[RenderDataArray::COLOR_DATA_ARRAY] = true;				
-		arrayDirtyMap[RenderDataArray::TEXCOORD_DATA_ARRAY] = true;						
-		arrayDirtyMap[RenderDataArray::NORMAL_DATA_ARRAY] = true;										
-		arrayDirtyMap[RenderDataArray::TANGENT_DATA_ARRAY] = true;		
-	}
-
-	Vector3 Mesh::recenterMesh() {
-		Vector3 positiveOffset;
-		Vector3 negativeOffset;
-		
-		for(int i=0; i < polygons.size(); i++) {
-			for(int j=0; j < polygons[i]->getVertexCount(); j++) {
-				positiveOffset.x = max(positiveOffset.x,polygons[i]->getVertex(j)->x);
-				positiveOffset.y = max(positiveOffset.y,polygons[i]->getVertex(j)->y);
-				positiveOffset.z = max(positiveOffset.z,polygons[i]->getVertex(j)->z);							
-				
-			}
-		}
-		
-		for(int i=0; i < polygons.size(); i++) {
-			for(int j=0; j < polygons[i]->getVertexCount(); j++) {
-				negativeOffset.x = min(negativeOffset.x,polygons[i]->getVertex(j)->x);
-				negativeOffset.y = min(negativeOffset.y,polygons[i]->getVertex(j)->y);
-				negativeOffset.z = min(negativeOffset.z,polygons[i]->getVertex(j)->z);							
-				
-			}
-		}		
-		
-		Vector3 finalOffset;
-		
-		finalOffset.x = (positiveOffset.x + negativeOffset.x)/2.0f;
-		finalOffset.y = (positiveOffset.y + negativeOffset.y)/2.0f;
-		finalOffset.z = (positiveOffset.z + negativeOffset.z)/2.0f;		
-		
-		vector<Vertex*> done;
-		for(int i=0; i < polygons.size(); i++) {
-			for(int j=0; j < polygons[i]->getVertexCount(); j++) {	
-				
-				bool alreadyDone = false;
-				for(int k=0; k < done.size(); k++) {
-					if(done[k] == polygons[i]->getVertex(j))
-						alreadyDone = true;
-				}
-				
-				if(!alreadyDone) {
-					polygons[i]->getVertex(j)->x = polygons[i]->getVertex(j)->x - finalOffset.x;
-					polygons[i]->getVertex(j)->y = polygons[i]->getVertex(j)->y - finalOffset.y;
-					polygons[i]->getVertex(j)->z = polygons[i]->getVertex(j)->z - finalOffset.z;				
-					done.push_back(polygons[i]->getVertex(j));
-				}
-			}
-		}		
-	
-		
-		arrayDirtyMap[RenderDataArray::VERTEX_DATA_ARRAY] = true;
-		
-		return finalOffset;		
-	}	
-	
-	Vector3 Mesh::calculateBBox() {
-		Vector3 retVec;
-		
-		for(int i=0; i < polygons.size(); i++) {
-			for(int j=0; j < polygons[i]->getVertexCount(); j++) {				
-				retVec.x = max(retVec.x,fabs(polygons[i]->getVertex(j)->x));
-				retVec.y = max(retVec.y,fabs(polygons[i]->getVertex(j)->y));
-				retVec.z = max(retVec.z,fabs(polygons[i]->getVertex(j)->z));							
-				
-			}
-		}
-		
-		return retVec*2;
-	}
-	
-	void Mesh::createSphere(Number _radius, int _segmentsH, int _segmentsW) {
-
-		setMeshType(Mesh::TRI_MESH);
-
-
-		Vector3 **grid = (Vector3 **) malloc(sizeof(Vector3*) * (_segmentsH+1));
-		for (int i=0 ; i < _segmentsH+1; i++) {
-			grid[i] = (Vector3*) malloc(sizeof(Vector3) * _segmentsW+1);		
-		}
-		
-	
-		for (int i = 0; i < _segmentsW; i++) {
-			grid[0][i] = Vector3(0,-_radius,0);
-		}
-			
-		for (int j = 1; j < _segmentsH; j++) {
-			Number horangle = ((float)j) / ((float)_segmentsH) * PI;
-			Number z = -_radius * cos(horangle);
-			Number ringradius = _radius * sin(horangle);
-
-			for (int i = 0; i < _segmentsW; i++) {
-				Number verangle = 2.0 * ((float)i) / ((float)_segmentsW) * PI;
-				Number x = ringradius * sin(verangle);
-				Number y = ringradius * cos(verangle);
-				grid[j][i] = Vector3(y, z, x);
+    for (int j = 1; j < _segmentsH; j++) {
+        Number horangle = ((float)j) / ((float)_segmentsH) * PI;
+        Number z = -_radius * cos(horangle);
+        Number ringradius = _radius * sin(horangle);
+
+        for (int i = 0; i < _segmentsW; i++) {
+            Number verangle = 2.0 * ((float)i) / ((float)_segmentsW) * PI;
+            Number x = ringradius * sin(verangle);
+            Number y = ringradius * cos(verangle);
+            grid[j][i] = Vector3(y, z, x);
+        }
+    }
+
+    for (int i = 0; i < _segmentsW; i++) {
+            grid[_segmentsH][i] = Vector3(0,_radius, 0);
+    }
+
+    for (int j = 1; j <= _segmentsH; j++) {
+        for (int i = 0; i < _segmentsW; i++) {
+            Vector3 a = grid[j][i];
+            Vector3 b = grid[j][(i-1+_segmentsW) % _segmentsW];
+            Vector3 c = grid[j-1][(i-1+_segmentsW) % _segmentsW];
+            Vector3 d = grid[j-1][i];
+
+            int i2 = i;
+            if (i == 0) i2 = _segmentsW;
+
+            Number vab = ((float)j) / ((float)_segmentsH);
+            Number vcd = (((float)j)-1.0) / ((float)_segmentsH);
+            Number uad = ((float)i2) / ((float)_segmentsW);
+            Number ubc = (((float)i2)-1.0) / ((float)_segmentsW);
+            Vector2 uva = Vector2(uad,vab);
+            Vector2 uvb = Vector2(ubc,vab);
+            Vector2 uvc = Vector2(ubc,vcd);
+            Vector2 uvd = Vector2(uad,vcd);
+
+            if (j < _segmentsH) {
+                addVertex(c.x, c.y, c.z, uvc.x ,uvc.y);
+                addVertex(b.x, b.y, b.z, uvb.x ,uvb.y);							
+                addVertex(a.x, a.y, a.z, uva.x ,uva.y);
+            }
+            if (j > 1) {
+                addVertex(d.x, d.y, d.z, uvd.x ,uvd.y);
+                addVertex(c.x, c.y, c.z, uvc.x ,uvc.y);
+                addVertex(a.x, a.y, a.z, uva.x ,uva.y);
             }
-		}
-
-		for (int i = 0; i < _segmentsW; i++) {
-                grid[_segmentsH][i] = Vector3(0,_radius, 0);
-		}
-
-		for (int j = 1; j <= _segmentsH; j++) {
-			for (int i = 0; i < _segmentsW; i++) {
-				Vector3 a = grid[j][i];
-				Vector3 b = grid[j][(i-1+_segmentsW) % _segmentsW];
-				Vector3 c = grid[j-1][(i-1+_segmentsW) % _segmentsW];
-				Vector3 d = grid[j-1][i];
-
-				int i2 = i;
-				if (i == 0) i2 = _segmentsW;
-
-				Number vab = ((float)j) / ((float)_segmentsH);
-				Number vcd = (((float)j)-1.0) / ((float)_segmentsH);
-				Number uad = ((float)i2) / ((float)_segmentsW);
-				Number ubc = (((float)i2)-1.0) / ((float)_segmentsW);
-				Vector2 uva = Vector2(uad,vab);
-				Vector2 uvb = Vector2(ubc,vab);
-				Vector2 uvc = Vector2(ubc,vcd);
-				Vector2 uvd = Vector2(uad,vcd);
-
-				if (j < _segmentsH) {
-					Polygon *polygon = new Polygon();
-					polygon->addVertex(c.x, c.y, c.z, uvc.x ,uvc.y);
-					polygon->addVertex(b.x, b.y, b.z, uvb.x ,uvb.y);							
-					polygon->addVertex(a.x, a.y, a.z, uva.x ,uva.y);
-					addPolygon(polygon);								
-				}
-				if (j > 1) {
-					Polygon *polygon = new Polygon();
-					polygon->addVertex(d.x, d.y, d.z, uvd.x ,uvd.y);												
-					polygon->addVertex(c.x, c.y, c.z, uvc.x ,uvc.y);
-					polygon->addVertex(a.x, a.y, a.z, uva.x ,uva.y);
-					addPolygon(polygon);					
-				}
-			}
-		}
-
-		calculateNormals();
-		calculateTangents();
-		arrayDirtyMap[RenderDataArray::VERTEX_DATA_ARRAY] = true;		
-		arrayDirtyMap[RenderDataArray::COLOR_DATA_ARRAY] = true;				
-		arrayDirtyMap[RenderDataArray::TEXCOORD_DATA_ARRAY] = true;						
-		arrayDirtyMap[RenderDataArray::NORMAL_DATA_ARRAY] = true;										
-		arrayDirtyMap[RenderDataArray::TANGENT_DATA_ARRAY] = true;		
-	}
-	
-	unsigned int Mesh::getVertexCount() {
-		unsigned int total = 0;
-		for(int i=0; i < polygons.size(); i++) {
-			total += polygons[i]->getVertexCount();
-		}
-		return total;
-	}
-
-	void Mesh::createTorus(Number radius, Number tubeRadius, int rSegments, int tSegments) {
-	
-		setMeshType(Mesh::TRI_MESH);
-			
-		Vector3 **grid = (Vector3 **) malloc(sizeof(Vector3*) * rSegments);
-		for (int i=0 ; i < rSegments; i++) {
-			grid[i] = (Vector3*) malloc(sizeof(Vector3) * tSegments);		
-		}
-		
-		for (int i=0 ; i < rSegments; i++) {
-			for (int j = 0; j < tSegments; ++j) {
-				Number u = ((Number)i) / rSegments * 2.0 * PI;
-				Number v = ((Number)j) / tSegments * 2.0 * PI;	
-
-				grid[i][j] = Vector3((radius + tubeRadius*cos(v))*cos(u), tubeRadius*sin(v), (radius + tubeRadius*cos(v))*sin(u));							
-													
-			}
-		}	
-		
-		for (int i=0 ; i < rSegments; i++) {
-			for (int j = 0; j < tSegments; ++j) {
-
-				int ip = (i+1) % rSegments;
-				int jp = (j+1) % tSegments;
-					
-				Vector3 a = grid[i ][j];
-				Vector3 b = grid[ip][j];
-				Vector3 c = grid[i ][jp];
-				Vector3 d = grid[ip][jp];
-
-				Vector2 uva = Vector2(((Number)i)     / ((Number)rSegments), ((Number)j)     / ((Number)tSegments));
-				Vector2 uvb = Vector2((((Number)i)+1.0) / ((Number)rSegments), ((Number)j)     / ((Number)tSegments));
-				Vector2 uvc = Vector2(((Number)i)    / ((Number)rSegments), (((Number)j)+1.0) / ((Number)tSegments));
-				Vector2 uvd = Vector2((((Number)i)+1.0) / ((Number)rSegments), (((Number)j)+1.0) / ((Number)tSegments));
-
-
-				Polygon *polygon = new Polygon();
-				polygon->addVertex(c.x, c.y, c.z, uvc.x ,uvc.y);
-				polygon->addVertex(b.x, b.y, b.z, uvb.x ,uvb.y);							
-				polygon->addVertex(a.x, a.y, a.z, uva.x ,uva.y);
-				addPolygon(polygon);	
-
-				polygon = new Polygon();
-				polygon->addVertex(b.x, b.y, b.z, uvb.x ,uvb.y);
-				polygon->addVertex(c.x, c.y, c.z, uvc.x ,uvc.y);					
-				polygon->addVertex(d.x, d.y, d.z, uvd.x ,uvd.y);				
-				addPolygon(polygon);	
-			}
-		}
-		
-		for (int i=0 ; i < rSegments; i++) {
-			free(grid[i]);
-		}		
-		free(grid);
-		
-	
-		calculateNormals();
-		calculateTangents();
-		arrayDirtyMap[RenderDataArray::VERTEX_DATA_ARRAY] = true;		
-		arrayDirtyMap[RenderDataArray::COLOR_DATA_ARRAY] = true;				
-		arrayDirtyMap[RenderDataArray::TEXCOORD_DATA_ARRAY] = true;						
-		arrayDirtyMap[RenderDataArray::NORMAL_DATA_ARRAY] = true;										
-		arrayDirtyMap[RenderDataArray::TANGENT_DATA_ARRAY] = true;				
-	}
-
-	void Mesh::createCylinder(Number height, Number radius, int numSegments, bool capped) {
-	
-		setMeshType(Mesh::TRI_MESH);
-		Number lastx = 0;
-		Number lastz = 0;
-		Number lastv = 0;		
-		for (int i=0 ; i < numSegments+1; i++) {
-			Number v = ((Number)i)/((Number)numSegments);
-			Number pos = ((PI*2.0)/((Number)numSegments)) * i;
-			Number x = sin(pos) * radius;
-			Number z = cos(pos) * radius;
-			
-			if(i > 0) {
-				Polygon *polygon = new Polygon();
-				polygon->addVertex(lastx,0,lastz,lastv,0);				
-				polygon->addVertex(x,0,z, v, 0);
-				polygon->addVertex(x,height,z, v, 1);				
-				addPolygon(polygon);							
-
-				polygon = new Polygon();	
-				polygon->addVertex(x,height,z, v, 1);							
-				polygon->addVertex(lastx,height,lastz, lastv, 1);
-				polygon->addVertex(lastx,0,lastz,lastv,0);												
-				addPolygon(polygon);	
-				
-				if(capped) {
-				polygon = new Polygon();	
-				polygon->addVertex(lastx,height,lastz, 0.5+(lastz/radius*0.5), 0.5+(lastx/radius*0.5));			
-				polygon->addVertex(x,height,z, 0.5+(z/radius*0.5), 0.5+(x/radius*0.5));														
-				polygon->addVertex(0,height,0,0.5,0.5);							
-				addPolygon(polygon);			
-
-				polygon = new Polygon();	
-				polygon->addVertex(lastx,0,lastz, 0.5+(lastz/radius*0.5), 0.5+(lastx/radius*0.5));						
-				polygon->addVertex(0,0,0,0.5,0.5);																																					
-				polygon->addVertex(x,0,z, 0.5+(z/radius*0.5), 0.5+(x/radius*0.5));								
-				addPolygon(polygon);			
-				}
-								
-			}
-			lastx = x;
-			lastz = z;			
-			lastv = v;
-		/*
-			Polygon *polygon = new Polygon();
-			polygon->addVertex(w,0,h, 1, 1);
-			polygon->addVertex(0,0,h, 1, 0);
-			polygon->addVertex(0,0,0,0,0);
-			polygon->addVertex(w,0,0,0,1);
-			addPolygon(polygon);			
-			*/
         }
-		
-		for(int i=0; i < polygons.size(); i++) {
-			for(int j=0; j < polygons[i]->getVertexCount(); j++) {
-//				polygons[i]->getVertex(j)->x = polygons[i]->getVertex(j)->x - (radius/2.0f);
-				polygons[i]->getVertex(j)->y = polygons[i]->getVertex(j)->y - (height/2.0f);
-//				polygons[i]->getVertex(j)->z = polygons[i]->getVertex(j)->z - (radius/2.0f);	
-			}
-		}
-		
-		
-		calculateNormals();
-		calculateTangents();
-		arrayDirtyMap[RenderDataArray::VERTEX_DATA_ARRAY] = true;		
-		arrayDirtyMap[RenderDataArray::COLOR_DATA_ARRAY] = true;				
-		arrayDirtyMap[RenderDataArray::TEXCOORD_DATA_ARRAY] = true;						
-		arrayDirtyMap[RenderDataArray::NORMAL_DATA_ARRAY] = true;										
-		arrayDirtyMap[RenderDataArray::TANGENT_DATA_ARRAY] = true;		
-	}
-	
-	void Mesh::createCone(Number height, Number radius, int numSegments) {
-	
-        setMeshType(Mesh::TRI_MESH);
-        
-        Number lastx = 0;
-		Number lasty = 0;
-		Number lastv = 0;
+    }
+    
+    for (int i=0 ; i < _segmentsH+1; i++) {
+        free(grid[i]);
+    }
+    free(grid);
+
+    calculateNormals();
+    calculateTangents();
+    arrayDirtyMap[RenderDataArray::VERTEX_DATA_ARRAY] = true;		
+    arrayDirtyMap[RenderDataArray::COLOR_DATA_ARRAY] = true;				
+    arrayDirtyMap[RenderDataArray::TEXCOORD_DATA_ARRAY] = true;						
+    arrayDirtyMap[RenderDataArray::NORMAL_DATA_ARRAY] = true;
+    arrayDirtyMap[RenderDataArray::TANGENT_DATA_ARRAY] = true;		
+}
+
+unsigned int Mesh::getVertexCount() {
+    return vertices.size();
+}
+
+void Mesh::createTorus(Number radius, Number tubeRadius, int rSegments, int tSegments) {
+
+    setMeshType(Mesh::TRI_MESH);
         
-        Polycode::Polygon *polygon;
-		for (int i=0 ; i < numSegments+1; i++) {
-			Number v = ((Number)i)/((Number)numSegments);
-			Number pos = ((PI*2.0)/((Number)numSegments)) * i;
-			Number x = sin(pos) * radius * 0.5;
-			Number y = cos(pos) * radius * 0.5;
-			
-            if(i > 0) {
-                
-                polygon = new Polygon();
-                polygon->addVertex(lastx,0, lasty, 0.5+(lasty/radius*0.5), 0.5+(lastx/radius*0.5))->setNormal(0.0, -1.0, 0.0);
-                polygon->addVertex(x,0,y, 0.5+(y/radius*0.5), 0.5+(x/radius*0.5))->setNormal(0.0, -1.0, 0.0);                
-                polygon->addVertex(0,height,0,0.5,0.5)->setNormal(0.0, -1.0, 0.0);
-                addPolygon(polygon);
-                
+    Vector3 **grid = (Vector3 **) malloc(sizeof(Vector3*) * rSegments);
+    for (int i=0 ; i < rSegments; i++) {
+        grid[i] = (Vector3*) malloc(sizeof(Vector3) * tSegments);		
+    }
+    
+    for (int i=0 ; i < rSegments; i++) {
+        for (int j = 0; j < tSegments; ++j) {
+            Number u = ((Number)i) / rSegments * 2.0 * PI;
+            Number v = ((Number)j) / tSegments * 2.0 * PI;	
+
+            grid[i][j] = Vector3((radius + tubeRadius*cos(v))*cos(u), tubeRadius*sin(v), (radius + tubeRadius*cos(v))*sin(u));							
+                                                
+        }
+    }	
+    
+    for (int i=0 ; i < rSegments; i++) {
+        for (int j = 0; j < tSegments; ++j) {
+
+            int ip = (i+1) % rSegments;
+            int jp = (j+1) % tSegments;
                 
-                polygon = new Polygon();
-                polygon->addVertex(0,0,0,0.5,0.5)->setNormal(0.0, -1.0, 0.0);
-                polygon->addVertex(x,0,y, 0.5+(y/radius*0.5), 0.5+(x/radius*0.5))->setNormal(0.0, -1.0, 0.0);
-                polygon->addVertex(lastx,0, lasty, 0.5+(lasty/radius*0.5), 0.5+(lastx/radius*0.5))->setNormal(0.0, -1.0, 0.0);
-                addPolygon(polygon);
-            }
-			lastx = x;
-			lastv = v;
-			lasty = y;
+            Vector3 a = grid[i ][j];
+            Vector3 b = grid[ip][j];
+            Vector3 c = grid[i ][jp];
+            Vector3 d = grid[ip][jp];
+
+            Vector2 uva = Vector2(((Number)i)     / ((Number)rSegments), ((Number)j)     / ((Number)tSegments));
+            Vector2 uvb = Vector2((((Number)i)+1.0) / ((Number)rSegments), ((Number)j)     / ((Number)tSegments));
+            Vector2 uvc = Vector2(((Number)i)    / ((Number)rSegments), (((Number)j)+1.0) / ((Number)tSegments));
+            Vector2 uvd = Vector2((((Number)i)+1.0) / ((Number)rSegments), (((Number)j)+1.0) / ((Number)tSegments));
+
+
+            addVertex(c.x, c.y, c.z, uvc.x ,uvc.y);
+            addVertex(b.x, b.y, b.z, uvb.x ,uvb.y);							
+            addVertex(a.x, a.y, a.z, uva.x ,uva.y);
+
+            addVertex(b.x, b.y, b.z, uvb.x ,uvb.y);
+            addVertex(c.x, c.y, c.z, uvc.x ,uvc.y);					
+            addVertex(d.x, d.y, d.z, uvd.x ,uvd.y);
         }
-		
-		for(int i=0; i < polygons.size(); i++) {
-			for(int j=0; j < polygons[i]->getVertexCount(); j++) {
-				polygons[i]->getVertex(j)->y = polygons[i]->getVertex(j)->y - (height/2.0f);
-			}
-		}
-		
-		calculateNormals();
-		calculateTangents();
-		arrayDirtyMap[RenderDataArray::VERTEX_DATA_ARRAY] = true;		
-		arrayDirtyMap[RenderDataArray::COLOR_DATA_ARRAY] = true;				
-		arrayDirtyMap[RenderDataArray::TEXCOORD_DATA_ARRAY] = true;
-		arrayDirtyMap[RenderDataArray::NORMAL_DATA_ARRAY] = true;
-		arrayDirtyMap[RenderDataArray::TANGENT_DATA_ARRAY] = true;			
-	
-	}
-
-	void Mesh::createBox(Number w, Number d, Number h) {
-        setMeshType(Mesh::TRI_MESH);
-        
-		Polygon *polygon = new Polygon();
-		polygon->addVertex(w,0,h, 1, 1);
-		polygon->addVertex(0,0,h, 1, 0);
-		polygon->addVertex(0,0,0,0,0);
-		addPolygon(polygon);
-        
-        polygon = new Polygon();
-        polygon->addVertex(w,0,h, 1, 1);
-		polygon->addVertex(0,0,0,0,0);
-		polygon->addVertex(w,0,0,0,1);
-		addPolygon(polygon);
-
-		polygon = new Polygon();
-		polygon->addVertex(w,d,h, 1, 1);
-		polygon->addVertex(w,d,0, 1, 0);
-		polygon->addVertex(0,d,0,0,0);
-        addPolygon(polygon);
-        
-		polygon = new Polygon();
-		polygon->addVertex(w,d,h, 1, 1);
-		polygon->addVertex(0,d,0,0,0);
-		polygon->addVertex(0,d,h,0,1);
-		addPolygon(polygon);
-
-		polygon = new Polygon();
-		polygon->addVertex(0,d,0,0,1);
-		polygon->addVertex(w,d,0, 1, 1);
-		polygon->addVertex(w,0,0, 1, 0);
-		addPolygon(polygon);
-
-        polygon = new Polygon();
-		polygon->addVertex(0,d,0,0,1);
-		polygon->addVertex(w,0,0, 1, 0);
-		polygon->addVertex(0,0,0,0,0);
-		addPolygon(polygon);
-
-		polygon = new Polygon();
-		polygon->addVertex(0,0,h,0,0);
-		polygon->addVertex(w,0,h, 1, 0);
-		polygon->addVertex(w,d,h, 1, 1);
-		addPolygon(polygon);
-
-        polygon = new Polygon();
-		polygon->addVertex(0,0,h,0,0);
-		polygon->addVertex(w,d,h, 1, 1);
-		polygon->addVertex(0,d,h,0,1);
-		addPolygon(polygon);
-
-		polygon = new Polygon();
-		polygon->addVertex(0,0,h,0,1);
-		polygon->addVertex(0,d,h, 1, 1);
-		polygon->addVertex(0,d,0, 1, 0);
-		addPolygon(polygon);
+    }
+    
+    for (int i=0 ; i < rSegments; i++) {
+        free(grid[i]);
+    }		
+    free(grid);
+    
+
+    calculateNormals();
+    calculateTangents();
+    arrayDirtyMap[RenderDataArray::VERTEX_DATA_ARRAY] = true;		
+    arrayDirtyMap[RenderDataArray::COLOR_DATA_ARRAY] = true;				
+    arrayDirtyMap[RenderDataArray::TEXCOORD_DATA_ARRAY] = true;						
+    arrayDirtyMap[RenderDataArray::NORMAL_DATA_ARRAY] = true;										
+    arrayDirtyMap[RenderDataArray::TANGENT_DATA_ARRAY] = true;				
+}
+
+void Mesh::createCylinder(Number height, Number radius, int numSegments, bool capped) {
+
+    setMeshType(Mesh::TRI_MESH);
+    Number lastx = 0;
+    Number lastz = 0;
+    Number lastv = 0;		
+    for (int i=0 ; i < numSegments+1; i++) {
+        Number v = ((Number)i)/((Number)numSegments);
+        Number pos = ((PI*2.0)/((Number)numSegments)) * i;
+        Number x = sin(pos) * radius;
+        Number z = cos(pos) * radius;
         
-		polygon = new Polygon();
-		polygon->addVertex(0,0,h,0,1);
-		polygon->addVertex(0,d,0, 1, 0);
-		polygon->addVertex(0,0,0,0,0);
-		addPolygon(polygon);
-
-		polygon = new Polygon();
-		polygon->addVertex(w,0,h,0,1);
-		polygon->addVertex(w,0,0, 1, 1);
-		polygon->addVertex(w,d,0, 1, 0);
-        addPolygon(polygon);
+        if(i > 0) {
+            addVertex(lastx,0,lastz,lastv,0);				
+            addVertex(x,0,z, v, 0);
+            addVertex(x,height,z, v, 1);
+
+            addVertex(x,height,z, v, 1);							
+            addVertex(lastx,height,lastz, lastv, 1);
+            addVertex(lastx,0,lastz,lastv,0);
+            
+            if(capped) {
+                addVertex(lastx,height,lastz, 0.5+(lastz/radius*0.5), 0.5+(lastx/radius*0.5));			
+                addVertex(x,height,z, 0.5+(z/radius*0.5), 0.5+(x/radius*0.5));
+                addVertex(0,height,0,0.5,0.5);
+
+                addVertex(lastx,0,lastz, 0.5+(lastz/radius*0.5), 0.5+(lastx/radius*0.5));						
+                addVertex(0,0,0,0.5,0.5);
+                addVertex(x,0,z, 0.5+(z/radius*0.5), 0.5+(x/radius*0.5));
+            }
+                            
+        }
+        lastx = x;
+        lastz = z;			
+        lastv = v;
+    }
+    
+    for(int i=0; i < vertices.size(); i++) {
+        vertices[i]->y = vertices[i]->y - (height/2.0f);
+    }
+    
+    
+    calculateNormals();
+    calculateTangents();
+    arrayDirtyMap[RenderDataArray::VERTEX_DATA_ARRAY] = true;		
+    arrayDirtyMap[RenderDataArray::COLOR_DATA_ARRAY] = true;				
+    arrayDirtyMap[RenderDataArray::TEXCOORD_DATA_ARRAY] = true;						
+    arrayDirtyMap[RenderDataArray::NORMAL_DATA_ARRAY] = true;										
+    arrayDirtyMap[RenderDataArray::TANGENT_DATA_ARRAY] = true;		
+}
+
+void Mesh::createCone(Number height, Number radius, int numSegments) {
+
+    setMeshType(Mesh::TRI_MESH);
+    
+    Number lastx = 0;
+    Number lasty = 0;
+    Number lastv = 0;
+    
+    for (int i=0 ; i < numSegments+1; i++) {
+        Number v = ((Number)i)/((Number)numSegments);
+        Number pos = ((PI*2.0)/((Number)numSegments)) * i;
+        Number x = sin(pos) * radius * 0.5;
+        Number y = cos(pos) * radius * 0.5;
         
-        polygon = new Polygon();
-		polygon->addVertex(w,0,h,0,1);
-		polygon->addVertex(w,d,0, 1, 0);
-		polygon->addVertex(w,d,h,0,0);
-		addPolygon(polygon);
-
-		for(int i=0; i < polygons.size(); i++) {
-			for(int j=0; j < polygons[i]->getVertexCount(); j++) {
-				polygons[i]->getVertex(j)->x = polygons[i]->getVertex(j)->x - (w/2.0f);
-				polygons[i]->getVertex(j)->y = polygons[i]->getVertex(j)->y - (d/2.0f);
-				polygons[i]->getVertex(j)->z = polygons[i]->getVertex(j)->z - (h/2.0f);	
-			}
-		}
-
-		calculateNormals(false);
-		calculateTangents();
-		arrayDirtyMap[RenderDataArray::VERTEX_DATA_ARRAY] = true;		
-		arrayDirtyMap[RenderDataArray::COLOR_DATA_ARRAY] = true;				
-		arrayDirtyMap[RenderDataArray::TEXCOORD_DATA_ARRAY] = true;						
-		arrayDirtyMap[RenderDataArray::NORMAL_DATA_ARRAY] = true;		
-		arrayDirtyMap[RenderDataArray::TANGENT_DATA_ARRAY] = true;									
-	}
-	
-	void Mesh::dirtyArray(unsigned int arrayIndex) {
-		if(arrayIndex < 16)
-			arrayDirtyMap[arrayIndex] = true;				
-	}
-	
-	void Mesh::dirtyArrays() {
-		for(int i=0; i < 16; i++) {
-			arrayDirtyMap[i] = true;
-		}
-	}
-	
-	
-	void Mesh::useVertexNormals(bool val) {
-		for(int i =0; i < polygons.size(); i++) {
-			polygons[i]->useVertexNormals = val;
-		}		
-		arrayDirtyMap[RenderDataArray::NORMAL_DATA_ARRAY] = true;										
-	}
-	
-	vector<Polygon*> Mesh::getConnectedFaces(Vertex *v) {
-		vector<Polygon*> retVec;	
-		for(int i=0; i < polygons.size(); i++) {
-			bool pushed = false;		
-			for(int j=0; j < polygons[i]->getVertexCount(); j++) {		
-				Vertex *vn =  polygons[i]->getVertex(j);			
-				if(*vn == *v) {
-					if(!pushed) {
-						retVec.push_back(polygons[i]);
-						pushed = true;
-					}
-				}
-			}
-		}
-		return retVec;
-	}
-	
-	void Mesh::calculateTangents() {
-		for(int i =0; i < polygons.size(); i++) {
-			polygons[i]->calculateTangent();
-		}		
-
-		for(int i=0; i < polygons.size(); i++) {
-			for(int j=0; j < polygons[i]->getVertexCount(); j++) {		
-				Vertex *v =  polygons[i]->getVertex(j);
-
-				Vector3 tangent;		
-				vector<Polygon*> connectedFaces = getConnectedFaces(v);
-				int numConnected = connectedFaces.size();
-				if(numConnected > 2)
-					numConnected = 2;
-				for(int k=0; k < numConnected; k++) {					
-					tangent += connectedFaces[k]->getFaceTangent();
-				}						
-				tangent = tangent / numConnected;
-				tangent.Normalize();
-				v->tangent = tangent;
-			}
-		}		
-
-		arrayDirtyMap[RenderDataArray::TANGENT_DATA_ARRAY] = true;		
-	}
-	
-	void Mesh::calculateNormals(bool smooth, Number smoothAngle) {
-		for(int i =0; i < polygons.size(); i++) {
-			polygons[i]->calculateNormal();
-		}	
-		
-		if(smooth) {
-			for(int i=0; i < polygons.size(); i++) {
-				for(int j=0; j < polygons[i]->getVertexCount(); j++) {		
-					Vertex *v =  polygons[i]->getVertex(j);
-
-					Vector3 normal;		
-					vector<Polygon*> connectedFaces = getConnectedFaces(v);
-					for(int k=0; k < connectedFaces.size(); k++) {					
-						normal += connectedFaces[k]->getFaceNormal();
-					}
-					if(connectedFaces.size() > 0) {
-						normal = normal / connectedFaces.size();
-					}
-					normal.Normalize();
-					v->setNormal(normal.x, normal.y, normal.z);
-				}
-			}
-		
-		}
-		
-		arrayDirtyMap[RenderDataArray::NORMAL_DATA_ARRAY] = true;		
-	}
-	
-	int Mesh::getMeshType() {
-		return meshType;
-	}
-	
-	void Mesh::setMeshType(int newType) {
-		meshType = newType;
-	}
-	
-	void Mesh::addPolygon(Polygon *newPolygon) {
-		polygons.push_back(newPolygon);
-		arrayDirtyMap[RenderDataArray::VERTEX_DATA_ARRAY] = true;		
-		arrayDirtyMap[RenderDataArray::COLOR_DATA_ARRAY] = true;				
-		arrayDirtyMap[RenderDataArray::TEXCOORD_DATA_ARRAY] = true;		
-		arrayDirtyMap[RenderDataArray::NORMAL_DATA_ARRAY] = true;		
-		arrayDirtyMap[RenderDataArray::TANGENT_DATA_ARRAY] = true;								
-	}
-	
-	
-	unsigned int Mesh::getPolygonCount() {
-		return polygons.size();
-	}
-	
-	Polygon *Mesh::getPolygon(unsigned int index) {
-		return polygons[index];
-	}
+        if(i > 0) {
+            
+            addVertex(lastx,0, lasty, 0.5+(lasty/radius*0.5), 0.5+(lastx/radius*0.5))->setNormal(0.0, -1.0, 0.0);
+            addVertex(x,0,y, 0.5+(y/radius*0.5), 0.5+(x/radius*0.5))->setNormal(0.0, -1.0, 0.0);                
+            addVertex(0,height,0,0.5,0.5)->setNormal(0.0, -1.0, 0.0);
+            
+            addVertex(0,0,0,0.5,0.5)->setNormal(0.0, -1.0, 0.0);
+            addVertex(x,0,y, 0.5+(y/radius*0.5), 0.5+(x/radius*0.5))->setNormal(0.0, -1.0, 0.0);
+            addVertex(lastx,0, lasty, 0.5+(lasty/radius*0.5), 0.5+(lastx/radius*0.5))->setNormal(0.0, -1.0, 0.0);
+        }
+        lastx = x;
+        lastv = v;
+        lasty = y;
+    }
+    
+    for(int i=0; i < vertices.size(); i++) {
+        vertices[i]->y = vertices[i]->y - (height/2.0f);
+    }
+    
+    calculateNormals();
+    calculateTangents();
+    arrayDirtyMap[RenderDataArray::VERTEX_DATA_ARRAY] = true;		
+    arrayDirtyMap[RenderDataArray::COLOR_DATA_ARRAY] = true;				
+    arrayDirtyMap[RenderDataArray::TEXCOORD_DATA_ARRAY] = true;
+    arrayDirtyMap[RenderDataArray::NORMAL_DATA_ARRAY] = true;
+    arrayDirtyMap[RenderDataArray::TANGENT_DATA_ARRAY] = true;			
+
+}
+
+void Mesh::createBox(Number w, Number d, Number h) {
+    setMeshType(Mesh::TRI_MESH);
+    
+    addVertex(w,0,h, 1, 1);
+    addVertex(0,0,h, 1, 0);
+    addVertex(0,0,0,0,0);
+    
+    addVertex(w,0,h, 1, 1);
+    addVertex(0,0,0,0,0);
+    addVertex(w,0,0,0,1);
+
+    addVertex(w,d,h, 1, 1);
+    addVertex(w,d,0, 1, 0);
+    addVertex(0,d,0,0,0);
+
+    addVertex(w,d,h, 1, 1);
+    addVertex(0,d,0,0,0);
+    addVertex(0,d,h,0,1);
+
+    addVertex(0,d,0,0,1);
+    addVertex(w,d,0, 1, 1);
+    addVertex(w,0,0, 1, 0);
+
+    addVertex(0,d,0,0,1);
+    addVertex(w,0,0, 1, 0);
+    addVertex(0,0,0,0,0);
+
+    addVertex(0,0,h,0,0);
+    addVertex(w,0,h, 1, 0);
+    addVertex(w,d,h, 1, 1);
+
+    addVertex(0,0,h,0,0);
+    addVertex(w,d,h, 1, 1);
+    addVertex(0,d,h,0,1);
+
+    addVertex(0,0,h,0,1);
+    addVertex(0,d,h, 1, 1);
+    addVertex(0,d,0, 1, 0);
+
+    addVertex(0,0,h,0,1);
+    addVertex(0,d,0, 1, 0);
+    addVertex(0,0,0,0,0);
+
+    addVertex(w,0,h,0,1);
+    addVertex(w,0,0, 1, 1);
+    addVertex(w,d,0, 1, 0);
+
+    addVertex(w,0,h,0,1);
+    addVertex(w,d,0, 1, 0);
+    addVertex(w,d,h,0,0);
+
+    for(int i=0; i < vertices.size(); i++) {
+        vertices[i]->x = vertices[i]->x - (w/2.0f);
+        vertices[i]->y = vertices[i]->y - (d/2.0f);
+        vertices[i]->z = vertices[i]->z - (h/2.0f);
+    }
+
+    calculateNormals(false);
+    calculateTangents();
+    arrayDirtyMap[RenderDataArray::VERTEX_DATA_ARRAY] = true;		
+    arrayDirtyMap[RenderDataArray::COLOR_DATA_ARRAY] = true;				
+    arrayDirtyMap[RenderDataArray::TEXCOORD_DATA_ARRAY] = true;						
+    arrayDirtyMap[RenderDataArray::NORMAL_DATA_ARRAY] = true;		
+    arrayDirtyMap[RenderDataArray::TANGENT_DATA_ARRAY] = true;									
+}
+
+void Mesh::dirtyArray(unsigned int arrayIndex) {
+    if(arrayIndex < 16)
+        arrayDirtyMap[arrayIndex] = true;				
+}
+
+void Mesh::dirtyArrays() {
+    for(int i=0; i < 16; i++) {
+        arrayDirtyMap[i] = true;
+    }
+}
+
+Vertex *Mesh::getVertex(unsigned int index) const {
+    return vertices[index];
+}
+
+void Mesh::calculateTangents() {
+
+    arrayDirtyMap[RenderDataArray::TANGENT_DATA_ARRAY] = true;		
+}
+
+void Mesh::calculateNormals(bool smooth, Number smoothAngle) {
+    
+    int polySize = 3;
+    if(meshType == Mesh::QUAD_MESH) {
+        polySize = 4;
+    }
+    
+    for(int i=0; i < vertices.size(); i++) {
+        vertices[i]->normal = Vector3();
+    }
+
+    for(int i=0; i+2 < vertices.size(); i += polySize) {
+        const Vector3 e1 = *(vertices[i]) - *(vertices[i+1]);
+        const Vector3 e2 = *(vertices[i+2]) - *(vertices[i+1]);
+        const Vector3 no = e1.crossProduct(e2);
+            
+        vertices[i]->normal -= no;
+        vertices[i+1]->normal -= no;
+        vertices[i+2]->normal -= no;
+    }
+    
+    arrayDirtyMap[RenderDataArray::NORMAL_DATA_ARRAY] = true;		
+}
+
+int Mesh::getMeshType() {
+    return meshType;
+}
+
+void Mesh::setMeshType(int newType) {
+    meshType = newType;
 }

Core/Contents/Source/PolyParticleEmitter.cpp

@@ -113,7 +113,6 @@ void SceneParticleEmitter::rebuildParticles() {
         case PARTICLE_TYPE_POINT:
         {
             mesh->setMeshType(Mesh::POINT_MESH);
-            Polycode::Polygon *poly = new Polycode::Polygon();
             Matrix4 inverseMatrix = systemTrasnformMatrix.Inverse();
             for(int i=0; i < particles.size(); i++) {
                 if(particles[i].lifetime > lifetime) {
@@ -123,9 +122,8 @@ void SceneParticleEmitter::rebuildParticles() {
                 if(particlesInWorldSpace) {
                     vertexPosition = inverseMatrix * vertexPosition;
                 }
-                poly->addVertex(vertexPosition.x, vertexPosition.y, vertexPosition.z, 0.5, 0.5)->vertexColor = particles[i].color;
+                mesh->addVertex(vertexPosition.x, vertexPosition.y, vertexPosition.z, 0.5, 0.5)->vertexColor = particles[i].color;
             }
-            mesh->addPolygon(poly);
         }
         break;
         case PARTICLE_TYPE_QUAD:
@@ -145,7 +143,6 @@ void SceneParticleEmitter::rebuildParticles() {
                 vertexColor = particles[i].color;
                 finalParticleSize = particleSize * particles[i].scale;
                 
-                Polycode::Polygon *poly = new Polycode::Polygon();
                 Vector3 particlePosition = particles[i].position;
                 if(particlesInWorldSpace) {
                     particlePosition = inverseMatrix * particlePosition;
@@ -154,25 +151,22 @@ void SceneParticleEmitter::rebuildParticles() {
                 Vector3 vertexPosition = Vector3(-finalParticleSize, -finalParticleSize, 0.0);
                 vertexPosition = q.applyTo(vertexPosition);
                 vertexPosition = cameraMatrix.rotateVector(vertexPosition);
-                poly->addVertex(particlePosition.x+vertexPosition.x, particlePosition.y+vertexPosition.y, particlePosition.z+vertexPosition.z, 0.0, 0.0)->vertexColor = vertexColor;
+                mesh->addVertex(particlePosition.x+vertexPosition.x, particlePosition.y+vertexPosition.y, particlePosition.z+vertexPosition.z, 0.0, 0.0)->vertexColor = vertexColor;
                 
                 vertexPosition = Vector3(finalParticleSize, -finalParticleSize, 0.0);
                 vertexPosition = q.applyTo(vertexPosition);
                 vertexPosition = cameraMatrix.rotateVector(vertexPosition);
-                poly->addVertex(particlePosition.x+vertexPosition.x, particlePosition.y+vertexPosition.y, particlePosition.z+vertexPosition.z, 1.0, 0.0)->vertexColor = vertexColor;
+                mesh->addVertex(particlePosition.x+vertexPosition.x, particlePosition.y+vertexPosition.y, particlePosition.z+vertexPosition.z, 1.0, 0.0)->vertexColor = vertexColor;
 
                 vertexPosition = Vector3(finalParticleSize, finalParticleSize, 0.0);
                 vertexPosition = q.applyTo(vertexPosition);
                 vertexPosition = cameraMatrix.rotateVector(vertexPosition);
-                poly->addVertex(particlePosition.x+vertexPosition.x, particlePosition.y+vertexPosition.y, particlePosition.z+vertexPosition.z, 1.0, 1.0)->vertexColor = vertexColor;
+                mesh->addVertex(particlePosition.x+vertexPosition.x, particlePosition.y+vertexPosition.y, particlePosition.z+vertexPosition.z, 1.0, 1.0)->vertexColor = vertexColor;
 
                 vertexPosition = Vector3(-finalParticleSize, finalParticleSize, 0.0);
                 vertexPosition = q.applyTo(vertexPosition);
                 vertexPosition = cameraMatrix.rotateVector(vertexPosition);
-                poly->addVertex(particlePosition.x+vertexPosition.x, particlePosition.y+vertexPosition.y, particlePosition.z+vertexPosition.z, 0.0, 1.0)->vertexColor = vertexColor;
-
-                
-                mesh->addPolygon(poly);
+                mesh->addVertex(particlePosition.x+vertexPosition.x, particlePosition.y+vertexPosition.y, particlePosition.z+vertexPosition.z, 0.0, 1.0)->vertexColor = vertexColor;
 
             }
         }

Core/Contents/Source/PolyPolygon.cpp

@@ -1,169 +0,0 @@
-/*
- Copyright (C) 2011 by Ivan Safrin
- 
- Permission is hereby granted, free of charge, to any person obtaining a copy
- of this software and associated documentation files (the "Software"), to deal
- in the Software without restriction, including without limitation the rights
- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- copies of the Software, and to permit persons to whom the Software is
- furnished to do so, subject to the following conditions:
- 
- The above copyright notice and this permission notice shall be included in
- all copies or substantial portions of the Software.
- 
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- THE SOFTWARE.
-*/
-
-#include "PolyPolygon.h"
-#include "PolyVector2.h"
-#include "PolyVertex.h"
-
-using std::min;
-using std::max;
-
-namespace Polycode {
-
-Polygon::Polygon()  : useVertexNormals(false), vertexCount(0) {
-	useVertexNormals = true;	
-}
-
-Polygon::~Polygon() {
-	
-	for(int i=0; i < vertices.size(); i++) {	
-		delete vertices[i];
-	}
-	vertices.clear();
-}
-	
-void Polygon::flipUVY() {
-	for(int i=0; i < vertices.size(); i++) {
-		Vector2 coord = vertices[i]->getTexCoord();
-		vertices[i]->setTexCoord(coord.x, 1-coord.y);
-	}
-}
-
-unsigned int Polygon::getVertexCount() {
-	return vertices.size();
-}
-
-Vertex *Polygon::getVertex(unsigned int index) {
-	return vertices[index];
-}
-
-Vector3 Polygon::getFaceTangent() {
-	return tangent;
-}
-
-Vector3 Polygon::getFaceNormal() {
-/*
-	Vector3 fNormal;
-	fNormal.x = (vertices[2]->z-vertices[1]->z)*(vertices[2]->y-vertices[1]->y)-(vertices[0]->y-vertices[1]->y)*(vertices[2]->z-vertices[1]->z);
-	fNormal.y = (vertices[0]->x-vertices[1]->x)*(vertices[2]->z-vertices[1]->z)-(vertices[0]->z-vertices[1]->z)*(vertices[2]->x-vertices[1]->x);
-	fNormal.z = (vertices[0]->y-vertices[1]->y)*(vertices[2]->x-vertices[1]->x)-(vertices[0]->x-vertices[1]->x)*(vertices[2]->y-vertices[1]->y);
-	fNormal.Normalize();	
-	return fNormal;
-	*/
-	return normal;
-}
-
-Rectangle Polygon::getBounds2D() {
-	Rectangle retBox;
-	retBox.x = 1000000000;
-	retBox.y = 1000000000;
-	for(int i=0; i < vertices.size(); i++) {
-			retBox.x = min(retBox.x,vertices[i]->x);
-			retBox.y = min(retBox.y,vertices[i]->y);
-	}
-	for(int i=0; i < vertices.size(); i++) {
-			retBox.w = max(retBox.w, vertices[i]->x - retBox.x);
-			retBox.h = max(retBox.h, vertices[i]->y - retBox.y);
-	}
-	
-	return retBox;
-}
-	
-void Polygon::removeVertex(int index) {
-	Vertex *vert = vertices[index];
-	vertices.erase(vertices.begin() + index);
-	delete vert;
-}
-
-void Polygon::setNormal(Vector3 normal) {
-	this->normal = normal;
-}	
-
-void Polygon::calculateNormal() {
-	if(vertices.size() < 3)
-		return;
-
-//	normal->x = (vertices[2]->z-vertices[1]->z)*(vertices[2]->y-vertices[1]->y)-(vertices[0]->y-vertices[1]->y)*(vertices[2]->z-vertices[1]->z);
-//	normal->y = (vertices[0]->x-vertices[1]->x)*(vertices[2]->z-vertices[1]->z)-(vertices[0]->z-vertices[1]->z)*(vertices[2]->x-vertices[1]->x);
-//	normal->z = (vertices[0]->y-vertices[1]->y)*(vertices[2]->x-vertices[1]->x)-(vertices[0]->x-vertices[1]->x)*(vertices[2]->y-vertices[1]->y);
-
-	normal = (*vertices[0] - *vertices[1]).crossProduct((*vertices[1] - *vertices[2]));
-	
-	normal.Normalize();
-	
-	for(int i=0; i < vertices.size(); i++) {
-		vertices[i]->normal.x = normal.x;
-		vertices[i]->normal.y = normal.y;
-		vertices[i]->normal.z = normal.z;		
-	}
-}
-
-void Polygon::calculateTangent() {
-	if(vertices.size() < 3)
-		return;
-		
-	
-	Vector3 side0 = *vertices[0] - *vertices[1];
-	Vector3 side1 = *vertices[2] - *vertices[0];
-	Vector3 normal = side1.crossProduct(side0);
-	normal.Normalize();
-	Number deltaV0 = vertices[0]->texCoord.y - vertices[1]->texCoord.y;
-	Number deltaV1 = vertices[2]->texCoord.y - vertices[0]->texCoord.y;
-	tangent = side0 * deltaV1 - side1 * deltaV0;	
-	tangent.Normalize();
-	
-	Number deltaU0 = vertices[0]->texCoord.x - vertices[1]->texCoord.x;
-	Number deltaU1 = vertices[2]->texCoord.x - vertices[0]->texCoord.x;
-	Vector3 binormal = side0 * deltaU1 - side1 * deltaU0;
-	binormal.Normalize();
-	Vector3 tangentCross = tangent.crossProduct(binormal);
-
-	if (tangentCross.dot(normal) < 0.0f) {
-		tangent = tangent * -1;
-	}
-
-	for(int i=0; i < vertices.size(); i++) {		
-		vertices[i]->tangent.x = tangent.x;
-		vertices[i]->tangent.y = tangent.y;
-		vertices[i]->tangent.z = tangent.z;		
-	}
-	
-	
-}
-
-Vertex *Polygon::addVertex(Number x, Number y, Number z) {
-	Vertex *vertex = new Vertex(x,y,z);
-	vertices.push_back(vertex);
-	return vertex;
-}
-
-void Polygon::addVertex(Vertex *vertex) {
-	vertices.push_back(vertex);
-}
-
-Vertex *Polygon::addVertex(Number x, Number y, Number z, Number u, Number v) {
-	Vertex *vertex = new Vertex(x,y,z,u,v);
-	vertices.push_back(vertex);
-	return vertex;
-}
-
-}

Core/Contents/Source/PolyRay.cpp

@@ -55,17 +55,13 @@ Vector3 Ray::planeIntersectPoint(const Vector3 &planeNormal, Number planeDistanc
 	 return origin + direction * (-distanceToOrigin / direction.dot(planeNormal));
 }
 
-bool Ray::polygonIntersect(Polycode::Polygon *polygon) const {
+bool Ray::polygonIntersect(Vertex *v1, Vertex *v2, Vertex *v3) const {
 
-	if(polygon->getVertexCount() != 3) {
-		return false;
-	}
-    
-	Number t,u,v;
+    Number t,u,v;
 	t = 0; u = 0; v = 0;
 
-	Vector3 edge1 = (*(Vector3*)polygon->getVertex(1)) - (*(Vector3*)polygon->getVertex(2));
-	Vector3 edge2 = (*(Vector3*)polygon->getVertex(0)) - (*(Vector3*)polygon->getVertex(2));
+	Vector3 edge1 = (*(Vector3*)v2) - (*(Vector3*)v3);
+	Vector3 edge2 = (*(Vector3*)v1) - (*(Vector3*)v3);
 
 	Vector3 tvec, pvec, qvec;
 	Number det, inv_det;
@@ -78,7 +74,7 @@ bool Ray::polygonIntersect(Polycode::Polygon *polygon) const {
 
 	inv_det = 1.0f / det;
 
-	tvec = origin - (*(Vector3*)polygon->getVertex(2));
+	tvec = origin - (*(Vector3*)v3);
 
 	u = tvec.dot(pvec) * inv_det;
 	if (u < -0.001f || u > 1.001f)

Core/Contents/Source/PolySceneImage.cpp

@@ -22,7 +22,6 @@
 
 #include "PolySceneImage.h"
 #include "PolyMesh.h"
-#include "PolyPolygon.h"
 #include "PolyTexture.h"
 #include "PolyVertex.h"
 
@@ -84,7 +83,6 @@ void SceneImage::applyClone(Entity *clone, bool deepClone, bool ignoreEditorOnly
 }
 
 void SceneImage::setImageCoordinates(Number x, Number y, Number width, Number height, Number realWidth, Number realHeight) {
-	Vertex *vertex;
 	
 	Number pixelSizeX = 1/imageWidth;
 	Number pixelSizeY = 1/imageHeight;
@@ -104,18 +102,10 @@ void SceneImage::setImageCoordinates(Number x, Number y, Number width, Number he
 	Number wFloat = width * pixelSizeX;
 	Number hFloat = height * pixelSizeY;
 
-	Polygon *imagePolygon = mesh->getPolygon(0);	
-	vertex = imagePolygon->getVertex(0);
-	vertex->setTexCoord(xFloat, yFloat - hFloat);
-
-	vertex = imagePolygon->getVertex(1);
-	vertex->setTexCoord(xFloat + wFloat, yFloat - hFloat);
-
-	vertex = imagePolygon->getVertex(2);
-	vertex->setTexCoord(xFloat + wFloat, yFloat);
-
-	vertex = imagePolygon->getVertex(3);		
-	vertex->setTexCoord(xFloat, yFloat);
+    mesh->getVertex(0)->setTexCoord(xFloat, yFloat - hFloat);
+    mesh->getVertex(1)->setTexCoord(xFloat + wFloat, yFloat - hFloat);
+    mesh->getVertex(2)->setTexCoord(xFloat + wFloat, yFloat);
+    mesh->getVertex(3)->setTexCoord(xFloat, yFloat);
 
 	mesh->arrayDirtyMap[RenderDataArray::VERTEX_DATA_ARRAY] = true;
 	mesh->arrayDirtyMap[RenderDataArray::TEXCOORD_DATA_ARRAY] = true;

Core/Contents/Source/PolySceneLabel.cpp

@@ -25,7 +25,6 @@
 #include "PolyFontManager.h"
 #include "PolyLabel.h"
 #include "PolyMesh.h"
-#include "PolyPolygon.h"
 #include "PolyRenderer.h"
 #include "PolyMaterialManager.h"
 

Core/Contents/Source/PolySceneLine.cpp

@@ -22,7 +22,6 @@
 
 #include "PolySceneLine.h"
 #include "PolyRenderer.h"
-#include "PolyPolygon.h"
 
 using namespace Polycode;
 
@@ -43,11 +42,9 @@ SceneLine::SceneLine(Entity *ent1, Entity *ent2) : SceneMesh(Mesh::LINE_MESH) {
 
 }
 
-void SceneLine::initLine() { 
-	Polygon *poly = new Polygon();
-	poly->addVertex(0,0,0,0,0);
-	poly->addVertex(0,0,0,1,0);	
-	mesh->addPolygon(poly);
+void SceneLine::initLine() {
+	mesh->addVertex(0,0,0,0,0);
+	mesh->addVertex(0,0,0,1,0);
 	mesh->arrayDirtyMap[RenderDataArray::TEXCOORD_DATA_ARRAY] = true;		
 }
 
@@ -74,13 +71,13 @@ void SceneLine::Update(){
 	if(ent1 != NULL && ent2 != NULL) {
 		v1 = ent1->getConcatenatedMatrix().getPosition();
 		v2 = ent2->getConcatenatedMatrix().getPosition();
-        mesh->getPolygon(0)->getVertex(0)->set(v1.x,v1.y,v1.z);
-        mesh->getPolygon(0)->getVertex(1)->set(v2.x,v2.y,v2.z);
+        mesh->getVertex(0)->set(v1.x,v1.y,v1.z);
+        mesh->getVertex(1)->set(v2.x,v2.y,v2.z);
 	} else {
 		v1 = start;
 		v2 = end;
-        mesh->getPolygon(0)->getVertex(0)->set(v1.x,v1.y*yAdjust,v1.z);
-        mesh->getPolygon(0)->getVertex(1)->set(v2.x,v2.y*yAdjust,v2.z);
+        mesh->getVertex(0)->set(v1.x,v1.y*yAdjust,v1.z);
+        mesh->getVertex(1)->set(v2.x,v2.y*yAdjust,v2.z);
 	}
 	
 	mesh->arrayDirtyMap[RenderDataArray::VERTEX_DATA_ARRAY] = true;

Core/Contents/Source/PolySceneMesh.cpp

@@ -24,7 +24,6 @@
 #include "PolyCoreServices.h"
 #include "PolyBone.h"
 #include "PolyMaterial.h"
-#include "PolyPolygon.h"
 #include "PolyRenderer.h"
 #include "PolyMaterial.h"
 #include "PolyMesh.h"
@@ -179,16 +178,12 @@ void SceneMesh::loadSkeleton(const String& fileName) {
 
 void SceneMesh::setSkeleton(Skeleton *skeleton) {
 	this->skeleton = skeleton;
-	for(int i=0; i < mesh->getPolygonCount(); i++) {
-		Polygon *polygon = mesh->getPolygon(i);
-		unsigned int vCount = polygon->getVertexCount();
-		for(int j=0; j < vCount; j++) {
-			Vertex *vertex = polygon->getVertex(j);
-			for(int k=0; k < vertex->getNumBoneAssignments(); k++) {
-				vertex->getBoneAssignment(k)->bone = skeleton->getBone(vertex->getBoneAssignment(k)->boneID);
-			}
-		}
-	}	
+    for(int i=0; i < mesh->getVertexCount(); i++) {
+        Vertex *vertex = mesh->getVertex(i);
+        for(int j=0; j < vertex->getNumBoneAssignments(); j++) {
+            vertex->getBoneAssignment(j)->bone = skeleton->getBone(vertex->getBoneAssignment(j)->boneID);
+        }
+    }
 }
 
 void SceneMesh::setLineWidth(Number newWidth) {
@@ -207,58 +202,54 @@ void SceneMesh::renderMeshLocally() {
 	Renderer *renderer = CoreServices::getInstance()->getRenderer();
 	
 	if(skeleton) {	
-		for(int i=0; i < mesh->getPolygonCount(); i++) {
-			Polygon *polygon = mesh->getPolygon(i);			
-			unsigned int vCount = polygon->getVertexCount();			
-			for(int j=0; j < vCount; j++) {
-				Vertex *vert = polygon->getVertex(j);
-				Vector3 norm;
-				
-					Vector3 aPos = vert->restPosition;
-					Vector3 tPos;
-
-					Number mult = 1;					
-/*				
-					Number mult = 0;
-					for(int b =0; b < vert->getNumBoneAssignments(); b++) {
-						BoneAssignment *bas = vert->getBoneAssignment(b);
-						mult += bas->weight;
-					}
-					mult = 1.0f/mult;
+		for(int i=0; i < mesh->getVertexCount(); i++) {
+            Vertex *vert = mesh->getVertex(i);
+            Vector3 norm;
+            
+            Vector3 aPos = vert->restPosition;
+            Vector3 tPos;
+
+            Number mult = 1;					
+/*
+            Number mult = 0;
+            for(int b =0; b < vert->getNumBoneAssignments(); b++) {
+                BoneAssignment *bas = vert->getBoneAssignment(b);
+                mult += bas->weight;
+            }
+            mult = 1.0f/mult;
 */				
-					for(int b =0; b < vert->getNumBoneAssignments(); b++) {
-						BoneAssignment *bas = vert->getBoneAssignment(b);
-						Bone *bone = bas->bone;
-						if(bone) {
-							
-							Matrix4 restMatrix = bone->getRestMatrix();
-							Matrix4 finalMatrix = bone->getFinalMatrix();
-							
-							Vector3 vec = restMatrix * aPos;
-							tPos += finalMatrix * vec * (bas->weight*mult);
-							
-							Vector3 nvec = vert->restNormal;
-							nvec = restMatrix.rotateVector(nvec);
-							nvec = finalMatrix.rotateVector(nvec);
-							
-							norm += nvec * (bas->weight*mult);
-						}
-					}					
-					
-				
-					vert->x = tPos.x;
-					vert->y = tPos.y;
-					vert->z = tPos.z;				
-				
-					norm.Normalize();
-					vert->setNormal(norm.x, norm.y, norm.z);
-				
-			}
-		}
-		mesh->arrayDirtyMap[RenderDataArray::VERTEX_DATA_ARRAY] = true;		
-		mesh->arrayDirtyMap[RenderDataArray::NORMAL_DATA_ARRAY] = true;	
-		mesh->arrayDirtyMap[RenderDataArray::TANGENT_DATA_ARRAY] = true;				
-	}
+            for(int b =0; b < vert->getNumBoneAssignments(); b++) {
+                BoneAssignment *bas = vert->getBoneAssignment(b);
+                Bone *bone = bas->bone;
+                if(bone) {
+                    
+                    Matrix4 restMatrix = bone->getRestMatrix();
+                    Matrix4 finalMatrix = bone->getFinalMatrix();
+                    
+                    Vector3 vec = restMatrix * aPos;
+                    tPos += finalMatrix * vec * (bas->weight*mult);
+                    
+                    Vector3 nvec = vert->restNormal;
+                    nvec = restMatrix.rotateVector(nvec);
+                    nvec = finalMatrix.rotateVector(nvec);
+                    
+                    norm += nvec * (bas->weight*mult);
+                }
+            }					
+            
+        
+            vert->x = tPos.x;
+            vert->y = tPos.y;
+            vert->z = tPos.z;				
+        
+            norm.Normalize();
+            vert->setNormal(norm.x, norm.y, norm.z);
+        }
+    }
+    
+    mesh->arrayDirtyMap[RenderDataArray::VERTEX_DATA_ARRAY] = true;		
+    mesh->arrayDirtyMap[RenderDataArray::NORMAL_DATA_ARRAY] = true;	
+    mesh->arrayDirtyMap[RenderDataArray::TANGENT_DATA_ARRAY] = true;
 
 	renderer->pushDataArrayForMesh(mesh, RenderDataArray::VERTEX_DATA_ARRAY);
 	renderer->pushDataArrayForMesh(mesh, RenderDataArray::NORMAL_DATA_ARRAY);		
@@ -290,10 +281,12 @@ bool SceneMesh::customHitDetection(const Ray &ray) {
 	transformedRay.origin = adjustedMatrix * ray.origin;
 	transformedRay.direction = adjustedMatrix.rotateVector(ray.direction);
 	
-	for(int i=0; i < mesh->getPolygonCount(); i++) {
-		if(transformedRay.polygonIntersect(mesh->getPolygon(i))) {
-			return true;
-		}
+	for(int i=0; i < mesh->getVertexCount(); i+=3) {
+        if(i+2 < mesh->getVertexCount()) {
+           if(transformedRay.polygonIntersect(mesh->getVertex(i), mesh->getVertex(i+1), mesh->getVertex(i+2))) {
+                return true;
+            }
+        }
 	}
 	
 	return false;

Core/Contents/Source/PolySceneSprite.cpp

@@ -24,7 +24,6 @@
 #include "PolyCore.h"
 #include "PolyCoreServices.h"
 #include "PolyMesh.h"
-#include "PolyPolygon.h"
 #include "PolyTexture.h"
 
 using std::vector;
@@ -400,16 +399,13 @@ void SceneSprite::updateSprite() {
 	Number xOffset = currentAnimation->framesOffsets[currentFrame].x;
 	Number yOffset = 1.0f - currentAnimation->framesOffsets[currentFrame].y - spriteUVHeight;
 
-    Polygon *imagePolygon;
-	imagePolygon = mesh->getPolygon(0);
-	imagePolygon->getVertex(0)->setTexCoord(xOffset, yOffset);
-	imagePolygon->getVertex(1)->setTexCoord(xOffset+spriteUVWidth, yOffset);
-	imagePolygon->getVertex(2)->setTexCoord(xOffset+spriteUVWidth, yOffset+spriteUVHeight);
+	mesh->getVertex(0)->setTexCoord(xOffset, yOffset);
+	mesh->getVertex(1)->setTexCoord(xOffset+spriteUVWidth, yOffset);
+	mesh->getVertex(2)->setTexCoord(xOffset+spriteUVWidth, yOffset+spriteUVHeight);
 	
-    imagePolygon = mesh->getPolygon(1);
-	imagePolygon->getVertex(0)->setTexCoord(xOffset, yOffset);	;
-	imagePolygon->getVertex(1)->setTexCoord(xOffset+spriteUVWidth, yOffset+spriteUVHeight);
-	imagePolygon->getVertex(2)->setTexCoord(xOffset, yOffset+spriteUVHeight);
+	mesh->getVertex(3)->setTexCoord(xOffset, yOffset);	;
+	mesh->getVertex(4)->setTexCoord(xOffset+spriteUVWidth, yOffset+spriteUVHeight);
+	mesh->getVertex(5)->setTexCoord(xOffset, yOffset+spriteUVHeight);
     
 	mesh->arrayDirtyMap[RenderDataArray::TEXCOORD_DATA_ARRAY] = true;
 

IDE/Contents/Include/PolycodeEntityEditor.h

@@ -35,6 +35,16 @@
 
 using namespace Polycode;
 
+class CameraDisplay : public Entity {
+    public:
+        CameraDisplay(Camera *camera);
+        ~CameraDisplay();
+        void Update();
+    
+    private:
+        SceneMesh *fovMesh;
+};
+
 class EntityEditorMainView : public UIElement {
 		public:
 			EntityEditorMainView();

IDE/Contents/Include/PolycodeFrame.h

@@ -97,7 +97,6 @@ class EditCurve : public UIElement {
 		
 		BezierCurve *targetCurve;
 		SceneMesh *visMesh;
-		Polycode::Polygon *poly;	
 		
 		EditPoint *pointToRemove;
 		UIElement *pointsBase;

IDE/Contents/Source/EditorGrid.cpp

@@ -31,33 +31,30 @@ EditorGrid::EditorGrid() : Entity() {
 }
 
 void EditorGrid::setGrid(int gridSize) {
-	Polycode::Polygon *gridPoly = new Polycode::Polygon();
 	int gridLen = 16;
     
+	if(grid) {
+        grid->getMesh()->clearMesh();
+	} else {
+        Mesh *gridMesh = new Mesh(Mesh::LINE_MESH);
+        
+        grid = new SceneMesh(gridMesh);
+        grid->setColor(0.3, 0.3, 0.3, 1.0);
+        grid->setLineWidth(CoreServices::getInstance()->getRenderer()->getBackingResolutionScaleX());
+        addChild(grid);
+	}
+    
 	for(int x=0; x < gridLen+1; x++) {
-			gridPoly->addVertex((-gridSize * gridLen * 0.5) + (x * gridSize), (-gridSize * gridLen * 0.5), 0);
-			gridPoly->addVertex((-gridSize * gridLen * 0.5) + (x * gridSize) , (-gridSize * gridLen * 0.5) + (gridSize * gridLen), 0);
+			grid->getMesh()->addVertex((-gridSize * gridLen * 0.5) + (x * gridSize), (-gridSize * gridLen * 0.5), 0);
+			grid->getMesh()->addVertex((-gridSize * gridLen * 0.5) + (x * gridSize) , (-gridSize * gridLen * 0.5) + (gridSize * gridLen), 0);
 	}
 
 	for(int y=0; y < gridLen+1; y++) {
-			gridPoly->addVertex((-gridSize * gridLen * 0.5), (-gridSize * gridLen * 0.5) + (y * gridSize), 0);
-			gridPoly->addVertex((-gridSize * gridLen * 0.5) + (gridSize * gridLen), (-gridSize * gridLen * 0.5) + (y * gridSize), 0);
-	}        
-
-	if(grid) {
-			grid->getMesh()->clearMesh();
-			grid->getMesh()->addPolygon(gridPoly);
-	} else {
-			Mesh *gridMesh = new Mesh(Mesh::LINE_MESH);
-			gridMesh->addPolygon(gridPoly);
-				
-			grid = new SceneMesh(gridMesh);
-			grid->setColor(0.3, 0.3, 0.3, 1.0);
-            grid->setLineWidth(CoreServices::getInstance()->getRenderer()->getBackingResolutionScaleX());
-			addChild(grid);
-            grid->cacheToVertexBuffer(true);
-            
+			grid->getMesh()->addVertex((-gridSize * gridLen * 0.5), (-gridSize * gridLen * 0.5) + (y * gridSize), 0);
+			grid->getMesh()->addVertex((-gridSize * gridLen * 0.5) + (gridSize * gridLen), (-gridSize * gridLen * 0.5) + (y * gridSize), 0);
 	}
+    
+    grid->cacheToVertexBuffer(true);    
 }
 
 void EditorGrid::setGridMode(int mode) {

IDE/Contents/Source/PolycodeEntityEditor.cpp

@@ -27,6 +27,20 @@ extern UIGlobalMenu *globalMenu;
 extern PolycodeFrame *globalFrame;
 extern Scene *globalScene;
 
+CameraDisplay::CameraDisplay(Camera *camera) : Entity() {
+    
+    camera->addChild(this);
+}
+
+CameraDisplay::~CameraDisplay() {
+    
+}
+
+void CameraDisplay::Update() {
+    
+}
+
+
 EntityEditorMainView::EntityEditorMainView() {
 	processInputEvents = true;
 
@@ -177,6 +191,8 @@ void EntityEditorMainView::setEditorProps(Entity *entity) {
 
     Camera *camera = dynamic_cast<Camera*>(entity);
     if(camera) {
+        
+        CameraDisplay *camVis = new CameraDisplay(camera);
         createIcon(entity, "camera_icon.png");
     }
 }

IDE/Contents/Source/PolycodeFrame.cpp

@@ -217,15 +217,12 @@ EditCurve::EditCurve(BezierCurve *targetCurve, Color curveColor) : UIElement() {
 	
 	this->targetCurve = targetCurve;
 	
-	poly = new Polycode::Polygon();
+	visMesh = new SceneMesh(Mesh::LINE_STRIP_MESH);
 	
 	for(int i=0; i < CURVE_SIZE; i++) {		
-		poly->addVertex(0.0, 0.0, 0.0);
+		visMesh->getMesh()->addVertex(0.0, 0.0, 0.0);
 	}
 	
-	visMesh = new SceneMesh(Mesh::LINE_STRIP_MESH);
-	visMesh->getMesh()->addPolygon(poly);
-	
 	visMesh->lineSmooth = true;
 	visMesh->lineWidth = 2.0;
 
@@ -325,7 +322,7 @@ void EditCurve::updateCurve() {
 	normInterval += normInterval/CURVE_SIZE;
 		
 	for(int i=0; i < CURVE_SIZE; i++) {
-		poly->getVertex(i)->set(targetCurve->getPointAt(normInterval * i).x * 300, targetCurve->getPointAt(normInterval * i).y * 100.0, 0.0);
+		visMesh->getMesh()->getVertex(i)->set(targetCurve->getPointAt(normInterval * i).x * 300, targetCurve->getPointAt(normInterval * i).y * 100.0, 0.0);
 	}
 	
 	visMesh->getMesh()->arrayDirtyMap[RenderDataArray::VERTEX_DATA_ARRAY] = true;

IDE/Contents/Source/TransformGizmo.cpp

@@ -85,10 +85,8 @@ TransformGizmo::TransformGizmo(Scene *targetScene, Camera *targetCamera) : Entit
 	addChild(rotateDectorators);	
 		
 	yLine = new SceneMesh(Mesh::LINE_MESH);
-	Polycode::Polygon *poly = new Polycode::Polygon();
-	poly->addVertex(0.0, 0.0, 0.0);
-	poly->addVertex(0.0, 1.0, 0.0);	
-	yLine->getMesh()->addPolygon(poly);
+	yLine->getMesh()->addVertex(0.0, 0.0, 0.0);
+	yLine->getMesh()->addVertex(0.0, 1.0, 0.0);
 	yLine->getMesh()->dirtyArrays();
 	yLine->depthTest = false;
 	yLine->setColor(0.0, 1.0, 0.0, 1.0);
@@ -96,10 +94,8 @@ TransformGizmo::TransformGizmo(Scene *targetScene, Camera *targetCamera) : Entit
 	transformAndScaleLines->addChild(yLine);
 
 	xLine = new SceneMesh(Mesh::LINE_MESH);
-	poly = new Polycode::Polygon();
-	poly->addVertex(0.0, 0.0, 0.0);
-	poly->addVertex(1.0, 0.0, 0.0);	
-	xLine->getMesh()->addPolygon(poly);
+	xLine->getMesh()->addVertex(0.0, 0.0, 0.0);
+	xLine->getMesh()->addVertex(1.0, 0.0, 0.0);
 	xLine->getMesh()->dirtyArrays();
 	xLine->depthTest = false;
 	xLine->setColor(1.0, 0.0, 0.0, 1.0);
@@ -107,10 +103,8 @@ TransformGizmo::TransformGizmo(Scene *targetScene, Camera *targetCamera) : Entit
 	transformAndScaleLines->addChild(xLine);
 
 	zLine = new SceneMesh(Mesh::LINE_MESH);
-	poly = new Polycode::Polygon();
-	poly->addVertex(0.0, 0.0, 0.0);
-	poly->addVertex(0.0, 0.0, 1.0);	
-	zLine->getMesh()->addPolygon(poly);
+	zLine->getMesh()->addVertex(0.0, 0.0, 0.0);
+	zLine->getMesh()->addVertex(0.0, 0.0, 1.0);
 	zLine->getMesh()->dirtyArrays();
 	zLine->depthTest = false;
 	zLine->setColor(0.0, 0.0, 1.0, 1.0);

Modules/Contents/2DPhysics/Source/PolyPhysicsScreenEntity.cpp

@@ -25,7 +25,6 @@ THE SOFTWARE.
 #include "PolyPhysicsScreenEntity.h"
 #include "PolyLogger.h"
 #include "PolyMesh.h"
-#include "PolyPolygon.h"
 #include "PolyEntity.h"
 
 using namespace Polycode;

Modules/Contents/3DPhysics/Source/PolyCollisionSceneEntity.cpp

@@ -23,7 +23,6 @@ THE SOFTWARE.
 #include "PolyCollisionSceneEntity.h"
 #include "PolyLogger.h"
 #include "PolyMesh.h"
-#include "PolyPolygon.h"
 #include "PolyEntity.h"
 #include "PolySceneMesh.h"
 #include "btBulletCollisionCommon.h"
@@ -128,11 +127,9 @@ btCollisionShape *CollisionEntity::createCollisionShape(Entity *entity, int type
 			SceneMesh* sceneMesh = dynamic_cast<SceneMesh*>(entity);
 			if(sceneMesh != NULL) {
 				btConvexHullShape *hullShape = new btConvexHullShape();
-				for(int i=0; i < sceneMesh->getMesh()->getPolygonCount(); i++) {
-					Polygon *poly = sceneMesh->getMesh()->getPolygon(i);
-					for(int j=0; j < poly->getVertexCount(); j++) {					
-						hullShape->addPoint(btVector3((btScalar)poly->getVertex(j)->x, (btScalar)poly->getVertex(j)->y,(btScalar)poly->getVertex(j)->z));
-					}
+                Mesh *mesh = sceneMesh->getMesh();
+				for(int i=0; i < mesh->getVertexCount(); i++) {
+                    hullShape->addPoint(btVector3((btScalar)mesh->getVertex(i)->x, (btScalar)mesh->getVertex(i)->y,(btScalar)mesh->getVertex(i)->z));
 				}				
 				collisionShape = hullShape;
 				

Modules/Contents/UI/Source/PolyUIColorBox.cpp

@@ -64,15 +64,12 @@ UIColorPicker::UIColorPicker() : UIWindow(L"", 300, 240) {
 	mainColorRect->setWidth(mainFrame->getWidth());
 	mainColorRect->setHeight(mainFrame->getWidth());
 	mainColorRect->setDepth(0.001);
+		
+	mainColorRect->getMesh()->addVertex(-mainFrame->getWidth()/2,mainFrame->getHeight()/2.0,0,0,0);
+	mainColorRect->getMesh()->addVertex(mainFrame->getWidth()/2,mainFrame->getHeight()/2.0,0, 1, 0);
+	mainColorRect->getMesh()->addVertex(mainFrame->getWidth()/2,-mainFrame->getHeight()/2.0,0, 1, 1);
+	mainColorRect->getMesh()->addVertex(-mainFrame->getWidth()/2,-mainFrame->getHeight()/2.0,0,0,1);
 	
-	Polygon *imagePolygon = new Polygon();
-	
-	imagePolygon->addVertex(-mainFrame->getWidth()/2,mainFrame->getHeight()/2.0,0,0,0);
-	imagePolygon->addVertex(mainFrame->getWidth()/2,mainFrame->getHeight()/2.0,0, 1, 0);		
-	imagePolygon->addVertex(mainFrame->getWidth()/2,-mainFrame->getHeight()/2.0,0, 1, 1);									
-	imagePolygon->addVertex(-mainFrame->getWidth()/2,-mainFrame->getHeight()/2.0,0,0,1);
-	
-	mainColorRect->getMesh()->addPolygon(imagePolygon);
 	mainColorRect->getMesh()->dirtyArrays();
 	mainColorRect->backfaceCulled = false;	
 
@@ -269,10 +266,10 @@ void UIColorPicker::updateSelectedColor(bool updateTextFields, bool updateHue, b
 	hueCol.setColorHSV(currentH, 1.0, 1.0);
 	hueCol.a = colorAlpha;
 
-	mainColorRect->getMesh()->getPolygon(0)->getVertex(0)->vertexColor = Color(1.0,1.0,1.0,colorAlpha);
-	mainColorRect->getMesh()->getPolygon(0)->getVertex(1)->vertexColor = hueCol;
-	mainColorRect->getMesh()->getPolygon(0)->getVertex(2)->vertexColor = Color(0.0,0.0,0.0,colorAlpha);
-	mainColorRect->getMesh()->getPolygon(0)->getVertex(3)->vertexColor = Color(0.0,0.0,0.0,colorAlpha);	
+	mainColorRect->getMesh()->getVertex(0)->vertexColor = Color(1.0,1.0,1.0,colorAlpha);
+	mainColorRect->getMesh()->getVertex(1)->vertexColor = hueCol;
+	mainColorRect->getMesh()->getVertex(2)->vertexColor = Color(0.0,0.0,0.0,colorAlpha);
+	mainColorRect->getMesh()->getVertex(3)->vertexColor = Color(0.0,0.0,0.0,colorAlpha);	
 	mainColorRect->getMesh()->arrayDirtyMap[RenderDataArray::COLOR_DATA_ARRAY] = true;				
 			
 	if(updateHue) {

Modules/Contents/UI/Source/PolyUIElement.cpp

@@ -91,7 +91,7 @@ UIRect::UIRect(Number width, Number height) : UIElement() {
 }
 
 void UIRect::setImageCoordinates(Number x, Number y, Number width, Number height, Number imageScale) {
-	Vertex *vertex;
+    Vertex *vertex;
 	Number pixelSizeX = 1/imageWidth;
 	Number pixelSizeY = 1/imageHeight;
 
@@ -106,20 +106,19 @@ void UIRect::setImageCoordinates(Number x, Number y, Number width, Number height
 	Number wFloat = width * pixelSizeX * imageScale;
 	Number hFloat = height * pixelSizeY * imageScale;
 
-	Polygon *imagePolygon = rectMesh->getPolygon(0);	
-	vertex = imagePolygon->getVertex(0);
+	vertex = rectMesh->getVertex(0);
 	vertex->set(-whalf,-hhalf,0);
 	vertex->setTexCoord(xFloat, (1.0-yFloat) - hFloat);
 
-	vertex = imagePolygon->getVertex(1);
+	vertex = rectMesh->getVertex(1);
 	vertex->set(-whalf+width,-hhalf,0);
 	vertex->setTexCoord(xFloat + wFloat, (1.0-yFloat) - hFloat);
 
-	vertex = imagePolygon->getVertex(2);
+	vertex = rectMesh->getVertex(2);
 	vertex->set(-whalf+width,-hhalf+height,0);
 	vertex->setTexCoord(xFloat + wFloat, 1.0-yFloat);
 
-	vertex = imagePolygon->getVertex(3);	
+	vertex = rectMesh->getVertex(3);
 	vertex->set(-whalf,-hhalf+height,0);	
 	vertex->setTexCoord(xFloat, 1.0-yFloat);
 
@@ -147,13 +146,11 @@ void UIRect::initRect(Number width, Number height) {
 	
 	Number whalf = width/2.0f;
 	Number hhalf = height/2.0f;
-						
-	Polygon *poly = new Polygon();
-	poly->addVertex(-whalf,-hhalf,0,0,0);
-	poly->addVertex(-whalf+width,-hhalf,0, 1, 0);
-	poly->addVertex(-whalf+width,-hhalf+height,0, 1, 1);
-	poly->addVertex(-whalf,-hhalf+height,0,0,1);
-	rectMesh->addPolygon(poly);
+				
+	rectMesh->addVertex(-whalf,-hhalf,0,0,0);
+	rectMesh->addVertex(-whalf+width,-hhalf,0, 1, 0);
+	rectMesh->addVertex(-whalf+width,-hhalf+height,0, 1, 1);
+	rectMesh->addVertex(-whalf,-hhalf+height,0,0,1);
 }
 
 UIRect::~UIRect() {
@@ -188,17 +185,15 @@ void UIRect::Resize(Number width, Number height) {
 
 	Number whalf = width/2.0f;
 	Number hhalf = height/2.0f;
-	Polygon *polygon;
 	Vertex *vertex;
 
-	polygon = rectMesh->getPolygon(0);	
-	vertex = polygon->getVertex(0);
+	vertex = rectMesh->getVertex(0);
 	vertex->set(-whalf,-hhalf,0);			
-	vertex = polygon->getVertex(1);
+	vertex = rectMesh->getVertex(1);
 	vertex->set(-whalf+width,-hhalf,0);			
-	vertex = polygon->getVertex(2);
+	vertex = rectMesh->getVertex(2);
 	vertex->set(-whalf+width,-hhalf+height,0);			
-	vertex = polygon->getVertex(3);	
+	vertex = rectMesh->getVertex(3);
 	vertex->set(-whalf,-hhalf+height,0);				
 	rectMesh->arrayDirtyMap[RenderDataArray::VERTEX_DATA_ARRAY] = true;	
 }

Tools/Contents/polyimport/Source/polyimport.cpp

@@ -1,6 +1,5 @@
 
 #include "polyimport.h"
-#include "PolyPolygon.h"
 #include "OSBasics.h"
 
 #include "physfs.h"
@@ -45,7 +44,6 @@ void addToMesh(String prefix, Polycode::Mesh *tmesh, const struct aiScene *sc, c
 
 		for (t = 0; t < mesh->mNumFaces; ++t) {
 			const struct aiFace* face = &mesh->mFaces[t];
-			Polycode::Polygon *poly = new Polycode::Polygon();			
 	
 			for(i = 0; i < face->mNumIndices; i++) {
 				Vertex *vertex = new Vertex();
@@ -90,9 +88,8 @@ void addToMesh(String prefix, Polycode::Mesh *tmesh, const struct aiScene *sc, c
 					vertex->set(mesh->mVertices[index].x, mesh->mVertices[index].z, -mesh->mVertices[index].y);
 				else
 					vertex->set(mesh->mVertices[index].x, mesh->mVertices[index].y, mesh->mVertices[index].z);
-				poly->addVertex(vertex);
+				tmesh->addVertex(vertex);
 			}
-			tmesh->addPolygon(poly);
 		}
 		
 		if(!addSubmeshes && !listOnly) {