// UniversalRenderPipeline.RenderSingleCamera（节选）
renderer.Clear(cameraData.renderType);
renderer.OnPreCullRenderPasses(in cameraData);        // → 每个 Feature.OnCameraPreCull
var cullResults = context.Cull(ref cullingParameters);
InitializeRenderingData(asset, ref cameraData, ref cullResults, cmd, out var renderingData);
renderer.AddRenderPasses(ref renderingData);          // → 每个 Feature.AddRenderPasses
renderer.Setup(context, ref renderingData);           // UniversalRenderer 决定中间纹理、深度/法线预渲染、入队内置 Pass
renderer.Execute(context, ref renderingData);

// ScriptableRenderer.Execute（节选）
m_IsPipelineExecuting = true;
SetupRenderPasses(in renderingData);                  // → 每个 Feature.SetupRenderPasses
InternalStartRendering(context, ref renderingData);   // → 每个 Pass.OnCameraSetup
SortStable(m_ActiveRenderPassQueue);                  // 按 renderPassEvent 稳定排序
foreach (var pass in activeRenderPassQueue)
    pass.Configure(cmd, cameraData.cameraTargetDescriptor);
// …按事件分块，依次 ExecuteRenderPass → 每个 Pass.Execute
InternalFinishRendering(...);                         // → Pass.OnCameraCleanup，栈中最后一个相机再调 OnFinishCameraStackRendering

// 案例 25.1：最小的全屏效果——反色 / 去色 / 染色。
// 顶点着色器直接用 core 包 Blit.hlsl 里的 Vert（全屏三角形），输入纹理名固定为 _BlitTexture。
Shader "Cookbook/Ch25/Tint"
{
    SubShader
    {
        Tags { "RenderType"="Opaque" "RenderPipeline"="UniversalPipeline" }
        // 全屏 Pass 的标配：不测深度、不写深度、不剔除
        ZTest Always ZWrite Off Cull Off

        Pass
        {
            Name "Tint"

            HLSLPROGRAM
            #pragma vertex Vert
            #pragma fragment Frag

            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
            // Blit.hlsl 提供：_BlitTexture、_BlitScaleBias、Attributes/Varyings、Vert()、sampler_LinearClamp 等
            #include "Packages/com.unity.render-pipelines.core/Runtime/Utilities/Blit.hlsl"

            // 这些参数由 C# 每帧写入材质，不放 Properties 块
            float4 _TintColor;    // 乘色
            float  _Invert;       // 0..1 反色程度
            float  _Desaturate;   // 0..1 去色程度

            half4 Frag(Varyings input) : SV_Target
            {
                UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);
                float2 uv = input.texcoord;
                half4 color = SAMPLE_TEXTURE2D_X(_BlitTexture, sampler_LinearClamp, uv);

                // 1) 去色：用 Rec.709 亮度权重（相机颜色缓冲是线性空间）
                half luma = dot(color.rgb, half3(0.2126, 0.7152, 0.0722));
                color.rgb = lerp(color.rgb, luma.xxx, _Desaturate);

                // 2) 反色：在 sRGB（感知）空间里做 1-x 才像“底片”，在线性空间直接反会整体发白
                half3 srgb = LinearToSRGB(saturate(color.rgb));
                half3 inverted = SRGBToLinear(1.0 - srgb);
                color.rgb = lerp(color.rgb, inverted, _Invert);

                // 3) 染色
                color.rgb *= _TintColor.rgb;
                return color;
            }
            ENDHLSL
        }
    }
}

public class TintFeature : ScriptableRendererFeature
{
    [System.Serializable]
    public class Settings
    {
        public RenderPassEvent passEvent = RenderPassEvent.BeforeRenderingPostProcessing;
        public Color tint = Color.white;
        [Range(0, 1)] public float invert = 1f;
        [Range(0, 1)] public float desaturate = 0f;
    }

    public Settings settings = new Settings();
    // 在 Inspector 里拖入 Cookbook/Ch25/Tint。直接引用能保证打包时 Shader 不被剔除；
    // 留空时退回 Shader.Find（只在编辑器或 Shader 已被别处引用时可靠）。
    public Shader shader;

    Material m_Material;
    TintPass m_Pass;

    // Create 在 OnEnable、以及 Inspector 每次改值（OnValidate）时都会被调用，
    // 所以这里必须先清理上一次创建的东西，否则每改一次参数就泄漏一份材质和 RT。
    public override void Create()
    {
        m_Pass?.Dispose();
        CoreUtils.Destroy(m_Material);

        if (shader == null) shader = Shader.Find("Cookbook/Ch25/Tint");
        m_Material = shader != null ? CoreUtils.CreateEngineMaterial(shader) : null;
        m_Pass = new TintPass(m_Material);
    }

    // 每个相机、每帧调用一次：决定这一帧要不要把 Pass 放进队列
    public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData)
    {
        if (m_Material == null) return;
        var camType = renderingData.cameraData.cameraType;
        // 材质球预览、反射探针烘焙用的相机不需要全屏效果
        if (camType == CameraType.Preview || camType == CameraType.Reflection) return;

        m_Pass.renderPassEvent = settings.passEvent;
        m_Pass.Setup(settings);
        renderer.EnqueuePass(m_Pass);
    }

    // 相机的颜色/深度目标在这里才已分配好；在 AddRenderPasses 里取会报错
    public override void SetupRenderPasses(ScriptableRenderer renderer, in RenderingData renderingData)
    {
        m_Pass.SetTarget(renderer.cameraColorTargetHandle, renderer.cameraDepthTargetHandle);
    }

    // Renderer 被销毁（切换管线资产、改 Renderer 列表、退出）时调用
    protected override void Dispose(bool disposing)
    {
        m_Pass?.Dispose();
        CoreUtils.Destroy(m_Material);
    }
}

public RTHandle cameraColorTargetHandle
{
    get
    {
        if (!m_IsPipelineExecuting)
        {
            Debug.LogError("You can only call cameraColorTarget inside the scope of a ScriptableRenderPass. ...");
            return null;
        }
        return m_CameraColorTarget.handle;
    }
}

class TintPass : ScriptableRenderPass
{
    static readonly int s_TintColor = Shader.PropertyToID("_TintColor");
    static readonly int s_Invert = Shader.PropertyToID("_Invert");
    static readonly int s_Desaturate = Shader.PropertyToID("_Desaturate");

    readonly Material m_Material;
    RTHandle m_CameraColor, m_CameraDepth;   // 借来的，不归我们释放
    RTHandle m_Temp;                         // 自己分配的，Dispose 里释放

    public TintPass(Material material)
    {
        m_Material = material;
        profilingSampler = new ProfilingSampler("Ch25 Tint");   // Frame Debugger 里显示的名字
    }

    public void Setup(TintFeature.Settings s)
    {
        // 这些值在一帧内不变，直接写材质即可
        m_Material.SetColor(s_TintColor, s.tint);
        m_Material.SetFloat(s_Invert, s.invert);
        m_Material.SetFloat(s_Desaturate, s.desaturate);
    }

    public void SetTarget(RTHandle color, RTHandle depth)
    {
        m_CameraColor = color;
        m_CameraDepth = depth;
    }

    public override void OnCameraSetup(CommandBuffer cmd, ref RenderingData renderingData)
    {
        // 临时 RT 和相机颜色同尺寸、同格式（HDR 时是浮点格式），但不要 MSAA、不要深度
        var desc = renderingData.cameraData.cameraTargetDescriptor;
        desc.msaaSamples = 1;
        desc.depthBufferBits = 0;
        RenderingUtils.ReAllocateIfNeeded(ref m_Temp, desc, FilterMode.Bilinear,
            TextureWrapMode.Clamp, name: "_Ch25TintTemp");
    }

    public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
    {
        var cmd = CommandBufferPool.Get();
        using (new ProfilingScope(cmd, profilingSampler))
        {
            // 不能边读边写同一张纹理：先“相机颜色 → 临时 RT（经过材质）”，再拷回
            Blitter.BlitCameraTexture(cmd, m_CameraColor, m_Temp, m_Material, 0);
            Blitter.BlitCameraTexture(cmd, m_Temp, m_CameraColor);
            // BlitCameraTexture 只绑定了颜色。URP 以为相机的颜色+深度还绑着，
            // 后面的天空盒/透明物体会直接画，所以由我们把深度一起恢复回去。
            CoreUtils.SetRenderTarget(cmd, m_CameraColor, m_CameraDepth);
        }
        context.ExecuteCommandBuffer(cmd);
        CommandBufferPool.Release(cmd);
    }

    public void Dispose()
    {
        m_Temp?.Release();
        m_Temp = null;
    }
}

[BookShot("ch25-tint", W = 640, H = 400, Panels = 3)]
static void Tint(Shot s)
{
    Stage(s);
    if (s.Panel == 0) return;                       // 第 1 格：不加 Feature
    var f = s.Feature<TintFeature>();
    if (s.Panel == 1) { f.settings.invert = 1; f.settings.desaturate = 0; }
    else { f.settings.invert = 0; f.settings.desaturate = 1; f.settings.tint = new Color(1.25f, 0.95f, 0.65f); }
}

public static bool ReAllocateIfNeeded(ref RTHandle handle, in RenderTextureDescriptor descriptor,
    FilterMode filterMode = FilterMode.Point, TextureWrapMode wrapMode = TextureWrapMode.Repeat,
    bool isShadowMap = false, int anisoLevel = 1, float mipMapBias = 0, string name = "")
{
    TextureDesc requestRTDesc = RTHandleResourcePool.CreateTextureDesc(descriptor, TextureSizeMode.Explicit, ...);
    if (RTHandleNeedsReAlloc(handle, requestRTDesc, false))
    {
        if (handle != null && handle.rt != null)
            AddStaleResourceToPoolOrRelease(currentRTDesc, handle);       // 旧的放回池子或释放
        if (UniversalRenderPipeline.s_RTHandlePool.TryGetResource(requestRTDesc, out handle))
            return true;                                                  // 池子里有现成的就复用
        handle = RTHandles.Alloc(descriptor, filterMode, wrapMode, isShadowMap, anisoLevel, mipMapBias, name);
        return true;
    }
    return false;                                                         // 描述符没变：什么都不做
}

TEXTURE2D_X(_BlitTexture);
uniform float4 _BlitScaleBias;

struct Attributes { uint vertexID : SV_VertexID; UNITY_VERTEX_INPUT_INSTANCE_ID };
struct Varyings   { float4 positionCS : SV_POSITION; float2 texcoord : TEXCOORD0; UNITY_VERTEX_OUTPUT_STEREO };

Varyings Vert(Attributes input)
{
    Varyings output;
    UNITY_SETUP_INSTANCE_ID(input);
    UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output);
    float4 pos = GetFullScreenTriangleVertexPosition(input.vertexID);
    float2 uv  = GetFullScreenTriangleTexCoord(input.vertexID);
    output.positionCS = pos;
    output.texcoord   = uv * _BlitScaleBias.xy + _BlitScaleBias.zw;
    return output;
}

public override void Create()
{
    Log("Feature.Create");
    m_Pass = new ProbePass();
}

public override void OnCameraPreCull(ScriptableRenderer renderer, in CameraData cameraData)
{
    s_Frame++;
    Log($"Feature.OnCameraPreCull  camera={cameraData.camera.name}");
}

public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData)
{
    Log("Feature.AddRenderPasses");
    m_Pass.renderPassEvent = passEvent;
    m_Pass.ConfigureInput(ScriptableRenderPassInput.Depth);   // 必须在这里声明输入
    renderer.EnqueuePass(m_Pass);
}

public override void SetupRenderPasses(ScriptableRenderer renderer, in RenderingData renderingData)
{
    // 此时相机目标已分配，可以安全读取
    Log($"Feature.SetupRenderPasses  color={renderer.cameraColorTargetHandle.name}");
}

protected override void Dispose(bool disposing) => Log("Feature.Dispose");

class ProbePass : ScriptableRenderPass
{
    public override void OnCameraSetup(CommandBuffer cmd, ref RenderingData renderingData)
        => Log("  Pass.OnCameraSetup");
    public override void Configure(CommandBuffer cmd, RenderTextureDescriptor desc)
        => Log($"  Pass.Configure  {desc.width}x{desc.height} msaa={desc.msaaSamples}");
    public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
        => Log($"  Pass.Execute  event={renderPassEvent}");
    public override void OnCameraCleanup(CommandBuffer cmd)
        => Log("  Pass.OnCameraCleanup");
    public override void OnFinishCameraStackRendering(CommandBuffer cmd)
        => Log("  Pass.OnFinishCameraStackRendering");
}

[帧0] Feature.Create
[帧0] Feature.Create
[帧1] Feature.OnCameraPreCull  camera=Main Camera
[帧1] Feature.AddRenderPasses
[帧1] Feature.SetupRenderPasses  color=_CameraColorAttachmentA
[帧1]   Pass.OnCameraSetup
[帧1]   Pass.Configure  640x400 msaa=1
[帧1]   Pass.Execute  event=AfterRenderingOpaques
[帧1]   Pass.OnCameraCleanup
[帧1]   Pass.OnFinishCameraStackRendering
……
[帧3]   Pass.OnFinishCameraStackRendering
[帧3] Feature.Dispose

private static void ExecuteMainPass(CommandBuffer cmd, RTHandle sourceTexture, Material material, int passIndex)
{
    s_SharedPropertyBlock.Clear();
    if (sourceTexture != null)
        s_SharedPropertyBlock.SetTexture(ShaderPropertyId.blitTexture, sourceTexture);       // _BlitTexture
    // We need to set the "_BlitScaleBias" uniform for user materials with shaders relying on core Blit.hlsl to work
    s_SharedPropertyBlock.SetVector(ShaderPropertyId.blitScaleBias, new Vector4(1, 1, 0, 0));
    cmd.DrawProcedural(Matrix4x4.identity, material, passIndex, MeshTopology.Triangles, 3, 1, s_SharedPropertyBlock);
}

half4 Frag(Varyings input) : SV_Target
{
    UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);
    float2 uv = input.texcoord;
    half3 c = SAMPLE_TEXTURE2D_X(_BlitTexture, sampler_LinearClamp, uv).rgb;

    // 亮度放大（模拟像增强管），再压一条曲线防止大片死白
    half luma = dot(c, half3(0.2126, 0.7152, 0.0722)) * _Gain;
    luma = luma / (1.0 + luma);

    // 颗粒噪点：按像素坐标取哈希，_Time 让它在运行时闪动（截图时 _Time≈0）
    float2 pixel = uv * _ScreenParams.xy;
    half grain = Hash12(pixel + frac(_Time.y * 13.0) * 517.0) - 0.5;
    luma = saturate(luma + grain * 0.12);

    // 扫描线：每 3 像素一条暗线
    half scan = 1.0 - _ScanlineStrength * step(2.0, fmod(pixel.y, 3.0));

    // 圆形镜筒暗角（按宽高比校正成正圆）
    float2 d = (uv - 0.5) * float2(_ScreenParams.x / _ScreenParams.y, 1.0);
    half vignette = smoothstep(_VignetteRadius, _VignetteRadius - 0.25, length(d));

    half3 result = _Tint.rgb * luma * scan * vignette;
    return half4(result, 1.0);
}

half4 Frag(Varyings input) : SV_Target
{
    UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);
    float2 uv = input.texcoord;
    half4 color = SAMPLE_TEXTURE2D_X(_BlitTexture, sampler_LinearClamp, uv);

    // 原始深度 → 观察空间线性深度（米）。Reversed-Z 的差异由 _ZBufferParams 处理
    float rawDepth = SampleSceneDepth(uv);
    float eyeDepth = LinearEyeDepth(rawDepth, _ZBufferParams);

    // 指数雾：f = 1 - e^(-density * 距离)
    float dist = max(eyeDepth - _FogStart, 0.0);
    half fog = 1.0 - exp(-_FogDensity * dist);
    color.rgb = lerp(color.rgb, _FogColor.rgb, fog);
    return color;
}

[BookShot("ch25-fullscreen", W = 640, H = 400, Panels = 3)]
static void FullScreen(Shot s)
{
    Stage(s);
    // 加一排远处的柱子，让深度雾有层次
    for (int i = 0; i < 6; i++)
        s.Cylinder(s.Lit(new Color(0.8f, 0.78f, 0.72f), 0, 0.3f), new Vector3(-5f + i * 2f, 1.5f, 4f + i * 2.5f), 1f)
            .transform.localScale = new Vector3(0.6f, 1.5f, 0.6f);
    if (s.Panel == 0) return;

    var f = s.Feature<FullScreenPassRendererFeature>();
    if (s.Panel == 1)
    {
        f.passMaterial = s.Mat("Cookbook/Ch25/FullscreenNightVision");
        f.injectionPoint = FullScreenPassRendererFeature.InjectionPoint.AfterRenderingPostProcessing;
        f.fetchColorBuffer = true;                               // 需要读屏幕颜色
        f.requirements = ScriptableRenderPassInput.None;
    }
    else
    {
        f.passMaterial = s.Mat("Cookbook/Ch25/FullscreenDepthFog");
        f.injectionPoint = FullScreenPassRendererFeature.InjectionPoint.BeforeRenderingPostProcessing;
        f.fetchColorBuffer = true;
        f.requirements = ScriptableRenderPassInput.Depth;        // 需要 _CameraDepthTexture
    }
}

// 案例 25.4：给 RenderObjects 当 Override Material 用的“叠加边缘光”。
// 物体已经在不透明 Pass 里画过一次，这里在同一深度上再画一遍，用加法混合叠上菲涅尔边缘光。
Shader "Cookbook/Ch25/RimOverlay"
{
    Properties
    {
        [HDR] _RimColor ("Rim Color", Color) = (0.2, 0.8, 1.6, 1)
        _RimPower ("Rim Power", Range(0.5, 8)) = 2.5
        _FillAlpha ("Fill", Range(0, 1)) = 0.12
    }
    SubShader
    {
        Tags { "RenderType"="Transparent" "RenderPipeline"="UniversalPipeline" "Queue"="Transparent" }

        Pass
        {
            Name "RimOverlay"
            Tags { "LightMode"="SRPDefaultUnlit" }
            Blend One One          // 加法：只增亮，不遮盖原来的颜色
            ZWrite Off
            ZTest LEqual           // 与自己在不透明 Pass 写下的深度相等，能通过

            HLSLPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"

            CBUFFER_START(UnityPerMaterial)
                float4 _RimColor;
                float  _RimPower;
                float  _FillAlpha;
            CBUFFER_END

            struct Attributes { float4 positionOS : POSITION; float3 normalOS : NORMAL; };
            struct Varyings
            {
                float4 positionCS : SV_POSITION;
                float3 normalWS   : TEXCOORD0;
                float3 positionWS : TEXCOORD1;
            };

            Varyings vert(Attributes v)
            {
                Varyings o;
                VertexPositionInputs p = GetVertexPositionInputs(v.positionOS.xyz);
                o.positionCS = p.positionCS;
                o.positionWS = p.positionWS;
                o.normalWS = TransformObjectToWorldNormal(v.normalOS);
                return o;
            }

            half4 frag(Varyings i) : SV_Target
            {
                float3 n = normalize(i.normalWS);
                float3 v = GetWorldSpaceNormalizeViewDir(i.positionWS);
                half rim = pow(1.0 - saturate(dot(n, v)), _RimPower);
                return half4(_RimColor.rgb * (rim + _FillAlpha), 1.0);
            }
            ENDHLSL
        }
    }
}

[BookShot("ch25-renderobjects", W = 640, H = 400, Panels = 2)]
static void RenderObjectsShot(Shot s)
{
    Stage(s, LayerA);          // 纽结和红球放到第 8 层
    if (s.Panel == 0) return;

    var f = s.Feature<RenderObjects>();
    f.settings.Event = RenderPassEvent.AfterRenderingOpaques;
    f.settings.filterSettings.RenderQueueType = RenderQueueType.Opaque;
    f.settings.filterSettings.LayerMask = 1 << LayerA;
    f.settings.overrideMode = RenderObjects.RenderObjectsSettings.OverrideMaterialMode.Material;
    f.settings.overrideMaterial = s.Mat("Cookbook/Ch25/RimOverlay");
    f.settings.overrideMaterialPassIndex = 0;
    // RenderObjects 只在 Create() 里把 settings 转成 Pass 参数。这里 Renderer 尚未创建，
    // 它创建时会调用每个 Feature 的 Create()；若 Renderer 已在运行，改完 settings 必须手动再调一次。
    f.Create();
}

// 案例 25.5：DrawRenderers 的 Override Material——把物体画成纯白剪影，写进遮罩 RT。
Shader "Cookbook/Ch25/LayerMaskSolid"
{
    SubShader
    {
        Tags { "RenderType"="Opaque" "RenderPipeline"="UniversalPipeline" }
        Pass
        {
            Name "Mask"
            ZWrite Off      // 绝不改动相机深度；深度比较方式由 C# 的 RenderStateBlock 决定
            Cull Back

            HLSLPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"

            struct Attributes { float4 positionOS : POSITION; };
            struct Varyings { float4 positionCS : SV_POSITION; };

            Varyings vert(Attributes v)
            {
                Varyings o;
                o.positionCS = TransformObjectToHClip(v.positionOS.xyz);
                return o;
            }

            half4 frag(Varyings i) : SV_Target { return 1.0; }
            ENDHLSL
        }
    }
}

class MaskPass : ScriptableRenderPass
{
    // 只画原材质里有这些 LightMode 的物体（URP 前向渲染用到的三个标签）
    static readonly List<ShaderTagId> s_ShaderTags = new List<ShaderTagId>
    {
        new ShaderTagId("UniversalForward"),
        new ShaderTagId("UniversalForwardOnly"),
        new ShaderTagId("SRPDefaultUnlit"),
    };

    readonly Material m_Material;
    FilteringSettings m_Filtering;
    RenderStateBlock m_StateBlock;
    public RTHandle mask;           // 遮罩 RT（自己分配）
    public RTHandle cameraDepth;    // 借用相机深度做遮挡测试

    public MaskPass(Material material)
    {
        m_Material = material;
        profilingSampler = new ProfilingSampler("Ch25 Layer Mask");
        m_Filtering = new FilteringSettings(RenderQueueRange.all);
    }

    public void Setup(Settings s)
    {
        m_Filtering.layerMask = s.layerMask;
        // 用 RenderStateBlock 覆盖材质里的深度状态：透视模式 ZTest Always，否则 LEqual
        m_StateBlock = new RenderStateBlock(RenderStateMask.Depth)
        {
            depthState = new DepthState(false, s.seeThrough ? CompareFunction.Always : CompareFunction.LessEqual)
        };
    }

    public override void OnCameraSetup(CommandBuffer cmd, ref RenderingData renderingData)
    {
        // 遮罩与相机同尺寸、同 MSAA（要和相机深度一起绑定，两者采样数必须一致），单通道 8 位即可
        var desc = renderingData.cameraData.cameraTargetDescriptor;
        desc.graphicsFormat = GraphicsFormat.R8_UNorm;
        desc.depthBufferBits = 0;
        RenderingUtils.ReAllocateIfNeeded(ref mask, desc, FilterMode.Bilinear,
            TextureWrapMode.Clamp, name: "_Ch25LayerMask");

        // 告诉 URP：这个 Pass 画到 mask 上，深度用相机深度；开始前只清颜色（深度绝不能清）
        ConfigureTarget(mask, cameraDepth);
        ConfigureClear(ClearFlag.Color, Color.clear);
    }

    public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
    {
        var cmd = CommandBufferPool.Get();
        using (new ProfilingScope(cmd, profilingSampler))
        {
            // 先把命令缓冲里已有的命令提交，再调用 context 级别的 DrawRenderers
            context.ExecuteCommandBuffer(cmd);
            cmd.Clear();

            var drawing = CreateDrawingSettings(s_ShaderTags, ref renderingData, SortingCriteria.CommonOpaque);
            drawing.overrideMaterial = m_Material;          // 所有物体都换成纯白材质
            drawing.overrideMaterialPassIndex = 0;
            context.DrawRenderers(renderingData.cullResults, ref drawing, ref m_Filtering, ref m_StateBlock);
        }
        context.ExecuteCommandBuffer(cmd);
        CommandBufferPool.Release(cmd);
    }

    public void Dispose()
    {
        mask?.Release();
        mask = null;
    }
}

half4 Frag(Varyings input) : SV_Target
{
    UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);
    float2 uv = input.texcoord;
    half center = Mask(uv);

    // 膨胀（Dilation）：在半径 = 线宽、线宽/2 的两圈圆周上各取 12 个样本，求最大值
    float2 r = _BlitTexture_TexelSize.xy * _OutlineWidth;
    half dilated = center;
    [unroll] for (int k = 0; k < 12; k++)
    {
        float a = k * (TWO_PI / 12.0);
        float2 dir = float2(cos(a), sin(a));
        dilated = max(dilated, Mask(uv + dir * r));
        dilated = max(dilated, Mask(uv + dir * r * 0.5));
    }

    // 膨胀后的区域减去原区域 = 物体外侧一圈
    half outline = saturate(dilated - center);
    half3 rgb = lerp(_FillColor.rgb, _OutlineColor.rgb, outline);
    half alpha = outline * _OutlineColor.a + center * _FillColor.a;
    return half4(rgb, alpha);
}

class CompositePass : ScriptableRenderPass
{
    static readonly int s_OutlineColor = Shader.PropertyToID("_OutlineColor");
    static readonly int s_FillColor = Shader.PropertyToID("_FillColor");
    static readonly int s_OutlineWidth = Shader.PropertyToID("_OutlineWidth");

    readonly Material m_Material;
    MaskPass m_MaskPass;
    RTHandle m_CameraColor, m_CameraDepth;
    int m_ShaderPass;

    public CompositePass(Material material)
    {
        m_Material = material;
        profilingSampler = new ProfilingSampler("Ch25 Outline Composite");
    }

    public void Setup(Settings s, MaskPass maskPass)
    {
        m_MaskPass = maskPass;
        m_ShaderPass = s.mode == Mode.Outline ? 0 : 1;
        m_Material.SetColor(s_OutlineColor, s.outlineColor);
        m_Material.SetColor(s_FillColor, s.fillColor);
        m_Material.SetFloat(s_OutlineWidth, s.width);
    }

    public void SetTarget(RTHandle color, RTHandle depth)
    {
        m_CameraColor = color;
        m_CameraDepth = depth;
    }

    public override void OnCameraSetup(CommandBuffer cmd, ref RenderingData renderingData)
    {
        // 画回相机颜色。显式 ConfigureTarget，URP 会在 MaskPass 之后重新绑定相机目标
        ConfigureTarget(m_CameraColor, m_CameraDepth);
    }

    public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
    {
        var cmd = CommandBufferPool.Get();
        using (new ProfilingScope(cmd, profilingSampler))
        {
            // 不切换目标，直接在当前目标（相机颜色）上画一个全屏三角形，靠混合叠加上去
            Blitter.BlitTexture(cmd, m_MaskPass.mask, new Vector4(1, 1, 0, 0), m_Material, m_ShaderPass);
        }
        context.ExecuteCommandBuffer(cmd);
        CommandBufferPool.Release(cmd);
    }
}