Ticket #1859: ModelCache.2.patch

source/renderer/ModelRenderer.cpp

@@ -453 +453 @@
             }
 
             SMRMaterialBucketKey key(model->GetMaterial().GetShaderEffect(), defs);
-            std::vector<CModel*>& bucketItems = materialBuckets[key];
-            bucketItems.push_back(model);
+            materialBuckets[key].push_back(model);
         }
     }
-
     std::vector<SMRSortByDistItem> sortByDistItems;
 
     std::vector<CShaderTechniquePtr> sortByDistTechs;
@@ -573 +571 @@
 
         size_t idxTechStart = 0;
         
-        // This vector keeps track of texture changes during rendering. It is kept outside the
-        // loops to avoid excessive reallocations. The token allocation of 64 elements 
-        // should be plenty, though it is reallocated below (at a cost) if necessary.
-        std::vector<CTexture*> currentTexs;
-        currentTexs.reserve(64);
         
-        // texBindings holds the identifier bindings in the shader, which can no longer be defined 
-        // statically in the ShaderRenderModifier class. texBindingNames uses interned strings to
-        // keep track of when bindings need to be reevaluated.
-        std::vector<CShaderProgram::Binding> texBindings;
-        texBindings.reserve(64);
-        std::vector<CStrIntern> texBindingNames;
-        texBindingNames.reserve(64);
-
+        // using "4" as the maximal size of these arrays as it's what we currently use at most.
+        // will crash if using more.
+        // This is temporary.
+        
+        CTexture* currentTexs[4];
+        CShaderProgram::Binding texBindings[4];
+        CStrIntern texBindingNames[4];
+        
         while (idxTechStart < techBuckets.size())
         {
             CShaderTechniquePtr currentTech = techBuckets[idxTechStart].tech;
@@ -611 +604 @@
 
                 m->vertexRenderer->BeginPass(streamflags);
                 
-                // When the shader technique changes, textures need to be
-                // rebound, so ensure there are no remnants from the last pass.
-                // (the vector size is set to 0, but memory is not freed)
-                currentTexs.clear();
-                texBindings.clear();
-                texBindingNames.clear();
+                // reinitialize the values since we're using a new shader that has not be bound yet.
+                for (size_t i = 0; i < 4; ++i)
+                {
+                    texBindingNames[i] = CStrIntern();
+                    currentTexs[i] = NULL;
+                    texBindings[i] = CShaderProgram::Binding();
+                }
                 
                 CModelDef* currentModeldef = NULL;
                 CShaderUniforms currentStaticUniforms;
@@ -625 +619 @@
                 {
                     CModel** models = techBuckets[idx].models;
                     size_t numModels = techBuckets[idx].numModels;
+
                     for (size_t i = 0; i < numModels; ++i)
                     {
                         CModel* model = models[i];
@@ -635 +630 @@
                         CMaterial::SamplersVector samplers = model->GetMaterial().GetSamplers();
                         size_t samplersNum = samplers.size();
                         
-                        // make sure the vectors are the right virtual sizes, and also
-                        // reallocate if there are more samplers than expected.
-                        if (currentTexs.size() != samplersNum)
+                        // We only cache up to 4. If there are more, we won't use caching
+                        // TODO: this isn't really nice, it probably ought to fail or something.
+                        if (samplersNum > 4)
                         {
-                            currentTexs.resize(samplersNum, NULL);
-                            texBindings.resize(samplersNum, CShaderProgram::Binding());
-                            texBindingNames.resize(samplersNum, CStrIntern());
-                            
-                            // ensure they are definitely empty
-                            std::fill(texBindings.begin(), texBindings.end(), CShaderProgram::Binding());
-                            std::fill(currentTexs.begin(), currentTexs.end(), (CTexture*)NULL);
-                            std::fill(texBindingNames.begin(), texBindingNames.end(), CStrIntern());
-                        }
-                        
-                        // bind the samplers to the shader
-                        for (size_t s = 0; s < samplersNum; ++s)
-                        {
-                            CMaterial::TextureSampler &samp = samplers[s];
-                            
-                            CShaderProgram::Binding bind = texBindings[s];
-                            // check that the handles are current
-                            // and reevaluate them if necessary
-                            if (texBindingNames[s] == samp.Name && bind.Active())
+                            for (size_t s = 0; s < samplersNum; ++s)
                             {
-                                bind = texBindings[s];
+                                CMaterial::TextureSampler &samp = samplers[s];
+                                CShaderProgram::Binding bind = texBindings[s];
+                                bind = shader->GetTextureBinding(samp.Name.c_str());
+                                if (bind.Active())
+                                    shader->BindTexture(bind, samp.Sampler->GetHandle());
                             }
-                            else
+                        } else {
+                            // bind the samplers to the shader
+                            for (size_t s = 0; s < samplersNum; ++s)
                             {
-                                bind = shader->GetTextureBinding(samp.Name.c_str());        
-                                texBindings[s] = bind;
-                                texBindingNames[s] = samp.Name;
+                                CMaterial::TextureSampler &samp = samplers[s];
+                                
+                                CShaderProgram::Binding bind = texBindings[s];
+                                // check that the handles are current
+                                // and reevaluate them if necessary
+                                if (!(texBindingNames[s] == samp.Name))
+                                {
+                                    bind = shader->GetTextureBinding(samp.Name.c_str());
+                                    texBindings[s] = bind;
+                                    texBindingNames[s] = samp.Name;
+                                }
+                                
+                                // same with the actual sampler bindings
+                                CTexture* newTex = samp.Sampler.get();
+                                if (bind.Active() && newTex != currentTexs[s])
+                                {
+                                    shader->BindTexture(bind, samp.Sampler->GetHandle());
+                                    currentTexs[s] = newTex;
+                                }
                             }
-
-                            // same with the actual sampler bindings
-                            CTexture* newTex = samp.Sampler.get();
-                            if (bind.Active() && newTex != currentTexs[s])
-                            {
-                                shader->BindTexture(bind, samp.Sampler->GetHandle());
-                                currentTexs[s] = newTex;
-                            }
                         }
                         
                         // Bind modeldef when it changes