Ticket #3073: Instancing_v1b.patch

binaries/data/mods/public/shaders/glsl/model_common.vs

@@ -1 +1 @@
 #version 120
+#extension GL_ARB_draw_instanced : enable
 
 uniform mat4 transform;
 uniform vec3 cameraPos;
@@ -11 +12 @@
 #endif
 uniform vec2 losTransform;
 uniform mat4 shadowTransform;
-uniform mat4 instancingTransform;
+uniform mat4 instancingTransforms[250];
 
 #if USE_SHADOW_SAMPLER && USE_SHADOW_PCF
   uniform vec4 shadowScale;
@@ -74 +75 @@
 
 void main()
 {
+  mat4 instancingTransform = instancingTransforms[gl_InstanceIDARB];//mat4(a_instancingTransform0, a_instancingTransform1, a_instancingTransform2, a_instancingTransform3);
+
   #if USE_GPU_SKINNING
     vec3 p = vec3(0.0);
     vec3 n = vec3(0.0);

source/graphics/ShaderProgram.cpp

@@ -484 +484 @@
         pglUseProgramObjectARB(m_Program);
 
         for (std::map<CStrIntern, int>::iterator it = m_VertexAttribs.begin(); it != m_VertexAttribs.end(); ++it)
+        {
             pglEnableVertexAttribArrayARB(it->second);
+
+            if (it->first == str_a_instancingTransform0
+                    || it->first == str_a_instancingTransform1
+                    || it->first == str_a_instancingTransform2
+                    || it->first == str_a_instancingTransform3
+            )
+            {
+                pglVertexAttribDivisorARB(it->second, 1);
     }
+        }
+    }
 
     virtual void Unbind()
     {
@@ -492 +503 @@
         pglUseProgramObjectARB(0);
 
         for (std::map<CStrIntern, int>::iterator it = m_VertexAttribs.begin(); it != m_VertexAttribs.end(); ++it)
+        {
             pglDisableVertexAttribArrayARB(it->second);
+            pglVertexAttribDivisorARB(it->second, 0);
+        }
 
         // TODO: should unbind textures, probably
     }

source/lib/external_libraries/glext_funcs.h

@@ -383 +383 @@
 FUNC(void, glDeletePerfQueryINTEL, (GLuint id))
 FUNC(void, glGetPerfQueryDataINTEL, (GLuint id, GLenum requestType, GLuint maxLength, char *buffer, GLuint *length))
 
+// GL_ARB_draw_instanced
+FUNC(void, glDrawArraysInstancedARB, (GLenum mode, GLint first, GLsizei count, GLsizei primcount))
+FUNC(void, glDrawElementsInstancedARB, (GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei primcount))
+
+// GL_ARB_instanced_arrays
+FUNC(void, glVertexAttribDivisorARB, (GLuint index, GLuint divisor))
+
 #endif  // #if CONFIG_GLES2
 
 

source/ps/CStrInternStatic.h

@@ -73 +73 @@
 X(a_splashPosition)
 X(a_tangent)
 X(a_waterInfo)
+X(a_instancingTransform0)
+X(a_instancingTransform1)
+X(a_instancingTransform2)
+X(a_instancingTransform3)
 X(ambient)
 X(baseTex)
 X(blendTex)
@@ -99 +103 @@
 X(hdr)
 X(height)
 X(instancingTransform)
+X2(instancingTransforms, "instancingTransforms[0]")
 X(losMap)
 X(losMatrix)
 X(losTex)

source/renderer/ModelVertexRenderer.h

@@ -154 +154 @@
      * succeed.
      */
     virtual void RenderModel(const CShaderProgramPtr& shader, int streamflags, CModel* model, CModelRData* data) = 0;
+
+    virtual void RenderModelInstanced(const CShaderProgramPtr& shader, int streamflags, CModel* model, size_t count) { };
+    
+    virtual bool IsInstanced() const = 0;
+
 };
 
 

source/renderer/VertexArray.h

@@ -157 +157 @@
     };
     
 public:
-    VertexArray(GLenum usage, GLenum target = GL_ARRAY_BUFFER);
+    VertexArray(GLenum usage = GL_DYNAMIC_DRAW, GLenum target = GL_ARRAY_BUFFER);
     ~VertexArray();
     
     // Set the number of vertices stored in the array

source/renderer/InstancingModelRenderer.cpp

@@ -389 +389 @@
     g_Renderer.m_Stats.m_ModelTris += numFaces;
 
 }
+
+void InstancingModelRenderer::RenderModelInstanced(const CShaderProgramPtr& shader, int UNUSED(streamflags), CModel* model, size_t count)
+{
+    CModelDefPtr mdldef = model->GetModelDef();
+
+    // render the lot
+    size_t numFaces = mdldef->GetNumFaces();
+    if (!g_Renderer.m_SkipSubmit)
+    {
+        // Draw with DrawRangeElements where available, since it might be more efficient
+        pglDrawElementsInstancedARB(GL_TRIANGLES, (GLsizei)numFaces*3, GL_UNSIGNED_SHORT, m->imodeldefIndexBase, count);
+//      pglDrawRangeElementsEXT(GL_TRIANGLES, 0, (GLuint)m->imodeldef->m_Array.GetNumVertices()-1,
+//              (GLsizei)numFaces*3, GL_UNSIGNED_SHORT, m->imodeldefIndexBase);
+    }
+
+    // bump stats
+    g_Renderer.m_Stats.m_DrawCalls++;
+    g_Renderer.m_Stats.m_ModelTris += numFaces * count;
+
+}

source/renderer/HWLightingModelRenderer.h

@@ -47 +47 @@
     void PrepareModelDef(const CShaderProgramPtr& shader, int streamflags, const CModelDef& def);
     void RenderModel(const CShaderProgramPtr& shader, int streamflags, CModel* model, CModelRData* data);
 
+    bool IsInstanced() const { return false; };
+
 protected:
     ShaderModelRendererInternals* m;
 };

source/renderer/ModelRenderer.cpp

@@ -215 +215 @@
 
     /// List of submitted models for rendering in this frame
     std::vector<CModel*> submissions[CRenderer::CULL_MAX];
+
+#define NUM_INSTANCING_ARRAYS 256
+    VertexArray instancingArray[NUM_INSTANCING_ARRAYS];
+    VertexArray::Attribute instancingTransform[NUM_INSTANCING_ARRAYS][4];
+    size_t currentInstancingArray;
 };
 
 
@@ -223 +228 @@
 {
     m = new ShaderModelRendererInternals(this);
     m->vertexRenderer = vertexrenderer;
+
+    for (size_t j = 0; j < NUM_INSTANCING_ARRAYS; ++j)
+    {
+        for (size_t i = 0; i < 4; ++i)
+        {
+            m->instancingTransform[j][i].type = GL_FLOAT;
+            m->instancingTransform[j][i].elems = 4;
+            m->instancingArray[j].AddAttribute(&m->instancingTransform[j][i]);
+        }
+
+        m->instancingArray[j].SetNumVertices(64);
+        m->instancingArray[j].Layout();
+    }
+
+    m->currentInstancingArray = 0;
 }
 
 ShaderModelRenderer::~ShaderModelRenderer()
@@ -363 +383 @@
     }
 };
 
+bool hasChanged(CModel* lastModel, CModel* newModel)
+{
+    if (lastModel->GetModelDef().get() != newModel->GetModelDef().get())
+        return true;
+    return false;
+}
+
 void ShaderModelRenderer::Render(const RenderModifierPtr& modifier, const CShaderDefines& context, int cullGroup, int flags)
 {
     if (m->submissions[cullGroup].empty())
@@ -618 +645 @@
         typedef ProxyAllocator<CStrIntern, Allocators::DynamicArena> BindingNamesListAllocator;
         std::vector<CStrIntern, BindingNamesListAllocator> texBindingNames((BindingNamesListAllocator(arena)));
         texBindingNames.reserve(64);
-
+printf("----\n");
         while (idxTechStart < techBuckets.size())
         {
             CShaderTechniquePtr currentTech = techBuckets[idxTechStart].tech;
@@ -655 +682 @@
 
                 for (size_t idx = idxTechStart; idx < idxTechEnd; ++idx)
                 {
+                    int instances = 0;
+
+                    std::vector<CMatrix3D> instancingTransforms;
+
                     CModel** models = techBuckets[idx].models;
                     size_t numModels = techBuckets[idx].numModels;
+
+                    if (numModels == 0)
+                        continue;
+
+                    CModel* newModel = NULL;
+                    
                     for (size_t i = 0; i < numModels; ++i)
                     {
                         CModel* model = models[i];
-
+                        
                         if (flags && !(model->GetFlags() & flags))
                             continue;
-
+                        
+                        if (m->vertexRenderer->IsInstanced())
+                        {
+                            instances++;
+                            CMatrix3D transform = model->GetTransform();
+                            instancingTransforms.push_back(transform);
+                        
+                            if (i < numModels-1)
+                            {
+                                newModel = models[i+1];
+                                while (i < numModels-1 && instances < 250 && !hasChanged(model, newModel)) {
+                                    model = models[++i];
+                                    instances++;
+                                    CMatrix3D transform = model->GetTransform();
+                                    instancingTransforms.push_back(transform);
+                                    newModel = models[i+1];
+                                }
+                            }
+                        }
+                        
                         const CMaterial::SamplersVector& samplers = model->GetMaterial().GetSamplers();
                         size_t samplersNum = samplers.size();
                         
@@ -730 +786 @@
                         for (size_t q = 0; q < renderQueries.GetSize(); q++)
                         {
                             CShaderRenderQueries::RenderQuery rq = renderQueries.GetItem(q);
-                            if (rq.first == RQUERY_TIME)
+                            if (rq.first == RQUERY_TIME && i == 0)
                             {
                                 CShaderProgram::Binding binding = shader->GetUniformBinding(rq.second);
                                 if (binding.Active())
@@ -756 +812 @@
                                 shader->BindTexture(str_skyCube, g_Renderer.GetSkyManager()->GetSkyCube());
                             }
                         }
-
+                        
                         modifier->PrepareModel(shader, model);
-
+                        
+                        if (m->vertexRenderer->IsInstanced())
+                        {
+                            shader->Uniform(str_instancingTransforms, instancingTransforms.size(), &instancingTransforms[0]);
+                            m->vertexRenderer->RenderModelInstanced(shader, streamflags, model, instances);
+                            instances = 0;
+                            instancingTransforms.clear();
+                        }
+                        else
+                        {
                         CModelRData* rdata = static_cast<CModelRData*>(model->GetRenderData());
                         ENSURE(rdata->GetKey() == m->vertexRenderer.get());
-
+                            
                         m->vertexRenderer->RenderModel(shader, streamflags, model, rdata);
                     }
                 }
+                }
 
                 m->vertexRenderer->EndPass(streamflags);
 

source/renderer/InstancingModelRenderer.h

@@ -46 +46 @@
     void EndPass(int streamflags);
     void PrepareModelDef(const CShaderProgramPtr& shader, int streamflags, const CModelDef& def);
     void RenderModel(const CShaderProgramPtr& shader, int streamflags, CModel* model, CModelRData* data);
+    void RenderModelInstanced(const CShaderProgramPtr& shader, int streamflags, CModel* model, size_t count);
 
+    bool IsInstanced() const { return true; }
+    
 protected:
     InstancingModelRendererInternals* m;
 };