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

Split glow to avoid re-bind color framebuffer

Browse Source
This commit is contained in:
Benau 2018-01-30 14:25:50 +08:00
parent 9e57bfb73f
commit 9399db6eba
10 changed files with 33 additions and 123 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/graphics/abstract_renderer.cpp
View File

@ -194,11 +194,3 @@ void AbstractRenderer::drawJoint(bool drawline, bool drawname,
} //drawJoint
#endif //DEBUG
AbstractRenderer::AbstractRenderer()
{
resetObjectCount();
resetPolyCount();
}

24
src/graphics/abstract_renderer.hpp
View File

@ -26,16 +26,6 @@
class RenderTarget;
enum STKRenderingPass
{
SOLID_NORMAL_AND_DEPTH_PASS,
SOLID_LIT_PASS,
TRANSPARENT_PASS,
GLOW_PASS,
SHADOW_PASS,
PASS_COUNT,
};
enum TypeRTT : unsigned int;
struct GlowData {
@ -56,10 +46,6 @@ class AbstractRenderer
protected:
irr::core::vector2df m_current_screen_size;
/** Performance stats */
unsigned m_object_count[PASS_COUNT];
unsigned m_poly_count [PASS_COUNT];
#ifdef DEBUG
void drawDebugMeshes() const;
@ -71,7 +57,7 @@ protected:
void renderSkybox(const irr::scene::ICameraSceneNode *camera) const;
public:
AbstractRenderer();
AbstractRenderer() {}
virtual ~AbstractRenderer(){}
virtual void onLoadWorld() = 0;
@ -114,14 +100,6 @@ public:
*/
virtual std::unique_ptr<RenderTarget> createRenderTarget(const irr::core::dimension2du &dimension,
const std::string &name) = 0;
void resetObjectCount() { memset(m_object_count, 0, sizeof(m_object_count));}
void resetPolyCount() { memset(m_poly_count, 0, sizeof(m_poly_count)); }
void incObjectCount(STKRenderingPass phase) { m_object_count[phase]++; }
unsigned getObjectCount(STKRenderingPass pass) const { return m_object_count[pass]; }
unsigned getPolyCount(STKRenderingPass pass) const { return m_poly_count [pass]; }
};
#endif //HEADER_ABSTRACT_RENDERER_HPP

21
src/graphics/irr_driver.cpp
View File

@ -116,8 +116,7 @@ const bool ALLOW_1280_X_720 = true;
IrrDriver::IrrDriver()
{
m_resolution_changing = RES_CHANGE_NONE;
m_phase = SOLID_NORMAL_AND_DEPTH_PASS;
struct irr::SIrrlichtCreationParameters p;
p.DriverType = video::EDT_NULL;
p.WindowSize = core::dimension2d<u32>(640,480);
@ -174,24 +173,6 @@ void IrrDriver::reset()
#endif
} // reset
// ----------------------------------------------------------------------------
void IrrDriver::setPhase(STKRenderingPass p)
{
m_phase = p;
}
// ----------------------------------------------------------------------------
STKRenderingPass IrrDriver::getPhase() const
{
return m_phase;
}
#// ----------------------------------------------------------------------------
void IrrDriver::increaseObjectCount()
{
m_renderer->incObjectCount(m_phase);
} // increaseObjectCount
// ----------------------------------------------------------------------------
core::array<video::IRenderTarget> &IrrDriver::getMainSetup()
{

8
src/graphics/irr_driver.hpp
View File

@ -175,7 +175,7 @@ private:
unsigned m_last_light_bucket_distance;
unsigned m_skinning_joint;
u32 m_renderpass;
SP::SPDynamicDrawCall* m_sun_interposer;
core::vector3df m_sun_direction;
video::SColorf m_suncolor;
@ -187,8 +187,6 @@ private:
std::vector<scene::ISceneNode *> m_background;
STKRenderingPass m_phase;
float m_ssao_radius;
float m_ssao_k;
float m_ssao_sigma;
@ -209,8 +207,6 @@ public:
void getOpenGLData(std::string *vendor, std::string *renderer,
std::string *version);
void setPhase(STKRenderingPass);
STKRenderingPass getPhase() const;
void increaseObjectCount();
core::array<video::IRenderTarget> &getMainSetup();
void updateConfigIfRelevant();
@ -419,8 +415,6 @@ public:
// ------------------------------------------------------------------------
void setRecording(bool val);
// ------------------------------------------------------------------------
u32 getRenderPass() { return m_renderpass; }
// ------------------------------------------------------------------------
std::vector<LightNode *> getLights() { return m_lights; }
// ------------------------------------------------------------------------
void addGlowingNode(scene::ISceneNode *n, float r = 1.0f, float g = 1.0f,

12
src/graphics/post_processing.cpp
View File

@ -1055,23 +1055,13 @@ void PostProcessing::renderTextureLayer(unsigned tex, unsigned layer) const
} // renderTextureLayer
// ----------------------------------------------------------------------------
void PostProcessing::renderGlow(const FrameBuffer& glow_framebuffer,
const FrameBuffer& half_framebuffer,
const FrameBuffer& quarter_framebuffer,
const FrameBuffer& color_framebuffer ) const
void PostProcessing::renderGlow(const FrameBuffer& quarter_framebuffer) const
{
// To half
FrameBuffer::blit(glow_framebuffer, half_framebuffer, GL_COLOR_BUFFER_BIT, GL_LINEAR);
// To quarter
FrameBuffer::blit(half_framebuffer, quarter_framebuffer, GL_COLOR_BUFFER_BIT, GL_LINEAR);
glEnable(GL_BLEND);
glBlendEquation(GL_FUNC_ADD);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glStencilFunc(GL_EQUAL, 0, ~0);
glEnable(GL_STENCIL_TEST);
color_framebuffer.bind();
GlowShader::getInstance()->render(quarter_framebuffer.getRTT()[0]);
glDisable(GL_STENCIL_TEST);
glDisable(GL_BLEND);

5
src/graphics/post_processing.hpp
View File

@ -99,10 +99,7 @@ public:
void renderMotionBlur(const FrameBuffer &in_fbo,
FrameBuffer &out_fbo,
GLuint depth_stencil_texture);
void renderGlow(const FrameBuffer& glow_framebuffer,
const FrameBuffer& half_framebuffer,
const FrameBuffer& quarter_framebuffer,
const FrameBuffer& color_framebuffer) const;
void renderGlow(const FrameBuffer& quarter_framebuffer) const;
void renderLightning(core::vector3df intensity);
/** Use motion blur for a short time */

2
src/graphics/rtts.cpp
View File

@ -190,7 +190,7 @@ RTT::RTT(unsigned int width, unsigned int height, float rtt_scale,
somevector.clear();
somevector.push_back(m_render_target_textures[RTT_RGBA_2]);
m_frame_buffers[FBO_RGBA_2] = new FrameBuffer(somevector, res.Width, res.Height);
m_frame_buffers[FBO_RGBA_2] = new FrameBuffer(somevector, m_depth_stencil_tex, res.Width, res.Height);
somevector.clear();
somevector.push_back(m_render_target_textures[RTT_DIFFUSE]);

54
src/graphics/shader_based_renderer.cpp
View File

@ -148,7 +148,7 @@ void ShaderBasedRenderer::renderSSAO() const
void ShaderBasedRenderer::renderGlow() const
{
irr_driver->getSceneManager()->setCurrentRendertime(scene::ESNRP_SOLID);
m_rtts->getFBO(FBO_RGBA_1).bind();
m_rtts->getFBO(FBO_RGBA_2).bind();
glClearStencil(0);
glClearColor(0, 0, 0, 0);
glClear(GL_STENCIL_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
@ -236,11 +236,7 @@ void ShaderBasedRenderer::renderSceneDeferred(scene::ICameraSceneNode * const ca
irr_driver->getSceneManager()->setActiveCamera(camnode);
PROFILER_PUSH_CPU_MARKER("- Draw Call Generation", 0xFF, 0xFF, 0xFF);
unsigned solid_poly_count = 0;
unsigned shadow_poly_count = 0;
m_draw_calls.prepareDrawCalls(camnode);
m_poly_count[SOLID_NORMAL_AND_DEPTH_PASS] += solid_poly_count;
m_poly_count[SHADOW_PASS] += shadow_poly_count;
PROFILER_POP_CPU_MARKER();
PROFILER_PUSH_CPU_MARKER("Update Light Info", 0xFF, 0x0, 0x0);
m_lighting_passes.updateLightsInfo(camnode, dt);
@ -279,7 +275,7 @@ void ShaderBasedRenderer::renderSceneDeferred(scene::ICameraSceneNode * const ca
glClearBufferfv(GL_COLOR, 1, clear_color_empty);
glClearBufferfv(GL_COLOR, 2, clear_color_gloss);
glClearBufferfi(GL_DEPTH_STENCIL, 0, 1.0f, 0);
ScopedGPUTimer Timer(irr_driver->getGPUTimer(Q_SOLID_PASS1));
ScopedGPUTimer Timer(irr_driver->getGPUTimer(Q_SOLID_PASS));
SP::draw(SP::RP_1ST, SP::DCT_NORMAL);
}
@ -325,12 +321,27 @@ void ShaderBasedRenderer::renderSceneDeferred(scene::ICameraSceneNode * const ca
PROFILER_POP_CPU_MARKER();
}
// Render anything glowing.
if (UserConfigParams::m_glow)
{
PROFILER_PUSH_CPU_MARKER("- Glow", 0xFF, 0xFF, 0x00);
ScopedGPUTimer Timer(irr_driver->getGPUTimer(Q_GLOW));
renderGlow();
// To half
FrameBuffer::blit(m_rtts->getFBO(FBO_RGBA_2),
m_rtts->getFBO(FBO_HALF2), GL_COLOR_BUFFER_BIT, GL_LINEAR);
// To quarter
FrameBuffer::blit(m_rtts->getFBO(FBO_HALF2),
m_rtts->getFBO(FBO_QUARTER1), GL_COLOR_BUFFER_BIT, GL_LINEAR);
PROFILER_POP_CPU_MARKER();
} // end glow
m_rtts->getFBO(FBO_COLORS).bind();
glClear(GL_COLOR_BUFFER_BIT);
{
PROFILER_PUSH_CPU_MARKER("- Combine diffuse color", 0x2F, 0x77, 0x33);
ScopedGPUTimer Timer(irr_driver->getGPUTimer(Q_SOLID_PASS2));
ScopedGPUTimer Timer(irr_driver->getGPUTimer(Q_COMBINE_DIFFUSE_COLOR));
glDisable(GL_DEPTH_TEST);
glDepthMask(GL_FALSE);
glDisable(GL_BLEND);
@ -361,20 +372,10 @@ void ShaderBasedRenderer::renderSceneDeferred(scene::ICameraSceneNode * const ca
PROFILER_POP_CPU_MARKER();
}
PROFILER_PUSH_CPU_MARKER("- Glow", 0xFF, 0xFF, 0x00);
// Render anything glowing.
if (UserConfigParams::m_glow)
{
ScopedGPUTimer Timer(irr_driver->getGPUTimer(Q_GLOW));
irr_driver->setPhase(GLOW_PASS);
renderGlow();
m_post_processing->renderGlow(m_rtts->getFBO(FBO_RGBA_1),
m_rtts->getFBO(FBO_HALF1),
m_rtts->getFBO(FBO_QUARTER1),
m_rtts->getFBO(FBO_COLORS));
} // end glow
PROFILER_POP_CPU_MARKER();
m_post_processing->renderGlow(m_rtts->getFBO(FBO_QUARTER1));
}
// Render transparent
{
@ -406,8 +407,6 @@ void ShaderBasedRenderer::renderSceneDeferred(scene::ICameraSceneNode * const ca
return;
}
// Ensure that no object will be drawn after that by using invalid pass
irr_driver->setPhase(PASS_COUNT);
} //renderSceneDeferred
// ----------------------------------------------------------------------------
@ -425,11 +424,7 @@ void ShaderBasedRenderer::renderScene(scene::ICameraSceneNode * const camnode,
irr_driver->getSceneManager()->setActiveCamera(camnode);
PROFILER_PUSH_CPU_MARKER("- Draw Call Generation", 0xFF, 0xFF, 0xFF);
unsigned solid_poly_count = 0;
unsigned shadow_poly_count = 0;
m_draw_calls.prepareDrawCalls(camnode);
m_poly_count[SOLID_NORMAL_AND_DEPTH_PASS] += solid_poly_count;
m_poly_count[SHADOW_PASS] += shadow_poly_count;
PROFILER_POP_CPU_MARKER();
glDepthMask(GL_TRUE);
@ -456,7 +451,7 @@ void ShaderBasedRenderer::renderScene(scene::ICameraSceneNode * const camnode,
glDepthMask(GL_TRUE);
glEnable(GL_DEPTH_TEST);
glDisable(GL_BLEND);
ScopedGPUTimer Timer(irr_driver->getGPUTimer(Q_SOLID_PASS1));
ScopedGPUTimer Timer(irr_driver->getGPUTimer(Q_SOLID_PASS));
SP::draw(SP::RP_1ST, SP::DCT_NORMAL);
}
@ -497,8 +492,6 @@ void ShaderBasedRenderer::renderScene(scene::ICameraSceneNode * const camnode,
return;
}
// Ensure that no object will be drawn after that by using invalid pass
irr_driver->setPhase(PASS_COUNT);
} //renderScene
// ----------------------------------------------------------------------------
@ -712,9 +705,6 @@ void ShaderBasedRenderer::addSunLight(const core::vector3df &pos)
// ----------------------------------------------------------------------------
void ShaderBasedRenderer::render(float dt)
{
resetObjectCount();
resetPolyCount();
// Start the RTT for post-processing.
// We do this before beginScene() because we want to capture the glClear()
// because of tracks that do not have skyboxes (generally add-on tracks)
@ -852,8 +842,6 @@ void ShaderBasedRenderer::renderToTexture(GL3RenderTarget *render_target,
// For render to texture no triple buffering of ubo is used
SP::sp_cur_player = 0;
SP::sp_cur_buf_id[0] = 0;
resetObjectCount();
resetPolyCount();
assert(m_rtts != NULL);
irr_driver->getSceneManager()->setActiveCamera(camera);

11
src/utils/profiler.cpp
View File

@ -41,22 +41,17 @@ static const char* GPU_Phase[Q_LAST] =
"Shadows Cascade 1",
"Shadows Cascade 2",
"Shadows Cascade 3",
"Shadows Postprocess",
"Solid Pass 1",
"RSM",
"RH",
"GI",
"Solid Pass",
"Env Map",
"SunLight",
"PointLights",
"SSAO",
"Solid Pass 2",
"Fog",
"Skybox",
"Glow",
"Combine Diffuse Color",
"Skybox",
"Transparent",
"Particles",
"Displacement",
"Depth of Field",
"Godrays",
"Bloom",

11
src/utils/profiler.hpp
View File

@ -39,22 +39,17 @@ enum QueryPerf
Q_SHADOWS_CASCADE1,
Q_SHADOWS_CASCADE2,
Q_SHADOWS_CASCADE3,
Q_SHADOW_POSTPROCESS,
Q_SOLID_PASS1,
Q_RSM,
Q_RH,
Q_GI,
Q_SOLID_PASS,
Q_ENVMAP,
Q_SUN,
Q_POINTLIGHTS,
Q_SSAO,
Q_SOLID_PASS2,
Q_FOG,
Q_SKYBOX,
Q_GLOW,
Q_COMBINE_DIFFUSE_COLOR,
Q_SKYBOX,
Q_TRANSPARENT,
Q_PARTICLES,
Q_DISPLACEMENT,
Q_DOF,
Q_GODRAYS,
Q_BLOOM,