Removed getFBO method in IrrDriver

src/graphics/abstract_renderer.hpp

@@ -60,7 +60,7 @@ public:
     virtual void onLoadWorld()   = 0;
     virtual void onUnloadWorld() = 0;
 
-    virtual void reset() {}
+    virtual void resetPostProcessing() {}
     virtual void giveBoost(unsigned int cam_index) {}
 
     virtual void addSkyBox(const std::vector<irr::video::ITexture*> &texture,

src/graphics/geometry_passes.cpp

@@ -158,6 +158,7 @@ void AbstractGeometryPasses::prepareShadowRendering(const FrameBuffer& shadow_fr
 
 void AbstractGeometryPasses::shadowPostProcessing(const ShadowMatrices& shadow_matrices,
                                                   const FrameBuffer& shadow_framebuffer,
+                                                  const FrameBuffer& scalar_framebuffer,
                                                   const PostProcessing* post_processing) const
 {
     ScopedGPUTimer Timer(irr_driver->getGPUTimer(Q_SHADOW_POSTPROCESS));
@@ -170,7 +171,7 @@ void AbstractGeometryPasses::shadowPostProcessing(const ShadowMatrices& shadow_m
         for (unsigned i = 0; i < 2; i++)
         {
             post_processing->renderGaussian6BlurLayer(
-                shadow_framebuffer, i,
+                shadow_framebuffer, scalar_framebuffer, i,
                 2.f * shadow_scales[0].first / shadow_scales[i].first,
                 2.f * shadow_scales[0].second / shadow_scales[i].second);
         }
@@ -264,7 +265,11 @@ void renderTransparenPass(const std::vector<RenderGeometry::TexUnit> &TexUnits,
 }   // renderTransparenPass
 
 // ----------------------------------------------------------------------------
-void AbstractGeometryPasses::renderTransparent(const DrawCalls& draw_calls, unsigned render_target, const PostProcessing* post_processing)
+void AbstractGeometryPasses::renderTransparent(const DrawCalls& draw_calls,
+                                               const FrameBuffer& tmp_framebuffer,
+                                               const FrameBuffer& displace_framebuffer,
+                                               const FrameBuffer& colors_framebuffer,
+                                               const PostProcessing* post_processing)
 {
 
     glEnable(GL_DEPTH_TEST);
@@ -312,9 +317,9 @@ void AbstractGeometryPasses::renderTransparent(const DrawCalls& draw_calls, unsi
         return;
 
     // Render displacement nodes
-    irr_driver->getFBO(FBO_TMP1_WITH_DS).bind();
+    tmp_framebuffer.bind();
     glClear(GL_COLOR_BUFFER_BIT);
-    irr_driver->getFBO(FBO_DISPLACE).bind();
+    displace_framebuffer.bind();
     glClear(GL_COLOR_BUFFER_BIT);
 
     DisplaceProvider * const cb =
@@ -333,7 +338,7 @@ void AbstractGeometryPasses::renderTransparent(const DrawCalls& draw_calls, unsi
         glBindVertexArray(VAOManager::getInstance()->getVAO(video::EVT_2TCOORDS));
     // Generate displace mask
     // Use RTT_TMP4 as displace mask
-    irr_driver->getFBO(FBO_TMP1_WITH_DS).bind();
+    tmp_framebuffer.bind();
     for (unsigned i = 0; i < ListDisplacement::getInstance()->size(); i++)
     {
         const GLMesh &mesh =
@@ -360,7 +365,7 @@ void AbstractGeometryPasses::renderTransparent(const DrawCalls& draw_calls, unsi
                                  (GLvoid *)mesh.vaoOffset, (int)mesh.vaoBaseVertex);
     }
 
-    irr_driver->getFBO(FBO_DISPLACE).bind();
+    displace_framebuffer.bind();
     for (unsigned i = 0; i < ListDisplacement::getInstance()->size(); i++)
     {
         const GLMesh &mesh = 
@@ -378,8 +383,8 @@ void AbstractGeometryPasses::renderTransparent(const DrawCalls& draw_calls, unsi
         // Render the effect
         DisplaceShader::getInstance()->setTextureUnits(
             getTextureGLuint(m_displace_tex),
-            irr_driver->getRenderTargetTexture(RTT_COLOR),
+            colors_framebuffer.getRTT()[0],
-            irr_driver->getRenderTargetTexture(RTT_TMP1),
+            tmp_framebuffer.getRTT()[0],
             getTextureGLuint(mesh.textures[0]));
         DisplaceShader::getInstance()->use();
         DisplaceShader::getInstance()->setUniforms(AbsoluteTransformation,
@@ -390,11 +395,11 @@ void AbstractGeometryPasses::renderTransparent(const DrawCalls& draw_calls, unsi
                                  (int)mesh.vaoBaseVertex);
     }
 
-    irr_driver->getFBO(FBO_COLORS).bind();
+    colors_framebuffer.bind();
     glStencilFunc(GL_EQUAL, 1, 0xFF);
-    post_processing->renderPassThrough(render_target,
+    post_processing->renderPassThrough(displace_framebuffer.getRTT()[0],
-                                       irr_driver->getFBO(FBO_COLORS).getWidth(), 
+                                       colors_framebuffer.getWidth(), 
-                                       irr_driver->getFBO(FBO_COLORS).getHeight());
+                                       colors_framebuffer.getHeight());
     glDisable(GL_STENCIL_TEST);
 
 }   // renderTransparent

src/graphics/geometry_passes.hpp

@@ -41,6 +41,7 @@ protected:
     void prepareShadowRendering(const FrameBuffer& shadow_framebuffer) const;
     void shadowPostProcessing(const ShadowMatrices& shadow_matrices,
                               const FrameBuffer& shadow_framebuffer,
+                              const FrameBuffer& scalar_framebuffer,
                               const PostProcessing* post_processing) const;
                 
     //TODO: move it in ShaderBasedRenderer
@@ -73,12 +74,15 @@ public:
                             const PostProcessing* post_processing  ) const = 0;
     
     void renderTransparent(const DrawCalls& draw_calls,
-                           unsigned render_target,
+                           const FrameBuffer& tmp_framebuffer,
+                           const FrameBuffer& displace_framebuffer,
+                           const FrameBuffer& colors_framebuffer,
                            const PostProcessing* post_processing);
                            
     virtual void renderShadows(const DrawCalls& draw_calls,
                                const ShadowMatrices& shadow_matrices,
                                const FrameBuffer& shadow_framebuffer,
+                               const FrameBuffer& scalar_framebuffer,
                                const PostProcessing* post_processing) const = 0;
                        
                        
@@ -162,6 +166,7 @@ public:
     void renderShadows(const DrawCalls& draw_calls,
                        const ShadowMatrices& shadow_matrices,
                        const FrameBuffer& shadow_framebuffer,
+                       const FrameBuffer& scalar_framebuffer,
                        const PostProcessing* post_processing) const
     {
         prepareShadowRendering(shadow_framebuffer);
@@ -175,7 +180,8 @@ public:
         glDisable(GL_POLYGON_OFFSET_FILL);
 
         if (CVS->isESMEnabled())
-            shadowPostProcessing(shadow_matrices, shadow_framebuffer, post_processing);
+            shadowPostProcessing(shadow_matrices, shadow_framebuffer,
+                                 scalar_framebuffer, post_processing);
     }
 
 

src/graphics/irr_driver.cpp

@@ -156,7 +156,7 @@ IrrDriver::~IrrDriver()
  */
 void IrrDriver::reset()
 {
-    m_renderer->reset();
+    m_renderer->resetPostProcessing();
 }   // reset
 
 void IrrDriver::setPhase(STKRenderingPass p)
@@ -2193,14 +2193,6 @@ GLuint IrrDriver::getRenderTargetTexture(TypeRTT which)
 }   // getRenderTargetTexture
 
 // ----------------------------------------------------------------------------
-
-FrameBuffer& IrrDriver::getFBO(TypeFBO which)
-{
-    return m_renderer->getRTT()->getFBO(which);
-}   // getFBO
-
-// ----------------------------------------------------------------------------
-
 GLuint IrrDriver::getDepthStencilTexture()
 {
     return m_renderer->getRTT()->getDepthStencilTexture();

src/graphics/irr_driver.hpp

@@ -208,10 +208,7 @@ private:
     std::vector<irr::scene::IAnimatedMeshSceneNode*> m_debug_meshes;
 #endif
 
-public: //TODO: move into renderer class
+public:
-    void renderGlow(std::vector<GlowData>& glows);
-    void renderSSAO();
-    void renderShadowsDebug();
     void doScreenShot();    
 public:
          IrrDriver();
@@ -413,7 +410,6 @@ public:
     }
     // ------------------------------------------------------------------------
     GLuint getRenderTargetTexture(TypeRTT which);
-    FrameBuffer& getFBO(TypeFBO which);
     GLuint getDepthStencilTexture();
     // ------------------------------------------------------------------------
     void resetDebugModes()

src/graphics/post_processing.cpp

@@ -982,6 +982,7 @@ void PostProcessing::renderGaussian3Blur(const FrameBuffer &in_fbo,
 
 // ----------------------------------------------------------------------------
 void PostProcessing::renderGaussian6BlurLayer(const FrameBuffer &in_fbo,
+                                              const FrameBuffer &scalar_fbo,
                                               size_t layer, float sigma_h,
                                               float sigma_v) const
 {
@@ -992,14 +993,14 @@ void PostProcessing::renderGaussian6BlurLayer(const FrameBuffer &in_fbo,
     if (!CVS->supportsComputeShadersFiltering())
     {
         // Used as temp
-        irr_driver->getFBO(FBO_SCALAR_1024).bind();
+        scalar_fbo.bind();
         Gaussian6VBlurShader::getInstance()
             ->render(layer_tex, UserConfigParams::m_shadows_resolution, 
                      UserConfigParams::m_shadows_resolution, sigma_v);
 
         in_fbo.bindLayer(layer);
         Gaussian6HBlurShader::getInstance()
-            ->render(irr_driver->getFBO(FBO_SCALAR_1024),
+            ->render(scalar_fbo,
                      UserConfigParams::m_shadows_resolution, 
                      UserConfigParams::m_shadows_resolution, sigma_h);
     }
@@ -1011,7 +1012,7 @@ void PostProcessing::renderGaussian6BlurLayer(const FrameBuffer &in_fbo,
         ComputeShadowBlurVShader::getInstance()->setTextureUnits(layer_tex);
         glBindSampler(ComputeShadowBlurVShader::getInstance()->m_dest_tu, 0);
         glBindImageTexture(ComputeShadowBlurVShader::getInstance()->m_dest_tu,
-                           irr_driver->getFBO(FBO_SCALAR_1024).getRTT()[0], 0,
+                           scalar_fbo.getRTT()[0], 0,
                            false, 0, GL_WRITE_ONLY, GL_R32F);
         ComputeShadowBlurVShader::getInstance()->setUniforms
             (core::vector2df(1.f / UserConfigParams::m_shadows_resolution,
@@ -1025,7 +1026,7 @@ void PostProcessing::renderGaussian6BlurLayer(const FrameBuffer &in_fbo,
                         | GL_SHADER_IMAGE_ACCESS_BARRIER_BIT);
         ComputeShadowBlurHShader::getInstance()->use();
         ComputeShadowBlurHShader::getInstance()
-            ->setTextureUnits(irr_driver->getFBO(FBO_SCALAR_1024).getRTT()[0]);
+            ->setTextureUnits(scalar_fbo.getRTT()[0]);
         glBindSampler(ComputeShadowBlurHShader::getInstance()->m_dest_tu, 0);
         glBindImageTexture(ComputeShadowBlurHShader::getInstance()->m_dest_tu,
                            layer_tex, 0, false, 0, GL_WRITE_ONLY, GL_R32F);
@@ -1274,7 +1275,7 @@ void PostProcessing::renderGodRays(scene::ICameraSceneNode * const camnode,
     glDisable(GL_DEPTH_TEST);
 
     // Fade to quarter
-    irr_driver->getFBO(FBO_QUARTER1).bind();
+    quarter1_fbo.bind();
     glViewport(0, 0, irr_driver->getActualScreenSize().Width / 4,
                      irr_driver->getActualScreenSize().Height / 4);
     GodFadeShader::getInstance()->render(fbo.getRTT()[0], col);
@@ -1299,7 +1300,7 @@ void PostProcessing::renderGodRays(scene::ICameraSceneNode * const camnode,
     const float suny = ((ndc[1] / ndc[3]) * 0.5f + 0.5f) * texh;
 
     // Rays please
-    irr_driver->getFBO(FBO_QUARTER2).bind();
+    quarter2_fbo.bind();
     GodRayShader::getInstance()
         ->render(quarter1_fbo.getRTT()[0], core::vector2df(sunx, suny));
 
@@ -1536,7 +1537,7 @@ FrameBuffer *PostProcessing::render(scene::ICameraSceneNode * const camnode,
 
     glEnable(GL_FRAMEBUFFER_SRGB);
     if(specified_render_target == NULL)
-        out_fbo = &irr_driver->getFBO(FBO_MLAA_COLORS);
+        out_fbo = &rtts->getFBO(FBO_MLAA_COLORS);
     else
         out_fbo = specified_render_target->getFrameBuffer();
     

src/graphics/post_processing.hpp

@@ -89,8 +89,8 @@ public:
                               float sigmaV, float sigmaH) const;
 	void renderHorizontalBlur(const FrameBuffer &in_fbo, const FrameBuffer &auxiliary) const;
 
-    void renderGaussian6BlurLayer(const FrameBuffer &in_fbo, size_t layer,
+    void renderGaussian6BlurLayer(const FrameBuffer &in_fbo, const FrameBuffer &scalar_fbo,
-                                  float sigmaH, float sigmaV) const;
+                                  size_t layer, float sigmaH, float sigmaV) const;
     void renderGaussian17TapBlur(const FrameBuffer &in_fbo,
                                  const FrameBuffer &auxiliary,
                                  const FrameBuffer &linear_depth) const;

src/graphics/shader_based_renderer.cpp

@@ -250,6 +250,7 @@ void ShaderBasedRenderer::renderScene(scene::ICameraSceneNode * const camnode,
             m_geometry_passes->renderShadows(m_draw_calls,
                                              m_shadow_matrices,
                                              m_rtts->getShadowFrameBuffer(),
+                                             m_rtts->getFBO(FBO_SCALAR_1024),
                                              m_post_processing);
             PROFILER_POP_CPU_MARKER();
             if (CVS->isGlobalIlluminationEnabled())
@@ -455,7 +456,9 @@ void ShaderBasedRenderer::renderScene(scene::ICameraSceneNode * const camnode,
         PROFILER_PUSH_CPU_MARKER("- Transparent Pass", 0xFF, 0x00, 0x00);
         ScopedGPUTimer Timer(irr_driver->getGPUTimer(Q_TRANSPARENT));
         m_geometry_passes->renderTransparent(m_draw_calls,
-                                             m_rtts->getRenderTarget(RTT_DISPLACE),
+                                             m_rtts->getFBO(FBO_TMP1_WITH_DS),
+                                             m_rtts->getFBO(FBO_DISPLACE),
+                                             m_rtts->getFBO(FBO_COLORS),                                             
                                              m_post_processing);
         PROFILER_POP_CPU_MARKER();
     }
@@ -560,7 +563,7 @@ void ShaderBasedRenderer::renderPostProcessing(Camera * const camera)
     FrameBuffer *fbo = m_post_processing->render(camnode, isRace, m_rtts);
 
     if (irr_driver->getNormals())
-        irr_driver->getFBO(FBO_NORMAL_AND_DEPTHS).BlitToDefault(viewport.UpperLeftCorner.X, viewport.UpperLeftCorner.Y, viewport.LowerRightCorner.X, viewport.LowerRightCorner.Y);
+        m_rtts->getFBO(FBO_NORMAL_AND_DEPTHS).BlitToDefault(viewport.UpperLeftCorner.X, viewport.UpperLeftCorner.Y, viewport.LowerRightCorner.X, viewport.LowerRightCorner.Y);
     else if (irr_driver->getSSAOViz())
     {
         glBindFramebuffer(GL_FRAMEBUFFER, 0);
@@ -644,7 +647,7 @@ void ShaderBasedRenderer::onUnloadWorld()
     removeSkyBox();    
 }
 
-void ShaderBasedRenderer::reset()
+void ShaderBasedRenderer::resetPostProcessing()
 {
     m_post_processing->reset();
 }

src/graphics/shader_based_renderer.hpp

@@ -30,11 +30,13 @@
 
 class GL3RenderTarget;
 class RenderTarget;
+class RTT;
 class PostProcessing;
 
 class ShaderBasedRenderer: public AbstractRenderer
 {
 private:
+    //RTT                  *m_rtts;
     Skybox *m_skybox;
     SphericalHarmonics *m_spherical_harmonics;
     
@@ -95,7 +97,7 @@ public:
     void onLoadWorld()  ;
     void onUnloadWorld();
     
-    void reset() override;
+    void resetPostProcessing() override;
     void giveBoost(unsigned int cam_index) override;
 
     void addSkyBox(const std::vector<irr::video::ITexture*> &texture,