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

Add the remaining shaders for GL3 hardware skinning

Browse Source 
Also use the same shader code for normal map shader
This commit is contained in:
Benau 2016-12-15 15:55:14 +08:00
parent 3d814d1036
commit 752d847b09
8 changed files with 315 additions and 103 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
data/shaders/normalmap.frag
View File

@ -1,9 +1,9 @@
#ifdef Use_Bindless_Texture
layout(bindless_sampler) uniform sampler2D normalMap;
layout(bindless_sampler) uniform sampler2D DiffuseForAlpha;
layout(bindless_sampler) uniform sampler2D glossMap;
#else
uniform sampler2D normalMap;
uniform sampler2D DiffuseForAlpha;
uniform sampler2D glossMap;
#endif
in vec3 tangent;
@ -17,7 +17,7 @@ void main()
{
// normal in Tangent Space
vec3 TS_normal = 2.0 * texture(normalMap, uv).rgb - 1.0;
float alpha = texture(DiffuseForAlpha, uv).a;
float gloss = texture(glossMap, uv).x;
// Because of interpolation, we need to renormalize
vec3 Frag_tangent = normalize(tangent);
vec3 Frag_normal = normalize(cross(Frag_tangent, bitangent));
@ -25,5 +25,5 @@ void main()
vec3 FragmentNormal = TS_normal.x * Frag_tangent + TS_normal.y * Frag_bitangent - TS_normal.z * Frag_normal;
EncodedNormal.xy = 0.5 * EncodeNormal(normalize(FragmentNormal)) + 0.5;
EncodedNormal.z = 1. - alpha;
EncodedNormal.z = gloss;
}

37
data/shaders/skinning_shadow.vert Normal file
View File

@ -0,0 +1,37 @@
uniform mat4 ModelMatrix;
uniform int skinning_offset;
uniform int layer;
layout(location = 0) in vec3 Position;
layout(location = 3) in vec4 Data1;
layout(location = 5) in ivec4 Joint;
layout(location = 6) in vec4 Weight;
#ifdef VSLayer
out vec2 uv;
#else
out vec2 tc;
out int layerId;
#endif
void main(void)
{
vec4 idle_position = vec4(Position, 1.);
vec4 skinned_position = vec4(0.);
for (int i = 0; i < 4; i++)
{
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;
}
#ifdef VSLayer
gl_Layer = layer;
uv = Data1.xy;
gl_Position = ShadowViewProjMatrixes[gl_Layer] * ModelMatrix * skinned_position;
#else
layerId = layer;
tc = Data1.xy;
gl_Position = ShadowViewProjMatrixes[layerId] * ModelMatrix * skinned_position;
#endif
}

51
src/graphics/draw_calls.cpp
View File

@ -318,18 +318,34 @@ void DrawCalls::handleSTKCommon(scene::ISceneNode *Node,
{
switch (Mat)
{
case Material::SHADERTYPE_SOLID:
ListMatDefault::getInstance()->SolidPass.emplace_back(mesh, ModelMatrix, InvModelMatrix, mesh->texture_trans,
(mesh->m_render_info && mesh->m_material ?
core::vector2df(mesh->m_render_info->getHue(), mesh->m_material->getColorizationFactor()) :
core::vector2df(0.0f, 0.0f)));
break;
case Material::SHADERTYPE_SOLID_SKINNED_MESH:
ListSkinnedSolid::getInstance()->SolidPass.emplace_back(mesh, ModelMatrix, InvModelMatrix, mesh->texture_trans,
(mesh->m_render_info && mesh->m_material ?
core::vector2df(mesh->m_render_info->getHue(), mesh->m_material->getColorizationFactor()) :
core::vector2df(0.0f, 0.0f)), skinning_offset);
break;
case Material::SHADERTYPE_ALPHA_TEST_SKINNED_MESH:
ListSkinnedAlphaRef::getInstance()->SolidPass.emplace_back(mesh, ModelMatrix, InvModelMatrix, mesh->texture_trans,
(mesh->m_render_info && mesh->m_material ?
core::vector2df(mesh->m_render_info->getHue(), mesh->m_material->getColorizationFactor()) :
core::vector2df(0.0f, 0.0f)), skinning_offset);
break;
case Material::SHADERTYPE_SOLID_UNLIT_SKINNED_MESH:
ListSkinnedUnlit::getInstance()->SolidPass.emplace_back(mesh, ModelMatrix, InvModelMatrix, mesh->texture_trans,
core::vector2df(0.0f, 0.0f), skinning_offset);
break;
case Material::SHADERTYPE_NORMAL_MAP_SKINNED_MESH:
ListSkinnedNormalMap::getInstance()->SolidPass.emplace_back(mesh, ModelMatrix, InvModelMatrix, mesh->texture_trans,
(mesh->m_render_info && mesh->m_material ?
core::vector2df(mesh->m_render_info->getHue(), mesh->m_material->getColorizationFactor()) :
core::vector2df(0.0f, 0.0f)), skinning_offset);
break;
case Material::SHADERTYPE_SOLID:
ListMatDefault::getInstance()->SolidPass.emplace_back(mesh, ModelMatrix, InvModelMatrix, mesh->texture_trans,
(mesh->m_render_info && mesh->m_material ?
core::vector2df(mesh->m_render_info->getHue(), mesh->m_material->getColorizationFactor()) :
core::vector2df(0.0f, 0.0f)));
break;
case Material::SHADERTYPE_ALPHA_TEST:
ListMatAlphaRef::getInstance()->SolidPass.emplace_back(mesh, ModelMatrix, InvModelMatrix, mesh->texture_trans,
(mesh->m_render_info && mesh->m_material ?
@ -399,6 +415,22 @@ void DrawCalls::handleSTKCommon(scene::ISceneNode *Node,
{
switch (Mat)
{
case Material::SHADERTYPE_SOLID_SKINNED_MESH:
ListSkinnedSolid::getInstance()->Shadows[cascade].emplace_back(mesh, ModelMatrix, InvModelMatrix, mesh->texture_trans,
core::vector2df(0.0f, 0.0f), skinning_offset);
break;
case Material::SHADERTYPE_ALPHA_TEST_SKINNED_MESH:
ListSkinnedAlphaRef::getInstance()->Shadows[cascade].emplace_back(mesh, ModelMatrix, InvModelMatrix, mesh->texture_trans,
core::vector2df(0.0f, 0.0f), skinning_offset);
break;
case Material::SHADERTYPE_SOLID_UNLIT_SKINNED_MESH:
ListSkinnedUnlit::getInstance()->Shadows[cascade].emplace_back(mesh, ModelMatrix, InvModelMatrix, mesh->texture_trans,
core::vector2df(0.0f, 0.0f), skinning_offset);
break;
case Material::SHADERTYPE_NORMAL_MAP_SKINNED_MESH:
ListSkinnedNormalMap::getInstance()->Shadows[cascade].emplace_back(mesh, ModelMatrix, InvModelMatrix, mesh->texture_trans,
core::vector2df(0.0f, 0.0f), skinning_offset);
break;
case Material::SHADERTYPE_SOLID:
ListMatDefault::getInstance()->Shadows[cascade].emplace_back(mesh, ModelMatrix, InvModelMatrix, mesh->texture_trans, core::vector2df(0.0f, 0.0f));
break;
@ -468,6 +500,12 @@ void DrawCalls::handleSTKCommon(scene::ISceneNode *Node,
{
switch (Mat)
{
// Todo: RSMs
case Material::SHADERTYPE_SOLID_SKINNED_MESH:
case Material::SHADERTYPE_ALPHA_TEST_SKINNED_MESH:
case Material::SHADERTYPE_SOLID_UNLIT_SKINNED_MESH:
case Material::SHADERTYPE_NORMAL_MAP_SKINNED_MESH:
break;
case Material::SHADERTYPE_SOLID:
ListMatDefault::getInstance()->RSM.emplace_back(mesh, ModelMatrix, InvModelMatrix, mesh->texture_trans, core::vector2df(0.0f, 0.0f));
break;
@ -719,7 +757,6 @@ void DrawCalls::renderParticlesList() const
void DrawCalls::drawIndirectSolidFirstPass() const
{
m_solid_cmd_buffer->bind();
m_solid_cmd_buffer->drawIndirectFirstPass<DefaultMaterial>();
m_solid_cmd_buffer->drawIndirectFirstPass<AlphaRef>();
m_solid_cmd_buffer->drawIndirectFirstPass<UnlitMat>();

20
src/graphics/draw_policies.cpp
View File

@ -178,7 +178,6 @@ void drawRSM(const core::matrix4 & rsm_matrix)
void GL3DrawPolicy::drawSolidFirstPass(const DrawCalls& draw_calls) const
{
renderMeshes1stPass<DefaultMaterial, 2, 1>();
renderMeshes1stPass<SkinnedSolid, 5, 2, 1>();
renderMeshes1stPass<SplattingMat, 2, 1>();
renderMeshes1stPass<UnlitMat, 3, 2, 1>();
renderMeshes1stPass<AlphaRef, 3, 2, 1>();
@ -186,6 +185,12 @@ void GL3DrawPolicy::drawSolidFirstPass(const DrawCalls& draw_calls) const
renderMeshes1stPass<NormalMat, 2, 1>();
renderMeshes1stPass<SphereMap, 2, 1>();
renderMeshes1stPass<DetailMat, 2, 1>();
if (!CVS->supportsHardwareSkinning()) return;
renderMeshes1stPass<SkinnedSolid, 5, 2, 1>();
renderMeshes1stPass<SkinnedAlphaRef, 5, 3, 2, 1>();
renderMeshes1stPass<SkinnedUnlitMat, 5, 3, 2, 1>();
renderMeshes1stPass<SkinnedNormalMat, 5, 2, 1>();
}
// ----------------------------------------------------------------------------
@ -194,7 +199,6 @@ void GL3DrawPolicy::drawSolidSecondPass (const DrawCalls& draw_calls,
const std::vector<GLuint>& prefilled_tex) const
{
renderMeshes2ndPass<DefaultMaterial, 4, 3, 1> (handles, prefilled_tex);
renderMeshes2ndPass<SkinnedSolid, 5, 4, 3, 1> (handles, prefilled_tex);
renderMeshes2ndPass<AlphaRef, 4, 3, 1> (handles, prefilled_tex);
renderMeshes2ndPass<UnlitMat, 3, 1 > (handles, prefilled_tex);
renderMeshes2ndPass<SplattingMat, 1 > (handles, prefilled_tex);
@ -202,6 +206,12 @@ void GL3DrawPolicy::drawSolidSecondPass (const DrawCalls& draw_calls,
renderMeshes2ndPass<DetailMat, 1 > (handles, prefilled_tex);
renderMeshes2ndPass<GrassMat, 4, 3, 1> (handles, prefilled_tex);
renderMeshes2ndPass<NormalMat, 4, 3, 1> (handles, prefilled_tex);
if (!CVS->supportsHardwareSkinning()) return;
renderMeshes2ndPass<SkinnedSolid, 5, 4, 3, 1> (handles, prefilled_tex);
renderMeshes2ndPass<SkinnedAlphaRef, 5, 4, 3, 1> (handles, prefilled_tex);
renderMeshes2ndPass<SkinnedUnlitMat, 5, 3, 1 > (handles, prefilled_tex);
renderMeshes2ndPass<SkinnedNormalMat, 5, 4, 3, 1> (handles, prefilled_tex);
}
// ----------------------------------------------------------------------------
@ -224,6 +234,12 @@ void GL3DrawPolicy::drawShadows(const DrawCalls& draw_calls, unsigned cascade) c
renderShadow<AlphaRef, 1>(cascade);
renderShadow<UnlitMat, 1>(cascade);
renderShadow<GrassMat, 3, 1>(cascade);
if (!CVS->supportsHardwareSkinning()) return;
renderShadow<SkinnedSolid, 5, 1>(cascade);
renderShadow<SkinnedAlphaRef, 5, 1>(cascade);
renderShadow<SkinnedUnlitMat, 5, 1>(cascade);
renderShadow<SkinnedNormalMat, 5, 1>(cascade);
}
// ----------------------------------------------------------------------------

258
src/graphics/materials.hpp
View File

@ -296,8 +296,8 @@ public:
loadProgram(OBJECT, GL_VERTEX_SHADER, "object_pass.vert",
GL_FRAGMENT_SHADER, "normalmap.frag");
assignUniforms("ModelMatrix", "InverseModelMatrix");
assignSamplerNames(1, "normalMap", ST_TRILINEAR_ANISOTROPIC_FILTERED,
0, "DiffuseForAlpha", ST_TRILINEAR_ANISOTROPIC_FILTERED);
assignSamplerNames(0, "normalMap", ST_TRILINEAR_ANISOTROPIC_FILTERED,
1, "glossMap", ST_TRILINEAR_ANISOTROPIC_FILTERED);
} // NormalMapShader
}; // NormalMapShader
@ -618,25 +618,62 @@ public:
}; // InstancedDetailedObjectPass2Shader
// ============================================================================
class InstancedSkinnedMeshPass1Shader : public TextureShader<InstancedSkinnedMeshPass1Shader, 1>
class SkinnedPass1Shader : public TextureShader<SkinnedPass1Shader, 1,
core::matrix4, core::matrix4,
int>
{
public:
InstancedSkinnedMeshPass1Shader()
SkinnedPass1Shader()
{
if (!CVS->supportsHardwareSkinning()) return;
loadProgram(OBJECT, GL_VERTEX_SHADER, "skinning.vert",
GL_FRAGMENT_SHADER, "object_pass1.frag");
assignUniforms("ModelMatrix", "InverseModelMatrix", "skinning_offset");
assignSamplerNames(0, "tex", ST_TRILINEAR_ANISOTROPIC_FILTERED);
} // SkinnedPass1Shader
}; // SkinnedPass1Shader
// ============================================================================
class InstancedSkinnedPass1Shader : public TextureShader<InstancedSkinnedPass1Shader, 1>
{
public:
InstancedSkinnedPass1Shader()
{
if (!CVS->supportsHardwareSkinning()) return;
loadProgram(OBJECT, GL_VERTEX_SHADER, "instanced_skinning.vert",
GL_FRAGMENT_SHADER, "instanced_object_pass1.frag");
assignUniforms();
assignSamplerNames(0, "glosstex", ST_TRILINEAR_ANISOTROPIC_FILTERED);
} // InstancedSkinnedMeshPass1Shader
}; // InstancedSkinnedMeshPass1Shader
} // InstancedSkinnedPass1Shader
}; // InstancedSkinnedPass1Shader
// ============================================================================
class InstancedSkinnedMeshPass2Shader : public TextureShader<InstancedSkinnedMeshPass2Shader, 6>
class SkinnedPass2Shader : public TextureShader<SkinnedPass2Shader, 6,
core::matrix4, core::vector2df,
core::vector2df, int >
{
public:
InstancedSkinnedMeshPass2Shader()
SkinnedPass2Shader()
{
if (!CVS->supportsHardwareSkinning()) return;
loadProgram(OBJECT, GL_VERTEX_SHADER, "skinning.vert",
GL_FRAGMENT_SHADER, "object_pass2.frag");
assignUniforms("ModelMatrix", "texture_trans", "color_change",
"skinning_offset");
assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED,
1, "SpecularMap", ST_NEAREST_FILTERED,
2, "SSAO", ST_BILINEAR_FILTERED,
3, "Albedo", ST_TRILINEAR_ANISOTROPIC_FILTERED,
4, "SpecMap", ST_TRILINEAR_ANISOTROPIC_FILTERED,
5, "colorization_mask", ST_TRILINEAR_ANISOTROPIC_FILTERED);
} // SkinnedPass2Shader
}; // SkinnedPass2Shader
// ============================================================================
class InstancedSkinnedPass2Shader : public TextureShader<InstancedSkinnedPass2Shader, 6>
{
public:
InstancedSkinnedPass2Shader()
{
if (!CVS->supportsHardwareSkinning()) return;
loadProgram(OBJECT, GL_VERTEX_SHADER, "instanced_skinning.vert",
@ -648,31 +685,71 @@ public:
3, "Albedo", ST_TRILINEAR_ANISOTROPIC_FILTERED,
4, "SpecMap", ST_TRILINEAR_ANISOTROPIC_FILTERED,
5, "colorization_mask", ST_TRILINEAR_ANISOTROPIC_FILTERED);
} // InstancedSkinnedMeshPass2Shader
}; // InstancedSkinnedMeshPass2Shader
} // InstancedSkinnedPass2Shader
}; // InstancedSkinnedPass2Shader
// ============================================================================
class InstancedSkinnedMeshRefPass1Shader : public TextureShader<InstancedSkinnedMeshRefPass1Shader, 2>
class SkinnedRefPass1Shader : public TextureShader<SkinnedRefPass1Shader, 2,
core::matrix4,
core::matrix4,
core::vector2df, int>
{
public:
InstancedSkinnedMeshRefPass1Shader()
SkinnedRefPass1Shader()
{
if (!CVS->supportsHardwareSkinning()) return;
loadProgram(OBJECT, GL_VERTEX_SHADER, "skinning.vert",
GL_FRAGMENT_SHADER, "objectref_pass1.frag");
assignUniforms("ModelMatrix", "InverseModelMatrix", "texture_trans",
"skinning_offset");
assignSamplerNames(0, "tex", ST_TRILINEAR_ANISOTROPIC_FILTERED,
1, "glosstex", ST_TRILINEAR_ANISOTROPIC_FILTERED);
} // SkinnedRefPass1Shader
}; // SkinnedRefPass1Shader
// ============================================================================
class InstancedSkinnedRefPass1Shader : public TextureShader<InstancedSkinnedRefPass1Shader, 2>
{
public:
InstancedSkinnedRefPass1Shader()
{
if (!CVS->supportsHardwareSkinning()) return;
loadProgram(OBJECT, GL_VERTEX_SHADER, "instanced_skinning.vert",
GL_FRAGMENT_SHADER, "instanced_objectref_pass1.frag");
assignUniforms();
assignSamplerNames(0, "tex", ST_TRILINEAR_ANISOTROPIC_FILTERED,
1, "glosstex", ST_TRILINEAR_ANISOTROPIC_FILTERED);
} // InstancedSkinnedMeshRefPass1Shader
}; // InstancedSkinnedMeshRefPass1Shader
} // InstancedSkinnedRefPass1Shader
}; // InstancedSkinnedRefPass1Shader
// ============================================================================
class InstancedSkinnedMeshRefPass2Shader : public TextureShader<InstancedSkinnedMeshRefPass2Shader, 6>
class SkinnedRefPass2Shader : public TextureShader<SkinnedRefPass2Shader, 6,
core::matrix4,
core::vector2df,
core::vector2df, int>
{
public:
InstancedSkinnedMeshRefPass2Shader()
SkinnedRefPass2Shader()
{
if (!CVS->supportsHardwareSkinning()) return;
loadProgram(OBJECT, GL_VERTEX_SHADER, "skinning.vert",
GL_FRAGMENT_SHADER, "objectref_pass2.frag");
assignUniforms("ModelMatrix", "texture_trans", "color_change",
"skinning_offset");
assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED,
1, "SpecularMap", ST_NEAREST_FILTERED,
2, "SSAO", ST_BILINEAR_FILTERED,
3, "Albedo", ST_TRILINEAR_ANISOTROPIC_FILTERED,
4, "SpecMap", ST_TRILINEAR_ANISOTROPIC_FILTERED,
5, "colorization_mask", ST_TRILINEAR_ANISOTROPIC_FILTERED);
} // SkinnedRefPass2Shader
}; // SkinnedRefPass2Shader
// ============================================================================
class InstancedSkinnedRefPass2Shader : public TextureShader<InstancedSkinnedRefPass2Shader, 6>
{
public:
InstancedSkinnedRefPass2Shader()
{
if (!CVS->supportsHardwareSkinning()) return;
loadProgram(OBJECT, GL_VERTEX_SHADER, "instanced_skinning.vert",
@ -684,14 +761,33 @@ public:
3, "Albedo", ST_TRILINEAR_ANISOTROPIC_FILTERED,
4, "SpecMap", ST_TRILINEAR_ANISOTROPIC_FILTERED,
5, "colorization_mask", ST_TRILINEAR_ANISOTROPIC_FILTERED);
} // InstancedSkinnedMeshRefPass2Shader
}; // InstancedSkinnedMeshRefPass2Shader
} // InstancedSkinnedRefPass2Shader
}; // InstancedSkinnedRefPass2Shader
// ============================================================================
class InstancedSkinnedMeshUnlitShader : public TextureShader<InstancedSkinnedMeshUnlitShader, 4>
class SkinnedUnlitShader : public TextureShader<SkinnedUnlitShader, 4,
core::matrix4, core::vector2df,
int>
{
public:
InstancedSkinnedMeshUnlitShader()
SkinnedUnlitShader()
{
if (!CVS->supportsHardwareSkinning()) return;
loadProgram(OBJECT, GL_VERTEX_SHADER, "skinning.vert",
GL_FRAGMENT_SHADER, "object_unlit.frag");
assignUniforms("ModelMatrix", "texture_trans", "skinning_offset");
assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED,
1, "SpecularMap", ST_NEAREST_FILTERED,
2, "SSAO", ST_BILINEAR_FILTERED,
3, "tex", ST_TRILINEAR_ANISOTROPIC_FILTERED);
} // SkinnedUnlitShader
}; // SkinnedUnlitShader
// ============================================================================
class InstancedSkinnedUnlitShader : public TextureShader<InstancedSkinnedUnlitShader, 4>
{
public:
InstancedSkinnedUnlitShader()
{
if (!CVS->supportsHardwareSkinning()) return;
loadProgram(OBJECT, GL_VERTEX_SHADER, "instanced_skinning.vert",
@ -701,8 +797,25 @@ public:
1, "SpecularMap", ST_NEAREST_FILTERED,
2, "SSAO", ST_BILINEAR_FILTERED,
3, "tex", ST_TRILINEAR_ANISOTROPIC_FILTERED);
} // InstancedSkinnedMeshUnlitShader
}; // InstancedSkinnedMeshUnlitShader
} // InstancedSkinnedUnlitShader
}; // InstancedSkinnedUnlitShader
// ============================================================================
class SkinnedNormalMapShader : public TextureShader<SkinnedNormalMapShader, 2,
core::matrix4,
core::matrix4, int>
{
public:
SkinnedNormalMapShader()
{
if (!CVS->supportsHardwareSkinning()) return;
loadProgram(OBJECT, GL_VERTEX_SHADER, "skinning.vert",
GL_FRAGMENT_SHADER, "normalmap.frag");
assignUniforms("ModelMatrix", "InverseModelMatrix", "skinning_offset");
assignSamplerNames(0, "normalMap", ST_TRILINEAR_ANISOTROPIC_FILTERED,
1, "glossMap", ST_TRILINEAR_ANISOTROPIC_FILTERED);
} // SkinnedNormalMapShader
}; // SkinnedNormalMapShader
// ============================================================================
class InstancedSkinnedNormalMapShader : public TextureShader<InstancedSkinnedNormalMapShader, 2>
@ -719,6 +832,33 @@ public:
} // InstancedSkinnedNormalMapShader
}; // InstancedSkinnedNormalMapShader
// ============================================================================
class SkinnedShadowShader : public TextureShader<SkinnedShadowShader, 0,
core::matrix4, int, int>
{
public:
SkinnedShadowShader()
{
#if !defined(USE_GLES2)
// Geometry shader needed
if (CVS->getGLSLVersion() < 150 || !CVS->supportsHardwareSkinning())
return;
if (CVS->isAMDVertexShaderLayerUsable())
{
loadProgram(OBJECT, GL_VERTEX_SHADER, "skinning_shadow.vert",
GL_FRAGMENT_SHADER, "shadow.frag");
}
else
{
loadProgram(OBJECT, GL_VERTEX_SHADER, "skinning_shadow.vert",
GL_GEOMETRY_SHADER, "shadow.geom",
GL_FRAGMENT_SHADER, "shadow.frag");
}
assignUniforms("ModelMatrix", "skinning_offset", "layer");
#endif
} // SkinnedShadowShader
}; // SkinnedShadowShader
// ============================================================================
class InstancedSkinnedShadowShader : public TextureShader<InstancedSkinnedShadowShader, 0, int>
{
@ -743,9 +883,36 @@ public:
assignUniforms("layer");
#endif
} // InstancedSkinnedShadowShader
}; // InstancedSkinnedShadowShader
// ============================================================================
class SkinnedRefShadowShader : public TextureShader<SkinnedRefShadowShader, 1,
core::matrix4, int, int>
{
public:
SkinnedRefShadowShader()
{
#if !defined(USE_GLES2)
// Geometry shader needed
if (CVS->getGLSLVersion() < 150 || !CVS->supportsHardwareSkinning())
return;
if (CVS->isAMDVertexShaderLayerUsable())
{
loadProgram(OBJECT, GL_VERTEX_SHADER, "skinning_shadow.vert",
GL_FRAGMENT_SHADER, "shadowref.frag");
}
else
{
loadProgram(OBJECT, GL_VERTEX_SHADER, "skinning_shadow.vert",
GL_GEOMETRY_SHADER, "shadow.geom",
GL_FRAGMENT_SHADER, "shadowref.frag");
}
assignUniforms("ModelMatrix", "skinning_offset", "layer");
assignSamplerNames(0, "tex", ST_TRILINEAR_ANISOTROPIC_FILTERED);
#endif
} // SkinnedRefShadowShader
}; // SkinnedRefShadowShader
// ============================================================================
class InstancedSkinnedRefShadowShader : public TextureShader<InstancedSkinnedRefShadowShader,
1, int>
@ -772,18 +939,17 @@ public:
assignSamplerNames(0, "tex", ST_TRILINEAR_ANISOTROPIC_FILTERED);
#endif
} // InstancedSkinnedRefShadowShader
}; // InstancedSkinnedRefShadowShader
// ============================================================================
struct SkinnedSolid
{
typedef InstancedSkinnedMeshPass1Shader InstancedFirstPassShader;
typedef InstancedSkinnedMeshPass2Shader InstancedSecondPassShader;
typedef InstancedSkinnedPass1Shader InstancedFirstPassShader;
typedef InstancedSkinnedPass2Shader InstancedSecondPassShader;
typedef InstancedSkinnedShadowShader InstancedShadowPassShader;
typedef Shaders::SkinnedMeshPass1Shader FirstPassShader;
typedef Shaders::SkinnedMeshPass2Shader SecondPassShader;
//typedef ShadowShader ShadowPassShader;
typedef SkinnedPass1Shader FirstPassShader;
typedef SkinnedPass2Shader SecondPassShader;
typedef SkinnedShadowShader ShadowPassShader;
// Todo: RSMs
typedef ListSkinnedSolid List;
static const enum video::E_VERTEX_TYPE VertexType = video::EVT_SKINNED_MESH;
@ -799,12 +965,12 @@ struct SkinnedSolid
// ----------------------------------------------------------------------------
struct SkinnedAlphaRef
{
typedef InstancedSkinnedMeshRefPass1Shader InstancedFirstPassShader;
typedef InstancedSkinnedMeshRefPass2Shader InstancedSecondPassShader;
typedef InstancedSkinnedRefPass1Shader InstancedFirstPassShader;
typedef InstancedSkinnedRefPass2Shader InstancedSecondPassShader;
typedef InstancedSkinnedRefShadowShader InstancedShadowPassShader;
//typedef ObjectRefPass1Shader FirstPassShader;
//typedef ObjectRefPass2Shader SecondPassShader;
//typedef RefShadowShader ShadowPassShader;
typedef SkinnedRefPass1Shader FirstPassShader;
typedef SkinnedRefPass2Shader SecondPassShader;
typedef SkinnedRefShadowShader ShadowPassShader;
// Todo: RSMs
typedef ListSkinnedAlphaRef List;
static const enum video::E_VERTEX_TYPE VertexType = video::EVT_SKINNED_MESH;
@ -821,11 +987,11 @@ struct SkinnedAlphaRef
struct SkinnedNormalMat
{
typedef InstancedSkinnedNormalMapShader InstancedFirstPassShader;
typedef InstancedSkinnedMeshPass2Shader InstancedSecondPassShader;
typedef InstancedSkinnedPass2Shader InstancedSecondPassShader;
typedef InstancedSkinnedShadowShader InstancedShadowPassShader;
//typedef ObjectRefPass1Shader FirstPassShader;
//typedef ObjectRefPass2Shader SecondPassShader;
//typedef RefShadowShader ShadowPassShader;
typedef SkinnedNormalMapShader FirstPassShader;
typedef SkinnedPass2Shader SecondPassShader;
typedef SkinnedShadowShader ShadowPassShader;
// Todo: RSMs
typedef ListSkinnedNormalMap List;
static const enum video::E_VERTEX_TYPE VertexType = video::EVT_SKINNED_MESH;
@ -841,12 +1007,12 @@ struct SkinnedNormalMat
// ----------------------------------------------------------------------------
struct SkinnedUnlitMat
{
typedef InstancedSkinnedMeshRefPass1Shader InstancedFirstPassShader;
typedef InstancedSkinnedMeshUnlitShader InstancedSecondPassShader;
typedef InstancedSkinnedRefPass1Shader InstancedFirstPassShader;
typedef InstancedSkinnedUnlitShader InstancedSecondPassShader;
typedef InstancedSkinnedRefShadowShader InstancedShadowPassShader;
//typedef ObjectRefPass1Shader FirstPassShader;
//typedef ObjectRefPass2Shader SecondPassShader;
//typedef RefShadowShader ShadowPassShader;
typedef SkinnedRefPass1Shader FirstPassShader;
typedef SkinnedUnlitShader SecondPassShader;
typedef SkinnedRefShadowShader ShadowPassShader;
// Todo: RSMs
typedef ListSkinnedUnlit List;
static const enum video::E_VERTEX_TYPE VertexType = video::EVT_SKINNED_MESH;

25
src/graphics/shaders.cpp
View File

@ -361,31 +361,6 @@ Shaders::ObjectPass2Shader::ObjectPass2Shader()
5, "colorization_mask", ST_TRILINEAR_ANISOTROPIC_FILTERED);
} // ObjectPass2Shader
// ============================================================================
Shaders::SkinnedMeshPass1Shader::SkinnedMeshPass1Shader()
{
if (!CVS->supportsHardwareSkinning()) return;
loadProgram(OBJECT, GL_VERTEX_SHADER, "skinning.vert",
GL_FRAGMENT_SHADER, "object_pass1.frag");
assignUniforms("ModelMatrix", "InverseModelMatrix", "skinning_offset");
assignSamplerNames(0, "tex", ST_TRILINEAR_ANISOTROPIC_FILTERED);
} // SkinnedMeshPass1Shader
// ============================================================================
Shaders::SkinnedMeshPass2Shader::SkinnedMeshPass2Shader()
{
if (!CVS->supportsHardwareSkinning()) return;
loadProgram(OBJECT, GL_VERTEX_SHADER, "skinning.vert",
GL_FRAGMENT_SHADER, "object_pass2.frag");
assignUniforms("ModelMatrix", "texture_trans", "color_change", "skinning_offset");
assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED,
1, "SpecularMap", ST_NEAREST_FILTERED,
2, "SSAO", ST_BILINEAR_FILTERED,
3, "Albedo", ST_TRILINEAR_ANISOTROPIC_FILTERED,
4, "SpecMap", ST_TRILINEAR_ANISOTROPIC_FILTERED,
5, "colorization_mask", ST_TRILINEAR_ANISOTROPIC_FILTERED);
} // SkinnedMeshPass2Shader
// ============================================================================
Shaders::SkinnedTransparentShader::SkinnedTransparentShader()
{

18
src/graphics/shaders.hpp
View File

@ -154,24 +154,6 @@ public:
ObjectPass2Shader();
}; // ObjectPass2Shader
// ========================================================================
class SkinnedMeshPass1Shader : public TextureShader<SkinnedMeshPass1Shader, 1,
core::matrix4, core::matrix4,
int>
{
public:
SkinnedMeshPass1Shader();
}; // SkinnedMeshPass1Shader
// ========================================================================
class SkinnedMeshPass2Shader : public TextureShader < SkinnedMeshPass2Shader, 6,
core::matrix4, core::vector2df,
core::vector2df, int >
{
public:
SkinnedMeshPass2Shader();
}; // SkinnedMeshPass2Shader
// ========================================================================
class SkinnedTransparentShader : public TextureShader<SkinnedTransparentShader, 1,
core::matrix4, core::vector2df,

1
src/tracks/track_object_presentation.cpp
View File

@ -203,7 +203,6 @@ TrackObjectPresentationLibraryNode::TrackObjectPresentationLibraryNode(
}
std::string lib_node_path = lib_path + "node.xml";
std::string lib_script_file_path = lib_path + "scripting.as";
World* world = World::getWorld();
if (local_lib_node_path.size() > 0 && file_manager->fileExists(local_lib_node_path))
{