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

Removed getRTT method in irr_driver

Browse Source
This commit is contained in:
Elderme 2015-12-18 14:19:55 +01:00
parent cba4685d02
commit c158fa1757
11 changed files with 83 additions and 83 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
src/graphics/geometry_passes.cpp
View File

@ -182,7 +182,8 @@ void AbstractGeometryPasses::shadowPostProcessing(const ShadowMatrices& shadow_m
void AbstractGeometryPasses::glowPostProcessing(const FrameBuffer& glow_framebuffer,
const FrameBuffer& half_framebuffer,
const FrameBuffer& quarter_framebuffer,
const FrameBuffer& color_framebuffer) const
const FrameBuffer& color_framebuffer,
GLuint quarter_render_target) const
{
// To half
FrameBuffer::Blit(glow_framebuffer, half_framebuffer, GL_COLOR_BUFFER_BIT, GL_LINEAR);
@ -197,7 +198,7 @@ void AbstractGeometryPasses::glowPostProcessing(const FrameBuffer& glow_framebuf
glStencilFunc(GL_EQUAL, 0, ~0);
glEnable(GL_STENCIL_TEST);
color_framebuffer.bind();
irr_driver->getPostProcessing()->renderGlow(irr_driver->getRTT()->getRenderTarget(RTT_QUARTER1));//TODO
irr_driver->getPostProcessing()->renderGlow(quarter_render_target);//TODO
glDisable(GL_STENCIL_TEST);
}

15
src/graphics/geometry_passes.hpp
View File

@ -41,11 +41,13 @@ protected:
void prepareShadowRendering(const FrameBuffer& shadow_framebuffer) const;
void shadowPostProcessing(const ShadowMatrices& shadow_matrices,
const FrameBuffer& shadow_framebuffer) const;
//TODO: move it in ShaderBasedRenderer
void glowPostProcessing(const FrameBuffer& glow_framebuffer,
const FrameBuffer& half_framebuffer,
const FrameBuffer& quater_framebuffer,
const FrameBuffer& color_framebuffer) const;
const FrameBuffer& color_framebuffer,
GLuint quarter_render_target) const;
public:
AbstractGeometryPasses();
@ -64,7 +66,8 @@ public:
const FrameBuffer& glow_framebuffer,
const FrameBuffer& half_framebuffer,
const FrameBuffer& quarter_framebuffer,
const FrameBuffer& color_framebuffer ) const = 0;
const FrameBuffer& color_framebuffer,
GLuint quarter_render_target ) const = 0;
void renderTransparent(const DrawCalls& draw_calls,
unsigned render_target);
@ -119,7 +122,8 @@ public:
const FrameBuffer& glow_framebuffer,
const FrameBuffer& half_framebuffer,
const FrameBuffer& quarter_framebuffer,
const FrameBuffer& color_framebuffer ) const
const FrameBuffer& color_framebuffer,
GLuint quarter_render_target ) const
{
irr_driver->getSceneManager()->setCurrentRendertime(scene::ESNRP_SOLID);
glow_framebuffer.bind();
@ -142,7 +146,8 @@ public:
glDisable(GL_BLEND);
glowPostProcessing(glow_framebuffer, half_framebuffer,
quarter_framebuffer, color_framebuffer);
quarter_framebuffer, color_framebuffer,
quarter_render_target);
}

2
src/graphics/irr_driver.hpp
View File

@ -374,8 +374,6 @@ public:
return m_texture_error_message;
} // getTextureErrorMessage
// ------------------------------------------------------------------------
RTT* getRTT() { return m_renderer->getRTT(); } //TODO: remove this
// ------------------------------------------------------------------------
AbstractRenderer* getRenderer() { return m_renderer; }
// ------------------------------------------------------------------------

22
src/graphics/lighting_passes.cpp
View File

@ -470,6 +470,8 @@ void LightingPasses::renderGlobalIllumination( const ShadowMatrices& shadow_mat
// ----------------------------------------------------------------------------
void LightingPasses::renderLights( bool has_shadow,
GLuint normal_depth_rander_target,
GLuint depth_stencil_texture,
const FrameBuffer& shadow_framebuffer,
const FrameBuffer& diffuse_specular_framebuffer,
GLuint specular_probe)
@ -483,9 +485,7 @@ void LightingPasses::renderLights( bool has_shadow,
ScopedGPUTimer timer(irr_driver->getGPUTimer(Q_ENVMAP));
post_processing->renderEnvMap(specular_probe);
}
RTT *rtts = irr_driver->getRTT();
// Render sunlight if and only if track supports shadow
if (!World::getWorld() || World::getWorld()->getTrack()->hasShadows())
{
@ -500,14 +500,14 @@ void LightingPasses::renderLights( bool has_shadow,
if (CVS->isESMEnabled())
{
ShadowedSunLightShaderESM::getInstance()->render(rtts->getRenderTarget(RTT_NORMAL_AND_DEPTH),
rtts->getDepthStencilTexture(),
ShadowedSunLightShaderESM::getInstance()->render(normal_depth_rander_target,
depth_stencil_texture,
shadow_framebuffer);
}
else
{
ShadowedSunLightShaderPCF::getInstance()->render(rtts->getRenderTarget(RTT_NORMAL_AND_DEPTH),
rtts->getDepthStencilTexture(),
ShadowedSunLightShaderPCF::getInstance()->render(normal_depth_rander_target,
depth_stencil_texture,
shadow_framebuffer);
}
}
@ -520,13 +520,13 @@ void LightingPasses::renderLights( bool has_shadow,
{
ScopedGPUTimer timer(irr_driver->getGPUTimer(Q_POINTLIGHTS));
renderPointLights(std::min(m_point_light_count, LightBaseClass::MAXLIGHT),
rtts->getRenderTarget(RTT_NORMAL_AND_DEPTH),
rtts->getDepthStencilTexture());
normal_depth_rander_target,
depth_stencil_texture);
}
} // renderLights
// ----------------------------------------------------------------------------
void LightingPasses::renderAmbientScatter()
void LightingPasses::renderAmbientScatter(GLuint depth_stencil_texture)
{
const Track * const track = World::getWorld()->getTrack();
@ -544,7 +544,7 @@ void LightingPasses::renderAmbientScatter()
glBlendEquation(GL_FUNC_ADD);
glBlendFunc(GL_ONE, GL_ONE);
FogShader::getInstance()->render(start, col, irr_driver->getRTT()->getDepthStencilTexture());
FogShader::getInstance()->render(start, col, depth_stencil_texture);
} // renderAmbientScatter
// ----------------------------------------------------------------------------

4
src/graphics/lighting_passes.hpp
View File

@ -38,10 +38,12 @@ public:
const FrameBuffer& reflective_shadow_map_framebuffer,
const FrameBuffer& diffuse_framebuffer);
void renderLights( bool has_shadow,
GLuint normal_depth_rander_target,
GLuint depth_stencil_texture,
const FrameBuffer& shadow_framebuffer,
const FrameBuffer& diffuse_specular_framebuffer,
GLuint specular_probe);
void renderAmbientScatter();
void renderAmbientScatter(GLuint depth_stencil_texture);
void renderLightsScatter(const FrameBuffer& half1_framebuffer,
const FrameBuffer& half2_framebuffer,
const FrameBuffer& colors_framebuffer,

6
src/graphics/rtts.cpp
View File

@ -290,12 +290,6 @@ RTT::~RTT()
}
}
void RTT::prepareRender(scene::ICameraSceneNode* camera)
{
irr_driver->setRTT(this); //FIXME
irr_driver->getSceneManager()->setActiveCamera(camera);
}
FrameBuffer* RTT::render(scene::ICameraSceneNode* camera, float dt)
{

2
src/graphics/rtts.hpp
View File

@ -153,8 +153,6 @@ public:
FrameBuffer* render(irr::scene::ICameraSceneNode* camera, float dt);
void prepareRender(irr::scene::ICameraSceneNode* camera);
private:
unsigned RenderTargetTextures[RTT_COUNT];
PtrVector<FrameBuffer> FrameBuffers;

88
src/graphics/shader_based_renderer.cpp
View File

@ -192,7 +192,7 @@ void ShaderBasedRenderer::computeMatrixesAndCameras(scene::ICameraSceneNode *con
size_t width, size_t height)
{
m_current_screen_size = core::vector2df(float(width), float(height));
m_shadow_matrices.computeMatrixesAndCameras(camnode, width, height);
m_shadow_matrices.computeMatrixesAndCameras(camnode, width, height, m_rtts->getDepthStencilTexture());
} // computeMatrixesAndCameras
// ----------------------------------------------------------------------------
@ -207,17 +207,16 @@ void ShaderBasedRenderer::renderSkybox(const scene::ICameraSceneNode *camera) co
// ============================================================================
void ShaderBasedRenderer::renderSSAO() const
{
RTT *rtts = irr_driver->getRTT();
rtts->getFBO(FBO_SSAO).bind();
m_rtts->getFBO(FBO_SSAO).bind();
glClearColor(1., 1., 1., 1.);
glClear(GL_COLOR_BUFFER_BIT);
irr_driver->getPostProcessing()->renderSSAO();
// Blur it to reduce noise.
FrameBuffer::Blit(rtts->getFBO(FBO_SSAO),
rtts->getFBO(FBO_HALF1_R),
FrameBuffer::Blit(m_rtts->getFBO(FBO_SSAO),
m_rtts->getFBO(FBO_HALF1_R),
GL_COLOR_BUFFER_BIT, GL_LINEAR);
irr_driver->getPostProcessing()->renderGaussian17TapBlur(irr_driver->getFBO(FBO_HALF1_R),
irr_driver->getFBO(FBO_HALF2_R));
irr_driver->getPostProcessing()->renderGaussian17TapBlur(m_rtts->getFBO(FBO_HALF1_R),
m_rtts->getFBO(FBO_HALF2_R));
} // renderSSAO
@ -247,7 +246,7 @@ void ShaderBasedRenderer::renderScene(scene::ICameraSceneNode * const camnode,
PROFILER_PUSH_CPU_MARKER("- Shadow", 0x30, 0x6F, 0x90);
m_geometry_passes->renderShadows(m_draw_calls,
m_shadow_matrices,
irr_driver->getRTT()->getShadowFrameBuffer());
m_rtts->getShadowFrameBuffer());
PROFILER_POP_CPU_MARKER();
if (CVS->isGlobalIlluminationEnabled())
{
@ -256,7 +255,7 @@ void ShaderBasedRenderer::renderScene(scene::ICameraSceneNode * const camnode,
PROFILER_PUSH_CPU_MARKER("- RSM", 0xFF, 0x0, 0xFF);
m_geometry_passes->renderReflectiveShadowMap(m_draw_calls,
m_shadow_matrices,
irr_driver->getRTT()->getReflectiveShadowMapFrameBuffer()); //TODO: move somewhere else as RSM are computed only once per track
m_rtts->getReflectiveShadowMapFrameBuffer()); //TODO: move somewhere else as RSM are computed only once per track
m_shadow_matrices.setRSMMapAvail(true);
PROFILER_POP_CPU_MARKER();
}
@ -273,10 +272,10 @@ void ShaderBasedRenderer::renderScene(scene::ICameraSceneNode * const camnode,
glEnable(GL_DEPTH_TEST);
glDisable(GL_BLEND);
glEnable(GL_CULL_FACE);
RTT *rtts = irr_driver->getRTT();
if (CVS->isDefferedEnabled() || forceRTT)
{
rtts->getFBO(FBO_NORMAL_AND_DEPTHS).bind();
m_rtts->getFBO(FBO_NORMAL_AND_DEPTHS).bind();
glClearColor(0., 0., 0., 0.);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
m_geometry_passes->renderSolidFirstPass(m_draw_calls);
@ -286,7 +285,7 @@ void ShaderBasedRenderer::renderScene(scene::ICameraSceneNode * const camnode,
// We need a cleared depth buffer for some effect (eg particles depth blending)
if (GraphicsRestrictions::isDisabled(GraphicsRestrictions::GR_FRAMEBUFFER_SRGB_WORKING))
glDisable(GL_FRAMEBUFFER_SRGB);
rtts->getFBO(FBO_NORMAL_AND_DEPTHS).bind();
m_rtts->getFBO(FBO_NORMAL_AND_DEPTHS).bind();
// Bind() modifies the viewport. In order not to affect anything else,
// the viewport is just reset here and not removed in Bind().
const core::recti &vp = Camera::getActiveCamera()->getViewport();
@ -310,9 +309,9 @@ void ShaderBasedRenderer::renderScene(scene::ICameraSceneNode * const camnode,
if (CVS->isGlobalIlluminationEnabled() && hasShadow)
{
m_lighting_passes.renderGlobalIllumination( m_shadow_matrices,
irr_driver->getRTT()->getRadianceHintFrameBuffer(),
irr_driver->getRTT()->getReflectiveShadowMapFrameBuffer(),
irr_driver->getRTT()->getFBO(FBO_DIFFUSE));
m_rtts->getRadianceHintFrameBuffer(),
m_rtts->getReflectiveShadowMapFrameBuffer(),
m_rtts->getFBO(FBO_DIFFUSE));
}
GLuint specular_probe;
@ -326,8 +325,10 @@ void ShaderBasedRenderer::renderScene(scene::ICameraSceneNode * const camnode,
}
m_lighting_passes.renderLights( hasShadow,
irr_driver->getRTT()->getShadowFrameBuffer(),
irr_driver->getRTT()->getFBO(FBO_COMBINED_DIFFUSE_SPECULAR),
m_rtts->getRenderTarget(RTT_NORMAL_AND_DEPTH),
m_rtts->getDepthStencilTexture(),
m_rtts->getShadowFrameBuffer(),
m_rtts->getFBO(FBO_COMBINED_DIFFUSE_SPECULAR),
specular_probe);
PROFILER_POP_CPU_MARKER();
}
@ -344,7 +345,7 @@ void ShaderBasedRenderer::renderScene(scene::ICameraSceneNode * const camnode,
PROFILER_PUSH_CPU_MARKER("- Solid Pass 2", 0x00, 0x00, 0xFF);
if (CVS->isDefferedEnabled() || forceRTT)
{
rtts->getFBO(FBO_COLORS).bind();
m_rtts->getFBO(FBO_COLORS).bind();
video::SColor clearColor(0, 150, 150, 150);
if (World::getWorld() != NULL)
clearColor = World::getWorld()->getClearColor();
@ -356,10 +357,10 @@ void ShaderBasedRenderer::renderScene(scene::ICameraSceneNode * const camnode,
}
std::vector<GLuint> prefilled_textures =
createVector<GLuint>(rtts->getRenderTarget(RTT_DIFFUSE),
rtts->getRenderTarget(RTT_SPECULAR),
rtts->getRenderTarget(RTT_HALF1_R),
irr_driver->getDepthStencilTexture());
createVector<GLuint>(m_rtts->getRenderTarget(RTT_DIFFUSE),
m_rtts->getRenderTarget(RTT_SPECULAR),
m_rtts->getRenderTarget(RTT_HALF1_R),
m_rtts->getDepthStencilTexture());
m_geometry_passes->setFirstPassRenderTargets(prefilled_textures);
//TODO: no need to update it every frame
@ -368,9 +369,9 @@ void ShaderBasedRenderer::renderScene(scene::ICameraSceneNode * const camnode,
if (irr_driver->getNormals())
{
rtts->getFBO(FBO_NORMAL_AND_DEPTHS).bind();
m_rtts->getFBO(FBO_NORMAL_AND_DEPTHS).bind();
m_geometry_passes->renderNormalsVisualisation(m_draw_calls);
rtts->getFBO(FBO_COLORS).bind();
m_rtts->getFBO(FBO_COLORS).bind();
}
// Render ambient scattering
@ -379,7 +380,7 @@ void ShaderBasedRenderer::renderScene(scene::ICameraSceneNode * const camnode,
{
PROFILER_PUSH_CPU_MARKER("- Ambient scatter", 0xFF, 0x00, 0x00);
ScopedGPUTimer Timer(irr_driver->getGPUTimer(Q_FOG));
m_lighting_passes.renderAmbientScatter();
m_lighting_passes.renderAmbientScatter(m_rtts->getDepthStencilTexture());
PROFILER_POP_CPU_MARKER();
}
@ -396,20 +397,20 @@ void ShaderBasedRenderer::renderScene(scene::ICameraSceneNode * const camnode,
{
PROFILER_PUSH_CPU_MARKER("- PointLight Scatter", 0xFF, 0x00, 0x00);
ScopedGPUTimer Timer(irr_driver->getGPUTimer(Q_FOG));
m_lighting_passes.renderLightsScatter(irr_driver->getRTT()->getFBO(FBO_HALF1),
irr_driver->getRTT()->getFBO(FBO_HALF2),
irr_driver->getRTT()->getFBO(FBO_COLORS),
irr_driver->getRTT()->getRenderTarget(RTT_HALF1));
m_lighting_passes.renderLightsScatter(m_rtts->getFBO(FBO_HALF1),
m_rtts->getFBO(FBO_HALF2),
m_rtts->getFBO(FBO_COLORS),
m_rtts->getRenderTarget(RTT_HALF1));
PROFILER_POP_CPU_MARKER();
}
if (irr_driver->getRH())
{
glDisable(GL_BLEND);
rtts->getFBO(FBO_COLORS).bind();
post_processing->renderRHDebug(rtts->getRadianceHintFrameBuffer().getRTT()[0],
rtts->getRadianceHintFrameBuffer().getRTT()[1],
rtts->getRadianceHintFrameBuffer().getRTT()[2],
m_rtts->getFBO(FBO_COLORS).bind();
post_processing->renderRHDebug(m_rtts->getRadianceHintFrameBuffer().getRTT()[0],
m_rtts->getRadianceHintFrameBuffer().getRTT()[1],
m_rtts->getRadianceHintFrameBuffer().getRTT()[2],
m_shadow_matrices.getRHMatrix(),
m_shadow_matrices.getRHExtend());
}
@ -417,10 +418,10 @@ void ShaderBasedRenderer::renderScene(scene::ICameraSceneNode * const camnode,
if (irr_driver->getGI())
{
glDisable(GL_BLEND);
rtts->getFBO(FBO_COLORS).bind();
m_rtts->getFBO(FBO_COLORS).bind();
post_processing->renderGI(m_shadow_matrices.getRHMatrix(),
m_shadow_matrices.getRHExtend(),
rtts->getRadianceHintFrameBuffer());
m_rtts->getRadianceHintFrameBuffer());
}
PROFILER_PUSH_CPU_MARKER("- Glow", 0xFF, 0xFF, 0x00);
@ -430,10 +431,11 @@ void ShaderBasedRenderer::renderScene(scene::ICameraSceneNode * const camnode,
ScopedGPUTimer Timer(irr_driver->getGPUTimer(Q_GLOW));
irr_driver->setPhase(GLOW_PASS);
m_geometry_passes->renderGlow(m_draw_calls, m_glowing,
irr_driver->getRTT()->getFBO(FBO_TMP1_WITH_DS),
irr_driver->getRTT()->getFBO(FBO_HALF1),
irr_driver->getRTT()->getFBO(FBO_QUARTER1),
irr_driver->getRTT()->getFBO(FBO_COLORS));
m_rtts->getFBO(FBO_TMP1_WITH_DS),
m_rtts->getFBO(FBO_HALF1),
m_rtts->getFBO(FBO_QUARTER1),
m_rtts->getFBO(FBO_COLORS),
m_rtts->getRenderTarget(RTT_QUARTER1));
} // end glow
PROFILER_POP_CPU_MARKER();
@ -442,7 +444,7 @@ 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,
irr_driver->getRTT()->getRenderTarget(RTT_DISPLACE));
m_rtts->getRenderTarget(RTT_DISPLACE));
PROFILER_POP_CPU_MARKER();
}
@ -553,17 +555,17 @@ 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()->getFBO(FBO_HALF1_R).getRTT()[0], viewport.LowerRightCorner.X - viewport.UpperLeftCorner.X, viewport.LowerRightCorner.Y - viewport.UpperLeftCorner.Y);
post_processing->renderPassThrough(m_rtts->getFBO(FBO_HALF1_R).getRTT()[0], viewport.LowerRightCorner.X - viewport.UpperLeftCorner.X, viewport.LowerRightCorner.Y - viewport.UpperLeftCorner.Y);
}
else if (irr_driver->getRSM())
{
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glViewport(viewport.UpperLeftCorner.X, viewport.UpperLeftCorner.Y, viewport.LowerRightCorner.X, viewport.LowerRightCorner.Y);
post_processing->renderPassThrough(irr_driver->getRTT()->getReflectiveShadowMapFrameBuffer().getRTT()[0], viewport.LowerRightCorner.X - viewport.UpperLeftCorner.X, viewport.LowerRightCorner.Y - viewport.UpperLeftCorner.Y);
post_processing->renderPassThrough(m_rtts->getReflectiveShadowMapFrameBuffer().getRTT()[0], viewport.LowerRightCorner.X - viewport.UpperLeftCorner.X, viewport.LowerRightCorner.Y - viewport.UpperLeftCorner.Y);
}
else if (irr_driver->getShadowViz())
{
m_shadow_matrices.renderShadowsDebug();
m_shadow_matrices.renderShadowsDebug(m_rtts->getShadowFrameBuffer());
}
else
{

16
src/graphics/shadow_matrices.cpp
View File

@ -292,10 +292,11 @@ void ShadowMatrices::updateSplitAndLightcoordRangeFromComputeShaders(unsigned in
* \param height of the rendering viewport
*/
void ShadowMatrices::computeMatrixesAndCameras(scene::ICameraSceneNode *const camnode,
unsigned int width, unsigned int height)
unsigned int width, unsigned int height,
GLuint depth_stencil_texture)
{
if (CVS->isSDSMEnabled())
updateSplitAndLightcoordRangeFromComputeShaders(width, height, irr_driver->getRTT()->getDepthStencilTexture());
updateSplitAndLightcoordRangeFromComputeShaders(width, height, depth_stencil_texture);
static_cast<scene::CSceneManager *>(irr_driver->getSceneManager())
->OnAnimate(os::Timer::getTime());
camnode->render();
@ -474,25 +475,24 @@ void ShadowMatrices::renderWireFrameFrustrum(float *tmp, unsigned i)
glDrawElements(GL_LINES, 24, GL_UNSIGNED_INT, 0);
}
// ----------------------------------------------------------------------------
void ShadowMatrices::renderShadowsDebug()
void ShadowMatrices::renderShadowsDebug(const FrameBuffer &shadow_framebuffer)
{
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glViewport(0, UserConfigParams::m_height / 2,
UserConfigParams::m_width / 2, UserConfigParams::m_height / 2);
PostProcessing *post_processing = irr_driver->getPostProcessing();
RTT *rtt = irr_driver->getRTT();
post_processing->renderTextureLayer(rtt->getShadowFrameBuffer().getRTT()[0], 0);
post_processing->renderTextureLayer(shadow_framebuffer.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->getShadowFrameBuffer().getRTT()[0], 1);
post_processing->renderTextureLayer(shadow_framebuffer.getRTT()[0], 1);
renderWireFrameFrustrum(m_shadows_cam[1], 1);
glViewport(0, 0, UserConfigParams::m_width / 2, UserConfigParams::m_height / 2);
post_processing->renderTextureLayer(rtt->getShadowFrameBuffer().getRTT()[0], 2);
post_processing->renderTextureLayer(shadow_framebuffer.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->getShadowFrameBuffer().getRTT()[0], 3);
post_processing->renderTextureLayer(shadow_framebuffer.getRTT()[0], 3);
renderWireFrameFrustrum(m_shadows_cam[3], 3);
glViewport(0, 0, UserConfigParams::m_width, UserConfigParams::m_height);
}

5
src/graphics/shadow_matrices.hpp
View File

@ -66,10 +66,11 @@ public:
ShadowMatrices();
void computeMatrixesAndCameras(scene::ICameraSceneNode *const camnode,
unsigned int width, unsigned int height);
unsigned int width, unsigned int height,
GLuint depth_stencil_texture);
void addLight(const core::vector3df &pos);
void updateSunOrthoMatrices();
void renderShadowsDebug();
void renderShadowsDebug(const FrameBuffer &shadow_framebuffer);
// ------------------------------------------------------------------------
void resetShadowCamNodes()

1
src/guiengine/widgets/model_view_widget.cpp
View File

@ -282,7 +282,6 @@ void ModelViewWidget::setupRTTScene(PtrVector<scene::IMesh, REF>& mesh,
m_camera->setFOV(DEGREE_TO_RAD*50.0f);
m_camera->updateAbsolutePosition();
m_rtt_provider->prepareRender(m_camera);
}
void ModelViewWidget::setRotateOff()