// 案例 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); }
}