Debug: display cascade in shadow debug mode

data/shaders/sunlightshadowdebug.frag

@@ -0,0 +1,70 @@
+uniform sampler2D ntex;
+uniform sampler2D dtex;
+uniform sampler2DArrayShadow shadowtex;
+
+uniform vec3 direction;
+uniform vec3 col;
+
+layout (std140) uniform MatrixesData
+{
+    mat4 ViewMatrix;
+    mat4 ProjectionMatrix;
+    mat4 InverseViewMatrix;
+    mat4 InverseProjectionMatrix;
+    mat4 ShadowViewProjMatrixes[4];
+};
+
+
+in vec2 uv;
+out vec4 Diff;
+out vec4 Spec;
+
+vec3 DecodeNormal(vec2 n);
+vec3 getSpecular(vec3 normal, vec3 eyedir, vec3 lightdir, vec3 color, float roughness);
+
+vec3 getShadowFactor(vec3 pos, float bias)
+{
+    vec3 cascadeColor[] = vec3[](
+        vec3(1., 0., 0.),
+        vec3(0., 1., 0.),
+        vec3(0., 0., 1.),
+        vec3(1., 1., 1.)
+    );
+    for (int i = 0; i < 4; i++)
+    {
+        vec4 shadowcoord = (ShadowViewProjMatrixes[i] * vec4(pos, 1.0));
+        shadowcoord /= shadowcoord.w;
+        vec2 shadowtexcoord = shadowcoord.xy * 0.5 + 0.5;
+        if (shadowtexcoord.x < 0. || shadowtexcoord.x > 1. || shadowtexcoord.y < 0. || shadowtexcoord.y > 1.)
+            continue;
+        return cascadeColor[i] * texture(shadowtex, vec4(shadowtexcoord, float(i), 0.5 * (shadowcoord.z + bias * 0.001) + 0.5));
+    }
+    return vec3(1.);
+}
+
+void main() {
+    float z = texture(dtex, uv).x;
+    vec4 xpos = 2.0 * vec4(uv, z, 1.0) - 1.0;
+    xpos = InverseViewMatrix * InverseProjectionMatrix * xpos;
+    xpos.xyz /= xpos.w;
+
+    vec3 norm = normalize(DecodeNormal(2. * texture(ntex, uv).xy - 1.));
+    float roughness =texture(ntex, uv).z;
+    vec3 eyedir = -normalize(xpos.xyz);
+
+    // Normalized on the cpu
+    vec3 L = direction;
+
+    float NdotL = max(0., dot(norm, L));
+
+    vec3 Specular = getSpecular(norm, eyedir, L, col, roughness) * NdotL;
+    vec3 outcol = NdotL * col;
+
+    // Shadows
+    float bias = 0.002 * tan(acos(NdotL)); // According to the slope
+    bias = clamp(bias, 0.001, 0.014);
+    vec3 factor = getShadowFactor(xpos.xyz, bias);
+    Diff = vec4(factor * NdotL * col, 1.);
+    Spec = vec4(factor * Specular, 1.);
+    return;
+}

src/graphics/post_processing.cpp

@@ -289,8 +289,6 @@ void PostProcessing::renderShadowedSunlight(const std::vector<core::matrix4> &su
     glBlendFunc(GL_ONE, GL_ONE);
     glBlendEquation(GL_FUNC_ADD);
 
-    glUseProgram(FullScreenShader::ShadowedSunLightShader::Program);
-    glBindVertexArray(FullScreenShader::ShadowedSunLightShader::vao);
     setTexture(0, irr_driver->getRenderTargetTexture(RTT_NORMAL_AND_DEPTH), GL_NEAREST, GL_NEAREST);
     setTexture(1, irr_driver->getDepthStencilTexture(), GL_NEAREST, GL_NEAREST);
     glActiveTexture(GL_TEXTURE2);
@@ -301,7 +299,20 @@ void PostProcessing::renderShadowedSunlight(const std::vector<core::matrix4> &su
     glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_T, GL_REPEAT);
     glTexParameterf(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE);
     glTexParameterf(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL);
-    FullScreenShader::ShadowedSunLightShader::setUniforms(sun_ortho_matrix, cb->getPosition(), irr_driver->getInvProjMatrix(), cb->getRed(), cb->getGreen(), cb->getBlue(), 0, 1, 2);
+
+    if (irr_driver->getShadowViz())
+    {
+        glUseProgram(FullScreenShader::ShadowedSunLightDebugShader::Program);
+        glBindVertexArray(FullScreenShader::ShadowedSunLightDebugShader::vao);
+        FullScreenShader::ShadowedSunLightDebugShader::setUniforms(cb->getPosition(), irr_driver->getInvProjMatrix(), cb->getRed(), cb->getGreen(), cb->getBlue(), 0, 1, 2);
+
+    }
+    else
+    {
+        glUseProgram(FullScreenShader::ShadowedSunLightShader::Program);
+        glBindVertexArray(FullScreenShader::ShadowedSunLightShader::vao);
+        FullScreenShader::ShadowedSunLightShader::setUniforms(sun_ortho_matrix, cb->getPosition(), irr_driver->getInvProjMatrix(), cb->getRed(), cb->getGreen(), cb->getBlue(), 0, 1, 2);
+    }
     glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
     glBindVertexArray(0);
 }

src/graphics/shaders.cpp

@@ -312,6 +312,7 @@ void Shaders::loadShaders()
     FullScreenShader::SunLightShader::init();
     FullScreenShader::DiffuseEnvMapShader::init();
     FullScreenShader::ShadowedSunLightShader::init();
+    FullScreenShader::ShadowedSunLightDebugShader::init();
     FullScreenShader::MotionBlurShader::init();
     FullScreenShader::GodFadeShader::init();
     FullScreenShader::GodRayShader::init();
@@ -2190,6 +2191,41 @@ namespace FullScreenShader
         delete[] tmp;
     }
 
+    GLuint ShadowedSunLightDebugShader::Program;
+    GLuint ShadowedSunLightDebugShader::uniform_ntex;
+    GLuint ShadowedSunLightDebugShader::uniform_dtex;
+    GLuint ShadowedSunLightDebugShader::uniform_shadowtex;
+    GLuint ShadowedSunLightDebugShader::uniform_direction;
+    GLuint ShadowedSunLightDebugShader::uniform_col;
+    GLuint ShadowedSunLightDebugShader::uniform_invproj;
+    GLuint ShadowedSunLightDebugShader::vao;
+
+    void ShadowedSunLightDebugShader::init()
+    {
+        Program = LoadProgram(
+            GL_VERTEX_SHADER, file_manager->getAsset("shaders/screenquad.vert").c_str(),
+            GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/utils/decodeNormal.frag").c_str(),
+            GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/utils/getSpecular.frag").c_str(),
+            GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/sunlightshadowdebug.frag").c_str());
+        uniform_ntex = glGetUniformLocation(Program, "ntex");
+        uniform_dtex = glGetUniformLocation(Program, "dtex");
+        uniform_shadowtex = glGetUniformLocation(Program, "shadowtex");
+        uniform_direction = glGetUniformLocation(Program, "direction");
+        uniform_col = glGetUniformLocation(Program, "col");
+        uniform_invproj = glGetUniformLocation(Program, "invproj");
+        vao = createVAO(Program);
+    }
+
+    void ShadowedSunLightDebugShader::setUniforms(const core::vector3df &direction, const core::matrix4 &InvProjMatrix, float r, float g, float b, unsigned TU_ntex, unsigned TU_dtex, unsigned TU_shadowtex)
+    {
+        glUniformMatrix4fv(uniform_invproj, 1, GL_FALSE, InvProjMatrix.pointer());
+        glUniform3f(uniform_direction, direction.X, direction.Y, direction.Z);
+        glUniform3f(uniform_col, r, g, b);
+        glUniform1i(uniform_ntex, TU_ntex);
+        glUniform1i(uniform_dtex, TU_dtex);
+        glUniform1i(uniform_shadowtex, TU_shadowtex);
+    }
+
     GLuint Gaussian6HBlurShader::Program;
     GLuint Gaussian6HBlurShader::uniform_tex;
     GLuint Gaussian6HBlurShader::uniform_pixel;

src/graphics/shaders.hpp

@@ -563,6 +563,17 @@ public:
     static void setUniforms(const std::vector<core::matrix4> &shadowmat, const core::vector3df &direction, const core::matrix4 &InvProjMatrix, float r, float g, float b, unsigned TU_ntex, unsigned TU_dtex, unsigned TU_shadowtex);
 };
 
+class ShadowedSunLightDebugShader
+{
+public:
+    static GLuint Program;
+    static GLuint uniform_ntex, uniform_dtex, uniform_shadowtex, uniform_direction, uniform_col, uniform_invproj;
+    static GLuint vao;
+
+    static void init();
+    static void setUniforms(const core::vector3df &direction, const core::matrix4 &InvProjMatrix, float r, float g, float b, unsigned TU_ntex, unsigned TU_dtex, unsigned TU_shadowtex);
+};
+
 class Gaussian6HBlurShader
 {
 public: