How can I fix shadow edge swimming in CSM ?

somboon · June 28, 2011, 4:22am

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

What is viewSize ? Is it the size of the frustum of selected slice (but why ignore the second dimension) ?
is “translation” a fragment position after transform in to light space (the one you use to do shadow look up) ?
where should I apply this fix (I guess it must be fragment shader) ?

Dark_Photon · June 28, 2011, 7:06am

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).

Dark_Photon · June 28, 2011, 7:23am

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.

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.

Abdallah · August 25, 2026, 8:51am

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;

Abdallah · August 25, 2026, 8:52am

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

Abdallah · August 25, 2026, 11:34am

Got it working
from stackoverflow/ questions/33499053/cascaded-shadow-map-shimmering

#include "Graphics/ShadowMap.hpp"
#include "Core/Log.hpp"
#include "Graphics/Skybox.hpp"
#include "glm/ext/matrix_float4x4.hpp"
#include "glm/ext/matrix_transform.hpp"
#include "glm/ext/matrix_clip_space.hpp"
#include "glm/ext/vector_float3.hpp"
#include "glm/geometric.hpp"
#include <cmath>

using namespace PhantomEngine;

void ShadowMap::Init(){
    glGenFramebuffers(1,&ShadowmapFBO);
    glGenTextures(1, &ID);
    glBindTexture(GL_TEXTURE_2D, ID);
    glTexImage2D(GL_TEXTURE_2D,0,GL_DEPTH_COMPONENT,ShadowMapReslotion,ShadowMapReslotion,0,GL_DEPTH_COMPONENT,GL_FLOAT,nullptr);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP_TO_BORDER);
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP_TO_BORDER);
    float clampColor[] = {1, 1, 1, 1};
    glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, clampColor);
    glBindFramebuffer(GL_FRAMEBUFFER, ShadowmapFBO);
    glFramebufferTexture2D(GL_FRAMEBUFFER,GL_DEPTH_ATTACHMENT,GL_TEXTURE_2D,ID,0);
    glDrawBuffer(GL_NONE);
    glReadBuffer(GL_NONE);
    glBindTexture(GL_TEXTURE_2D, 0);
    glBindFramebuffer(GL_FRAMEBUFFER, 0);

}
void ShadowMap::Bind(glm::mat4& view){
    Corners = GetFrustomCornersWS(CameraProjection,view);
    UpdateCenter();
    ShadowDirection = glm::normalize(ShadowDirection);
    glm::vec3 up = glm::vec3(0,1,0);
    glm::mat4 ShadowView = glm::lookAt(center-ShadowDirection, center,up);
    float radius = glm::length(center - glm::vec3(Corners[6]));
    for (uint i = 0;i<8;i++) {
        float distance = glm::length(center-glm::vec3(Corners[i]));
        radius = glm::max(radius,distance);
    }
    radius = std::ceil(radius);
    glm::vec3 minBox = center-glm::vec3(radius);
    glm::vec3 maxBox = center+glm::vec3(radius);

    minBox = glm::vec3(ShadowView*glm::vec4(minBox,1.0f));
    maxBox = glm::vec3(ShadowView*glm::vec4(maxBox,1.0f));
    float near = minBox.z;
    float far = maxBox.z;

    glm::mat4 ShadowOrtho = glm::ortho(minBox.x,maxBox.x,minBox.y,maxBox.y,near,far);
    //shadowmatix, kinda?
    glm::mat4 SMatrix = ShadowOrtho * ShadowView;
    glm::vec4 ShadowOrigin = glm::vec4(0,0,0,1);
    ShadowOrigin = SMatrix*ShadowOrigin;
    ShadowOrigin = ShadowOrigin*(float)ShadowMapReslotion/2.0f;
    glm::vec4 roundedOrigin = glm::round(ShadowOrigin);
    glm::vec4 roundedOffset = roundedOrigin-ShadowOrigin;
    roundedOffset = roundedOffset * 2.0f/(float)ShadowMapReslotion;
    roundedOffset.z = 0;
    roundedOffset.w = 0;
    glm::mat4 ShadowProj = ShadowOrtho;
    ShadowProj[3] +=roundedOffset;
    ShadowOrtho = ShadowProj;
    ShadowMatrix = ShadowOrtho * ShadowView;
    glEnable(GL_DEPTH_TEST);
    glViewport(0,0,ShadowMapReslotion,ShadowMapReslotion);
    glBindFramebuffer(GL_FRAMEBUFFER, ShadowmapFBO);
    glClear(GL_DEPTH_BUFFER_BIT);
    glCullFace(GL_FRONT);
}
void ShadowMap::UpdatePreojection(float FOV,float Aspect){
    CameraProjection = glm::mat4(1.0f);
    CameraProjection = glm::perspective(glm::radians(FOV),Aspect, 0.01f,ShadowDistance);
}
void ShadowMap::ActiveTexture(){
    glEnable(GL_CULL_FACE);
    glCullFace(GL_BACK);
    glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
    glActiveTexture(GL_TEXTURE0+1);
    glBindTexture(GL_TEXTURE_2D, ID);
};