Moved m_shadow_matrices from IrrDriver to Renderer class

src/graphics/abstract_renderer.hpp

@@ -18,7 +18,6 @@
 #ifndef HEADER_ABSTRACT_RENDERER_HPP
 #define HEADER_ABSTRACT_RENDERER_HPP
 
-#include "graphics/irr_driver.hpp"
 #include <irrlicht.h>
 #include <vector>
 
@@ -27,6 +26,8 @@ struct GlowData;
 class AbstractRenderer
 {
 protected:
+    irr::core::vector2df m_current_screen_size;
+    
     bool                 m_wireframe;
     bool                 m_mipviz;
 
@@ -42,6 +43,9 @@ public:
     AbstractRenderer();
     virtual ~AbstractRenderer(){}
 
+    virtual void addSunLight(const irr::core::vector3df &pos){}
+
+    
     virtual void render(float dt) = 0;
 
     virtual void renderScene(irr::scene::ICameraSceneNode * const camnode,
@@ -51,6 +55,18 @@ public:
     virtual void updateLightsInfo(irr::scene::ICameraSceneNode * const camnode,
                                       float dt) = 0;
 
+    virtual void computeMatrixesAndCameras(irr::scene::ICameraSceneNode * const camnode,
+                                   size_t width, size_t height) {}
+
+    virtual void resetShadowCamNodes() {}
+
+ 
+     // ------------------------------------------------------------------------
+    const irr::core::vector2df &getCurrentScreenSize() const
+    {
+        return m_current_screen_size;
+    }
+ 
     // ------------------------------------------------------------------------
     void toggleWireframe() { m_wireframe = !m_wireframe; }
     // ------------------------------------------------------------------------

src/graphics/geometry_passes.cpp

@@ -21,7 +21,6 @@
 #include "graphics/post_processing.hpp"
 #include "graphics/rtts.hpp"
 #include "graphics/shaders.hpp"
-#include "graphics/shadow_matrices.hpp"
 #include "graphics/stk_scene_manager.hpp"
 #include "modes/world.hpp"
 #include "utils/profiler.hpp"
@@ -1756,7 +1755,8 @@ static void multidrawShadow(unsigned i, Args ...args)
 
 
 // ----------------------------------------------------------------------------
-void GeometryPasses::renderShadows(const FrameBuffer& shadow_framebuffer)
+void GeometryPasses::renderShadows(const ShadowMatrices& shadow_matrices,
+                                   const FrameBuffer& shadow_framebuffer)
 {
     glDepthFunc(GL_LEQUAL);
     glDepthMask(GL_TRUE);
@@ -1822,7 +1822,7 @@ void GeometryPasses::renderShadows(const FrameBuffer& shadow_framebuffer)
         if (CVS->isARBTextureViewUsable())
         {
             const std::pair<float, float>* shadow_scales 
-                = irr_driver->getShadowMatrices()->getShadowScales();
+                = shadow_matrices.getShadowScales();
 
             for (unsigned i = 0; i < 2; i++)
             {
@@ -1927,15 +1927,14 @@ void multidrawRSM(Args...args)
 }   // multidrawRSM
 
 // ----------------------------------------------------------------------------
-void GeometryPasses::renderReflectiveShadowMap(const FrameBuffer& reflective_shadow_map_framebuffer)
+void GeometryPasses::renderReflectiveShadowMap(const ShadowMatrices& shadow_matrices,
+                                               const FrameBuffer& reflective_shadow_map_framebuffer)
 {
-    if (irr_driver->getShadowMatrices()->isRSMMapAvail())
-        return;
     ScopedGPUTimer Timer(irr_driver->getGPUTimer(Q_RSM));
     reflective_shadow_map_framebuffer.bind();
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
-    const core::matrix4 &rsm_matrix = irr_driver->getShadowMatrices()->getRSMMatrix();
+    const core::matrix4 &rsm_matrix = shadow_matrices.getRSMMatrix();
     drawRSM<DefaultMaterial, 3, 1>(rsm_matrix);
     drawRSM<AlphaRef, 3, 1>(rsm_matrix);
     drawRSM<NormalMat, 3, 1>(rsm_matrix);
@@ -1963,5 +1962,4 @@ void GeometryPasses::renderReflectiveShadowMap(const FrameBuffer& reflective_sha
         renderRSMShadow<NormalMat>(rsm_matrix);
         renderRSMShadow<DetailMat>(rsm_matrix);
     }
-    irr_driver->getShadowMatrices()->setRSMMapAvail(true);
 }   // renderRSM

src/graphics/geometry_passes.hpp

@@ -19,6 +19,7 @@
 #define HEADER_GEOMETRY_PASSES_HPP
 
 #include "graphics/glwrap.hpp"
+#include "graphics/shadow_matrices.hpp"
 #include <ITexture.h>
 
 class GeometryPasses
@@ -38,8 +39,10 @@ public:
                                 unsigned render_target_half_red);
     void renderNormalsVisualisation();
     void renderTransparent(unsigned render_target);
-    void renderShadows(const FrameBuffer& shadow_framebuffer);
+    void renderShadows(const ShadowMatrices& shadow_matrices,
-    void renderReflectiveShadowMap(const FrameBuffer& reflective_shadow_map_framebuffer);
+                       const FrameBuffer& shadow_framebuffer);
+    void renderReflectiveShadowMap(const ShadowMatrices& shadow_matrices,
+                                   const FrameBuffer& reflective_shadow_map_framebuffer);
 
 
 };

src/graphics/irr_driver.cpp

@@ -109,7 +109,6 @@ const int MIN_SUPPORTED_WIDTH  = 1024;
  */
 IrrDriver::IrrDriver()
 {
-    m_shadow_matrices     = NULL;
     m_resolution_changing = RES_CHANGE_NONE;
     m_phase               = SOLID_NORMAL_AND_DEPTH_PASS;
     m_device              = createDevice(video::EDT_NULL,
@@ -158,8 +157,6 @@ IrrDriver::~IrrDriver()
     m_device = NULL;
     m_modes.clear();
 
-    delete m_shadow_matrices;
-    m_shadow_matrices = NULL;
     if (CVS->isGLSL())
     {
         Shaders::destroy();
@@ -206,14 +203,6 @@ GPUTimer &IrrDriver::getGPUTimer(unsigned i)
     return m_perf_query[i];
 }
 
-// ----------------------------------------------------------------------------
-void IrrDriver::computeMatrixesAndCameras(scene::ICameraSceneNode *const camnode,
-                                          size_t width, size_t height)
-{
-    m_current_screen_size = core::vector2df(float(width), float(height));
-    m_shadow_matrices->computeMatrixesAndCameras(camnode, width, height);
-}   // computeMatrixesAndCameras
-
 // ----------------------------------------------------------------------------
 
 #if defined(__linux__) && !defined(ANDROID)
@@ -627,7 +616,6 @@ void IrrDriver::initDevice()
     // so let's decide ourselves...)
     m_device->getCursorControl()->setVisible(true);
     m_pointer_shown = true;
-    m_shadow_matrices = new ShadowMatrices();
 }   // initDevice
 
 // ----------------------------------------------------------------------------
@@ -1762,7 +1750,7 @@ video::ITexture* IrrDriver::applyMask(video::ITexture* texture,
 // ----------------------------------------------------------------------------
 void IrrDriver::setRTT(RTT* rtt)
 {
-    m_shadow_matrices->resetShadowCamNodes();
+    m_renderer->resetShadowCamNodes();
     m_rtts = rtt;
 }
 // ----------------------------------------------------------------------------
@@ -2394,7 +2382,7 @@ scene::ISceneNode *IrrDriver::addLight(const core::vector3df &pos,
         {
             //m_sun_interposer->setPosition(pos);
             //m_sun_interposer->updateAbsolutePosition();
-            m_shadow_matrices->addLight(pos);
+            m_renderer->addSunLight(pos);
 
             ((WaterShaderProvider *) Shaders::getCallback(ES_WATER) )
                                                          ->setSunPosition(pos);

src/graphics/irr_driver.hpp

@@ -216,7 +216,6 @@ private:
     Wind                 *m_wind;
     /** RTTs. */
     RTT                *m_rtts;
-    core::vector2df    m_current_screen_size;
     core::dimension2du m_actual_screen_size;
 
     /** Additional details to be shown in case that a texture is not found.
@@ -245,7 +244,6 @@ private:
     enum {RES_CHANGE_NONE, RES_CHANGE_YES,
           RES_CHANGE_CANCEL}                m_resolution_changing;
 
-    ShadowMatrices *m_shadow_matrices;
 
 public:
     /** A simple class to store video resolutions. */
@@ -328,7 +326,7 @@ public: //TODO: move into renderer class
     void renderSSAO();
     void renderShadowsDebug();
     void doScreenShot();    
-    void PrepareDrawCalls(scene::ICameraSceneNode *camnode);
+    void PrepareDrawCalls( ShadowMatrices& shadow_matrices, scene::ICameraSceneNode *camnode);
 public:
          IrrDriver();
         ~IrrDriver();
@@ -652,8 +650,6 @@ public:
     // ------------------------------------------------------------------------
     class STKMeshSceneNode *getSunInterposer() { return m_sun_interposer; }
     // ------------------------------------------------------------------------
-    ShadowMatrices *getShadowMatrices() { return m_shadow_matrices;  }
-    // ------------------------------------------------------------------------
     
     void cleanSunInterposer();
     void createSunInterposer();
@@ -692,7 +688,7 @@ public:
     // ------------------------------------------------------------------------
     const core::vector2df &getCurrentScreenSize() const
     {
-        return m_current_screen_size;
+        return m_renderer->getCurrentScreenSize();
     }
     // ------------------------------------------------------------------------
     const core::dimension2du getActualScreenSize() const
@@ -755,8 +751,7 @@ public:
 
     void updateSplitAndLightcoordRangeFromComputeShaders(size_t width,
                                                          size_t height);
-    void computeMatrixesAndCameras(scene::ICameraSceneNode * const camnode,
+
-                                   size_t width, size_t height);
     void uploadLightingData();
 
 

src/graphics/lighting_passes.cpp

@@ -407,7 +407,7 @@ void LightingPasses::updateLightsInfo(scene::ICameraSceneNode * const camnode,
 }   // updateLightsInfo
 
 // ----------------------------------------------------------------------------
-void LightingPasses::renderGlobalIllumination(  ShadowMatrices *shadow_matrices,
+void LightingPasses::renderGlobalIllumination(  const ShadowMatrices& shadow_matrices,
                                                 const FrameBuffer& radiance_hint_framebuffer,
                                                 const FrameBuffer& reflective_shadow_map_framebuffer,
                                                 const FrameBuffer& diffuse_framebuffer)
@@ -428,9 +428,9 @@ void LightingPasses::renderGlobalIllumination(  ShadowMatrices *shadow_matrices,
         for (unsigned i = 0; i < 32; i++)
         {
             NVWorkaroundRadianceHintsConstructionShader::getInstance()
-                ->setUniforms(shadow_matrices->getRSMMatrix(), 
+                ->setUniforms(shadow_matrices.getRSMMatrix(), 
-                              shadow_matrices->getRHMatrix(),
+                              shadow_matrices.getRHMatrix(),
-                              shadow_matrices->getRHExtend(), i,
+                              shadow_matrices.getRHExtend(), i,
                               irr_driver->getSunColor());
             glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
         }
@@ -445,9 +445,9 @@ void LightingPasses::renderGlobalIllumination(  ShadowMatrices *shadow_matrices,
                 reflective_shadow_map_framebuffer.getDepthTexture()
         );
         RadianceHintsConstructionShader::getInstance()
-            ->setUniforms(shadow_matrices->getRSMMatrix(),
+            ->setUniforms(shadow_matrices.getRSMMatrix(),
-                          shadow_matrices->getRHMatrix(), 
+                          shadow_matrices.getRHMatrix(), 
-                          shadow_matrices->getRHExtend(),
+                          shadow_matrices.getRHExtend(),
                           irr_driver->getSunColor());
         glDrawArraysInstanced(GL_TRIANGLE_STRIP, 0, 4, 32);
     }
@@ -456,8 +456,8 @@ void LightingPasses::renderGlobalIllumination(  ShadowMatrices *shadow_matrices,
     {
         ScopedGPUTimer timer(irr_driver->getGPUTimer(Q_GI));
         diffuse_framebuffer.bind();
-        irr_driver->getPostProcessing()->renderGI(  shadow_matrices->getRHMatrix(),
+        irr_driver->getPostProcessing()->renderGI(  shadow_matrices.getRHMatrix(),
-                                                    shadow_matrices->getRHExtend(),
+                                                    shadow_matrices.getRHExtend(),
                                                     radiance_hint_framebuffer);
     }
 }

src/graphics/lighting_passes.hpp

@@ -33,7 +33,7 @@ public:
     void updateLightsInfo(irr::scene::ICameraSceneNode * const camnode,
                           float dt);
     
-    void renderGlobalIllumination(  ShadowMatrices *shadow_matrices,
+    void renderGlobalIllumination(  const ShadowMatrices& shadow_matrices,
                                     const FrameBuffer& radiance_hint_framebuffer,
                                     const FrameBuffer& reflective_shadow_map_framebuffer,
                                     const FrameBuffer& diffuse_framebuffer);

src/graphics/rtts.cpp

@@ -304,7 +304,7 @@ FrameBuffer* RTT::render(scene::ICameraSceneNode* camera, float dt)
     irr_driver->getSceneManager()->setActiveCamera(camera);
 
     std::vector<GlowData> glows;
-    irr_driver->computeMatrixesAndCameras(camera, m_width, m_height);
+    irr_driver->getRenderer()->computeMatrixesAndCameras(camera, m_width, m_height);
     irr_driver->getRenderer()->updateLightsInfo(camera, dt);
     irr_driver->uploadLightingData();
     irr_driver->getRenderer()->renderScene(camera, glows, dt, false, true);

src/graphics/shader_based_renderer.cpp

@@ -24,7 +24,6 @@
 #include "graphics/post_processing.hpp"
 #include "graphics/rtts.hpp"
 #include "graphics/shaders.hpp"
-#include "graphics/shadow_matrices.hpp"
 #include "graphics/stk_scene_manager.hpp"
 #include "graphics/texture_manager.hpp"
 #include "items/item_manager.hpp"
@@ -151,10 +150,17 @@ void ShaderBasedRenderer::updateLightsInfo(scene::ICameraSceneNode * const camno
     m_lighting_passes.updateLightsInfo(camnode, dt);
 }
 
+// ----------------------------------------------------------------------------
+void ShaderBasedRenderer::computeMatrixesAndCameras(scene::ICameraSceneNode *const camnode,
+                                                    size_t width, size_t height)
+{
+    m_current_screen_size = core::vector2df(float(width), float(height));
+    m_shadow_matrices.computeMatrixesAndCameras(camnode, width, height);
+}   // computeMatrixesAndCameras
+
 // ============================================================================
 void ShaderBasedRenderer::renderScene(scene::ICameraSceneNode * const camnode, std::vector<GlowData>& glows, float dt, bool hasShadow, bool forceRTT)
 {
-    ShadowMatrices *shadow_matrices = irr_driver->getShadowMatrices();
     PostProcessing *post_processing = irr_driver->getPostProcessing();
     
     glBindBufferBase(GL_UNIFORM_BUFFER, 0, SharedGPUObjects::getViewProjectionMatricesUBO());
@@ -162,23 +168,29 @@ void ShaderBasedRenderer::renderScene(scene::ICameraSceneNode * const camnode, s
     irr_driver->getSceneManager()->setActiveCamera(camnode);
 
     PROFILER_PUSH_CPU_MARKER("- Draw Call Generation", 0xFF, 0xFF, 0xFF);
-    irr_driver->PrepareDrawCalls(camnode);
+    irr_driver->PrepareDrawCalls(m_shadow_matrices, camnode);
     PROFILER_POP_CPU_MARKER();
     // Shadows
     {
         // To avoid wrong culling, use the largest view possible
-        irr_driver->getSceneManager()->setActiveCamera(shadow_matrices->getSunCam());
+        irr_driver->getSceneManager()->setActiveCamera(m_shadow_matrices.getSunCam());
         if (CVS->isDefferedEnabled() &&
             CVS->isShadowEnabled() && hasShadow)
         {
             PROFILER_PUSH_CPU_MARKER("- Shadow", 0x30, 0x6F, 0x90);
-            m_geometry_passes.renderShadows(irr_driver->getRTT()->getShadowFrameBuffer());
+            m_geometry_passes.renderShadows(m_shadow_matrices,
+                                            irr_driver->getRTT()->getShadowFrameBuffer());
             PROFILER_POP_CPU_MARKER();
             if (CVS->isGlobalIlluminationEnabled())
             {
-                PROFILER_PUSH_CPU_MARKER("- RSM", 0xFF, 0x0, 0xFF);
+                if (!m_shadow_matrices.isRSMMapAvail())
-                m_geometry_passes.renderReflectiveShadowMap(irr_driver->getRTT()->getReflectiveShadowMapFrameBuffer()); //TODO: move somewhere else as RSM are computed only once per track
+                {
-                PROFILER_POP_CPU_MARKER();
+                    PROFILER_PUSH_CPU_MARKER("- RSM", 0xFF, 0x0, 0xFF);
+                    m_geometry_passes.renderReflectiveShadowMap(m_shadow_matrices, 
+                                                                irr_driver->getRTT()->getReflectiveShadowMapFrameBuffer()); //TODO: move somewhere else as RSM are computed only once per track
+                    m_shadow_matrices.setRSMMapAvail(true);
+                    PROFILER_POP_CPU_MARKER();
+                }
             }
         }
         irr_driver->getSceneManager()->setActiveCamera(camnode);
@@ -228,7 +240,7 @@ void ShaderBasedRenderer::renderScene(scene::ICameraSceneNode * const camnode, s
         if (CVS->isDefferedEnabled())
             if (CVS->isGlobalIlluminationEnabled() && hasShadow)
             {    
-                m_lighting_passes.renderGlobalIllumination(irr_driver->getShadowMatrices(),
+                m_lighting_passes.renderGlobalIllumination( m_shadow_matrices,
                                                             irr_driver->getRTT()->getRadianceHintFrameBuffer(),
                                                             irr_driver->getRTT()->getReflectiveShadowMapFrameBuffer(),
                                                             irr_driver->getRTT()->getFBO(FBO_DIFFUSE));
@@ -308,16 +320,16 @@ void ShaderBasedRenderer::renderScene(scene::ICameraSceneNode * const camnode, s
         post_processing->renderRHDebug(rtts->getRadianceHintFrameBuffer().getRTT()[0],
                                        rtts->getRadianceHintFrameBuffer().getRTT()[1], 
                                        rtts->getRadianceHintFrameBuffer().getRTT()[2],
-                                       shadow_matrices->getRHMatrix(),
+                                       m_shadow_matrices.getRHMatrix(),
-                                       shadow_matrices->getRHExtend());
+                                       m_shadow_matrices.getRHExtend());
     }
 
     if (irr_driver->getGI())
     {
         glDisable(GL_BLEND);
         rtts->getFBO(FBO_COLORS).bind();
-        post_processing->renderGI(shadow_matrices->getRHMatrix(),
+        post_processing->renderGI(m_shadow_matrices.getRHMatrix(),
-                                  shadow_matrices->getRHExtend(),
+                                  m_shadow_matrices.getRHExtend(),
                                   rtts->getRadianceHintFrameBuffer());
     }
 
@@ -444,7 +456,7 @@ void ShaderBasedRenderer::renderPostProcessing(Camera * const camera)
     }
     else if (irr_driver->getShadowViz())
     {
-        irr_driver->getShadowMatrices()->renderShadowsDebug();
+        m_shadow_matrices.renderShadowsDebug();
     }
     else
     {
@@ -457,16 +469,16 @@ void ShaderBasedRenderer::renderPostProcessing(Camera * const camera)
 }
 
 
-ShaderBasedRenderer::ShaderBasedRenderer():AbstractRenderer()
+ShaderBasedRenderer::ShaderBasedRenderer():AbstractRenderer(), m_shadow_matrices()
 {
 
 }
 
-ShaderBasedRenderer::~ShaderBasedRenderer()
+void ShaderBasedRenderer::addSunLight(const core::vector3df &pos) {
-{
+    m_shadow_matrices.addLight(pos);
-
 }
 
+
 void ShaderBasedRenderer::render(float dt)
 {
     BoundingBoxes.clear(); //TODO: what is it doing here?
@@ -515,8 +527,8 @@ void ShaderBasedRenderer::render(float dt)
         m_lighting_passes.updateLightsInfo(camnode, dt);
         PROFILER_POP_CPU_MARKER();
         PROFILER_PUSH_CPU_MARKER("UBO upload", 0x0, 0xFF, 0x0);
-        irr_driver->computeMatrixesAndCameras(camnode, viewport.LowerRightCorner.X - viewport.UpperLeftCorner.X, viewport.LowerRightCorner.Y - viewport.UpperLeftCorner.Y);
+        computeMatrixesAndCameras(camnode, viewport.LowerRightCorner.X - viewport.UpperLeftCorner.X, viewport.LowerRightCorner.Y - viewport.UpperLeftCorner.Y);
-        irr_driver->getShadowMatrices()->updateSunOrthoMatrices();
+        m_shadow_matrices.updateSunOrthoMatrices();
         irr_driver->uploadLightingData(); //TODO: move method; update "global" lighting (sun and spherical harmonics)
         PROFILER_POP_CPU_MARKER();
         renderScene(camnode, glows, dt, track->hasShadows(), false); 

src/graphics/shader_based_renderer.hpp

@@ -21,12 +21,16 @@
 #include "graphics/abstract_renderer.hpp"
 #include "graphics/geometry_passes.hpp"
 #include "graphics/lighting_passes.hpp"
+#include "graphics/shadow_matrices.hpp"
+
 
 class ShaderBasedRenderer: public AbstractRenderer
 {
 private:
     GeometryPasses  m_geometry_passes;
     LightingPasses  m_lighting_passes;
+    ShadowMatrices  m_shadow_matrices;
+
     
     void compressPowerUpTextures();
     void setOverrideMaterial();
@@ -36,6 +40,11 @@ private:
     void updateLightsInfo(irr::scene::ICameraSceneNode * const camnode,
                           float dt);
 
+    void computeMatrixesAndCameras(scene::ICameraSceneNode * const camnode,
+                                   size_t width, size_t height);
+    
+    void resetShadowCamNodes(){m_shadow_matrices.resetShadowCamNodes();}
+    
     void renderScene(irr::scene::ICameraSceneNode * const camnode,
                      std::vector<GlowData>& glows,
                      float dt, bool hasShadows, bool forceRTT);
@@ -46,7 +55,8 @@ private:
 
 public:
     ShaderBasedRenderer();
-    ~ShaderBasedRenderer();
+
+    void addSunLight(const irr::core::vector3df &pos) override;
     
     void render(float dt);
 };

src/graphics/shadow_matrices.hpp

@@ -81,11 +81,11 @@ public:
     // ------------------------------------------------------------------------
     scene::ICameraSceneNode* getSunCam() { return m_sun_cam; }
     // ------------------------------------------------------------------------
-    core::matrix4& getRHMatrix() { return m_rh_matrix;  }
+    const core::matrix4& getRHMatrix() const { return m_rh_matrix;  }
     // ------------------------------------------------------------------------
-    core::vector3df& getRHExtend() { return m_rh_extend;  }
+    const core::vector3df& getRHExtend() const { return m_rh_extend;  }
     // ------------------------------------------------------------------------
-    core::matrix4& getRSMMatrix() { return m_rsm_matrix; }
+    const core::matrix4& getRSMMatrix() const { return m_rsm_matrix; }
     // ------------------------------------------------------------------------
     std::vector<core::matrix4>& getSunOrthoMatrices()
     {

src/graphics/stk_scene_manager.cpp

@@ -563,7 +563,7 @@ static void FixBoundingBoxes(scene::ISceneNode* node)
     }
 }
 
-void IrrDriver::PrepareDrawCalls(scene::ICameraSceneNode *camnode)
+void IrrDriver::PrepareDrawCalls( ShadowMatrices& shadow_matrices, scene::ICameraSceneNode *camnode)
 {
     windDir = getWindDir();
     ListBlendTransparent::getInstance()->clear();
@@ -604,10 +604,10 @@ PROFILER_PUSH_CPU_MARKER("- culling", 0xFF, 0xFF, 0x0);
     bool cam = false, rsmcam = false;
     bool shadowcam[4] = { false, false, false, false };
     parseSceneManager(List, ImmediateDrawList::getInstance(), camnode, 
-                      getShadowMatrices()->getShadowCamNodes(),
+                      shadow_matrices.getShadowCamNodes(),
-                      getShadowMatrices()->getSunCam(), cam,
+                      shadow_matrices.getSunCam(), cam,
                       shadowcam, rsmcam,
-                      !getShadowMatrices()->isRSMMapAvail());
+                      !shadow_matrices.isRSMMapAvail());
 PROFILER_POP_CPU_MARKER();
 
     // Add a 1 s timeout
@@ -815,7 +815,7 @@ PROFILER_POP_CPU_MARKER();
             }
         }
 #pragma omp section
-        if (!getShadowMatrices()->isRSMMapAvail())
+        if (!shadow_matrices.isRSMMapAvail())
         {
             size_t offset = 0, current_cmd = 0;
             if (!CVS->supportsAsyncInstanceUpload())