Point lighting with shadow mapping and camera moving

Question

Faced a problem when trying to create a spotlight in my scene. The problem is that my camera is moving around the scene, and because of this, there is something wrong with the lighting. In addition, I see only a black screen. I understand that I missed the transformation somewhere, or did some extra, but where - I really do not know.

Below is the code for my shaders.

Fragment shader:

#version 330 core

precision mediump float;                        // Set the default precision to medium. We don't need as high of a
                                            // precision in the fragment shader.

#define MAX_LAMPS_COUNT 8                   // Max lamps count.

uniform vec3 u_ViewPos;                     // Camera position
uniform int u_LampsCount;                   // Lamps count
uniform int u_ShadowMapWidth = 1024;        // shadow map width / default is 1024
uniform int u_ShadowMapHeight = 1024;       // shadow map height / default is 1024
uniform float brightnessThreshold = 0.5;        // brightness threshold variable
uniform float far_plane = 16;

varying mat4 v_MVMatrix;                    // Model View matrix
varying mat3 v_TBN;                         // Tangent Bitangent Normal matrix
varying vec4 v_Position;                    // Position for this fragment.
varying vec3 v_Normal;                      // Interpolated normal for this fragment.
varying vec2 v_Texture;                     // Texture coordinates.
varying float v_NormalMapping;              // Is normal mapping enabled 0 - false, 1 - true

struct Lamp {
    float ambientStrength;
    float diffuseStrength;
    float specularStrength;
    float kc; // constant term
    float kl; // linear term
    float kq; // quadratic term
    int shininess;
    vec3 lampPos; // in eye space, cameraViewMatrix * lamp world coordinates
    vec3 lampColor;
};

uniform samplerCube shadowMaps[MAX_LAMPS_COUNT];

uniform struct Mapping {
    sampler2D ambient;
    sampler2D diffuse;
    sampler2D specular;
    sampler2D normal;
} u_Mapping;

uniform Lamp u_Lamps[MAX_LAMPS_COUNT];

vec3 norm;
vec3 fragPos;
float shadow;

// output colors
layout(location = 0) out vec4 fragColor;
layout(location = 1) out vec4 fragBrightColor;

float calculateShadow(int textureIndex, vec3 lightPos) {
    // get vector between fragment position and light position
    vec3 fragToLight = fragPos - lightPos;
    // use the light to fragment vector to sample from the depth map
    float closestDepth = texture(shadowMaps[textureIndex], fragToLight).r;
    // it is currently in linear range between [0,1]. Re-transform back to original value
    closestDepth *= far_plane;
    // now get current linear depth as the length between the fragment and light position
    float currentDepth = length(fragToLight);
    // now test for shadows
    float bias = 0.05;
    float shadow = currentDepth - bias > closestDepth ? 1.0 : 0.0;
    //fragColor = vec4(vec3(closestDepth / far_plane), 1.0);  // visualization
    return shadow;
}

float calculateAttenuation(Lamp lamp) {
    float distance = length(lamp.lampPos - fragPos);
    return 1.0 / (
                    lamp.kc +
                    lamp.kl * distance +
                    lamp.kq * (distance * distance)
            );
}

vec4 toVec4(vec3 v) {
    return vec4(v, 1);
}

// The entry point for our fragment shader.
void main() {
     // Transform the vertex into eye space.
    fragPos = vec3(v_MVMatrix * v_Position);

    vec3 viewDir = normalize(u_ViewPos - fragPos);
    if (v_NormalMapping == 0) norm = vec3(normalize(v_MVMatrix * vec4(v_Normal, 0)));
    else { // using normal map if normal mapping enabled
        norm = texture2D(u_Mapping.normal, v_Texture).rgb;
        norm = normalize(norm * 2.0 - 1.0); // from [0; 1] to [-1; -1]
        norm = normalize(v_TBN * norm);
    }

    vec3 ambientResult = vec3(0, 0, 0); // result of ambient lighting for all lamps
    vec3 diffuseResult = vec3(0, 0, 0); // result of diffuse lighting for all lamps
    vec3 specularResult = vec3(0, 0, 0); // result of specular lighting for all lamps

    for (int i = 0; i brightnessThreshold) fragBrightColor = vec4(fragColor.rgb, 1.0);
    fragBrightColor = vec4(0, 0, 0, 1);
}

Vertex shader:

#version 130

uniform mat4 u_MVPMatrix;      // A constant representing the combined model/view/projection matrix.
uniform mat4 u_MVMatrix;       // A constant representing the combined model/view matrix.
uniform float u_NormalMapping;  // Normal mapping; 0 - false, 1 - true

attribute vec4 a_Position;     // Per-vertex position information we will pass in.
attribute vec3 a_Normal;       // Per-vertex normal information we will pass in.
attribute vec3 a_Tangent;      // Per-vertex tangent information we will pass in.
attribute vec3 a_Bitangent;    // Per-vertex bitangent information we will pass in.
attribute vec2 a_Texture;      // Per-vertex texture information we will pass in.

varying mat4 v_MVMatrix;       // This will be passed into the fragment shader.
varying mat3 v_TBN;            // This will be passed into the fragment shader.
varying vec4 v_Position;       // This will be passed into the fragment shader.
varying vec3 v_Normal;         // This will be passed into the fragment shader.
varying vec2 v_Texture;        // This will be passed into the fragment shader.
varying float v_NormalMapping;  // This will be passed into the fragment shader.

void main() {
    // creating TBN (tangent-bitangent-normal) matrix if normal mapping enabled
    if (u_NormalMapping == 1) {
        vec3 T = normalize(vec3(u_MVMatrix * vec4(a_Tangent, 0.0)));
        vec3 B = normalize(vec3(u_MVMatrix * vec4(a_Bitangent, 0.0)));
        vec3 N = normalize(vec3(u_MVMatrix * vec4(a_Normal, 0.0)));
        mat3 TBN = mat3(T, B, N);
        v_TBN = TBN;
    }

    // gl_Position is a special variable used to store the final position.
    // Multiply the vertex by the matrix to get the final point in normalized screen coordinates.
    gl_Position = u_MVPMatrix * a_Position;

    // sending all needed variables to fragment shader
    v_Position = a_Position;
    v_Texture = a_Texture;
    v_NormalMapping = u_NormalMapping;
    v_MVMatrix = u_MVMatrix;
    v_Normal = a_Normal;
}

Vertex shadow shader:

#version 130

attribute vec3 a_Position;
uniform mat4 u_ModelMatrix;

void main() {
    gl_Position = u_ModelMatrix * vec4(a_Position, 1.0);
}

Fragment shadow shader:

#version 330 core
in vec4 fragPos;

uniform vec3 lightPos; // cameraViewMatrix * lamp world coordinates
uniform float far_plane = 16;

void main()
{
    float lightDistance = length(fragPos.xyz - lightPos);

    // map to [0;1] range by dividing by far_plane
    lightDistance = lightDistance / far_plane;

    // write this as modified depth
    gl_FragDepth = lightDistance;
}

Geometry shadow shader:

#version 330 core
layout (triangles) in;
layout (triangle_strip, max_vertices=18) out;

uniform mat4 shadowMatrices[6];

out vec4 fragPos; // FragPos from GS (output per emitvertex)

void main() {
    for(int face = 0; face < 6; ++face) {
        gl_Layer = face; // built-in variable that specifies to which face we render.
        for(int i = 0; i < 3; ++i) // for each triangle's vertices
        {
            fragPos = gl_in[i].gl_Position;
            gl_Position = shadowMatrices[face] * fragPos;
            EmitVertex();
        }
        EndPrimitive();
    }
}

And a video demonstrating visualization shadow map: https://youtu.be/zaNXGG1qLaw

congard · Accepted Answer

The problem was solved. It was due to the fact that I considered a map of shadows in the camera space (view space), but it was necessary in the world space. Also, during the calculation of the shadow itself, it was also necessary to calculate everything in the world space.

Fragment shader:

vec3 fragToLight = vec3(model * v_Position) - lightPosWorldSpace;

or

vec3 fragToLight = vec3(model * v_Position) - vec3(inverse(view) * lightPos); (lightPos - vec4)

Fragment shadow shader:

float lightDistance = length(fragPos.xyz - lightPos);, lightPos - lamp position in world space

Point lighting with shadow mapping and camera moving

Answers (2)

Related Questions