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

Partially replaced singleton SolidPassCmd by DrawCalls class

Browse Source
This commit is contained in:
Elderme 2015-11-07 15:01:00 +01:00
parent 331cc0827f
commit 928dd8d24d
7 changed files with 83 additions and 102 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/graphics/command_buffer.cpp
View File

@ -88,7 +88,7 @@ void CommandBuffer::fillMaterial(int material_id,
std::vector<GLMesh *> &instanced_list, std::vector<GLMesh *> &instanced_list,
T *instance_buffer) T *instance_buffer)
{ {
m_offset[material_id] = m_instance_buffer_offset; m_offset[material_id] = m_command_buffer_offset;
FillInstances<T>(mesh_map[material_id], FillInstances<T>(mesh_map[material_id],
instanced_list, instanced_list,
instance_buffer, instance_buffer,

3
src/graphics/command_buffer.hpp
View File

@ -127,6 +127,9 @@ public:
inline size_t getPolyCount() const {return m_poly_count;} inline size_t getPolyCount() const {return m_poly_count;}
inline bool isEmpty(Material::ShaderType shader_type) const
{ return m_size[static_cast<int>(shader_type)] == 0;}
inline void bind() const inline void bind() const
{ {
glBindBuffer(GL_DRAW_INDIRECT_BUFFER, m_draw_indirect_cmd_id); glBindBuffer(GL_DRAW_INDIRECT_BUFFER, m_draw_indirect_cmd_id);

2
src/graphics/draw_calls.hpp
View File

@ -98,6 +98,8 @@ public:
void renderParticlesList() const; void renderParticlesList() const;
inline void bindSolidCmd() const { m_solid_cmd_buffer.bind(); } inline void bindSolidCmd() const { m_solid_cmd_buffer.bind(); }
inline bool isSolidCmdEmpty(Material::ShaderType shader_type) const
{ return m_solid_cmd_buffer.isEmpty(shader_type); }
void drawIndirectSolidCmd(Material::ShaderType shader_type, int i) const; void drawIndirectSolidCmd(Material::ShaderType shader_type, int i) const;
void multidrawIndirectSolidCmd(Material::ShaderType shader_type) const; void multidrawIndirectSolidCmd(Material::ShaderType shader_type) const;
}; };

160
src/graphics/geometry_passes.cpp
View File

@ -981,7 +981,7 @@ using namespace RenderGeometry;
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
template<typename T, int ...List> template<typename T, int ...List>
void renderMeshes1stPass() void renderMeshes1stPass(const DrawCalls& draw_calls)
{ {
auto &meshes = T::List::getInstance()->SolidPass; auto &meshes = T::List::getInstance()->SolidPass;
T::FirstPassShader::getInstance()->use(); T::FirstPassShader::getInstance()->use();
@ -989,8 +989,6 @@ void renderMeshes1stPass()
glBindVertexArray(VAOManager::getInstance()->getVAO(T::VertexType)); glBindVertexArray(VAOManager::getInstance()->getVAO(T::VertexType));
for (unsigned i = 0; i < meshes.size(); i++) for (unsigned i = 0; i < meshes.size(); i++)
{ {
std::vector<GLuint> Textures;
std::vector<uint64_t> Handles;
GLMesh &mesh = *(STK::tuple_get<0>(meshes.at(i))); GLMesh &mesh = *(STK::tuple_get<0>(meshes.at(i)));
if (!CVS->isARBBaseInstanceUsable()) if (!CVS->isARBBaseInstanceUsable())
glBindVertexArray(mesh.vao); glBindVertexArray(mesh.vao);
@ -1012,14 +1010,13 @@ void renderMeshes1stPass()
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
template<typename T, typename...Args> template<typename T, typename...Args>
void renderInstancedMeshes1stPass(Args...args) void renderInstancedMeshes1stPass(const DrawCalls& draw_calls, Args...args)
{ {
std::vector<GLMesh *> &meshes = T::InstancedList::getInstance()->SolidPass; std::vector<GLMesh *> &meshes = T::InstancedList::getInstance()->SolidPass;
T::InstancedFirstPassShader::getInstance()->use(); T::InstancedFirstPassShader::getInstance()->use();
glBindVertexArray(VAOManager::getInstance()->getInstanceVAO(T::VertexType, T::Instance)); glBindVertexArray(VAOManager::getInstance()->getInstanceVAO(T::VertexType, T::Instance));
for (unsigned i = 0; i < meshes.size(); i++) for (unsigned i = 0; i < meshes.size(); i++)
{ {
std::vector<GLuint> Textures;
GLMesh *mesh = meshes[i]; GLMesh *mesh = meshes[i];
#ifdef DEBUG #ifdef DEBUG
if (mesh->VAOType != T::VertexType) if (mesh->VAOType != T::VertexType)
@ -1032,23 +1029,20 @@ void renderInstancedMeshes1stPass(Args...args)
TexExpander<typename T::InstancedFirstPassShader>::template expandTex(*mesh, T::FirstPassTextures); TexExpander<typename T::InstancedFirstPassShader>::template expandTex(*mesh, T::FirstPassTextures);
T::InstancedFirstPassShader::getInstance()->setUniforms(args...); T::InstancedFirstPassShader::getInstance()->setUniforms(args...);
glDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_SHORT, (const void*)((SolidPassCmd::getInstance()->Offset[T::MaterialType] + i) * sizeof(DrawElementsIndirectCommand))); draw_calls.drawIndirectSolidCmd(T::MaterialType, i);
} }
} // renderInstancedMeshes1stPass } // renderInstancedMeshes1stPass
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
template<typename T, typename...Args> template<typename T, typename...Args>
void multidraw1stPass(Args...args) void multidraw1stPass(const DrawCalls& draw_calls, Args...args)
{ {
T::InstancedFirstPassShader::getInstance()->use(); T::InstancedFirstPassShader::getInstance()->use();
glBindVertexArray(VAOManager::getInstance()->getInstanceVAO(T::VertexType, T::Instance)); glBindVertexArray(VAOManager::getInstance()->getInstanceVAO(T::VertexType, T::Instance));
if (SolidPassCmd::getInstance()->Size[T::MaterialType]) if (!draw_calls.isSolidCmdEmpty(T::MaterialType))
{ {
T::InstancedFirstPassShader::getInstance()->setUniforms(args...); T::InstancedFirstPassShader::getInstance()->setUniforms(args...);
glMultiDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_SHORT, draw_calls.multidrawIndirectSolidCmd(T::MaterialType);
(const void*)(SolidPassCmd::getInstance()->Offset[T::MaterialType] * sizeof(DrawElementsIndirectCommand)),
(int)SolidPassCmd::getInstance()->Size[T::MaterialType],
sizeof(DrawElementsIndirectCommand));
} }
} // multidraw1stPass } // multidraw1stPass
@ -1064,7 +1058,7 @@ void GeometryPasses::renderSolidFirstPass(const DrawCalls& draw_calls)
m_wind_dir = getWindDir(); //TODO: why this function instead of Wind::getWind()? m_wind_dir = getWindDir(); //TODO: why this function instead of Wind::getWind()?
if (CVS->supportsIndirectInstancingRendering()) if (CVS->supportsIndirectInstancingRendering())
glBindBuffer(GL_DRAW_INDIRECT_BUFFER, SolidPassCmd::getInstance()->drawindirectcmd); draw_calls.bindSolidCmd();
{ {
ScopedGPUTimer Timer(irr_driver->getGPUTimer(Q_SOLID_PASS1)); ScopedGPUTimer Timer(irr_driver->getGPUTimer(Q_SOLID_PASS1));
@ -1073,35 +1067,35 @@ void GeometryPasses::renderSolidFirstPass(const DrawCalls& draw_calls)
draw_calls.renderImmediateDrawList(); draw_calls.renderImmediateDrawList();
//TODO: is it useful if AZDO enabled? //TODO: is it useful if AZDO enabled?
renderMeshes1stPass<DefaultMaterial, 2, 1>(); renderMeshes1stPass<DefaultMaterial, 2, 1>(draw_calls);
renderMeshes1stPass<SplattingMat, 2, 1>(); renderMeshes1stPass<SplattingMat, 2, 1>(draw_calls);
renderMeshes1stPass<UnlitMat, 3, 2, 1>(); renderMeshes1stPass<UnlitMat, 3, 2, 1>(draw_calls);
renderMeshes1stPass<AlphaRef, 3, 2, 1>(); renderMeshes1stPass<AlphaRef, 3, 2, 1>(draw_calls);
renderMeshes1stPass<GrassMat, 3, 2, 1>(); renderMeshes1stPass<GrassMat, 3, 2, 1>(draw_calls);
renderMeshes1stPass<NormalMat, 2, 1>(); renderMeshes1stPass<NormalMat, 2, 1>(draw_calls);
renderMeshes1stPass<SphereMap, 2, 1>(); renderMeshes1stPass<SphereMap, 2, 1>(draw_calls);
renderMeshes1stPass<DetailMat, 2, 1>(); renderMeshes1stPass<DetailMat, 2, 1>(draw_calls);
if (CVS->isAZDOEnabled()) if (CVS->isAZDOEnabled())
{ {
multidraw1stPass<DefaultMaterial>(); multidraw1stPass<DefaultMaterial>(draw_calls);
multidraw1stPass<AlphaRef>(); multidraw1stPass<AlphaRef>(draw_calls);
multidraw1stPass<SphereMap>(); multidraw1stPass<SphereMap>(draw_calls);
multidraw1stPass<UnlitMat>(); multidraw1stPass<UnlitMat>(draw_calls);
multidraw1stPass<GrassMat>(m_wind_dir); multidraw1stPass<GrassMat>(draw_calls, m_wind_dir);
multidraw1stPass<NormalMat>(); multidraw1stPass<NormalMat>(draw_calls);
multidraw1stPass<DetailMat>(); multidraw1stPass<DetailMat>(draw_calls);
} }
else if (CVS->supportsIndirectInstancingRendering()) else if (CVS->supportsIndirectInstancingRendering())
{ {
renderInstancedMeshes1stPass<DefaultMaterial>(); renderInstancedMeshes1stPass<DefaultMaterial>(draw_calls);
renderInstancedMeshes1stPass<AlphaRef>(); renderInstancedMeshes1stPass<AlphaRef>(draw_calls);
renderInstancedMeshes1stPass<UnlitMat>(); renderInstancedMeshes1stPass<UnlitMat>(draw_calls);
renderInstancedMeshes1stPass<SphereMap>(); renderInstancedMeshes1stPass<SphereMap>(draw_calls);
renderInstancedMeshes1stPass<GrassMat>(m_wind_dir); renderInstancedMeshes1stPass<GrassMat>(draw_calls, m_wind_dir);
renderInstancedMeshes1stPass<DetailMat>(); renderInstancedMeshes1stPass<DetailMat>(draw_calls);
renderInstancedMeshes1stPass<NormalMat>(); renderInstancedMeshes1stPass<NormalMat>(draw_calls);
} }
} }
} // renderSolidFirstPass } // renderSolidFirstPass
@ -1147,7 +1141,7 @@ void renderMeshes2ndPass( const std::vector<uint64_t> &Prefilled_Handle,
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
template<typename T, typename...Args> template<typename T, typename...Args>
void renderInstancedMeshes2ndPass(const std::vector<GLuint> &Prefilled_tex, Args...args) void renderInstancedMeshes2ndPass(const DrawCalls& draw_calls, const std::vector<GLuint> &Prefilled_tex, Args...args)
{ {
std::vector<GLMesh *> &meshes = T::InstancedList::getInstance()->SolidPass; std::vector<GLMesh *> &meshes = T::InstancedList::getInstance()->SolidPass;
T::InstancedSecondPassShader::getInstance()->use(); T::InstancedSecondPassShader::getInstance()->use();
@ -1160,31 +1154,25 @@ void renderInstancedMeshes2ndPass(const std::vector<GLuint> &Prefilled_tex, Args
expandTex(*mesh, T::SecondPassTextures, Prefilled_tex[0], expandTex(*mesh, T::SecondPassTextures, Prefilled_tex[0],
Prefilled_tex[1], Prefilled_tex[2]); Prefilled_tex[1], Prefilled_tex[2]);
T::InstancedSecondPassShader::getInstance()->setUniforms(args...); T::InstancedSecondPassShader::getInstance()->setUniforms(args...);
glDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_SHORT, draw_calls.drawIndirectSolidCmd(T::MaterialType, i);
(const void*)((SolidPassCmd::getInstance()->Offset[T::MaterialType] + i)
* sizeof(DrawElementsIndirectCommand)));
} }
} // renderInstancedMeshes2ndPass } // renderInstancedMeshes2ndPass
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
template<typename T, typename...Args> template<typename T, typename...Args>
void multidraw2ndPass(const std::vector<uint64_t> &Handles, Args... args) void multidraw2ndPass(const DrawCalls& draw_calls, const std::vector<uint64_t> &Handles, Args... args)
{ {
T::InstancedSecondPassShader::getInstance()->use(); T::InstancedSecondPassShader::getInstance()->use();
glBindVertexArray(VAOManager::getInstance()->getInstanceVAO(T::VertexType, glBindVertexArray(VAOManager::getInstance()->getInstanceVAO(T::VertexType,
T::Instance)); T::Instance));
uint64_t nulltex[10] = {}; uint64_t nulltex[10] = {};
if (SolidPassCmd::getInstance()->Size[T::MaterialType]) if (!draw_calls.isSolidCmdEmpty(T::MaterialType))
{ {
HandleExpander<typename T::InstancedSecondPassShader>::template HandleExpander<typename T::InstancedSecondPassShader>::template
expand(nulltex, T::SecondPassTextures, Handles[0], Handles[1], expand(nulltex, T::SecondPassTextures, Handles[0], Handles[1],
Handles[2]); Handles[2]);
T::InstancedSecondPassShader::getInstance()->setUniforms(args...); T::InstancedSecondPassShader::getInstance()->setUniforms(args...);
glMultiDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_SHORT, draw_calls.multidrawIndirectSolidCmd(T::MaterialType);
(const void*)(SolidPassCmd::getInstance()->Offset[T::MaterialType]
* sizeof(DrawElementsIndirectCommand)),
(int)SolidPassCmd::getInstance()->Size[T::MaterialType],
(int)sizeof(DrawElementsIndirectCommand));
} }
} // multidraw2ndPass } // multidraw2ndPass
@ -1225,8 +1213,7 @@ void GeometryPasses::renderSolidSecondPass( const DrawCalls& draw_calls,
} }
if (CVS->supportsIndirectInstancingRendering()) if (CVS->supportsIndirectInstancingRendering())
glBindBuffer(GL_DRAW_INDIRECT_BUFFER, draw_calls.bindSolidCmd();
SolidPassCmd::getInstance()->drawindirectcmd);
{ {
ScopedGPUTimer Timer(irr_driver->getGPUTimer(Q_SOLID_PASS2)); ScopedGPUTimer Timer(irr_driver->getGPUTimer(Q_SOLID_PASS2));
@ -1252,12 +1239,12 @@ void GeometryPasses::renderSolidSecondPass( const DrawCalls& draw_calls,
if (CVS->isAZDOEnabled()) if (CVS->isAZDOEnabled())
{ {
multidraw2ndPass<DefaultMaterial>(createVector<uint64_t>(DiffuseHandle, SpecularHandle, SSAOHandle, 0, 0)); multidraw2ndPass<DefaultMaterial>(draw_calls, createVector<uint64_t>(DiffuseHandle, SpecularHandle, SSAOHandle, 0, 0));
multidraw2ndPass<AlphaRef>(createVector<uint64_t>(DiffuseHandle, SpecularHandle, SSAOHandle, 0, 0)); multidraw2ndPass<AlphaRef>(draw_calls, createVector<uint64_t>(DiffuseHandle, SpecularHandle, SSAOHandle, 0, 0));
multidraw2ndPass<SphereMap>(createVector<uint64_t>(DiffuseHandle, SpecularHandle, SSAOHandle, 0)); multidraw2ndPass<SphereMap>(draw_calls, createVector<uint64_t>(DiffuseHandle, SpecularHandle, SSAOHandle, 0));
multidraw2ndPass<UnlitMat>(createVector<uint64_t>(DiffuseHandle, SpecularHandle, SSAOHandle, 0)); multidraw2ndPass<UnlitMat>(draw_calls, createVector<uint64_t>(DiffuseHandle, SpecularHandle, SSAOHandle, 0));
multidraw2ndPass<NormalMat>(createVector<uint64_t>(DiffuseHandle, SpecularHandle, SSAOHandle, 0, 0)); multidraw2ndPass<NormalMat>(draw_calls, createVector<uint64_t>(DiffuseHandle, SpecularHandle, SSAOHandle, 0, 0));
multidraw2ndPass<DetailMat>(createVector<uint64_t>(DiffuseHandle, SpecularHandle, SSAOHandle, 0, 0, 0)); multidraw2ndPass<DetailMat>(draw_calls, createVector<uint64_t>(DiffuseHandle, SpecularHandle, SSAOHandle, 0, 0, 0));
// template does not work with template due to extra depth texture // template does not work with template due to extra depth texture
{ {
@ -1265,29 +1252,25 @@ void GeometryPasses::renderSolidSecondPass( const DrawCalls& draw_calls,
glBindVertexArray(VAOManager::getInstance()->getInstanceVAO(GrassMat::VertexType, glBindVertexArray(VAOManager::getInstance()->getInstanceVAO(GrassMat::VertexType,
GrassMat::Instance)); GrassMat::Instance));
uint64_t nulltex[10] = {}; uint64_t nulltex[10] = {};
if (SolidPassCmd::getInstance()->Size[GrassMat::MaterialType]) if (!draw_calls.isSolidCmdEmpty(GrassMat::MaterialType))
{ {
HandleExpander<GrassMat::InstancedSecondPassShader> HandleExpander<GrassMat::InstancedSecondPassShader>
::expand(nulltex, GrassMat::SecondPassTextures, DiffuseHandle, ::expand(nulltex, GrassMat::SecondPassTextures, DiffuseHandle,
SpecularHandle, SSAOHandle, DepthHandle); SpecularHandle, SSAOHandle, DepthHandle);
GrassMat::InstancedSecondPassShader::getInstance()->setUniforms(m_wind_dir, GrassMat::InstancedSecondPassShader::getInstance()->setUniforms(m_wind_dir,
irr_driver->getSunDirection()); irr_driver->getSunDirection());
glMultiDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_SHORT, draw_calls.multidrawIndirectSolidCmd(GrassMat::MaterialType);
(const void*)(SolidPassCmd::getInstance()->Offset[GrassMat::MaterialType]
* sizeof(DrawElementsIndirectCommand)),
(int)SolidPassCmd::getInstance()->Size[GrassMat::MaterialType],
(int)sizeof(DrawElementsIndirectCommand));
} }
} }
} }
else if (CVS->supportsIndirectInstancingRendering()) else if (CVS->supportsIndirectInstancingRendering())
{ {
renderInstancedMeshes2ndPass<DefaultMaterial>(DiffSpecSSAOTex); renderInstancedMeshes2ndPass<DefaultMaterial>(draw_calls, DiffSpecSSAOTex);
renderInstancedMeshes2ndPass<AlphaRef>(DiffSpecSSAOTex); renderInstancedMeshes2ndPass<AlphaRef>(draw_calls, DiffSpecSSAOTex);
renderInstancedMeshes2ndPass<UnlitMat>(DiffSpecSSAOTex); renderInstancedMeshes2ndPass<UnlitMat>(draw_calls, DiffSpecSSAOTex);
renderInstancedMeshes2ndPass<SphereMap>(DiffSpecSSAOTex); renderInstancedMeshes2ndPass<SphereMap>(draw_calls, DiffSpecSSAOTex);
renderInstancedMeshes2ndPass<DetailMat>(DiffSpecSSAOTex); renderInstancedMeshes2ndPass<DetailMat>(draw_calls, DiffSpecSSAOTex);
renderInstancedMeshes2ndPass<NormalMat>(DiffSpecSSAOTex); renderInstancedMeshes2ndPass<NormalMat>(draw_calls, DiffSpecSSAOTex);
// template does not work with template due to extra depth texture // template does not work with template due to extra depth texture
{ {
@ -1304,9 +1287,7 @@ void GeometryPasses::renderSolidSecondPass( const DrawCalls& draw_calls,
irr_driver->getDepthStencilTexture()); irr_driver->getDepthStencilTexture());
GrassMat::InstancedSecondPassShader::getInstance() GrassMat::InstancedSecondPassShader::getInstance()
->setUniforms(m_wind_dir, irr_driver->getSunDirection()); ->setUniforms(m_wind_dir, irr_driver->getSunDirection());
glDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_SHORT, draw_calls.drawIndirectSolidCmd(GrassMat::MaterialType, i);
(const void*)((SolidPassCmd::getInstance()->Offset[GrassMat::MaterialType] + i)
* sizeof(DrawElementsIndirectCommand)));
} }
} }
} }
@ -1315,7 +1296,7 @@ void GeometryPasses::renderSolidSecondPass( const DrawCalls& draw_calls,
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
template<typename T> template<typename T>
static void renderInstancedMeshNormals() static void renderInstancedMeshNormals(const DrawCalls& draw_calls)
{ {
std::vector<GLMesh *> &meshes = T::InstancedList::getInstance()->SolidPass; std::vector<GLMesh *> &meshes = T::InstancedList::getInstance()->SolidPass;
NormalVisualizer::getInstance()->use(); NormalVisualizer::getInstance()->use();
@ -1323,47 +1304,42 @@ static void renderInstancedMeshNormals()
for (unsigned i = 0; i < meshes.size(); i++) for (unsigned i = 0; i < meshes.size(); i++)
{ {
NormalVisualizer::getInstance()->setUniforms(video::SColor(255, 0, 255, 0)); NormalVisualizer::getInstance()->setUniforms(video::SColor(255, 0, 255, 0));
glDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_SHORT, draw_calls.drawIndirectSolidCmd(T::MaterialType, i);
(const void*)((SolidPassCmd::getInstance()->Offset[T::MaterialType] + i)
* sizeof(DrawElementsIndirectCommand)));
} }
} // renderInstancedMeshNormals } // renderInstancedMeshNormals
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
template<typename T> template<typename T>
static void renderMultiMeshNormals() static void renderMultiMeshNormals(const DrawCalls& draw_calls)
{ {
NormalVisualizer::getInstance()->use(); NormalVisualizer::getInstance()->use();
glBindVertexArray(VAOManager::getInstance()->getInstanceVAO(T::VertexType, T::Instance)); glBindVertexArray(VAOManager::getInstance()->getInstanceVAO(T::VertexType, T::Instance));
if (SolidPassCmd::getInstance()->Size[T::MaterialType]) if (!draw_calls.isSolidCmdEmpty(T::MaterialType))
{ {
NormalVisualizer::getInstance()->setUniforms(video::SColor(255, 0, 255, 0)); NormalVisualizer::getInstance()->setUniforms(video::SColor(255, 0, 255, 0));
glMultiDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_SHORT, draw_calls.multidrawIndirectSolidCmd(T::MaterialType);
(const void*)(SolidPassCmd::getInstance()->Offset[T::MaterialType] * sizeof(DrawElementsIndirectCommand)),
(int)SolidPassCmd::getInstance()->Size[T::MaterialType],
(int)sizeof(DrawElementsIndirectCommand));
} }
} // renderMultiMeshNormals } // renderMultiMeshNormals
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
void GeometryPasses::renderNormalsVisualisation() void GeometryPasses::renderNormalsVisualisation(const DrawCalls& draw_calls)
{ {
if (CVS->isAZDOEnabled()) { if (CVS->isAZDOEnabled()) {
renderMultiMeshNormals<DefaultMaterial>(); renderMultiMeshNormals<DefaultMaterial>(draw_calls);
renderMultiMeshNormals<AlphaRef>(); renderMultiMeshNormals<AlphaRef>(draw_calls);
renderMultiMeshNormals<UnlitMat>(); renderMultiMeshNormals<UnlitMat>(draw_calls);
renderMultiMeshNormals<SphereMap>(); renderMultiMeshNormals<SphereMap>(draw_calls);
renderMultiMeshNormals<DetailMat>(); renderMultiMeshNormals<DetailMat>(draw_calls);
renderMultiMeshNormals<NormalMat>(); renderMultiMeshNormals<NormalMat>(draw_calls);
} }
else if (CVS->supportsIndirectInstancingRendering()) else if (CVS->supportsIndirectInstancingRendering())
{ {
renderInstancedMeshNormals<DefaultMaterial>(); renderInstancedMeshNormals<DefaultMaterial>(draw_calls);
renderInstancedMeshNormals<AlphaRef>(); renderInstancedMeshNormals<AlphaRef>(draw_calls);
renderInstancedMeshNormals<UnlitMat>(); renderInstancedMeshNormals<UnlitMat>(draw_calls);
renderInstancedMeshNormals<SphereMap>(); renderInstancedMeshNormals<SphereMap>(draw_calls);
renderInstancedMeshNormals<DetailMat>(); renderInstancedMeshNormals<DetailMat>(draw_calls);
renderInstancedMeshNormals<NormalMat>(); renderInstancedMeshNormals<NormalMat>(draw_calls);
} }
} // renderNormalsVisualisation } // renderNormalsVisualisation

2
src/graphics/geometry_passes.hpp
View File

@ -39,7 +39,7 @@ public:
unsigned render_target_diffuse, unsigned render_target_diffuse,
unsigned render_target_specular, unsigned render_target_specular,
unsigned render_target_half_red); unsigned render_target_half_red);
void renderNormalsVisualisation(); void renderNormalsVisualisation(const DrawCalls& draw_calls);
void renderTransparent(const DrawCalls& draw_calls, void renderTransparent(const DrawCalls& draw_calls,
unsigned render_target); unsigned render_target);
void renderShadows(const ShadowMatrices& shadow_matrices, void renderShadows(const ShadowMatrices& shadow_matrices,

10
src/graphics/shader_based_renderer.cpp
View File

@ -289,7 +289,7 @@ void ShaderBasedRenderer::renderScene(scene::ICameraSceneNode * const camnode,
if (irr_driver->getNormals()) if (irr_driver->getNormals())
{ {
rtts->getFBO(FBO_NORMAL_AND_DEPTHS).bind(); rtts->getFBO(FBO_NORMAL_AND_DEPTHS).bind();
m_geometry_passes.renderNormalsVisualisation(); m_geometry_passes.renderNormalsVisualisation(m_draw_calls);
rtts->getFBO(FBO_COLORS).bind(); rtts->getFBO(FBO_COLORS).bind();
} }
@ -388,7 +388,7 @@ void ShaderBasedRenderer::renderParticles()
glDisable(GL_CULL_FACE); glDisable(GL_CULL_FACE);
glEnable(GL_BLEND); glEnable(GL_BLEND);
glBlendEquation(GL_FUNC_ADD); glBlendEquation(GL_FUNC_ADD);
m_draw_calls.renderBillboardList(); m_draw_calls.renderParticlesList();
// m_scene_manager->drawAll(scene::ESNRP_TRANSPARENT_EFFECT); // m_scene_manager->drawAll(scene::ESNRP_TRANSPARENT_EFFECT);
} }
@ -491,17 +491,17 @@ void ShaderBasedRenderer::renderPostProcessing(Camera * const camera)
ShaderBasedRenderer::ShaderBasedRenderer() ShaderBasedRenderer::ShaderBasedRenderer()
{ {
/*if (CVS->isAZDOEnabled()) if (CVS->isAZDOEnabled())
m_solid_first_pass = new AZDOSolidFirstPass(); m_solid_first_pass = new AZDOSolidFirstPass();
else if (CVS->supportsIndirectInstancingRendering()) else if (CVS->supportsIndirectInstancingRendering())
m_solid_first_pass = new IndirectInstancedSolidFirstPass(); m_solid_first_pass = new IndirectInstancedSolidFirstPass();
else else
m_solid_first_pass = new GL3SolidFirstPass();*/ m_solid_first_pass = new GL3SolidFirstPass();
} }
ShaderBasedRenderer::~ShaderBasedRenderer() ShaderBasedRenderer::~ShaderBasedRenderer()
{ {
//delete m_solid_first_pass; delete m_solid_first_pass;
} }
void ShaderBasedRenderer::addSunLight(const core::vector3df &pos) { void ShaderBasedRenderer::addSunLight(const core::vector3df &pos) {

2
src/graphics/shader_based_renderer.hpp
View File

@ -37,7 +37,7 @@ private:
ShadowMatrices m_shadow_matrices; ShadowMatrices m_shadow_matrices;
irr::core::vector3df m_wind_dir; irr::core::vector3df m_wind_dir;
//SolidFirstPass *m_solid_first_pass; SolidFirstPass *m_solid_first_pass;
void compressPowerUpTextures(); void compressPowerUpTextures();
void setOverrideMaterial(); void setOverrideMaterial();