Shadow blur sampling

2025-11-04 11:23 UTC gpt-5-thinking Open in ChatGPT ↗

I need to sample the shadowmask at 4 points to create a blurred version

void MainLight_float(float3 WorldPos, out float3 Direction, out float3 Color, out float DistanceAtten, out float ShadowAtten) { #if SHADERGRAPH_PREVIEW Direction = float3(0.5, 0.5, 0); Color = 1; DistanceAtten = 1; ShadowAtten = 1; #else #if SHADOWS_SCREEN float4 clipPos = TransformWorldToHClip(WorldPos); float4 shadowCoord = ComputeScreenPos(clipPos); #else float4 shadowCoord = TransformWorldToShadowCoord(WorldPos); #endif Light mainLight = GetMainLight(shadowCoord); Direction = mainLight.direction; Color = mainLight.color; DistanceAtten = mainLight.distanceAttenuation; ShadowSamplingData shadowSamplingData = GetMainLightShadowSamplingData(); float4 shadowParams = GetMainLightShadowParams(); ShadowAtten = SampleShadowmap( TEXTURE2D_ARGS(_MainLightShadowmapTexture, sampler_MainLightShadowmapTexture),shadowCoord,shadowSamplingData,shadowParams,false );

//float shadowStrength = GetMainLightShadowStrength();
//ShadowAtten = SampleShadowmap(shadowCoord, TEXTURE2D_ARGS(_MainLightShadowmapTexture, sampler_MainLightShadowmapTexture), shadowSamplingData, shadowStrength, false);

#endif }

You can do a tiny 4-tap PCF blur by offsetting either the screen-space shadow texture (when SHADOWS_SCREEN is on) or the shadowmap UV that feeds SampleShadowmap (when it’s off). Here’s a drop-in version of your function with a small 4-point kernel. It uses a tunable _ShadowBlurRadius (in texels) so you can dial it in per material or globally.

// Add this property somewhere (material or CBUFFER as fits your setup)
float _ShadowBlurRadius; // e.g. 0.75–2.0

void MainLight_float(float3 WorldPos, out float3 Direction, out float3 Color, out float DistanceAtten, out float ShadowAtten)
{
#if SHADERGRAPH_PREVIEW
    Direction = float3(0.5, 0.5, 0);
    Color = 1;
    DistanceAtten = 1;
    ShadowAtten = 1;
#else
    // Build the coord used for shadow sampling
    #if SHADOWS_SCREEN
        float4 clipPos = TransformWorldToHClip(WorldPos);
        float4 shadowCoord = ComputeScreenPos(clipPos);
    #else
        float4 shadowCoord = TransformWorldToShadowCoord(WorldPos);
    #endif

    // Base light info
    Light mainLight = GetMainLight(shadowCoord);
    Direction      = mainLight.direction;
    Color          = mainLight.color;
    DistanceAtten  = mainLight.distanceAttenuation;

    // Shadow data
    ShadowSamplingData shadowSamplingData = GetMainLightShadowSamplingData();
    float4 shadowParams                   = GetMainLightShadowParams();

    // ---- 4-tap blur ----
    // Use a small cross/corner kernel; tweak _ShadowBlurRadius for strength.

    #if SHADOWS_SCREEN
        // Screen-space resolve path: sample the screen-space shadow texture directly
        // Convert to normalized screen UV
        float2 uv = shadowCoord.xy / shadowCoord.w;

        // _ScreenParams.zw == (1/width, 1/height)
        float2 texel = _ScreenParams.zw * _ShadowBlurRadius;

        // A simple 4-corner kernel
        float2 k0 = float2(-0.5, -0.5) * texel;
        float2 k1 = float2( 0.5, -0.5) * texel;
        float2 k2 = float2(-0.5,  0.5) * texel;
        float2 k3 = float2( 0.5,  0.5) * texel;

        // The screen-space shadow texture encodes attenuation (1 = lit, 0 = fully shadowed)
        // Names are from URP; adjust if your shader has different sampler names.
        float s0 = SAMPLE_TEXTURE2D(_ScreenSpaceShadowmapTexture, sampler_ScreenSpaceShadowmapTexture, uv + k0).r;
        float s1 = SAMPLE_TEXTURE2D(_ScreenSpaceShadowmapTexture, sampler_ScreenSpaceShadowmapTexture, uv + k1).r;
        float s2 = SAMPLE_TEXTURE2D(_ScreenSpaceShadowmapTexture, sampler_ScreenSpaceShadowmapTexture, uv + k2).r;
        float s3 = SAMPLE_TEXTURE2D(_ScreenSpaceShadowmapTexture, sampler_ScreenSpaceShadowmapTexture, uv + k3).r;

        ShadowAtten = (s0 + s1 + s2 + s3) * 0.25;

    #else
        // Shadowmap path: jitter the shadowmap UV used by SampleShadowmap
        // In URP, shadowSamplingData.shadowmapSize is typically (W, H, 1/W, 1/H)
        // We’ll use .zw as texel size.
        float2 texel = shadowSamplingData.shadowmapSize.zw * _ShadowBlurRadius;

        float2 k0 = float2(-0.5, -0.5) * texel;
        float2 k1 = float2( 0.5, -0.5) * texel;
        float2 k2 = float2(-0.5,  0.5) * texel;
        float2 k3 = float2( 0.5,  0.5) * texel;

        float atten = 0;

        // Tap 0
        {
            float4 sc = shadowCoord;
            sc.xy += k0;
            atten += SampleShadowmap(TEXTURE2D_ARGS(_MainLightShadowmapTexture, sampler_MainLightShadowmapTexture),
                                     sc, shadowSamplingData, shadowParams, false);
        }
        // Tap 1
        {
            float4 sc = shadowCoord;
            sc.xy += k1;
            atten += SampleShadowmap(TEXTURE2D_ARGS(_MainLightShadowmapTexture, sampler_MainLightShadowmapTexture),
                                     sc, shadowSamplingData, shadowParams, false);
        }
        // Tap 2
        {
            float4 sc = shadowCoord;
            sc.xy += k2;
            atten += SampleShadowmap(TEXTURE2D_ARGS(_MainLightShadowmapTexture, sampler_MainLightShadowmapTexture),
                                     sc, shadowSamplingData, shadowParams, false);
        }
        // Tap 3
        {
            float4 sc = shadowCoord;
            sc.xy += k3;
            atten += SampleShadowmap(TEXTURE2D_ARGS(_MainLightShadowmapTexture, sampler_MainLightShadowmapTexture),
                                     sc, shadowSamplingData, shadowParams, false);
        }

        ShadowAtten = atten * 0.25;
    #endif

    // If you want to blend with the engine's shadow strength:
    // float strength = GetMainLightShadowStrength();
    // ShadowAtten = lerp(1.0, ShadowAtten, strength);
#endif
}

Notes & tips

_ShadowBlurRadius is in texels (not world units). Start around 1.0 and adjust.
If you prefer a cross kernel, replace the four corner offsets with (±1,0) and (0,±1) times texel.
This is a very small kernel. For softer shadows without banding, consider 9- or 12-tap PCF (with rotated Poisson offsets) and optionally randomize per-pixel using a small blue-noise texture.

Yep—that “all white” result is classic “offsetting in the wrong space / falling outside the cascade tile.”
In the shadowmap path, SampleShadowmap expects a projective coord (xy in homogeneous space). If you nudge shadowCoord.xy with a texel-sized offset without scaling by shadowCoord.w, you’re moving much farther than you think. You end up sampling outside the cascade’s tile in the atlas, and the sampler’s border color is 1 (fully lit) → looks white.

Here’s a fixed 4-tap that:

applies offsets in homogeneous space (* shadowCoord.w)
guards against sampling across the cascade border (simple margin clamp)

Drop-in:

// Strength in texels (0.5–2.0 is a good range)
float _ShadowBlurRadius = 1.0;

static float4 OffsetShadowCoord(float4 sc, float2 uvTexelOffset, ShadowSamplingData sdata)
{
    // uvTexelOffset is in *texels*; convert to homogeneous offset
    float2 texel = sdata.shadowmapSize.zw;   // (1/width, 1/height)
    float2 delta = uvTexelOffset * texel * sc.w;
    sc.xy += delta;
    return sc;
}

// Optional: keep taps away from cascade borders to avoid bleeding to 1.0
static float4 ClampInsideAtlas(float4 sc, ShadowSamplingData sdata, float guardTexels)
{
    float2 uv = sc.xy / sc.w;
    float2 m  = sdata.shadowmapSize.zw * guardTexels;
    uv = clamp(uv, m, 1.0 - m);
    sc.xy = uv * sc.w;
    return sc;
}

void MainLight_float(float3 WorldPos, out float3 Direction, out float3 Color, out float DistanceAtten, out float ShadowAtten)
{
#if SHADERGRAPH_PREVIEW
    Direction = float3(0.5, 0.5, 0);
    Color = 1;
    DistanceAtten = 1;
    ShadowAtten = 1;
#else
    float4 shadowCoord = TransformWorldToShadowCoord(WorldPos);

    Light mainLight = GetMainLight(shadowCoord);
    Direction     = mainLight.direction;
    Color         = mainLight.color;
    DistanceAtten = mainLight.distanceAttenuation;

    ShadowSamplingData sdata = GetMainLightShadowSamplingData();
    float4 shadowParams      = GetMainLightShadowParams();

    // 4-corner PCF kernel (in texels)
    float2 k0 = float2(-0.5, -0.5) * _ShadowBlurRadius;
    float2 k1 = float2( 0.5, -0.5) * _ShadowBlurRadius;
    float2 k2 = float2(-0.5,  0.5) * _ShadowBlurRadius;
    float2 k3 = float2( 0.5,  0.5) * _ShadowBlurRadius;

    // Optional: small guard so taps don't wander into atlas gaps/borders
    const float guardTexels = 1.0;

    float atten = 0.0;

    {
        float4 sc = ClampInsideAtlas(OffsetShadowCoord(shadowCoord, k0, sdata), sdata, guardTexels);
        atten += SampleShadowmap(TEXTURE2D_ARGS(_MainLightShadowmapTexture, sampler_MainLightShadowmapTexture), sc, sdata, shadowParams, false);
    }
    {
        float4 sc = ClampInsideAtlas(OffsetShadowCoord(shadowCoord, k1, sdata), sdata, guardTexels);
        atten += SampleShadowmap(TEXTURE2D_ARGS(_MainLightShadowmapTexture, sampler_MainLightShadowmapTexture), sc, sdata, shadowParams, false);
    }
    {
        float4 sc = ClampInsideAtlas(OffsetShadowCoord(shadowCoord, k2, sdata), sdata, guardTexels);
        atten += SampleShadowmap(TEXTURE2D_ARGS(_MainLightShadowmapTexture, sampler_MainLightShadowmapTexture), sc, sdata, shadowParams, false);
    }
    {
        float4 sc = ClampInsideAtlas(OffsetShadowCoord(shadowCoord, k3, sdata), sdata, guardTexels);
        atten += SampleShadowmap(TEXTURE2D_ARGS(_MainLightShadowmapTexture, sampler_MainLightShadowmapTexture), sc, sdata, shadowParams, false);
    }

    ShadowAtten = atten * 0.25;

    // If you want to honor the main light shadow strength:
    // ShadowAtten = lerp(1.0, ShadowAtten, GetMainLightShadowStrength());
#endif
}

Why this fixes it

Projective coords: Unity’s shadow atlas sampling uses projective coordinates. Texel-sized UV offsets must be multiplied by shadowCoord.w before adding to shadowCoord.xy.
Atlas borders: Cascaded shadowmaps pack tiles into one texture. A tiny overshoot crosses into empty/border space, which returns 1. Clamping with a ~1-texel guard (or just keeping _ShadowBlurRadius small) prevents that.

Quick checks if you still see white

Keep _ShadowBlurRadius ≤ 1–1.5 to start.
Verify you’re in the non-SHADOWS_SCREEN path.
Make sure your URP version provides shadowmapSize.zw = (1/W, 1/H) (it does in recent URP).
If using very soft kernels (many taps), increase guardTexels slightly (e.g., 1.5–2).