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

Allow render red or blue karts in soccer mode using shader

Browse Source
This commit is contained in:
Benau 2016-06-25 16:29:54 +08:00
parent d520c4477d
commit 2f217fd55b
20 changed files with 456 additions and 11 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

39
data/shaders/instanced_object_pass2_blue.frag Normal file
View File

@ -0,0 +1,39 @@
#ifndef Use_Bindless_Texture
uniform sampler2D Albedo;
uniform sampler2D SpecMap;
#endif
#ifdef Use_Bindless_Texture
flat in sampler2D handle;
flat in sampler2D secondhandle;
#endif
in vec2 uv;
in vec4 color;
out vec4 FragColor;
vec3 getLightFactor(vec3 diffuseMatColor, vec3 specularMatColor, float specMapValue, float emitMapValue);
vec3 rgbToHsv(vec3 c);
vec3 hsvToRgb(vec3 c);
void main(void)
{
#ifdef Use_Bindless_Texture
vec4 col = texture(handle, uv);
float specmap = texture(secondhandle, uv).g;
float emitmap = texture(secondhandle, uv).b;
#ifdef SRGBBindlessFix
col.xyz = pow(col.xyz, vec3(2.2));
#endif
#else
vec4 col = texture(Albedo, uv);
float specmap = texture(SpecMap, uv).g;
float emitmap = texture(SpecMap, uv).b;
#endif
vec3 old_color = rgbToHsv(col.rgb);
vec3 new_color = hsvToRgb(vec3(0.1,0.5,old_color.z));
col = vec4(new_color.b, new_color.g, new_color.r, col.a);
col.xyz *= pow(color.xyz, vec3(2.2));
FragColor = vec4(getLightFactor(col.xyz, vec3(1.), specmap, emitmap) , 1.);
}

39
data/shaders/instanced_object_pass2_red.frag Normal file
View File

@ -0,0 +1,39 @@
#ifndef Use_Bindless_Texture
uniform sampler2D Albedo;
uniform sampler2D SpecMap;
#endif
#ifdef Use_Bindless_Texture
flat in sampler2D handle;
flat in sampler2D secondhandle;
#endif
in vec2 uv;
in vec4 color;
out vec4 FragColor;
vec3 getLightFactor(vec3 diffuseMatColor, vec3 specularMatColor, float specMapValue, float emitMapValue);
vec3 rgbToHsv(vec3 c);
vec3 hsvToRgb(vec3 c);
void main(void)
{
#ifdef Use_Bindless_Texture
vec4 col = texture(handle, uv);
float specmap = texture(secondhandle, uv).g;
float emitmap = texture(secondhandle, uv).b;
#ifdef SRGBBindlessFix
col.xyz = pow(col.xyz, vec3(2.2));
#endif
#else
vec4 col = texture(Albedo, uv);
float specmap = texture(SpecMap, uv).g;
float emitmap = texture(SpecMap, uv).b;
#endif
vec3 old_color = rgbToHsv(col.rgb);
vec3 new_color = hsvToRgb(vec3(0.7,0.7,old_color.z));
col = vec4(new_color.b, new_color.g, new_color.r, col.a);
col.xyz *= pow(color.xyz, vec3(2.2));
FragColor = vec4(getLightFactor(col.xyz, vec3(1.), specmap, emitmap) , 1.);
}

35
data/shaders/object_pass2_blue.frag Normal file
View File

@ -0,0 +1,35 @@
#ifdef Use_Bindless_Texture
layout(bindless_sampler) uniform sampler2D Albedo;
layout(bindless_sampler) uniform sampler2D SpecMap;
#else
uniform sampler2D Albedo;
uniform sampler2D SpecMap;
#endif
in vec2 uv;
in vec4 color;
out vec4 FragColor;
vec3 getLightFactor(vec3 diffuseMatColor, vec3 specularMatColor, float specMapValue, float emitMapValue);
vec3 rgbToHsv(vec3 c);
vec3 hsvToRgb(vec3 c);
void main(void)
{
#ifdef Use_Bindless_Texture
vec4 col = texture(Albedo, uv);
#ifdef SRGBBindlessFix
col.xyz = pow(col.xyz, vec3(2.2));
#endif
#else
vec4 col = texture(Albedo, uv);
#endif
vec3 old_color = rgbToHsv(col.rgb);
vec3 new_color = hsvToRgb(vec3(0.1,0.5,old_color.z));
col = vec4(new_color.b, new_color.g, new_color.r, col.a);
col.xyz *= pow(color.xyz, vec3(2.2));
float specmap = texture(SpecMap, uv).g;
float emitmap = texture(SpecMap, uv).b;
FragColor = vec4(getLightFactor(col.xyz, vec3(1.), specmap, emitmap), 1.);
}

35
data/shaders/object_pass2_red.frag Normal file
View File

@ -0,0 +1,35 @@
#ifdef Use_Bindless_Texture
layout(bindless_sampler) uniform sampler2D Albedo;
layout(bindless_sampler) uniform sampler2D SpecMap;
#else
uniform sampler2D Albedo;
uniform sampler2D SpecMap;
#endif
in vec2 uv;
in vec4 color;
out vec4 FragColor;
vec3 getLightFactor(vec3 diffuseMatColor, vec3 specularMatColor, float specMapValue, float emitMapValue);
vec3 rgbToHsv(vec3 c);
vec3 hsvToRgb(vec3 c);
void main(void)
{
#ifdef Use_Bindless_Texture
vec4 col = texture(Albedo, uv);
#ifdef SRGBBindlessFix
col.xyz = pow(col.xyz, vec3(2.2));
#endif
#else
vec4 col = texture(Albedo, uv);
#endif
vec3 old_color = rgbToHsv(col.rgb);
vec3 new_color = hsvToRgb(vec3(0.7,0.7,old_color.z));
col = vec4(new_color.b, new_color.g, new_color.r, col.a);
col.xyz *= pow(color.xyz, vec3(2.2));
float specmap = texture(SpecMap, uv).g;
float emitmap = texture(SpecMap, uv).b;
FragColor = vec4(getLightFactor(col.xyz, vec3(1.), specmap, emitmap), 1.);
}

17
data/shaders/utils/rgb_conversion.frag Normal file
View File

@ -0,0 +1,17 @@
vec3 rgbToHsv(vec3 c)
{
vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
vec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g));
vec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r));
float d = q.x - min(q.w, q.y);
float e = 1.0e-10;
return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);
}
vec3 hsvToRgb(vec3 c)
{
vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
}

6
lib/irrlicht/include/IMesh.h
View File

@ -81,15 +81,15 @@ namespace scene
//! Set the mesh to use a specific render type (mainly karts in STK)
/** \param t New render type for the mesh.
\param effective_buffer Mesh buffer numbers which are effected by new render type,
\param affected_buffers Mesh buffer numbers which are effected by new render type,
if not given all mesh buffers are affected. */
void setMeshRenderType(video::E_RENDER_TYPE t, const std::vector<int>& effective_buffer = std::vector<int>())
void setMeshRenderType(video::E_RENDER_TYPE t, const std::vector<int>& affected_buffers = std::vector<int>())
{
if (t == video::ERT_DEFAULT) return;
setCustomRenderType(true);
for (int i = 0; i < int(getMeshBufferCount()); i++)
{
if (!effective_buffer.empty() && std::find(effective_buffer.begin(), effective_buffer.end(), i) == effective_buffer.end())
if (!affected_buffers.empty() && std::find(affected_buffers.begin(), affected_buffers.end(), i) == affected_buffers.end())
continue;
getMeshBuffer(i)->setRenderType(t);
}

4
src/graphics/irr_driver.cpp
View File

@ -1015,7 +1015,7 @@ scene::IMesh *IrrDriver::getMesh(const std::string &filename)
*/
scene::IAnimatedMesh *IrrDriver::copyAnimatedMesh(scene::IAnimatedMesh *orig,
video::E_RENDER_TYPE rt,
const std::vector<int>& effective_buffer)
const std::vector<int>& affected_buffers)
{
using namespace scene;
CSkinnedMesh *mesh = dynamic_cast<CSkinnedMesh*>(orig);
@ -1026,7 +1026,7 @@ scene::IAnimatedMesh *IrrDriver::copyAnimatedMesh(scene::IAnimatedMesh *orig,
}
scene::IAnimatedMesh* out = mesh->clone();
out->setMeshRenderType(rt, effective_buffer);
out->setMeshRenderType(rt, affected_buffers);
return out;
} // copyAnimatedMesh

2
src/graphics/irr_driver.hpp
View File

@ -355,7 +355,7 @@ public:
scene::IMesh *getMesh(const std::string &name);
scene::IAnimatedMesh *copyAnimatedMesh(scene::IAnimatedMesh *orig,
video::E_RENDER_TYPE rt,
const std::vector<int>& effective_buffer = std::vector<int>());
const std::vector<int>& affected_buffers = std::vector<int>());
video::ITexture *applyMask(video::ITexture* texture,
const std::string& mask_path);
void displayFPS();

2
src/graphics/material.cpp
View File

@ -140,6 +140,7 @@ Material::Material(const XMLNode *node, bool deprecated)
node->get("slowdown-time", &m_slowdown_time );
node->get("backface-culling", &m_backface_culling );
node->get("disable-z-write", &m_disable_z_write );
node->get("colorizable", &m_colorizable );
node->get("fog", &m_fog );
node->get("mask", &m_mask );
@ -434,6 +435,7 @@ void Material::init()
m_mirror_axis_when_reverse = ' ';
m_collision_reaction = NORMAL;
m_disable_z_write = false;
m_colorizable = false;
m_water_shader_speed_1 = 6.6667f;
m_water_shader_speed_2 = 4.0f;
m_fog = true;

9
src/graphics/material.hpp
View File

@ -47,6 +47,8 @@ public:
enum ShaderType
{
SHADERTYPE_SOLID,
SHADERTYPE_SOLID_RED,
SHADERTYPE_SOLID_BLUE,
SHADERTYPE_ALPHA_TEST,
SHADERTYPE_ALPHA_BLEND,
SHADERTYPE_ADDITIVE,
@ -175,6 +177,9 @@ private:
/** Set to true to disable writing to the Z buffer. Usually to be used with alpha blending */
bool m_disable_z_write;
/** True if this material can be colorized (like red/blue in team game). */
bool m_colorizable;
/** Some textures need to be pre-multiplied, some divided to give
* the intended effect. */
//enum {ADJ_NONE, ADJ_PREMUL, ADJ_DIV}
@ -283,6 +288,10 @@ public:
* is driving on it. */
bool isDriveReset () const { return m_drive_reset; }
// ------------------------------------------------------------------------
/** Returns if this material can be colorized (like red/blue in team game).
*/
bool isColorizable () const { return m_colorizable; }
// ------------------------------------------------------------------------
/** Returns if this material should trigger a rescue if a kart
* crashes against it. */
CollisionReaction getCollisionReaction() const { return m_collision_reaction; }

128
src/graphics/render_geometry.cpp
View File

@ -149,6 +149,46 @@ public:
} // InstancedObjectPass2Shader
}; // InstancedObjectPass2Shader
// ============================================================================
class InstancedObjectPass2ShaderRed : public TextureShader<InstancedObjectPass2ShaderRed, 5>
{
public:
InstancedObjectPass2ShaderRed()
{
loadProgram(OBJECT, GL_VERTEX_SHADER, "utils/getworldmatrix.vert",
GL_VERTEX_SHADER, "instanced_object_pass.vert",
GL_FRAGMENT_SHADER, "utils/getLightFactor.frag",
GL_FRAGMENT_SHADER, "utils/rgb_conversion.frag",
GL_FRAGMENT_SHADER, "instanced_object_pass2_red.frag");
assignUniforms();
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);
} // InstancedObjectPass2ShaderRed
}; // InstancedObjectPass2ShaderRed
// ============================================================================
class InstancedObjectPass2ShaderBlue : public TextureShader<InstancedObjectPass2ShaderBlue, 5>
{
public:
InstancedObjectPass2ShaderBlue()
{
loadProgram(OBJECT, GL_VERTEX_SHADER, "utils/getworldmatrix.vert",
GL_VERTEX_SHADER, "instanced_object_pass.vert",
GL_FRAGMENT_SHADER, "utils/getLightFactor.frag",
GL_FRAGMENT_SHADER, "utils/rgb_conversion.frag",
GL_FRAGMENT_SHADER, "instanced_object_pass2_blue.frag");
assignUniforms();
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);
} // InstancedObjectPass2ShaderBlue
}; // InstancedObjectPass2ShaderBlue
// ============================================================================
class InstancedObjectRefPass2Shader : public TextureShader<InstancedObjectRefPass2Shader, 5>
{
@ -542,6 +582,66 @@ const STK::Tuple<size_t, size_t> DefaultMaterial::SecondPassTextures
const STK::Tuple<> DefaultMaterial::ShadowTextures;
const STK::Tuple<size_t> DefaultMaterial::RSMTextures = STK::Tuple<size_t>(0);
// ============================================================================
struct RedMaterial
{
typedef InstancedObjectPass1Shader InstancedFirstPassShader;
typedef InstancedObjectPass2ShaderRed InstancedSecondPassShader;
typedef InstancedShadowShader InstancedShadowPassShader;
typedef CInstancedRSMShader InstancedRSMShader;
typedef ListInstancedMatRed InstancedList;
typedef Shaders::ObjectPass1Shader FirstPassShader;
typedef Shaders::ObjectPass2ShaderRed SecondPassShader;
typedef ShadowShader ShadowPassShader;
typedef CRSMShader RSMShader;
typedef ListMatRed List;
static const enum video::E_VERTEX_TYPE VertexType = video::EVT_STANDARD;
static const enum Material::ShaderType MaterialType
= Material::SHADERTYPE_SOLID_RED;
static const enum InstanceType Instance = InstanceTypeDualTex;
static const STK::Tuple<size_t> FirstPassTextures;
static const STK::Tuple<size_t, size_t> SecondPassTextures;
static const STK::Tuple<> ShadowTextures;
static const STK::Tuple<size_t> RSMTextures;
}; // struct RedMaterial
const STK::Tuple<size_t> RedMaterial::FirstPassTextures
= STK::Tuple<size_t>(1);
const STK::Tuple<size_t, size_t> RedMaterial::SecondPassTextures
= STK::Tuple<size_t, size_t>(0, 1);
const STK::Tuple<> RedMaterial::ShadowTextures;
const STK::Tuple<size_t> RedMaterial::RSMTextures = STK::Tuple<size_t>(0);
// ============================================================================
struct BlueMaterial
{
typedef InstancedObjectPass1Shader InstancedFirstPassShader;
typedef InstancedObjectPass2ShaderBlue InstancedSecondPassShader;
typedef InstancedShadowShader InstancedShadowPassShader;
typedef CInstancedRSMShader InstancedRSMShader;
typedef ListInstancedMatBlue InstancedList;
typedef Shaders::ObjectPass1Shader FirstPassShader;
typedef Shaders::ObjectPass2ShaderBlue SecondPassShader;
typedef ShadowShader ShadowPassShader;
typedef CRSMShader RSMShader;
typedef ListMatBlue List;
static const enum video::E_VERTEX_TYPE VertexType = video::EVT_STANDARD;
static const enum Material::ShaderType MaterialType
= Material::SHADERTYPE_SOLID_BLUE;
static const enum InstanceType Instance = InstanceTypeDualTex;
static const STK::Tuple<size_t> FirstPassTextures;
static const STK::Tuple<size_t, size_t> SecondPassTextures;
static const STK::Tuple<> ShadowTextures;
static const STK::Tuple<size_t> RSMTextures;
}; // struct BlueMaterial
const STK::Tuple<size_t> BlueMaterial::FirstPassTextures
= STK::Tuple<size_t>(1);
const STK::Tuple<size_t, size_t> BlueMaterial::SecondPassTextures
= STK::Tuple<size_t, size_t>(0, 1);
const STK::Tuple<> BlueMaterial::ShadowTextures;
const STK::Tuple<size_t> BlueMaterial::RSMTextures = STK::Tuple<size_t>(0);
// ----------------------------------------------------------------------------
struct AlphaRef
{
@ -1187,6 +1287,8 @@ void IrrDriver::renderSolidFirstPass()
ImmediateDrawList::getInstance()->at(i)->render();
renderMeshes1stPass<DefaultMaterial, 2, 1>();
renderMeshes1stPass<RedMaterial, 2, 1>();
renderMeshes1stPass<BlueMaterial, 2, 1>();
renderMeshes1stPass<SplattingMat, 2, 1>();
renderMeshes1stPass<UnlitMat, 3, 2, 1>();
renderMeshes1stPass<AlphaRef, 3, 2, 1>();
@ -1198,6 +1300,8 @@ void IrrDriver::renderSolidFirstPass()
if (CVS->isAZDOEnabled())
{
multidraw1stPass<DefaultMaterial>();
multidraw1stPass<RedMaterial>();
multidraw1stPass<BlueMaterial>();
multidraw1stPass<AlphaRef>();
multidraw1stPass<SphereMap>();
multidraw1stPass<UnlitMat>();
@ -1209,6 +1313,8 @@ void IrrDriver::renderSolidFirstPass()
else if (CVS->supportsIndirectInstancingRendering())
{
renderInstancedMeshes1stPass<DefaultMaterial>();
renderInstancedMeshes1stPass<RedMaterial>();
renderInstancedMeshes1stPass<BlueMaterial>();
renderInstancedMeshes1stPass<AlphaRef>();
renderInstancedMeshes1stPass<UnlitMat>();
renderInstancedMeshes1stPass<SphereMap>();
@ -1351,6 +1457,8 @@ void IrrDriver::renderSolidSecondPass()
m_rtts->getRenderTarget(RTT_HALF1_R));
renderMeshes2ndPass<DefaultMaterial, 3, 1>(createVector<uint64_t>(DiffuseHandle, SpecularHandle, SSAOHandle), DiffSpecSSAOTex);
renderMeshes2ndPass<RedMaterial, 3, 1>(createVector<uint64_t>(DiffuseHandle, SpecularHandle, SSAOHandle), DiffSpecSSAOTex);
renderMeshes2ndPass<BlueMaterial, 3, 1>(createVector<uint64_t>(DiffuseHandle, SpecularHandle, SSAOHandle), DiffSpecSSAOTex);
renderMeshes2ndPass<AlphaRef, 3, 1 >(createVector<uint64_t>(DiffuseHandle, SpecularHandle, SSAOHandle), DiffSpecSSAOTex);
renderMeshes2ndPass<UnlitMat, 3, 1>(createVector<uint64_t>(DiffuseHandle, SpecularHandle, SSAOHandle), DiffSpecSSAOTex);
renderMeshes2ndPass<SplattingMat, 1>(createVector<uint64_t>(DiffuseHandle, SpecularHandle, SSAOHandle), DiffSpecSSAOTex);
@ -1362,6 +1470,8 @@ void IrrDriver::renderSolidSecondPass()
if (CVS->isAZDOEnabled())
{
multidraw2ndPass<DefaultMaterial>(createVector<uint64_t>(DiffuseHandle, SpecularHandle, SSAOHandle, 0, 0));
multidraw2ndPass<RedMaterial>(createVector<uint64_t>(DiffuseHandle, SpecularHandle, SSAOHandle, 0, 0));
multidraw2ndPass<BlueMaterial>(createVector<uint64_t>(DiffuseHandle, SpecularHandle, SSAOHandle, 0, 0));
multidraw2ndPass<AlphaRef>(createVector<uint64_t>(DiffuseHandle, SpecularHandle, SSAOHandle, 0, 0));
multidraw2ndPass<SphereMap>(createVector<uint64_t>(DiffuseHandle, SpecularHandle, SSAOHandle, 0));
multidraw2ndPass<UnlitMat>(createVector<uint64_t>(DiffuseHandle, SpecularHandle, SSAOHandle, 0));
@ -1392,6 +1502,8 @@ void IrrDriver::renderSolidSecondPass()
else if (CVS->supportsIndirectInstancingRendering())
{
renderInstancedMeshes2ndPass<DefaultMaterial>(DiffSpecSSAOTex);
renderInstancedMeshes2ndPass<RedMaterial>(DiffSpecSSAOTex);
renderInstancedMeshes2ndPass<BlueMaterial>(DiffSpecSSAOTex);
renderInstancedMeshes2ndPass<AlphaRef>(DiffSpecSSAOTex);
renderInstancedMeshes2ndPass<UnlitMat>(DiffSpecSSAOTex);
renderInstancedMeshes2ndPass<SphereMap>(DiffSpecSSAOTex);
@ -1459,6 +1571,8 @@ void IrrDriver::renderNormalsVisualisation()
{
if (CVS->isAZDOEnabled()) {
renderMultiMeshNormals<DefaultMaterial>();
renderMultiMeshNormals<RedMaterial>();
renderMultiMeshNormals<BlueMaterial>();
renderMultiMeshNormals<AlphaRef>();
renderMultiMeshNormals<UnlitMat>();
renderMultiMeshNormals<SphereMap>();
@ -1468,6 +1582,8 @@ void IrrDriver::renderNormalsVisualisation()
else if (CVS->supportsIndirectInstancingRendering())
{
renderInstancedMeshNormals<DefaultMaterial>();
renderInstancedMeshNormals<RedMaterial>();
renderInstancedMeshNormals<BlueMaterial>();
renderInstancedMeshNormals<AlphaRef>();
renderInstancedMeshNormals<UnlitMat>();
renderInstancedMeshNormals<SphereMap>();
@ -1777,6 +1893,8 @@ void IrrDriver::renderShadows()
ScopedGPUTimer Timer(getGPUTimer(Q_SHADOWS_CASCADE0 + cascade));
renderShadow<DefaultMaterial, 1>(cascade);
renderShadow<RedMaterial, 1>(cascade);
renderShadow<BlueMaterial, 1>(cascade);
renderShadow<SphereMap, 1>(cascade);
renderShadow<DetailMat, 1>(cascade);
renderShadow<SplattingMat, 1>(cascade);
@ -1791,6 +1909,8 @@ void IrrDriver::renderShadows()
if (CVS->isAZDOEnabled())
{
multidrawShadow<DefaultMaterial>(cascade);
multidrawShadow<RedMaterial>(cascade);
multidrawShadow<BlueMaterial>(cascade);
multidrawShadow<DetailMat>(cascade);
multidrawShadow<NormalMat>(cascade);
multidrawShadow<AlphaRef>(cascade);
@ -1800,6 +1920,8 @@ void IrrDriver::renderShadows()
else if (CVS->supportsIndirectInstancingRendering())
{
renderInstancedShadow<DefaultMaterial>(cascade);
renderInstancedShadow<RedMaterial>(cascade);
renderInstancedShadow<BlueMaterial>(cascade);
renderInstancedShadow<DetailMat>(cascade);
renderInstancedShadow<AlphaRef>(cascade);
renderInstancedShadow<UnlitMat>(cascade);
@ -1932,6 +2054,8 @@ void IrrDriver::renderRSM()
const core::matrix4 &rsm_matrix = getShadowMatrices()->getRSMMatrix();
drawRSM<DefaultMaterial, 3, 1>(rsm_matrix);
drawRSM<RedMaterial, 3, 1>(rsm_matrix);
drawRSM<BlueMaterial, 3, 1>(rsm_matrix);
drawRSM<AlphaRef, 3, 1>(rsm_matrix);
drawRSM<NormalMat, 3, 1>(rsm_matrix);
drawRSM<UnlitMat, 3, 1>(rsm_matrix);
@ -1945,6 +2069,8 @@ void IrrDriver::renderRSM()
if (CVS->isAZDOEnabled())
{
multidrawRSM<DefaultMaterial>(rsm_matrix);
multidrawRSM<RedMaterial>(rsm_matrix);
multidrawRSM<BlueMaterial>(rsm_matrix);
multidrawRSM<NormalMat>(rsm_matrix);
multidrawRSM<AlphaRef>(rsm_matrix);
multidrawRSM<UnlitMat>(rsm_matrix);
@ -1953,6 +2079,8 @@ void IrrDriver::renderRSM()
else if (CVS->supportsIndirectInstancingRendering())
{
renderRSMShadow<DefaultMaterial>(rsm_matrix);
renderRSMShadow<RedMaterial>(rsm_matrix);
renderRSMShadow<BlueMaterial>(rsm_matrix);
renderRSMShadow<AlphaRef>(rsm_matrix);
renderRSMShadow<UnlitMat>(rsm_matrix);
renderRSMShadow<NormalMat>(rsm_matrix);

32
src/graphics/shaders.cpp
View File

@ -349,6 +349,38 @@ Shaders::ObjectPass2Shader::ObjectPass2Shader()
4, "SpecMap", ST_TRILINEAR_ANISOTROPIC_FILTERED);
} // ObjectPass2Shader
// ============================================================================
// Solid Lit pass shaders (red version)
Shaders::ObjectPass2ShaderRed::ObjectPass2ShaderRed()
{
loadProgram(OBJECT, GL_VERTEX_SHADER, "object_pass.vert",
GL_FRAGMENT_SHADER, "utils/getLightFactor.frag",
GL_FRAGMENT_SHADER, "utils/rgb_conversion.frag",
GL_FRAGMENT_SHADER, "object_pass2_red.frag");
assignUniforms("ModelMatrix", "TextureMatrix");
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);
} // ObjectPass2ShaderRed
// ============================================================================
// Solid Lit pass shaders (blue version)
Shaders::ObjectPass2ShaderBlue::ObjectPass2ShaderBlue()
{
loadProgram(OBJECT, GL_VERTEX_SHADER, "object_pass.vert",
GL_FRAGMENT_SHADER, "utils/getLightFactor.frag",
GL_FRAGMENT_SHADER, "utils/rgb_conversion.frag",
GL_FRAGMENT_SHADER, "object_pass2_blue.frag");
assignUniforms("ModelMatrix", "TextureMatrix");
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);
} // ObjectPass2ShaderBlue
// ============================================================================
Shaders::TransparentShader::TransparentShader()
{

16
src/graphics/shaders.hpp
View File

@ -151,6 +151,22 @@ public:
}; // ObjectPass2Shader
// ========================================================================
class ObjectPass2ShaderRed : public TextureShader < ObjectPass2ShaderRed, 5,
core::matrix4, core::matrix4 >
{
public:
ObjectPass2ShaderRed();
}; // ObjectPass2ShaderRed
// ========================================================================
class ObjectPass2ShaderBlue : public TextureShader < ObjectPass2ShaderBlue, 5,
core::matrix4, core::matrix4 >
{
public:
ObjectPass2ShaderBlue();
}; // ObjectPass2ShaderBlue
// ========================================================================
}; // class Shaders

8
src/graphics/stk_animated_mesh.cpp
View File

@ -130,6 +130,14 @@ void STKAnimatedMesh::updateNoGL()
{
TransparentMesh[TM_ADDITIVE].push_back(&mesh);
}
else if (mb->getRenderType() == video::ERT_RED)
{
MeshSolidMaterial[Material::SHADERTYPE_SOLID_RED].push_back(&mesh);
}
else if (mb->getRenderType() == video::ERT_BLUE)
{
MeshSolidMaterial[Material::SHADERTYPE_SOLID_BLUE].push_back(&mesh);
}
else
{
Material::ShaderType MatType = material->getShaderType();// getMeshMaterialFromType(type, mb->getVertexType(), material);

18
src/graphics/stk_mesh.hpp
View File

@ -122,10 +122,28 @@ class ListMatDefault : public MeshList<ListMatDefault, GLMesh *, core::matrix4,
core::matrix4, core::matrix4>
{};
// ----------------------------------------------------------------------------
class ListMatRed : public MeshList<ListMatRed, GLMesh *, core::matrix4,
core::matrix4, core::matrix4>
{};
// ----------------------------------------------------------------------------
class ListMatBlue : public MeshList<ListMatBlue, GLMesh *, core::matrix4,
core::matrix4, core::matrix4>
{};
// ----------------------------------------------------------------------------
class ListInstancedMatDefault : public InstancedMeshList<ListInstancedMatDefault>
{};
// ----------------------------------------------------------------------------
class ListInstancedMatRed : public InstancedMeshList<ListInstancedMatRed>
{};
// ----------------------------------------------------------------------------
class ListInstancedMatBlue : public InstancedMeshList<ListInstancedMatBlue>
{};
// ----------------------------------------------------------------------------
class ListMatAlphaRef : public MeshList<ListMatAlphaRef, GLMesh *, core::matrix4,
core::matrix4, core::matrix4>

10
src/graphics/stk_mesh_scene_node.cpp
View File

@ -188,6 +188,16 @@ void STKMeshSceneNode::updateNoGL()
else
additive = (TranspMat == TM_ADDITIVE);
}
else if (mb->getRenderType() == video::ERT_RED)
{
if (!immediate_draw)
MeshSolidMaterial[Material::SHADERTYPE_SOLID_RED].push_back(&mesh);
}
else if (mb->getRenderType() == video::ERT_BLUE)
{
if (!immediate_draw)
MeshSolidMaterial[Material::SHADERTYPE_SOLID_BLUE].push_back(&mesh);
}
else
{
assert(!isDisplacement);

36
src/graphics/stk_scene_manager.cpp
View File

@ -331,6 +331,12 @@ handleSTKCommon(scene::ISceneNode *Node, std::vector<scene::ISceneNode *> *Immed
case Material::SHADERTYPE_SOLID:
ListMatDefault::getInstance()->SolidPass.emplace_back(mesh, ModelMatrix, InvModelMatrix, mesh->TextureMatrix);
break;
case Material::SHADERTYPE_SOLID_RED:
ListMatRed::getInstance()->SolidPass.emplace_back(mesh, ModelMatrix, InvModelMatrix, mesh->TextureMatrix);
break;
case Material::SHADERTYPE_SOLID_BLUE:
ListMatBlue::getInstance()->SolidPass.emplace_back(mesh, ModelMatrix, InvModelMatrix, mesh->TextureMatrix);
break;
case Material::SHADERTYPE_ALPHA_TEST:
ListMatAlphaRef::getInstance()->SolidPass.emplace_back(mesh, ModelMatrix, InvModelMatrix, mesh->TextureMatrix);
break;
@ -356,6 +362,12 @@ handleSTKCommon(scene::ISceneNode *Node, std::vector<scene::ISceneNode *> *Immed
case Material::SHADERTYPE_SOLID:
ListMatDefault::getInstance()->SolidPass.emplace_back(mesh, ModelMatrix, InvModelMatrix, mesh->TextureMatrix);
break;
case Material::SHADERTYPE_SOLID_RED:
ListMatRed::getInstance()->SolidPass.emplace_back(mesh, ModelMatrix, InvModelMatrix, mesh->TextureMatrix);
break;
case Material::SHADERTYPE_SOLID_BLUE:
ListMatBlue::getInstance()->SolidPass.emplace_back(mesh, ModelMatrix, InvModelMatrix, mesh->TextureMatrix);
break;
case Material::SHADERTYPE_ALPHA_TEST:
ListMatAlphaRef::getInstance()->SolidPass.emplace_back(mesh, ModelMatrix, InvModelMatrix, mesh->TextureMatrix);
break;
@ -416,6 +428,12 @@ handleSTKCommon(scene::ISceneNode *Node, std::vector<scene::ISceneNode *> *Immed
case Material::SHADERTYPE_SOLID:
ListMatDefault::getInstance()->Shadows[cascade].emplace_back(mesh, ModelMatrix, InvModelMatrix, mesh->TextureMatrix);
break;
case Material::SHADERTYPE_SOLID_RED:
ListMatRed::getInstance()->Shadows[cascade].emplace_back(mesh, ModelMatrix, InvModelMatrix, mesh->TextureMatrix);
break;
case Material::SHADERTYPE_SOLID_BLUE:
ListMatBlue::getInstance()->Shadows[cascade].emplace_back(mesh, ModelMatrix, InvModelMatrix, mesh->TextureMatrix);
break;
case Material::SHADERTYPE_ALPHA_TEST:
ListMatAlphaRef::getInstance()->Shadows[cascade].emplace_back(mesh, ModelMatrix, InvModelMatrix, mesh->TextureMatrix);
break;
@ -475,6 +493,12 @@ handleSTKCommon(scene::ISceneNode *Node, std::vector<scene::ISceneNode *> *Immed
case Material::SHADERTYPE_SOLID:
ListMatDefault::getInstance()->RSM.emplace_back(mesh, ModelMatrix, InvModelMatrix, mesh->TextureMatrix);
break;
case Material::SHADERTYPE_SOLID_RED:
ListMatRed::getInstance()->RSM.emplace_back(mesh, ModelMatrix, InvModelMatrix, mesh->TextureMatrix);
break;
case Material::SHADERTYPE_SOLID_BLUE:
ListMatBlue::getInstance()->RSM.emplace_back(mesh, ModelMatrix, InvModelMatrix, mesh->TextureMatrix);
break;
case Material::SHADERTYPE_ALPHA_TEST:
ListMatAlphaRef::getInstance()->RSM.emplace_back(mesh, ModelMatrix, InvModelMatrix, mesh->TextureMatrix);
break;
@ -573,6 +597,8 @@ void IrrDriver::PrepareDrawCalls(scene::ICameraSceneNode *camnode)
ListDisplacement::getInstance()->clear();
ListMatDefault::getInstance()->clear();
ListMatRed::getInstance()->clear();
ListMatBlue::getInstance()->clear();
ListMatAlphaRef::getInstance()->clear();
ListMatSphereMap::getInstance()->clear();
ListMatDetails::getInstance()->clear();
@ -674,6 +700,8 @@ PROFILER_POP_CPU_MARKER();
enableOpenMP = 0;
ListInstancedMatDefault::getInstance()->clear();
ListInstancedMatRed::getInstance()->clear();
ListInstancedMatBlue::getInstance()->clear();
ListInstancedMatAlphaRef::getInstance()->clear();
ListInstancedMatGrass::getInstance()->clear();
ListInstancedMatNormalMap::getInstance()->clear();
@ -703,6 +731,14 @@ PROFILER_POP_CPU_MARKER();
SolidPassCmd::getInstance()->Offset[Material::SHADERTYPE_SOLID] = current_cmd;
FillInstances(MeshForSolidPass[Material::SHADERTYPE_SOLID], ListInstancedMatDefault::getInstance()->SolidPass, InstanceBufferDualTex, CmdBuffer, offset, current_cmd, SolidPoly);
SolidPassCmd::getInstance()->Size[Material::SHADERTYPE_SOLID] = current_cmd - SolidPassCmd::getInstance()->Offset[Material::SHADERTYPE_SOLID];
// Red Material
SolidPassCmd::getInstance()->Offset[Material::SHADERTYPE_SOLID_RED] = current_cmd;
FillInstances(MeshForSolidPass[Material::SHADERTYPE_SOLID_RED], ListInstancedMatRed::getInstance()->SolidPass, InstanceBufferDualTex, CmdBuffer, offset, current_cmd, SolidPoly);
SolidPassCmd::getInstance()->Size[Material::SHADERTYPE_SOLID_RED] = current_cmd - SolidPassCmd::getInstance()->Offset[Material::SHADERTYPE_SOLID_RED];
// Blue Material
SolidPassCmd::getInstance()->Offset[Material::SHADERTYPE_SOLID_BLUE] = current_cmd;
FillInstances(MeshForSolidPass[Material::SHADERTYPE_SOLID_BLUE], ListInstancedMatBlue::getInstance()->SolidPass, InstanceBufferDualTex, CmdBuffer, offset, current_cmd, SolidPoly);
SolidPassCmd::getInstance()->Size[Material::SHADERTYPE_SOLID_BLUE] = current_cmd - SolidPassCmd::getInstance()->Offset[Material::SHADERTYPE_SOLID_BLUE];
// Alpha Ref
SolidPassCmd::getInstance()->Offset[Material::SHADERTYPE_ALPHA_TEST] = current_cmd;
FillInstances(MeshForSolidPass[Material::SHADERTYPE_ALPHA_TEST], ListInstancedMatAlphaRef::getInstance()->SolidPass, InstanceBufferDualTex, CmdBuffer, offset, current_cmd, SolidPoly);

23
src/karts/kart_model.cpp
View File

@ -27,6 +27,8 @@
#include "graphics/central_settings.hpp"
#include "graphics/irr_driver.hpp"
#include "graphics/lod_node.hpp"
#include "graphics/material.hpp"
#include "graphics/material_manager.hpp"
#include "graphics/mesh_tools.hpp"
#include "io/file_manager.hpp"
#include "io/xml_node.hpp"
@ -309,7 +311,8 @@ KartModel* KartModel::makeCopy(video::E_RENDER_TYPE rt)
km->m_kart_height = m_kart_height;
km->m_kart_highest_point= m_kart_highest_point;
km->m_kart_lowest_point = m_kart_lowest_point;
km->m_mesh = irr_driver->copyAnimatedMesh(m_mesh, rt);
km->m_mesh = irr_driver->copyAnimatedMesh
(m_mesh, rt, getColorizableParts(m_mesh));
km->m_model_filename = m_model_filename;
km->m_animation_speed = m_animation_speed;
km->m_current_animation = AF_DEFAULT;
@ -982,6 +985,7 @@ void KartModel::update(float dt, float distance, float steer, float speed,
m_animated_node->setCurrentFrame(frame);
} // update
//-----------------------------------------------------------------------------
void KartModel::attachHat()
{
@ -1016,4 +1020,19 @@ void KartModel::attachHat()
m_hat_node->setRotation(inv.getRotationDegrees());
} // if bone
} // if(m_hat_name)
}
} // attachHat
//-----------------------------------------------------------------------------
std::vector<int> KartModel::getColorizableParts(scene::IAnimatedMesh* m)
{
std::vector<int> colorizable_parts;
for (int i = 0; i < int(m->getMeshBufferCount()); ++i)
{
scene::IMeshBuffer* mb = m->getMeshBuffer(i);
Material* material = material_manager->getMaterialFor(mb
->getMaterial().getTexture(0), mb);
if (material->isColorizable())
colorizable_parts.push_back(i);
}
return colorizable_parts;
} // getColorizableParts

2
src/karts/kart_model.hpp
View File

@ -328,6 +328,8 @@ public:
scene::IAnimatedMeshSceneNode* getAnimatedNode(){ return m_animated_node; }
// ------------------------------------------------------------------------
core::vector3df getHatOffset() { return m_hat_offset; }
// ------------------------------------------------------------------------
std::vector<int> getColorizableParts(scene::IAnimatedMesh* m);
}; // KartModel
#endif

6
src/modes/soccer_world.cpp
View File

@ -388,9 +388,9 @@ AbstractKart *SoccerWorld::createKart(const std::string &kart_ident, int index,
m_kart_position_map[index] = (unsigned)(pos_index - 1);
AbstractKart *new_kart = new Kart(kart_ident, index, position, init_pos,
difficulty);
//difficulty, team == SOCCER_TEAM_BLUE ?
//video::ERT_BLUE : video::ERT_RED);
//difficulty);
difficulty, team == SOCCER_TEAM_BLUE ?
video::ERT_BLUE : video::ERT_RED);
new_kart->init(race_manager->getKartType(index));
Controller *controller = NULL;