How can I fix shadow edge swimming in CSM ?

OpenGL OpenGL: Advanced Coding
1

I have successfully implement Cascaded Shadow Map and the result look very good in still shot.

But when the camera start moving , the shadow edge are start to flickering/swimming.

Right now I just want to fix the translation case first since my game is a 2.5d fighting game that doesn’t have much camera rotation.

After sometime of research on the Internet I found out the way to fix this issue in “Shadows & Decals: D3D10 Techniques in Frostbite (GDC’09)”.

http://www.slideshare.net/repii/02-g-d-c09-shadow-and-decals-frostbite-final3flat

They said you should “round light space translation to even texel increments” with the given code


float f = viewSize/(float)shadowMapSize;
translation.x = round(translation.x/f)*f;
translation.y = round(translation.x/f)*f;

My question is

  1. What is viewSize ? Is it the size of the frustum of selected slice (but why ignore the second dimension) ?

  2. is “translation” a fragment position after transform in to light space (the one you use to do shadow look up) ?

  3. where should I apply this fix (I guess it must be fragment shader) ?

2

ShaderX6: Stable Rendering of Cascaded Shadow Maps (Michal Valient) has a good description.

Basically, pick a world-space point as your “quantization origin”, project it to shadow space, and then subtract from it that shadow space position rounded to the nearest texel. This “correction” offset can be appended to the shadow matrix (used for shadow projection). Essentially this keeps the quantization origin on the corner of a shadow texel, effectively making your shadow map march along in one shadow texel increments.

Beware getting your quantization origin too far from your shadow map though (floating point precision issue).

3

Haven’t read his presentation, but looks like there’s a mode where shadow texel sizes can be multiples of the base shadow map resolution.

  1. where should I apply this fix (I guess it must be fragment shader) ?

No, you can just quantize your light-space frustum (built on the CPU) using this offset, with your shader remaining oblivious. Basically, just use the offset to scoot your light-space frustum over a tiny bit in XY in light space.

4

Hi, I know it’s been about 15 years, but I’m stuck with shadow swimming too in CSM
I follow learnopengl CSM and from that I have this setup:

            std::vector<glm::vec4> GetFrustomCornersWS(const glm::mat4& projection,glm::mat4& view){
                const auto inversProjView = glm::inverse(projection*view);
                std::vector<glm::vec4> corners;
                for (unsigned int x = 0;x<2;x++) {
                    for (unsigned int y = 0;y<2;y++) {
                        for (unsigned int z = 0;z<2;z++) {
                            const glm::vec4 point = inversProjView*glm::vec4(2.0f*x-1.0f,2.0f*y-1.0f,2.0f*z-1.0f,1.0f);
                            corners.push_back(point/point.w);
                        }
                    }
                }
                return  corners;
            }
            std::vector<glm::vec4> Corners;
            glm::vec3 center = glm::vec3(0.0);
            void UpdateCenter(){
                center = glm::vec3(0.0f,0.0f,0.0f);
                for (const auto& v : Corners) {
                    center+=glm::vec3(v);
                }
                center/= Corners.size();
            }

Bind function:

float minx = std::numeric_limits<float>::max();
float maxx = std::numeric_limits<float>::lowest();
float minz = std::numeric_limits<float>::max();
float maxz = std::numeric_limits<float>::lowest();
for (const auto& v : Corners) {
    const auto trf = ShadowView*v;
    minx = std::min(minx,trf.x);
    maxx = std::max(maxx,trf.x);
    minz = std::min(minz,trf.z);
    maxz = std::max(maxz,trf.z);
}
zMultiplayer = 10.0f;
if(minz<0){
    minz *= zMultiplayer;
}else {
    minz /=zMultiplayer;
}
if(maxz<0){
    maxz /= zMultiplayer;
}else {
    maxz *=zMultiplayer;
}
float WorldUnitPerTexel = (maxx-minx) / ShadowMapReslotion;
center.x = std::round(center.x/WorldUnitPerTexel)*WorldUnitPerTexel;
center.z = std::round(center.z/WorldUnitPerTexel)*WorldUnitPerTexel;
ShadowView = glm::lookAt(center+ShadowDirection, center,up);

glm::mat4 ShadowProjection = glm::ortho(minx,maxx,minx,maxx,-maxz,-minz);

ShadowMatrix = ShadowProjection * ShadowView;
5

Can’t add links or videos of the result l: