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

Remove irr_driver dependency in GeometryPasses class

Browse Source
This commit is contained in:
Elderme 2015-10-04 13:58:54 +02:00
parent ff6e6c8340
commit cf7bb82e8a
7 changed files with 34 additions and 31 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
src/graphics/geometry_passes.cpp
View File

@ -18,7 +18,6 @@
#include "graphics/geometry_passes.hpp"
#include "graphics/callbacks.hpp"
#include "graphics/glwrap.hpp"
#include "graphics/irr_driver.hpp" //TODO: remove dependency
#include "graphics/post_processing.hpp"
#include "graphics/rtts.hpp"
#include "graphics/shaders.hpp"
@ -1303,29 +1302,29 @@ void multidraw2ndPass(const std::vector<uint64_t> &Handles, Args... args)
// ----------------------------------------------------------------------------
void GeometryPasses::renderSolidSecondPass()
void GeometryPasses::renderSolidSecondPass(unsigned renderTargetDiffuse,
unsigned renderTargetSpecular,
unsigned renderTargetHalfRed)
{
irr_driver->setPhase(SOLID_LIT_PASS);
glEnable(GL_DEPTH_TEST);
glDisable(GL_BLEND);
uint64_t DiffuseHandle = 0, SpecularHandle = 0, SSAOHandle = 0, DepthHandle = 0;
RTT *rtts = irr_driver->getRTT();
if (CVS->isAZDOEnabled())
{
DiffuseHandle = glGetTextureSamplerHandleARB(rtts->getRenderTarget(RTT_DIFFUSE),
DiffuseHandle = glGetTextureSamplerHandleARB(renderTargetDiffuse,
Shaders::ObjectPass2Shader::getInstance()->m_sampler_ids[0]);
if (!glIsTextureHandleResidentARB(DiffuseHandle))
glMakeTextureHandleResidentARB(DiffuseHandle);
SpecularHandle = glGetTextureSamplerHandleARB(rtts->getRenderTarget(RTT_SPECULAR),
SpecularHandle = glGetTextureSamplerHandleARB(renderTargetSpecular,
Shaders::ObjectPass2Shader::getInstance()->m_sampler_ids[1]);
if (!glIsTextureHandleResidentARB(SpecularHandle))
glMakeTextureHandleResidentARB(SpecularHandle);
SSAOHandle = glGetTextureSamplerHandleARB(rtts->getRenderTarget(RTT_HALF1_R),
SSAOHandle = glGetTextureSamplerHandleARB(renderTargetHalfRed,
Shaders::ObjectPass2Shader::getInstance()->m_sampler_ids[2]);
if (!glIsTextureHandleResidentARB(SSAOHandle))
glMakeTextureHandleResidentARB(SSAOHandle);
@ -1349,9 +1348,9 @@ void GeometryPasses::renderSolidSecondPass()
ImmediateDrawList::getInstance()->at(i)->render();
std::vector<GLuint> DiffSpecSSAOTex =
createVector<GLuint>(rtts->getRenderTarget(RTT_DIFFUSE),
rtts->getRenderTarget(RTT_SPECULAR),
rtts->getRenderTarget(RTT_HALF1_R));
createVector<GLuint>(renderTargetDiffuse,
renderTargetSpecular,
renderTargetHalfRed);
renderMeshes2ndPass<DefaultMaterial, 3, 1>(createVector<uint64_t>(DiffuseHandle, SpecularHandle, SSAOHandle), DiffSpecSSAOTex);
renderMeshes2ndPass<AlphaRef, 3, 1 >(createVector<uint64_t>(DiffuseHandle, SpecularHandle, SSAOHandle), DiffSpecSSAOTex);
@ -1512,7 +1511,7 @@ void renderTransparenPass(const std::vector<RenderGeometry::TexUnit> &TexUnits,
} // renderTransparenPass
// ----------------------------------------------------------------------------
void GeometryPasses::renderTransparent()
void GeometryPasses::renderTransparent(unsigned rendertarget)
{
glEnable(GL_DEPTH_TEST);
@ -1644,7 +1643,7 @@ void GeometryPasses::renderTransparent()
irr_driver->getFBO(FBO_COLORS).bind();
glStencilFunc(GL_EQUAL, 1, 0xFF);
irr_driver->getPostProcessing()->renderPassThrough(irr_driver->getRTT()->getRenderTarget(RTT_DISPLACE),
irr_driver->getPostProcessing()->renderPassThrough(rendertarget,
irr_driver->getFBO(FBO_COLORS).getWidth(),
irr_driver->getFBO(FBO_COLORS).getHeight());
glDisable(GL_STENCIL_TEST);
@ -1754,15 +1753,14 @@ static void multidrawShadow(unsigned i, Args ...args)
// ----------------------------------------------------------------------------
void GeometryPasses::renderShadows()
void GeometryPasses::renderShadows(const FrameBuffer& shadowFrameBuffer)
{
glDepthFunc(GL_LEQUAL);
glDepthMask(GL_TRUE);
glEnable(GL_DEPTH_TEST);
glDisable(GL_BLEND);
RTT *rtts = irr_driver->getRTT();
rtts->getShadowFBO().bind();
shadowFrameBuffer.bind();
if (!CVS->isESMEnabled())
{
glDrawBuffer(GL_NONE);
@ -1826,12 +1824,12 @@ void GeometryPasses::renderShadows()
for (unsigned i = 0; i < 2; i++)
{
irr_driver->getPostProcessing()->renderGaussian6BlurLayer(
rtts->getShadowFBO(), i,
shadowFrameBuffer, i,
2.f * shadow_scales[0].first / shadow_scales[i].first,
2.f * shadow_scales[0].second / shadow_scales[i].second);
}
}
glBindTexture(GL_TEXTURE_2D_ARRAY, rtts->getShadowFBO().getRTT()[0]);
glBindTexture(GL_TEXTURE_2D_ARRAY, shadowFrameBuffer.getRTT()[0]);
glGenerateMipmap(GL_TEXTURE_2D_ARRAY);
}
} // renderShadows
@ -1926,12 +1924,12 @@ void multidrawRSM(Args...args)
} // multidrawRSM
// ----------------------------------------------------------------------------
void GeometryPasses::renderRSM()
void GeometryPasses::renderReflectiveShadowMap(const FrameBuffer& reflectiveShadowMapFrameBuffer)
{
if (irr_driver->getShadowMatrices()->isRSMMapAvail())
return;
ScopedGPUTimer Timer(irr_driver->getGPUTimer(Q_RSM));
irr_driver->getRTT()->getRSM().bind();
reflectiveShadowMapFrameBuffer.bind();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
const core::matrix4 &rsm_matrix = irr_driver->getShadowMatrices()->getRSMMatrix();

11
src/graphics/geometry_passes.hpp
View File

@ -18,6 +18,7 @@
#ifndef HEADER_GEOMETRY_PASSES_HPP
#define HEADER_GEOMETRY_PASSES_HPP
#include "graphics/glwrap.hpp"
#include <ITexture.h>
class GeometryPasses
@ -30,11 +31,13 @@ private:
public:
void renderSolidFirstPass();
void renderSolidSecondPass();
void renderSolidSecondPass( unsigned renderTargetDiffuse,
unsigned renderTargetSpecular,
unsigned renderTargetHalfRed);
void renderNormalsVisualisation();
void renderTransparent();
void renderShadows();
void renderRSM();
void renderTransparent(unsigned rendertarget);
void renderShadows(const FrameBuffer& shadowFrameBuffer);
void renderReflectiveShadowMap(const FrameBuffer& reflectiveShadowMapFrameBuffer);
};

2
src/graphics/glwrap.cpp
View File

@ -252,7 +252,7 @@ void FrameBuffer::bind() const
glDrawBuffers((int)RenderTargets.size(), bufs);
}
void FrameBuffer::bindLayer(unsigned i)
void FrameBuffer::bindLayer(unsigned i) const
{
glBindFramebuffer(GL_FRAMEBUFFER, fbolayer);
glFramebufferTextureLayer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, RenderTargets[0], 0, i);

2
src/graphics/glwrap.hpp
View File

@ -73,7 +73,7 @@ public:
FrameBuffer(const std::vector <GLuint> &RTTs, GLuint DS, size_t w, size_t h, bool layered = false);
~FrameBuffer();
void bind() const;
void bindLayer(unsigned);
void bindLayer(unsigned) const;
const std::vector<GLuint> &getRTT() const { return RenderTargets; }
GLuint &getDepthTexture() { assert(DepthTexture); return DepthTexture; }
size_t getWidth() const { return width; }

2
src/graphics/post_processing.cpp
View File

@ -1108,7 +1108,7 @@ void PostProcessing::renderGaussian3Blur(const FrameBuffer &in_fbo,
} // renderGaussian3Blur
// ----------------------------------------------------------------------------
void PostProcessing::renderGaussian6BlurLayer(FrameBuffer &in_fbo,
void PostProcessing::renderGaussian6BlurLayer(const FrameBuffer &in_fbo,
size_t layer, float sigma_h,
float sigma_v)
{

2
src/graphics/post_processing.hpp
View File

@ -93,7 +93,7 @@ public:
float sigmaV, float sigmaH);
void renderHorizontalBlur(const FrameBuffer &in_fbo, const FrameBuffer &auxiliary);
void renderGaussian6BlurLayer(FrameBuffer &in_fbo, size_t layer,
void renderGaussian6BlurLayer(const FrameBuffer &in_fbo, size_t layer,
float sigmaH, float sigmaV);
void renderGaussian17TapBlur(const FrameBuffer &in_fbo, const FrameBuffer &auxiliary);

10
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();
m_geometry_passes->renderShadows(irr_driver->getRTT()->getShadowFBO());
PROFILER_POP_CPU_MARKER();
if (CVS->isGlobalIlluminationEnabled())
{
PROFILER_PUSH_CPU_MARKER("- RSM", 0xFF, 0x0, 0xFF);
m_geometry_passes->renderRSM();
m_geometry_passes->renderReflectiveShadowMap(irr_driver->getRTT()->getRSM()); //TODO: move somewhere else as RSM are computed only once per track
PROFILER_POP_CPU_MARKER();
}
}
@ -252,7 +252,9 @@ void ShaderBasedRenderer::renderScene(scene::ICameraSceneNode * const camnode, u
glClear(GL_COLOR_BUFFER_BIT);
glDepthMask(GL_FALSE);
}
m_geometry_passes->renderSolidSecondPass();
m_geometry_passes->renderSolidSecondPass(rtts->getRenderTarget(RTT_DIFFUSE),
rtts->getRenderTarget(RTT_SPECULAR),
rtts->getRenderTarget(RTT_HALF1_R));
PROFILER_POP_CPU_MARKER();
if (irr_driver->getNormals())
@ -323,7 +325,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();
m_geometry_passes->renderTransparent(irr_driver->getRTT()->getRenderTarget(RTT_DISPLACE));
PROFILER_POP_CPU_MARKER();
}