New renderer finally rendering basic attributes and uniforms! Removed TextMesh from the codebase, removed support for MESH_QUAD meshes (to comply with ES2 standards), added TRISTRI_MESH support.

Assets/Default asset pack/default/Unlit.vert

@@ -1,13 +1,14 @@
 attribute vec4 position;
 attribute vec2 texCoord;
 
-uniform mat4 modelView;
-uniform mat4 projection;
+uniform mat4 modelMatrix;
+uniform mat4 viewMatrix;
+uniform mat4 projectionMatrix;
 varying vec2 texCoordVar;
 
 void main()
 {
-	vec4 p = modelView * position;
-	gl_Position = projection * p;
+	vec4 p = modelMatrix * viewMatrix * position;
+	gl_Position = projectionMatrix * p;
 	texCoordVar = texCoord;
 }

Core/Contents/CMakeLists.txt

@@ -55,8 +55,7 @@ SET(polycore_SRCS
     Source/PolySound.cpp
     Source/PolySoundManager.cpp
     Source/PolyString.cpp
-	Source/PolyTextMesh.cpp
-	Source/PolyTexture.cpp
+    Source/PolyTexture.cpp
     Source/PolyThreaded.cpp
     Source/PolyTimer.cpp
     Source/PolyTimerManager.cpp
@@ -138,7 +137,6 @@ SET(polycore_HDRS
     Include/PolySound.h
     Include/PolySoundManager.h
     Include/PolyString.h
-	Include/PolyTextMesh.h
     Include/PolyTexture.h
     Include/PolyThreaded.h
     Include/PolyTimer.h

Core/Contents/Include/PolyGPUDrawBuffer.h

@@ -43,17 +43,14 @@ namespace Polycode {
     class _PolyExport GPUDrawCall {
     public:
         unsigned int numVertices;
-        unsigned char type;
-        bool ownsAttributes;
-        GPUDrawOptions options;
+        unsigned char mode;
+        bool indexed;
         
+        GPUDrawOptions options;
         Matrix4 modelMatrix;
-        
         Material *material;
         ShaderBinding *shaderBinding;
-        
-        std::vector<RenderDataArray*> attributeArrays;
-        std::vector<LocalShaderParam> uniforms;
+        IndexDataArray *indexArray;
     };
     
     
@@ -63,6 +60,8 @@ namespace Polycode {
         ~GPUDrawBuffer();
         
         Matrix4 projectionMatrix;
+        Matrix4 viewMatrix;
+        
         Polycode::Rectangle viewport;
         std::vector<GPUDrawCall> drawCalls;
     };

Core/Contents/Include/PolyMatrix4.h

@@ -329,6 +329,7 @@ namespace Polycode {
             }
 
             inline void setProjection(Number fov, Number aspect, Number zNear, Number zFar) {
+                
                 m[0][0] = 1.0f/tanf(fov/2.0)/aspect;
                 m[1][1] = 1.0f/tanf(fov/2.0);
                 m[2][2] = (zFar+zNear)/(zNear-zFar);

Core/Contents/Include/PolyMesh.h

@@ -77,7 +77,7 @@ namespace Polycode {
 			
 			/**
 			* Construct with an empty mesh of specified type.
-			* @param meshType Type of mesh. Possible values are: Mesh::QUAD_MESH, Mesh::TRI_MESH, Mesh::TRIFAN_MESH, Mesh::TRISTRIP_MESH, Mesh::LINE_MESH, Mesh::POINT_MESH.
+			* @param meshType Type of mesh. Possible values are: Mesh::TRISTRIP_MESH, Mesh::TRI_MESH, Mesh::TRIFAN_MESH, Mesh::TRISTRIP_MESH, Mesh::LINE_MESH, Mesh::POINT_MESH.
 			*/			
 			explicit Mesh(int meshType);
 					
@@ -289,13 +289,12 @@ namespace Polycode {
 			
 			/**
 			* Sets a new mesh type.
-			* @param newType New mesh type. Possible values are: Mesh::QUAD_MESH, Mesh::TRI_MESH, Mesh::TRIFAN_MESH, Mesh::TRISTRIP_MESH, Mesh::LINE_MESH, Mesh::POINT_MESH.
+			* @param newType New mesh type. Possible values are: Mesh::TRISTRIP_MESH, Mesh::TRI_MESH, Mesh::TRIFAN_MESH, Mesh::TRISTRIP_MESH, Mesh::LINE_MESH, Mesh::POINT_MESH.
 			*/ 
 			void setMeshType(int newType);
 
 			inline unsigned int getIndexGroupSize() {
 				switch (meshType) {
-				case QUAD_MESH: return 4;
 				case TRI_MESH: return 3;
 				case LINE_MESH: return 2;
 				default: return 1;
@@ -316,7 +315,7 @@ namespace Polycode {
 			/**
 			* Quad based mesh.
 			*/
-			static const int QUAD_MESH = 0;			
+			static const int TRISTRIP_MESH = 0;
 			
 			/**
 			* Triangle based mesh.
@@ -367,7 +366,7 @@ namespace Polycode {
 			 * @param vertexRemovalCount Number of elements to remove from the vertex array */
 			void removeVertexRange(unsigned int beginRemoveVertex, int vertexRemovalCount = 3);
 
-			/** Removes a face from the mesh. Face is defined as a quad for QUAD_MESH, a triangle for TRI_MESH, a line for LI
+			/** Removes a face from the mesh. Face is defined as a triangle for TRI_MESH, or a line for LI
 			 *  In indexedMesh mode this may result in orphaned vertices.
 			 * @param faceIndex The 0-indexed face of the mesh (and NOT the index into the indices array!) */
 			void removeFace(unsigned int faceIndex);

Core/Contents/Include/PolyOpenGLGraphicsInterface.h

@@ -60,11 +60,21 @@ namespace Polycode {
         void setViewport(unsigned int x,unsigned  int y,unsigned  int width, unsigned height);
         void clearBuffers(bool colorBuffer, bool depthBuffer, bool stencilBuffer);
         void setParamInShader(Shader *shader, const ProgramParam &param, LocalShaderParam *localParam);
+        void setAttributeInShader(Shader *shader, const ProgramAttribute &attribute, AttributeBinding *attributeBinding);
+        void disableAttribute(Shader *shader, const ProgramAttribute &attribute);
+        void useShader(Shader *shader);
         void createProgram(ShaderProgram *program);
         void createShader(Shader *shader);
         
+        void drawIndices(int type, IndexDataArray *indexArray);
+        void drawArrays(int type, unsigned int vertexCount);
+        
+        void enableDepthTest(bool val);
+        void enableDepthWrite(bool val);
+        
 	protected:
 		
+        static GLenum getGLDrawMode(int polycodeMode);
         static int getPolycodeParamType(int glType);
         static int getAttributeSize(int glType);
         void setUniformMatrix(GLint paramLocation, const Polycode::Matrix4& matrix);

Core/Contents/Include/PolyRenderer.h

@@ -41,11 +41,21 @@ namespace Polycode {
         public:
             GraphicsInterface();
             virtual void setParamInShader(Shader *shader, const ProgramParam &param, LocalShaderParam *localParam) = 0;
+            virtual void setAttributeInShader(Shader *shader, const ProgramAttribute &attribute, AttributeBinding *attributeBinding) = 0;
+            virtual void disableAttribute(Shader *shader, const ProgramAttribute &attribute) = 0;
             virtual void createTexture(Texture *texture, int filteringMode, int anisotropy, bool createMipmaps) = 0;
             virtual void setViewport(unsigned int x,unsigned  int y,unsigned  int width, unsigned height) = 0;
             virtual void clearBuffers(bool colorBuffer, bool depthBuffer, bool stencilBuffer) = 0;
             virtual void createProgram(ShaderProgram *program) = 0;
             virtual void createShader(Shader *shader) = 0;
+            virtual void useShader(Shader *shader) = 0;
+        
+            virtual void drawIndices(int type, IndexDataArray *indexArray) = 0;
+            virtual void drawArrays(int type, unsigned int vertexCount) = 0;
+        
+            virtual void enableDepthTest(bool val) = 0;
+            virtual void enableDepthWrite(bool val) = 0;
+        
     };
     
     class _PolyExport RendererThreadJob {
@@ -85,6 +95,11 @@ namespace Polycode {
             CoreMutex *jobQueueMutex;
             std::queue<RendererThreadJob> jobQueue;
             GraphicsInterface *interface;
+        
+            ShaderBinding *rendererShaderBinding;
+            LocalShaderParam *projectionMatrixParam;
+            LocalShaderParam *viewMatrixParam;
+            LocalShaderParam *modelMatrixParam;
     };
     
     class _PolyExport Renderer : public PolyBase {

Core/Contents/Include/PolySceneLight.h

@@ -219,6 +219,5 @@ namespace Polycode {
 			bool shadowsEnabled;
 		
 			Number distance;
-			Mesh *lightMesh;
 	};
 }

Core/Contents/Include/PolyShader.h

@@ -35,6 +35,7 @@ namespace Polycode {
 	class Cubemap;
 	class ShaderBinding;
 	class Texture;
+    class VertexDataArray;
 	
 	class _PolyExport ProgramParam {
 		public:
@@ -89,7 +90,6 @@ namespace Polycode {
 			void setName(const String& name);
 			const String& getName() const;
 			
-			ShaderBinding *createBinding();
 			virtual void reload() {}
 			
 			int getExpectedParamType(String name);
@@ -156,7 +156,13 @@ namespace Polycode {
             void setColor(Color x);
         
             void setParamValueFromString(int type, String pvalue);
-	};	
+	};
+    
+    class AttributeBinding : public PolyBase {
+        public:
+            String name;
+            VertexDataArray *vertexData;
+    };
 	
 	class RenderTargetBinding : public PolyBase {
 		public:
@@ -172,7 +178,7 @@ namespace Polycode {
 
 	class _PolyExport ShaderBinding : public PolyBase {
 		public:
-			ShaderBinding(Shader *shader);
+			ShaderBinding();
 			virtual ~ShaderBinding();
         
             void copyTo(ShaderBinding *targetBinding);
@@ -189,6 +195,9 @@ namespace Polycode {
 			unsigned int getNumLocalParams();
 			LocalShaderParam *getLocalParam(unsigned int index);
 			LocalShaderParam *getLocalParamByName(const String& name);
+        
+            AttributeBinding *addAttributeBinding(const String &name, VertexDataArray *dataArray);
+            AttributeBinding *getAttributeBindingByName(const String &name);
 			
 			void addRenderTargetBinding(RenderTargetBinding *binding);
 			void removeRenderTargetBinding(RenderTargetBinding *binding);
@@ -210,9 +219,9 @@ namespace Polycode {
 			            
             std::vector<TextureBinding> textures;
             std::vector<CubemapBinding> cubemaps;
-		
-			Shader* shader;
+	
 			std::vector<LocalShaderParam*> localParams;
+			std::vector<AttributeBinding*> attributes;
 			std::vector<RenderTargetBinding*> renderTargetBindings;
 			std::vector<RenderTargetBinding*> inTargetBindings;
 			std::vector<RenderTargetBinding*> outTargetBindings;

Core/Contents/Include/PolyTextMesh.h

@@ -1,25 +0,0 @@
-
-#pragma once
-#include "PolyGlobals.h"
-#include "PolyEntity.h"
-#include "PolyMesh.h"
-#include "PolyString.h"
-
-namespace Polycode {
-
-	class FontGlyphSheet;
-
-	class _PolyExport TextMesh : public Mesh {
-	public:
-		TextMesh(FontGlyphSheet* font, const String& text);
-
-		void setFont(FontGlyphSheet* font);
-		void setText(const String& text);
-
-		void rebuild();
-
-	private:
-		String text;
-		FontGlyphSheet* font;
-	};
-}

Core/Contents/Include/Polycode.h

@@ -58,7 +58,6 @@
 #include "PolyTexture.h"
 #include "PolyMaterial.h"
 #include "PolyMesh.h"
-#include "PolyTextMesh.h"
 #include "PolyShader.h"
 #include "PolySceneManager.h"
 #include "PolyCoreServices.h"

Core/Contents/Source/PolyMaterial.cpp

@@ -167,13 +167,13 @@ void Material::removeShader(int shaderIndex) {
 
 void Material::addShaderAtIndex(Shader *shader,ShaderBinding *shaderBinding, int shaderIndex) {
         // RENDERER_TODO
-    /*
+
 	materialShaders.insert(materialShaders.begin()+shaderIndex, shader);
 	shaderBindings.insert(shaderBindings.begin()+shaderIndex, shaderBinding);
 	
 	shader->addEventListener(this, Event::RESOURCE_RELOAD_EVENT);	
-	CoreServices::getInstance()->getRenderer()->setRendererShaderParams(shader, shaderBinding);	
 	
+    /*
 	for(int i=0; i < shader->expectedParams.size(); i++) {
 		if(!shaderBinding->getLocalParamByName(shader->expectedParams[i].name)) {
 			shaderBinding->addParam(shader->expectedParams[i].type, shader->expectedParams[i].name);
@@ -183,14 +183,11 @@ void Material::addShaderAtIndex(Shader *shader,ShaderBinding *shaderBinding, int
 }
 			
 void Material::addShader(Shader *shader,ShaderBinding *shaderBinding) {
-    // RENDERER_TODO
-    /*
+
 	materialShaders.push_back(shader);
 	shaderBindings.push_back(shaderBinding);
-	
-	shader->addEventListener(this, Event::RESOURCE_RELOAD_EVENT);	
-	CoreServices::getInstance()->getRenderer()->setRendererShaderParams(shader, shaderBinding);	
-	
+	shader->addEventListener(this, Event::RESOURCE_RELOAD_EVENT);
+    /*
 	for(int i=0; i < shader->expectedParams.size(); i++) {
 		if(!shaderBinding->getLocalParamByName(shader->expectedParams[i].name)) {
 			shaderBinding->addParam(shader->expectedParams[i].type, shader->expectedParams[i].name);

Core/Contents/Source/PolyMaterialManager.cpp

@@ -409,7 +409,7 @@ Material *MaterialManager::createMaterial(ResourcePool *resourcePool, String mat
 	Shader *retShader = (Shader*)resourcePool->getResource(Resource::RESOURCE_SHADER, shaderName);
 	
 	if(retShader) {
-		ShaderBinding *newShaderBinding = retShader->createBinding();
+		ShaderBinding *newShaderBinding = new ShaderBinding();
 		newMaterial->addShader(retShader, newShaderBinding);
 	}
 	
@@ -504,7 +504,7 @@ Material *MaterialManager::materialFromXMLNode(ResourcePool *resourcePool, TiXml
 		if(strcmp(pChild3->Value(), "shader") == 0) {
 			materialShader = setShaderFromXMLNode(resourcePool, pChild3);
 			if(materialShader) {
-				newShaderBinding = materialShader->createBinding();
+                newShaderBinding = new ShaderBinding();
 				materialShaders.push_back(materialShader);
 				newShaderBindings.push_back(newShaderBinding);
 				for (pChild = pChild3->FirstChild(); pChild != 0; pChild = pChild->NextSibling()) {

Core/Contents/Source/PolyMesh.cpp

@@ -1227,9 +1227,6 @@ void Mesh::calculateTangents() {
     vertexTangentArray.data.clear();
     
     int polySize = 3;
-    if(meshType == Mesh::QUAD_MESH) {
-        polySize = 4;
-    }
     
     for(int i=0; i < vertexPositionArray.data.size() / 3; i++) {
         addTangent(0.0, 0.0, 0.0);
@@ -1273,9 +1270,6 @@ void Mesh::calculateTangents() {
 void Mesh::calculateNormals() {
 
     int polySize = 3;
-    if(meshType == Mesh::QUAD_MESH) {
-        polySize = 4;
-    }
     
     vertexNormalArray.data.clear();
     

Core/Contents/Source/PolyOpenGLGraphicsInterface.cpp

@@ -110,7 +110,64 @@ void OpenGLGraphicsInterface::setParamInShader(Shader *shader, const ProgramPara
             }
             break;
     }
+}
+
+void OpenGLGraphicsInterface::useShader(Shader *shader) {
+    GLuint shaderID = *((GLuint*) shader->platformData);
+    glUseProgram(shaderID);
+}
+
+void OpenGLGraphicsInterface::setAttributeInShader(Shader *shader, const ProgramAttribute &attribute, AttributeBinding *attributeBinding) {
+    // TODO: ALSO DO NOT LOOK UP BY STRING!
+    GLuint shaderID = *((GLuint*) shader->platformData);
+    int attribLocation = glGetAttribLocation(shaderID, attribute.name.c_str());
+    
+    glVertexAttribPointer(attribLocation, attributeBinding->vertexData->countPerVertex, GL_FLOAT, false, 0, attributeBinding->vertexData->data.data());
+    glEnableVertexAttribArray(attribLocation);
+}
+
+void OpenGLGraphicsInterface::disableAttribute(Shader *shader, const ProgramAttribute &attribute) {
     
+    // TODO: ALSO DO NOT LOOK UP BY STRING!
+    GLuint shaderID = *((GLuint*) shader->platformData);
+    int attribLocation = glGetAttribLocation(shaderID, attribute.name.c_str());
+    glDisableVertexAttribArray(attribLocation);
+}
+
+GLenum OpenGLGraphicsInterface::getGLDrawMode(int polycodeMode) {
+    switch(polycodeMode) {
+        case Mesh::POINT_MESH:
+            return GL_POINTS;
+        break;
+        case Mesh::LINE_STRIP_MESH:
+            return GL_LINE_STRIP;
+        break;
+        case Mesh::LINE_LOOP_MESH:
+            return GL_LINE_LOOP;
+        break;
+        case Mesh::LINE_MESH:
+            return GL_LINES;
+        break;
+        case Mesh::TRISTRIP_MESH:
+            return GL_TRIANGLE_STRIP;
+        break;
+        case Mesh::TRIFAN_MESH:
+            return GL_TRIANGLE_FAN;
+        break;
+        case Mesh::TRI_MESH:
+            return GL_TRIANGLES;
+        break;
+    }
+    
+    return GL_TRIANGLES;
+}
+
+void OpenGLGraphicsInterface::drawIndices(int type, IndexDataArray *indexArray) {
+     glDrawElements(getGLDrawMode(type), indexArray->data.size(), GL_UNSIGNED_INT, indexArray->data.data());
+}
+
+void OpenGLGraphicsInterface::drawArrays(int type, unsigned int vertexCount) {
+    glDrawArrays(getGLDrawMode(type), 0, vertexCount);
 }
 
 void OpenGLGraphicsInterface::createTexture(Texture *texture, int filteringMode, int anisotropy, bool createMipmaps) {
@@ -324,6 +381,23 @@ void OpenGLGraphicsInterface::createShader(Shader *shader) {
     
 }
 
+void OpenGLGraphicsInterface::enableDepthTest(bool val) {
+    if(val) {
+        glEnable(GL_DEPTH_TEST);
+        glDepthFunc( GL_LEQUAL );
+    } else {
+        glDisable(GL_DEPTH_TEST);
+    }
+}
+
+void OpenGLGraphicsInterface::enableDepthWrite(bool val) {
+    if(val) {
+        glDepthMask(GL_TRUE);
+    } else {
+        glDepthMask(GL_FALSE);
+    }
+}
+
 void OpenGLGraphicsInterface::clearBuffers(bool colorBuffer, bool depthBuffer, bool stencilBuffer) {
     GLbitfield clearMask = 0;
     
@@ -340,6 +414,7 @@ void OpenGLGraphicsInterface::clearBuffers(bool colorBuffer, bool depthBuffer, b
     }
     
     
+    glClearColor(0.5, 0.5, 0.5, 1.0);
     glClear(clearMask);
 }
 

Core/Contents/Source/PolyParticleEmitter.cpp

@@ -283,7 +283,10 @@ void SceneParticleEmitter::rebuildParticles() {
                     }
                     
                 } else {
-                    mesh->setMeshType(Mesh::QUAD_MESH);
+                    mesh->setMeshType(Mesh::TRI_MESH);
+                    mesh->indexedMesh = true;
+                    
+                    int vertexCount = mesh->getVertexCount();
                     
                     Vector3 vertexPosition = Vector3(-finalParticleSize, -finalParticleSize, 0.0);
                     vertexPosition = q.applyTo(vertexPosition);
@@ -308,6 +311,10 @@ void SceneParticleEmitter::rebuildParticles() {
                     vertexPosition = cameraMatrix.rotateVector(vertexPosition);
                     mesh->addVertexWithUV(particlePosition.x+vertexPosition.x, particlePosition.y+vertexPosition.y, particlePosition.z+vertexPosition.z, 0.0, 1.0);
                     mesh->addColor(vertexColor);
+                    
+
+                    mesh->addIndexedFace(vertexCount, vertexCount+1, vertexCount+2);
+                    mesh->addIndexedFace(vertexCount, vertexCount+2, vertexCount+3);
                 }
 
             }

Core/Contents/Source/PolyRenderer.cpp

@@ -45,11 +45,18 @@ RenderThread::RenderThread() : interface(NULL) {
     options.anisotropy = 0;
     options.createMipmaps = true;
     
+    rendererShaderBinding = new ShaderBinding();
+    
+    projectionMatrixParam = rendererShaderBinding->addParam(ProgramParam::PARAM_MATRIX, "projectionMatrix");
+    modelMatrixParam = rendererShaderBinding->addParam(ProgramParam::PARAM_MATRIX, "modelMatrix");
+    viewMatrixParam = rendererShaderBinding->addParam(ProgramParam::PARAM_MATRIX, "viewMatrix");
+    
     jobQueueMutex = Services()->getCore()->createMutex();
 }
 
 void RenderThread::runThread() {
     while(threadRunning) {
+        
         Services()->getCore()->lockMutex(jobQueueMutex);
         if(jobQueue.size() > 0) {
             RendererThreadJob nextJob = jobQueue.front();
@@ -64,30 +71,49 @@ void RenderThread::processDrawBuffer(GPUDrawBuffer *buffer) {
     interface->setViewport(buffer->viewport.x, buffer->viewport.y, buffer->viewport.w, buffer->viewport.h);
     interface->clearBuffers(true, true, true);
     
+    
+    projectionMatrixParam->setMatrix4(buffer->projectionMatrix);
+    viewMatrixParam->setMatrix4(buffer->viewMatrix);
+    
     for(int i=0; i < buffer->drawCalls.size(); i++) {
+        
+        
+        interface->enableDepthTest(buffer->drawCalls[i].options.depthTest);
+        interface->enableDepthWrite(buffer->drawCalls[i].options.depthWrite);
+        
+        modelMatrixParam->setMatrix4(buffer->drawCalls[i].modelMatrix);
+        
         if(buffer->drawCalls[i].material) {
-            
             ShaderBinding *localShaderBinding = buffer->drawCalls[i].shaderBinding;
             
             for(int s=0; s < buffer->drawCalls[i].material->getNumShaders(); s++) {
                 
                 Shader *shader = buffer->drawCalls[i].material->getShader(s);
+                
+                interface->useShader(shader);
+                
                 ShaderBinding *materialShaderBinding = buffer->drawCalls[i].material->getShaderBinding(s);
 
                 
-             
-                
                 // !!!!!!!!!!!!!!!!!!!!!!!!
                 // TODO: Don't do string lookups on every frame for all this stuff, find a better way!!
                 // !!!!!!!!!!!!!!!!!!!!!!!!
                 
                 // set shader uniforms
                 
+   
                 for(int p=0; p < shader->expectedParams.size(); p++) {
                     ProgramParam param = shader->expectedParams[p];
-
+                    
                     LocalShaderParam *localParam = NULL;
-                    localParam = materialShaderBinding->getLocalParamByName(param.name);
+                    localParam = rendererShaderBinding->getLocalParamByName(param.name);
+
+                    // material options override renderer options
+                    
+                    LocalShaderParam *materialOptionsParam = materialShaderBinding->getLocalParamByName(param.name);
+                    if(materialOptionsParam) {
+                        localParam = materialOptionsParam;
+                    }
                     
                     // local options override material options
                     
@@ -97,19 +123,43 @@ void RenderThread::processDrawBuffer(GPUDrawBuffer *buffer) {
                     }
                     
                     interface->setParamInShader(shader, param, localParam);
+                    
                 }
                 
                  for(int a=0; a < shader->expectedAttributes.size(); a++) {
                      ProgramAttribute attribute = shader->expectedAttributes[a];
+                     
+                     
+                     AttributeBinding *attributeBinding = NULL;
+                     attributeBinding = materialShaderBinding->getAttributeBindingByName(attribute.name);
+                     
+                     // local options override material options
+                     
+                     AttributeBinding *localAttributeBinding = localShaderBinding->getAttributeBindingByName(attribute.name);
+                     
+                     if(localAttributeBinding) {
+                         attributeBinding = localAttributeBinding;
+                     }
+                     
+                     if(attributeBinding) {
+                         interface->setAttributeInShader(shader, attribute, attributeBinding);
+                     }
 
                  }
                 
-                // set shader attributes
+                if(buffer->drawCalls[i].indexed) {
+                    interface->drawIndices(buffer->drawCalls[i].mode, buffer->drawCalls[i].indexArray);
+                } else {
+                    interface->drawArrays(buffer->drawCalls[i].mode, buffer->drawCalls[i].numVertices);
+                }
+                
                 
-//                glVertexAttribPointer(texCoordAttribute, 2, GL_FLOAT, false, 0, uvs);
-  //              glEnableVertexAttribArray(texCoordAttribute);
+                for(int a=0; a < shader->expectedAttributes.size(); a++) {
+                    ProgramAttribute attribute = shader->expectedAttributes[a];
+                    interface->disableAttribute(shader, attribute);
+                }
                 
-                // render with shader
+
             }
         }
     }

Core/Contents/Source/PolyScene.cpp

@@ -236,8 +236,9 @@ void Scene::Render(Camera *targetCamera) {
 	
 	
 	targetCamera->rebuildTransformMatrix();
-    drawBuffer->projectionMatrix = targetCamera->getProjectionMatrix();
     
+    drawBuffer->projectionMatrix = targetCamera->createProjectionMatrix();
+    drawBuffer->viewMatrix = targetCamera->getConcatenatedMatrix().Inverse();
 /*
 	if(useClearColor) {
 		CoreServices::getInstance()->getRenderer()->setClearColor(clearColor.r,clearColor.g,clearColor.b, clearColor.a);	
@@ -283,11 +284,12 @@ void Scene::Render(Camera *targetCamera) {
 		//CoreServices::getInstance()->getRenderer()->addLight(light->getLightImportance(), position, direction, light->getLightType(), light->lightColor, light->specularLightColor, light->getConstantAttenuation(), light->getLinearAttenuation(), light->getQuadraticAttenuation(), light->getIntensity(), light->getSpotlightCutoff(), light->getSpotlightExponent(), light->areShadowsEnabled(), matrixPtr, shadowMapTexture);
 	}	
 		
-    	
+    	/*
     if(_doVisibilityChecking) {
         targetCamera->buildFrustumPlanes();
         setEntityVisibility(&rootEntity, targetCamera);
     }
+         */
 	rootEntity.transformAndRender(drawBuffer);
 
     

Core/Contents/Source/PolySceneImage.cpp

@@ -103,8 +103,11 @@ void SceneImage::setImageCoordinates(Number x, Number y, Number width, Number he
 
 	mesh->vertexPositionArray.data.clear();
 	mesh->vertexTexCoordArray.data.clear();
+    mesh->indexArray.data.clear();
+    
+    mesh->indexedMesh = true;
 
-	mesh->setMeshType(Mesh::QUAD_MESH);
+	mesh->setMeshType(Mesh::TRI_MESH);
 
 	mesh->addVertex(0 - whalf, 0 - hhalf, 0);
 	mesh->addTexCoord(xFloat, (1.0 - yFloat) - hFloat);
@@ -118,6 +121,10 @@ void SceneImage::setImageCoordinates(Number x, Number y, Number width, Number he
 	mesh->addVertex(0 - whalf, realHeight - hhalf, 0);
 	mesh->addTexCoord(xFloat, 1.0 - yFloat);
 
+    
+    mesh->addIndexedFace(0, 1, 2);
+    mesh->addIndexedFace(0, 2, 3);
+    
 	rebuildTransformMatrix();
 	matrixDirty = true;
 }

Core/Contents/Source/PolySceneLight.cpp

@@ -43,9 +43,7 @@ SceneLight::SceneLight(int type, Scene *parentScene, Number intensity, Number co
 		
     shadowMapRes = 256;
 	this->depthWrite = false;
-	lightMesh = new Mesh(Mesh::QUAD_MESH);
-	lightMesh->createBox(0.1,0.1,0.1);
-	setLocalBoundingBox(lightMesh->calculateBBox());
+	    
 	shadowMapFOV = 60.0f;
 	zBufferTexture = NULL;
 	spotCamera = NULL;

Core/Contents/Source/PolySceneMesh.cpp

@@ -185,7 +185,11 @@ void SceneMesh::setMaterial(Material *material) {
 			return;
 		
 	this->material = material;
-	localShaderOptions = material->getShader(0)->createBinding();
+    localShaderOptions = new ShaderBinding();
+    
+    localShaderOptions->addAttributeBinding("texCoord", &mesh->vertexTexCoordArray);
+    localShaderOptions->addAttributeBinding("position", &mesh->vertexPositionArray);
+    
 	if(texture) {
 		localShaderOptions->clearTexture("diffuse");
 		localShaderOptions->addTexture("diffuse", texture);
@@ -356,11 +360,24 @@ void SceneMesh::Render(GPUDrawBuffer *buffer) {
     drawCall.options.backfaceCull = backfaceCulled;
     drawCall.options.depthTest = depthTest;
     drawCall.options.depthWrite = depthWrite;
-    drawCall.ownsAttributes = false;
+
+    drawCall.mode = mesh->getMeshType();
+    
     
-    drawCall.attributeArrays.push_back(&mesh->vertexPositionArray);
     drawCall.numVertices = mesh->getVertexCount();
     
+    if(mesh->indexedMesh) {
+        drawCall.indexed = true;
+        drawCall.indexArray = &mesh->indexArray;
+    } else {
+        drawCall.indexed = false;
+    }
+    
+    
+    drawCall.material = material;
+    drawCall.shaderBinding = localShaderOptions;
+    
+    buffer->drawCalls.push_back(drawCall);
     
     /*
    	if(material) {

Core/Contents/Source/PolyScenePrimitive.cpp

@@ -25,7 +25,7 @@
 
 using namespace Polycode;
 
-ScenePrimitive::ScenePrimitive(int type, Number v1, Number v2, Number v3,Number v4,Number v5) : SceneMesh(Mesh::QUAD_MESH) {
+ScenePrimitive::ScenePrimitive(int type, Number v1, Number v2, Number v3,Number v4,Number v5) : SceneMesh(Mesh::TRI_MESH) {
 
 	this->type = type;
 	this->v1 = v1;

Core/Contents/Source/PolySceneSprite.cpp

@@ -31,7 +31,7 @@ using std::vector;
 using namespace Polycode;
 
 
-SceneSprite::SceneSprite(SpriteSet *spriteSet) : SceneMesh(Mesh::QUAD_MESH) {
+SceneSprite::SceneSprite(SpriteSet *spriteSet) : SceneMesh(Mesh::TRI_MESH) {
     currentSprite = NULL;
     currentSpriteState = NULL;
     this->spriteSet = NULL;
@@ -383,7 +383,7 @@ void SpriteState::rebuildStateMeshes() {
     largestFrameBoundingBox = Vector3();
     
     for(int i=0; i < frameIDs.size(); i++) {
-        Mesh *frameMesh = new Mesh(Mesh::QUAD_MESH);
+        Mesh *frameMesh = new Mesh(Mesh::TRI_MESH);
         SpriteFrame frame = spriteSet->getSpriteFrameByID(frameIDs[i]);
         
         frameMesh->indexedMesh = true;
@@ -428,10 +428,9 @@ void SpriteState::rebuildStateMeshes() {
                 largestFrameBoundingBox.z = val;
             }
         }
-        frameMesh->addIndexedFace(0,1);
-        frameMesh->addIndexedFace(1,2);
-        frameMesh->addIndexedFace(2,3);
-        frameMesh->addIndexedFace(3,0);
+        
+        frameMesh->addIndexedFace(0, 1, 2);
+        frameMesh->addIndexedFace(0, 2, 3);
         
         frameMeshes.push_back(frameMesh);
     }

Core/Contents/Source/PolyShader.cpp

@@ -82,8 +82,7 @@ void ShaderProgram::reloadResource() {
 }
 
 
-ShaderBinding::ShaderBinding(Shader *shader) {
-	this->shader = shader;
+ShaderBinding::ShaderBinding() {
 }
 
 ShaderBinding::~ShaderBinding() {
@@ -113,6 +112,16 @@ LocalShaderParam *ShaderBinding::getLocalParamByName(const String& name) {
 	return NULL;
 }
 
+AttributeBinding *ShaderBinding::getAttributeBindingByName(const String &name) {
+    for(int i=0; i < attributes.size(); i++) {
+        if(attributes[i]->name == name) {
+            return attributes[i];
+        }
+    }
+    return NULL;
+}
+
+
 LocalShaderParam * ShaderBinding::addParam(int type, const String& name) {
 	void *defaultData = ProgramParam::createParamData(type);
 	LocalShaderParam *newParam = new LocalShaderParam();
@@ -259,10 +268,6 @@ int Shader::getExpectedParamType(String name) {
 	return ProgramParam::PARAM_UNKNOWN;
 }
 
-ShaderBinding *Shader::createBinding() {
-    return new ShaderBinding(this);
-}
-
 Shader::~Shader() {
 
 }
@@ -414,6 +419,14 @@ LocalShaderParam *LocalShaderParam::Copy() {
     return copyParam;
 }
 
+AttributeBinding *ShaderBinding::addAttributeBinding(const String &name, VertexDataArray *dataArray) {
+    AttributeBinding *binding = new AttributeBinding();
+    binding->name = name;
+    binding->vertexData = dataArray;
+    attributes.push_back(binding);
+    return binding;
+}
+
 void LocalShaderParam::setParamValueFromString(int type, String pvalue) {
         switch(type) {
             case ProgramParam::PARAM_NUMBER:

Core/Contents/Source/PolyTextMesh.cpp

@@ -1,46 +0,0 @@
-
-#include "PolyTextMesh.h"
-#include "PolyFontGlyphSheet.h"
-
-using namespace Polycode;
-
-TextMesh::TextMesh(FontGlyphSheet *font, const String &text)
-:	Mesh(QUAD_MESH)
-,	font(font)
-,	text(text)
-{
-	rebuild();
-}
-
-void TextMesh::setFont(FontGlyphSheet *font) {
-	this->font = font;
-	rebuild();
-}
-
-void TextMesh::setText(const String &text) {
-	if (text == this->text) return;
-	this->text = text;
-	rebuild();
-}
-
-void TextMesh::rebuild() {
-
-    // TODO: FIX
-/*
-	if (text == "" || font == NULL) {
-		for (std::vector<Vertex*>::iterator it = vertices.begin(); it != vertices.end(); it++) delete *it;
-		vertices.clear();
-		return;
-	}
-
-	int last = font->renderStringVertices(text, vertices);
-	if (last < vertices.size()) {
-		for (int i = last; i < vertices.size(); i++) {
-			delete vertices[i];
-		}
-		vertices.resize(last);
-	}
- */
-}
-
-

Modules/Contents/UI/Source/PolyUIColorBox.cpp

@@ -59,7 +59,7 @@ UIColorPicker::UIColorPicker() : UIWindow(L"", 300, 240) {
 	addChild(alphaSlider);
 	alphaSlider->addEventListener(this, UIEvent::CHANGE_EVENT);
 	
-	mainColorRect = new SceneMesh(Mesh::QUAD_MESH);
+	mainColorRect = new SceneMesh(Mesh::TRI_MESH);
     mainColorRect->setBlendingMode(Renderer::BLEND_MODE_NORMAL);
 	mainColorRect->setWidth(mainFrame->getWidth());
 	mainColorRect->setHeight(mainFrame->getWidth());
@@ -69,7 +69,12 @@ UIColorPicker::UIColorPicker() : UIWindow(L"", 300, 240) {
 	mainColorRect->getMesh()->addVertexWithUV(mainFrame->getWidth()/2,mainFrame->getHeight()/2.0,0, 1, 0);
 	mainColorRect->getMesh()->addVertexWithUV(mainFrame->getWidth()/2,-mainFrame->getHeight()/2.0,0, 1, 1);
 	mainColorRect->getMesh()->addVertexWithUV(-mainFrame->getWidth()/2,-mainFrame->getHeight()/2.0,0,0,1);
-	
+    
+    mainColorRect->getMesh()->indexedMesh = true;
+    
+    mainColorRect->getMesh()->addIndexedFace(0, 1, 2);
+    mainColorRect->getMesh()->addIndexedFace(0, 2, 3);
+    
 	mainColorRect->backfaceCulled = false;	
 
 	mainColorRect->setAnchorPoint(-1.0, -1.0, 0.0);

Modules/Contents/UI/Source/PolyUIElement.cpp

@@ -232,7 +232,7 @@ Number UIRect::getImageHeight() const {
 }
 
 void UIRect::initRect(Number width, Number height) {
-	rectMesh = new Mesh(Mesh::QUAD_MESH);
+	rectMesh = new Mesh(Mesh::TRI_MESH);
 	processInputEvents = true;
 
 	setAnchorPoint(-1.0, -1.0, 0.0);
@@ -246,6 +246,10 @@ void UIRect::initRect(Number width, Number height) {
 	rectMesh->addVertexWithUV(-whalf+width,-hhalf,0, 1, 0);
 	rectMesh->addVertexWithUV(-whalf+width,-hhalf+height,0, 1, 1);
 	rectMesh->addVertexWithUV(-whalf,-hhalf+height,0,0,1);
+    
+    rectMesh->indexedMesh = true;
+    rectMesh->addIndexedFace(0, 1, 2);
+    rectMesh->addIndexedFace(0, 2, 3);
 }
 
 UIRect::~UIRect() {