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

Improved LightingPasses interfaces

Browse Source
This commit is contained in:
Elderme 2015-10-10 16:06:03 +02:00
parent 0ebadf7963
commit 7590a90e67
9 changed files with 62 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/graphics/abstract_renderer.hpp
View File

@ -45,10 +45,10 @@ public:
virtual void render(float dt) = 0;
virtual void renderScene(irr::scene::ICameraSceneNode * const camnode,
unsigned pointlightcount, std::vector<GlowData>& glows,
std::vector<GlowData>& glows,
float dt, bool hasShadows, bool forceRTT) = 0;
virtual unsigned updateLightsInfo(irr::scene::ICameraSceneNode * const camnode,
virtual void updateLightsInfo(irr::scene::ICameraSceneNode * const camnode,
float dt) = 0;
// ------------------------------------------------------------------------

4
src/graphics/fixed_pipeline_renderer.hpp
View File

@ -26,9 +26,9 @@ public:
void render(float dt);
void renderScene(irr::scene::ICameraSceneNode * const camnode,
unsigned pointlightcount, std::vector<GlowData>& glows,
std::vector<GlowData>& glows,
float dt, bool hasShadows, bool forceRTT){}
unsigned updateLightsInfo(irr::scene::ICameraSceneNode * const camnode,
void updateLightsInfo(irr::scene::ICameraSceneNode * const camnode,
float dt){}
};

7
src/graphics/geometry_passes.cpp
View File

@ -1169,6 +1169,11 @@ void multidraw1stPass(Args...args)
} // multidraw1stPass
GeometryPasses::GeometryPasses()
{
m_displace_tex = irr_driver->getTexture(FileManager::TEXTURE, "displace.png");
}
// ----------------------------------------------------------------------------
void GeometryPasses::renderSolidFirstPass()
{
@ -1610,8 +1615,6 @@ void GeometryPasses::renderTransparent(unsigned render_target)
}
irr_driver->getFBO(FBO_DISPLACE).bind();
if (!m_displace_tex)
m_displace_tex = irr_driver->getTexture(FileManager::TEXTURE, "displace.png"); //TODO: move in class constructor
for (unsigned i = 0; i < ListDisplacement::getInstance()->size(); i++)
{
const GLMesh &mesh =

2
src/graphics/geometry_passes.hpp
View File

@ -30,6 +30,8 @@ private:
public:
GeometryPasses();
void renderSolidFirstPass();
void renderSolidSecondPass( unsigned render_target_diffuse,
unsigned render_target_specular,

38
src/graphics/lighting_passes.cpp
View File

@ -326,8 +326,8 @@ static void renderPointLights(unsigned count)
} // renderPointLights
// ----------------------------------------------------------------------------
unsigned LightingPasses::updateLightsInfo(scene::ICameraSceneNode * const camnode,
float dt)
void LightingPasses::updateLightsInfo(scene::ICameraSceneNode * const camnode,
float dt)
{
std::vector<LightNode *> lights = irr_driver->getLights();
const u32 lightcount = (u32)lights.size();
@ -352,14 +352,14 @@ unsigned LightingPasses::updateLightsInfo(scene::ICameraSceneNode * const camnod
BucketedLN[idx].push_back(lights[i]);
}
unsigned lightnum = 0;
m_point_light_count = 0;
bool multiplayer = (race_manager->getNumLocalPlayers() > 1);
for (unsigned i = 0; i < 15; i++)
{
for (unsigned j = 0; j < BucketedLN[i].size(); j++)
{
if (++lightnum >= LightBaseClass::MAXLIGHT)
if (++m_point_light_count >= LightBaseClass::MAXLIGHT)
{
LightNode* light_node = BucketedLN[i].at(j);
light_node->setEnergyMultiplier(0.0f);
@ -380,31 +380,30 @@ unsigned LightingPasses::updateLightsInfo(scene::ICameraSceneNode * const camnod
}
const core::vector3df &pos = light_node->getAbsolutePosition();
m_point_lights_info[lightnum].posX = pos.X;
m_point_lights_info[lightnum].posY = pos.Y;
m_point_lights_info[lightnum].posZ = pos.Z;
m_point_lights_info[m_point_light_count].posX = pos.X;
m_point_lights_info[m_point_light_count].posY = pos.Y;
m_point_lights_info[m_point_light_count].posZ = pos.Z;
m_point_lights_info[lightnum].energy =
m_point_lights_info[m_point_light_count].energy =
light_node->getEffectiveEnergy();
const core::vector3df &col = light_node->getColor();
m_point_lights_info[lightnum].red = col.X;
m_point_lights_info[lightnum].green = col.Y;
m_point_lights_info[lightnum].blue = col.Z;
m_point_lights_info[m_point_light_count].red = col.X;
m_point_lights_info[m_point_light_count].green = col.Y;
m_point_lights_info[m_point_light_count].blue = col.Z;
// Light radius
m_point_lights_info[lightnum].radius = light_node->getRadius();
m_point_lights_info[m_point_light_count].radius = light_node->getRadius();
}
}
if (lightnum > LightBaseClass::MAXLIGHT)
if (m_point_light_count > LightBaseClass::MAXLIGHT)
{
irr_driver->setLastLightBucketDistance(i * 10);
break;
}
}
lightnum++;
return lightnum;
m_point_light_count++;
} // updateLightsInfo
// ----------------------------------------------------------------------------
@ -463,7 +462,8 @@ void LightingPasses::renderGlobalIllumination( ShadowMatrices *shadow_matrices,
}
}
void LightingPasses::renderLights( unsigned point_light_count, bool has_shadow,
// ----------------------------------------------------------------------------
void LightingPasses::renderLights( bool has_shadow,
const FrameBuffer& shadow_framebuffer,
const FrameBuffer& diffuse_specular_framebuffer)
{
@ -513,7 +513,7 @@ void LightingPasses::renderLights( unsigned point_light_count, bool has_shadow,
//points lights
{
ScopedGPUTimer timer(irr_driver->getGPUTimer(Q_POINTLIGHTS));
renderPointLights(std::min(point_light_count, LightBaseClass::MAXLIGHT));
renderPointLights(std::min(m_point_light_count, LightBaseClass::MAXLIGHT));
}
} // renderLights
@ -540,7 +540,7 @@ void LightingPasses::renderAmbientScatter()
} // renderAmbientScatter
// ----------------------------------------------------------------------------
void LightingPasses::renderLightsScatter(unsigned point_light_count)
void LightingPasses::renderLightsScatter()
{
irr_driver->getFBO(FBO_HALF1).bind();
glClearColor(0., 0., 0., 0.);
@ -573,7 +573,7 @@ void LightingPasses::renderLightsScatter(unsigned point_light_count)
->setUniforms(1.f / (40.f * start), col2);
glDrawArraysInstanced(GL_TRIANGLE_STRIP, 0, 4,
std::min(point_light_count, LightBaseClass::MAXLIGHT));
std::min(m_point_light_count, LightBaseClass::MAXLIGHT));
glDisable(GL_BLEND);
PostProcessing *post_processing = irr_driver->getPostProcessing();

12
src/graphics/lighting_passes.hpp
View File

@ -24,22 +24,24 @@
class LightingPasses
{
private:
unsigned m_point_light_count;
public:
unsigned updateLightsInfo(irr::scene::ICameraSceneNode * const camnode,
float dt);
LightingPasses(): m_point_light_count(0){}
void updateLightsInfo(irr::scene::ICameraSceneNode * const camnode,
float dt);
void renderGlobalIllumination( ShadowMatrices *shadow_matrices,
const FrameBuffer& radiance_hint_framebuffer,
const FrameBuffer& reflective_shadow_map_framebuffer,
const FrameBuffer& diffuse_framebuffer);
void renderLights( unsigned point_light_count, bool has_shadow,
void renderLights( bool has_shadow,
const FrameBuffer& shadow_framebuffer,
const FrameBuffer& diffuse_specular_framebuffer);
void renderAmbientScatter();
void renderLightsScatter(unsigned point_light_count);
void renderLightsScatter();

4
src/graphics/rtts.cpp
View File

@ -305,9 +305,9 @@ FrameBuffer* RTT::render(scene::ICameraSceneNode* camera, float dt)
std::vector<GlowData> glows;
irr_driver->computeMatrixesAndCameras(camera, m_width, m_height);
unsigned plc = irr_driver->getRenderer()->updateLightsInfo(camera, dt);
irr_driver->getRenderer()->updateLightsInfo(camera, dt);
irr_driver->uploadLightingData();
irr_driver->getRenderer()->renderScene(camera, plc, glows, dt, false, true);
irr_driver->getRenderer()->renderScene(camera, glows, dt, false, true);
FrameBuffer* frame_buffer = irr_driver->getPostProcessing()->render(camera, false);
// reset

38
src/graphics/shader_based_renderer.cpp
View File

@ -145,14 +145,14 @@ void ShaderBasedRenderer::prepareForwardRenderer()
}
// ----------------------------------------------------------------------------
unsigned ShaderBasedRenderer::updateLightsInfo(scene::ICameraSceneNode * const camnode,
float dt)
void ShaderBasedRenderer::updateLightsInfo(scene::ICameraSceneNode * const camnode,
float dt)
{
return m_lighting_passes->updateLightsInfo(camnode, dt);
m_lighting_passes.updateLightsInfo(camnode, dt);
}
// ============================================================================
void ShaderBasedRenderer::renderScene(scene::ICameraSceneNode * const camnode, unsigned pointlightcount, std::vector<GlowData>& glows, float dt, bool hasShadow, bool forceRTT)
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();
@ -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()->getShadowFrameBuffer());
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()->getReflectiveShadowMapFrameBuffer()); //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();
}
}
@ -198,7 +198,7 @@ void ShaderBasedRenderer::renderScene(scene::ICameraSceneNode * const camnode, u
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_geometry_passes.renderSolidFirstPass();
}
else
{
@ -228,13 +228,13 @@ void ShaderBasedRenderer::renderScene(scene::ICameraSceneNode * const camnode, u
if (CVS->isDefferedEnabled())
if (CVS->isGlobalIlluminationEnabled() && hasShadow)
{
m_lighting_passes->renderGlobalIllumination(irr_driver->getShadowMatrices(),
m_lighting_passes.renderGlobalIllumination(irr_driver->getShadowMatrices(),
irr_driver->getRTT()->getRadianceHintFrameBuffer(),
irr_driver->getRTT()->getReflectiveShadowMapFrameBuffer(),
irr_driver->getRTT()->getFBO(FBO_DIFFUSE));
}
m_lighting_passes->renderLights(pointlightcount, hasShadow,
m_lighting_passes.renderLights( hasShadow,
irr_driver->getRTT()->getShadowFrameBuffer(),
irr_driver->getRTT()->getFBO(FBO_COMBINED_DIFFUSE_SPECULAR));
PROFILER_POP_CPU_MARKER();
@ -262,7 +262,7 @@ void ShaderBasedRenderer::renderScene(scene::ICameraSceneNode * const camnode, u
glClear(GL_COLOR_BUFFER_BIT);
glDepthMask(GL_FALSE);
}
m_geometry_passes->renderSolidSecondPass(rtts->getRenderTarget(RTT_DIFFUSE),
m_geometry_passes.renderSolidSecondPass(rtts->getRenderTarget(RTT_DIFFUSE),
rtts->getRenderTarget(RTT_SPECULAR),
rtts->getRenderTarget(RTT_HALF1_R));
PROFILER_POP_CPU_MARKER();
@ -270,7 +270,7 @@ void ShaderBasedRenderer::renderScene(scene::ICameraSceneNode * const camnode, u
if (irr_driver->getNormals())
{
rtts->getFBO(FBO_NORMAL_AND_DEPTHS).bind();
m_geometry_passes->renderNormalsVisualisation();
m_geometry_passes.renderNormalsVisualisation();
rtts->getFBO(FBO_COLORS).bind();
}
@ -280,7 +280,7 @@ void ShaderBasedRenderer::renderScene(scene::ICameraSceneNode * const camnode, u
{
PROFILER_PUSH_CPU_MARKER("- Ambient scatter", 0xFF, 0x00, 0x00);
ScopedGPUTimer Timer(irr_driver->getGPUTimer(Q_FOG));
m_lighting_passes->renderAmbientScatter();
m_lighting_passes.renderAmbientScatter();
PROFILER_POP_CPU_MARKER();
}
@ -297,7 +297,7 @@ void ShaderBasedRenderer::renderScene(scene::ICameraSceneNode * const camnode, u
{
PROFILER_PUSH_CPU_MARKER("- PointLight Scatter", 0xFF, 0x00, 0x00);
ScopedGPUTimer Timer(irr_driver->getGPUTimer(Q_FOG));
m_lighting_passes->renderLightsScatter(pointlightcount);
m_lighting_passes.renderLightsScatter();
PROFILER_POP_CPU_MARKER();
}
@ -335,7 +335,7 @@ void ShaderBasedRenderer::renderScene(scene::ICameraSceneNode * const camnode, u
{
PROFILER_PUSH_CPU_MARKER("- Transparent Pass", 0xFF, 0x00, 0x00);
ScopedGPUTimer Timer(irr_driver->getGPUTimer(Q_TRANSPARENT));
m_geometry_passes->renderTransparent(irr_driver->getRTT()->getRenderTarget(RTT_DISPLACE));
m_geometry_passes.renderTransparent(irr_driver->getRTT()->getRenderTarget(RTT_DISPLACE));
PROFILER_POP_CPU_MARKER();
}
@ -459,14 +459,12 @@ void ShaderBasedRenderer::renderPostProcessing(Camera * const camera)
ShaderBasedRenderer::ShaderBasedRenderer():AbstractRenderer()
{
m_geometry_passes = new GeometryPasses();
m_lighting_passes = new LightingPasses();
}
ShaderBasedRenderer::~ShaderBasedRenderer()
{
delete m_geometry_passes;
delete m_lighting_passes;
}
void ShaderBasedRenderer::render(float dt)
@ -514,14 +512,14 @@ void ShaderBasedRenderer::render(float dt)
glEnable(GL_FRAMEBUFFER_SRGB);
PROFILER_PUSH_CPU_MARKER("Update Light Info", 0xFF, 0x0, 0x0);
unsigned plc = updateLightsInfo(camnode, dt); //TODO: replace plc by a more explicit name
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();
irr_driver->uploadLightingData(); //TODO: move method; update "global" lighting (sun and spherical harmonics)
PROFILER_POP_CPU_MARKER();
renderScene(camnode, plc, glows, dt, track->hasShadows(), false);
renderScene(camnode, glows, dt, track->hasShadows(), false);
if (irr_driver->getBoundingBoxesViz())
{

10
src/graphics/shader_based_renderer.hpp
View File

@ -25,19 +25,19 @@
class ShaderBasedRenderer: public AbstractRenderer
{
private:
GeometryPasses *m_geometry_passes;
LightingPasses *m_lighting_passes;
GeometryPasses m_geometry_passes;
LightingPasses m_lighting_passes;
void compressPowerUpTextures();
void setOverrideMaterial();
std::vector<GlowData> updateGlowingList();
void prepareForwardRenderer();
unsigned updateLightsInfo(irr::scene::ICameraSceneNode * const camnode,
float dt);
void updateLightsInfo(irr::scene::ICameraSceneNode * const camnode,
float dt);
void renderScene(irr::scene::ICameraSceneNode * const camnode,
unsigned pointlightcount, std::vector<GlowData>& glows,
std::vector<GlowData>& glows,
float dt, bool hasShadows, bool forceRTT);
void renderBoundingBoxes();
void debugPhysics();