我试图把我的头围绕级联阴影贴图，我遇到了一个问题与近场剔除。基本上，相机后面的对象被剔除，分割的阴影也被剔除。请看下面的图片。

的数据
我找到了一种方法来解决这个问题，做glEnable(GL_DEPTH_CLAMP);之前的阴影通行证，但现在我有一些其他的问题，我们需要的远和近剪辑剔除。Sponza模型就是一个例子，看起来里面的所有东西都在阴影中结束，因为即使光线应该到达里面的物体，墙也会出现在阴影贴图中。
你们是如何处理这个问题的？
下面是我如何生成阴影贴图的投影视图矩阵

float clipRange = camera->getFarClipPlane() - camera->getNearClipPlane();
    float minZ = camera->getNearClipPlane();
    float maxZ = camera->getNearClipPlane() + clipRange;
    float range = maxZ - minZ;
    float ratio = maxZ / minZ;
    float cascadeSplitLambda = 0.95f;
    // Calculate split depths based on view camera furstum
    // Based on method presentd in https://developer.nvidia.com/gpugems/GPUGems3/gpugems3_ch10.html
    cascadeSplits.clear();
    cascadeSplitsNew.clear();
    for (int i = 0; i < SHADOW_MAP_CASCADE_COUNT; i++) {
        auto i_float = static_cast<GLfloat>(i);
        float p = (i_float + 1.f) / static_cast<float>(SHADOW_MAP_CASCADE_COUNT);
        float log = minZ * std::pow(ratio, p);
        float uniform = minZ + range * p;
        float d = cascadeSplitLambda * (log - uniform) + uniform;
        GLfloat cascadeSplit = (d - camera->getNearClipPlane()) / clipRange;
        cascadeSplits.push_back(cascadeSplit);
    }

    directionalLightShadowVPMatrixes.clear();
    for (int casscadeIndex = 0; casscadeIndex < SHADOW_MAP_CASCADE_COUNT; casscadeIndex++) {
        glm::vec3 frustumCornersWS[8] = {
                glm::vec3(-1.0f, 1.0f, -1.0f),
                glm::vec3( 1.0f, 1.0f, -1.0f),
                glm::vec3( 1.0f, -1.0f, -1.0f),
                glm::vec3(-1.0f, -1.0f, -1.0f),
                glm::vec3(-1.0f, 1.0f, 1.0f),
                glm::vec3( 1.0f, 1.0f, 1.0f),
                glm::vec3( 1.0f, -1.0f, 1.0f),
                glm::vec3(-1.0f, -1.0f, 1.0f),
        };

        glm::mat4 invViewProj = glm::inverse(camera->getProjectionMatrix() * camera->getViewMatrix());
        for (unsigned int i = 0; i < 8; i++) {
            glm::vec4 inversePoint = invViewProj * glm::vec4(frustumCornersWS[i], 1.0f);
            frustumCornersWS[i] = inversePoint / inversePoint.w;

            //std::cout << "FrustumCorner oldValues" << i << " is: " << glm::to_string(frustumCornersWS[i]) << std::endl;
        }

        // TODO: Modify this if doing all 4 splits

        for (unsigned int i = 0; i < 4; i++) {
            GLfloat prevSplitDistance;
            if (casscadeIndex == 0) {
                prevSplitDistance = 0.1f / 1000.f;
            } else {
                prevSplitDistance = cascadeSplits.at(casscadeIndex - 1);
            }
            GLfloat splitDistance = cascadeSplits.at(casscadeIndex);
            glm::vec3 cornerRay = frustumCornersWS[i + 4] - frustumCornersWS[i];
            glm::vec3 nearCornerRay = cornerRay * prevSplitDistance;
            glm::vec3 farCornerRay = cornerRay * splitDistance;
            frustumCornersWS[i + 4] = frustumCornersWS[i] + farCornerRay;
            frustumCornersWS[i] = frustumCornersWS[i] + nearCornerRay;
        }

        for (unsigned int i = 0; i < 8; i++) {
           // std::cout << "FrustumCorner new values" << i << " is: " << glm::to_string(frustumCornersWS[i]) << std::endl;
        }

        // Finding frustum center by adding 8 corners and dividing by 8
        glm::vec3 frustumCenter = glm::vec3(0.0f);
        for (unsigned int i = 0; i < 8; i++) {
            frustumCenter += frustumCornersWS[i];
        }
        frustumCenter /= 8.0f;

        //std::cout << "FrustumCenter is at: " << glm::to_string(frustumCenter) << std::endl;

        // Building a sphere that encapsulates the view frustum
        GLfloat radius = 0.0f;
        for (unsigned int i = 0; i < 8; i++) {
            GLfloat distance = glm::length(frustumCornersWS[i] - frustumCenter);
            radius = glm::max(radius, distance);
        }
        radius = std::ceil(radius * 16.0f) / 16.0f;

       // std::cout << "Radius is: " << radius << std::endl;

        glm::vec3 lightDirection = frustumCenter - glm::normalize(lights.at(0)->getDirection()) * radius;
        glm::mat4 lightViewMatrix = glm::mat4(1.0f);
        lightViewMatrix = glm::lookAt(lightDirection, frustumCenter, glm::vec3(0.0f, 1.0f, 0.0f));

        glm::mat4 lightOrthoMatrix = glm::ortho(-radius, radius, -radius, radius, 0.f, 2.f * radius);

        // TODO: Maybe calculate splits like this (I believe this is in world pos)
        //std::cout << "split is: " << (camera->getNearClipPlane() + cascadeSplits.at(casscadeIndex) * clipRange) * -1.0f << std::endl;
        cascadeSplitsNew.push_back((camera->getNearClipPlane() + cascadeSplits.at(casscadeIndex) * clipRange));

        // This is used to avoid shimmering when we move the camera
        glm::mat4 shadowMatrix = lightOrthoMatrix * lightViewMatrix;
        glm::vec4 shadowOrigin = glm::vec4(0.0f, 0.0f, 0.0f, 1.0f);
        shadowOrigin = shadowMatrix * shadowOrigin;
        shadowOrigin = shadowOrigin * static_cast<GLfloat>(directionalLightShadowFrameBuffer->getResolutionX()) / 2.0f;

        glm::vec4 roundedOrigin = glm::round(shadowOrigin);
        glm::vec4 roundOffset = roundedOrigin - shadowOrigin;
        roundOffset = roundOffset * 2.0f / static_cast<GLfloat>(directionalLightShadowFrameBuffer->getResolutionX());
        roundOffset.z = 0.0f;
        roundOffset.w = 0.0f;

        glm::mat4 shadowProj = lightOrthoMatrix;
        shadowProj[3] += roundOffset;
        lightOrthoMatrix = shadowProj;

        glm::mat4 directionalLightShadowVPMatrix = lightOrthoMatrix * lightViewMatrix;
        directionalLightShadowVPMatrixes.push_back(directionalLightShadowVPMatrix);

字符集