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

Start moving m_rtts from IrrDriver to Renderer classes

Browse Source
This commit is contained in:
Elderme
2015-12-16 10:15:38 +01:00
parent c5caa610ec
commit cba4685d02
14 changed files with 237 additions and 164 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
src/graphics/abstract_renderer.cpp
View File

@@ -194,5 +194,13 @@ void AbstractRenderer::drawJoint(bool drawline, bool drawname,
}
} //drawJoint
AbstractRenderer::AbstractRenderer()
{
m_rtts = NULL;
}
#endif //DEBUG

16
src/graphics/abstract_renderer.hpp
View File

@@ -1,4 +1,4 @@
// SuperTuxKart - a fun racing game with go-kart
// SuperTuxKart - a fun racing game with }go-kart
// Copyright (C) 2015 SuperTuxKart-Team
//
// This program is free software; you can redistribute it and/or
@@ -18,6 +18,7 @@
#ifndef HEADER_ABSTRACT_RENDERER_HPP
#define HEADER_ABSTRACT_RENDERER_HPP
#include "graphics/rtts.hpp"
#include "graphics/sphericalHarmonics.hpp"
#include <irrlicht.h>
#include <vector>
@@ -32,9 +33,8 @@ class AbstractRenderer
{
protected:
irr::core::vector2df m_current_screen_size;
//bool m_wireframe;
//bool m_mipviz;
RTT *m_rtts;
#ifdef DEBUG
void drawDebugMeshes() const;
@@ -48,7 +48,15 @@ protected:
public:
AbstractRenderer();
virtual ~AbstractRenderer(){}
RTT* getRTT() { return m_rtts;} //FIXME: remove this
void setRTT(RTT *rtts) { m_rtts = rtts; } //FIXME: remove this
virtual void onLoadWorld() = 0;
virtual void onUnloadWorld() = 0;
virtual void addSkyBox(const std::vector<irr::video::ITexture*> &texture,
const std::vector<irr::video::ITexture*> &spherical_harmonics_textures) {}

15
src/graphics/fixed_pipeline_renderer.cpp
View File

@@ -23,6 +23,21 @@
#include "physics/physics.hpp"
#include "utils/profiler.hpp"
FixedPipelineRenderer::FixedPipelineRenderer(): AbstractRenderer() {}
void FixedPipelineRenderer::onLoadWorld()
{
}
void FixedPipelineRenderer::onUnloadWorld()
{
}
void FixedPipelineRenderer::render(float dt)
{
World *world = World::getWorld(); // Never NULL.

4
src/graphics/fixed_pipeline_renderer.hpp
View File

@@ -23,6 +23,10 @@
class FixedPipelineRenderer: public AbstractRenderer
{
public:
FixedPipelineRenderer();
void onLoadWorld() ;
void onUnloadWorld();
void render(float dt);
void renderScene(irr::scene::ICameraSceneNode * const camnode,

23
src/graphics/irr_driver.cpp
View File

@@ -120,7 +120,6 @@ IrrDriver::IrrDriver()
/*event receiver*/ NULL,
file_manager->getFileSystem());
m_request_screenshot = false;
m_rtts = NULL;
m_renderer = NULL;
m_wind = new Wind();
@@ -1737,26 +1736,17 @@ video::ITexture* IrrDriver::applyMask(video::ITexture* texture,
void IrrDriver::setRTT(RTT* rtt)
{
m_renderer->resetShadowCamNodes();
m_rtts = rtt;
m_renderer->setRTT(rtt); //FIXME
}
// ----------------------------------------------------------------------------
void IrrDriver::onLoadWorld()
{
if (CVS->isGLSL())
{
const core::recti &viewport = Camera::getCamera(0)->getViewport();
size_t width = viewport.LowerRightCorner.X - viewport.UpperLeftCorner.X;
size_t height = viewport.LowerRightCorner.Y - viewport.UpperLeftCorner.Y;
m_rtts = new RTT(width, height);
}
m_renderer->onLoadWorld();
}
// ----------------------------------------------------------------------------
void IrrDriver::onUnloadWorld()
{
delete m_rtts;
m_rtts = NULL;
suppressSkyBox();
m_renderer->onUnloadWorld();
}
// ----------------------------------------------------------------------------
/** Sets the ambient light.
@@ -2404,20 +2394,21 @@ void IrrDriver::clearLights()
GLuint IrrDriver::getRenderTargetTexture(TypeRTT which)
{
return m_rtts->getRenderTarget(which);
return m_renderer->getRTT()->getRenderTarget(which);
} // getRenderTargetTexture
// ----------------------------------------------------------------------------
FrameBuffer& IrrDriver::getFBO(TypeFBO which)
{
return m_rtts->getFBO(which);
return m_renderer->getRTT()->getFBO(which);
} // getFBO
// ----------------------------------------------------------------------------
GLuint IrrDriver::getDepthStencilTexture()
{
return m_rtts->getDepthStencilTexture();
return m_renderer->getRTT()->getDepthStencilTexture();
} // getDepthStencilTexture

116
src/graphics/irr_driver.hpp
View File

@@ -38,6 +38,8 @@
#include "ISkinnedMesh.h"
#include "graphics/abstract_renderer.hpp"
#include "graphics/gl_headers.hpp"
#include "graphics/sphericalHarmonics.hpp"
#include "graphics/rtts.hpp"
#include "graphics/wind.hpp"
#include "io/file_manager.hpp"
#include "utils/aligned_array.hpp"
@@ -56,6 +58,8 @@ namespace irr
}
using namespace irr;
struct GlowData;
class RTT;
class FrameBuffer;
class ShadowImportanceProvider;
@@ -78,108 +82,6 @@ enum STKRenderingPass
PASS_COUNT,
};
enum TypeFBO
{
FBO_SSAO,
FBO_NORMAL_AND_DEPTHS,
FBO_COMBINED_DIFFUSE_SPECULAR,
FBO_COLORS,
FBO_DIFFUSE,
FBO_SPECULAR,
FBO_MLAA_COLORS,
FBO_MLAA_BLEND,
FBO_MLAA_TMP,
FBO_TMP1_WITH_DS,
FBO_TMP2_WITH_DS,
FBO_TMP4,
FBO_LINEAR_DEPTH,
FBO_HALF1,
FBO_HALF1_R,
FBO_HALF2,
FBO_HALF2_R,
FBO_QUARTER1,
FBO_QUARTER2,
FBO_EIGHTH1,
FBO_EIGHTH2,
FBO_DISPLACE,
FBO_BLOOM_1024,
FBO_SCALAR_1024,
FBO_BLOOM_512,
FBO_TMP_512,
FBO_LENS_512,
FBO_BLOOM_256,
FBO_TMP_256,
FBO_LENS_256,
FBO_BLOOM_128,
FBO_TMP_128,
FBO_LENS_128,
FBO_COUNT
};
enum TypeRTT
{
RTT_TMP1 = 0,
RTT_TMP2,
RTT_TMP3,
RTT_TMP4,
RTT_LINEAR_DEPTH,
RTT_NORMAL_AND_DEPTH,
RTT_COLOR,
RTT_DIFFUSE,
RTT_SPECULAR,
RTT_HALF1,
RTT_HALF2,
RTT_HALF1_R,
RTT_HALF2_R,
RTT_QUARTER1,
RTT_QUARTER2,
// RTT_QUARTER3,
// RTT_QUARTER4,
RTT_EIGHTH1,
RTT_EIGHTH2,
// RTT_SIXTEENTH1,
// RTT_SIXTEENTH2,
RTT_SSAO,
// RTT_COLLAPSE,
// RTT_COLLAPSEH,
// RTT_COLLAPSEV,
// RTT_COLLAPSEH2,
// RTT_COLLAPSEV2,
// RTT_WARPH,
// RTT_WARPV,
// RTT_HALF_SOFT,
RTT_DISPLACE,
RTT_MLAA_COLORS,
RTT_MLAA_BLEND,
RTT_MLAA_TMP,
RTT_BLOOM_1024,
RTT_SCALAR_1024,
RTT_BLOOM_512,
RTT_TMP_512,
RTT_LENS_512,
RTT_BLOOM_256,
RTT_TMP_256,
RTT_LENS_256,
RTT_BLOOM_128,
RTT_TMP_128,
RTT_LENS_128,
RTT_COUNT
};
/**
@@ -207,8 +109,7 @@ private:
/** Wind. */
Wind *m_wind;
/** RTTs. */
RTT *m_rtts;
core::dimension2du m_actual_screen_size;
/** Additional details to be shown in case that a texture is not found.
@@ -472,10 +373,9 @@ public:
{
return m_texture_error_message;
} // getTextureErrorMessage
// ------------------------------------------------------------------------
void setRTT(RTT* rtt);
// ------------------------------------------------------------------------
RTT* getRTT() { return m_rtts; }
RTT* getRTT() { return m_renderer->getRTT(); } //TODO: remove this
// ------------------------------------------------------------------------
AbstractRenderer* getRenderer() { return m_renderer; }
// ------------------------------------------------------------------------
@@ -731,7 +631,7 @@ public:
} // addDebugMesh
#endif
void setRTT(RTT* rtt); //FIXME
void onLoadWorld();
void onUnloadWorld();

62
src/graphics/lighting_passes.cpp
View File

@@ -66,9 +66,9 @@ public:
assignSamplerNames(0, "tex", ST_NEAREST_FILTERED);
} // FogShader
// ------------------------------------------------------------------------
void render(float start, const core::vector3df &color)
void render(float start, const core::vector3df &color, GLuint depth_stencil_texture)
{
setTextureUnits(irr_driver->getDepthStencilTexture());
setTextureUnits(depth_stencil_texture);
drawFullScreenEffect(1.f / (40.f * start), color);
} // render
@@ -251,10 +251,12 @@ public:
assignUniforms("split0", "split1", "split2", "splitmax", "shadow_res");
} // ShadowedSunLightShaderPCF
// ------------------------------------------------------------------------
void render(const FrameBuffer& shadowFrameBuffer)
void render(GLuint normal_depth_rander_target,
GLuint depth_stencil_texture,
const FrameBuffer& shadowFrameBuffer)
{
setTextureUnits(irr_driver->getRenderTargetTexture(RTT_NORMAL_AND_DEPTH),
irr_driver->getDepthStencilTexture(),
setTextureUnits(normal_depth_rander_target,
depth_stencil_texture,
shadowFrameBuffer.getDepthTexture() );
drawFullScreenEffect(ShadowMatrices::m_shadow_split[1],
ShadowMatrices::m_shadow_split[2],
@@ -289,10 +291,12 @@ public:
assignUniforms("split0", "split1", "split2", "splitmax");
} // ShadowedSunLightShaderESM
// ------------------------------------------------------------------------
void render(const FrameBuffer& shadowFrameBuffer)
void render(GLuint normal_depth_rander_target,
GLuint depth_stencil_texture,
const FrameBuffer& shadowFrameBuffer)
{
setTextureUnits(irr_driver->getRenderTargetTexture(RTT_NORMAL_AND_DEPTH),
irr_driver->getDepthStencilTexture(),
setTextureUnits(normal_depth_rander_target,
depth_stencil_texture,
shadowFrameBuffer.getRTT()[0]);
drawFullScreenEffect(ShadowMatrices::m_shadow_split[1],
ShadowMatrices::m_shadow_split[2],
@@ -302,7 +306,9 @@ public:
}; // ShadowedSunLightShaderESM
// ============================================================================
static void renderPointLights(unsigned count)
static void renderPointLights(unsigned count,
GLuint normal_depth_rander_target,
GLuint depth_stencil_texture)
{
glEnable(GL_BLEND);
glBlendEquation(GL_FUNC_ADD);
@@ -318,8 +324,8 @@ static void renderPointLights(unsigned count)
m_point_lights_info);
PointLightShader::getInstance()->setTextureUnits(
irr_driver->getRenderTargetTexture(RTT_NORMAL_AND_DEPTH),
irr_driver->getDepthStencilTexture());
normal_depth_rander_target,
depth_stencil_texture);
PointLightShader::getInstance()->setUniforms();
glDrawArraysInstanced(GL_TRIANGLE_STRIP, 0, 4, count);
@@ -478,6 +484,8 @@ void LightingPasses::renderLights( bool has_shadow,
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())
{
@@ -489,13 +497,18 @@ void LightingPasses::renderLights( bool has_shadow,
glBlendFunc(GL_ONE, GL_ONE);
glBlendEquation(GL_FUNC_ADD);
if (CVS->isESMEnabled())
{
ShadowedSunLightShaderESM::getInstance()->render(shadow_framebuffer);
ShadowedSunLightShaderESM::getInstance()->render(rtts->getRenderTarget(RTT_NORMAL_AND_DEPTH),
rtts->getDepthStencilTexture(),
shadow_framebuffer);
}
else
{
ShadowedSunLightShaderPCF::getInstance()->render(shadow_framebuffer);
ShadowedSunLightShaderPCF::getInstance()->render(rtts->getRenderTarget(RTT_NORMAL_AND_DEPTH),
rtts->getDepthStencilTexture(),
shadow_framebuffer);
}
}
else
@@ -506,7 +519,9 @@ void LightingPasses::renderLights( bool has_shadow,
//points lights
{
ScopedGPUTimer timer(irr_driver->getGPUTimer(Q_POINTLIGHTS));
renderPointLights(std::min(m_point_light_count, LightBaseClass::MAXLIGHT));
renderPointLights(std::min(m_point_light_count, LightBaseClass::MAXLIGHT),
rtts->getRenderTarget(RTT_NORMAL_AND_DEPTH),
rtts->getDepthStencilTexture());
}
} // renderLights
@@ -529,13 +544,16 @@ void LightingPasses::renderAmbientScatter()
glBlendEquation(GL_FUNC_ADD);
glBlendFunc(GL_ONE, GL_ONE);
FogShader::getInstance()->render(start, col);
FogShader::getInstance()->render(start, col, irr_driver->getRTT()->getDepthStencilTexture());
} // renderAmbientScatter
// ----------------------------------------------------------------------------
void LightingPasses::renderLightsScatter()
void LightingPasses::renderLightsScatter(const FrameBuffer& half1_framebuffer,
const FrameBuffer& half2_framebuffer,
const FrameBuffer& colors_framebuffer,
GLuint half1_render_target)
{
irr_driver->getFBO(FBO_HALF1).bind();
half1_framebuffer.bind();
glClearColor(0., 0., 0., 0.);
glClear(GL_COLOR_BUFFER_BIT);
@@ -570,15 +588,15 @@ void LightingPasses::renderLightsScatter()
glDisable(GL_BLEND);
PostProcessing *post_processing = irr_driver->getPostProcessing();
post_processing->renderGaussian6Blur(irr_driver->getFBO(FBO_HALF1),
irr_driver->getFBO(FBO_HALF2), 5., 5.);
post_processing->renderGaussian6Blur(half1_framebuffer,
half2_framebuffer, 5., 5.);
glEnable(GL_BLEND);
glDisable(GL_DEPTH_TEST);
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
irr_driver->getFBO(FBO_COLORS).bind();
post_processing->renderPassThrough(irr_driver->getRenderTargetTexture(RTT_HALF1),
irr_driver->getFBO(FBO_COLORS).getWidth(),
irr_driver->getFBO(FBO_COLORS).getHeight());
post_processing->renderPassThrough(half1_render_target,
colors_framebuffer.getWidth(),
colors_framebuffer.getHeight());
} // renderLightsScatter

5
src/graphics/lighting_passes.hpp
View File

@@ -42,7 +42,10 @@ public:
const FrameBuffer& diffuse_specular_framebuffer,
GLuint specular_probe);
void renderAmbientScatter();
void renderLightsScatter();
void renderLightsScatter(const FrameBuffer& half1_framebuffer,
const FrameBuffer& half2_framebuffer,
const FrameBuffer& colors_framebuffer,
GLuint half1_render_target);

6
src/graphics/rtts.cpp
View File

@@ -292,14 +292,14 @@ RTT::~RTT()
void RTT::prepareRender(scene::ICameraSceneNode* camera)
{
irr_driver->setRTT(this);
irr_driver->setRTT(this); //FIXME
irr_driver->getSceneManager()->setActiveCamera(camera);
}
FrameBuffer* RTT::render(scene::ICameraSceneNode* camera, float dt)
{
irr_driver->setRTT(this);
irr_driver->setRTT(this); //FIXME
irr_driver->getSceneManager()->setActiveCamera(camera);
@@ -313,7 +313,7 @@ FrameBuffer* RTT::render(scene::ICameraSceneNode* camera, float dt)
glViewport(0, 0,
irr_driver->getActualScreenSize().Width,
irr_driver->getActualScreenSize().Height);
irr_driver->setRTT(NULL);
irr_driver->setRTT(NULL); //FIXME
glBindFramebuffer(GL_FRAMEBUFFER, 0);
irr_driver->getSceneManager()->setActiveCamera(NULL);

105
src/graphics/rtts.hpp
View File

@@ -18,7 +18,6 @@
#ifndef HEADER_RTTS_HPP
#define HEADER_RTTS_HPP
#include "graphics/irr_driver.hpp"
#include "utils/ptr_vector.hpp"
#include "utils/leak_check.hpp"
@@ -35,6 +34,108 @@ namespace irr {
using irr::video::ITexture;
enum TypeFBO
{
FBO_SSAO,
FBO_NORMAL_AND_DEPTHS,
FBO_COMBINED_DIFFUSE_SPECULAR,
FBO_COLORS,
FBO_DIFFUSE,
FBO_SPECULAR,
FBO_MLAA_COLORS,
FBO_MLAA_BLEND,
FBO_MLAA_TMP,
FBO_TMP1_WITH_DS,
FBO_TMP2_WITH_DS,
FBO_TMP4,
FBO_LINEAR_DEPTH,
FBO_HALF1,
FBO_HALF1_R,
FBO_HALF2,
FBO_HALF2_R,
FBO_QUARTER1,
FBO_QUARTER2,
FBO_EIGHTH1,
FBO_EIGHTH2,
FBO_DISPLACE,
FBO_BLOOM_1024,
FBO_SCALAR_1024,
FBO_BLOOM_512,
FBO_TMP_512,
FBO_LENS_512,
FBO_BLOOM_256,
FBO_TMP_256,
FBO_LENS_256,
FBO_BLOOM_128,
FBO_TMP_128,
FBO_LENS_128,
FBO_COUNT
};
enum TypeRTT
{
RTT_TMP1 = 0,
RTT_TMP2,
RTT_TMP3,
RTT_TMP4,
RTT_LINEAR_DEPTH,
RTT_NORMAL_AND_DEPTH,
RTT_COLOR,
RTT_DIFFUSE,
RTT_SPECULAR,
RTT_HALF1,
RTT_HALF2,
RTT_HALF1_R,
RTT_HALF2_R,
RTT_QUARTER1,
RTT_QUARTER2,
// RTT_QUARTER3,
// RTT_QUARTER4,
RTT_EIGHTH1,
RTT_EIGHTH2,
// RTT_SIXTEENTH1,
// RTT_SIXTEENTH2,
RTT_SSAO,
// RTT_COLLAPSE,
// RTT_COLLAPSEH,
// RTT_COLLAPSEV,
// RTT_COLLAPSEH2,
// RTT_COLLAPSEV2,
// RTT_WARPH,
// RTT_WARPV,
// RTT_HALF_SOFT,
RTT_DISPLACE,
RTT_MLAA_COLORS,
RTT_MLAA_BLEND,
RTT_MLAA_TMP,
RTT_BLOOM_1024,
RTT_SCALAR_1024,
RTT_BLOOM_512,
RTT_TMP_512,
RTT_LENS_512,
RTT_BLOOM_256,
RTT_TMP_256,
RTT_LENS_256,
RTT_BLOOM_128,
RTT_TMP_128,
RTT_LENS_128,
RTT_COUNT
};
class RTT
{
@@ -52,7 +153,7 @@ public:
FrameBuffer* render(irr::scene::ICameraSceneNode* camera, float dt);
void prepareRender(scene::ICameraSceneNode* camera);
void prepareRender(irr::scene::ICameraSceneNode* camera);
private:
unsigned RenderTargetTextures[RTT_COUNT];

23
src/graphics/shader_based_renderer.cpp
View File

@@ -396,7 +396,10 @@ 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();
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));
PROFILER_POP_CPU_MARKER();
}
@@ -573,7 +576,7 @@ void ShaderBasedRenderer::renderPostProcessing(Camera * const camera)
}
ShaderBasedRenderer::ShaderBasedRenderer()
ShaderBasedRenderer::ShaderBasedRenderer():AbstractRenderer()
{
m_skybox = NULL;
m_spherical_harmonics = new SphericalHarmonics(irr_driver->getAmbientLight().toSColor());
@@ -594,6 +597,22 @@ ShaderBasedRenderer::~ShaderBasedRenderer()
delete m_skybox;
}
void ShaderBasedRenderer::onLoadWorld()
{
const core::recti &viewport = Camera::getCamera(0)->getViewport();
size_t width = viewport.LowerRightCorner.X - viewport.UpperLeftCorner.X;
size_t height = viewport.LowerRightCorner.Y - viewport.UpperLeftCorner.Y;
m_rtts = new RTT(width, height);
}
void ShaderBasedRenderer::onUnloadWorld()
{
delete m_rtts;
m_rtts = NULL;
removeSkyBox();
}
void ShaderBasedRenderer::addSkyBox(const std::vector<video::ITexture*> &texture,
const std::vector<video::ITexture*> &spherical_harmonics_textures)

5
src/graphics/shader_based_renderer.hpp
View File

@@ -32,7 +32,6 @@ class ShaderBasedRenderer: public AbstractRenderer
private:
Skybox *m_skybox;
SphericalHarmonics *m_spherical_harmonics;
//GLsync m_sync; //TODO
DrawCalls m_draw_calls;
@@ -85,6 +84,10 @@ private:
public:
ShaderBasedRenderer();
~ShaderBasedRenderer();
void onLoadWorld() ;
void onUnloadWorld();
void addSkyBox(const std::vector<irr::video::ITexture*> &texture,
const std::vector<irr::video::ITexture*> &spherical_harmonics_textures) override;

8
src/graphics/shadow_matrices.cpp
View File

@@ -18,7 +18,6 @@
#include "graphics/shadow_matrices.hpp"
#include "graphics/central_settings.hpp"
#include "graphics/glwrap.hpp"
#include "graphics/irr_driver.hpp"
#include "graphics/post_processing.hpp"
#include "graphics/rtts.hpp"
@@ -217,7 +216,8 @@ core::matrix4 ShadowMatrices::getTighestFitOrthoProj(const core::matrix4 &transf
* I have some motivation
*/
void ShadowMatrices::updateSplitAndLightcoordRangeFromComputeShaders(unsigned int width,
unsigned int height)
unsigned int height,
GLuint depth_stencil_texture)
{
struct CascadeBoundingBox
{
@@ -254,7 +254,7 @@ void ShadowMatrices::updateSplitAndLightcoordRangeFromComputeShaders(unsigned in
LightspaceBoundingBoxShader::getInstance()->use();
LightspaceBoundingBoxShader::getInstance()
->setTextureUnits(irr_driver->getDepthStencilTexture());
->setTextureUnits(depth_stencil_texture);
LightspaceBoundingBoxShader::getInstance()
->setUniforms(m_sun_cam->getViewMatrix(),
ShadowMatrices::m_shadow_split[1],
@@ -295,7 +295,7 @@ void ShadowMatrices::computeMatrixesAndCameras(scene::ICameraSceneNode *const ca
unsigned int width, unsigned int height)
{
if (CVS->isSDSMEnabled())
updateSplitAndLightcoordRangeFromComputeShaders(width, height);
updateSplitAndLightcoordRangeFromComputeShaders(width, height, irr_driver->getRTT()->getDepthStencilTexture());
static_cast<scene::CSceneManager *>(irr_driver->getSceneManager())
->OnAnimate(os::Timer::getTime());
camnode->render();

5
src/graphics/shadow_matrices.hpp
View File

@@ -19,6 +19,8 @@
#ifndef HEADER_SHADOW_MATRICES_HPP
#define HEADER_SHADOW_MATRICES_HPP
#include "graphics/glwrap.hpp"
#include "matrix4.h"
#include "vector3d.h"
@@ -53,7 +55,8 @@ private:
void updateSplitAndLightcoordRangeFromComputeShaders(unsigned int width,
unsigned int height);
unsigned int height,
GLuint depth_stencil_texture);
core::matrix4 getTighestFitOrthoProj(const core::matrix4 &transform,
const std::vector<core::vector3df> &pointsInside,
std::pair<float, float> &size);