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

Removed useless things in CommandBuffer and GeometryPasses classes, and removed ShadowPassCmd singleton class

Browse Source
This commit is contained in:
Elderme 2015-11-19 14:16:59 +01:00
parent e36ba066fb
commit c0ca591827
7 changed files with 254 additions and 315 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

94
src/graphics/command_buffer.cpp
View File

@ -20,46 +20,55 @@
#include "utils/cpp2011.hpp" #include "utils/cpp2011.hpp"
template<> template<>
void InstanceFiller<InstanceDataSingleTex>::add(GLMesh *mesh, scene::ISceneNode *node, InstanceDataSingleTex &instance) void InstanceFiller<InstanceDataSingleTex>::add(GLMesh *mesh, scene::ISceneNode *node, InstanceDataSingleTex &instance)
{ {
fillOriginOrientationScale<InstanceDataSingleTex>(node, instance); fillOriginOrientationScale<InstanceDataSingleTex>(node, instance);
instance.Texture = mesh->TextureHandles[0]; instance.Texture = mesh->TextureHandles[0];
} }
template<> template<>
void InstanceFiller<InstanceDataDualTex>::add(GLMesh *mesh, scene::ISceneNode *node, InstanceDataDualTex &instance) void InstanceFiller<InstanceDataDualTex>::add(GLMesh *mesh, scene::ISceneNode *node, InstanceDataDualTex &instance)
{ {
fillOriginOrientationScale<InstanceDataDualTex>(node, instance); fillOriginOrientationScale<InstanceDataDualTex>(node, instance);
instance.Texture = mesh->TextureHandles[0]; instance.Texture = mesh->TextureHandles[0];
instance.SecondTexture = mesh->TextureHandles[1]; instance.SecondTexture = mesh->TextureHandles[1];
} }
template<> template<>
void InstanceFiller<InstanceDataThreeTex>::add(GLMesh *mesh, scene::ISceneNode *node, InstanceDataThreeTex &instance) void InstanceFiller<InstanceDataThreeTex>::add(GLMesh *mesh, scene::ISceneNode *node, InstanceDataThreeTex &instance)
{ {
fillOriginOrientationScale<InstanceDataThreeTex>(node, instance); fillOriginOrientationScale<InstanceDataThreeTex>(node, instance);
instance.Texture = mesh->TextureHandles[0]; instance.Texture = mesh->TextureHandles[0];
instance.SecondTexture = mesh->TextureHandles[1]; instance.SecondTexture = mesh->TextureHandles[1];
instance.ThirdTexture = mesh->TextureHandles[2]; instance.ThirdTexture = mesh->TextureHandles[2];
} }
template<> template<>
void InstanceFiller<GlowInstanceData>::add(GLMesh *mesh, scene::ISceneNode *node, GlowInstanceData &instance) void InstanceFiller<GlowInstanceData>::add(GLMesh *mesh, scene::ISceneNode *node, GlowInstanceData &instance)
{ {
fillOriginOrientationScale<GlowInstanceData>(node, instance); fillOriginOrientationScale<GlowInstanceData>(node, instance);
STKMeshSceneNode *nd = dynamic_cast<STKMeshSceneNode*>(node); STKMeshSceneNode *nd = dynamic_cast<STKMeshSceneNode*>(node);
instance.Color = nd->getGlowColor().color; instance.Color = nd->getGlowColor().color;
} }
template<> template<>
void expandTexSecondPass<GrassMat>(const GLMesh &mesh, void expandTexSecondPass<GrassMat>(const GLMesh &mesh,
const std::vector<GLuint> &prefilled_tex) const std::vector<GLuint> &prefilled_tex)
{ {
TexExpander<typename GrassMat::InstancedSecondPassShader>::template TexExpander<typename GrassMat::InstancedSecondPassShader>::template
expandTex(mesh, GrassMat::SecondPassTextures, prefilled_tex[0], expandTex(mesh, GrassMat::SecondPassTextures, prefilled_tex[0],
prefilled_tex[1], prefilled_tex[2], prefilled_tex[3]); prefilled_tex[1], prefilled_tex[2], prefilled_tex[3]);
} }
template<>
void expandHandlesSecondPass<GrassMat>(const std::vector<uint64_t> &handles)
{
uint64_t nulltex[10] = {};
HandleExpander<GrassMat::InstancedSecondPassShader>::template
expand(nulltex, GrassMat::SecondPassTextures,
handles[0], handles[1], handles[2], handles[3]);
}
template<int N> template<int N>
@ -152,19 +161,11 @@ ShadowCommandBuffer::ShadowCommandBuffer(): CommandBuffer()
{ {
} }
//void ShadowCommandBuffer::fill(std::array<MeshMap,Material::SHADERTYPE_COUNT> mesh_map)
void ShadowCommandBuffer::fill(MeshMap *mesh_map) void ShadowCommandBuffer::fill(MeshMap *mesh_map)
{ {
clearMeshes(); clearMeshes();
std::vector<int> shadow_tex_material_list; std::vector<int> shadow_tex_material_list;
/* createVector<Material::ShaderType>(Material::SHADERTYPE_SOLID,
Material::SHADERTYPE_ALPHA_TEST,
Material::SHADERTYPE_SOLID_UNLIT,
Material::SHADERTYPE_NORMAL_MAP,
Material::SHADERTYPE_SPHERE_MAP,
Material::SHADERTYPE_DETAIL_MAP,
Material::SHADERTYPE_VEGETATION);*/
for(int cascade=0; cascade<4; cascade++) for(int cascade=0; cascade<4; cascade++)
{ {
shadow_tex_material_list.push_back(cascade * Material::SHADERTYPE_COUNT shadow_tex_material_list.push_back(cascade * Material::SHADERTYPE_COUNT
@ -184,7 +185,6 @@ void ShadowCommandBuffer::fill(MeshMap *mesh_map)
} }
fillInstanceData<InstanceDataSingleTex>(mesh_map, shadow_tex_material_list, InstanceTypeShadow); fillInstanceData<InstanceDataSingleTex>(mesh_map, shadow_tex_material_list, InstanceTypeShadow);
//fillInstanceData<InstanceDataSingleTex>(mesh_map.data(), shadow_tex_material_list, InstanceTypeShadow);
unmapBuffers(); unmapBuffers();
@ -243,9 +243,7 @@ void GlowCommandBuffer::fill(MeshMap *mesh_map)
GL_MAP_WRITE_BIT | GL_MAP_UNSYNCHRONIZED_BIT | GL_MAP_INVALIDATE_BUFFER_BIT); GL_MAP_WRITE_BIT | GL_MAP_UNSYNCHRONIZED_BIT | GL_MAP_INVALIDATE_BUFFER_BIT);
} }
fillMaterial( 0, fillMaterial( 0, mesh_map, glow_instance_buffer);
mesh_map,
glow_instance_buffer);
unmapBuffers(); unmapBuffers();
} //GlowCommandBuffer::fill } //GlowCommandBuffer::fill

141
src/graphics/command_buffer.hpp
View File

@ -120,6 +120,20 @@ template<>
void expandTexSecondPass<GrassMat>(const GLMesh &mesh, void expandTexSecondPass<GrassMat>(const GLMesh &mesh,
const std::vector<GLuint> &prefilled_tex); const std::vector<GLuint> &prefilled_tex);
template<typename T>
void expandHandlesSecondPass(const std::vector<uint64_t> &handles)
{
uint64_t nulltex[10] = {};
HandleExpander<typename T::InstancedSecondPassShader>::template
expand(nulltex, T::SecondPassTextures,
handles[0], handles[1], handles[2]);
}
template<>
void expandHandlesSecondPass<GrassMat>(const std::vector<uint64_t> &handles);
template<int N> template<int N>
class CommandBuffer class CommandBuffer
{ {
@ -207,41 +221,13 @@ 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);
} }
/** Draw the i-th mesh with the specified material
* (require at least OpenGL 4.0
* or GL_ARB_base_instance and GL_ARB_draw_indirect extensions)
*/
inline void drawIndirect(int material_id, int i) const
{
glDrawElementsIndirect(GL_TRIANGLES,
GL_UNSIGNED_SHORT,
(const void*)((m_offset[material_id] + i) * sizeof(DrawElementsIndirectCommand)));
}
/** Draw the meshes with the specified material
* (require at least OpenGL 4.3 or AZDO extensions)
*/
inline void multidrawIndirect(int material_id) const
{
glMultiDrawElementsIndirect(GL_TRIANGLES,
GL_UNSIGNED_SHORT,
(const void*)(m_offset[material_id] * sizeof(DrawElementsIndirectCommand)),
(int) m_size[material_id],
sizeof(DrawElementsIndirectCommand));
}
}; };
class SolidCommandBuffer: public CommandBuffer<static_cast<int>(Material::SHADERTYPE_COUNT)> class SolidCommandBuffer: public CommandBuffer<static_cast<int>(Material::SHADERTYPE_COUNT)>
{ {
public: public:
@ -278,6 +264,24 @@ public:
} //drawIndirectFirstPass } //drawIndirectFirstPass
// ----------------------------------------------------------------------------
template<typename T, typename...Uniforms>
void multidrawFirstPass(Uniforms...uniforms) const
{
T::InstancedFirstPassShader::getInstance()->use();
T::InstancedFirstPassShader::getInstance()->setUniforms(uniforms...);
glBindVertexArray(VAOManager::getInstance()->getInstanceVAO(T::VertexType,
T::Instance));
if (m_size[T::MaterialType])
{
glMultiDrawElementsIndirect(GL_TRIANGLES,
GL_UNSIGNED_SHORT,
(const void*)(m_offset[T::MaterialType] * sizeof(DrawElementsIndirectCommand)),
(int) m_size[T::MaterialType],
sizeof(DrawElementsIndirectCommand));
}
} // multidrawFirstPass
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
template<typename T, typename...Uniforms> template<typename T, typename...Uniforms>
@ -299,6 +303,62 @@ public:
} }
} //drawIndirectSecondPass } //drawIndirectSecondPass
// ----------------------------------------------------------------------------
template<typename T, typename...Uniforms>
void multidraw2ndPass(const std::vector<uint64_t> &handles,
Uniforms... uniforms) const
{
T::InstancedSecondPassShader::getInstance()->use();
T::InstancedSecondPassShader::getInstance()->setUniforms(uniforms...);
glBindVertexArray(VAOManager::getInstance()->getInstanceVAO(T::VertexType,
T::Instance));
if (m_size[T::MaterialType])
{
expandHandlesSecondPass<T>(handles);
glMultiDrawElementsIndirect(GL_TRIANGLES,
GL_UNSIGNED_SHORT,
(const void*)(m_offset[T::MaterialType] * sizeof(DrawElementsIndirectCommand)),
(int) m_size[T::MaterialType],
sizeof(DrawElementsIndirectCommand));
}
} // multidraw2ndPass
// ----------------------------------------------------------------------------
template<typename T>
void drawIndirectNormals() const
{
NormalVisualizer::getInstance()->use();
NormalVisualizer::getInstance()->setUniforms(video::SColor(255, 0, 255, 0));
glBindVertexArray(VAOManager::getInstance()->getInstanceVAO(T::VertexType,
T::Instance));
for (unsigned i = 0; i < m_meshes[T::MaterialType].size(); i++)
{
glDrawElementsIndirect(GL_TRIANGLES,
GL_UNSIGNED_SHORT,
(const void*)((m_offset[T::MaterialType] + i) * sizeof(DrawElementsIndirectCommand))); }
} // drawIndirectNormals
// ----------------------------------------------------------------------------
template<typename T>
void multidrawNormals() const
{
NormalVisualizer::getInstance()->use();
NormalVisualizer::getInstance()->setUniforms(video::SColor(255, 0, 255, 0));
glBindVertexArray(VAOManager::getInstance()->getInstanceVAO(T::VertexType,
T::Instance));
if (m_size[T::MaterialType])
{
glMultiDrawElementsIndirect(GL_TRIANGLES,
GL_UNSIGNED_SHORT,
(const void*)(m_offset[T::MaterialType] * sizeof(DrawElementsIndirectCommand)),
(int) m_size[T::MaterialType],
sizeof(DrawElementsIndirectCommand));
}
} // multidrawNormals
}; };
class ShadowCommandBuffer: public CommandBuffer<4*static_cast<int>(Material::SHADERTYPE_COUNT)> class ShadowCommandBuffer: public CommandBuffer<4*static_cast<int>(Material::SHADERTYPE_COUNT)>
@ -330,7 +390,30 @@ public:
(const void*)((m_offset[material_id] + i) (const void*)((m_offset[material_id] + i)
* sizeof(DrawElementsIndirectCommand))); * sizeof(DrawElementsIndirectCommand)));
} // for i } // for i
} // renderInstancedShadow } // drawIndirect
// ----------------------------------------------------------------------------
template<typename T, typename...Uniforms>
void multidrawShadow(Uniforms ...uniforms, unsigned cascade) const
{
T::InstancedShadowPassShader::getInstance()->use();
T::InstancedShadowPassShader::getInstance()->setUniforms(uniforms..., cascade);
glBindVertexArray(VAOManager::getInstance()->getInstanceVAO(T::VertexType,
InstanceTypeShadow));
int material_id = T::MaterialType + cascade * Material::SHADERTYPE_COUNT;
if (m_size[material_id])
{
glMultiDrawElementsIndirect(GL_TRIANGLES,
GL_UNSIGNED_SHORT,
(const void*)(m_offset[material_id] * sizeof(DrawElementsIndirectCommand)),
(int) m_size[material_id],
sizeof(DrawElementsIndirectCommand));
}
} // multidrawShadow
}; };
class ReflectiveShadowMapCommandBuffer: public CommandBuffer<static_cast<int>(Material::SHADERTYPE_COUNT)> class ReflectiveShadowMapCommandBuffer: public CommandBuffer<static_cast<int>(Material::SHADERTYPE_COUNT)>

120
src/graphics/draw_calls.cpp
View File

@ -66,31 +66,6 @@ void DrawCalls::clearLists()
ListInstancedGlow::getInstance()->clear(); ListInstancedGlow::getInstance()->clear();
} }
//TODO: rename (shadow pass only)
template<Material::ShaderType Mat, typename T>
void DrawCalls::genDrawCalls(unsigned cascade,
std::vector<GLMesh *> &InstancedList,
T *InstanceBuffer,
DrawElementsIndirectCommand *CommandBuffer,
size_t &InstanceBufferOffset,
size_t &CommandBufferOffset,
size_t &PolyCount)
{
if (CVS->supportsIndirectInstancingRendering())
ShadowPassCmd::getInstance()->Offset[cascade][Mat] = CommandBufferOffset; // Store command buffer offset
FillInstances<T>(m_shadow_pass_mesh[cascade * Material::SHADERTYPE_COUNT + Mat],
InstancedList,
InstanceBuffer,
CommandBuffer,
InstanceBufferOffset,
CommandBufferOffset,
PolyCount);
if (CVS->isAZDOEnabled())
ShadowPassCmd::getInstance()->Size[cascade][Mat] = CommandBufferOffset - ShadowPassCmd::getInstance()->Offset[cascade][Mat];
}
void DrawCalls::handleSTKCommon(scene::ISceneNode *Node, void DrawCalls::handleSTKCommon(scene::ISceneNode *Node,
std::vector<scene::ISceneNode *> *ImmediateDraw, std::vector<scene::ISceneNode *> *ImmediateDraw,
@ -504,7 +479,6 @@ void DrawCalls::prepareDrawCalls( ShadowMatrices& shadow_matrices, scene::ICamer
InstanceDataSingleTex *ShadowInstanceBuffer; InstanceDataSingleTex *ShadowInstanceBuffer;
InstanceDataSingleTex *RSMInstanceBuffer; InstanceDataSingleTex *RSMInstanceBuffer;
GlowInstanceData *GlowInstanceBuffer; GlowInstanceData *GlowInstanceBuffer;
DrawElementsIndirectCommand *ShadowCmdBuffer;
DrawElementsIndirectCommand *RSMCmdBuffer; DrawElementsIndirectCommand *RSMCmdBuffer;
DrawElementsIndirectCommand *GlowCmdBuffer; DrawElementsIndirectCommand *GlowCmdBuffer;
@ -515,7 +489,6 @@ void DrawCalls::prepareDrawCalls( ShadowMatrices& shadow_matrices, scene::ICamer
ShadowInstanceBuffer = (InstanceDataSingleTex*)VAOManager::getInstance()->getInstanceBufferPtr(InstanceTypeShadow); ShadowInstanceBuffer = (InstanceDataSingleTex*)VAOManager::getInstance()->getInstanceBufferPtr(InstanceTypeShadow);
RSMInstanceBuffer = (InstanceDataSingleTex*)VAOManager::getInstance()->getInstanceBufferPtr(InstanceTypeRSM); RSMInstanceBuffer = (InstanceDataSingleTex*)VAOManager::getInstance()->getInstanceBufferPtr(InstanceTypeRSM);
GlowInstanceBuffer = (GlowInstanceData*)VAOManager::getInstance()->getInstanceBufferPtr(InstanceTypeGlow); GlowInstanceBuffer = (GlowInstanceData*)VAOManager::getInstance()->getInstanceBufferPtr(InstanceTypeGlow);
ShadowCmdBuffer = ShadowPassCmd::getInstance()->Ptr;
GlowCmdBuffer = GlowPassCmd::getInstance()->Ptr; GlowCmdBuffer = GlowPassCmd::getInstance()->Ptr;
RSMCmdBuffer = RSMPassCmd::getInstance()->Ptr; RSMCmdBuffer = RSMPassCmd::getInstance()->Ptr;
enableOpenMP = 1; enableOpenMP = 1;
@ -615,24 +588,11 @@ void DrawCalls::renderParticlesList() const
particles->render(); particles->render();
} }
// ----------------------------------------------------------------------------
/** Draw the i-th mesh with the specified material for the solid pass /** Render the solid first pass (depth and normals)
* (require at least OpenGL 4.0 * Require at least OpenGL 4.0
* or GL_ARB_base_instance and GL_ARB_draw_indirect extensions) * or GL_ARB_base_instance and GL_ARB_draw_indirect extensions)
*/ */
void DrawCalls::drawIndirectSolidCmd(Material::ShaderType shader_type, int i) const
{
m_solid_cmd_buffer.drawIndirect(static_cast<int>(shader_type), i);
}
/** Draw the meshes with the specified material
* (require at least OpenGL 4.3 or AZDO extensions)
*/
void DrawCalls::multidrawIndirectSolidCmd(Material::ShaderType shader_type) const
{
m_solid_cmd_buffer.multidrawIndirect(static_cast<int>(shader_type));
}
void DrawCalls::drawIndirectSolidFirstPass() const void DrawCalls::drawIndirectSolidFirstPass() const
{ {
m_solid_cmd_buffer.drawIndirectFirstPass<DefaultMaterial>(); m_solid_cmd_buffer.drawIndirectFirstPass<DefaultMaterial>();
@ -644,10 +604,24 @@ void DrawCalls::drawIndirectSolidFirstPass() const
m_solid_cmd_buffer.drawIndirectFirstPass<NormalMat>(); m_solid_cmd_buffer.drawIndirectFirstPass<NormalMat>();
} }
// ----------------------------------------------------------------------------
/** Render the solid first pass (depth and normals)
* Require OpenGL AZDO extensions
*/
void DrawCalls::multidrawSolidFirstPass() const
{
m_solid_cmd_buffer.multidrawFirstPass<DefaultMaterial>();
m_solid_cmd_buffer.multidrawFirstPass<AlphaRef>();
m_solid_cmd_buffer.multidrawFirstPass<SphereMap>();
m_solid_cmd_buffer.multidrawFirstPass<UnlitMat>();
m_solid_cmd_buffer.multidrawFirstPass<GrassMat>(windDir);
m_solid_cmd_buffer.multidrawFirstPass<NormalMat>();
m_solid_cmd_buffer.multidrawFirstPass<DetailMat>();
}
// ----------------------------------------------------------------------------
void DrawCalls::drawIndirectSolidSecondPass(const std::vector<GLuint> &prefilled_tex) const void DrawCalls::drawIndirectSolidSecondPass(const std::vector<GLuint> &prefilled_tex) const
{ {
m_solid_cmd_buffer.drawIndirectSecondPass<DefaultMaterial>(prefilled_tex); m_solid_cmd_buffer.drawIndirectSecondPass<DefaultMaterial>(prefilled_tex);
m_solid_cmd_buffer.drawIndirectSecondPass<AlphaRef>(prefilled_tex); m_solid_cmd_buffer.drawIndirectSecondPass<AlphaRef>(prefilled_tex);
m_solid_cmd_buffer.drawIndirectSecondPass<UnlitMat>(prefilled_tex); m_solid_cmd_buffer.drawIndirectSecondPass<UnlitMat>(prefilled_tex);
@ -657,15 +631,41 @@ void DrawCalls::drawIndirectSolidSecondPass(const std::vector<GLuint> &prefilled
m_solid_cmd_buffer.drawIndirectSecondPass<NormalMat>(prefilled_tex); m_solid_cmd_buffer.drawIndirectSecondPass<NormalMat>(prefilled_tex);
} }
void DrawCalls::drawIndirectReflectiveShadowMaps(const core::matrix4 &rsm_matrix) const // ----------------------------------------------------------------------------
void DrawCalls::multidrawSolidSecondPass(const std::vector<uint64_t> &handles) const
{ {
m_reflective_shadow_map_cmd_buffer.drawIndirect<DefaultMaterial>(rsm_matrix); m_solid_cmd_buffer.multidraw2ndPass<DefaultMaterial>(handles);
m_reflective_shadow_map_cmd_buffer.drawIndirect<AlphaRef>(rsm_matrix); m_solid_cmd_buffer.multidraw2ndPass<AlphaRef>(handles);
m_reflective_shadow_map_cmd_buffer.drawIndirect<UnlitMat>(rsm_matrix); m_solid_cmd_buffer.multidraw2ndPass<SphereMap>(handles);
m_reflective_shadow_map_cmd_buffer.drawIndirect<NormalMat>(rsm_matrix); m_solid_cmd_buffer.multidraw2ndPass<UnlitMat>(handles);
m_reflective_shadow_map_cmd_buffer.drawIndirect<DetailMat>(rsm_matrix); m_solid_cmd_buffer.multidraw2ndPass<NormalMat>(handles);
m_solid_cmd_buffer.multidraw2ndPass<DetailMat>(handles);
m_solid_cmd_buffer.multidraw2ndPass<GrassMat>(handles, windDir, irr_driver->getSunDirection());
} }
// ----------------------------------------------------------------------------
void DrawCalls::drawIndirectNormals() const
{
m_solid_cmd_buffer.drawIndirectNormals<DefaultMaterial>();
m_solid_cmd_buffer.drawIndirectNormals<AlphaRef>();
m_solid_cmd_buffer.drawIndirectNormals<UnlitMat>();
m_solid_cmd_buffer.drawIndirectNormals<SphereMap>();
m_solid_cmd_buffer.drawIndirectNormals<DetailMat>();
m_solid_cmd_buffer.drawIndirectNormals<NormalMat>();
}
// ----------------------------------------------------------------------------
void DrawCalls::multidrawNormals() const
{
m_solid_cmd_buffer.multidrawNormals<DefaultMaterial>();
m_solid_cmd_buffer.multidrawNormals<AlphaRef>();
m_solid_cmd_buffer.multidrawNormals<UnlitMat>();
m_solid_cmd_buffer.multidrawNormals<SphereMap>();
m_solid_cmd_buffer.multidrawNormals<DetailMat>();
m_solid_cmd_buffer.multidrawNormals<NormalMat>();
}
// ----------------------------------------------------------------------------
void DrawCalls::drawIndirectShadows(unsigned cascade) const void DrawCalls::drawIndirectShadows(unsigned cascade) const
{ {
m_shadow_cmd_buffer.drawIndirect<DefaultMaterial>(cascade); m_shadow_cmd_buffer.drawIndirect<DefaultMaterial>(cascade);
@ -676,3 +676,23 @@ void DrawCalls::drawIndirectShadows(unsigned cascade) const
m_shadow_cmd_buffer.drawIndirect<NormalMat>(cascade); m_shadow_cmd_buffer.drawIndirect<NormalMat>(cascade);
} }
void DrawCalls::multidrawShadows(unsigned cascade) const
{
m_shadow_cmd_buffer.multidrawShadow<DefaultMaterial>(cascade);
m_shadow_cmd_buffer.multidrawShadow<DetailMat>(cascade);
m_shadow_cmd_buffer.multidrawShadow<NormalMat>(cascade);
m_shadow_cmd_buffer.multidrawShadow<AlphaRef>(cascade);
m_shadow_cmd_buffer.multidrawShadow<UnlitMat>(cascade);
m_shadow_cmd_buffer.multidrawShadow<GrassMat,irr::core::vector3df>(windDir, cascade);
}
// ----------------------------------------------------------------------------
void DrawCalls::drawIndirectReflectiveShadowMaps(const core::matrix4 &rsm_matrix) const
{
m_reflective_shadow_map_cmd_buffer.drawIndirect<DefaultMaterial>(rsm_matrix);
m_reflective_shadow_map_cmd_buffer.drawIndirect<AlphaRef>(rsm_matrix);
m_reflective_shadow_map_cmd_buffer.drawIndirect<UnlitMat>(rsm_matrix);
m_reflective_shadow_map_cmd_buffer.drawIndirect<NormalMat>(rsm_matrix);
m_reflective_shadow_map_cmd_buffer.drawIndirect<DetailMat>(rsm_matrix);
}

24
src/graphics/draw_calls.hpp
View File

@ -61,15 +61,6 @@ private:
void clearLists(); void clearLists();
template<Material::ShaderType Mat, typename T>
void genDrawCalls( unsigned cascade,
std::vector<GLMesh *> &InstancedList,
T *InstanceBuffer,
DrawElementsIndirectCommand *CommandBuffer,
size_t &InstanceBufferOffset,
size_t &CommandBufferOffset,
size_t &PolyCount);
void handleSTKCommon(scene::ISceneNode *Node, void handleSTKCommon(scene::ISceneNode *Node,
std::vector<scene::ISceneNode *> *ImmediateDraw, std::vector<scene::ISceneNode *> *ImmediateDraw,
const scene::ICameraSceneNode *cam, const scene::ICameraSceneNode *cam,
@ -101,17 +92,16 @@ public:
inline void bindShadowCmd() const { m_shadow_cmd_buffer.bind(); } inline void bindShadowCmd() const { m_shadow_cmd_buffer.bind(); }
inline void bindReflectiveShadowMapsCmd() const { m_reflective_shadow_map_cmd_buffer.bind(); } inline void bindReflectiveShadowMapsCmd() const { m_reflective_shadow_map_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 multidrawIndirectSolidCmd(Material::ShaderType shader_type) const;
void drawIndirectSolidFirstPass() const; void drawIndirectSolidFirstPass() const;
//void multidrawIndirectSolidCmd() const; //TODO void multidrawSolidFirstPass() const;
void drawIndirectSolidSecondPass(const std::vector<GLuint> &prefilled_tex) const; void drawIndirectSolidSecondPass(const std::vector<GLuint> &prefilled_tex) const;
void multidrawSolidSecondPass(const std::vector<uint64_t> &handles) const;
void drawIndirectNormals() const;
void multidrawNormals() const;
void drawIndirectShadows(unsigned cascade) const; void drawIndirectShadows(unsigned cascade) const;
void multidrawShadows(unsigned cascade) const;
void drawIndirectReflectiveShadowMaps(const core::matrix4 &rsm_matrix) const; void drawIndirectReflectiveShadowMaps(const core::matrix4 &rsm_matrix) const;
}; };

173
src/graphics/geometry_passes.cpp
View File

@ -164,19 +164,6 @@ void renderMeshes1stPass(const DrawCalls& draw_calls)
} }
} // renderMeshes1stPass } // renderMeshes1stPass
// ----------------------------------------------------------------------------
template<typename T, typename...Args>
void multidraw1stPass(const DrawCalls& draw_calls, Args...args)
{
T::InstancedFirstPassShader::getInstance()->use();
glBindVertexArray(VAOManager::getInstance()->getInstanceVAO(T::VertexType, T::Instance));
if (!draw_calls.isSolidCmdEmpty(T::MaterialType))
{
T::InstancedFirstPassShader::getInstance()->setUniforms(args...);
draw_calls.multidrawIndirectSolidCmd(T::MaterialType);
}
} // multidraw1stPass
GeometryPasses::GeometryPasses() GeometryPasses::GeometryPasses()
{ {
@ -209,14 +196,7 @@ void GeometryPasses::renderSolidFirstPass(const DrawCalls& draw_calls)
if (CVS->isAZDOEnabled()) if (CVS->isAZDOEnabled())
{ {
multidraw1stPass<DefaultMaterial>(draw_calls); draw_calls.multidrawSolidFirstPass();
multidraw1stPass<AlphaRef>(draw_calls);
multidraw1stPass<SphereMap>(draw_calls);
multidraw1stPass<UnlitMat>(draw_calls);
multidraw1stPass<GrassMat>(draw_calls, m_wind_dir);
multidraw1stPass<NormalMat>(draw_calls);
multidraw1stPass<DetailMat>(draw_calls);
} }
else if (CVS->supportsIndirectInstancingRendering()) else if (CVS->supportsIndirectInstancingRendering())
{ {
@ -264,31 +244,12 @@ void renderMeshes2ndPass( const std::vector<uint64_t> &Prefilled_Handle,
} }
} // renderMeshes2ndPass } // renderMeshes2ndPass
// ----------------------------------------------------------------------------
template<typename T, typename...Args>
void multidraw2ndPass(const DrawCalls& draw_calls, const std::vector<uint64_t> &Handles, Args... args)
{
T::InstancedSecondPassShader::getInstance()->use();
glBindVertexArray(VAOManager::getInstance()->getInstanceVAO(T::VertexType,
T::Instance));
uint64_t nulltex[10] = {};
if (!draw_calls.isSolidCmdEmpty(T::MaterialType))
{
HandleExpander<typename T::InstancedSecondPassShader>::template
expand(nulltex, T::SecondPassTextures, Handles[0], Handles[1],
Handles[2]);
T::InstancedSecondPassShader::getInstance()->setUniforms(args...);
draw_calls.multidrawIndirectSolidCmd(T::MaterialType);
}
} // multidraw2ndPass
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
void GeometryPasses::renderSolidSecondPass( const DrawCalls& draw_calls, void GeometryPasses::renderSolidSecondPass( const DrawCalls& draw_calls,
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)
{ {
irr_driver->setPhase(SOLID_LIT_PASS); irr_driver->setPhase(SOLID_LIT_PASS);
glEnable(GL_DEPTH_TEST); glEnable(GL_DEPTH_TEST);
glDisable(GL_BLEND); glDisable(GL_BLEND);
@ -345,29 +306,13 @@ void GeometryPasses::renderSolidSecondPass( const DrawCalls& draw_calls,
if (CVS->isAZDOEnabled()) if (CVS->isAZDOEnabled())
{ {
multidraw2ndPass<DefaultMaterial>(draw_calls, createVector<uint64_t>(DiffuseHandle, SpecularHandle, SSAOHandle, 0, 0)); std::vector<uint64_t> handles =
multidraw2ndPass<AlphaRef>(draw_calls, createVector<uint64_t>(DiffuseHandle, SpecularHandle, SSAOHandle, 0, 0)); createVector<uint64_t>(DiffuseHandle,
multidraw2ndPass<SphereMap>(draw_calls, createVector<uint64_t>(DiffuseHandle, SpecularHandle, SSAOHandle, 0)); SpecularHandle,
multidraw2ndPass<UnlitMat>(draw_calls, createVector<uint64_t>(DiffuseHandle, SpecularHandle, SSAOHandle, 0)); SSAOHandle,
multidraw2ndPass<NormalMat>(draw_calls, createVector<uint64_t>(DiffuseHandle, SpecularHandle, SSAOHandle, 0, 0)); DepthHandle);
multidraw2ndPass<DetailMat>(draw_calls, createVector<uint64_t>(DiffuseHandle, SpecularHandle, SSAOHandle, 0, 0, 0));
// template does not work with template due to extra depth texture draw_calls.multidrawSolidSecondPass(handles);
{
GrassMat::InstancedSecondPassShader::getInstance()->use();
glBindVertexArray(VAOManager::getInstance()->getInstanceVAO(GrassMat::VertexType,
GrassMat::Instance));
uint64_t nulltex[10] = {};
if (!draw_calls.isSolidCmdEmpty(GrassMat::MaterialType))
{
HandleExpander<GrassMat::InstancedSecondPassShader>
::expand(nulltex, GrassMat::SecondPassTextures, DiffuseHandle,
SpecularHandle, SSAOHandle, DepthHandle);
GrassMat::InstancedSecondPassShader::getInstance()->setUniforms(m_wind_dir,
irr_driver->getSunDirection());
draw_calls.multidrawIndirectSolidCmd(GrassMat::MaterialType);
}
}
} }
else if (CVS->supportsIndirectInstancingRendering()) else if (CVS->supportsIndirectInstancingRendering())
{ {
@ -381,52 +326,16 @@ void GeometryPasses::renderSolidSecondPass( const DrawCalls& draw_calls,
} }
} // renderSolidSecondPass } // renderSolidSecondPass
// ----------------------------------------------------------------------------
template<typename T>
static void renderInstancedMeshNormals(const DrawCalls& draw_calls)
{
std::vector<GLMesh *> &meshes = T::InstancedList::getInstance()->SolidPass;
NormalVisualizer::getInstance()->use();
glBindVertexArray(VAOManager::getInstance()->getInstanceVAO(T::VertexType, T::Instance));
for (unsigned i = 0; i < meshes.size(); i++)
{
NormalVisualizer::getInstance()->setUniforms(video::SColor(255, 0, 255, 0));
draw_calls.drawIndirectSolidCmd(T::MaterialType, i);
}
} // renderInstancedMeshNormals
// ----------------------------------------------------------------------------
template<typename T>
static void renderMultiMeshNormals(const DrawCalls& draw_calls)
{
NormalVisualizer::getInstance()->use();
glBindVertexArray(VAOManager::getInstance()->getInstanceVAO(T::VertexType, T::Instance));
if (!draw_calls.isSolidCmdEmpty(T::MaterialType))
{
NormalVisualizer::getInstance()->setUniforms(video::SColor(255, 0, 255, 0));
draw_calls.multidrawIndirectSolidCmd(T::MaterialType);
}
} // renderMultiMeshNormals
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
void GeometryPasses::renderNormalsVisualisation(const DrawCalls& draw_calls) void GeometryPasses::renderNormalsVisualisation(const DrawCalls& draw_calls)
{ {
if (CVS->isAZDOEnabled()) { if (CVS->isAZDOEnabled()) {
renderMultiMeshNormals<DefaultMaterial>(draw_calls); draw_calls.multidrawNormals();
renderMultiMeshNormals<AlphaRef>(draw_calls);
renderMultiMeshNormals<UnlitMat>(draw_calls);
renderMultiMeshNormals<SphereMap>(draw_calls);
renderMultiMeshNormals<DetailMat>(draw_calls);
renderMultiMeshNormals<NormalMat>(draw_calls);
} }
else if (CVS->supportsIndirectInstancingRendering()) else if (CVS->supportsIndirectInstancingRendering())
{ {
renderInstancedMeshNormals<DefaultMaterial>(draw_calls); draw_calls.drawIndirectNormals();
renderInstancedMeshNormals<AlphaRef>(draw_calls);
renderInstancedMeshNormals<UnlitMat>(draw_calls);
renderInstancedMeshNormals<SphereMap>(draw_calls);
renderInstancedMeshNormals<DetailMat>(draw_calls);
renderInstancedMeshNormals<NormalMat>(draw_calls);
} }
} // renderNormalsVisualisation } // renderNormalsVisualisation
@ -619,48 +528,6 @@ void renderShadow(unsigned cascade)
} // for i } // for i
} // renderShadow } // renderShadow
// ----------------------------------------------------------------------------
template<typename T, typename...Args>
void renderInstancedShadow(unsigned cascade, Args ...args)
{
T::InstancedShadowPassShader::getInstance()->use();
glBindVertexArray(VAOManager::getInstance()->getInstanceVAO(T::VertexType,
InstanceTypeShadow));
std::vector<GLMesh *> &t = T::InstancedList::getInstance()->Shadows[cascade];
for (unsigned i = 0; i < t.size(); i++)
{
GLMesh *mesh = t[i];
TexExpander<typename T::InstancedShadowPassShader>::template
expandTex(*mesh, T::ShadowTextures);
T::InstancedShadowPassShader::getInstance()->setUniforms(args..., cascade);
size_t tmp = ShadowPassCmd::getInstance()->Offset[cascade][T::MaterialType] + i;
glDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_SHORT,
(const void*)((tmp)
* sizeof(DrawElementsIndirectCommand)));
} // for i
} // renderInstancedShadow
// ----------------------------------------------------------------------------
template<typename T, typename...Args>
static void multidrawShadow(unsigned i, Args ...args)
{
T::InstancedShadowPassShader::getInstance()->use();
glBindVertexArray(VAOManager::getInstance()->getInstanceVAO(T::VertexType,
InstanceTypeShadow));
if (ShadowPassCmd::getInstance()->Size[i][T::MaterialType])
{
T::InstancedShadowPassShader::getInstance()->setUniforms(args..., i);
glMultiDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_SHORT,
(const void*)(ShadowPassCmd::getInstance()->Offset[i][T::MaterialType]
* sizeof(DrawElementsIndirectCommand)),
(int)ShadowPassCmd::getInstance()->Size[i][T::MaterialType],
sizeof(DrawElementsIndirectCommand));
}
} // multidrawShadow
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
void GeometryPasses::renderShadows(const DrawCalls& draw_calls, void GeometryPasses::renderShadows(const DrawCalls& draw_calls,
const ShadowMatrices& shadow_matrices, const ShadowMatrices& shadow_matrices,
@ -689,39 +556,27 @@ void GeometryPasses::renderShadows(const DrawCalls& draw_calls,
{ {
ScopedGPUTimer Timer(irr_driver->getGPUTimer(Q_SHADOWS_CASCADE0 + cascade)); ScopedGPUTimer Timer(irr_driver->getGPUTimer(Q_SHADOWS_CASCADE0 + cascade));
/*renderShadow<DefaultMaterial, 1>(cascade); //TODO: useless if indirect instancing rendering or AZDO
renderShadow<DefaultMaterial, 1>(cascade);
renderShadow<SphereMap, 1>(cascade); renderShadow<SphereMap, 1>(cascade);
renderShadow<DetailMat, 1>(cascade); renderShadow<DetailMat, 1>(cascade);
renderShadow<SplattingMat, 1>(cascade); renderShadow<SplattingMat, 1>(cascade);
renderShadow<NormalMat, 1>(cascade); renderShadow<NormalMat, 1>(cascade);
renderShadow<AlphaRef, 1>(cascade); renderShadow<AlphaRef, 1>(cascade);
renderShadow<UnlitMat, 1>(cascade); renderShadow<UnlitMat, 1>(cascade);
renderShadow<GrassMat, 3, 1>(cascade);*/ renderShadow<GrassMat, 3, 1>(cascade);
if (CVS->supportsIndirectInstancingRendering()) if (CVS->supportsIndirectInstancingRendering())
//glBindBuffer(GL_DRAW_INDIRECT_BUFFER, ShadowPassCmd::getInstance()->drawindirectcmd);
draw_calls.bindShadowCmd(); draw_calls.bindShadowCmd();
if (CVS->isAZDOEnabled()) if (CVS->isAZDOEnabled())
{ {
multidrawShadow<DefaultMaterial>(cascade); draw_calls.multidrawShadows(cascade);
multidrawShadow<DetailMat>(cascade);
multidrawShadow<NormalMat>(cascade);
multidrawShadow<AlphaRef>(cascade);
multidrawShadow<UnlitMat>(cascade);
multidrawShadow<GrassMat>(cascade, m_wind_dir);
} }
else if (CVS->supportsIndirectInstancingRendering()) else if (CVS->supportsIndirectInstancingRendering())
{ {
//if(cascade==0)
draw_calls.drawIndirectShadows(cascade); draw_calls.drawIndirectShadows(cascade);
/*renderInstancedShadow<DefaultMaterial>(cascade);
renderInstancedShadow<DetailMat>(cascade);
renderInstancedShadow<AlphaRef>(cascade);
renderInstancedShadow<UnlitMat>(cascade);
renderInstancedShadow<GrassMat>(cascade, m_wind_dir);
renderInstancedShadow<NormalMat>(cascade);*/
} }
} }

1
src/graphics/irr_driver.cpp
View File

@ -816,7 +816,6 @@ void IrrDriver::applyResolutionSettings()
// (we're sure to update main.cpp at some point and forget this one...) // (we're sure to update main.cpp at some point and forget this one...)
ShaderBase::updateShaders(); ShaderBase::updateShaders();
VAOManager::getInstance()->kill(); VAOManager::getInstance()->kill();
ShadowPassCmd::getInstance()->kill();
RSMPassCmd::getInstance()->kill(); RSMPassCmd::getInstance()->kill();
GlowPassCmd::getInstance()->kill(); GlowPassCmd::getInstance()->kill();
resetTextureTable(); resetTextureTable();

6
src/graphics/stk_scene_manager.hpp
View File

@ -61,12 +61,6 @@ public:
}; };
class ShadowPassCmd : public CommandBufferOld<ShadowPassCmd, 4, static_cast<int>(Material::SHADERTYPE_COUNT)>
{
public:
size_t Offset[4][Material::SHADERTYPE_COUNT], Size[4][Material::SHADERTYPE_COUNT];
};
class RSMPassCmd : public CommandBufferOld<RSMPassCmd, 1, static_cast<int>(Material::SHADERTYPE_COUNT)> class RSMPassCmd : public CommandBufferOld<RSMPassCmd, 1, static_cast<int>(Material::SHADERTYPE_COUNT)>
{ {
public: public: