ilikecats/stk-code_catmod
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Moved m_shadow_matrices from IrrDriver to Renderer class

Browse Source
This commit is contained in:
Elderme 2015-10-12 13:44:49 +02:00
parent 7590a90e67
commit 878570f7c1
12 changed files with 95 additions and 73 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
src/graphics/abstract_renderer.hpp
View File

@ -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; }
// ------------------------------------------------------------------------

14
src/graphics/geometry_passes.cpp
View File

@ -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

7
src/graphics/geometry_passes.hpp
View File

@ -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 renderReflectiveShadowMap(const FrameBuffer& reflective_shadow_map_framebuffer);
void renderShadows(const ShadowMatrices& shadow_matrices,
const FrameBuffer& shadow_framebuffer);
void renderReflectiveShadowMap(const ShadowMatrices& shadow_matrices,
const FrameBuffer& reflective_shadow_map_framebuffer);
};

16
src/graphics/irr_driver.cpp
View File

@ -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);

11
src/graphics/irr_driver.hpp
View File

@ -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();

18
src/graphics/lighting_passes.cpp
View File

@ -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(),
shadow_matrices->getRHMatrix(),
shadow_matrices->getRHExtend(), i,
->setUniforms(shadow_matrices.getRSMMatrix(),
shadow_matrices.getRHMatrix(),
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(),
shadow_matrices->getRHMatrix(),
shadow_matrices->getRHExtend(),
->setUniforms(shadow_matrices.getRSMMatrix(),
shadow_matrices.getRHMatrix(),
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(),
shadow_matrices->getRHExtend(),
irr_driver->getPostProcessing()->renderGI( shadow_matrices.getRHMatrix(),
shadow_matrices.getRHExtend(),
radiance_hint_framebuffer);
}
}

2
src/graphics/lighting_passes.hpp
View File

@ -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);

2
src/graphics/rtts.cpp
View File

@ -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);

52
src/graphics/shader_based_renderer.cpp
View File

@ -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);
m_geometry_passes.renderReflectiveShadowMap(irr_driver->getRTT()->getReflectiveShadowMapFrameBuffer()); //TODO: move somewhere else as RSM are computed only once per track
PROFILER_POP_CPU_MARKER();
if (!m_shadow_matrices.isRSMMapAvail())
{
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(),
shadow_matrices->getRHExtend());
m_shadow_matrices.getRHMatrix(),
m_shadow_matrices.getRHExtend());
}
if (irr_driver->getGI())
{
glDisable(GL_BLEND);
rtts->getFBO(FBO_COLORS).bind();
post_processing->renderGI(shadow_matrices->getRHMatrix(),
shadow_matrices->getRHExtend(),
post_processing->renderGI(m_shadow_matrices.getRHMatrix(),
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);
irr_driver->getShadowMatrices()->updateSunOrthoMatrices();
computeMatrixesAndCameras(camnode, viewport.LowerRightCorner.X - viewport.UpperLeftCorner.X, viewport.LowerRightCorner.Y - viewport.UpperLeftCorner.Y);
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);

12
src/graphics/shader_based_renderer.hpp
View File

@ -21,13 +21,17 @@
#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();
std::vector<GlowData> updateGlowingList();
@ -35,6 +39,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,
@ -46,8 +55,9 @@ private:
public:
ShaderBasedRenderer();
~ShaderBasedRenderer();
void addSunLight(const irr::core::vector3df &pos) override;
void render(float dt);
};

6
src/graphics/shadow_matrices.hpp
View File

@ -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()
{

10
src/graphics/stk_scene_manager.cpp
View File

@ -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(),
getShadowMatrices()->getSunCam(), cam,
shadow_matrices.getShadowCamNodes(),
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())