定向光影映射问题

Question

所以我一直在尝试使用定向光在我的引擎中重新实现阴影贴图，但到目前为止我必须对我的进展进行阴影处理（看看我在那里做了什么？）。

我让它在前一段时间的提交中工作，但重构了我的引擎，我正在尝试重做一些阴影映射。 不会说我在绘制阴影方面是最好的，所以我想我会尝试寻求帮助。

基本上我的问题似乎源于光空间矩阵的计算（似乎很多人都有同样的问题）。 最初我有一个硬编码的投影矩阵和简单的视图矩阵，用于像这样的光

    void ZLight::UpdateLightspaceMatrix()
    {
        // …
       if (type == ZLightType::Directional) {
           auto lightDir = glm::normalize(glm::eulerAngles(Orientation()));
           glm::mat4 lightV = glm::lookAt(lightDir, glm::vec3(0.f), WORLD_UP);
           glm::mat4 lightP = glm::ortho(-50.f, 50.f, -50.f, 50.f, -100.f, 100.f);
           lightspaceMatrix_ = lightP * lightV;
       }
        // …
    }

然后，它未经修改地作为着色器制服传递，我将其乘以顶点世界空间位置。 几个月前这是可行的，但最近我对引擎进行了重构，它不再显示任何内容。 output 到阴影 map 看起来像这样

而且我的场景没有显示任何阴影，至少在重要的地方没有

除此之外，经过数小时的关于如何为在任何给定时间包含场景内容的灯光实现动态平截头体的帖子和文章搜索后，我还实现了一个简单的解决方案，该解决方案基于将相机的平截头体转换为光空间，使用NDC立方体并用逆相机VP矩阵对其进行变换，并从结果中计算一个边界框，将其传递给glm::ortho以制作光的投影矩阵

    void ZLight::UpdateLightspaceMatrix()
    {
        static std::vector <glm::vec4> ndcCube = {
            glm::vec4{ -1.0f, -1.0f, -1.0f, 1.0f },
            glm::vec4{ 1.0f, -1.0f, -1.0f, 1.0f },
            glm::vec4{ -1.0f, 1.0f, -1.0f, 1.0f },
            glm::vec4{ 1.0f, 1.0f, -1.0f, 1.0f },
            glm::vec4{ -1.0f, -1.0f, 1.0f, 1.0f },
            glm::vec4{ 1.0f, -1.0f, 1.0f, 1.0f },
            glm::vec4{ -1.0f, 1.0f, 1.0f, 1.0f },
            glm::vec4{ 1.0f, 1.0f, 1.0f, 1.0f }
        };
        if (type == ZLightType::Directional) {
            auto activeCamera = Scene()->ActiveCamera();
    
            auto lightDir = normalize(glm::eulerAngles(Orientation()));
            glm::mat4 lightV = glm::lookAt(lightDir, glm::vec3(0.f), WORLD_UP);
    
            lightspaceRegion_ = ZAABBox();
            for (const auto& corner : ndcCube) {
                auto invVPMatrix = glm::inverse(activeCamera->ProjectionMatrix() * activeCamera->ViewMatrix());
                auto transformedCorner = lightV * invVPMatrix * corner;
                transformedCorner /= transformedCorner.w;
                lightspaceRegion_.minimum.x = glm::min(lightspaceRegion_.minimum.x, transformedCorner.x);
                lightspaceRegion_.minimum.y = glm::min(lightspaceRegion_.minimum.y, transformedCorner.y);
                lightspaceRegion_.minimum.z = glm::min(lightspaceRegion_.minimum.z, transformedCorner.z);
                lightspaceRegion_.maximum.x = glm::max(lightspaceRegion_.maximum.x, transformedCorner.x);
                lightspaceRegion_.maximum.y = glm::max(lightspaceRegion_.maximum.y, transformedCorner.y);
                lightspaceRegion_.maximum.z = glm::max(lightspaceRegion_.maximum.z, transformedCorner.z);
            }
    
            glm::mat4 lightP = glm::ortho(lightspaceRegion_.minimum.x, lightspaceRegion_.maximum.x,
                lightspaceRegion_.minimum.y, lightspaceRegion_.maximum.y,
                -lightspaceRegion_.maximum.z, -lightspaceRegion_.minimum.z);
    
            lightspaceMatrix_ = lightP * lightV;
        }
    }

结果在我的场景中是相同的 output（任何地方都没有阴影）和以下阴影 map

我一遍又一遍地检查了光空间矩阵的计算，并尝试了数十次调整值，包括使用 glm::lookAt function 的各种 lightV 矩阵，但我从未得到所需的 output。

如需更多参考，这是我的阴影顶点着色器

    #version 450 core
    
    #include "Shaders/common.glsl" //! #include "../common.glsl"
    
    layout (location = 0) in vec3 position;
    layout (location = 5) in ivec4 boneIDs;
    layout (location = 6) in vec4 boneWeights;
    layout (location = 7) in mat4 instanceM;
    
    uniform mat4 P_lightSpace;
    uniform mat4 M;
    uniform mat4 Bones[MAX_BONES];
    uniform bool rigged = false;
    uniform bool instanced = false;
    
    void main()
    {
    vec4 pos = vec4(position, 1.0);
       if (rigged) {
        mat4 boneTransform = Bones[boneIDs[0]] * boneWeights[0];
     boneTransform += Bones[boneIDs[1]] * boneWeights[1];
     boneTransform += Bones[boneIDs[2]] * boneWeights[2];
     boneTransform += Bones[boneIDs[3]] * boneWeights[3];
    
           pos = boneTransform * pos;
       }
    
       gl_Position = P_lightSpace * (instanced ? instanceM : M) * pos;
    }

我的软阴影实现

    float PCFShadow(VertexOutput vout, sampler2D shadowMap) {
     vec3 projCoords = vout.FragPosLightSpace.xyz / vout.FragPosLightSpace.w;
     if (projCoords.z > 1.0)
       return 0.0;
    
     projCoords = projCoords * 0.5 + 0.5;
    
     // PCF
     float shadow = 0.0;
     float bias = max(0.05 * (1.0 - dot(vout.FragNormal, vout.FragPosLightSpace.xyz - vout.FragPos.xzy)), 0.005);  
     for (int i = 0; i < 4; ++i) {
       float z = texture(shadowMap, projCoords.xy + poissonDisk[i]).r;
       shadow += z < (projCoords.z - bias) ? 1.0 : 0.0;
     }
     return shadow / 4;
    }
    ...
    ...
    float shadow = PCFShadow(vout, shadowSampler0);
    vec3 color = (ambient + (1.0 - shadow) * (diffuse + specular)) + materials[materialIndex].emission;
    FragColor = vec4(color, albd.a);

和我的相机视图和投影矩阵吸气剂

    glm::mat4 ZCamera::ProjectionMatrix()
    {
       glm::mat4 projectionMatrix(1.f);
    
       auto scene = Scene();
       if (!scene) return projectionMatrix;
    
       if (cameraType_ == ZCameraType::Orthographic)
       {
           float zoomInverse_ = 1.f / (2.f * zoom_);
           glm::vec2 resolution = scene->Domain()->Resolution();
           float left = -((float)resolution.x * zoomInverse_);
           float right = -left;
           float bottom = -((float)resolution.y * zoomInverse_);
           float top = -bottom;
           projectionMatrix = glm::ortho(left, right, bottom, top, -farClippingPlane_, farClippingPlane_);
       }
       else
       {
           projectionMatrix = glm::perspective(glm::radians(zoom_),
               (float)scene->Domain()->Aspect(),
               nearClippingPlane_, farClippingPlane_);
       }
       return projectionMatrix;
    }
    
    glm::mat4 ZCamera::ViewMatrix()
    {
       return glm::lookAt(Position(), Position() + Front(), Up());
    }

一直在尝试各种小的变化，但我仍然没有得到正确的阴影。 不知道我在这里做错了什么。 我得到的最接近的方法是在光空间矩阵计算中将 lightspaceRegion_ 边界缩放 10 倍（仅在 X 和 Y 中），但阴影仍然没有接近正确的地方。

摄像机近端和远端剪裁平面设置为合理的值（分别为 0.01 和 100.0），摄像机缩放为 45.0 度， scene→Domain()→Aspect()仅返回帧缓冲区分辨率的宽度/高度纵横比。 我的影子 map 分辨率设置为 2048x2048。

在这里的任何帮助将不胜感激。 如果我遗漏了任何重要的代码或信息，请告诉我。