Improved interfaces

src/graphics/abstract_renderer.hpp

@@ -49,7 +49,7 @@ public:
     virtual void render(float dt) = 0;
 
     virtual void renderScene(irr::scene::ICameraSceneNode * const camnode,
-                             std::vector<GlowData>& glows,
+                             const std::vector<GlowData>& glows,
                              float dt, bool hasShadows, bool forceRTT) = 0;
                              
     virtual void updateLightsInfo(irr::scene::ICameraSceneNode * const camnode,

src/graphics/draw_calls.cpp

@@ -542,6 +542,7 @@ void DrawCalls::renderParticlesList() const
  */ 
 void DrawCalls::drawIndirectSolidFirstPass() const
 {
+    m_solid_cmd_buffer.bind();
     m_solid_cmd_buffer.drawIndirectFirstPass<DefaultMaterial>();
     m_solid_cmd_buffer.drawIndirectFirstPass<AlphaRef>();
     m_solid_cmd_buffer.drawIndirectFirstPass<UnlitMat>();
@@ -557,6 +558,7 @@ void DrawCalls::drawIndirectSolidFirstPass() const
  */ 
 void DrawCalls::multidrawSolidFirstPass() const
 {
+    m_solid_cmd_buffer.bind();
     m_solid_cmd_buffer.multidrawFirstPass<DefaultMaterial>();
     m_solid_cmd_buffer.multidrawFirstPass<AlphaRef>();
     m_solid_cmd_buffer.multidrawFirstPass<SphereMap>();
@@ -569,6 +571,7 @@ void DrawCalls::multidrawSolidFirstPass() const
 // ----------------------------------------------------------------------------
 void DrawCalls::drawIndirectSolidSecondPass(const std::vector<GLuint> &prefilled_tex) const
 {
+    m_solid_cmd_buffer.bind();
     m_solid_cmd_buffer.drawIndirectSecondPass<DefaultMaterial>(prefilled_tex);
     m_solid_cmd_buffer.drawIndirectSecondPass<AlphaRef>(prefilled_tex);
     m_solid_cmd_buffer.drawIndirectSecondPass<UnlitMat>(prefilled_tex);
@@ -581,6 +584,7 @@ void DrawCalls::drawIndirectSolidSecondPass(const std::vector<GLuint> &prefilled
 // ----------------------------------------------------------------------------
 void DrawCalls::multidrawSolidSecondPass(const std::vector<uint64_t> &handles) const
 {
+    m_solid_cmd_buffer.bind();
     m_solid_cmd_buffer.multidraw2ndPass<DefaultMaterial>(handles);
     m_solid_cmd_buffer.multidraw2ndPass<AlphaRef>(handles);
     m_solid_cmd_buffer.multidraw2ndPass<SphereMap>(handles);
@@ -593,6 +597,7 @@ void DrawCalls::multidrawSolidSecondPass(const std::vector<uint64_t> &handles) c
 // ----------------------------------------------------------------------------
 void DrawCalls::drawIndirectNormals() const
 {
+    m_solid_cmd_buffer.bind();
     m_solid_cmd_buffer.drawIndirectNormals<DefaultMaterial>();
     m_solid_cmd_buffer.drawIndirectNormals<AlphaRef>();
     m_solid_cmd_buffer.drawIndirectNormals<UnlitMat>();
@@ -604,6 +609,7 @@ void DrawCalls::drawIndirectNormals() const
 // ----------------------------------------------------------------------------
 void DrawCalls::multidrawNormals() const
 {
+    m_solid_cmd_buffer.bind();
     m_solid_cmd_buffer.multidrawNormals<DefaultMaterial>();
     m_solid_cmd_buffer.multidrawNormals<AlphaRef>();
     m_solid_cmd_buffer.multidrawNormals<UnlitMat>();
@@ -615,17 +621,19 @@ void DrawCalls::multidrawNormals() const
 // ----------------------------------------------------------------------------
 void DrawCalls::drawIndirectShadows(unsigned cascade) const
 {
+    m_shadow_cmd_buffer.bind();
     m_shadow_cmd_buffer.drawIndirect<DefaultMaterial>(cascade);
     m_shadow_cmd_buffer.drawIndirect<DetailMat>(cascade);
     m_shadow_cmd_buffer.drawIndirect<AlphaRef>(cascade);
     m_shadow_cmd_buffer.drawIndirect<UnlitMat>(cascade);
     m_shadow_cmd_buffer.drawIndirect<GrassMat,irr::core::vector3df>(windDir, cascade);
     m_shadow_cmd_buffer.drawIndirect<NormalMat>(cascade);
-    
+    m_shadow_cmd_buffer.drawIndirect<SplattingMat>(cascade);
 }
 
 void DrawCalls::multidrawShadows(unsigned cascade) const
 {
+    m_shadow_cmd_buffer.bind();
     m_shadow_cmd_buffer.multidrawShadow<DefaultMaterial>(cascade);
     m_shadow_cmd_buffer.multidrawShadow<DetailMat>(cascade);
     m_shadow_cmd_buffer.multidrawShadow<NormalMat>(cascade);
@@ -637,6 +645,7 @@ void DrawCalls::multidrawShadows(unsigned cascade) const
 // ----------------------------------------------------------------------------
 void DrawCalls::drawIndirectReflectiveShadowMaps(const core::matrix4 &rsm_matrix) const
 {
+    m_reflective_shadow_map_cmd_buffer.bind();
     m_reflective_shadow_map_cmd_buffer.drawIndirect<DefaultMaterial>(rsm_matrix);
     m_reflective_shadow_map_cmd_buffer.drawIndirect<AlphaRef>(rsm_matrix);
     m_reflective_shadow_map_cmd_buffer.drawIndirect<UnlitMat>(rsm_matrix);
@@ -647,6 +656,7 @@ void DrawCalls::drawIndirectReflectiveShadowMaps(const core::matrix4 &rsm_matrix
 // ----------------------------------------------------------------------------
 void DrawCalls::multidrawReflectiveShadowMaps(const core::matrix4 &rsm_matrix) const
 {
+    m_reflective_shadow_map_cmd_buffer.bind();
     m_reflective_shadow_map_cmd_buffer.multidraw<DefaultMaterial>(rsm_matrix);
     m_reflective_shadow_map_cmd_buffer.multidraw<NormalMat>(rsm_matrix);
     m_reflective_shadow_map_cmd_buffer.multidraw<AlphaRef>(rsm_matrix);
@@ -657,11 +667,13 @@ void DrawCalls::multidrawReflectiveShadowMaps(const core::matrix4 &rsm_matrix) c
 // ----------------------------------------------------------------------------
 void DrawCalls::drawIndirectGlow() const
 {
+    m_glow_cmd_buffer.bind();
     m_glow_cmd_buffer.drawIndirect();
 }
 
 // ----------------------------------------------------------------------------
 void DrawCalls::multidrawGlow() const
 {
+    m_glow_cmd_buffer.bind();
     m_glow_cmd_buffer.multidraw();
 }

src/graphics/draw_calls.hpp

@@ -48,8 +48,7 @@ private:
     ShadowCommandBuffer                   m_shadow_cmd_buffer;
     ReflectiveShadowMapCommandBuffer      m_reflective_shadow_map_cmd_buffer;
     GlowCommandBuffer                     m_glow_cmd_buffer;
-    
+        
-    
     irr::core::vector3df windDir; //TODO: same member in geometry_passes
     
     MeshMap m_solid_pass_mesh           [Material::SHADERTYPE_COUNT]    ;
@@ -88,11 +87,6 @@ public:
     void renderBillboardList()      const;
     void renderParticlesList()     const;
 
-    inline void bindSolidCmd() const { m_solid_cmd_buffer.bind(); }
-    inline void bindShadowCmd() const { m_shadow_cmd_buffer.bind(); }
-    inline void bindReflectiveShadowMapsCmd() const { m_reflective_shadow_map_cmd_buffer.bind(); }
-    inline void bindGlowCmd() const { m_glow_cmd_buffer.bind(); }
-
     void drawIndirectSolidFirstPass() const;
     void multidrawSolidFirstPass() const;
     void drawIndirectSolidSecondPass(const std::vector<GLuint> &prefilled_tex) const;

src/graphics/fixed_pipeline_renderer.hpp

@@ -26,7 +26,7 @@ public:
     
     void render(float dt);
     void renderScene(irr::scene::ICameraSceneNode * const camnode,
-                     std::vector<GlowData>& glows,
+                     const std::vector<GlowData>& glows,
                      float dt, bool hasShadows, bool forceRTT){}
     void updateLightsInfo(irr::scene::ICameraSceneNode * const camnode,
                               float dt){}

src/graphics/geometry_passes.cpp

@@ -176,9 +176,6 @@ void GeometryPasses::renderSolidFirstPass(const DrawCalls& draw_calls)
 {
     m_wind_dir = getWindDir(); //TODO: why this function instead of Wind::getWind()?
 
-    if (CVS->supportsIndirectInstancingRendering())
-        draw_calls.bindSolidCmd();
-
     {
         ScopedGPUTimer Timer(irr_driver->getGPUTimer(Q_SOLID_PASS1));
         irr_driver->setPhase(SOLID_NORMAL_AND_DEPTH_PASS);
@@ -279,9 +276,6 @@ void GeometryPasses::renderSolidSecondPass( const DrawCalls& draw_calls,
         if (!glIsTextureHandleResidentARB(DepthHandle))
             glMakeTextureHandleResidentARB(DepthHandle);
     }
-
-    if (CVS->supportsIndirectInstancingRendering())
-        draw_calls.bindSolidCmd();
         
     {
         ScopedGPUTimer Timer(irr_driver->getGPUTimer(Q_SOLID_PASS2));
@@ -344,7 +338,7 @@ void GeometryPasses::renderNormalsVisualisation(const DrawCalls& draw_calls)
 
 // ----------------------------------------------------------------------------
 
-void GeometryPasses::renderGlow(const DrawCalls& draw_calls, std::vector<GlowData>& glows)
+void GeometryPasses::renderGlow(const DrawCalls& draw_calls, const std::vector<GlowData>& glows)
 {
     irr_driver->getSceneManager()->setCurrentRendertime(scene::ESNRP_SOLID);
     irr_driver->getRTT()->getFBO(FBO_TMP1_WITH_DS).bind();
@@ -377,7 +371,6 @@ void GeometryPasses::renderGlow(const DrawCalls& draw_calls, std::vector<GlowDat
 
     if (CVS->supportsIndirectInstancingRendering())
     {
-        draw_calls.bindGlowCmd();
          if (CVS->isAZDOEnabled())
         {
             draw_calls.multidrawGlow();
@@ -632,16 +625,12 @@ void GeometryPasses::renderShadows(const DrawCalls& draw_calls,
         renderShadow<DefaultMaterial, 1>(cascade);
         renderShadow<SphereMap, 1>(cascade);
         renderShadow<DetailMat, 1>(cascade);
-        renderShadow<SplattingMat, 1>(cascade);
+        //renderShadow<SplattingMat, 1>(cascade);
         renderShadow<NormalMat, 1>(cascade);
         renderShadow<AlphaRef, 1>(cascade);
         renderShadow<UnlitMat, 1>(cascade);
         renderShadow<GrassMat, 3, 1>(cascade);
 
-        if (CVS->supportsIndirectInstancingRendering())
-            draw_calls.bindShadowCmd();
-
-
         if (CVS->isAZDOEnabled())
         {
             draw_calls.multidrawShadows(cascade);
@@ -716,9 +705,6 @@ void GeometryPasses::renderReflectiveShadowMap(const DrawCalls& draw_calls,
     drawRSM<DetailMat, 3, 1>(rsm_matrix);
     drawRSM<SplattingMat, 1>(rsm_matrix);
 
-    if (CVS->supportsIndirectInstancingRendering())
-        draw_calls.bindReflectiveShadowMapsCmd();
-
     if (CVS->isAZDOEnabled())
     {
         draw_calls.multidrawReflectiveShadowMaps(rsm_matrix);

src/graphics/shader_based_renderer.cpp

@@ -160,7 +160,7 @@ void ShaderBasedRenderer::computeMatrixesAndCameras(scene::ICameraSceneNode *con
 
 // ============================================================================
 void ShaderBasedRenderer::renderScene(scene::ICameraSceneNode * const camnode,
-                                      std::vector<GlowData>& glows,
+                                      const std::vector<GlowData>& glows,
                                       float dt,
                                       bool hasShadow,
                                       bool forceRTT)

src/graphics/shader_based_renderer.hpp

@@ -53,7 +53,7 @@ private:
     void prepareDrawCalls(scene::ICameraSceneNode *camnode);
 
     void renderScene(irr::scene::ICameraSceneNode * const camnode,
-                     std::vector<GlowData>& glows,
+                     const std::vector<GlowData>& glows,
                      float dt, bool hasShadows, bool forceRTT);
                      
     void renderParticles();