Add shadow for instanced grass.

data/shaders/instanciedgrassshadow.vert

@@ -0,0 +1,49 @@
+layout (std140) uniform MatrixesData
+{
+    mat4 ViewMatrix;
+    mat4 ProjectionMatrix;
+    mat4 InverseViewMatrix;
+    mat4 InverseProjectionMatrix;
+    mat4 ShadowViewProjMatrixes[4];
+};
+uniform vec3 windDir;
+#if __VERSION__ >= 330
+layout(location = 0) in vec3 Position;
+layout(location = 2) in vec4 Color;
+layout(location = 3) in vec2 Texcoord;
+
+layout(location = 7) in vec3 Origin;
+layout(location = 8) in vec3 Orientation;
+layout(location = 9) in vec3 Scale;
+#else
+in vec3 Position;
+in vec2 Texcoord;
+
+in vec3 Origin;
+in vec3 Orientation;
+in vec3 Scale;
+#endif
+
+#ifdef VSLayer
+out vec2 uv;
+#else
+out vec2 tc;
+out int layerId;
+#endif
+
+mat4 getWorldMatrix(vec3 translation, vec3 rotation, vec3 scale);
+mat4 getInverseWorldMatrix(vec3 translation, vec3 rotation, vec3 scale);
+
+void main(void)
+{
+    mat4 ModelMatrix = getWorldMatrix(Origin, Orientation, Scale);
+#ifdef VSLayer
+    gl_Layer = gl_InstanceID & 3;
+    gl_Position = ShadowViewProjMatrixes[gl_Layer] * ModelMatrix * vec4(Position + windDir * Color.r, 1.);
+    uv = Texcoord;
+#else
+    layerId = gl_InstanceID & 3;
+    gl_Position = ShadowViewProjMatrixes[layerId] * ModelMatrix * vec4(Position + windDir * Color.r, 1.);
+    tc = Texcoord;
+#endif
+}

src/graphics/shaders.cpp

@@ -355,6 +355,7 @@ void Shaders::loadShaders()
     MeshShader::RefShadowShaderInstance = new MeshShader::RefShadowShader();
     MeshShader::InstancedRefShadowShaderInstance = new MeshShader::InstancedRefShadowShader();
     MeshShader::GrassShadowShaderInstance = new MeshShader::GrassShadowShader();
+    MeshShader::InstancedGrassShadowShaderInstance = new MeshShader::InstancedGrassShadowShader();
     MeshShader::SkyboxShader::init();
     MeshShader::ViewFrustrumShader::init();
     ParticleShader::FlipParticleRender::init();
@@ -1072,6 +1073,36 @@ namespace MeshShader
 
     GrassShadowShader *GrassShadowShaderInstance;
 
+    InstancedGrassShadowShader::InstancedGrassShadowShader()
+    {
+        // Geometry shader needed
+        if (irr_driver->getGLSLVersion() < 150)
+            return;
+        if (irr_driver->hasVSLayerExtension())
+        {
+            Program = LoadProgram(
+                GL_VERTEX_SHADER, file_manager->getAsset("shaders/utils/getworldmatrix.vert").c_str(),
+                GL_VERTEX_SHADER, file_manager->getAsset("shaders/instanciedgrassshadow.vert").c_str(),
+                GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/object_unlit.frag").c_str());
+        }
+        else
+        {
+            Program = LoadProgram(
+                GL_VERTEX_SHADER, file_manager->getAsset("shaders/utils/getworldmatrix.vert").c_str(),
+                GL_VERTEX_SHADER, file_manager->getAsset("shaders/instanciedgrassshadow.vert").c_str(),
+                GL_GEOMETRY_SHADER, file_manager->getAsset("shaders/shadow.geom").c_str(),
+                GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/object_unlit.frag").c_str());
+        }
+        TU_tex = 0;
+        AssignTextureUnit(Program, { { TU_tex, "tex" } });
+
+        AssignUniforms(Program, uniforms, { "windDir" });
+        GLuint uniform_ViewProjectionMatrixesUBO = glGetUniformBlockIndex(Program, "MatrixesData");
+        glUniformBlockBinding(Program, uniform_ViewProjectionMatrixesUBO, 0);
+    }
+
+    InstancedGrassShadowShader *InstancedGrassShadowShaderInstance;
+
     DisplaceMaskShader::DisplaceMaskShader()
     {
         Program = LoadProgram(

src/graphics/shaders.hpp

@@ -397,6 +397,15 @@ public:
 
 extern GrassShadowShader *GrassShadowShaderInstance;
 
+class InstancedGrassShadowShader : public ShaderHelper<core::vector3df>
+{
+public:
+    GLuint TU_tex;
+    InstancedGrassShadowShader();
+};
+
+extern InstancedGrassShadowShader *InstancedGrassShadowShaderInstance;
+
 class DisplaceMaskShader : public ShaderHelper<core::matrix4>
 {
 public:

src/graphics/stkinstancedscenenode.cpp

@@ -194,6 +194,21 @@ static void drawShadowAlphaRefTexture(GLMesh &mesh, size_t instance_count)
     glDrawElementsInstanced(ptype, count, itype, 0, 4 * instance_count);
 }
 
+static void drawShadowGrass(GLMesh &mesh, const core::vector3df &windDir, size_t instance_count)
+{
+    irr_driver->IncreaseObjectCount();
+    GLenum ptype = mesh.PrimitiveType;
+    GLenum itype = mesh.IndexType;
+    size_t count = mesh.IndexCount;
+
+    compressTexture(mesh.textures[0], true);
+    setTexture(MeshShader::InstancedGrassShadowShaderInstance->TU_tex, getTextureGLuint(mesh.textures[0]), GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true);
+    MeshShader::InstancedGrassShadowShaderInstance->setUniforms(windDir);
+
+    glBindVertexArray(mesh.vao_shadow_pass);
+    glDrawElementsInstanced(ptype, count, itype, 0, 4 * instance_count);
+}
+
 static void drawFSPMGrass(GLMesh &mesh, const core::vector3df &windDir, size_t instance_count)
 {
     irr_driver->IncreaseObjectCount();
@@ -351,6 +366,11 @@ void STKInstancedSceneNode::render()
             glUseProgram(MeshShader::InstancedRefShadowShaderInstance->Program);
         for (unsigned i = 0; i < GeometricMesh[FPSM_ALPHA_REF_TEXTURE].size(); i++)
             drawShadowAlphaRefTexture(*GeometricMesh[FPSM_ALPHA_REF_TEXTURE][i], instance_pos.size() / 9);
+
+        if (!GeometricMesh[FPSM_GRASS].empty())
+            glUseProgram(MeshShader::InstancedGrassShadowShaderInstance->Program);
+        for (unsigned i = 0; i < GeometricMesh[FPSM_GRASS].size(); i++)
+            drawShadowGrass(*GeometricMesh[FPSM_GRASS][i], windDir, instance_pos.size() / 9);
         return;
     }
 }