Improvement(with code) to the shadowmaps example for cascades and stability.

[unravel-dev]

Hi i am playing around with the shadowmaps example and i have noticed several issues with the cascade splitting and stabilizing.
Cascades frustums felt off in some directions where most detailed cascade should be chosen but it wasn't.
Stabilize basically did not really stabilize anything since when rotating or moving the camera there were noticeable movement on the edges of the shadows(very noticeable when scene is static and camera moves). This new approach is based on GPU Gems 3, Chapter 10] and tries to solve that. The code can be copy pasted directly to test or you can add a checkbox to toggle between the current one and this to see the difference. I cannot make a PR since i have a fork of the repo with some local changes that is why i am posting it here. At the bottom is the whole code which is not so much.

Improved Cascade Shadow Map Calculation for Directional Lights

Summary

This PR introduces an alternative cascade shadow map (CSM) calculation for directional lights in the 16-shadowmaps example. The new method resolves shadow edge flickering when the camera moves or rotates with static geometry/lighting, and extends shadow coverage to scenes whose geometry lives far from the world origin.

Both approaches share the same high-level structure — split the camera frustum into cascades, fit an orthographic projection around each split — but they differ in several critical geometric details.

---

Key Differences

1. Light View Matrix Construction

Aspect	Old	New
Eye position	-lightDir (negative of light direction vector)	{0, 0, 0} (origin)
Look-at target	{0, 0, 0} (world origin)	lightDir (along light direction)
Up vector	Default (implicit, unhandled degeneracy)	Explicit +Y, with fallback to +Z when the light is nearly vertical (dot > 0.99)

Why it matters:

The old code places the light "eye" at -lightDir looking at the origin. This means the light view is anchored to the world origin. Because a directional light has no position (it represents parallel rays), the view matrix should only encode the light's orientation, not a position relative to any world point. The new code constructs a pure orientation-only view matrix at the origin looking along the light direction, making it independent of any particular world position. This means shadow maps remain valid regardless of how far the scene geometry is from the origin.

The explicit up-vector fallback in the new code also prevents a degenerate matrix when the light points straight down (a common sun configuration).

2. Cascade Split Calculation

Aspect	Old (splitFrustum)	New (calculateCascadeSplits)
Output format	Interleaved [near0, far0, near1, far1, ...] pairs with a small overlap factor (far = near * 1.005f)	Normalized depths [0..1] relative to clip range
Distribution	numSlices = numSplits * 2, iterates even/odd indices	numSlicesF = numSplits * 2.5, iterates odd indices (i*2+1) for GPU Gems 3–style weighting
Cascade near/far	Read directly from interleaved array; each cascade's near is a hard value from the array	Computed as nearClip + splitDist * clipRange; cascade near of split i equals cascade far of split i-1 (tracked via lastSplitDist) — seamless, gap-free

Why it matters:

The old split function produces small intentional overlaps (1.005f multiplier) between cascades, which can cause slight discontinuities at cascade boundaries. The new method produces seamless, gap-free cascades and uses a GPU Gems 3–inspired logarithmic/uniform blend that distributes resolution more evenly across the view range.

3. Frustum Fitting — AABB vs. Bounding Sphere Scale

Aspect	Old	New
Bounding volume	Tight axis-aligned bounding box (AABB) in light space	AABB for centering, but bounding sphere radius for scale
Scale derivation	scalex = 2.0 / (maxproj.x - minproj.x) per-axis	scalex = scaley = 1.0 / frustum_radius (uniform, sphere-based)

Why it matters — this is the core stability improvement:

With a tight AABB, the bounding box dimensions change as the camera rotates, because the 8 frustum corners trace different extents in light space depending on the camera orientation. This causes the orthographic projection bounds to expand and contract frame-to-frame, which shifts shadow texels and produces edge shimmer/flickering.

Using the bounding sphere radius gives a rotation-invariant extent. No matter how the camera rotates, a sphere enclosing the frustum corners has the same radius, so the projection scale remains constant. Combined with the existing texel-snapping stabilization, this eliminates sub-texel jitter entirely.

4. Depth (Z) Centering via mtxCrop[14]

Aspect	Old	New
Z offset in crop matrix	Not applied (mtxCrop[14] is 0, identity)	mtxCrop[14] = -lightSpaceCenter.z — re-centers the depth range on the cascade frustum's light-space center

Why it matters:

The old code uses a fixed depth range (-far .. +far) for all cascades with no per-cascade Z adjustment. If the camera is far from the origin, the actual shadow casters may fall outside this fixed range, causing shadow clipping or lost precision. The new code shifts the depth origin to the center of each cascade's frustum in light space, ensuring the depth range is always centered on the geometry that matters for that cascade. This is critical for scenes with large world coordinates — the shadows simply don't work in the old method when geometry is far from {0, 0, 0}.

5. Frustum Corner Calculation

Aspect	Old	New
Method	Calls worldSpaceFrustumCorners() utility with absolute near/far values	Inline computation: builds view-space corners, transforms to world space via mtxViewInv, then to light space
Frustum center	Not computed	Explicitly computed as average of 8 world-space corners; used for sphere radius and Z centering

The inline approach is functionally equivalent for the corner positions themselves, but the explicit frustum center computation is essential for the bounding-sphere and Z-centering improvements.

---

Visual Impact Summary

Scenario	Old Behavior	New Behavior
Camera rotation (static scene)	Shadow edges flicker/shimmer due to AABB resizing	Stable shadows — sphere radius is rotation-invariant
Camera translation (static scene)	Moderate shimmer from AABB shifts	Stable — uniform scale + texel snapping
Geometry far from world origin	Shadows break — light view is anchored at {0,0,0}, depth range misses distant geometry	Works correctly — orientation-only view matrix + per-cascade Z centering
Near-vertical directional light	Potential degenerate view matrix (no up-vector fallback)	Handled gracefully with +Z up fallback

---

All code

 /**
  * Calculate cascade split depths based on view camera frustum using GPU Gems 3 method.
  * Based on: https://developer.nvidia.com/gpugems/GPUGems3/gpugems3_ch10.html
  * 
  * @param cascadeSplits Output array of normalized split depths [0..1] for each cascade
  * @param numSplits Number of cascade splits (typically 4)
  * @param nearClip Near clip plane distance
  * @param farClip Far clip plane distance  
  * @param splitLambda Blend factor between logarithmic (1.0) and uniform (0.0) distribution
  */
  void calculateCascadeSplits(float* cascadeSplits, uint8_t numSplits, float nearClip, float farClip, float splitLambda)
  {
	  const float clipRange = farClip - nearClip;
	  const float minZ = nearClip;
	  const float maxZ = nearClip + clipRange;
	  const float range = maxZ - minZ;
	  const float ratio = maxZ / minZ;
  
	  // Calculate split depths based on view camera frustum
	  // Use a modified indexing similar to the original implementation for better distribution feel
	  // The original used odd indices (1,3,5,7) out of (num_splits*2), giving more weight to near cascades
	  const float numSlicesF = float(numSplits) * 2.5f;
	  
	  for(uint32_t i = 0; i < numSplits; i++)
	  {
		  // Use odd indices like the original: 1, 3, 5, 7 for 4 splits
		  const float si = float(i * 2 + 1) / numSlicesF;
		  const float logSplit = minZ * bx::pow(ratio, si);
		  const float uniformSplit = minZ + range * si;
		  const float d = splitLambda * (logSplit - uniformSplit) + uniformSplit;
		  cascadeSplits[i] = (d - nearClip) / clipRange;
	  }
  }


... 
        else // LightType::DirectionalLight == m_settings.m_lightType
	{
		// ============================================================================
		// Cascaded Shadow Map calculation based on GPU Gems 3, Chapter 10
		// ============================================================================

		const uint8_t maxNumSplits = 4;
		BX_ASSERT(maxNumSplits >= m_settings.m_numSplits, "Error! Max num splits.");

		// Get camera parameters
		const float nearClip = currentSmSettings->m_near;
		const float farClip = currentSmSettings->m_far;
		const float clipRange = farClip - nearClip;

		// Calculate cascade split depths using GPU Gems 3 logarithmic/uniform blend
		float cascadeSplits[maxNumSplits];
		calculateCascadeSplits(cascadeSplits, 
									uint8_t(m_settings.m_numSplits), 
									nearClip, 
									farClip, 
									m_settings.m_splitDistribution);

		// Light direction (normalized) - this is the direction the light travels
		const bx::Vec3 lightDir = bx::normalize(bx::Vec3{
			m_directionalLight.m_position.m_x,
			m_directionalLight.m_position.m_y,
			m_directionalLight.m_position.m_z
		});

		const bx::Vec3 lightEye = {0.0f, 0.0f, 0.0f};
		const bx::Vec3 lightAt = lightDir;  // Look along light direction
		
		// Use +Y as default up vector, falling back to +Z if light is nearly vertical
		bx::Vec3 upVec = {0.0f, 1.0f, 0.0f};
		if(bx::abs(bx::dot(lightDir, upVec)) > 0.99f)
		{
			upVec = {0.0f, 0.0f, 1.0f};
		}
		
		// All cascades share the same light view matrix (camera position independent)
		bx::mtxLookAt(lightView[0], lightEye, lightAt, upVec);

		// Create base orthographic projection (will be adjusted by crop matrices)
		float mtxProj[16];
		bx::mtxOrtho(mtxProj,
						-1.0f, 1.0f,    // left, right
						-1.0f, 1.0f,    // bottom, top
						-currentSmSettings->m_far,
						currentSmSettings->m_far,
						0.0f,
						caps->homogeneousDepth);

		// Get camera inverse view matrix for frustum corner calculation
		float mtxViewInv[16];
		bx::mtxInverse(mtxViewInv, m_viewState.m_view);
		// Process each cascade
		const uint8_t numCorners = 8;
		float frustumCorners[maxNumSplits][numCorners][3];
		float lastSplitDist = 0.0f;

		// Cascade blend overlap: extend each cascade's near plane backward to cover
		// the previous cascade's transition band. Must match the shader's cascadeBlendBand.
		// const float cascadeBlendOverlap = 0.1f;

		for(uint8_t ii = 0; ii < m_settings.m_numSplits; ++ii)
		{
			const float splitDist = cascadeSplits[ii];
			
			// Compute actual near/far distances for this cascade
			const float cascadeNear = nearClip + lastSplitDist * clipRange;
			const float cascadeFar = nearClip + splitDist * clipRange;

			// Update cascade far distance uniform (use original split distance for shader blend)
			s_uniforms.m_csmFarDistances[ii] = cascadeFar;

			// Compute frustum corners for this cascade in world space
			const float nw = cascadeNear * projWidth;
			const float nh = cascadeNear * projHeight;
			const float fw = cascadeFar * projWidth;
			const float fh = cascadeFar * projHeight;

			// Frustum corners in view space (camera looking along +Z)
			const bx::Vec3 viewSpaceCorners[8] = {
				{-nw,  nh, cascadeNear},  // near top-left
				{ nw,  nh, cascadeNear},  // near top-right
				{ nw, -nh, cascadeNear},  // near bottom-right
				{-nw, -nh, cascadeNear},  // near bottom-left
				{-fw,  fh, cascadeFar},   // far top-left
				{ fw,  fh, cascadeFar},   // far top-right
				{ fw, -fh, cascadeFar},   // far bottom-right
				{-fw, -fh, cascadeFar},   // far bottom-left
			};

			// Transform corners to world space and then to light space
			bx::Vec3 min = {9000.0f, 9000.0f, 9000.0f};
			bx::Vec3 max = {-9000.0f, -9000.0f, -9000.0f};
			float frustum_radius = 0.0f;
			
			// Calculate frustum center in world space
			bx::Vec3 frustumCenter = {0.0f, 0.0f, 0.0f};
			for(uint8_t jj = 0; jj < numCorners; ++jj)
			{
				// Transform from view space to world space
				const bx::Vec3 worldCorner = bx::mul(viewSpaceCorners[jj], mtxViewInv);
				bx::store(&frustumCorners[ii][jj], worldCorner);
				frustumCenter = bx::add(frustumCenter, worldCorner);
			}
			frustumCenter = bx::mul(frustumCenter, 1.0f / 8.0f);
			
			// Transform center to light space for radius calculation
			const bx::Vec3 lightSpaceCenter = bx::mul(frustumCenter, lightView[0]);
			
			// Transform corners to light space and compute bounds
			for(uint8_t jj = 0; jj < numCorners; ++jj)
			{
				const bx::Vec3 xyz = bx::mul(bx::load<bx::Vec3>(frustumCorners[ii][jj]), lightView[0]);
				
				// Calculate distance from center for radius
				const float dx = xyz.x - lightSpaceCenter.x;
				const float dy = xyz.y - lightSpaceCenter.y;
				const float dz = xyz.z - lightSpaceCenter.z;
				const float distance = bx::sqrt(dx*dx + dy*dy + dz*dz);
				frustum_radius = bx::max(frustum_radius, distance);
				
				// Update bounding box in light space
				min = bx::min(min, xyz);
				max = bx::max(max, xyz);
			}
			
			// Round radius to reduce flickering
			frustum_radius = bx::ceil(frustum_radius * 8.0f) / 8.0f;

			// Project bounds to the base ortho projection space
			const bx::Vec3 minproj = bx::mulH(min, mtxProj);
			const bx::Vec3 maxproj = bx::mulH(max, mtxProj);

			// Calculate scale using radius-based approach for stability
			float scalex = 1.0f / frustum_radius;
			float scaley = 1.0f / frustum_radius;

			if(m_settings.m_stabilize)
			{
				// Quantize scale for stability
				const float quantizer = 64.0f;
				scalex = quantizer / bx::ceil(quantizer / scalex);
				scaley = quantizer / bx::ceil(quantizer / scaley);
			}

			// Calculate offset to center the cascade in the projection
			float offsetx = -scalex * (minproj.x + maxproj.x) * 0.5f;
			float offsety = -scaley * (minproj.y + maxproj.y) * 0.5f;

			// Apply texel snapping for stability					
			if (m_settings.m_stabilize)
			{
				const float halfSize = currentShadowMapSizef * 0.5f;
				offsetx = bx::ceil(offsetx * halfSize) / halfSize;
				offsety = bx::ceil(offsety * halfSize) / halfSize;
			}

			// Build crop matrix to adjust the base projection for this cascade
			float mtxCrop[16];
			bx::mtxIdentity(mtxCrop);
			mtxCrop[0] = scalex;   // x-scale
			mtxCrop[5] = scaley;   // y-scale
			mtxCrop[12] = offsetx; // x-offset
			mtxCrop[13] = offsety; // y-offset
			mtxCrop[14] = -lightSpaceCenter.z; // z-offset: center depth range on cascade frustum

			// Final projection = crop * base projection
			bx::mtxMul(lightProj[ii], mtxCrop, mtxProj);

			lastSplitDist = splitDist;
		}
	}

[bkaradzic]

This is great! Thanks!

I cannot make a PR since i have a fork of the repo with some local changes that is why i am posting it here. At the bottom is the whole code which is not so much.

You should just do fresh clone, and submit PR. That way you would be properly credited as a contributor.

[unravel-dev]

since posting this i have found several issues with my proposal here. Let me fix them and i will try to do a pr

[unravel-dev]

i have improved on this and updated the original comment here. Unfortunatelly i cannot do a PR without a fork. But i already have one with multiple commits and it would really be a hassle to manuver them around so for me it doesn't matter if i am credited as a contributor just want to contribute :). Love the library and all the work people invest in it. You can try it and if you like it just add it. If you are not finding it to your liking dont add it :).

Another separate thing which if you like can improve the example is PCSS shadow method.
here is the shader code which works. Just need to call it

#if SM_HARD
    visibility = hardShadow(_sampler, shadowcoord, _bias);
#elif SM_PCF
    visibility = PCF(_sampler, shadowcoord, _bias, _samplingParams, _texelSize);
#elif SM_PCSS
    visibility = PCSS(_sampler, shadowcoord, _bias, _samplingParams, _texelSize, fragCoord);
#elif SM_VSM
    visibility = VSM(_sampler, shadowcoord, _bias, _depthMultiplier, _minVariance);
#elif SM_ESM
    visibility = ESM(_sampler, shadowcoord, _bias, _depthMultiplier * _hardness);
#endif

Here is all the code for the PCSS

vec2 samplePoisson(int index)
{

#if BGFX_SHADER_LANGUAGE_GLSL
#	define CONST_ARRAY_BEGIN(_type, _name, _count) CONST(_type) _name[_count] = _type[](
#else
#	define CONST_ARRAY_BEGIN(_type, _name, _count) CONST(_type) _name[_count] = {
#endif // BGFX_SHADER_LANGUAGE_GLSL


vec2 sampleVogelDisk(int index, int sampleCount)
{
    const float goldenAngle = 2.39996323; // radians
    float i = float(index);
    float r = sqrt((i + 0.5) / float(sampleCount));
    float a = i * goldenAngle;
    return vec2(cos(a), sin(a)) * r;
}

vec2 samplePoisson(int index)
{
        // If arrays are not supported(glsl 1.0) we can calculate it.
	//return sampleVogelDisk(index, 10);
CONST_ARRAY_BEGIN(vec2, PoissonDistribution, 64)
    vec2(-0.94201624, -0.39906216),
    vec2(0.94558609, -0.76890725),
    vec2(-0.094184101, -0.92938870),
    vec2(0.34495938, 0.29387760),
    vec2(-0.91588581, 0.45771432),
    vec2(-0.81544232, -0.87912464),
    vec2(-0.38277543, 0.27676845),
    vec2(0.97484398, 0.75648379),
    vec2(0.44323325, -0.97511554),
    vec2(0.53742981, -0.47373420),
    vec2(-0.26496911, -0.41893023),
    vec2(0.79197514, 0.19090188),
    vec2(-0.24188840, 0.99706507),
    vec2(-0.81409955, 0.91437590),
    vec2(0.19984126, 0.78641367),
    vec2(0.14383161, -0.14100790),
    vec2(-0.413923, -0.439757),
    vec2(-0.979153, -0.201245),
    vec2(-0.865579, -0.288695),
    vec2(-0.243704, -0.186378),
    vec2(-0.294920, -0.055748),
    vec2(-0.604452, -0.544251),
    vec2(-0.418056, -0.587679),
    vec2(-0.549156, -0.415877),
    vec2(-0.238080, -0.611761),
    vec2(-0.267004, -0.459702),
    vec2(-0.100006, -0.229116),
    vec2(-0.101928, -0.380382),
    vec2(-0.681467, -0.700773),
    vec2(-0.763488, -0.543386),
    vec2(-0.549030, -0.750749),
    vec2(-0.809045, -0.408738),
    vec2(-0.388134, -0.773448),
    vec2(-0.429392, -0.894892),
    vec2(-0.131597, 0.065058),
    vec2(-0.275002, 0.102922),
    vec2(-0.106117, -0.068327),
    vec2(-0.294586, -0.891515),
    vec2(-0.629418, 0.379387),
    vec2(-0.407257, 0.339748),
    vec2(0.071650, -0.384284),
    vec2(0.022018, -0.263793),
    vec2(0.003879, -0.136073),
    vec2(-0.137533, -0.767844),
    vec2(-0.050874, -0.906068),
    vec2(0.114133, -0.070053),
    vec2(0.163314, -0.217231),
    vec2(-0.100262, -0.587992),
    vec2(-0.004942, 0.125368),
    vec2(0.035302, -0.619310),
    vec2(0.195646, -0.459022),
    vec2(0.303969, -0.346362),
    vec2(-0.678118, 0.685099),
    vec2(-0.628418, 0.507978),
    vec2(-0.508473, 0.458753),
    vec2(0.032134, -0.782030),
    vec2(0.122595, 0.280353),
    vec2(-0.043643, 0.312119),
    vec2(0.132993, 0.085170),
    vec2(-0.192106, 0.285848),
    vec2(0.183621, -0.713242),
    vec2(0.265220, -0.596716),
    vec2(-0.009628, -0.483058),
    vec2(-0.018516, 0.435703)
ARRAY_END();

    return PoissonDistribution[int(mod(index,64))];
}


// Rotate a 2D sample by a precomputed sin/cos pair.
// _sincos = vec2(sin(angle), cos(angle))
vec2 rotateSample(vec2 _sample, vec2 _sincos)
{
    return vec2(_sample.x * _sincos.y - _sample.y * _sincos.x,
                _sample.x * _sincos.x + _sample.y * _sincos.y);
}

// Interleaved gradient noise for per-pixel Poisson disk rotation.
// Produces well-distributed noise that avoids the clustering artifacts of
// traditional fract(sin(...)) hashes. Converts structured Poisson banding
// into smooth, perceptually-uniform noise.
// Source: "Next Generation Post Processing in Call of Duty: AW" (Jimenez 2014)
float interleavedGradientNoise(vec2 _screenPos)
{
    vec3 magic = vec3(0.06711056, 0.00583715, 52.9829189);
    return fract(magic.z * fract(dot(_screenPos, magic.xy)));
}

float hardShadowLod(sampler2D _sampler, float lod, vec4 _shadowCoord, float _bias)
{
    vec2 texCoord = _shadowCoord.xy/_shadowCoord.w;

    bool outside = any(greaterThan(texCoord, vec2_splat(1.0)))
                || any(lessThan   (texCoord, vec2_splat(0.0)))
                 ;

    if (outside)
    {
        return 1.0;
    }

    float receiver = (_shadowCoord.z-_bias)/_shadowCoord.w;
    float occluder = unpackRgbaToFloat(texture2DLod(_sampler, texCoord, lod) );

    float visibility = step(receiver, occluder);
    return visibility;
}

// _diskRotation = vec2(sin(angle), cos(angle)) for per-pixel Poisson disk rotation.
// Pass vec2(0.0, 1.0) for no rotation (identity).
float PCFLodOffset(sampler2D _sampler, float lod, vec2 offset, vec4 _shadowCoord, float _bias, vec4 _pcfParams, vec2 _texelSize, vec2 _diskRotation)
{
    float result = 0.0;

    for ( int i = 0; i < PCF_LOD_OFFSET_NUM_SAMPLES; ++i )
    {
        vec2 jitteredOffset = rotateSample(samplePoisson(i), _diskRotation) * offset;
        result += hardShadowLod(_sampler, lod, _shadowCoord + vec4(jitteredOffset, 0.0, 0.0), _bias);
    }
    return result / PCF_LOD_OFFSET_NUM_SAMPLES;
}


// Returns vec3(avgBlockerDepth, closestBlockerDepth, blockerRatio)
//   avgBlockerDepth:     mean depth of all blockers found (for general penumbra)
//   closestBlockerDepth: maximum depth among blockers (nearest to receiver, for contact hardening)
//   blockerRatio:        fraction of search samples that found a blocker [0..1]
// _diskRotation = vec2(sin(angle), cos(angle)) for per-pixel Poisson disk rotation
vec3 findBlocker(sampler2D _sampler, vec4 _shadowCoord, vec2 _searchSize, float _bias, vec2 _diskRotation)
{
    int blockerCount = 0;
    float avgBlockerDepth = 0.0;
    float closestBlockerDepth = 0.0;
    vec2 texCoord = _shadowCoord.xy / _shadowCoord.w;
    float receiverDepth = (_shadowCoord.z / _shadowCoord.w) - _bias;

    // Search around the shadow coordinate to find blockers
    for( int i = 0; i < BLOCKER_SEARCH_NUM_SAMPLES; ++i )
    {
        vec2 offset = rotateSample(samplePoisson(i), _diskRotation) * _searchSize;
        float shadowMapDepth = unpackRgbaToFloat(texture2D(_sampler, texCoord + offset));
        if (shadowMapDepth < receiverDepth)
        {
            avgBlockerDepth += shadowMapDepth;
            closestBlockerDepth = max(closestBlockerDepth, shadowMapDepth);
            blockerCount++;
        }
    }

    // Calculate average blocker depth
    if (blockerCount > 0)
    {
        avgBlockerDepth /= float(blockerCount);
    }
    else
    {
        avgBlockerDepth = -1.0; // No blockers found
    }

    float blockerRatio = float(blockerCount) / float(BLOCKER_SEARCH_NUM_SAMPLES);
    return vec3(avgBlockerDepth, closestBlockerDepth, blockerRatio);
}



float PCSS(sampler2D _sampler, vec4 _shadowCoord, float _bias, vec4 _pcfParams, vec2 _texelSize, vec2 fragCoord)
{
    // -----------------------------------------------------------------------
    // PCSS Parameters
    // -----------------------------------------------------------------------

    // Blocker search radius in UV space (~10 texels on 1024 map).
    float searchRadiusUV = 0.01;

    // Penumbra scale. Amplifies the squared depth ratio into a UV-space
    // filter radius. Higher = softer shadows at distance.
    float penumbraScale = 4.0;

    // Maximum filter radius in UV space (~50 texels on 1024 map).
    float maxFilterRadius = 0.05;

    // -----------------------------------------------------------------------
    // Per-pixel Poisson disk rotation (Interleaved Gradient Noise)
    // -----------------------------------------------------------------------
    vec2 noiseCoord = fragCoord;
    // Alternatively this can be used instead(bit worse results thant the fragCoord)
    //vec2 noiseCoord = (_shadowCoord.xy / _shadowCoord.w) * (1.0 / _texelSize.x);
    float noise = interleavedGradientNoise(noiseCoord);
    float rotationAngle = noise * 6.283185;
    vec2 diskRotation = vec2(sin(rotationAngle), cos(rotationAngle));

    // Receiver depth in normalized shadow map space
    float receiverDepth = (_shadowCoord.z / _shadowCoord.w) - _bias;

    // -----------------------------------------------------------------------
    // Step 1: Blocker Search
    // -----------------------------------------------------------------------
    vec3 blockerResult = findBlocker(_sampler, _shadowCoord, vec2(searchRadiusUV, searchRadiusUV), _bias, diskRotation);
    float avgBlockerDepth = blockerResult.x;
    float blockerRatio = blockerResult.z;

    if (avgBlockerDepth < -0.99)
    {
        return 1.0;
    }

    // -----------------------------------------------------------------------
    // Step 2: Penumbra Estimation (standard PCSS, Fernando 2005)
    //
    //   penumbraWidth = lightSize * (d_receiver - d_blocker) / d_blocker
    //
    // The depth gap at contact equals the object's thickness along the
    // light direction. For curved objects (spheres, characters), the gap
    // varies across the shadow giving the contact-hardening gradient.
    // For flat objects (cubes), the gap is constant → uniform penumbra.
    // -----------------------------------------------------------------------
    float penumbraWidth = penumbraScale * max(0.0, receiverDepth - avgBlockerDepth) / avgBlockerDepth;
    float filterRadiusUV = clamp(penumbraWidth, 0.0, maxFilterRadius);

    // -----------------------------------------------------------------------
    // Step 3: Percentage-Closer Filtering
    // -----------------------------------------------------------------------
    float visibility = PCFLodOffset(_sampler, 0.0, vec2(filterRadiusUV, filterRadiusUV), _shadowCoord, _bias, _pcfParams, _texelSize, diskRotation);

    // -----------------------------------------------------------------------
    // Step 4: Edge fade based on blocker ratio
    // -----------------------------------------------------------------------
    float edgeFade = smoothstep(0.0, 0.25, blockerRatio);
    visibility = mix(1.0, visibility, edgeFade);

    return visibility;
}

[bkaradzic]

i have improved on this and updated the original comment here. Unfortunatelly i cannot do a PR without a fork. But i already have one with multiple commits and it would really be a hassle to manuver them around so for me it doesn't matter if i am credited as a contributor just want to contribute :). Love the library and all the work people invest in it. You can try it and if you like it just add it. If you are not finding it to your liking dont add it :).

Actually you don't need multiple forks. Rather you should create branch in your fork, reset it to origin/master (which is bgfx repo, not your fork), then cherry-pick, or just copy files directly over. Then push that branch into your fork, and when creating PR, base it of that particular branch, not fork/master.

[bkaradzic]

git fetch --all
git rebase upstream/master
git checkout -b improve-shadowmaps
git reset --hard upstream/master
<copy files you changed>
git commit -am "Improvement to the shadowmaps example for cascades and stability."
git push -u origin improve-shadowmaps

Start PR, and change fork master to improve-shadowmaps before clicking create PR.

[unravel-dev]

i have created a PR for this. thanks.

So about the PCSS are you open to me making a PR as well to improve that? Its mostly shaders.
I have updated the previous comment with the code necessary in the shader.

Here is the current PCF

which can be improved to this by adding disc noise rotation

float hardShadowLod(sampler2D _sampler, float lod, vec4 _shadowCoord, float _bias)
{
    vec2 texCoord = _shadowCoord.xy/_shadowCoord.w;

    bool outside = any(greaterThan(texCoord, vec2_splat(1.0)))
                || any(lessThan   (texCoord, vec2_splat(0.0)))
                 ;

    if (outside)
    {
        return 1.0;
    }

    float receiver = (_shadowCoord.z-_bias)/_shadowCoord.w;
    float occluder = unpackRgbaToFloat(texture2DLod(_sampler, texCoord, lod) );

    float visibility = step(receiver, occluder);
    return visibility;
}

float hardShadow(sampler2D _sampler, vec4 _shadowCoord, float _bias)
{
    return hardShadowLod(_sampler, 0.0, _shadowCoord, _bias);
}


// _diskRotation = vec2(sin(angle), cos(angle)) for per-pixel Poisson disk rotation.
// Pass vec2(0.0, 1.0) for no rotation (identity).
float PCFLodOffset(sampler2D _sampler, float lod, vec2 offset, vec4 _shadowCoord, float _bias, vec4 _pcfParams, vec2 _texelSize, vec2 _diskRotation)
{
    float result = 0.0;

    for ( int i = 0; i < PCF_LOD_OFFSET_NUM_SAMPLES; ++i )
    {
        vec2 jitteredOffset = rotateSample(samplePoisson(i), _diskRotation) * offset;
        result += hardShadowLod(_sampler, lod, _shadowCoord + vec4(jitteredOffset, 0.0, 0.0), _bias);
    }
    return result / PCF_LOD_OFFSET_NUM_SAMPLES;
}
float PCFLod(sampler2D _sampler, float lod, vec2 filterRadius, vec4 _shadowCoord, float _bias, vec4 _pcfParams, vec2 _texelSize, vec2 _diskRotation)
{
    vec2 offset = filterRadius * _pcfParams.zw * _texelSize * _shadowCoord.w;
    return PCFLodOffset(_sampler, lod, offset, _shadowCoord, _bias, _pcfParams, _texelSize, _diskRotation);
}
float PCF(sampler2D _sampler, vec4 _shadowCoord, float _bias, vec4 _pcfParams, vec2 _texelSize, vec2 fragCoord)
{
    // Per-pixel Poisson disk rotation from shadow map texel coordinates
    vec2 noiseCoord = fragCoord;//(_shadowCoord.xy / _shadowCoord.w) * (1.0 / _texelSize.x);
    float angle = interleavedGradientNoise(noiseCoord) * 6.283185;
    vec2 diskRotation = vec2(sin(angle), cos(angle));
    return PCFLod(_sampler, 0.0, vec2(2.0, 2.0), _shadowCoord, _bias, _pcfParams, _texelSize, diskRotation);
}

and this is the PCSS for which i have updated the previous comment

[bkaradzic]

So about the PCSS are you open to me making a PR as well to improve that? Its mostly shaders.
I have updated the previous comment with the code necessary in the shader.

Of course!

[unravel-dev]

How do you rebuild the example shaders like all of them? I am using the bgfx.cmake project to build everything but on windows i only trigger these

[build] [111/252 30% :: 50.468] Compiling shader 16-shadowmaps/fs_shadowmaps_color_texture.sc for DX11, ESSL, GLSL, SPIRV, WGSL

The There may be missing some like dxil. Do i need to rebuild them for all types when submitting the PR?

[bkaradzic]

In original repo you would invoke make TARGET=x to build shader.

But it's not needed for PR, it's actually better to not submit binary shaders, I'll rebuild them once PR lands.

[unravel-dev]

Submitted the PR :). Thanks for your assistance. Hope you like the improvements. Love the library :). I have been using it for quite some time in my game engine.
https://github.com/unravel-dev/UnravelEngine

[bkaradzic]

Thank you for improvements! :)

Also add your engine to README.md, and send PR.

Are you on Discord?

[unravel-dev]

I added a pr with the readme.
I have a discord https://discordapp.com/users/689017622712680637