Allow render red or blue karts in soccer mode using shader

data/shaders/instanced_object_pass2_blue.frag

@@ -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.);
+}

data/shaders/instanced_object_pass2_red.frag

@@ -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.);
+}

data/shaders/object_pass2_blue.frag

@@ -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.);
+}

data/shaders/object_pass2_red.frag

@@ -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.);
+}

data/shaders/utils/rgb_conversion.frag

@@ -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);
+}

lib/irrlicht/include/IMesh.h

@@ -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);
 			}

src/graphics/irr_driver.cpp

@@ -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
 

src/graphics/irr_driver.hpp

@@ -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();

src/graphics/material.cpp

@@ -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;

src/graphics/material.hpp

@@ -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; }

src/graphics/render_geometry.cpp

@@ -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);

src/graphics/shaders.cpp

@@ -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()
 {

src/graphics/shaders.hpp

@@ -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

src/graphics/stk_animated_mesh.cpp

@@ -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);

src/graphics/stk_mesh.hpp

@@ -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>

src/graphics/stk_mesh_scene_node.cpp

@@ -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);

src/graphics/stk_scene_manager.cpp

@@ -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);

src/karts/kart_model.cpp

@@ -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

src/karts/kart_model.hpp

@@ -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

src/modes/soccer_world.cpp

@@ -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);
-            //difficulty, team == SOCCER_TEAM_BLUE ?
+            difficulty, team == SOCCER_TEAM_BLUE ?
-            //video::ERT_BLUE : video::ERT_RED);
+            video::ERT_BLUE : video::ERT_RED);
     new_kart->init(race_manager->getKartType(index));
     Controller *controller = NULL;