class LayerPass : ScriptableRenderPass
{
    static readonly List<ShaderTagId> s_ShaderTags = new List<ShaderTagId>
    {
        new ShaderTagId("UniversalForward"),
        new ShaderTagId("UniversalForwardOnly"),
        new ShaderTagId("SRPDefaultUnlit"),
    };

    public LayerMask layerMask;
    public RTHandle color, depth;

    public LayerPass() { profilingSampler = new ProfilingSampler("Ch25 Ghost Layer"); }

    public override void OnCameraSetup(CommandBuffer cmd, ref RenderingData renderingData)
    {
        var desc = renderingData.cameraData.cameraTargetDescriptor;
        desc.msaaSamples = 1;

        // 颜色：带 Alpha 的半精度浮点（HDR 光照结果 + 覆盖率）
        var colorDesc = desc;
        colorDesc.graphicsFormat = GraphicsFormat.R16G16B16A16_SFloat;
        colorDesc.depthBufferBits = 0;
        RenderingUtils.ReAllocateIfNeeded(ref color, colorDesc, FilterMode.Bilinear,
            TextureWrapMode.Clamp, name: "_Ch25GhostColor");

        // 深度：纯深度格式的 RT，之后还要在合成 Shader 里当纹理采样
        var depthDesc = desc;
        depthDesc.graphicsFormat = GraphicsFormat.None;
        depthDesc.depthStencilFormat = GraphicsFormat.D32_SFloat;
        depthDesc.depthBufferBits = 32;
        RenderingUtils.ReAllocateIfNeeded(ref depth, depthDesc, FilterMode.Point,
            TextureWrapMode.Clamp, name: "_Ch25GhostDepth");

        ConfigureTarget(color, depth);
        ConfigureClear(ClearFlag.All, Color.clear);   // 颜色清成全透明，深度清成最远
    }

    public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
    {
        var cmd = CommandBufferPool.Get();
        using (new ProfilingScope(cmd, profilingSampler))
        {
            context.ExecuteCommandBuffer(cmd);
            cmd.Clear();
            // 不覆盖材质：用物体自己的 Lit 材质正常打光，只是画到了另一张 RT 上
            var drawing = CreateDrawingSettings(s_ShaderTags, ref renderingData,
                renderingData.cameraData.defaultOpaqueSortFlags);
            var filtering = new FilteringSettings(RenderQueueRange.opaque, layerMask);
            context.DrawRenderers(renderingData.cullResults, ref drawing, ref filtering);
        }
        context.ExecuteCommandBuffer(cmd);
        CommandBufferPool.Release(cmd);
    }

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

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

    // 1) 遮挡：幽灵层深度 与 场景深度 都换成线性深度再比较，与平台的 Reversed-Z 无关
    float ghostEye = LinearEyeDepth(SAMPLE_TEXTURE2D_X(_GhostDepth, sampler_PointClamp, uv).r, _ZBufferParams);
    float sceneEye = LinearEyeDepth(SampleSceneDepth(uv), _ZBufferParams);
    half visible = step(ghostEye, sceneEye + 0.01);

    // 2) 轮廓光：覆盖率（alpha）在邻域里的最小值 < 1 说明靠近剪影边缘
    float2 r = _BlitTexture_TexelSize.xy * _RimWidth;
    half minA = ghost.a;
    minA = min(minA, SAMPLE_TEXTURE2D_X(_BlitTexture, sampler_LinearClamp, uv + float2( r.x, 0)).a);
    minA = min(minA, SAMPLE_TEXTURE2D_X(_BlitTexture, sampler_LinearClamp, uv + float2(-r.x, 0)).a);
    minA = min(minA, SAMPLE_TEXTURE2D_X(_BlitTexture, sampler_LinearClamp, uv + float2(0,  r.y)).a);
    minA = min(minA, SAMPLE_TEXTURE2D_X(_BlitTexture, sampler_LinearClamp, uv + float2(0, -r.y)).a);
    half rim = ghost.a * (1.0 - minA);

    // 3) 整层统一透明度：内部的穿插面在离屏 RT 里已被深度测试剔除，合成时看不到
    half3 rgb = ghost.rgb * _Tint.rgb + _RimColor.rgb * rim;
    half alpha = saturate(ghost.a * _Opacity + rim) * visible;
    return half4(rgb, alpha);
}

class CompositePass : ScriptableRenderPass
{
    static readonly int s_GhostDepth = Shader.PropertyToID("_GhostDepth");
    static readonly int s_Opacity = Shader.PropertyToID("_Opacity");
    static readonly int s_Tint = Shader.PropertyToID("_Tint");
    static readonly int s_RimColor = Shader.PropertyToID("_RimColor");
    static readonly int s_RimWidth = Shader.PropertyToID("_RimWidth");

    readonly Material m_Material;
    LayerPass m_Layer;
    RTHandle m_CameraColor, m_CameraDepth;

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

    public void Setup(Settings s, LayerPass layer)
    {
        m_Layer = layer;
        m_Material.SetFloat(s_Opacity, s.opacity);
        m_Material.SetColor(s_Tint, s.tint);
        m_Material.SetColor(s_RimColor, s.rimColor);
        m_Material.SetFloat(s_RimWidth, s.rimWidth);
    }

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

    public override void OnCameraSetup(CommandBuffer cmd, ref RenderingData renderingData)
        => ConfigureTarget(m_CameraColor, m_CameraDepth);

    public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
    {
        var cmd = CommandBufferPool.Get();
        using (new ProfilingScope(cmd, profilingSampler))
        {
            cmd.SetGlobalTexture(s_GhostDepth, m_Layer.depth);
            Blitter.BlitTexture(cmd, m_Layer.color, new Vector4(1, 1, 0, 0), m_Material, 0);
        }
        context.ExecuteCommandBuffer(cmd);
        CommandBufferPool.Release(cmd);
    }
}

[BookShot("ch25-ghost", W = 640, H = 440, Panels = 3)]
static void Ghost(Shot s)
{
    GhostStage(s, naive: s.Panel == 0);
    if (s.Panel == 0) return;    // 第 1 格：逐物体半透明（对照组）

    // 幽灵层不参与主不透明 Pass，只由 Feature 单独绘制
    s.Renderer.opaqueLayerMask = ~(1 << LayerB);
    var f = s.Feature<GhostLayerFeature>();
    f.settings.layerMask = 1 << LayerB;
    if (s.Panel == 1) { f.settings.rimWidth = 0; f.settings.opacity = 0.45f; }
    else { f.settings.rimWidth = 3; f.settings.opacity = 0.3f; }
}