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

Start removing dependency to irr_driver in LightingPasses class

Browse Source
This commit is contained in:
Elderme
2015-10-06 22:29:00 +02:00
parent cf7bb82e8a
commit 017c609154
6 changed files with 116 additions and 82 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/graphics/glwrap.hpp
View File

@@ -75,7 +75,7 @@ public:
void bind() const;
void bindLayer(unsigned) const;
const std::vector<GLuint> &getRTT() const { return RenderTargets; }
GLuint &getDepthTexture() { assert(DepthTexture); return DepthTexture; }
GLuint getDepthTexture() const { assert(DepthTexture); return DepthTexture; }
size_t getWidth() const { return width; }
size_t getHeight() const { return height; }
static void Blit(const FrameBuffer &Src, FrameBuffer &Dst, GLbitfield mask = GL_COLOR_BUFFER_BIT, GLenum filter = GL_NEAREST);

145
src/graphics/lighting_passes.cpp
View File

@@ -17,7 +17,6 @@
#include "graphics/lighting_passes.hpp"
#include "graphics/central_settings.hpp"
#include "graphics/glwrap.hpp"
#include "graphics/irr_driver.hpp"
#include "graphics/light.hpp"
#include "graphics/post_processing.hpp"
@@ -252,11 +251,11 @@ public:
assignUniforms("split0", "split1", "split2", "splitmax", "shadow_res");
} // ShadowedSunLightShaderPCF
// ------------------------------------------------------------------------
void render(RTT *rtts)
void render(const FrameBuffer& shadowFrameBuffer)
{
setTextureUnits(irr_driver->getRenderTargetTexture(RTT_NORMAL_AND_DEPTH),
irr_driver->getDepthStencilTexture(),
rtts->getShadowFBO().getDepthTexture() );
shadowFrameBuffer.getDepthTexture() );
drawFullScreenEffect(ShadowMatrices::m_shadow_split[1],
ShadowMatrices::m_shadow_split[2],
ShadowMatrices::m_shadow_split[3],
@@ -290,11 +289,11 @@ public:
assignUniforms("split0", "split1", "split2", "splitmax");
} // ShadowedSunLightShaderESM
// ------------------------------------------------------------------------
void render(RTT *rtt)
void render(const FrameBuffer& shadowFrameBuffer)
{
setTextureUnits(irr_driver->getRenderTargetTexture(RTT_NORMAL_AND_DEPTH),
irr_driver->getDepthStencilTexture(),
rtt->getShadowFBO().getRTT()[0]);
shadowFrameBuffer.getRTT()[0]);
drawFullScreenEffect(ShadowMatrices::m_shadow_split[1],
ShadowMatrices::m_shadow_split[2],
ShadowMatrices::m_shadow_split[3],
@@ -326,6 +325,52 @@ static void renderPointLights(unsigned count)
glDrawArraysInstanced(GL_TRIANGLE_STRIP, 0, 4, count);
} // renderPointLights
// ----------------------------------------------------------------------------
void LightingPasses::renderRadianceHints(ShadowMatrices *shadow_matrices,
const FrameBuffer& radiance_hint_framebuffer,
const FrameBuffer& reflective_shadow_map_framebuffer)
{
ScopedGPUTimer timer(irr_driver->getGPUTimer(Q_RH));
glDisable(GL_BLEND);
radiance_hint_framebuffer.bind();
glBindVertexArray(SharedGPUObjects::getFullScreenQuadVAO());
if (CVS->needRHWorkaround())
{
NVWorkaroundRadianceHintsConstructionShader::getInstance()->use();
NVWorkaroundRadianceHintsConstructionShader::getInstance()
->setTextureUnits(
reflective_shadow_map_framebuffer.getRTT()[0],
reflective_shadow_map_framebuffer.getRTT()[1],
reflective_shadow_map_framebuffer.getDepthTexture());
for (unsigned i = 0; i < 32; i++)
{
NVWorkaroundRadianceHintsConstructionShader::getInstance()
->setUniforms(shadow_matrices->getRSMMatrix(),
shadow_matrices->getRHMatrix(),
shadow_matrices->getRHExtend(), i,
irr_driver->getSunColor());
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
}
}
else
{
RadianceHintsConstructionShader::getInstance()->use();
RadianceHintsConstructionShader::getInstance()
->setTextureUnits(
reflective_shadow_map_framebuffer.getRTT()[0],
reflective_shadow_map_framebuffer.getRTT()[1],
reflective_shadow_map_framebuffer.getDepthTexture()
);
RadianceHintsConstructionShader::getInstance()
->setUniforms(shadow_matrices->getRSMMatrix(),
shadow_matrices->getRHMatrix(),
shadow_matrices->getRHExtend(),
irr_driver->getSunColor());
glDrawArraysInstanced(GL_TRIANGLE_STRIP, 0, 4, 32);
}
}
// ----------------------------------------------------------------------------
unsigned LightingPasses::updateLightsInfo(scene::ICameraSceneNode * const camnode,
float dt)
@@ -409,68 +454,38 @@ unsigned LightingPasses::updateLightsInfo(scene::ICameraSceneNode * const camnod
} // updateLightsInfo
void LightingPasses::renderLights(unsigned pointlightcount, bool hasShadow)
void LightingPasses::renderLights( unsigned point_light_count, bool has_shadow,
ShadowMatrices *shadow_matrices,
const FrameBuffer& shadow_framebuffer,
const FrameBuffer& radiance_hint_framebuffer,
const FrameBuffer& reflective_shadow_map_framebuffer,
const FrameBuffer& diffuse_framebuffer,
const FrameBuffer& diffuse_specular_framebuffer)
{
RTT *rtts = irr_driver->getRTT();
ShadowMatrices *shadow_matrices = irr_driver->getShadowMatrices();
//RH
if (CVS->isGlobalIlluminationEnabled() && hasShadow)
{
ScopedGPUTimer timer(irr_driver->getGPUTimer(Q_RH));
glDisable(GL_BLEND);
rtts->getRH().bind();
glBindVertexArray(SharedGPUObjects::getFullScreenQuadVAO());
if (CVS->needRHWorkaround())
{
NVWorkaroundRadianceHintsConstructionShader::getInstance()->use();
NVWorkaroundRadianceHintsConstructionShader::getInstance()
->setTextureUnits(
rtts->getRSM().getRTT()[0],
rtts->getRSM().getRTT()[1],
rtts->getRSM().getDepthTexture());
for (unsigned i = 0; i < 32; i++)
{
NVWorkaroundRadianceHintsConstructionShader::getInstance()
->setUniforms(shadow_matrices->getRSMMatrix(),
shadow_matrices->getRHMatrix(),
shadow_matrices->getRHExtend(), i,
irr_driver->getSunColor());
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
}
}
else
{
RadianceHintsConstructionShader::getInstance()->use();
RadianceHintsConstructionShader::getInstance()
->setTextureUnits(
rtts->getRSM().getRTT()[0],
rtts->getRSM().getRTT()[1],
rtts->getRSM().getDepthTexture()
);
RadianceHintsConstructionShader::getInstance()
->setUniforms(shadow_matrices->getRSMMatrix(),
shadow_matrices->getRHMatrix(),
shadow_matrices->getRHExtend(),
irr_driver->getSunColor());
glDrawArraysInstanced(GL_TRIANGLE_STRIP, 0, 4, 32);
}
}
shadow_matrices->updateSunOrthoMatrices();
rtts->getFBO(FBO_COMBINED_DIFFUSE_SPECULAR).bind();
glClear(GL_COLOR_BUFFER_BIT);
//TODO: split this method in several smaller methods
rtts->getFBO(FBO_DIFFUSE).bind();
if (CVS->isGlobalIlluminationEnabled() && has_shadow)
{
renderRadianceHints(shadow_matrices, radiance_hint_framebuffer, reflective_shadow_map_framebuffer);
}
shadow_matrices->updateSunOrthoMatrices();
diffuse_framebuffer.bind();
PostProcessing *post_processing = irr_driver->getPostProcessing();
if (CVS->isGlobalIlluminationEnabled() && hasShadow)
if (CVS->isGlobalIlluminationEnabled() && has_shadow)
{
ScopedGPUTimer timer(irr_driver->getGPUTimer(Q_GI));
post_processing->renderGI(shadow_matrices->getRHMatrix(),
shadow_matrices->getRHExtend(),
rtts->getRH());
radiance_hint_framebuffer);
}
rtts->getFBO(FBO_COMBINED_DIFFUSE_SPECULAR).bind();
diffuse_specular_framebuffer.bind();
glClear(GL_COLOR_BUFFER_BIT);
{
ScopedGPUTimer timer(irr_driver->getGPUTimer(Q_ENVMAP));
@@ -489,7 +504,7 @@ void LightingPasses::renderLights(unsigned pointlightcount, bool hasShadow)
if (!World::getWorld() || World::getWorld()->getTrack()->hasShadows())
{
ScopedGPUTimer timer(irr_driver->getGPUTimer(Q_SUN));
if (World::getWorld() && CVS->isShadowEnabled() && hasShadow)
if (World::getWorld() && CVS->isShadowEnabled() && has_shadow)
{
glEnable(GL_BLEND);
glDisable(GL_DEPTH_TEST);
@@ -498,20 +513,22 @@ void LightingPasses::renderLights(unsigned pointlightcount, bool hasShadow)
if (CVS->isESMEnabled())
{
ShadowedSunLightShaderESM::getInstance()->render(rtts);
ShadowedSunLightShaderESM::getInstance()->render(shadow_framebuffer);
}
else
{
ShadowedSunLightShaderPCF::getInstance()->render(rtts);
ShadowedSunLightShaderPCF::getInstance()->render(shadow_framebuffer);
}
}
else
post_processing->renderSunlight(irr_driver->getSunDirection(),
irr_driver->getSunColor());
}
//points lights
{
ScopedGPUTimer timer(irr_driver->getGPUTimer(Q_POINTLIGHTS));
renderPointLights(std::min(pointlightcount, LightBaseClass::MAXLIGHT));
renderPointLights(std::min(point_light_count, LightBaseClass::MAXLIGHT));
}
} // renderLights
@@ -538,7 +555,7 @@ void LightingPasses::renderAmbientScatter()
} // renderAmbientScatter
// ----------------------------------------------------------------------------
void LightingPasses::renderLightsScatter(unsigned pointlightcount)
void LightingPasses::renderLightsScatter(unsigned point_light_count)
{
irr_driver->getFBO(FBO_HALF1).bind();
glClearColor(0., 0., 0., 0.);
@@ -571,7 +588,7 @@ void LightingPasses::renderLightsScatter(unsigned pointlightcount)
->setUniforms(1.f / (40.f * start), col2);
glDrawArraysInstanced(GL_TRIANGLE_STRIP, 0, 4,
std::min(pointlightcount, LightBaseClass::MAXLIGHT));
std::min(point_light_count, LightBaseClass::MAXLIGHT));
glDisable(GL_BLEND);
PostProcessing *post_processing = irr_driver->getPostProcessing();

15
src/graphics/lighting_passes.hpp
View File

@@ -18,18 +18,29 @@
#ifndef HEADER_LIGHTING_PASSES_HPP
#define HEADER_LIGHTING_PASSES_HPP
#include "graphics/glwrap.hpp"
#include <irrlicht.h>
class LightingPasses
{
private:
void renderRadianceHints(ShadowMatrices *shadow_matrices,
const FrameBuffer& radiance_hint_framebuffer,
const FrameBuffer& reflective_shadow_map_framebuffer);
public:
unsigned updateLightsInfo(irr::scene::ICameraSceneNode * const camnode,
float dt);
void renderLights(unsigned pointlightcount, bool hasShadow);
void renderLights( unsigned point_light_count, bool has_shadow,
ShadowMatrices *shadow_matrices,
const FrameBuffer& shadow_framebuffer,
const FrameBuffer& radiance_hint_framebuffer,
const FrameBuffer& reflective_shadow_map_framebuffer,
const FrameBuffer& diffuse_framebuffer,
const FrameBuffer& diffuse_specular_framebuffer);
void renderAmbientScatter();
void renderLightsScatter(unsigned pointlightCount);
void renderLightsScatter(unsigned point_light_count);

6
src/graphics/rtts.hpp
View File

@@ -42,9 +42,9 @@ public:
RTT(size_t width, size_t height);
~RTT();
FrameBuffer &getShadowFBO() { return *m_shadow_FBO; }
FrameBuffer &getRH() { return *m_RH_FBO; }
FrameBuffer &getRSM() { return *m_RSM; }
FrameBuffer &getShadowFrameBuffer() { return *m_shadow_FBO; }
FrameBuffer &getRadianceHintFrameBuffer() { return *m_RH_FBO; }
FrameBuffer &getReflectiveShadowMapFrameBuffer() { return *m_RSM; }
unsigned getDepthStencilTexture() const { return DepthStencilTexture; }
unsigned getRenderTarget(enum TypeRTT target) const { return RenderTargetTextures[target]; }

22
src/graphics/shader_based_renderer.cpp
View File

@@ -172,12 +172,12 @@ void ShaderBasedRenderer::renderScene(scene::ICameraSceneNode * const camnode, u
CVS->isShadowEnabled() && hasShadow)
{
PROFILER_PUSH_CPU_MARKER("- Shadow", 0x30, 0x6F, 0x90);
m_geometry_passes->renderShadows(irr_driver->getRTT()->getShadowFBO());
m_geometry_passes->renderShadows(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()->getRSM()); //TODO: move somewhere else as RSM are computed only once per track
m_geometry_passes->renderReflectiveShadowMap(irr_driver->getRTT()->getReflectiveShadowMapFrameBuffer()); //TODO: move somewhere else as RSM are computed only once per track
PROFILER_POP_CPU_MARKER();
}
}
@@ -226,7 +226,13 @@ void ShaderBasedRenderer::renderScene(scene::ICameraSceneNode * const camnode, u
{
PROFILER_PUSH_CPU_MARKER("- Light", 0x00, 0xFF, 0x00);
if (CVS->isDefferedEnabled())
m_lighting_passes->renderLights(pointlightcount, hasShadow);
m_lighting_passes->renderLights(pointlightcount, hasShadow,
irr_driver->getShadowMatrices(),
irr_driver->getRTT()->getShadowFrameBuffer(),
irr_driver->getRTT()->getRadianceHintFrameBuffer(),
irr_driver->getRTT()->getReflectiveShadowMapFrameBuffer(),
irr_driver->getRTT()->getFBO(FBO_DIFFUSE),
irr_driver->getRTT()->getFBO(FBO_COMBINED_DIFFUSE_SPECULAR));
PROFILER_POP_CPU_MARKER();
}
@@ -295,9 +301,9 @@ void ShaderBasedRenderer::renderScene(scene::ICameraSceneNode * const camnode, u
{
glDisable(GL_BLEND);
rtts->getFBO(FBO_COLORS).bind();
post_processing->renderRHDebug(rtts->getRH().getRTT()[0],
rtts->getRH().getRTT()[1],
rtts->getRH().getRTT()[2],
post_processing->renderRHDebug(rtts->getRadianceHintFrameBuffer().getRTT()[0],
rtts->getRadianceHintFrameBuffer().getRTT()[1],
rtts->getRadianceHintFrameBuffer().getRTT()[2],
shadow_matrices->getRHMatrix(),
shadow_matrices->getRHExtend());
}
@@ -308,7 +314,7 @@ void ShaderBasedRenderer::renderScene(scene::ICameraSceneNode * const camnode, u
rtts->getFBO(FBO_COLORS).bind();
post_processing->renderGI(shadow_matrices->getRHMatrix(),
shadow_matrices->getRHExtend(),
rtts->getRH());
rtts->getRadianceHintFrameBuffer());
}
PROFILER_PUSH_CPU_MARKER("- Glow", 0xFF, 0xFF, 0x00);
@@ -430,7 +436,7 @@ void ShaderBasedRenderer::renderPostProcessing(Camera * const camera)
{
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glViewport(viewport.UpperLeftCorner.X, viewport.UpperLeftCorner.Y, viewport.LowerRightCorner.X, viewport.LowerRightCorner.Y);
post_processing->renderPassThrough(irr_driver->getRTT()->getRSM().getRTT()[0], viewport.LowerRightCorner.X - viewport.UpperLeftCorner.X, viewport.LowerRightCorner.Y - viewport.UpperLeftCorner.Y);
post_processing->renderPassThrough(irr_driver->getRTT()->getReflectiveShadowMapFrameBuffer().getRTT()[0], viewport.LowerRightCorner.X - viewport.UpperLeftCorner.X, viewport.LowerRightCorner.Y - viewport.UpperLeftCorner.Y);
}
else if (irr_driver->getShadowViz())
{

8
src/graphics/shadow_matrices.cpp
View File

@@ -481,18 +481,18 @@ void ShadowMatrices::renderShadowsDebug()
UserConfigParams::m_width / 2, UserConfigParams::m_height / 2);
PostProcessing *post_processing = irr_driver->getPostProcessing();
RTT *rtt = irr_driver->getRTT();
post_processing->renderTextureLayer(rtt->getShadowFBO().getRTT()[0], 0);
post_processing->renderTextureLayer(rtt->getShadowFrameBuffer().getRTT()[0], 0);
renderWireFrameFrustrum(m_shadows_cam[0], 0);
glViewport(UserConfigParams::m_width / 2, UserConfigParams::m_height / 2,
UserConfigParams::m_width / 2, UserConfigParams::m_height / 2);
post_processing->renderTextureLayer(rtt->getShadowFBO().getRTT()[0], 1);
post_processing->renderTextureLayer(rtt->getShadowFrameBuffer().getRTT()[0], 1);
renderWireFrameFrustrum(m_shadows_cam[1], 1);
glViewport(0, 0, UserConfigParams::m_width / 2, UserConfigParams::m_height / 2);
post_processing->renderTextureLayer(rtt->getShadowFBO().getRTT()[0], 2);
post_processing->renderTextureLayer(rtt->getShadowFrameBuffer().getRTT()[0], 2);
renderWireFrameFrustrum(m_shadows_cam[2], 2);
glViewport(UserConfigParams::m_width / 2, 0, UserConfigParams::m_width / 2,
UserConfigParams::m_height / 2);
post_processing->renderTextureLayer(rtt->getShadowFBO().getRTT()[0], 3);
post_processing->renderTextureLayer(rtt->getShadowFrameBuffer().getRTT()[0], 3);
renderWireFrameFrustrum(m_shadows_cam[3], 3);
glViewport(0, 0, UserConfigParams::m_width, UserConfigParams::m_height);
}