阴影扰动效果(URP阴影渲染)

比较简单普适的阴影效果实现思路

URP阴影渲染流程

Github源码传送门————>ShadowEdgeDistortion

Bilibili教程传送门————>小祥带你实现阴影扰动效果

阴影贴图

以官方URP中的SampleLit材质+平行光源(Directional Light)为例，过一遍阴影渲染流程

  1. ShadowCaster
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
Pass
{
  Name "ShadowCaster"

  Tags
  {
      "LightMode" = "ShadowCaster"
  }

  // -------------------------------------
  // Render State Commands
  ZWrite On
  ZTest LEqual
  ColorMask 0
  Cull[_Cull]

  HLSLPROGRAM
  #pragma target 2.0
  // -------------------------------------
  // Shader Stages
  #pragma vertex ShadowPassVertex
  #pragma fragment ShadowPassFragment
  ENDHLSL   
}
  • 投射阴影的物体执行这个Pass，将其从光源视角(平行光的话就是光照方向摆一个正交摄像机)下的深度信息写入阴影贴图(ShadowMap)
  • 阴影贴图是例图中间那张，记录深度信息。可以看到包含四张不同分辨率贴图，这是因为引入了级联阴影贴图(Cascaded Shadow Maps)，保证不论远近阴影的质量比较稳定(近处的阴影更靠近相机，在屏幕上占的像素更多，稍有锯齿就很明显，使用较高分辨率的贴图；而远处阴影即使有锯齿，也在屏幕上占很少像素，不容易察觉，使用较低分辨率的贴图)
  1. ForwardLit
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
Pass
{
  Name "ForwardLit"

  Tags
  {
      "LightMode" = "UniversalForward"
  }

  // -------------------------------------
  // Render State Commands
  // Use same blending / depth states as Standard shader
  Blend[_SrcBlend][_DstBlend], [_SrcBlendAlpha][_DstBlendAlpha]
  ZWrite[_ZWrite]
  Cull[_Cull]
  AlphaToMask[_AlphaToMask]

  HLSLPROGRAM
  #pragma target 2.0
  // -------------------------------------
  // Shader Stages
  #pragma vertex LitPassVertexSimple
  #pragma fragment LitPassFragmentSimple
  ENDHLSL
}
  • 被投射阴影的物体在执行这个Pass的时候计算光照，阴影，环境光遮蔽等数据，将阴影绘制到物体上
  1. LitPassFragmentSimple
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
void LitPassFragmentSimple(
    Varyings input
    , out half4 outColor : SV_Target0
#ifdef _WRITE_RENDERING_LAYERS
    , out float4 outRenderingLayers : SV_Target1
#endif
)
{
    // ......

    InputData inputData;
    InitializeInputData(input, surfaceData.normalTS, inputData);
    SETUP_DEBUG_TEXTURE_DATA(inputData, UNDO_TRANSFORM_TEX(input.uv, _BaseMap));

#if defined(_DBUFFER)
    ApplyDecalToSurfaceData(input.positionCS, surfaceData, inputData);
#endif

    InitializeBakedGIData(input, inputData);

    half4 color = UniversalFragmentBlinnPhong(inputData, surfaceData);
    color.rgb = MixFog(color.rgb, inputData.fogCoord);
    color.a = OutputAlpha(color.a, IsSurfaceTypeTransparent(_Surface));

    outColor = color;

    // ......
}
  • 可以看到在片元着色器中，初始化数据之后调用 BlinnPhong 光照模型对应的方法进行绘制
  1. UniversalFragmentBlinnPhong
1
2
3
4
5
6
7
8
9
10
11
12
13
half4 UniversalFragmentBlinnPhong(InputData inputData, SurfaceData surfaceData)
{
    // ......

    uint meshRenderingLayers = GetMeshRenderingLayer();
    half4 shadowMask = CalculateShadowMask(inputData);
    AmbientOcclusionFactor aoFactor = CreateAmbientOcclusionFactor(inputData, surfaceData);
    Light mainLight = GetMainLight(inputData, shadowMask, aoFactor);

    // ......

    return CalculateFinalColor(lightingData, surfaceData.alpha);
}
  • GetMainLight方法计算阴影和光照
  1. GetMainLight
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
Light GetMainLight(float4 shadowCoord)
{
    Light light = GetMainLight();
    light.shadowAttenuation = MainLightRealtimeShadow(shadowCoord);
    return light;
}

Light GetMainLight(float4 shadowCoord, float3 positionWS, half4 shadowMask)
{
    Light light = GetMainLight();
    light.shadowAttenuation = MainLightShadow(shadowCoord, positionWS, shadowMask, _MainLightOcclusionProbes);

    #if defined(_LIGHT_COOKIES)
        real3 cookieColor = SampleMainLightCookie(positionWS);
        light.color *= cookieColor;
    #endif

    return light;
}
  • MainLightRealtimeShadow方法处理阴影
  1. MainLightRealtimeShadow
1
2
3
4
5
6
7
8
9
10
11
12
half MainLightRealtimeShadow(float4 shadowCoord, half4 shadowParams, ShadowSamplingData shadowSamplingData)
{
    #if !defined(MAIN_LIGHT_CALCULATE_SHADOWS)
        return half(1.0);
    #endif

    #if defined(_MAIN_LIGHT_SHADOWS_SCREEN) && !defined(_SURFACE_TYPE_TRANSPARENT)
        return SampleScreenSpaceShadowmap(shadowCoord);
    #else
        return SampleShadowmap(TEXTURE2D_ARGS(_MainLightShadowmapTexture, sampler_LinearClampCompare), shadowCoord, shadowSamplingData, shadowParams, false);
    #endif
}
  • 这个方法是具体计算阴影的地方，可以看到有两种阴影采样路径
  • 一种是屏幕空间阴影，提前渲染好一张屏幕阴影贴图(_ScreenSpaceShadowmapTexture)，例图最右侧那张，渲染好的阴影贴图直接拿来采样使用即可，只做一次全屏计算，性能较好
  • 一种是传统阴影计算路径，使用深度图(_MainLightShadowmapTexture)，通过比较深度计算当前像素是否为阴影，每个片元都要采样，性能稍逊

阴影扰动效果

效果

那么阴影渲染流程清楚之后，要对阴影做效果思路也比较清晰了，一种是去修改被投射阴影物体的主渲染Pass中渲染阴影的那一部分内容，一种是以屏幕空间阴影贴图为基础进一步操作。那么相比较而言显然是后者更易操作一些。我一向是喜欢使用非侵入式的实现方式的，在不改动原有实现的基础上去做效果最好，我愿称之为游戏开发糊弄第一准则XD。选好实现方式，具体的效果实现实际上就没什么难度了。比如要做阴影扰动效果，对UV进行扰动之后进行重采样即可，要做阴影外描边效果，边缘检测之后绘制描边即可。这里以扰动效果为例讲一下：

  1. ShadowDistortionRendererFeature
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class ShadowDistortionRendererFeature : ScriptableRendererFeature
{
    public ShadowDistortionRenderPass shadowDistortionRenderPass;

    public Material shadowDistortionMaterial;

    public override void Create()
    {
        shadowDistortionRenderPass = new ShadowDistortionRenderPass(shadowDistortionMaterial);
        shadowDistortionRenderPass.renderPassEvent = RenderPassEvent.BeforeRenderingOpaques;
    }

    public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData)
    {
        renderer.EnqueuePass(shadowDistortionRenderPass);
    }
}
  • 屏幕空间阴影的渲染是在Gbuffer之后，阴影是在非透明物体阶段渲染的，那么我们的渲染顺序排在非透明物体渲染之前(BeforeRenderingOpaques)即可
  1. ShadowDistortionRenderPass
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
public class ShadowDistortionRenderPass : ScriptableRenderPass
{
    private int shadowTexID;
    private Material shadowDistortionMaterial;

    class PassData
    {
        public Material material;
        public TextureHandle target;
    }

    public ShadowDistortionRenderPass(Material material)
    {
        shadowTexID = Shader.PropertyToID("_ScreenSpaceShadowmapTexture");
        shadowDistortionMaterial = material;
    }

    public override void RecordRenderGraph(RenderGraph renderGraph, ContextContainer frameData)
    {
        UniversalCameraData cameraData = frameData.Get<UniversalCameraData>();

        var desc = cameraData.cameraTargetDescriptor;
        desc.depthStencilFormat = GraphicsFormat.None;
        desc.msaaSamples = 1;
        desc.graphicsFormat = SystemInfo.IsFormatSupported(GraphicsFormat.R8_UNorm, GraphicsFormatUsage.Blend)
            ? GraphicsFormat.R8_UNorm
            : GraphicsFormat.B8G8R8A8_UNorm;

        TextureHandle color = UniversalRenderer.CreateRenderGraphTexture(renderGraph, desc, "_TempScreenSpaceShadowmapTexture", true);

        using (var builder = renderGraph.AddRasterRenderPass<PassData>("ShadowDistortion", out var passData))
        {
            passData.material = shadowDistortionMaterial;
            passData.target = color;

            builder.SetRenderAttachment(color, 0, AccessFlags.Write);

            builder.SetGlobalTextureAfterPass(color, shadowTexID);

            builder.SetRenderFunc((PassData data, RasterGraphContext context) => 
            {
                Blitter.BlitTexture(context.cmd, data.target, Vector4.one, data.material, 0);
            });
        }
    }
}
  • 创建一张临时贴图，通过材质将屏幕空间阴影贴图进行处理，实现效果之后赋值到这张临时贴图，使用SetGlobalTextureAfterPass方法将我们的临时贴图设置为屏幕空间阴影，后续非透明物体渲染时采样的就是我们处理过的阴影贴图
  1. ShadowDistortion
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
Shader "Custom/ShadowDistortion"
{
    Properties
    {
        _DistortionAmount("_DistortionAmount", Range(0, 5)) = 1.0
        _PixelSize("_PixelSize", Float) = 200.0
    }

    SubShader
    {
        Tags { "RenderType"="Transparent" "Queue"="Transparent" "RenderPipeline"="UniversalPipeline" }
        Blend SrcAlpha OneMinusSrcAlpha
        Cull Off 
        ZWrite Off
        Pass
        {
            Name "ShadowDistortion"

            HLSLPROGRAM
            #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Common.hlsl"
            #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/ImageBasedLighting.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
            #include "Packages/com.unity.render-pipelines.core/Runtime/Utilities/Blit.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Shadows.hlsl"

            #pragma vertex Vert
            #pragma fragment Frag

            float _DistortionAmount;
            float _PixelSize;

            float Noise(float2 uv)
            {
                return frac(sin(dot(uv * 1234.56 + _Time.y * 10, float2(12.9898, 78.233))) * 43758.5453) * 2 - 1;
            }

            float4 Frag(Varyings input) : SV_Target
            {
                float2 screenUV = GetNormalizedScreenSpaceUV(input.positionCS);

                float time = _Time.y;

                float2 distortedUV = screenUV;

                distortedUV.x += sin(time * 10.0 + screenUV.y * 100.0) * 0.002 * _DistortionAmount;  
                distortedUV.y += Noise(screenUV * 10.0 + time * 3.0) * 0.002 * _DistortionAmount;

                float2 pixelSize = float2(_PixelSize, _PixelSize);
                distortedUV = floor(distortedUV * pixelSize) / pixelSize;
                float pushAmount = (screenUV.x - 0.5) * 0.05 * _DistortionAmount;
                distortedUV.x -= pushAmount;

                half shadowMapDistorted = SAMPLE_TEXTURE2D(_ScreenSpaceShadowmapTexture, sampler_PointClamp, distortedUV);

                return shadowMapDistorted;
            }
            ENDHLSL
        }
    }
}
  • 我们操作的屏幕空间阴影贴图(_ScreenSpaceShadowmapTexture)是屏幕空间的废话，使用GetNormalizedScreenSpaceUV方法将uv转到屏幕空间
  • 简单做一个坐标扰动和像素化(其他效果类似)，处理后的坐标去采样原贴图然后返回色值即可

完结撒花~

pid:132704750

Unity
#URP #阴影
阴影扰动效果(URP阴影渲染)
https://baifabaiquan.cn/2025/07/16/ShadowDistortion/
作者
白发败犬
发布于
2025年7月16日
许可协议