Split glow to avoid re-bind color framebuffer

src/graphics/abstract_renderer.cpp

@@ -194,11 +194,3 @@ void AbstractRenderer::drawJoint(bool drawline, bool drawname,
 } //drawJoint
 
 #endif //DEBUG
-
-AbstractRenderer::AbstractRenderer()
-{
-    resetObjectCount();
-    resetPolyCount();
-}
-
-

src/graphics/abstract_renderer.hpp

@@ -26,16 +26,6 @@
 
 class RenderTarget;
 
-enum STKRenderingPass
-{
-    SOLID_NORMAL_AND_DEPTH_PASS,
-    SOLID_LIT_PASS,
-    TRANSPARENT_PASS,
-    GLOW_PASS,
-    SHADOW_PASS,
-    PASS_COUNT,
-};
-
 enum TypeRTT : unsigned int;
 
 struct GlowData {
@@ -56,10 +46,6 @@ class AbstractRenderer
 protected:
     irr::core::vector2df m_current_screen_size;
 
-    /** Performance stats */
-    unsigned             m_object_count[PASS_COUNT];
-    unsigned             m_poly_count  [PASS_COUNT];
-
 #ifdef DEBUG
     void drawDebugMeshes() const;
 
@@ -71,7 +57,7 @@ protected:
     void renderSkybox(const irr::scene::ICameraSceneNode *camera) const;
 
 public:
-    AbstractRenderer();
+    AbstractRenderer() {}
     virtual ~AbstractRenderer(){}
         
     virtual void onLoadWorld()   = 0;
@@ -114,14 +100,6 @@ public:
      */
     virtual std::unique_ptr<RenderTarget> createRenderTarget(const irr::core::dimension2du &dimension,
                                                              const std::string &name) = 0;
-    
-    void resetObjectCount()                     { memset(m_object_count, 0, sizeof(m_object_count));}
-    void resetPolyCount()                       { memset(m_poly_count, 0, sizeof(m_poly_count));    }
-    void incObjectCount(STKRenderingPass phase) {  m_object_count[phase]++;                         }
-    
-    unsigned getObjectCount(STKRenderingPass pass) const { return m_object_count[pass];             }
-    unsigned getPolyCount(STKRenderingPass pass) const   { return m_poly_count  [pass];             }
-    
 };
 
 #endif //HEADER_ABSTRACT_RENDERER_HPP

src/graphics/irr_driver.cpp

@@ -116,7 +116,6 @@ const bool ALLOW_1280_X_720    = true;
 IrrDriver::IrrDriver()
 {
     m_resolution_changing = RES_CHANGE_NONE;
-    m_phase               = SOLID_NORMAL_AND_DEPTH_PASS;
 
     struct irr::SIrrlichtCreationParameters p;
     p.DriverType    = video::EDT_NULL;
@@ -174,24 +173,6 @@ void IrrDriver::reset()
 #endif
 }   // reset
 
-// ----------------------------------------------------------------------------
-void IrrDriver::setPhase(STKRenderingPass p)
-{
-    m_phase = p;
-}
-
-// ----------------------------------------------------------------------------
-STKRenderingPass IrrDriver::getPhase() const
-{
-  return m_phase;
-}
-
-#// ----------------------------------------------------------------------------
-void IrrDriver::increaseObjectCount()
-{
-    m_renderer->incObjectCount(m_phase);
-}   // increaseObjectCount
-
 // ----------------------------------------------------------------------------
 core::array<video::IRenderTarget> &IrrDriver::getMainSetup()
 {

src/graphics/irr_driver.hpp

@@ -175,7 +175,7 @@ private:
 
     unsigned             m_last_light_bucket_distance;
     unsigned             m_skinning_joint;
-    u32                  m_renderpass;
+
     SP::SPDynamicDrawCall* m_sun_interposer;
     core::vector3df m_sun_direction;
     video::SColorf m_suncolor;
@@ -187,8 +187,6 @@ private:
 
     std::vector<scene::ISceneNode *> m_background;
 
-    STKRenderingPass m_phase;
-
     float m_ssao_radius;
     float m_ssao_k;
     float m_ssao_sigma;
@@ -209,8 +207,6 @@ public:
     void getOpenGLData(std::string *vendor, std::string *renderer,
                        std::string *version);
 
-    void setPhase(STKRenderingPass);
-    STKRenderingPass getPhase() const;
     void increaseObjectCount();
     core::array<video::IRenderTarget> &getMainSetup();
     void updateConfigIfRelevant();
@@ -419,8 +415,6 @@ public:
     // ------------------------------------------------------------------------
     void setRecording(bool val);
     // ------------------------------------------------------------------------
-    u32 getRenderPass() { return m_renderpass; }
-    // ------------------------------------------------------------------------
     std::vector<LightNode *> getLights() { return m_lights; }
     // ------------------------------------------------------------------------
     void addGlowingNode(scene::ISceneNode *n, float r = 1.0f, float g = 1.0f,

src/graphics/post_processing.cpp

@@ -1055,23 +1055,13 @@ void PostProcessing::renderTextureLayer(unsigned tex, unsigned layer) const
 }   // renderTextureLayer
 
 // ----------------------------------------------------------------------------
-void PostProcessing::renderGlow(const FrameBuffer& glow_framebuffer,
+void PostProcessing::renderGlow(const FrameBuffer& quarter_framebuffer) const
-                                const FrameBuffer& half_framebuffer,
-                                const FrameBuffer& quarter_framebuffer,
-                                const FrameBuffer& color_framebuffer   ) const
 {
-    // To half
-    FrameBuffer::blit(glow_framebuffer, half_framebuffer, GL_COLOR_BUFFER_BIT, GL_LINEAR);
-
-    // To quarter
-    FrameBuffer::blit(half_framebuffer, quarter_framebuffer, GL_COLOR_BUFFER_BIT, GL_LINEAR);
-
     glEnable(GL_BLEND);
     glBlendEquation(GL_FUNC_ADD);
     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
     glStencilFunc(GL_EQUAL, 0, ~0);
     glEnable(GL_STENCIL_TEST);
-    color_framebuffer.bind();
     GlowShader::getInstance()->render(quarter_framebuffer.getRTT()[0]);
     glDisable(GL_STENCIL_TEST);
     glDisable(GL_BLEND);

src/graphics/post_processing.hpp

@@ -99,10 +99,7 @@ public:
     void renderMotionBlur(const FrameBuffer &in_fbo,
                           FrameBuffer &out_fbo,
                           GLuint depth_stencil_texture);
-    void renderGlow(const FrameBuffer& glow_framebuffer,
+    void renderGlow(const FrameBuffer& quarter_framebuffer) const;
-                    const FrameBuffer& half_framebuffer,
-                    const FrameBuffer& quarter_framebuffer,
-                    const FrameBuffer& color_framebuffer) const;
     void renderLightning(core::vector3df intensity);
 
     /** Use motion blur for a short time */

src/graphics/rtts.cpp

@@ -190,7 +190,7 @@ RTT::RTT(unsigned int width, unsigned int height, float rtt_scale,
 
         somevector.clear();
         somevector.push_back(m_render_target_textures[RTT_RGBA_2]);
-        m_frame_buffers[FBO_RGBA_2] = new FrameBuffer(somevector, res.Width, res.Height);
+        m_frame_buffers[FBO_RGBA_2] = new FrameBuffer(somevector, m_depth_stencil_tex, res.Width, res.Height);
 
         somevector.clear();
         somevector.push_back(m_render_target_textures[RTT_DIFFUSE]);

src/graphics/shader_based_renderer.cpp

@@ -148,7 +148,7 @@ void ShaderBasedRenderer::renderSSAO() const
 void ShaderBasedRenderer::renderGlow() const
 {
     irr_driver->getSceneManager()->setCurrentRendertime(scene::ESNRP_SOLID);
-    m_rtts->getFBO(FBO_RGBA_1).bind();
+    m_rtts->getFBO(FBO_RGBA_2).bind();
     glClearStencil(0);
     glClearColor(0, 0, 0, 0);
     glClear(GL_STENCIL_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
@@ -236,11 +236,7 @@ void ShaderBasedRenderer::renderSceneDeferred(scene::ICameraSceneNode * const ca
     irr_driver->getSceneManager()->setActiveCamera(camnode);
 
     PROFILER_PUSH_CPU_MARKER("- Draw Call Generation", 0xFF, 0xFF, 0xFF);
-    unsigned solid_poly_count = 0;
-    unsigned shadow_poly_count = 0;
     m_draw_calls.prepareDrawCalls(camnode);
-    m_poly_count[SOLID_NORMAL_AND_DEPTH_PASS] += solid_poly_count;
-    m_poly_count[SHADOW_PASS] += shadow_poly_count;
     PROFILER_POP_CPU_MARKER();
     PROFILER_PUSH_CPU_MARKER("Update Light Info", 0xFF, 0x0, 0x0);
     m_lighting_passes.updateLightsInfo(camnode, dt);
@@ -279,7 +275,7 @@ void ShaderBasedRenderer::renderSceneDeferred(scene::ICameraSceneNode * const ca
         glClearBufferfv(GL_COLOR, 1, clear_color_empty);
         glClearBufferfv(GL_COLOR, 2, clear_color_gloss);
         glClearBufferfi(GL_DEPTH_STENCIL, 0, 1.0f, 0);
-        ScopedGPUTimer Timer(irr_driver->getGPUTimer(Q_SOLID_PASS1));
+        ScopedGPUTimer Timer(irr_driver->getGPUTimer(Q_SOLID_PASS));
         SP::draw(SP::RP_1ST, SP::DCT_NORMAL);
     }
 
@@ -325,12 +321,27 @@ void ShaderBasedRenderer::renderSceneDeferred(scene::ICameraSceneNode * const ca
         PROFILER_POP_CPU_MARKER();
     }
 
+    // Render anything glowing.
+    if (UserConfigParams::m_glow)
+    {
+        PROFILER_PUSH_CPU_MARKER("- Glow", 0xFF, 0xFF, 0x00);
+        ScopedGPUTimer Timer(irr_driver->getGPUTimer(Q_GLOW));
+        renderGlow();
+        // To half
+        FrameBuffer::blit(m_rtts->getFBO(FBO_RGBA_2),
+            m_rtts->getFBO(FBO_HALF2), GL_COLOR_BUFFER_BIT, GL_LINEAR);
+        // To quarter
+        FrameBuffer::blit(m_rtts->getFBO(FBO_HALF2),
+            m_rtts->getFBO(FBO_QUARTER1), GL_COLOR_BUFFER_BIT, GL_LINEAR);
+        PROFILER_POP_CPU_MARKER();
+    } // end glow
+
     m_rtts->getFBO(FBO_COLORS).bind();
     glClear(GL_COLOR_BUFFER_BIT);
 
     {
         PROFILER_PUSH_CPU_MARKER("- Combine diffuse color", 0x2F, 0x77, 0x33);
-        ScopedGPUTimer Timer(irr_driver->getGPUTimer(Q_SOLID_PASS2));
+        ScopedGPUTimer Timer(irr_driver->getGPUTimer(Q_COMBINE_DIFFUSE_COLOR));
         glDisable(GL_DEPTH_TEST);
         glDepthMask(GL_FALSE);
         glDisable(GL_BLEND);
@@ -361,20 +372,10 @@ void ShaderBasedRenderer::renderSceneDeferred(scene::ICameraSceneNode * const ca
         PROFILER_POP_CPU_MARKER();
     }
 
-
-    PROFILER_PUSH_CPU_MARKER("- Glow", 0xFF, 0xFF, 0x00);
-    // Render anything glowing.
     if (UserConfigParams::m_glow)
     {
-        ScopedGPUTimer Timer(irr_driver->getGPUTimer(Q_GLOW));
+        m_post_processing->renderGlow(m_rtts->getFBO(FBO_QUARTER1));
-        irr_driver->setPhase(GLOW_PASS);
+    }
-        renderGlow();
-        m_post_processing->renderGlow(m_rtts->getFBO(FBO_RGBA_1),
-                                      m_rtts->getFBO(FBO_HALF1),
-                                      m_rtts->getFBO(FBO_QUARTER1),
-                                      m_rtts->getFBO(FBO_COLORS));
-    } // end glow
-    PROFILER_POP_CPU_MARKER();
 
     // Render transparent
     {
@@ -406,8 +407,6 @@ void ShaderBasedRenderer::renderSceneDeferred(scene::ICameraSceneNode * const ca
         return;
     }
 
-    // Ensure that no object will be drawn after that by using invalid pass
-    irr_driver->setPhase(PASS_COUNT);
 } //renderSceneDeferred
 
 // ----------------------------------------------------------------------------
@@ -425,11 +424,7 @@ void ShaderBasedRenderer::renderScene(scene::ICameraSceneNode * const camnode,
     irr_driver->getSceneManager()->setActiveCamera(camnode);
 
     PROFILER_PUSH_CPU_MARKER("- Draw Call Generation", 0xFF, 0xFF, 0xFF);
-    unsigned solid_poly_count = 0;
-    unsigned shadow_poly_count = 0;
     m_draw_calls.prepareDrawCalls(camnode);
-    m_poly_count[SOLID_NORMAL_AND_DEPTH_PASS] += solid_poly_count;
-    m_poly_count[SHADOW_PASS] += shadow_poly_count;
     PROFILER_POP_CPU_MARKER();
 
     glDepthMask(GL_TRUE);
@@ -456,7 +451,7 @@ void ShaderBasedRenderer::renderScene(scene::ICameraSceneNode * const camnode,
         glDepthMask(GL_TRUE);
         glEnable(GL_DEPTH_TEST);
         glDisable(GL_BLEND);
-        ScopedGPUTimer Timer(irr_driver->getGPUTimer(Q_SOLID_PASS1));
+        ScopedGPUTimer Timer(irr_driver->getGPUTimer(Q_SOLID_PASS));
         SP::draw(SP::RP_1ST, SP::DCT_NORMAL);
     }
 
@@ -497,8 +492,6 @@ void ShaderBasedRenderer::renderScene(scene::ICameraSceneNode * const camnode,
         return;
     }
 
-    // Ensure that no object will be drawn after that by using invalid pass
-    irr_driver->setPhase(PASS_COUNT);
 } //renderScene
 
 // ----------------------------------------------------------------------------
@@ -712,9 +705,6 @@ void ShaderBasedRenderer::addSunLight(const core::vector3df &pos)
 // ----------------------------------------------------------------------------
 void ShaderBasedRenderer::render(float dt)
 {
-    resetObjectCount();
-    resetPolyCount();
-
     // Start the RTT for post-processing.
     // We do this before beginScene() because we want to capture the glClear()
     // because of tracks that do not have skyboxes (generally add-on tracks)
@@ -852,8 +842,6 @@ void ShaderBasedRenderer::renderToTexture(GL3RenderTarget *render_target,
     // For render to texture no triple buffering of ubo is used
     SP::sp_cur_player = 0;
     SP::sp_cur_buf_id[0] = 0;
-    resetObjectCount();
-    resetPolyCount();
     assert(m_rtts != NULL);
 
     irr_driver->getSceneManager()->setActiveCamera(camera);

src/utils/profiler.cpp

@@ -41,22 +41,17 @@ static const char* GPU_Phase[Q_LAST] =
     "Shadows Cascade 1",
     "Shadows Cascade 2",
     "Shadows Cascade 3",
-    "Shadows Postprocess",
+    "Solid Pass",
-    "Solid Pass 1",
-    "RSM",
-    "RH",
-    "GI",
     "Env Map",
     "SunLight",
     "PointLights",
     "SSAO",
-    "Solid Pass 2",
     "Fog",
-    "Skybox",
     "Glow",
+    "Combine Diffuse Color",
+    "Skybox",
     "Transparent",
     "Particles",
-    "Displacement",
     "Depth of Field",
     "Godrays",
     "Bloom",

src/utils/profiler.hpp

@@ -39,22 +39,17 @@ enum QueryPerf
     Q_SHADOWS_CASCADE1,
     Q_SHADOWS_CASCADE2,
     Q_SHADOWS_CASCADE3,
-    Q_SHADOW_POSTPROCESS,
+    Q_SOLID_PASS,
-    Q_SOLID_PASS1,
-    Q_RSM,
-    Q_RH,
-    Q_GI,
     Q_ENVMAP,
     Q_SUN,
     Q_POINTLIGHTS,
     Q_SSAO,
-    Q_SOLID_PASS2,
     Q_FOG,
-    Q_SKYBOX,
     Q_GLOW,
+    Q_COMBINE_DIFFUSE_COLOR,
+    Q_SKYBOX,
     Q_TRANSPARENT,
     Q_PARTICLES,
-    Q_DISPLACEMENT,
     Q_DOF,
     Q_GODRAYS,
     Q_BLOOM,