// 第 28 章通用的“全屏效果” Renderer Feature（URP 14 的 RTHandle + Blitter 写法）。
// 做的事很简单：把相机颜色拷贝到一张临时 RT，再用指定材质画回相机颜色。
// 本章的世界坐标重建、扫描线、雾、SSR 都靠它跑，算法全部写在各自的 Shader 里。
using UnityEngine;
using UnityEngine.Rendering;
using UnityEngine.Rendering.Universal;

namespace Cookbook.Ch28
{
    public class ScreenEffectFeature : ScriptableRendererFeature
    {
        [System.Serializable]
        public class Settings
        {
            public Material material;
            public int passIndex = 0;
            // 屏幕空间效果大多放在不透明物体之后、后处理之前
            public RenderPassEvent renderPassEvent = RenderPassEvent.BeforeRenderingPostProcessing;
            // 需要哪些屏幕纹理：Depth 会保证 _CameraDepthTexture 可用，Normal 会触发 DepthNormals 预通道
            public ScriptableRenderPassInput requirements = ScriptableRenderPassInput.Depth;
        }
        public Settings settings = new Settings();

        ScreenEffectPass m_Pass;

        public override void Create()
        {
            m_Pass = new ScreenEffectPass(name);
        }

        public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData)
        {
            var camType = renderingData.cameraData.cameraType;
            if (settings.material == null || camType == CameraType.Preview || camType == CameraType.Reflection)
                return;
            m_Pass.renderPassEvent = settings.renderPassEvent;
            m_Pass.ConfigureInput(settings.requirements);
            m_Pass.Setup(settings.material, settings.passIndex);
            renderer.EnqueuePass(m_Pass);
        }

        public override void SetupRenderPasses(ScriptableRenderer renderer, in RenderingData renderingData)
        {
            // cameraColorTargetHandle 只有在这里（以及之后）才是本帧有效的句柄
            m_Pass.SetTarget(renderer.cameraColorTargetHandle);
        }

        protected override void Dispose(bool disposing)
        {
            m_Pass?.Dispose();
        }

        class ScreenEffectPass : ScriptableRenderPass
        {
            Material m_Material;
            int m_PassIndex;
            RTHandle m_CameraColor;
            RTHandle m_Copy;

            public ScreenEffectPass(string name)
            {
                profilingSampler = new ProfilingSampler(name);
            }

            public void Setup(Material material, int passIndex) { m_Material = material; m_PassIndex = passIndex; }
            public void SetTarget(RTHandle cameraColor) { m_CameraColor = cameraColor; }

            public override void OnCameraSetup(CommandBuffer cmd, ref RenderingData renderingData)
            {
                // 临时 RT 与相机目标同尺寸、同格式，但不要 MSAA、不要深度
                var desc = renderingData.cameraData.cameraTargetDescriptor;
                desc.msaaSamples = 1;
                desc.depthBufferBits = 0;
                RenderingUtils.ReAllocateIfNeeded(ref m_Copy, desc, FilterMode.Bilinear, TextureWrapMode.Clamp, name: "_ScreenEffectCopy");
                ConfigureTarget(m_CameraColor);
            }

            public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
            {
                var cmd = CommandBufferPool.Get();
                using (new ProfilingScope(cmd, profilingSampler))
                {
                    // 不能边读边写同一张 RT：先拷贝，再以拷贝为 _BlitTexture 画回去
                    Blitter.BlitCameraTexture(cmd, m_CameraColor, m_Copy);
                    Blitter.BlitCameraTexture(cmd, m_Copy, m_CameraColor, m_Material, m_PassIndex);
                }
                context.ExecuteCommandBuffer(cmd);
                CommandBufferPool.Release(cmd);
            }

            public void Dispose() { m_Copy?.Release(); }
        }
    }
}

float4 ComputeClipSpacePosition(float2 positionNDC, float deviceDepth)
{
    float4 positionCS = float4(positionNDC * 2.0 - 1.0, deviceDepth, 1.0);
#if UNITY_UV_STARTS_AT_TOP
    // 投影矩阵里已经烘焙了上下翻转，这里从 CS 回到 NDC 时要手动翻回来
    positionCS.y = -positionCS.y;
#endif
    return positionCS;
}

float3 ComputeWorldSpacePosition(float2 positionNDC, float deviceDepth, float4x4 invViewProjMatrix)
{
    float4 positionCS  = ComputeClipSpacePosition(positionNDC, deviceDepth);
    float4 hpositionWS = mul(invViewProjMatrix, positionCS);
    return hpositionWS.xyz / hpositionWS.w;
}

// 读“设备深度”，并统一成 ComputeWorldSpacePosition 需要的 NDC z
float SampleDeviceDepth(float2 uv)
{
    float d = SampleSceneDepth(uv);
#if !UNITY_REVERSED_Z
    // OpenGL 系：深度纹理是 [0,1]，而它的裁剪空间 z 是 [-1,1]
    d = lerp(UNITY_NEAR_CLIP_VALUE, 1, d);
#endif
    return d;
}

// 循环里采样深度要用显式 LOD 版本：带隐式导数的 SAMPLE_TEXTURE2D 在动态循环里
// 会逼编译器展开整个循环（Metal/D3D 都会报 unable to unroll loop）
float SampleSceneDepthLod(float2 uv)
{
    return SAMPLE_TEXTURE2D_X_LOD(_CameraDepthTexture, sampler_CameraDepthTexture, UnityStereoTransformScreenSpaceTex(uv), 0).r;
}

// 天空（没有写深度的像素）：Reversed-Z 下是 0，否则是 1
bool IsSkyDepth(float deviceDepth)
{
#if UNITY_REVERSED_Z
    return deviceDepth < 1e-6;
#else
    return deviceDepth > 1 - 1e-6;
#endif
}

// 方法一：逆 VP 矩阵。uv + 深度 → NDC → 乘逆矩阵 → 齐次除法
float3 ReconstructPositionWS(float2 uv, float deviceDepth)
{
    return ComputeWorldSpacePosition(uv, deviceDepth, UNITY_MATRIX_I_VP);
}

// 方法二：视锥射线。顶点着色器里算“相机 → 远裁剪面”的向量，光栅化线性插值后，
// 片元里乘上 0~1 的线性深度即可，每像素省掉一次 4x4 矩阵乘法和除法。
struct VaryingsRay
{
    float4 positionCS : SV_POSITION;
    float2 texcoord   : TEXCOORD0;
    float3 farRayWS   : TEXCOORD1;   // 相机位置 → 该像素对应的远裁剪面上的点
    UNITY_VERTEX_OUTPUT_STEREO
};

VaryingsRay VertRay(Attributes input)
{
    VaryingsRay output;
    UNITY_SETUP_INSTANCE_ID(input);
    UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output);
#if SHADER_API_GLES
    float4 pos = input.positionOS;
    float2 uv  = input.uv;
#else
    float4 pos = GetFullScreenTriangleVertexPosition(input.vertexID);
    float2 uv  = GetFullScreenTriangleTexCoord(input.vertexID);
#endif
    output.positionCS = pos;
    output.texcoord   = uv * _BlitScaleBias.xy + _BlitScaleBias.zw;
    // 远平面上的点关于屏幕坐标是仿射（线性）的，所以只在 3 个顶点算、再插值，结果是精确的
    float3 farWS = ComputeWorldSpacePosition(output.texcoord, UNITY_RAW_FAR_CLIP_VALUE, UNITY_MATRIX_I_VP);
    output.farRayWS = farWS - _WorldSpaceCameraPos;
    return output;
}

float3 ReconstructPositionWSFromRay(float3 farRayWS, float rawDepth)
{
    // Linear01Depth = 观察空间深度 / 远裁剪面距离，正好是射线的缩放系数
    return _WorldSpaceCameraPos + farRayWS * Linear01Depth(rawDepth, _ZBufferParams);
}

half4 Frag(Varyings input) : SV_Target
{
    UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);
    float2 uv = input.texcoord;
    half4 sceneColor = SAMPLE_TEXTURE2D_X(_BlitTexture, sampler_PointClamp, uv);
    float depth = SampleDeviceDepth(uv);
    if (IsSkyDepth(depth)) return sceneColor * 0.35;   // 天空没有几何，压暗区分
    float3 positionWS = ReconstructPositionWS(uv, depth);
    // +0.5：避开地面 y=0 这种整数坐标，frac 在 0/1 之间来回跳会产生噪点
    return half4(frac(positionWS + 0.5), 1);
}

half4 Frag(VaryingsRay input) : SV_Target
{
    UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);
    float2 uv = input.texcoord;
    half4 sceneColor = SAMPLE_TEXTURE2D_X(_BlitTexture, sampler_PointClamp, uv);
    float rawDepth = SampleSceneDepth(uv);
    if (IsSkyDepth(rawDepth)) return sceneColor;
    float3 positionWS = ReconstructPositionWSFromRay(input.farRayWS, rawDepth);

    // 1 米网格线：用 fwidth 把线宽换算成像素，远近粗细一致
    float3 dist = abs(frac(positionWS + 0.5) - 0.5);
    float3 width = fwidth(positionWS) * _GridWidth;
    float3 lines = 1 - smoothstep(width * 0.5, width * 1.5, dist);
    float grid = saturate(max(lines.x, max(lines.y, lines.z)));
    return lerp(sceneColor, _GridColor, grid * 0.85);
}

half4 Frag(VaryingsRay input) : SV_Target
{
    UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);
    float2 uv = input.texcoord;
    half4 color = SAMPLE_TEXTURE2D_X(_BlitTexture, sampler_PointClamp, uv);
    float rawDepth = SampleSceneDepth(uv);
    if (IsSkyDepth(rawDepth)) return color;
    float3 positionWS = ReconstructPositionWSFromRay(input.farRayWS, rawDepth);

    // 当前波前半径：运行时用 _Time 循环，拍摄/调试时用 _Progress 定格
    float t = _UseTime > 0.5 ? frac(_Time.y * _Speed) : _Progress;
    float radius = t * _MaxRadius;

    // 水平距离：只看 xz，扫描波像贴着地面向外扩
    float d = distance(positionWS.xz, _ScanCenter.xz);
    float behind = radius - d;                     // >0 表示已被波前扫过

    // 波前亮边：|behind| 很小的一圈
    float edge = 1 - smoothstep(0, _EdgeWidth, abs(behind));
    // 尾迹：波前后方 _TrailWidth 米内从 1 渐隐到 0
    float trail = (behind > 0) ? pow(saturate(1 - behind / _TrailWidth), 2) : 0;

    // 尾迹里的世界网格（xz 平面），fwidth 让线宽恒定为 ~1 像素
    float2 g = abs(frac(positionWS.xz / _GridSize + 0.5) - 0.5) * _GridSize;
    float2 gw = fwidth(positionWS.xz);
    float grid = 1 - min(smoothstep(gw.x * 0.5, gw.x * 1.5, g.x), smoothstep(gw.y * 0.5, gw.y * 1.5, g.y));

    // 越扩越淡，扫完一圈自然消失
    float fade = 1 - smoothstep(0.7, 1.0, t);
    float intensity = (edge * 1.5 + trail * (0.25 + 0.75 * grid)) * fade;
    color.rgb += _ScanColor.rgb * intensity;
    return color;
}

// 高度雾的光学厚度：密度 σ(y) = a·exp(-b·(y - h0))，沿射线 c + t·v (0≤t≤L) 积分
float HeightFogOpticalDepth(float3 camPos, float3 viewDir, float rayLength)
{
    float a = _HeightDensity, b = _HeightFalloff;
    float densityAtCam = a * exp(-b * (camPos.y - _FogBaseHeight));
    float k = b * viewDir.y * rayLength;          // 射线跨过的“高度衰减量”
    // (1 - e^{-k}) / k 在 k→0 时趋于 1；用泰勒展开避免水平视线除零
    float factor = abs(k) > 1e-3 ? (1 - exp(-k)) / k : 1 - 0.5 * k;
    return densityAtCam * rayLength * factor;
}

half4 Frag(VaryingsRay input) : SV_Target
{
    UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);
    float2 uv = input.texcoord;
    half4 color = SAMPLE_TEXTURE2D_X(_BlitTexture, sampler_PointClamp, uv);
    float rawDepth = SampleSceneDepth(uv);

    float3 viewDir = normalize(input.farRayWS);
    float rayLength = IsSkyDepth(rawDepth) ? _SkyDistance
                    : length(ReconstructPositionWSFromRay(input.farRayWS, rawDepth) - _WorldSpaceCameraPos);

    float tauDistance = _DistanceDensity * max(0, rayLength - _FogStart);
    float tauHeight = HeightFogOpticalDepth(_WorldSpaceCameraPos, viewDir, rayLength);
    float transmittance = exp(-(tauDistance + tauHeight));

    // 朝太阳看时雾更亮更暖（前向散射的廉价近似）
    Light mainLight = GetMainLight();
    float sunAmount = pow(saturate(dot(viewDir, mainLight.direction)), _SunScatterPower);
    half3 fogColor = lerp(_FogColor.rgb, _SunScatterColor.rgb * mainLight.color, sunAmount);

    color.rgb = color.rgb * transmittance + fogColor * (1 - transmittance);
    return color;
}

// Relative postition of the sample point
half3 v_s2 = half3(ReconstructViewPos(uv_s1_01, linearDepth_s) - vpos_o);

// Estimate the obscurance value
half dotVal = dot(v_s2, normal_o) - kBeta * halfLinearDepth_o;
half a1 = max(dotVal, HALF_ZERO);
half a2 = dot(v_s2, v_s2) + kEpsilon;
ao += a1 * rcp(a2) * isInsideRadius;

AmbientOcclusionFactor GetScreenSpaceAmbientOcclusion(float2 normalizedScreenSpaceUV)
{
    AmbientOcclusionFactor aoFactor;
    #if defined(_SCREEN_SPACE_OCCLUSION) && !defined(_SURFACE_TYPE_TRANSPARENT)
        float ssao = saturate(SampleAmbientOcclusion(normalizedScreenSpaceUV) + (1.0 - _AmbientOcclusionParam.x));
        aoFactor.indirectAmbientOcclusion = ssao;
        aoFactor.directAmbientOcclusion = lerp(half(1.0), ssao, _AmbientOcclusionParam.w);
    #else
    ...

half4 FragAO(Varyings input) : SV_Target
{
    UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);
    float2 uv = input.texcoord;
    float depth = SampleDeviceDepth(uv);
    if (IsSkyDepth(depth)) return 1;

    float3 positionWS = ReconstructPositionWS(uv, depth);
    float3 normalWS = normalize(SampleSceneNormals(uv));   // URP 14 的法线纹理是世界空间
    float centerEye = LinearEyeDepth(positionWS, UNITY_MATRIX_V);

    // 每像素一个随机旋转角，把规则的采样图案打散成高频噪声，后面再模糊掉
    float noise = InterleavedGradientNoise(input.positionCS.xy, 0);
    float3 randomDir = float3(cos(noise * TWO_PI), sin(noise * TWO_PI), 0.37);
    float3 tangentWS = normalize(cross(normalWS, randomDir));
    float3 bitangentWS = cross(normalWS, tangentWS);

    int count = (int)_SampleCount;
    float occlusion = 0;
    for (int i = 0; i < count; i++)
    {
        // 余弦分布的半球方向（黄金角螺旋），长度向中心聚集：近处样本更重要
        float u = (i + 0.5) / count;
        float phi = i * 2.39996323;
        float cosTheta = sqrt(1 - u), sinTheta = sqrt(u);
        float3 dirTS = float3(cos(phi) * sinTheta, sin(phi) * sinTheta, cosTheta);
        float lenScale = lerp(0.1, 1.0, frac(u * 7.31 + noise) * frac(u * 7.31 + noise));
        float3 offsetWS = (tangentWS * dirTS.x + bitangentWS * dirTS.y + normalWS * dirTS.z) * (lenScale * _Radius);
        float3 sampleWS = positionWS + offsetWS;

        // 投影回屏幕，读那里的场景深度
        float2 sampleUV = ComputeNormalizedDeviceCoordinates(sampleWS, UNITY_MATRIX_VP);
        float sampleEye = LinearEyeDepth(sampleWS, UNITY_MATRIX_V);
        float sceneEye = EyeDepthAt(sampleUV);

        // 场景表面在样本点前面 → 样本点被埋住 → 记一次遮挡
        float occluded = sceneEye < sampleEye - _Bias ? 1 : 0;
        // 范围检查：深度差远大于半径的（背景前的前景边缘）不算，避免黑边光晕
        float rangeCheck = smoothstep(0, 1, _Radius / max(abs(centerEye - sceneEye), 1e-4));
        occlusion += occluded * rangeCheck;
    }
    float visibility = saturate(1 - occlusion / count * _Intensity);
    return half4(visibility, visibility, visibility, 1);
}

// 双边模糊：高斯权重 × 深度相似度权重，跨越深度断层的样本被压低，AO 不会渗到背景上
half4 BilateralBlur(float2 uv, float2 dir)
{
    static const float w[4] = { 0.324, 0.232, 0.0855, 0.0205 };
    float centerEye = EyeDepthAt(uv);
    half sum = SAMPLE_TEXTURE2D_X(_BlitTexture, sampler_LinearClamp, uv).r * w[0];
    float wsum = w[0];
    for (int i = 1; i < 4; i++)
    {
        for (int s = -1; s <= 1; s += 2)
        {
            float2 suv = uv + dir * (i * s);
            float d = EyeDepthAt(suv);
            float wd = w[i] * exp(-abs(d - centerEye) / max(centerEye * 0.02, 1e-3));
            sum += SAMPLE_TEXTURE2D_X_LOD(_BlitTexture, sampler_LinearClamp, suv, 0).r * wd;
            wsum += wd;
        }
    }
    half v = sum / wsum;
    return half4(v, v, v, 1);
}

// 进光照：必须在不透明物体之前，且要等深度/法线预通道画完（+1 与 URP 自带 SSAO 一致）
m_Pass.renderPassEvent = settings.mode == Mode.IntoLighting
    ? RenderPassEvent.AfterRenderingPrePasses + 1
    : RenderPassEvent.AfterRenderingOpaques;
// 要法线：Forward 路径下这会让 URP 执行 DepthNormals 预通道
m_Pass.ConfigureInput(ScriptableRenderPassInput.Depth | ScriptableRenderPassInput.Normal);

public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
{
    var mat = m_Settings.material;
    var cmd = CommandBufferPool.Get();
    using (new ProfilingScope(cmd, profilingSampler))
    {
        int w = m_AO.rt.width, h = m_AO.rt.height;
        mat.SetVector(s_TexelSize, new Vector4(1f / w, 1f / h, w, h));

        // 1) AO：没有输入纹理，直接画全屏三角形到 m_AO
        CoreUtils.SetRenderTarget(cmd, m_AO);
        Blitter.BlitTexture(cmd, new Vector4(1, 1, 0, 0), mat, 0);
        // 2) 可分离双边模糊：AO → Temp（横）→ AO（竖）
        if (m_Settings.blur)
        {
            Blitter.BlitCameraTexture(cmd, m_AO, m_AOTemp, mat, 1);
            Blitter.BlitCameraTexture(cmd, m_AOTemp, m_AO, mat, 2);
        }

        if (m_Settings.mode == Mode.IntoLighting)
        {
            // 3a) 按 URP 的约定把结果交给光照：纹理 + 关键字 + 参数（w = 直接光受 AO 影响的比例）
            cmd.SetGlobalTexture(s_URPOcclusionTex, m_AO);
            cmd.SetGlobalVector(s_URPOcclusionParam, new Vector4(1, 0, 0, m_Settings.directLightingStrength));
            CoreUtils.SetKeyword(cmd, k_URPKeyword, true);
        }
        else
        {
            // 3b) 直接乘到相机颜色上（或只显示 AO）
            cmd.SetGlobalTexture(s_Result, m_AO);
            Blitter.BlitCameraTexture(cmd, m_CameraColor, m_ColorCopy);
            Blitter.BlitCameraTexture(cmd, m_ColorCopy, m_CameraColor, mat, m_Settings.mode == Mode.ShowAO ? 4 : 3);
        }
    }
    context.ExecuteCommandBuffer(cmd);
    CommandBufferPool.Release(cmd);
}

public override void OnCameraCleanup(CommandBuffer cmd)
{
    // 关键字是全局状态，用完一定要关，否则会“漏”到下一台相机
    if (m_Settings != null && m_Settings.mode == Mode.IntoLighting)
        CoreUtils.SetKeyword(cmd, k_URPKeyword, false);
}