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

100
src/graphics/command_buffer.cpp
View File

@ -20,46 +20,55 @@
#include "utils/cpp2011.hpp"
template<>
void InstanceFiller<InstanceDataSingleTex>::add(GLMesh *mesh, scene::ISceneNode *node, InstanceDataSingleTex &instance)
{
fillOriginOrientationScale<InstanceDataSingleTex>(node, instance);
instance.Texture = mesh->TextureHandles[0];
}
template<>
void InstanceFiller<InstanceDataSingleTex>::add(GLMesh *mesh, scene::ISceneNode *node, InstanceDataSingleTex &instance)
{
fillOriginOrientationScale<InstanceDataSingleTex>(node, instance);
instance.Texture = mesh->TextureHandles[0];
}
template<>
void InstanceFiller<InstanceDataDualTex>::add(GLMesh *mesh, scene::ISceneNode *node, InstanceDataDualTex &instance)
{
fillOriginOrientationScale<InstanceDataDualTex>(node, instance);
instance.Texture = mesh->TextureHandles[0];
instance.SecondTexture = mesh->TextureHandles[1];
}
template<>
void InstanceFiller<InstanceDataDualTex>::add(GLMesh *mesh, scene::ISceneNode *node, InstanceDataDualTex &instance)
{
fillOriginOrientationScale<InstanceDataDualTex>(node, instance);
instance.Texture = mesh->TextureHandles[0];
instance.SecondTexture = mesh->TextureHandles[1];
}
template<>
void InstanceFiller<InstanceDataThreeTex>::add(GLMesh *mesh, scene::ISceneNode *node, InstanceDataThreeTex &instance)
{
fillOriginOrientationScale<InstanceDataThreeTex>(node, instance);
instance.Texture = mesh->TextureHandles[0];
instance.SecondTexture = mesh->TextureHandles[1];
instance.ThirdTexture = mesh->TextureHandles[2];
}
template<>
void InstanceFiller<InstanceDataThreeTex>::add(GLMesh *mesh, scene::ISceneNode *node, InstanceDataThreeTex &instance)
{
fillOriginOrientationScale<InstanceDataThreeTex>(node, instance);
instance.Texture = mesh->TextureHandles[0];
instance.SecondTexture = mesh->TextureHandles[1];
instance.ThirdTexture = mesh->TextureHandles[2];
}
template<>
void InstanceFiller<GlowInstanceData>::add(GLMesh *mesh, scene::ISceneNode *node, GlowInstanceData &instance)
{
fillOriginOrientationScale<GlowInstanceData>(node, instance);
STKMeshSceneNode *nd = dynamic_cast<STKMeshSceneNode*>(node);
instance.Color = nd->getGlowColor().color;
}
template<>
void expandTexSecondPass<GrassMat>(const GLMesh &mesh,
const std::vector<GLuint> &prefilled_tex)
{
TexExpander<typename GrassMat::InstancedSecondPassShader>::template
expandTex(mesh, GrassMat::SecondPassTextures, prefilled_tex[0],
prefilled_tex[1], prefilled_tex[2], prefilled_tex[3]);
}
template<>
void InstanceFiller<GlowInstanceData>::add(GLMesh *mesh, scene::ISceneNode *node, GlowInstanceData &instance)
{
fillOriginOrientationScale<GlowInstanceData>(node, instance);
STKMeshSceneNode *nd = dynamic_cast<STKMeshSceneNode*>(node);
instance.Color = nd->getGlowColor().color;
}
template<>
void expandTexSecondPass<GrassMat>(const GLMesh &mesh,
const std::vector<GLuint> &prefilled_tex)
{
TexExpander<typename GrassMat::InstancedSecondPassShader>::template
expandTex(mesh, GrassMat::SecondPassTextures, prefilled_tex[0],
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>
@ -152,19 +161,11 @@ ShadowCommandBuffer::ShadowCommandBuffer(): CommandBuffer()
{
}
//void ShadowCommandBuffer::fill(std::array<MeshMap,Material::SHADERTYPE_COUNT> mesh_map)
void ShadowCommandBuffer::fill(MeshMap *mesh_map)
{
clearMeshes();
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++)
{
shadow_tex_material_list.push_back(cascade * Material::SHADERTYPE_COUNT
@ -182,10 +183,9 @@ void ShadowCommandBuffer::fill(MeshMap *mesh_map)
shadow_tex_material_list.push_back(cascade * Material::SHADERTYPE_COUNT
+ Material::SHADERTYPE_VEGETATION);
}
fillInstanceData<InstanceDataSingleTex>(mesh_map, shadow_tex_material_list, InstanceTypeShadow);
//fillInstanceData<InstanceDataSingleTex>(mesh_map.data(), shadow_tex_material_list, InstanceTypeShadow);
unmapBuffers();
} //ShadowCommandBuffer::fill
@ -243,9 +243,7 @@ void GlowCommandBuffer::fill(MeshMap *mesh_map)
GL_MAP_WRITE_BIT | GL_MAP_UNSYNCHRONIZED_BIT | GL_MAP_INVALIDATE_BUFFER_BIT);
}
fillMaterial( 0,
mesh_map,
glow_instance_buffer);
fillMaterial( 0, mesh_map, glow_instance_buffer);
unmapBuffers();
} //GlowCommandBuffer::fill

143
src/graphics/command_buffer.hpp
View File

@ -120,6 +120,20 @@ template<>
void expandTexSecondPass<GrassMat>(const GLMesh &mesh,
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>
class CommandBuffer
{
@ -207,41 +221,13 @@ public:
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
{
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)>
{
public:
@ -278,7 +264,25 @@ public:
} //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>
void drawIndirectSecondPass(const std::vector<GLuint> &prefilled_tex,
@ -299,6 +303,62 @@ public:
}
} //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)>
@ -330,7 +390,30 @@ public:
(const void*)((m_offset[material_id] + i)
* sizeof(DrawElementsIndirectCommand)));
} // 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)>

120
src/graphics/draw_calls.cpp
View File

@ -66,31 +66,6 @@ void DrawCalls::clearLists()
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,
std::vector<scene::ISceneNode *> *ImmediateDraw,
@ -504,7 +479,6 @@ void DrawCalls::prepareDrawCalls( ShadowMatrices& shadow_matrices, scene::ICamer
InstanceDataSingleTex *ShadowInstanceBuffer;
InstanceDataSingleTex *RSMInstanceBuffer;
GlowInstanceData *GlowInstanceBuffer;
DrawElementsIndirectCommand *ShadowCmdBuffer;
DrawElementsIndirectCommand *RSMCmdBuffer;
DrawElementsIndirectCommand *GlowCmdBuffer;
@ -515,7 +489,6 @@ void DrawCalls::prepareDrawCalls( ShadowMatrices& shadow_matrices, scene::ICamer
ShadowInstanceBuffer = (InstanceDataSingleTex*)VAOManager::getInstance()->getInstanceBufferPtr(InstanceTypeShadow);
RSMInstanceBuffer = (InstanceDataSingleTex*)VAOManager::getInstance()->getInstanceBufferPtr(InstanceTypeRSM);
GlowInstanceBuffer = (GlowInstanceData*)VAOManager::getInstance()->getInstanceBufferPtr(InstanceTypeGlow);
ShadowCmdBuffer = ShadowPassCmd::getInstance()->Ptr;
GlowCmdBuffer = GlowPassCmd::getInstance()->Ptr;
RSMCmdBuffer = RSMPassCmd::getInstance()->Ptr;
enableOpenMP = 1;
@ -615,24 +588,11 @@ void DrawCalls::renderParticlesList() const
particles->render();
}
/** Draw the i-th mesh with the specified material for the solid pass
* (require at least OpenGL 4.0
// ----------------------------------------------------------------------------
/** Render the solid first pass (depth and normals)
* Require at least OpenGL 4.0
* 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
{
m_solid_cmd_buffer.drawIndirectFirstPass<DefaultMaterial>();
@ -644,10 +604,24 @@ void DrawCalls::drawIndirectSolidFirstPass() const
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
{
m_solid_cmd_buffer.drawIndirectSecondPass<DefaultMaterial>(prefilled_tex);
m_solid_cmd_buffer.drawIndirectSecondPass<AlphaRef>(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);
}
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_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);
m_solid_cmd_buffer.multidraw2ndPass<DefaultMaterial>(handles);
m_solid_cmd_buffer.multidraw2ndPass<AlphaRef>(handles);
m_solid_cmd_buffer.multidraw2ndPass<SphereMap>(handles);
m_solid_cmd_buffer.multidraw2ndPass<UnlitMat>(handles);
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
{
m_shadow_cmd_buffer.drawIndirect<DefaultMaterial>(cascade);
@ -676,3 +676,23 @@ void DrawCalls::drawIndirectShadows(unsigned cascade) const
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

@ -60,15 +60,6 @@ private:
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,
std::vector<scene::ISceneNode *> *ImmediateDraw,
@ -101,17 +92,16 @@ public:
inline void bindShadowCmd() const { m_shadow_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 multidrawIndirectSolidCmd() const; //TODO
void multidrawSolidFirstPass() 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 multidrawShadows(unsigned cascade) const;
void drawIndirectReflectiveShadowMaps(const core::matrix4 &rsm_matrix) const;
};

175
src/graphics/geometry_passes.cpp
View File

@ -164,19 +164,6 @@ void renderMeshes1stPass(const DrawCalls& draw_calls)
}
} // 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()
{
@ -209,14 +196,7 @@ void GeometryPasses::renderSolidFirstPass(const DrawCalls& draw_calls)
if (CVS->isAZDOEnabled())
{
multidraw1stPass<DefaultMaterial>(draw_calls);
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);
draw_calls.multidrawSolidFirstPass();
}
else if (CVS->supportsIndirectInstancingRendering())
{
@ -264,31 +244,12 @@ void renderMeshes2ndPass( const std::vector<uint64_t> &Prefilled_Handle,
}
} // 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,
unsigned render_target_diffuse,
unsigned render_target_specular,
unsigned render_target_half_red)
{
{
irr_driver->setPhase(SOLID_LIT_PASS);
glEnable(GL_DEPTH_TEST);
glDisable(GL_BLEND);
@ -345,29 +306,13 @@ void GeometryPasses::renderSolidSecondPass( const DrawCalls& draw_calls,
if (CVS->isAZDOEnabled())
{
multidraw2ndPass<DefaultMaterial>(draw_calls, createVector<uint64_t>(DiffuseHandle, SpecularHandle, SSAOHandle, 0, 0));
multidraw2ndPass<AlphaRef>(draw_calls, createVector<uint64_t>(DiffuseHandle, SpecularHandle, SSAOHandle, 0, 0));
multidraw2ndPass<SphereMap>(draw_calls, createVector<uint64_t>(DiffuseHandle, SpecularHandle, SSAOHandle, 0));
multidraw2ndPass<UnlitMat>(draw_calls, createVector<uint64_t>(DiffuseHandle, SpecularHandle, SSAOHandle, 0));
multidraw2ndPass<NormalMat>(draw_calls, createVector<uint64_t>(DiffuseHandle, SpecularHandle, SSAOHandle, 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
{
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);
}
}
std::vector<uint64_t> handles =
createVector<uint64_t>(DiffuseHandle,
SpecularHandle,
SSAOHandle,
DepthHandle);
draw_calls.multidrawSolidSecondPass(handles);
}
else if (CVS->supportsIndirectInstancingRendering())
{
@ -381,52 +326,16 @@ void GeometryPasses::renderSolidSecondPass( const DrawCalls& draw_calls,
}
} // 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)
{
if (CVS->isAZDOEnabled()) {
renderMultiMeshNormals<DefaultMaterial>(draw_calls);
renderMultiMeshNormals<AlphaRef>(draw_calls);
renderMultiMeshNormals<UnlitMat>(draw_calls);
renderMultiMeshNormals<SphereMap>(draw_calls);
renderMultiMeshNormals<DetailMat>(draw_calls);
renderMultiMeshNormals<NormalMat>(draw_calls);
draw_calls.multidrawNormals();
}
else if (CVS->supportsIndirectInstancingRendering())
{
renderInstancedMeshNormals<DefaultMaterial>(draw_calls);
renderInstancedMeshNormals<AlphaRef>(draw_calls);
renderInstancedMeshNormals<UnlitMat>(draw_calls);
renderInstancedMeshNormals<SphereMap>(draw_calls);
renderInstancedMeshNormals<DetailMat>(draw_calls);
renderInstancedMeshNormals<NormalMat>(draw_calls);
draw_calls.drawIndirectNormals();
}
} // renderNormalsVisualisation
@ -619,48 +528,6 @@ void renderShadow(unsigned cascade)
} // for i
} // 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,
const ShadowMatrices& shadow_matrices,
@ -689,39 +556,27 @@ void GeometryPasses::renderShadows(const DrawCalls& draw_calls,
{
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<DetailMat, 1>(cascade);
renderShadow<SplattingMat, 1>(cascade);
renderShadow<NormalMat, 1>(cascade);
renderShadow<AlphaRef, 1>(cascade);
renderShadow<UnlitMat, 1>(cascade);
renderShadow<GrassMat, 3, 1>(cascade);*/
renderShadow<GrassMat, 3, 1>(cascade);
if (CVS->supportsIndirectInstancingRendering())
//glBindBuffer(GL_DRAW_INDIRECT_BUFFER, ShadowPassCmd::getInstance()->drawindirectcmd);
draw_calls.bindShadowCmd();
if (CVS->isAZDOEnabled())
{
multidrawShadow<DefaultMaterial>(cascade);
multidrawShadow<DetailMat>(cascade);
multidrawShadow<NormalMat>(cascade);
multidrawShadow<AlphaRef>(cascade);
multidrawShadow<UnlitMat>(cascade);
multidrawShadow<GrassMat>(cascade, m_wind_dir);
draw_calls.multidrawShadows(cascade);
}
else if (CVS->supportsIndirectInstancingRendering())
{
//if(cascade==0)
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...)
ShaderBase::updateShaders();
VAOManager::getInstance()->kill();
ShadowPassCmd::getInstance()->kill();
RSMPassCmd::getInstance()->kill();
GlowPassCmd::getInstance()->kill();
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)>
{
public: