Fixed test shader, more optimizations

Assets/Default asset pack/default/Unlit.vert

@@ -8,7 +8,7 @@ varying vec2 texCoordVar;
 
 void main()
 {
-	vec4 p = modelMatrix * viewMatrix * position;
+	vec4 p = viewMatrix * modelMatrix  * position;
 	gl_Position = projectionMatrix * p;
 	texCoordVar = texCoord;
 }

Core/Contents/Include/PolyGPUDrawBuffer.h

@@ -42,17 +42,6 @@ namespace Polycode {
         Color drawColor;
     };
     
-    class _PolyExport GPUShaderParam {
-    public:
-        ProgramParam *programParam;
-        LocalShaderParam *localParam;
-    };
-    
-    class _PolyExport GPUShaderAttribute {
-    public:
-        ProgramAttribute *programAttribute;
-        AttributeBinding *attributeBinding;
-    };
     
     class _PolyExport GPUDrawCall {
     public:
@@ -63,8 +52,6 @@ namespace Polycode {
         GPUDrawOptions options;
         Matrix4 modelMatrix;
         Material *material;
-        std::vector<GPUShaderParam> shaderParams;
-        std::vector<GPUShaderAttribute> shaderAttributes;
         ShaderBinding *shaderBinding;
         IndexDataArray *indexArray;
     };

Core/Contents/Include/PolyOpenGLGraphicsInterface.h

@@ -76,6 +76,7 @@ namespace Polycode {
         
 	protected:
 		
+        GLuint currentShaderID;
         int textureIndex;
         static GLenum getGLDrawMode(int polycodeMode);
         static int getPolycodeParamType(int glType);

Core/Contents/Include/PolyRenderer.h

@@ -99,10 +99,10 @@ namespace Polycode {
             static const int JOB_REQUEST_CONTEXT_CHANGE = 0;
             static const int JOB_CREATE_TEXTURE = 1;
             static const int JOB_PROCESS_DRAW_BUFFER = 2;
-            static const int JOB_FLUSH_CONTEXT = 3;
+            static const int JOB_END_FRAME = 3;
             static const int JOB_CREATE_PROGRAM = 4;
             static const int JOB_CREATE_SHADER = 5;
-        
+            static const int JOB_BEGIN_FRAME = 6;
         
         protected:
         
@@ -147,7 +147,8 @@ namespace Polycode {
         void setAnisotropyAmount(Number amount);
         Number getAnisotropyAmount();
         
-        void flushContext();
+        void beginFrame();
+        void endFrame();
         
         static const int BLEND_MODE_NONE = 0;
         static const int BLEND_MODE_NORMAL = 1;

Core/Contents/Include/PolySceneMesh.h

@@ -225,8 +225,6 @@ namespace Polycode {
             bool backfaceCulled;
         
             bool sendBoneMatricesToMaterial;
-        
-            void cacheShaderParams();
 			
 		protected:
 		
@@ -237,9 +235,6 @@ namespace Polycode {
 			Skeleton *skeleton;
 			ShaderBinding *localShaderOptions;
             String fileName;
-            std::vector<GPUShaderParam> shaderParams;
-            std::vector<GPUShaderAttribute> shaderAttributes;
-        
             std::vector<Matrix4> materialBoneMatrices;
         
             VertexDataArray skeletalVertexPositions;

Core/Contents/Include/PolyShader.h

@@ -98,6 +98,9 @@ namespace Polycode {
 			void setName(const String& name);
 			const String& getName() const;
 			
+            ProgramParam *getParamPointer(const String &name);
+            ProgramAttribute *getAttribPointer(const String &name);
+        
 			virtual void reload() {}
 			
 			int getExpectedParamType(String name);
@@ -150,7 +153,8 @@ namespace Polycode {
 			int type;
             bool ownsPointer;
             unsigned int arraySize;
-		
+            ProgramParam *param;
+        
             // Convenience getters/setters for Lua users
             Number getNumber();
             Vector2 getVector2();
@@ -173,6 +177,7 @@ namespace Polycode {
         public:
             String name;
             VertexDataArray *vertexData;
+            ProgramAttribute *attribute;
     };
 	
 	class RenderTargetBinding : public PolyBase {
@@ -199,6 +204,11 @@ namespace Polycode {
 			unsigned int getNumLocalParams();
 			LocalShaderParam *getLocalParam(unsigned int index);
 			LocalShaderParam *getLocalParamByName(const String& name);
+
+        
+            unsigned int getNumAttributeBindings();
+            AttributeBinding *getAttributeBinding(unsigned int index);
+
         
             AttributeBinding *addAttributeBinding(const String &name, VertexDataArray *dataArray);
             AttributeBinding *getAttributeBindingByName(const String &name);

Core/Contents/Source/PolyCocoaCore.mm

@@ -628,8 +628,9 @@ vector<String> CocoaCore::openFilePicker(vector<CoreFileExtension> extensions, b
 }
 
 void CocoaCore::Render() {
+    renderer->beginFrame();
     services->Render(Polycode::Rectangle(0, 0, getBackingXRes(), getBackingYRes()));
-    renderer->flushContext();
+    renderer->endFrame();
 }
 
 void CocoaCore::flushRenderContext() {

Core/Contents/Source/PolyOpenGLGraphicsInterface.cpp

@@ -117,7 +117,6 @@ void OpenGLGraphicsInterface::setParamInShader(Shader *shader, ProgramParam *par
             } else {
                 glBindTexture(GL_TEXTURE_2D, 0);
             }
-            
             textureIndex++;
         break;
         case ProgramParam::PARAM_CUBEMAP:
@@ -161,7 +160,10 @@ void OpenGLGraphicsInterface::beginDrawCall() {
 
 void OpenGLGraphicsInterface::useShader(Shader *shader) {
     GLuint shaderID = *((GLuint*) shader->platformData);
-    glUseProgram(shaderID);
+    if(shaderID != currentShaderID) {
+        glUseProgram(shaderID);
+        currentShaderID = shaderID;
+    }
 }
 
 void OpenGLGraphicsInterface::setAttributeInShader(Shader *shader, ProgramAttribute *attribute, AttributeBinding *attributeBinding) {

Core/Contents/Source/PolyRenderer.cpp

@@ -83,7 +83,6 @@ void RenderThread::processDrawBuffer(GPUDrawBuffer *buffer) {
     
     for(int i=0; i < buffer->drawCalls.size(); i++) {
         
-        interface->beginDrawCall();
         
         interface->setBlendingMode(buffer->drawCalls[i].options.blendingMode);
         interface->enableDepthTest(buffer->drawCalls[i].options.depthTest);
@@ -93,23 +92,77 @@ void RenderThread::processDrawBuffer(GPUDrawBuffer *buffer) {
         
         if(buffer->drawCalls[i].material) {
             
+            ShaderBinding *localShaderBinding = buffer->drawCalls[i].shaderBinding;
+            
             for(int s=0; s < buffer->drawCalls[i].material->getNumShaders(); s++) {
         
                 ++currentDebugFrameInfo.drawCallsProcessed;
+                interface->beginDrawCall();
                 
                 Shader *shader = buffer->drawCalls[i].material->getShader(s);
                 interface->useShader(shader);
                 
+                ShaderBinding *materialShaderBinding = buffer->drawCalls[i].material->getShaderBinding(s);
+
+                
                 // set shader uniforms
+                
+                for(int p=0; p < rendererShaderBinding->getNumLocalParams(); p++) {
+                    
+                    LocalShaderParam *localParam = rendererShaderBinding->getLocalParam(p);
+                    if(localParam) {
+                        if(!localParam->param) {
+                            localParam->param = shader->getParamPointer(localParam->name);
+                        }
+                        if(localParam->param) {
+                            interface->setParamInShader(shader, localParam->param, localParam);
+                        }
+                    }
+                    
+                }
    
-                for(int p=0; p < buffer->drawCalls[i].shaderParams.size(); p++) {
-                    interface->setParamInShader(shader, buffer->drawCalls[i].shaderParams[p].programParam, buffer->drawCalls[i].shaderParams[p].localParam);
+                for(int p=0; p < materialShaderBinding->getNumLocalParams(); p++) {
                     
+                    LocalShaderParam *localParam = materialShaderBinding->getLocalParam(p);
+                    if(localParam) {
+                        if(!localParam->param) {
+                            localParam->param = shader->getParamPointer(localParam->name);
+                        }
+                        if(localParam->param) {
+                            interface->setParamInShader(shader, localParam->param, localParam);
+                        }
+                    }
+
                 }
                 
-                 for(int a=0; a < buffer->drawCalls[i].shaderAttributes.size(); a++) {
-                        interface->setAttributeInShader(shader, buffer->drawCalls[i].shaderAttributes[a].programAttribute,  buffer->drawCalls[i].shaderAttributes[a].attributeBinding);
-                 }
+                for(int p=0; p < localShaderBinding->getNumLocalParams(); p++) {
+                    
+                    LocalShaderParam *localParam = localShaderBinding->getLocalParam(p);
+                    if(localParam) {
+                        if(!localParam->param) {
+                            localParam->param = shader->getParamPointer(localParam->name);
+                        }
+                        if(localParam->param) {
+                            interface->setParamInShader(shader, localParam->param, localParam);
+                        }
+                    }
+                    
+                }
+                
+                for(int a=0; a < localShaderBinding->getNumAttributeBindings(); a++) {
+                    
+                    AttributeBinding *attributeBinding = localShaderBinding->getAttributeBinding(a);
+                    
+                    if(attributeBinding) {
+                        if(!attributeBinding->attribute) {
+                            attributeBinding->attribute = shader->getAttribPointer(attributeBinding->name);
+                        }
+                        if(attributeBinding->attribute) {
+                             interface->setAttributeInShader(shader, attributeBinding->attribute, attributeBinding);
+                        }
+                    }
+                    
+                }
                 
                 if(buffer->drawCalls[i].indexed) {
                     interface->drawIndices(buffer->drawCalls[i].mode, buffer->drawCalls[i].indexArray);
@@ -151,18 +204,21 @@ void RenderThread::processJob(const RendererThreadJob &job) {
             delete buffer;
         }
         break;
-        case JOB_FLUSH_CONTEXT:
+        case JOB_BEGIN_FRAME:
         {
-            core->flushRenderContext();
-            
-            currentDebugFrameInfo.timeTaken = Services()->getCore()->getTicks() - frameStart;
-            lastFrameDebugInfo = currentDebugFrameInfo;
             currentDebugFrameInfo.buffersProcessed = 0;
             currentDebugFrameInfo.drawCallsProcessed = 0;
             currentDebugFrameInfo.timeTaken = 0;
             frameStart = Services()->getCore()->getTicks();
         }
         break;
+        case JOB_END_FRAME:
+        {
+            core->flushRenderContext();
+            currentDebugFrameInfo.timeTaken = Services()->getCore()->getTicks() - frameStart;
+            lastFrameDebugInfo = currentDebugFrameInfo;
+        }
+        break;
         case JOB_CREATE_PROGRAM:
         {
             ShaderProgram *program = (ShaderProgram*) job.data;
@@ -179,7 +235,11 @@ void RenderThread::processJob(const RendererThreadJob &job) {
 }
 
 RenderThreadDebugInfo RenderThread::getFrameInfo() {
-    return lastFrameDebugInfo;
+    RenderThreadDebugInfo info;
+    Services()->getCore()->lockMutex(jobQueueMutex);
+    info = lastFrameDebugInfo;
+    Services()->getCore()->unlockMutex(jobQueueMutex);
+    return info;
 }
 
 void RenderThread::enqueueJob(int jobType, void *data) {
@@ -245,8 +305,12 @@ void Renderer::processDrawBuffer(GPUDrawBuffer *buffer) {
     renderThread->enqueueJob(RenderThread::JOB_PROCESS_DRAW_BUFFER, buffer);
 }
 
-void Renderer::flushContext() {
-    renderThread->enqueueJob(RenderThread::JOB_FLUSH_CONTEXT, NULL);
+void Renderer::beginFrame() {
+    renderThread->enqueueJob(RenderThread::JOB_BEGIN_FRAME, NULL);
+}
+
+void Renderer::endFrame() {
+    renderThread->enqueueJob(RenderThread::JOB_END_FRAME, NULL);
 }
 
 Texture *Renderer::createTexture(unsigned int width, unsigned int height, char *textureData, bool clamp, bool createMipmaps, int type) {

Core/Contents/Source/PolySceneMesh.cpp

@@ -336,73 +336,6 @@ bool SceneMesh::customHitDetection(const Ray &ray) {
 	return false;
 }
 
-void SceneMesh::cacheShaderParams() {
-    
-    shaderParams.clear();
-    shaderAttributes.clear();
-    
-    if(!material) {
-        return;
-    }
-    
-    if(material->getNumShaders() == 0) {
-        return;
-    }
-    
-    // TODO: do this for every shader
-    
-    Shader *shader = material->getShader(0);
-    ShaderBinding *materialShaderBinding = material->getShaderBinding(0);
-    ShaderBinding *rendererShaderBinding = Services()->getRenderer()->getRenderThread()->getShaderBinding();
-    
-    for(int p=0; p < shader->expectedParams.size(); p++) {
-        
-        LocalShaderParam *localParam = NULL;
-        localParam = rendererShaderBinding->getLocalParamByName(shader->expectedParams[p].name);
-        
-        // material options override renderer options
-        
-        LocalShaderParam *materialOptionsParam = materialShaderBinding->getLocalParamByName(shader->expectedParams[p].name);
-        if(materialOptionsParam) {
-            localParam = materialOptionsParam;
-        }
-        
-        // local options override material options
-        LocalShaderParam *localOptionsParam = localShaderOptions->getLocalParamByName(shader->expectedParams[p].name);
-        if(localOptionsParam) {
-            localParam = localOptionsParam;
-        }
-        
-        GPUShaderParam shaderParam;
-        shaderParam.programParam = &shader->expectedParams[p];
-        shaderParam.localParam = localParam;
-        shaderParams.push_back(shaderParam);
-        
-    }
-    
-    for(int a=0; a < shader->expectedAttributes.size(); a++) {
-        
-        AttributeBinding *attributeBinding = NULL;
-        attributeBinding = materialShaderBinding->getAttributeBindingByName(shader->expectedAttributes[a].name);
-        
-        // local options override material options
-        
-        AttributeBinding *localAttributeBinding = localShaderOptions->getAttributeBindingByName(shader->expectedAttributes[a].name);
-        
-        if(localAttributeBinding) {
-            attributeBinding = localAttributeBinding;
-        }
-        
-        if(attributeBinding) {
-            GPUShaderAttribute attribute;
-            attribute.attributeBinding = attributeBinding;
-            attribute.programAttribute = &shader->expectedAttributes[a];
-            shaderAttributes.push_back(attribute);
-        }
-        
-    }
-    
-}
 
 void SceneMesh::Render(GPUDrawBuffer *buffer) {
     
@@ -428,9 +361,6 @@ void SceneMesh::Render(GPUDrawBuffer *buffer) {
     drawCall.material = material;
     drawCall.shaderBinding = localShaderOptions;
     
-    drawCall.shaderParams = shaderParams;
-    drawCall.shaderAttributes = shaderAttributes;
-    
     buffer->drawCalls.push_back(drawCall);
     
     /*

Core/Contents/Source/PolyShader.cpp

@@ -105,6 +105,13 @@ unsigned int ShaderBinding::getNumLocalParams() {
 	return localParams.size();
 }
 
+unsigned int ShaderBinding::getNumAttributeBindings() {
+    return attributes.size();
+}
+
+AttributeBinding *ShaderBinding::getAttributeBinding(unsigned int index) {
+    return attributes[index];
+}
 
 LocalShaderParam *ShaderBinding::getLocalParam(unsigned int index) {
 	return localParams[index];
@@ -135,6 +142,7 @@ LocalShaderParam * ShaderBinding::addParam(int type, const String& name) {
 	newParam->data = defaultData;
 	newParam->name = name;
     newParam->type = type;
+    newParam->param = NULL;
 	localParams.push_back(newParam);
 	return newParam;
 }
@@ -144,6 +152,7 @@ LocalShaderParam *ShaderBinding::addParamPointer(int type, const String& name, v
     newParam->name = name;
     newParam->data = ptr;
     newParam->type = type;
+    newParam->param = NULL;
     newParam->ownsPointer = false;
     localParams.push_back(newParam);
     return newParam;
@@ -257,6 +266,25 @@ Shader::Shader() : Resource(Resource::RESOURCE_SHADER) {
 	fragmentProgram = NULL;
 }
 
+ProgramParam *Shader::getParamPointer(const String &name) {
+    for(int i=0; i < expectedParams.size(); i++) {
+        if(expectedParams[i].name == name) {
+            return &expectedParams[i];
+        }
+    }
+    return NULL;
+}
+
+ProgramAttribute *Shader::getAttribPointer(const String &name) {
+    for(int i=0; i < expectedAttributes.size(); i++) {
+        if(expectedAttributes[i].name == name) {
+            return &expectedAttributes[i];
+        }
+    }
+    return NULL;
+}
+
+
 int Shader::getExpectedParamType(String name) {
 	for(int i=0; i < expectedParams.size(); i++) {
 		if(expectedParams[i].name == name) {
@@ -428,6 +456,7 @@ LocalShaderParam *LocalShaderParam::Copy() {
 AttributeBinding *ShaderBinding::addAttributeBinding(const String &name, VertexDataArray *dataArray) {
     AttributeBinding *binding = new AttributeBinding();
     binding->name = name;
+    binding->attribute = NULL;
     binding->vertexData = dataArray;
     attributes.push_back(binding);
     return binding;