Simplify some code and have a function that render a scene from a cam pov

src/graphics/irr_driver.hpp

@@ -265,22 +265,12 @@ private:
     void renderTransparent();
     void renderParticles();
     void computeSunVisibility();
-    void computeCameraMatrix(scene::ICameraSceneNode * const camnode,
+    void renderScene(scene::ICameraSceneNode * const camnode, std::vector<GlowData>& glows, float dt, bool hasShadows);
-        Camera * const camera);
+    void computeCameraMatrix(scene::ICameraSceneNode * const camnode);
-    void renderShadows(//ShadowImportanceProvider * const sicb,
+    void renderShadows();
-                       scene::ICameraSceneNode * const camnode,
+    void renderGlow(std::vector<GlowData>& glows);
-                       //video::SOverrideMaterial &overridemat,
+    void renderLights(float dt);
-                       Camera * const camera);
+    void renderDisplacement();
-    void renderGlow(video::SOverrideMaterial &overridemat,
-                    std::vector<GlowData>& glows,
-                    const core::aabbox3df& cambox,
-                    int cam);
-    void renderLights(const core::aabbox3df& cambox,
-                      scene::ICameraSceneNode * const camnode,
-                      video::SOverrideMaterial &overridemat,
-                      int cam, float dt);
-    void renderDisplacement(video::SOverrideMaterial &overridemat,
-                            int cam);
     void doScreenShot();
 public:
          IrrDriver();
@@ -288,7 +278,7 @@ public:
     void initDevice();
     void reset();
     void generateSkyboxCubemap();
-    void renderSkybox();
+    void renderSkybox(const scene::ICameraSceneNode *camera);
     void setPhase(STKRenderingPass);
     STKRenderingPass getPhase() const;
     const std::vector<core::matrix4> &getShadowViewProj() const

src/graphics/post_processing.cpp

@@ -665,7 +665,7 @@ void PostProcessing::render()
             // Grab the sky
             glBindFramebuffer(GL_FRAMEBUFFER, out_fbo);
             glClear(GL_COLOR_BUFFER_BIT);
-            irr_driver->renderSkybox();
+//            irr_driver->renderSkybox();
 
             // Set the sun's color
             const SColor col = World::getWorld()->getTrack()->getSunColor();

src/graphics/render.cpp

@@ -140,119 +140,7 @@ void IrrDriver::renderGLSL(float dt)
         camera->activate();
         rg->preRenderCallback(camera);   // adjusts start referee
 
-        const u32 bgnodes = m_background.size();
+        renderScene(camnode, glows, dt, track->hasShadows());
-/*        if (bgnodes)
-        {
-            // If there are background nodes (3d skybox), draw them now.
-            m_video_driver->setRenderTarget(m_rtts->getRTT(RTT_COLOR), false, false);
-
-            m_renderpass = scene::ESNRP_SKY_BOX;
-            m_scene_manager->drawAll(m_renderpass);
-
-            const video::SOverrideMaterial prev = overridemat;
-            overridemat.Enabled = 1;
-            overridemat.EnableFlags = video::EMF_MATERIAL_TYPE;
-            overridemat.Material.MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
-
-            for (i = 0; i < bgnodes; i++)
-            {
-                m_background[i]->setPosition(camnode->getPosition() * 0.97f);
-                m_background[i]->updateAbsolutePosition();
-                m_background[i]->render();
-            }
-
-            overridemat = prev;
-            m_video_driver->setRenderTarget(m_rtts->getRTT(RTT_COLOR), false, true);
-        }*/
-
-        // Get Projection and view matrix
-        computeCameraMatrix(camnode, camera);
-        glBindBufferBase(GL_UNIFORM_BUFFER, 0, SharedObject::ViewProjectionMatrixesUBO);
-
-
-        // Fire up the MRT
-        PROFILER_PUSH_CPU_MARKER("- Solid Pass 1", 0xFF, 0x00, 0x00);
-        renderSolidFirstPass();
-        PROFILER_POP_CPU_MARKER();
-
-
-        // Todo : reenable glow and shadows
-        //ShadowImportanceProvider * const sicb = (ShadowImportanceProvider *)
-        //                                         irr_driver->getCallback(ES_SHADOW_IMPORTANCE);
-        //sicb->updateIPVMatrix();
-
-        // Used to cull glowing items & lights
-        const core::aabbox3df cambox = camnode->getViewFrustum()->getBoundingBox();
-
-        PROFILER_PUSH_CPU_MARKER("- Shadow", 0x30, 0x6F, 0x90);
-        // Shadows
-        if (!m_mipviz && !m_wireframe && UserConfigParams::m_dynamic_lights &&
-            UserConfigParams::m_shadows && track->hasShadows())
-        {
-            renderShadows(camnode, camera);
-        }
-        PROFILER_POP_CPU_MARKER();
-
-        PROFILER_PUSH_CPU_MARKER("- Light", 0x00, 0xFF, 0x00);
-
-        // Lights
-        renderLights(cambox, camnode, overridemat, cam, dt);
-		PROFILER_POP_CPU_MARKER();
-
-		PROFILER_PUSH_CPU_MARKER("- Solid Pass 2", 0x00, 0x00, 0xFF);
-        if (!UserConfigParams::m_dynamic_lights)
-        {
-            glEnable(GL_FRAMEBUFFER_SRGB);
-            glBindFramebuffer(GL_FRAMEBUFFER, 0);
-        }
-        else
-        {
-            glBindFramebuffer(GL_FRAMEBUFFER, m_rtts->getFBO(FBO_COLORS));
-        }
-        renderSolidSecondPass();
-        PROFILER_POP_CPU_MARKER();
-
-        if (UserConfigParams::m_dynamic_lights && World::getWorld()->isFogEnabled())
-        {
-            PROFILER_PUSH_CPU_MARKER("- Fog", 0xFF, 0x00, 0x00);
-            m_post_processing->renderFog();
-            PROFILER_POP_CPU_MARKER();
-        }
-
-        PROFILER_PUSH_CPU_MARKER("- Skybox", 0xFF, 0x00, 0xFF);
-        renderSkybox();
-        PROFILER_POP_CPU_MARKER();
-
-        PROFILER_PUSH_CPU_MARKER("- Glow", 0xFF, 0xFF, 0x00);
-        // Render anything glowing.
-        if (!m_mipviz && !m_wireframe && UserConfigParams::m_glow)
-        {
-            irr_driver->setPhase(GLOW_PASS);
-            renderGlow(overridemat, glows, cambox, cam);
-        } // end glow
-        PROFILER_POP_CPU_MARKER();
-
-        PROFILER_PUSH_CPU_MARKER("- Lensflare/godray", 0x00, 0xFF, 0xFF);
-        computeSunVisibility();
-        PROFILER_POP_CPU_MARKER();
-
-        // We need to re-render camera due to the per-cam-node hack.
-        PROFILER_PUSH_CPU_MARKER("- Transparent Pass", 0xFF, 0x00, 0x00);
-        renderTransparent();
-		PROFILER_POP_CPU_MARKER();
-
-		PROFILER_PUSH_CPU_MARKER("- Particles", 0xFF, 0xFF, 0x00);
-        renderParticles();
-		PROFILER_POP_CPU_MARKER();
-
-        PROFILER_PUSH_CPU_MARKER("- Displacement", 0x00, 0x00, 0xFF);
-        // Handle displacing nodes, if any
-        const u32 displacingcount = m_displacing.size();
-        if (displacingcount)
-        {
-            renderDisplacement(overridemat, cam);
-        }
-        PROFILER_POP_CPU_MARKER();
 
         PROFILER_POP_CPU_MARKER();
 
@@ -317,6 +205,83 @@ void IrrDriver::renderGLSL(float dt)
     getPostProcessing()->update(dt);
 }
 
+void IrrDriver::renderScene(scene::ICameraSceneNode * const camnode, std::vector<GlowData>& glows, float dt, bool hasShadow)
+{
+    computeCameraMatrix(camnode);
+    glBindBufferBase(GL_UNIFORM_BUFFER, 0, SharedObject::ViewProjectionMatrixesUBO);
+
+    PROFILER_PUSH_CPU_MARKER("- Solid Pass 1", 0xFF, 0x00, 0x00);
+    renderSolidFirstPass();
+    PROFILER_POP_CPU_MARKER();
+
+    const core::aabbox3df cambox = camnode->getViewFrustum()->getBoundingBox();
+
+    PROFILER_PUSH_CPU_MARKER("- Shadow", 0x30, 0x6F, 0x90);
+    // Shadows
+    if (!m_mipviz && !m_wireframe && UserConfigParams::m_dynamic_lights &&
+        UserConfigParams::m_shadows && hasShadow)
+    {
+        renderShadows();
+    }
+    PROFILER_POP_CPU_MARKER();
+
+    PROFILER_PUSH_CPU_MARKER("- Light", 0x00, 0xFF, 0x00);
+
+    // Lights
+    renderLights(dt);
+    PROFILER_POP_CPU_MARKER();
+
+    PROFILER_PUSH_CPU_MARKER("- Solid Pass 2", 0x00, 0x00, 0xFF);
+    if (!UserConfigParams::m_dynamic_lights)
+    {
+        glEnable(GL_FRAMEBUFFER_SRGB);
+        glBindFramebuffer(GL_FRAMEBUFFER, 0);
+    }
+    else
+    {
+        glBindFramebuffer(GL_FRAMEBUFFER, m_rtts->getFBO(FBO_COLORS));
+    }
+    renderSolidSecondPass();
+    PROFILER_POP_CPU_MARKER();
+
+    if (UserConfigParams::m_dynamic_lights && World::getWorld()->isFogEnabled())
+    {
+        PROFILER_PUSH_CPU_MARKER("- Fog", 0xFF, 0x00, 0x00);
+        m_post_processing->renderFog();
+        PROFILER_POP_CPU_MARKER();
+    }
+
+    PROFILER_PUSH_CPU_MARKER("- Skybox", 0xFF, 0x00, 0xFF);
+    renderSkybox(camnode);
+    PROFILER_POP_CPU_MARKER();
+
+    PROFILER_PUSH_CPU_MARKER("- Glow", 0xFF, 0xFF, 0x00);
+    // Render anything glowing.
+    if (!m_mipviz && !m_wireframe && UserConfigParams::m_glow)
+    {
+        irr_driver->setPhase(GLOW_PASS);
+        renderGlow(glows);
+    } // end glow
+    PROFILER_POP_CPU_MARKER();
+
+    PROFILER_PUSH_CPU_MARKER("- Lensflare/godray", 0x00, 0xFF, 0xFF);
+    computeSunVisibility();
+    PROFILER_POP_CPU_MARKER();
+
+    // We need to re-render camera due to the per-cam-node hack.
+    PROFILER_PUSH_CPU_MARKER("- Transparent Pass", 0xFF, 0x00, 0x00);
+    renderTransparent();
+    PROFILER_POP_CPU_MARKER();
+
+    PROFILER_PUSH_CPU_MARKER("- Particles", 0xFF, 0xFF, 0x00);
+    renderParticles();
+    PROFILER_POP_CPU_MARKER();
+
+    PROFILER_PUSH_CPU_MARKER("- Displacement", 0x00, 0x00, 0xFF);
+    renderDisplacement();
+    PROFILER_POP_CPU_MARKER();
+}
+
 // --------------------------------------------
 
 void IrrDriver::renderFixed(float dt)
@@ -560,10 +525,12 @@ void IrrDriver::renderParticles()
     m_scene_manager->drawAll(scene::ESNRP_TRANSPARENT_EFFECT);
 }
 
-void IrrDriver::computeCameraMatrix(scene::ICameraSceneNode * const camnode,
+void IrrDriver::computeCameraMatrix(scene::ICameraSceneNode * const camnode)
-    Camera * const camera)
 {
-    m_scene_manager->setCurrentRendertime(scene::ESNRP_SOLID);
+    m_scene_manager->drawAll(scene::ESNRP_CAMERA);
+    irr_driver->setProjMatrix(irr_driver->getVideoDriver()->getTransform(video::ETS_PROJECTION));
+    irr_driver->setViewMatrix(irr_driver->getVideoDriver()->getTransform(video::ETS_VIEW));
+    irr_driver->genProjViewMatrix();
 
     const Vec3 *vmin, *vmax;
     World::getWorld()->getTrack()->getAABB(&vmin, &vmax);
@@ -622,17 +589,6 @@ void IrrDriver::computeCameraMatrix(scene::ICameraSceneNode * const camnode,
         float up = box.MaxEdge.Y;
         float down = box.MinEdge.Y;
 
-/*        left -= fmodf(left, units_per_w);
-        right -= fmodf(right, units_per_w);
-        up -= fmodf(up, units_per_h);
-        down -= fmodf(down, units_per_h);
-        z -= fmodf(z, 0.5f);
-
-        // FIXME: quick and dirt (and wrong) workaround to avoid division by zero
-        if (left == right) right += 0.1f;
-        if (up == down) down += 0.1f;
-        if (z == 30) z += 0.1f;*/
-
         core::matrix4 tmp_matrix;
 
         tmp_matrix.buildProjectionMatrixOrthoLH(left, right,
@@ -647,12 +603,7 @@ void IrrDriver::computeCameraMatrix(scene::ICameraSceneNode * const camnode,
     assert(sun_ortho_matrix.size() == 4);
     camnode->setNearValue(oldnear);
     camnode->setFarValue(oldfar);
-    camnode->render();
+//    camnode->render();
-    camera->activate();
-    m_scene_manager->drawAll(scene::ESNRP_CAMERA);
-    irr_driver->setProjMatrix(irr_driver->getVideoDriver()->getTransform(video::ETS_PROJECTION));
-    irr_driver->setViewMatrix(irr_driver->getVideoDriver()->getTransform(video::ETS_VIEW));
-    irr_driver->genProjViewMatrix();
 
     float *tmp = new float[16 * 8];
 
@@ -669,12 +620,8 @@ void IrrDriver::computeCameraMatrix(scene::ICameraSceneNode * const camnode,
     delete tmp;
 }
 
-void IrrDriver::renderShadows(//ShadowImportanceProvider * const sicb,
+void IrrDriver::renderShadows()
-                              scene::ICameraSceneNode * const camnode,
-                              //video::SOverrideMaterial &overridemat,
-                              Camera * const camera)
 {
-
     irr_driver->setPhase(SHADOW_PASS);
     glDisable(GL_BLEND);
     glEnable(GL_POLYGON_OFFSET_FILL);
@@ -693,104 +640,11 @@ void IrrDriver::renderShadows(//ShadowImportanceProvider * const sicb,
 
 
     glViewport(0, 0, UserConfigParams::m_width, UserConfigParams::m_height);
-
-
-    //sun_ortho_matrix *= m_suncam->getViewMatrix();
-/*    ((SunLightProvider *) m_shaders->m_callbacks[ES_SUNLIGHT])->setShadowMatrix(ortho);
-    sicb->setShadowMatrix(ortho);
-
-    overridemat.Enabled = 0;
-
-    // Render the importance map
-    m_video_driver->setRenderTarget(m_rtts->getRTT(RTT_COLLAPSE), true, true);
-
-    m_shadow_importance->render();
-
-    CollapseProvider * const colcb = (CollapseProvider *)
-                                            m_shaders->
-                                            m_callbacks[ES_COLLAPSE];
-    ScreenQuad sq(m_video_driver);
-    sq.setMaterialType(m_shaders->getShader(ES_COLLAPSE));
-    sq.setTexture(m_rtts->getRTT(RTT_COLLAPSE));
-    sq.getMaterial().setFlag(EMF_BILINEAR_FILTER, false);
-
-    const TypeRTT oldh = tick ? RTT_COLLAPSEH : RTT_COLLAPSEH2;
-    const TypeRTT oldv = tick ? RTT_COLLAPSEV : RTT_COLLAPSEV2;
-    const TypeRTT curh = tick ? RTT_COLLAPSEH2 : RTT_COLLAPSEH;
-    const TypeRTT curv = tick ? RTT_COLLAPSEV2 : RTT_COLLAPSEV;
-
-    colcb->setResolution(1, m_rtts->getRTT(RTT_WARPV)->getSize().Height);
-    sq.setTexture(m_rtts->getRTT(oldh), 1);
-    sq.render(m_rtts->getRTT(RTT_WARPH));
-
-    colcb->setResolution(m_rtts->getRTT(RTT_WARPV)->getSize().Height, 1);
-    sq.setTexture(m_rtts->getRTT(oldv), 1);
-    sq.render(m_rtts->getRTT(RTT_WARPV));
-
-    sq.setTexture(0, 1);
-    ((GaussianBlurProvider *) m_shaders->m_callbacks[ES_GAUSSIAN3H])->setResolution(
-                m_rtts->getRTT(RTT_WARPV)->getSize().Height,
-                m_rtts->getRTT(RTT_WARPV)->getSize().Height);
-
-    sq.setMaterialType(m_shaders->getShader(ES_GAUSSIAN6H));
-    sq.setTexture(m_rtts->getRTT(RTT_WARPH));
-    sq.render(m_rtts->getRTT(curh));
-
-    sq.setMaterialType(m_shaders->getShader(ES_GAUSSIAN6V));
-    sq.setTexture(m_rtts->getRTT(RTT_WARPV));
-    sq.render(m_rtts->getRTT(curv));*/
-
-    // Convert importance maps to warp maps
-    //
-    // It should be noted that while they do repeated work
-    // calculating the min, max, and total, it's several hundred us
-    // faster to do that than to do it once in a separate shader
-    // (shader switch overhead, measured).
-    /*colcb->setResolution(m_rtts->getRTT(RTT_WARPV)->getSize().Height,
-                            m_rtts->getRTT(RTT_WARPV)->getSize().Height);
-
-    sq.setMaterialType(m_shaders->getShader(ES_SHADOW_WARPH));
-    sq.setTexture(m_rtts->getRTT(curh));
-    sq.render(m_rtts->getRTT(RTT_WARPH));
-
-    sq.setMaterialType(m_shaders->getShader(ES_SHADOW_WARPV));
-    sq.setTexture(m_rtts->getRTT(curv));
-    sq.render(m_rtts->getRTT(RTT_WARPV));*/
-
-    // Actual shadow map
-
-
-/*    overridemat.Material.MaterialType = m_shaders->getShader(ES_SHADOWPASS);
-    overridemat.EnableFlags = video::EMF_MATERIAL_TYPE | video::EMF_TEXTURE1 |
-                                video::EMF_TEXTURE2;
-    overridemat.EnablePasses = scene::ESNRP_SOLID;
-    overridemat.Material.setTexture(1, m_rtts->getRTT(RTT_WARPH));
-    overridemat.Material.setTexture(2, m_rtts->getRTT(RTT_WARPV));
-    overridemat.Material.TextureLayer[1].TextureWrapU =
-    overridemat.Material.TextureLayer[1].TextureWrapV =
-    overridemat.Material.TextureLayer[2].TextureWrapU =
-    overridemat.Material.TextureLayer[2].TextureWrapV = video::ETC_CLAMP_TO_EDGE;
-    overridemat.Material.TextureLayer[1].BilinearFilter =
-    overridemat.Material.TextureLayer[2].BilinearFilter = true;
-    overridemat.Material.TextureLayer[1].TrilinearFilter =
-    overridemat.Material.TextureLayer[2].TrilinearFilter = false;
-    overridemat.Material.TextureLayer[1].AnisotropicFilter =
-    overridemat.Material.TextureLayer[2].AnisotropicFilter = 0;
-    overridemat.Material.Wireframe = 1;
-    overridemat.Enabled = true;*/
-
-
-
-//    overridemat.EnablePasses = 0;
-//    overridemat.Enabled = false;
 }
 
 // ----------------------------------------------------------------------------
 
-void IrrDriver::renderGlow(video::SOverrideMaterial &overridemat,
+void IrrDriver::renderGlow(std::vector<GlowData>& glows)
-                           std::vector<GlowData>& glows,
-                           const core::aabbox3df& cambox,
-                           int cam)
 {
     m_scene_manager->setCurrentRendertime(scene::ESNRP_SOLID);
     glBindFramebuffer(GL_FRAMEBUFFER, m_rtts->getFBO(FBO_TMP1_WITH_DS));
@@ -815,10 +669,11 @@ void IrrDriver::renderGlow(video::SOverrideMaterial &overridemat,
         const GlowData &dat = glows[i];
         scene::ISceneNode * const cur = dat.node;
 
+        //TODO : implement culling on gpu
         // Quick box-based culling
-        const core::aabbox3df nodebox = cur->getTransformedBoundingBox();
+//        const core::aabbox3df nodebox = cur->getTransformedBoundingBox();
-        if (!nodebox.intersectsWithBox(cambox))
+//        if (!nodebox.intersectsWithBox(cambox))
-            continue;
+//            continue;
 
         cb->setColor(dat.r, dat.g, dat.b);
         cur->render();
@@ -880,10 +735,7 @@ static void renderPointLights(unsigned count)
     glDrawArraysInstanced(GL_TRIANGLE_STRIP, 0, 4, count);
 }
 
-void IrrDriver::renderLights(const core::aabbox3df& cambox,
+void IrrDriver::renderLights(float dt)
-                             scene::ICameraSceneNode * const camnode,
-                             video::SOverrideMaterial &overridemat,
-                             int cam, float dt)
 {
 
     for (unsigned i = 0; i < sun_ortho_matrix.size(); i++)
@@ -1444,11 +1296,10 @@ void IrrDriver::generateSkyboxCubemap()
 }
 
 
-void IrrDriver::renderSkybox()
+void IrrDriver::renderSkybox(const scene::ICameraSceneNode *camera)
 {
     if (SkyboxTextures.empty()) return;
 
-    scene::ICameraSceneNode *camera = m_scene_manager->getActiveCamera();
     if (!SkyboxCubeMap)
         generateSkyboxCubemap();
     glBindVertexArray(MeshShader::SkyboxShader::cubevao);
@@ -1481,8 +1332,7 @@ void IrrDriver::renderSkybox()
 
 // ----------------------------------------------------------------------------
 
-void IrrDriver::renderDisplacement(video::SOverrideMaterial &overridemat,
+void IrrDriver::renderDisplacement()
-                                   int cam)
 {
     glBindFramebuffer(GL_FRAMEBUFFER, irr_driver->getFBO(FBO_TMP4));
     glClear(GL_COLOR_BUFFER_BIT);
@@ -1505,9 +1355,6 @@ void IrrDriver::renderDisplacement(video::SOverrideMaterial &overridemat,
 
     for (int i = 0; i < displacingcount; i++)
     {
-        m_scene_manager->setCurrentRendertime(scene::ESNRP_SOLID);
-        m_displacing[i]->render();
-
         m_scene_manager->setCurrentRendertime(scene::ESNRP_TRANSPARENT);
         m_displacing[i]->render();
     }