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

Use texture buffer (texture2d in gles) for skinning

Browse Source
This commit is contained in:
Benau 2017-10-19 13:31:07 +08:00
parent 1a9cf6a46f
commit 0d96906d54
30 changed files with 479 additions and 190 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
data/shaders/instanced_objectref_pass2.frag
View File

@ -22,6 +22,7 @@ void main(void)
#ifdef Use_Bindless_Texture
vec4 col = texture(handle, uv);
float specmap = texture(secondhandle, uv).g;
float emitmap = texture(secondhandle, uv).b;
float mask = texture(thirdhandle, uv).a;
#ifdef SRGBBindlessFix
col.xyz = pow(col.xyz, vec3(2.2));

37
data/shaders/instanced_skinning.vert
View File

@ -49,6 +49,8 @@ flat out sampler2D fourthhandle;
#stk_include "utils/getworldmatrix.vert"
uniform samplerBuffer skinning_tex;
void main(void)
{
mat4 ModelMatrix = getWorldMatrix(Origin, Orientation, Scale);
@ -61,18 +63,31 @@ void main(void)
vec4 skinned_normal = vec4(0.);
vec4 skinned_tangent = vec4(0.);
vec4 skinned_bitangent = vec4(0.);
// Note : For normal we assume no scale factor in bone (otherwise we'll have to compute inversematrix for each bones...)
for (int i = 0; i < 4; i++)
if (Weight[0] < 0.01)
{
vec4 single_bone_influenced_position = joint_matrices[clamp(Joint[i] + skinning_offset, 0, MAX_BONES)] * idle_position;
single_bone_influenced_position /= single_bone_influenced_position.w;
vec4 single_bone_influenced_normal = joint_matrices[clamp(Joint[i] + skinning_offset, 0, MAX_BONES)] * idle_normal;
vec4 single_bone_influenced_tangent = joint_matrices[clamp(Joint[i] + skinning_offset, 0, MAX_BONES)] * idle_tangent;
vec4 single_bone_influenced_bitangent = joint_matrices[clamp(Joint[i] + skinning_offset, 0, MAX_BONES)] * idle_bitangent;
skinned_position += Weight[i] * single_bone_influenced_position;
skinned_normal += Weight[i] * single_bone_influenced_normal;
skinned_tangent += Weight[i] * single_bone_influenced_tangent;
skinned_bitangent += Weight[i] * single_bone_influenced_bitangent;
skinned_position = idle_position;
skinned_normal = idle_normal;
skinned_tangent = idle_tangent;
skinned_bitangent = idle_bitangent;
}
else
{
for (int i = 0; i < 4; i++)
{
if (Weight[i] < 0.01)
{
break;
}
mat4 joint_matrix = mat4(
texelFetch(skinning_tex, (Joint[i] + skinning_offset) * 4),
texelFetch(skinning_tex, (Joint[i] + skinning_offset) * 4 + 1),
texelFetch(skinning_tex, (Joint[i] + skinning_offset) * 4 + 2),
texelFetch(skinning_tex, (Joint[i] + skinning_offset) * 4 + 3));
skinned_position += Weight[i] * joint_matrix * idle_position;
skinned_normal += Weight[i] * joint_matrix * idle_normal;
skinned_tangent += Weight[i] * joint_matrix * idle_tangent;
skinned_bitangent += Weight[i] * joint_matrix * idle_bitangent;
}
}
gl_Position = ProjectionViewMatrix * ModelMatrix * skinned_position;

24
data/shaders/instanced_skinning_shadow.vert
View File

@ -38,16 +38,32 @@ flat out uvec2 hdle;
#stk_include "utils/getworldmatrix.vert"
uniform samplerBuffer skinning_tex;
void main(void)
{
mat4 ModelMatrix = getWorldMatrix(Origin, Orientation, Scale);
vec4 idle_position = vec4(Position, 1.);
vec4 skinned_position = vec4(0.);
for (int i = 0; i < 4; i++)
if (Weight[0] < 0.01)
{
vec4 single_bone_influenced_position = joint_matrices[clamp(Joint[i] + skinning_offset, 0, MAX_BONES)] * idle_position;
single_bone_influenced_position /= single_bone_influenced_position.w;
skinned_position += Weight[i] * single_bone_influenced_position;
skinned_position = idle_position;
}
else
{
for (int i = 0; i < 4; i++)
{
if (Weight[i] < 0.01)
{
break;
}
mat4 joint_matrix = mat4(
texelFetch(skinning_tex, (Joint[i] + skinning_offset) * 4),
texelFetch(skinning_tex, (Joint[i] + skinning_offset) * 4 + 1),
texelFetch(skinning_tex, (Joint[i] + skinning_offset) * 4 + 2),
texelFetch(skinning_tex, (Joint[i] + skinning_offset) * 4 + 3));
skinned_position += Weight[i] * joint_matrix * idle_position;
}
}
#ifdef VSLayer

48
data/shaders/skinning.vert
View File

@ -17,6 +17,11 @@ uniform mat4 InverseModelMatrix =
uniform vec2 texture_trans = vec2(0., 0.);
#endif
uniform int skinning_offset;
#ifdef GL_ES
uniform sampler2D skinning_tex;
#else
uniform samplerBuffer skinning_tex;
#endif
#ifdef Explicit_Attrib_Location_Usable
layout(location = 0) in vec3 Position;
@ -55,18 +60,39 @@ void main(void)
vec4 skinned_normal = vec4(0.);
vec4 skinned_tangent = vec4(0.);
vec4 skinned_bitangent = vec4(0.);
// Note : For normal we assume no scale factor in bone (otherwise we'll have to compute inversematrix for each bones...)
for (int i = 0; i < 4; i++)
if (Weight[0] < 0.01)
{
vec4 single_bone_influenced_position = joint_matrices[clamp(Joint[i] + skinning_offset, 0, MAX_BONES)] * idle_position;
single_bone_influenced_position /= single_bone_influenced_position.w;
vec4 single_bone_influenced_normal = joint_matrices[clamp(Joint[i] + skinning_offset, 0, MAX_BONES)] * idle_normal;
vec4 single_bone_influenced_tangent = joint_matrices[clamp(Joint[i] + skinning_offset, 0, MAX_BONES)] * idle_tangent;
vec4 single_bone_influenced_bitangent = joint_matrices[clamp(Joint[i] + skinning_offset, 0, MAX_BONES)] * idle_bitangent;
skinned_position += Weight[i] * single_bone_influenced_position;
skinned_normal += Weight[i] * single_bone_influenced_normal;
skinned_tangent += Weight[i] * single_bone_influenced_tangent;
skinned_bitangent += Weight[i] * single_bone_influenced_bitangent;
skinned_position = idle_position;
skinned_normal = idle_normal;
skinned_tangent = idle_tangent;
skinned_bitangent = idle_bitangent;
}
else
{
for (int i = 0; i < 4; i++)
{
if (Weight[i] < 0.01)
{
break;
}
#ifdef GL_ES
mat4 joint_matrix = mat4(
texelFetch(skinning_tex, ivec2(0, skinning_offset + Joint[i]), 0),
texelFetch(skinning_tex, ivec2(1, skinning_offset + Joint[i]), 0),
texelFetch(skinning_tex, ivec2(2, skinning_offset + Joint[i]), 0),
texelFetch(skinning_tex, ivec2(3, skinning_offset + Joint[i]), 0));
#else
mat4 joint_matrix = mat4(
texelFetch(skinning_tex, (Joint[i] + skinning_offset) * 4),
texelFetch(skinning_tex, (Joint[i] + skinning_offset) * 4 + 1),
texelFetch(skinning_tex, (Joint[i] + skinning_offset) * 4 + 2),
texelFetch(skinning_tex, (Joint[i] + skinning_offset) * 4 + 3));
#endif
skinned_position += Weight[i] * joint_matrix * idle_position;
skinned_normal += Weight[i] * joint_matrix * idle_normal;
skinned_tangent += Weight[i] * joint_matrix * idle_tangent;
skinned_bitangent += Weight[i] * joint_matrix * idle_bitangent;
}
}
gl_Position = ProjectionViewMatrix * ModelMatrix * skinned_position;

23
data/shaders/skinning_shadow.vert
View File

@ -1,6 +1,7 @@
uniform mat4 ModelMatrix;
uniform int skinning_offset;
uniform int layer;
uniform samplerBuffer skinning_tex;
#ifdef Explicit_Attrib_Location_Usable
layout(location = 0) in vec3 Position;
@ -25,11 +26,25 @@ void main(void)
{
vec4 idle_position = vec4(Position, 1.);
vec4 skinned_position = vec4(0.);
for (int i = 0; i < 4; i++)
if (Weight[0] < 0.01)
{
vec4 single_bone_influenced_position = joint_matrices[clamp(Joint[i] + skinning_offset, 0, MAX_BONES)] * idle_position;
single_bone_influenced_position /= single_bone_influenced_position.w;
skinned_position += Weight[i] * single_bone_influenced_position;
skinned_position = idle_position;
}
else
{
for (int i = 0; i < 4; i++)
{
if (Weight[i] < 0.01)
{
break;
}
mat4 joint_matrix = mat4(
texelFetch(skinning_tex, (Joint[i] + skinning_offset) * 4),
texelFetch(skinning_tex, (Joint[i] + skinning_offset) * 4 + 1),
texelFetch(skinning_tex, (Joint[i] + skinning_offset) * 4 + 2),
texelFetch(skinning_tex, (Joint[i] + skinning_offset) * 4 + 3));
skinned_position += Weight[i] * joint_matrix * idle_position;
}
}
#ifdef VSLayer

10
lib/irrlicht/include/S3DVertex.h
View File

@ -255,14 +255,8 @@ struct S3DVertexTangents : public S3DVertex
struct S3DVertexSkinnedMesh : public S3DVertexTangents
{
s32 m_joint_idx1;
s32 m_joint_idx2;
s32 m_joint_idx3;
s32 m_joint_idx4;
f32 m_weight1;
f32 m_weight2;
f32 m_weight3;
f32 m_weight4;
s16 m_joint_idx[4];
s16 m_weight[4];
E_VERTEX_TYPE getType() const
{

32
lib/irrlicht/include/SSkinMeshBuffer.h
View File

@ -243,14 +243,14 @@ struct SSkinMeshBuffer : public IMeshBuffer
Vertex.TCoords=Vertices_Standard[n].TCoords;
Vertex.Tangent=core::vector3df(0.0f, 0.0f, 0.0f);
Vertex.Binormal=core::vector3df(0.0f, 0.0f, 0.0f);
Vertex.m_joint_idx1 = 0;
Vertex.m_joint_idx2 = 0;
Vertex.m_joint_idx3 = 0;
Vertex.m_joint_idx4 = 0;
Vertex.m_weight1 = 0;
Vertex.m_weight2 = 0;
Vertex.m_weight3 = 0;
Vertex.m_weight4 = 0;
Vertex.m_joint_idx[0] = 0;
Vertex.m_joint_idx[1] = 0;
Vertex.m_joint_idx[2] = 0;
Vertex.m_joint_idx[3] = 0;
Vertex.m_weight[0] = 0;
Vertex.m_weight[1] = 0;
Vertex.m_weight[2] = 0;
Vertex.m_weight[3] = 0;
Vertices_SkinnedMesh.push_back(Vertex);
}
}
@ -265,14 +265,14 @@ struct SSkinMeshBuffer : public IMeshBuffer
Vertex.TCoords=Vertices_Tangents[n].TCoords;
Vertex.Tangent=Vertices_Tangents[n].Tangent;
Vertex.Binormal=Vertices_Tangents[n].Binormal;
Vertex.m_joint_idx1 = 0;
Vertex.m_joint_idx2 = 0;
Vertex.m_joint_idx3 = 0;
Vertex.m_joint_idx4 = 0;
Vertex.m_weight1 = 0;
Vertex.m_weight2 = 0;
Vertex.m_weight3 = 0;
Vertex.m_weight4 = 0;
Vertex.m_joint_idx[0] = 0;
Vertex.m_joint_idx[1] = 0;
Vertex.m_joint_idx[2] = 0;
Vertex.m_joint_idx[3] = 0;
Vertex.m_weight[0] = 0;
Vertex.m_weight[1] = 0;
Vertex.m_weight[2] = 0;
Vertex.m_weight[3] = 0;
Vertices_SkinnedMesh.push_back(Vertex);
}
}

89
lib/irrlicht/source/Irrlicht/CSkinnedMesh.cpp
View File

@ -11,6 +11,55 @@
#include "os.h"
#include "irrMap.h"
inline irr::s16 float_16(irr::f32 in)
{
irr::s32 i;
memcpy(&i, &in, 4);
irr::s32 s = (i >> 16) & 0x00008000;
irr::s32 e = ((i >> 23) & 0x000000ff) - (127 - 15);
irr::s32 m = i & 0x007fffff;
if (e <= 0)
{
if (e < -10)
{
return irr::s16(s);
}
m = (m | 0x00800000) >> (1 - e);
if (m & 0x00001000)
m += 0x00002000;
return irr::s16(s | (m >> 13));
}
else if (e == 0xff - (127 - 15))
{
if (m == 0)
{
return irr::s16(s | 0x7c00);
}
else
{
m >>= 13;
return irr::s16(s | 0x7c00 | m | (m == 0));
}
}
else
{
if (m & 0x00001000)
{
m += 0x00002000;
if (m & 0x00800000)
{
m = 0; // overflow in significand,
e += 1; // adjust exponent
}
}
if (e > 30)
{
return irr::s16(s | 0x7c00);
}
return irr::s16(s | (e << 10) | (m >> 13));
}
}
namespace irr
{
namespace scene
@ -1450,28 +1499,34 @@ void CSkinnedMesh::convertForSkinning()
core::array<JointInfluence> this_influence;
core::array<JointInfluence> reported_weight = wi[b][i];
reported_weight.sort(sortJointInfluenceFunc);
float remaining_weight = 1.0f;
for (u32 j = 0; j < 4; j++)
{
JointInfluence influence;
if (reported_weight.size() > j)
influence = reported_weight[j];
else
{
influence.joint_idx = -100000;
influence.weight = remaining_weight;
}
remaining_weight -= influence.weight;
influence.joint_idx = -100000;
influence.weight = 0.0f;
this_influence.push_back(influence);
}
LocalBuffers[b]->Vertices_SkinnedMesh[i].m_joint_idx1 = this_influence[0].joint_idx;
LocalBuffers[b]->Vertices_SkinnedMesh[i].m_joint_idx2 = this_influence[1].joint_idx;
LocalBuffers[b]->Vertices_SkinnedMesh[i].m_joint_idx3 = this_influence[2].joint_idx;
LocalBuffers[b]->Vertices_SkinnedMesh[i].m_joint_idx4 = this_influence[3].joint_idx;
LocalBuffers[b]->Vertices_SkinnedMesh[i].m_weight1 = this_influence[0].weight;
LocalBuffers[b]->Vertices_SkinnedMesh[i].m_weight2 = this_influence[1].weight;
LocalBuffers[b]->Vertices_SkinnedMesh[i].m_weight3 = this_influence[2].weight;
LocalBuffers[b]->Vertices_SkinnedMesh[i].m_weight4 = this_influence[3].weight;
float total_weight = 0.0f;
for (u32 j = 0; j < reported_weight.size(); j++)
{
total_weight += reported_weight[j].weight;
this_influence[j].joint_idx = reported_weight[j].joint_idx;
this_influence[j].weight = reported_weight[j].weight;
}
if (!reported_weight.empty())
{
for (u32 j = 0; j < reported_weight.size(); j++)
{
this_influence[j].weight =
this_influence[j].weight / total_weight;
}
}
for (int j = 0; j < 4; j++)
{
LocalBuffers[b]->Vertices_SkinnedMesh[i].m_joint_idx[j] = (s16)this_influence[j].joint_idx;
LocalBuffers[b]->Vertices_SkinnedMesh[i].m_weight[j] = float_16
(this_influence[j].weight);
}
}
}
}

2
src/graphics/central_settings.cpp
View File

@ -527,7 +527,7 @@ bool CentralVideoSettings::isDefferedEnabled() const
bool CentralVideoSettings::supportsHardwareSkinning() const
{
return isARBUniformBufferObjectUsable();
return true;
}
bool CentralVideoSettings::isARBTextureSwizzleUsable() const

12
src/graphics/command_buffer.hpp
View File

@ -263,7 +263,7 @@ public:
{
T::InstancedFirstPassShader::getInstance()->use();
T::InstancedFirstPassShader::getInstance()->setUniforms(uniforms...);
handleSkinning(T::InstancedFirstPassShader::getInstance());
glBindVertexArray(VAOManager::getInstance()->getInstanceVAO(T::VertexType,
T::Instance));
for (unsigned i = 0; i < m_meshes[T::MaterialType].size(); i++)
@ -303,7 +303,7 @@ public:
{
T::InstancedFirstPassShader::getInstance()->use();
T::InstancedFirstPassShader::getInstance()->setUniforms(uniforms...);
handleSkinning(T::InstancedFirstPassShader::getInstance());
glBindVertexArray(VAOManager::getInstance()->getInstanceVAO(T::VertexType,
T::Instance));
glMultiDrawElementsIndirect(GL_TRIANGLES,
@ -329,7 +329,7 @@ public:
{
T::InstancedSecondPassShader::getInstance()->use();
T::InstancedSecondPassShader::getInstance()->setUniforms(uniforms...);
handleSkinning(T::InstancedSecondPassShader::getInstance());
glBindVertexArray(VAOManager::getInstance()->getInstanceVAO(T::VertexType,
T::Instance));
for (unsigned i = 0; i < m_meshes[T::MaterialType].size(); i++)
@ -364,7 +364,7 @@ public:
{
T::InstancedSecondPassShader::getInstance()->use();
T::InstancedSecondPassShader::getInstance()->setUniforms(uniforms...);
handleSkinning(T::InstancedSecondPassShader::getInstance());
glBindVertexArray(VAOManager::getInstance()->getInstanceVAO(T::VertexType,
T::Instance));
expandHandlesSecondPass<T>(handles);
@ -451,7 +451,7 @@ public:
{
T::InstancedShadowPassShader::getInstance()->use();
T::InstancedShadowPassShader::getInstance()->setUniforms(cascade, uniforms...);
handleSkinning(T::InstancedShadowPassShader::getInstance());
glBindVertexArray(VAOManager::getInstance()->getInstanceVAO(T::VertexType,
InstanceTypeShadow));
@ -488,7 +488,7 @@ public:
{
T::InstancedShadowPassShader::getInstance()->use();
T::InstancedShadowPassShader::getInstance()->setUniforms(cascade, uniforms...);
handleSkinning(T::InstancedShadowPassShader::getInstance());
glBindVertexArray(VAOManager::getInstance()->getInstanceVAO(T::VertexType,
InstanceTypeShadow));
glMultiDrawElementsIndirect(GL_TRIANGLES,

13
src/graphics/draw_calls.cpp
View File

@ -258,7 +258,7 @@ void DrawCalls::handleSTKCommon(scene::ISceneNode *Node,
(!culled_for_cams[0] || !culled_for_cams[1] || !culled_for_cams[2] ||
!culled_for_cams[3] || !culled_for_cams[4] || !culled_for_cams[5]))
{
skinning_offset = getSkinningOffset() + 1/*reserved identity matrix*/;
skinning_offset = getSkinningOffset();
if (skinning_offset + am->getTotalJoints() >
SharedGPUObjects::getMaxMat4Size())
{
@ -684,9 +684,20 @@ void DrawCalls::prepareDrawCalls( ShadowMatrices& shadow_matrices,
}*/
PROFILER_PUSH_CPU_MARKER("- Animations/Buffer upload", 0x0, 0x0, 0x0);
shadow_matrices.updateUBO();
#ifdef USE_GLES2
glBindTexture(GL_TEXTURE_2D, SharedGPUObjects::getSkinningTexture());
#else
glBindBuffer(GL_TEXTURE_BUFFER, SharedGPUObjects::getSkinningBuffer());
#endif
for (unsigned i = 0; i < m_deferred_update.size(); i++)
m_deferred_update[i]->updateGL();
PROFILER_POP_CPU_MARKER();
#ifdef USE_GLES2
glBindTexture(GL_TEXTURE_2D, 0);
#else
glBindBuffer(GL_TEXTURE_BUFFER, 0);
#endif
PROFILER_PUSH_CPU_MARKER("- cpu particle upload", 0x3F, 0x03, 0x61);
CPUParticleManager::getInstance()->uploadAll();

3
src/graphics/draw_policies.cpp
View File

@ -28,6 +28,7 @@ void renderMeshes1stPass()
{
auto &meshes = T::List::getInstance()->SolidPass;
T::FirstPassShader::getInstance()->use();
handleSkinning(T::FirstPassShader::getInstance());
if (CVS->isARBBaseInstanceUsable())
glBindVertexArray(VAOManager::getInstance()->getVAO(T::VertexType));
for (unsigned i = 0; i < meshes.size(); i++)
@ -58,6 +59,7 @@ void renderMeshes2ndPass( const std::vector<uint64_t> &Prefilled_Handle,
{
auto &meshes = T::List::getInstance()->SolidPass;
T::SecondPassShader::getInstance()->use();
handleSkinning(T::SecondPassShader::getInstance());
if (CVS->isARBBaseInstanceUsable())
glBindVertexArray(VAOManager::getInstance()->getVAO(T::VertexType));
for (unsigned i = 0; i < meshes.size(); i++)
@ -95,6 +97,7 @@ void renderShadow(unsigned cascade)
{
auto &t = T::List::getInstance()->Shadows[cascade];
T::ShadowPassShader::getInstance()->use();
handleSkinning(T::ShadowPassShader::getInstance());
if (CVS->isARBBaseInstanceUsable())
glBindVertexArray(VAOManager::getInstance()->getVAO(T::VertexType));
for (unsigned i = 0; i < t.size(); i++)

9
src/graphics/draw_tools.hpp
View File

@ -183,5 +183,14 @@ struct HandleExpander
} // Expand
}; // HandleExpander
// ----------------------------------------------------------------------------
template <typename Shader>
inline void handleSkinning(Shader* s)
{
if (SkinnedMeshShader* sms = dynamic_cast<SkinnedMeshShader*>(s))
{
sms->bindSkinningTexture();
}
}
#endif //HEADER_DRAW_TOOLS_HPP

1
src/graphics/geometry_passes.cpp
View File

@ -202,6 +202,7 @@ void renderTransparenPass(const std::vector<RenderGeometry::TexUnit> &TexUnits,
std::vector<std::tuple<TupleType...> > *meshes)
{
Shader::getInstance()->use();
handleSkinning(Shader::getInstance());
if (CVS->isARBBaseInstanceUsable())
glBindVertexArray(VAOManager::getInstance()->getVAO(VertexType));
for (unsigned i = 0; i < meshes->size(); i++)

4
src/graphics/glwrap.hpp
View File

@ -154,9 +154,9 @@ public:
glEnableVertexAttribArray(4);
glVertexAttribPointer(4, 4, GL_FLOAT, GL_FALSE, getVertexPitchFromType(tp), (GLvoid*)44);
glEnableVertexAttribArray(5);
glVertexAttribIPointer(5, 4, GL_INT, getVertexPitchFromType(tp), (GLvoid*)60);
glVertexAttribIPointer(5, 4, GL_SHORT, getVertexPitchFromType(tp), (GLvoid*)60);
glEnableVertexAttribArray(6);
glVertexAttribPointer(6, 4, GL_FLOAT, GL_FALSE, getVertexPitchFromType(tp), (GLvoid*)76);
glVertexAttribPointer(6, 4, GL_HALF_FLOAT, GL_FALSE, getVertexPitchFromType(tp), (GLvoid*)68);
break;
}
}

64
src/graphics/materials.cpp
View File

@ -488,6 +488,10 @@ SkinnedPass1Shader::SkinnedPass1Shader()
if (!CVS->supportsHardwareSkinning()) return;
loadProgram(SKINNED_MESH, GL_VERTEX_SHADER, "skinning.vert",
GL_FRAGMENT_SHADER, "object_pass1.frag");
if (SkinnedMeshShader* sms = dynamic_cast<SkinnedMeshShader*>(this))
{
sms->init(this);
}
assignUniforms("ModelMatrix", "InverseModelMatrix", "skinning_offset");
assignSamplerNames(0, "tex", ST_TRILINEAR_ANISOTROPIC_FILTERED);
} // SkinnedPass1Shader
@ -499,6 +503,10 @@ InstancedSkinnedPass1Shader::InstancedSkinnedPass1Shader()
loadProgram(SKINNED_MESH,
GL_VERTEX_SHADER, "instanced_skinning.vert",
GL_FRAGMENT_SHADER, "instanced_object_pass1.frag");
if (SkinnedMeshShader* sms = dynamic_cast<SkinnedMeshShader*>(this))
{
sms->init(this);
}
assignUniforms();
assignSamplerNames(0, "glosstex", ST_TRILINEAR_ANISOTROPIC_FILTERED);
} // InstancedSkinnedPass1Shader
@ -509,6 +517,10 @@ SkinnedPass2Shader::SkinnedPass2Shader()
if (!CVS->supportsHardwareSkinning()) return;
loadProgram(SKINNED_MESH, GL_VERTEX_SHADER, "skinning.vert",
GL_FRAGMENT_SHADER, "object_pass2.frag");
if (SkinnedMeshShader* sms = dynamic_cast<SkinnedMeshShader*>(this))
{
sms->init(this);
}
assignUniforms("ModelMatrix", "texture_trans", "color_change",
"skinning_offset");
assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED,
@ -527,6 +539,10 @@ InstancedSkinnedPass2Shader::InstancedSkinnedPass2Shader()
loadProgram(SKINNED_MESH,
GL_VERTEX_SHADER, "instanced_skinning.vert",
GL_FRAGMENT_SHADER, "instanced_object_pass2.frag");
if (SkinnedMeshShader* sms = dynamic_cast<SkinnedMeshShader*>(this))
{
sms->init(this);
}
assignUniforms();
assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED,
1, "SpecularMap", ST_NEAREST_FILTERED,
@ -543,6 +559,10 @@ SkinnedRefPass1Shader::SkinnedRefPass1Shader()
if (!CVS->supportsHardwareSkinning()) return;
loadProgram(SKINNED_MESH, GL_VERTEX_SHADER, "skinning.vert",
GL_FRAGMENT_SHADER, "objectref_pass1.frag");
if (SkinnedMeshShader* sms = dynamic_cast<SkinnedMeshShader*>(this))
{
sms->init(this);
}
assignUniforms("ModelMatrix", "InverseModelMatrix", "texture_trans",
"skinning_offset");
assignSamplerNames(0, "tex", ST_TRILINEAR_ANISOTROPIC_FILTERED,
@ -556,6 +576,10 @@ InstancedSkinnedRefPass1Shader::InstancedSkinnedRefPass1Shader()
loadProgram(SKINNED_MESH,
GL_VERTEX_SHADER, "instanced_skinning.vert",
GL_FRAGMENT_SHADER, "instanced_objectref_pass1.frag");
if (SkinnedMeshShader* sms = dynamic_cast<SkinnedMeshShader*>(this))
{
sms->init(this);
}
assignUniforms();
assignSamplerNames(0, "tex", ST_TRILINEAR_ANISOTROPIC_FILTERED,
1, "glosstex", ST_TRILINEAR_ANISOTROPIC_FILTERED);
@ -567,6 +591,10 @@ SkinnedRefPass2Shader::SkinnedRefPass2Shader()
if (!CVS->supportsHardwareSkinning()) return;
loadProgram(SKINNED_MESH, GL_VERTEX_SHADER, "skinning.vert",
GL_FRAGMENT_SHADER, "objectref_pass2.frag");
if (SkinnedMeshShader* sms = dynamic_cast<SkinnedMeshShader*>(this))
{
sms->init(this);
}
assignUniforms("ModelMatrix", "texture_trans", "color_change",
"skinning_offset");
assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED,
@ -585,6 +613,10 @@ InstancedSkinnedRefPass2Shader::InstancedSkinnedRefPass2Shader()
loadProgram(SKINNED_MESH,
GL_VERTEX_SHADER, "instanced_skinning.vert",
GL_FRAGMENT_SHADER, "instanced_objectref_pass2.frag");
if (SkinnedMeshShader* sms = dynamic_cast<SkinnedMeshShader*>(this))
{
sms->init(this);
}
assignUniforms();
assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED,
1, "SpecularMap", ST_NEAREST_FILTERED,
@ -601,6 +633,10 @@ SkinnedUnlitShader::SkinnedUnlitShader()
if (!CVS->supportsHardwareSkinning()) return;
loadProgram(SKINNED_MESH, GL_VERTEX_SHADER, "skinning.vert",
GL_FRAGMENT_SHADER, "object_unlit.frag");
if (SkinnedMeshShader* sms = dynamic_cast<SkinnedMeshShader*>(this))
{
sms->init(this);
}
assignUniforms("ModelMatrix", "texture_trans", "skinning_offset");
assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED,
1, "SpecularMap", ST_NEAREST_FILTERED,
@ -615,6 +651,10 @@ InstancedSkinnedUnlitShader::InstancedSkinnedUnlitShader()
loadProgram(SKINNED_MESH,
GL_VERTEX_SHADER, "instanced_skinning.vert",
GL_FRAGMENT_SHADER, "instanced_object_unlit.frag");
if (SkinnedMeshShader* sms = dynamic_cast<SkinnedMeshShader*>(this))
{
sms->init(this);
}
assignUniforms();
assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED,
1, "SpecularMap", ST_NEAREST_FILTERED,
@ -628,6 +668,10 @@ SkinnedNormalMapShader::SkinnedNormalMapShader()
if (!CVS->supportsHardwareSkinning()) return;
loadProgram(SKINNED_MESH, GL_VERTEX_SHADER, "skinning.vert",
GL_FRAGMENT_SHADER, "normalmap.frag");
if (SkinnedMeshShader* sms = dynamic_cast<SkinnedMeshShader*>(this))
{
sms->init(this);
}
assignUniforms("ModelMatrix", "InverseModelMatrix", "skinning_offset");
assignSamplerNames(0, "normalMap", ST_TRILINEAR_ANISOTROPIC_FILTERED,
1, "glossMap", ST_TRILINEAR_ANISOTROPIC_FILTERED);
@ -639,6 +683,10 @@ InstancedSkinnedNormalMapShader::InstancedSkinnedNormalMapShader()
if (!CVS->supportsHardwareSkinning()) return;
loadProgram(SKINNED_MESH, GL_VERTEX_SHADER, "instanced_skinning.vert",
GL_FRAGMENT_SHADER, "instanced_normalmap.frag");
if (SkinnedMeshShader* sms = dynamic_cast<SkinnedMeshShader*>(this))
{
sms->init(this);
}
assignUniforms();
assignSamplerNames(0, "normalMap", ST_TRILINEAR_ANISOTROPIC_FILTERED,
1, "glossMap", ST_TRILINEAR_ANISOTROPIC_FILTERED);
@ -662,6 +710,10 @@ SkinnedShadowShader::SkinnedShadowShader()
GL_GEOMETRY_SHADER, "shadow.geom",
GL_FRAGMENT_SHADER, "shadow.frag");
}
if (SkinnedMeshShader* sms = dynamic_cast<SkinnedMeshShader*>(this))
{
sms->init(this);
}
assignUniforms("ModelMatrix", "skinning_offset", "layer");
#endif
} // SkinnedShadowShader
@ -686,6 +738,10 @@ InstancedSkinnedShadowShader::InstancedSkinnedShadowShader()
GL_GEOMETRY_SHADER, "instanced_shadow.geom",
GL_FRAGMENT_SHADER, "shadow.frag");
}
if (SkinnedMeshShader* sms = dynamic_cast<SkinnedMeshShader*>(this))
{
sms->init(this);
}
assignUniforms("layer");
#endif
} // InstancedSkinnedShadowShader
@ -708,6 +764,10 @@ SkinnedRefShadowShader::SkinnedRefShadowShader()
GL_GEOMETRY_SHADER, "shadow.geom",
GL_FRAGMENT_SHADER, "shadowref.frag");
}
if (SkinnedMeshShader* sms = dynamic_cast<SkinnedMeshShader*>(this))
{
sms->init(this);
}
assignUniforms("ModelMatrix", "skinning_offset", "layer");
assignSamplerNames(0, "tex", ST_TRILINEAR_ANISOTROPIC_FILTERED);
#endif
@ -733,6 +793,10 @@ InstancedSkinnedRefShadowShader::InstancedSkinnedRefShadowShader()
GL_GEOMETRY_SHADER, "instanced_shadow.geom",
GL_FRAGMENT_SHADER, "instanced_shadowref.frag");
}
if (SkinnedMeshShader* sms = dynamic_cast<SkinnedMeshShader*>(this))
{
sms->init(this);
}
assignUniforms("layer");
assignSamplerNames(0, "tex", ST_TRILINEAR_ANISOTROPIC_FILTERED);
#endif

48
src/graphics/materials.hpp
View File

@ -296,7 +296,8 @@ public:
// ============================================================================
class SkinnedPass1Shader : public TextureShader<SkinnedPass1Shader, 1,
core::matrix4, core::matrix4,
int>
int>,
public SkinnedMeshShader
{
public:
SkinnedPass1Shader();
@ -304,7 +305,8 @@ public:
// ============================================================================
class InstancedSkinnedPass1Shader
: public TextureShader<InstancedSkinnedPass1Shader, 1>
: public TextureShader<InstancedSkinnedPass1Shader, 1>,
public SkinnedMeshShader
{
public:
InstancedSkinnedPass1Shader();
@ -313,7 +315,8 @@ public:
// ============================================================================
class SkinnedPass2Shader : public TextureShader<SkinnedPass2Shader, 6,
core::matrix4, core::vector2df,
core::vector2df, int >
core::vector2df, int >,
public SkinnedMeshShader
{
public:
SkinnedPass2Shader();
@ -321,7 +324,8 @@ public:
// ============================================================================
class InstancedSkinnedPass2Shader
: public TextureShader<InstancedSkinnedPass2Shader, 6>
: public TextureShader<InstancedSkinnedPass2Shader, 6>,
public SkinnedMeshShader
{
public:
InstancedSkinnedPass2Shader();
@ -331,7 +335,8 @@ public:
class SkinnedRefPass1Shader : public TextureShader<SkinnedRefPass1Shader, 2,
core::matrix4,
core::matrix4,
core::vector2df, int>
core::vector2df, int>,
public SkinnedMeshShader
{
public:
SkinnedRefPass1Shader();
@ -339,7 +344,8 @@ public:
// ============================================================================
class InstancedSkinnedRefPass1Shader
: public TextureShader<InstancedSkinnedRefPass1Shader, 2>
: public TextureShader<InstancedSkinnedRefPass1Shader, 2>,
public SkinnedMeshShader
{
public:
InstancedSkinnedRefPass1Shader();
@ -349,7 +355,8 @@ public:
class SkinnedRefPass2Shader : public TextureShader<SkinnedRefPass2Shader, 6,
core::matrix4,
core::vector2df,
core::vector2df, int>
core::vector2df, int>,
public SkinnedMeshShader
{
public:
SkinnedRefPass2Shader();
@ -357,7 +364,8 @@ public:
// ============================================================================
class InstancedSkinnedRefPass2Shader
: public TextureShader<InstancedSkinnedRefPass2Shader, 6>
: public TextureShader<InstancedSkinnedRefPass2Shader, 6>,
public SkinnedMeshShader
{
public:
InstancedSkinnedRefPass2Shader();
@ -366,7 +374,8 @@ public:
// ============================================================================
class SkinnedUnlitShader : public TextureShader<SkinnedUnlitShader, 4,
core::matrix4, core::vector2df,
int>
int>,
public SkinnedMeshShader
{
public:
SkinnedUnlitShader();
@ -374,7 +383,8 @@ public:
// ============================================================================
class InstancedSkinnedUnlitShader
: public TextureShader<InstancedSkinnedUnlitShader, 4>
: public TextureShader<InstancedSkinnedUnlitShader, 4>,
public SkinnedMeshShader
{
public:
InstancedSkinnedUnlitShader();
@ -383,7 +393,8 @@ public:
// ============================================================================
class SkinnedNormalMapShader : public TextureShader<SkinnedNormalMapShader, 2,
core::matrix4,
core::matrix4, int>
core::matrix4, int>,
public SkinnedMeshShader
{
public:
SkinnedNormalMapShader();
@ -391,7 +402,8 @@ public:
// ============================================================================
class InstancedSkinnedNormalMapShader
: public TextureShader<InstancedSkinnedNormalMapShader, 2>
: public TextureShader<InstancedSkinnedNormalMapShader, 2>,
public SkinnedMeshShader
{
public:
InstancedSkinnedNormalMapShader();
@ -399,7 +411,8 @@ public:
// ============================================================================
class SkinnedShadowShader : public TextureShader<SkinnedShadowShader, 0,
core::matrix4, int, int>
core::matrix4, int, int>,
public SkinnedMeshShader
{
public:
SkinnedShadowShader();
@ -407,7 +420,8 @@ public:
// ============================================================================
class InstancedSkinnedShadowShader
: public TextureShader<InstancedSkinnedShadowShader, 0, int>
: public TextureShader<InstancedSkinnedShadowShader, 0, int>,
public SkinnedMeshShader
{
public:
InstancedSkinnedShadowShader();
@ -415,7 +429,8 @@ public:
// ============================================================================
class SkinnedRefShadowShader : public TextureShader<SkinnedRefShadowShader, 1,
core::matrix4, int, int>
core::matrix4, int, int>,
public SkinnedMeshShader
{
public:
SkinnedRefShadowShader();
@ -423,7 +438,8 @@ public:
// ============================================================================
class InstancedSkinnedRefShadowShader
: public TextureShader<InstancedSkinnedRefShadowShader, 1, int>
: public TextureShader<InstancedSkinnedRefShadowShader, 1, int>,
public SkinnedMeshShader
{
public:
InstancedSkinnedRefShadowShader();

30
src/graphics/shader.hpp
View File

@ -367,6 +367,8 @@ public:
}
} // loadProgram
// ------------------------------------------------------------------------
virtual void bindCustomTextures() {}
// ------------------------------------------------------------------------
void drawFullScreenEffect(Args...args)
{
@ -379,6 +381,34 @@ public:
}; // Shader
// ============================================================================
class SkinnedMeshShader
{
private:
GLuint m_skinning_tex_location;
public:
SkinnedMeshShader() : m_skinning_tex_location(0) {}
// ------------------------------------------------------------------------
template <typename Shader>
void init(Shader* s)
{
s->use();
m_skinning_tex_location = s->getUniformLocation("skinning_tex");
glUniform1i(m_skinning_tex_location, 15);
}
// ------------------------------------------------------------------------
void bindSkinningTexture()
{
glActiveTexture(GL_TEXTURE0 + 15);
#ifdef USE_GLES2
glBindTexture(GL_TEXTURE_2D, SharedGPUObjects::getSkinningTexture());
#else
glBindTexture(GL_TEXTURE_BUFFER,
SharedGPUObjects::getSkinningTexture());
#endif
glBindSampler(15, 0);
}
};
#endif

42
src/graphics/shader_based_renderer.cpp
View File

@ -152,39 +152,6 @@ void ShaderBasedRenderer::prepareForwardRenderer()
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
}
// ----------------------------------------------------------------------------
/** Upload lighting info to the dedicated uniform buffer
*/
void ShaderBasedRenderer::uploadLightingData() const
{
assert(CVS->isARBUniformBufferObjectUsable());
float Lighting[36];
core::vector3df sun_direction = irr_driver->getSunDirection();
video::SColorf sun_color = irr_driver->getSunColor();
Lighting[0] = sun_direction.X;
Lighting[1] = sun_direction.Y;
Lighting[2] = sun_direction.Z;
Lighting[4] = sun_color.getRed();
Lighting[5] = sun_color.getGreen();
Lighting[6] = sun_color.getBlue();
Lighting[7] = 0.54f;
const SHCoefficients* sh_coeff = m_spherical_harmonics->getCoefficients();
if(sh_coeff) {
memcpy(&Lighting[8], sh_coeff->blue_SH_coeff, 9 * sizeof(float));
memcpy(&Lighting[17], sh_coeff->green_SH_coeff, 9 * sizeof(float));
memcpy(&Lighting[26], sh_coeff->red_SH_coeff, 9 * sizeof(float));
}
glBindBuffer(GL_UNIFORM_BUFFER, SharedGPUObjects::getLightingDataUBO());
glBufferSubData(GL_UNIFORM_BUFFER, 0, 36 * sizeof(float), Lighting);
} // uploadLightingData
// ----------------------------------------------------------------------------
void ShaderBasedRenderer::computeMatrixesAndCameras(scene::ICameraSceneNode *const camnode,
unsigned int width, unsigned int height)
@ -237,8 +204,6 @@ void ShaderBasedRenderer::renderScene(scene::ICameraSceneNode * const camnode,
{
glBindBufferBase(GL_UNIFORM_BUFFER, 0, SharedGPUObjects::getViewProjectionMatricesUBO());
glBindBufferBase(GL_UNIFORM_BUFFER, 1, SharedGPUObjects::getLightingDataUBO());
if (CVS->supportsHardwareSkinning())
glBindBufferBase(GL_UNIFORM_BUFFER, 2, SharedGPUObjects::getSkinningUBO());
}
irr_driver->getSceneManager()->setActiveCamera(camnode);
@ -812,11 +777,9 @@ void ShaderBasedRenderer::render(float dt)
glEnable(GL_FRAMEBUFFER_SRGB);
#endif
PROFILER_PUSH_CPU_MARKER("UBO upload", 0x0, 0xFF, 0x0);
PROFILER_PUSH_CPU_MARKER("Update camera matrices", 0x0, 0xFF, 0x0);
computeMatrixesAndCameras(camnode, m_rtts->getWidth(), m_rtts->getHeight());
m_shadow_matrices.updateSunOrthoMatrices();
if(CVS->isARBUniformBufferObjectUsable())
uploadLightingData();
PROFILER_POP_CPU_MARKER();
renderScene(camnode, dt, track->hasShadows(), false);
@ -923,9 +886,6 @@ void ShaderBasedRenderer::renderToTexture(GL3RenderTarget *render_target,
irr_driver->getSceneManager()->setActiveCamera(camera);
computeMatrixesAndCameras(camera, m_rtts->getWidth(), m_rtts->getHeight());
if (CVS->isARBUniformBufferObjectUsable())
uploadLightingData();
renderScene(camera, dt, false, true);
render_target->setFrameBuffer(m_post_processing
->render(camera, false, m_rtts));

2
src/graphics/shader_based_renderer.hpp
View File

@ -61,8 +61,6 @@ private:
void prepareForwardRenderer();
void uploadLightingData() const;
void computeMatrixesAndCameras(scene::ICameraSceneNode * const camnode,
unsigned int width, unsigned int height);

4
src/graphics/shaders.cpp
View File

@ -277,6 +277,10 @@ Shaders::SkinnedTransparentShader::SkinnedTransparentShader()
if (!CVS->supportsHardwareSkinning()) return;
loadProgram(SKINNED_MESH, GL_VERTEX_SHADER, "skinning.vert",
GL_FRAGMENT_SHADER, "transparent.frag");
if (SkinnedMeshShader* sms = dynamic_cast<SkinnedMeshShader*>(this))
{
sms->init(this);
}
assignUniforms("ModelMatrix", "texture_trans", "skinning_offset", "custom_alpha");
assignSamplerNames(0, "tex", ST_TRILINEAR_ANISOTROPIC_FILTERED);
} // SkinnedTransparentShader

3
src/graphics/shaders.hpp
View File

@ -140,7 +140,8 @@ public:
// ========================================================================
class SkinnedTransparentShader : public TextureShader<SkinnedTransparentShader, 1,
core::matrix4, core::vector2df,
int, float >
int, float >,
public SkinnedMeshShader
{
public:
SkinnedTransparentShader();

83
src/graphics/shadow_matrices.cpp
View File

@ -26,6 +26,7 @@
#include "graphics/post_processing.hpp"
#include "graphics/rtts.hpp"
#include "graphics/shared_gpu_objects.hpp"
#include "graphics/spherical_harmonics.hpp"
#include "graphics/texture_shader.hpp"
#include "modes/world.hpp"
#include "physics/triangle_mesh.hpp"
@ -311,6 +312,55 @@ void ShadowMatrices::updateSplitAndLightcoordRangeFromComputeShaders(unsigned in
#endif
} // updateSplitAndLightcoordRangeFromComputeShaders
// ----------------------------------------------------------------------------
void ShadowMatrices::updateUBO()
{
if (!CVS->isARBUniformBufferObjectUsable())
{
return;
}
float lighting[36] = {};
core::vector3df sun_direction = irr_driver->getSunDirection();
video::SColorf sun_color = irr_driver->getSunColor();
lighting[0] = sun_direction.X;
lighting[1] = sun_direction.Y;
lighting[2] = sun_direction.Z;
lighting[4] = sun_color.getRed();
lighting[5] = sun_color.getGreen();
lighting[6] = sun_color.getBlue();
lighting[7] = 0.54f;
const SHCoefficients* sh_coeff = irr_driver->getSHCoefficients();
if (sh_coeff)
{
memcpy(&lighting[8], sh_coeff->blue_SH_coeff, 9 * sizeof(float));
memcpy(&lighting[17], sh_coeff->green_SH_coeff, 9 * sizeof(float));
memcpy(&lighting[26], sh_coeff->red_SH_coeff, 9 * sizeof(float));
}
glBindBuffer(GL_UNIFORM_BUFFER, SharedGPUObjects::getLightingDataUBO());
void* ptr = glMapBufferRange(GL_UNIFORM_BUFFER, 0, 36 * 4,
GL_MAP_WRITE_BIT | GL_MAP_UNSYNCHRONIZED_BIT |
GL_MAP_INVALIDATE_BUFFER_BIT);
memcpy(ptr, lighting, 36 * 4);
glUnmapBuffer(GL_UNIFORM_BUFFER);
if (CVS->isSDSMEnabled())
{
return;
}
glBindBuffer(GL_UNIFORM_BUFFER,
SharedGPUObjects::getViewProjectionMatricesUBO());
ptr = glMapBufferRange(GL_UNIFORM_BUFFER, 0, (16 * 9 + 2) * 4,
GL_MAP_WRITE_BIT | GL_MAP_UNSYNCHRONIZED_BIT |
GL_MAP_INVALIDATE_BUFFER_BIT);
memcpy(ptr, m_ubo_data, (16 * 9 + 2) * 4);
glUnmapBuffer(GL_UNIFORM_BUFFER);
glBindBuffer(GL_UNIFORM_BUFFER, 0);
} // updateUBO
// ----------------------------------------------------------------------------
/** Generate View, Projection, Inverse View, Inverse Projection, ViewProjection
* and InverseProjection matrixes and matrixes and cameras for the four shadow
@ -338,12 +388,11 @@ void ShadowMatrices::computeMatrixesAndCameras(scene::ICameraSceneNode *const ca
const float oldfar = camnode->getFarValue();
const float oldnear = camnode->getNearValue();
float tmp[16 * 9 + 2];
memcpy(tmp, irr_driver->getViewMatrix().pointer(), 16 * sizeof(float));
memcpy(&tmp[16], irr_driver->getProjMatrix().pointer(), 16 * sizeof(float));
memcpy(&tmp[32], irr_driver->getInvViewMatrix().pointer(), 16 * sizeof(float));
memcpy(&tmp[48], irr_driver->getInvProjMatrix().pointer(), 16 * sizeof(float));
memcpy(&tmp[64], irr_driver->getProjViewMatrix().pointer(), 16 * sizeof(float));
memcpy(m_ubo_data, irr_driver->getViewMatrix().pointer(), 16 * sizeof(float));
memcpy(&m_ubo_data[16], irr_driver->getProjMatrix().pointer(), 16 * sizeof(float));
memcpy(&m_ubo_data[32], irr_driver->getInvViewMatrix().pointer(), 16 * sizeof(float));
memcpy(&m_ubo_data[48], irr_driver->getInvProjMatrix().pointer(), 16 * sizeof(float));
memcpy(&m_ubo_data[64], irr_driver->getProjViewMatrix().pointer(), 16 * sizeof(float));
m_sun_cam->render();
for (unsigned i = 0; i < 4; i++)
@ -469,27 +518,23 @@ void ShadowMatrices::computeMatrixesAndCameras(scene::ICameraSceneNode *const ca
size_t size = m_sun_ortho_matrices.size();
for (unsigned i = 0; i < size; i++)
memcpy(&tmp[16 * i + 80],
memcpy(&m_ubo_data[16 * i + 80],
m_sun_ortho_matrices[i].pointer(),
16 * sizeof(float));
}
if(!CVS->isARBUniformBufferObjectUsable())
return;
tmp[144] = float(width);
tmp[145] = float(height);
glBindBuffer(GL_UNIFORM_BUFFER,
SharedGPUObjects::getViewProjectionMatricesUBO());
m_ubo_data[144] = float(width);
m_ubo_data[145] = float(height);
if (CVS->isSDSMEnabled())
{
glBufferSubData(GL_UNIFORM_BUFFER, 0, (16 * 5) * sizeof(float), tmp);
glBindBuffer(GL_UNIFORM_BUFFER,
SharedGPUObjects::getViewProjectionMatricesUBO());
glBufferSubData(GL_UNIFORM_BUFFER, 0, (16 * 5) * sizeof(float),
m_ubo_data);
glBufferSubData(GL_UNIFORM_BUFFER, (16 * 9) * sizeof(float),
2 * sizeof(float), &tmp[144]);
2 * sizeof(float), &m_ubo_data[144]);
glBindBuffer(GL_UNIFORM_BUFFER, 0);
}
else
glBufferSubData(GL_UNIFORM_BUFFER, 0, (16 * 9 + 2) * sizeof(float),
tmp);
} // computeMatrixesAndCameras
// ----------------------------------------------------------------------------

2
src/graphics/shadow_matrices.hpp
View File

@ -49,6 +49,7 @@ private:
core::matrix4 m_rsm_matrix;
bool m_rsm_matrix_initialized;
float m_shadows_cam[4][24];
float m_ubo_data[16 * 9 + 2];
bool m_rsm_map_available;
core::vector3df m_rh_extend;
core::matrix4 m_rh_matrix;
@ -104,6 +105,7 @@ public:
return m_shadow_scales;
}
// ------------------------------------------------------------------------
void updateUBO();
}; // class ShadowMatrices

49
src/graphics/shared_gpu_objects.cpp
View File

@ -33,7 +33,8 @@ GLuint SharedGPUObjects::m_full_screen_quad_vao;
GLuint SharedGPUObjects::m_ui_vao;
GLuint SharedGPUObjects::m_quad_buffer;
GLuint SharedGPUObjects::m_quad_vbo;
GLuint SharedGPUObjects::m_skinning_ubo;
GLuint SharedGPUObjects::m_skinning_tex;
GLuint SharedGPUObjects::m_skinning_buf;
int SharedGPUObjects::m_max_mat4_size = 1024;
bool SharedGPUObjects::m_has_been_initialised = false;
@ -158,24 +159,29 @@ void SharedGPUObjects::initLightingDataUBO()
} // initLightingDataUBO
// ----------------------------------------------------------------------------
void SharedGPUObjects::initSkinningUBO()
void SharedGPUObjects::initSkinning()
{
assert(CVS->isARBUniformBufferObjectUsable());
irr::core::matrix4 m;
glGenBuffers(1, &m_skinning_ubo);
glBindBuffer(GL_UNIFORM_BUFFER, m_skinning_ubo);
int max_size = 0;
glGetIntegerv(GL_MAX_UNIFORM_BLOCK_SIZE, &max_size);
max_size = std::min(max_size, 65536);
m_max_mat4_size = max_size / 16 / sizeof(float);
Log::info("SharedGPUObjects", "Hardware skinning supported, max joints"
" support: %d", m_max_mat4_size);
glBufferData(GL_UNIFORM_BUFFER, max_size, 0, GL_STREAM_DRAW);
// Reserve a identity matrix for non moving mesh in animated model used by
// vertex shader calculation
glBufferSubData(GL_UNIFORM_BUFFER, 0, 16 * sizeof(float), m.pointer());
glBindBuffer(GL_UNIFORM_BUFFER, 0);
} // initSkinningUBO
m_max_mat4_size = 1024;
glGenTextures(1, &m_skinning_tex);
#ifdef USE_GLES2
glBindTexture(GL_TEXTURE_2D, m_skinning_tex);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, 16, 1024, 0, GL_RGBA, GL_FLOAT,
NULL);
glBindTexture(GL_TEXTURE_2D, 0);
#else
glGenBuffers(1, &m_skinning_buf);
glBindBuffer(GL_TEXTURE_BUFFER, m_skinning_buf);
glBufferData(GL_TEXTURE_BUFFER, 65536, NULL, GL_DYNAMIC_DRAW);
glBindTexture(GL_TEXTURE_BUFFER, m_skinning_tex);
glTexBuffer(GL_TEXTURE_BUFFER, GL_RGBA32F, m_skinning_buf);
glBindTexture(GL_TEXTURE_BUFFER, 0);
glBindBuffer(GL_TEXTURE_BUFFER, 0);
#endif
} // initSkinningTBO
// ----------------------------------------------------------------------------
void SharedGPUObjects::init()
@ -186,13 +192,14 @@ void SharedGPUObjects::init()
initQuadBuffer();
initSkyTriVBO();
initFrustrumVBO();
if (CVS->supportsHardwareSkinning())
{
initSkinning();
}
if (CVS->isARBUniformBufferObjectUsable())
{
initShadowVPMUBO();
initLightingDataUBO();
if (CVS->supportsHardwareSkinning())
initSkinningUBO();
}
m_has_been_initialised = true;

17
src/graphics/shared_gpu_objects.hpp
View File

@ -35,7 +35,8 @@ private:
static GLuint m_ui_vao;
static GLuint m_quad_buffer;
static GLuint m_quad_vbo;
static GLuint m_skinning_ubo;
static GLuint m_skinning_tex;
static GLuint m_skinning_buf;
static int m_max_mat4_size;
static void initQuadVBO();
@ -44,7 +45,7 @@ private:
static void initFrustrumVBO();
static void initShadowVPMUBO();
static void initLightingDataUBO();
static void initSkinningUBO();
static void initSkinning();
public:
static void init();
@ -104,11 +105,17 @@ public:
return m_quad_vbo;
} // getQuadVBO
// ------------------------------------------------------------------------
static GLuint getSkinningUBO()
static GLuint getSkinningTexture()
{
assert(m_has_been_initialised);
return m_skinning_ubo;
} // getSkinningUBO
return m_skinning_tex;
} // getSkinningTex
// ------------------------------------------------------------------------
static GLuint getSkinningBuffer()
{
assert(m_has_been_initialised);
return m_skinning_buf;
} // getSkinningBuffer
// ------------------------------------------------------------------------
static int getMaxMat4Size()
{

8
src/graphics/stk_animated_mesh.cpp
View File

@ -378,9 +378,13 @@ void STKAnimatedMesh::uploadJoints(const irr::core::matrix4& m,
int joint, int offset)
{
assert(offset != -1);
glBindBuffer(GL_UNIFORM_BUFFER, SharedGPUObjects::getSkinningUBO());
glBufferSubData(GL_UNIFORM_BUFFER, offset + joint * 16 * sizeof(float),
#ifdef USE_GLES2
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, (offset >> 6) + joint, 16, 1, GL_RGBA,
GL_FLOAT, m.pointer());
#else
glBufferSubData(GL_TEXTURE_BUFFER, offset + joint * 16 * sizeof(float),
16 * sizeof(float), m.pointer());
#endif
}
#endif // !SERVER_ONLY

4
src/graphics/stk_mesh.cpp
View File

@ -193,9 +193,9 @@ GLuint createVAO(GLuint vbo, GLuint idx, video::E_VERTEX_TYPE type)
glEnableVertexAttribArray(4);
glVertexAttribPointer(4, 4, GL_FLOAT, GL_FALSE, getVertexPitchFromType(type), (GLvoid*)44);
glEnableVertexAttribArray(5);
glVertexAttribIPointer(5, 4, GL_INT, getVertexPitchFromType(type), (GLvoid*)60);
glVertexAttribIPointer(5, 4, GL_SHORT, getVertexPitchFromType(type), (GLvoid*)60);
glEnableVertexAttribArray(6);
glVertexAttribPointer(6, 4, GL_FLOAT, GL_FALSE, getVertexPitchFromType(type), (GLvoid*)76);
glVertexAttribPointer(6, 4, GL_HALF_FLOAT, GL_FALSE, getVertexPitchFromType(type), (GLvoid*)68);
break;
default:
assert(0 && "Wrong vertex type");

4
src/graphics/stk_particle.cpp
View File

@ -513,6 +513,10 @@ void STKParticle::OnRegisterSceneNode()
continue;
}
scene::SParticle p;
p.startTime = 0;
p.endTime = 0;
p.color = 0;
p.startColor = 0;
p.pos = m_particles_generating[i].m_position;
Buffer->BoundingBox.addInternalPoint(p.pos);
p.size = core::dimension2df(m_particles_generating[i].m_size,

1
src/graphics/texture_shader.hpp
View File

@ -177,6 +177,7 @@ public:
template<int N, typename... TexIds>
void setTextureUnitsImpl(GLuint tex_id, TexIds... args)
{
static_assert(N != 15, "15 is reserved for skinning texture");
#if defined(USE_GLES2)
if (CVS->getGLSLVersion() >= 300)
#else