#5909: Separate time-dependent stage evaluation and state application…

… routines
codereader · Mar 13, 2022 · ac47e37 · ac47e37
1 parent 555c3b3
commit ac47e37
Show file tree

Hide file tree

Showing 4 changed files with 47 additions and 42 deletions.
diff --git a/radiantcore/rendersystem/backend/LightInteractions.cpp b/radiantcore/rendersystem/backend/LightInteractions.cpp
@@ -77,7 +77,7 @@ void LightInteractions::fillDepthBuffer(OpenGLState& state, RenderStateFlags glo
             }
 
             // Apply our state to the current state object
-            depthFillPass->applyState(state, globalFlagsMask, renderTime, entity);
+            depthFillPass->evaluateStagesAndApplyState(state, globalFlagsMask, renderTime, entity);
 
             auto depthFillProgram = depthFillPass->getDepthFillProgram();
 
@@ -140,7 +140,7 @@ void LightInteractions::render(OpenGLState& state, RenderStateFlags globalFlagsM
             if (pass && pass->stateIsActive())
             {
                 // Apply our state to the current state object
-                pass->applyState(state, globalFlagsMask, renderTime, entity);
+                pass->evaluateStagesAndApplyState(state, globalFlagsMask, renderTime, entity);
 
                 for (const auto& object : objects)
                 {

diff --git a/radiantcore/rendersystem/backend/LightingModeRenderer.cpp b/radiantcore/rendersystem/backend/LightingModeRenderer.cpp
@@ -106,7 +106,7 @@ IRenderResult::Ptr LightingModeRenderer::render(RenderStateFlags globalFlagsMask
                 }
 
                 // Apply our state to the current state object
-                pass.applyState(current, globalFlagsMask, time, entity.get());
+                pass.evaluateStagesAndApplyState(current, globalFlagsMask, time, entity.get());
 
                 if (current.glProgram)
                 {

diff --git a/radiantcore/rendersystem/backend/OpenGLShaderPass.cpp b/radiantcore/rendersystem/backend/OpenGLShaderPass.cpp
@@ -69,16 +69,15 @@ inline void setState(unsigned int state,
 
 inline void evaluateStage(const IShaderLayer::Ptr& stage, std::size_t time, const IRenderEntity* entity)
 {
-    if (stage)
+    if (!stage) return;
+
+    if (entity)
     {
-        if (entity)
-        {
-            stage->evaluateExpressions(time, *entity);
-        }
-        else
-        {
-            stage->evaluateExpressions(time);
-        }
+        stage->evaluateExpressions(time, *entity);
+    }
+    else
+    {
+        stage->evaluateExpressions(time);
     }
 }
 
@@ -162,7 +161,7 @@ void OpenGLShaderPass::setupTextureMatrix(GLenum textureUnit, const IShaderLayer
     }
     else
     {
-        glLoadMatrixd(Matrix4::getIdentity());
+        glLoadIdentity();
     }
 }
 
@@ -216,32 +215,34 @@ void OpenGLShaderPass::applyAllTextures(OpenGLState& current,
     }
 }
 
-// Apply own state to current state object
-void OpenGLShaderPass::applyState(OpenGLState& current,
-                                  unsigned int globalStateMask,
-                                  std::size_t time,
-                                  const IRenderEntity* entity)
+void OpenGLShaderPass::evaluateShaderStages(std::size_t time, const IRenderEntity* entity)
 {
-    // Evaluate any shader expressions
-    if (_glState.stage0)
-    {
-        evaluateStage(_glState.stage0, time, entity);
+    // Evaluate shader expressions in all stages
+    evaluateStage(_glState.stage0, time, entity);
+    evaluateStage(_glState.stage1, time, entity);
+    evaluateStage(_glState.stage2, time, entity);
+    evaluateStage(_glState.stage3, time, entity);
+    evaluateStage(_glState.stage4, time, entity);
+}
 
-        // The alpha test value might change over time
-        if (_glState.stage0->getAlphaTest() > 0)
-        {
-            _glState.setRenderFlag(RENDER_ALPHATEST);
-        }
-        else
-        {
-            _glState.clearRenderFlag(RENDER_ALPHATEST);
-        }
-    }
+void OpenGLShaderPass::evaluateStagesAndApplyState(OpenGLState& current,
+    unsigned int globalStateMask, std::size_t time, const IRenderEntity* entity)
+{
+    evaluateShaderStages(time, entity);
+    applyState(current, globalStateMask);
+}
 
-    if (_glState.stage1) evaluateStage(_glState.stage1, time, entity);
-    if (_glState.stage2) evaluateStage(_glState.stage2, time, entity);
-    if (_glState.stage3) evaluateStage(_glState.stage3, time, entity);
-    if (_glState.stage4) evaluateStage(_glState.stage4, time, entity);
+void OpenGLShaderPass::applyState(OpenGLState& current, unsigned int globalStateMask)
+{
+    // The alpha test value might change over time
+    if (_glState.stage0 && _glState.stage0->getAlphaTest() > 0)
+    {
+        _glState.setRenderFlag(RENDER_ALPHATEST);
+    }
+    else
+    {
+        _glState.clearRenderFlag(RENDER_ALPHATEST);
+    }
 
     if (_glState.testRenderFlag(RENDER_OVERRIDE))
     {
@@ -524,15 +525,15 @@ void OpenGLShaderPass::submitSurfaces(OpenGLState& current,
                               std::size_t time)
 {
     // Apply our state to the current state object
-    applyState(current, flagsMask, time, nullptr);
+    evaluateStagesAndApplyState(current, flagsMask, time, nullptr);
 
     _owner.drawSurfaces(view);
 }
 
 void OpenGLShaderPass::submitRenderables(OpenGLState& current, unsigned int flagsMask, std::size_t time)
 {
     // Apply our state to the current state object
-    applyState(current, flagsMask, time, nullptr);
+    evaluateStagesAndApplyState(current, flagsMask, time, nullptr);
 
     drawRenderables(current);
 }

diff --git a/radiantcore/rendersystem/backend/OpenGLShaderPass.h b/radiantcore/rendersystem/backend/OpenGLShaderPass.h
@@ -163,13 +163,17 @@ class OpenGLShaderPass
     // Whether this shader pass is suitable for the give view type
     bool isApplicableTo(RenderViewType renderViewType) const;
 
+    // Evaluates all stages and invokes applyState
+    void evaluateStagesAndApplyState(OpenGLState& current, unsigned int globalStateMask,
+        std::size_t time, const IRenderEntity* entity);
+
     // Apply own state to the "current" state object passed in as a reference,
     // in combination with the global state mask, as well as setting
     // relevant GL parameters directly.
-    void applyState(OpenGLState& current,
-        unsigned int globalStateMask,
-        std::size_t time,
-        const IRenderEntity* entity);
+    void applyState(OpenGLState& current, unsigned int globalStateMask);
+
+    // Evaluates the time- and entity-dependent expressions in the shader stages
+    void evaluateShaderStages(std::size_t time, const IRenderEntity* entity);
 
     // Set up lighting calculation
     static void SetUpLightingCalculation(OpenGLState& current,