// 摘自 URP 14 ShaderLibrary/Shadows.hlsl
half GetMainLightShadowFade(float3 positionWS)
{
    float3 camToPixel = positionWS - _WorldSpaceCameraPos;
    float distanceCamToPixel2 = dot(camToPixel, camToPixel);
    float fade = saturate(distanceCamToPixel2 * float(_MainLightShadowParams.z) + float(_MainLightShadowParams.w));
    return half(fade);
}

// 摘自 URP 14 ShaderLibrary/Shadows.hlsl
half ComputeCascadeIndex(float3 positionWS)
{
    float3 fromCenter0 = positionWS - _CascadeShadowSplitSpheres0.xyz;
    // …… fromCenter1~3 同理
    float4 distances2 = float4(dot(fromCenter0, fromCenter0), dot(fromCenter1, fromCenter1),
                               dot(fromCenter2, fromCenter2), dot(fromCenter3, fromCenter3));
    half4 weights = half4(distances2 < _CascadeShadowSplitSphereRadii);
    weights.yzw = saturate(weights.yzw - weights.xyz);
    return half(4.0) - dot(weights, half4(4, 3, 2, 1));
}

half4 frag(Varyings i) : SV_Target
{
    float4 shadowCoord = TransformWorldToShadowCoord(i.positionWS);
    half shadow = MainLightRealtimeShadow(shadowCoord);
    if (_Mode > 0.5) return half4(shadow.xxx, 1);

    half3 n = normalize(i.normalWS);
    Light l = GetMainLight();
    half3 shade = (saturate(dot(n, l.direction)) * shadow * 0.8 + 0.25).xxx;
    #if defined(_MAIN_LIGHT_SHADOWS_CASCADE)
        half cascade = ComputeCascadeIndex(i.positionWS);   // 0..3，超出所有级联球为 4
    #else
        half cascade = 0;
    #endif
    static const half3 kColors[5] =
    {
        half3(1.0, 0.35, 0.3), half3(0.35, 0.9, 0.4), half3(0.35, 0.55, 1.0),
        half3(1.0, 0.85, 0.3), half3(0.6, 0.6, 0.6)
    };
    half3 tint = lerp(half3(1, 1, 1), kColors[(int)cascade], _Tint);
    return half4(shade * tint, 1);
}

// 摘自 URP 14 ShaderLibrary/Shadows.hlsl
float3 ApplyShadowBias(float3 positionWS, float3 normalWS, float3 lightDirection)
{
    float invNdotL = 1.0 - saturate(dot(lightDirection, normalWS));
    float scale = invNdotL * _ShadowBias.y;
    // normal bias is negative since we want to apply an inset normal offset
    positionWS = lightDirection * _ShadowBias.xxx + positionWS;
    positionWS = normalWS * scale.xxx + positionWS;
    return positionWS;
}

// 案例 23.3：平面投影阴影（Planar Shadow）。
// 第一个 Pass 正常着色；第二个 Pass（SRPDefaultUnlit）把同一个网格沿主光方向“拍扁”到地面上，
// 输出半透明的阴影色，并用模板测试保证同一个像素只被阴影覆盖一次，避免重叠部分变黑。
Shader "Cookbook/Ch23/PlanarShadow"
{
    Properties
    {
        [MainColor] _BaseColor ("Base Color", Color) = (0.9, 0.6, 0.3, 1)
        _ShadowColor ("Shadow Color", Color) = (0.05, 0.06, 0.1, 0.65)
        _PlaneHeight ("Plane Height (世界空间 y)", Float) = 0
        _ShadowFalloff ("Height Falloff", Range(0, 2)) = 0.35
        [Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp ("Stencil Comp", Float) = 6  // 6 = NotEqual
    }
    SubShader
    {
        // 排在普通不透明物体之后，保证地面已经画好，阴影才能混合到地面颜色上
        Tags { "RenderType"="Opaque" "RenderPipeline"="UniversalPipeline" "Queue"="Geometry+10" }

        HLSLINCLUDE
        #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
        CBUFFER_START(UnityPerMaterial)
            half4 _BaseColor;
            half4 _ShadowColor;
            float _PlaneHeight;
            float _ShadowFalloff;
        CBUFFER_END
        ENDHLSL

        Pass
        {
            Name "ForwardLit"
            Tags { "LightMode"="UniversalForward" }
            HLSLPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"
            struct Attributes { float4 positionOS : POSITION; float3 normalOS : NORMAL; };
            struct Varyings { float4 positionCS : SV_POSITION; half3 normalWS : TEXCOORD0; };
            Varyings vert(Attributes v)
            {
                Varyings o;
                o.positionCS = TransformObjectToHClip(v.positionOS.xyz);
                o.normalWS = TransformObjectToWorldNormal(v.normalOS);
                return o;
            }
            half4 frag(Varyings i) : SV_Target
            {
                half3 n = normalize(i.normalWS);
                Light l = GetMainLight();
                half3 c = _BaseColor.rgb * (l.color * saturate(dot(n, l.direction)) + SampleSH(n));
                return half4(c, 1);
            }
            ENDHLSL
        }

        Pass
        {
            Name "PlanarShadow"
            Tags { "LightMode"="SRPDefaultUnlit" }   // URP 会把它和 UniversalForward 一起画

            Stencil
            {
                Ref 1
                Comp [_StencilComp]   // NotEqual：这个像素还没画过阴影才画
                Pass Replace          // 画过就把模板写成 1，后面的阴影三角形再来就被拒绝
            }
            Blend SrcAlpha OneMinusSrcAlpha
            ZWrite Off
            Cull Back

            HLSLPROGRAM
            #pragma vertex vert
            #pragma fragment frag

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

            Varyings vert(Attributes v)
            {
                Varyings o;
                float3 positionWS = TransformObjectToWorld(v.positionOS.xyz);
                // _MainLightPosition.xyz 对方向光来说是“指向光源”的单位向量 L
                float3 L = normalize(_MainLightPosition.xyz);

                // 求沿 -L 方向走多远能碰到平面 y = h：  P' = P - L * (P.y - h) / L.y
                float height = positionWS.y - _PlaneHeight;
                float3 projected = positionWS - L * (height / max(L.y, 1e-3));
                projected.y = _PlaneHeight + 0.002;   // 抬高 2 毫米，避免与地面 Z-Fighting

                o.positionCS = TransformWorldToHClip(projected);
                // 离地越高的部位投下的阴影越淡，模拟真实阴影随距离变软变淡
                o.fade = saturate(1.0 - height * _ShadowFalloff);
                return o;
            }

            half4 frag(Varyings i) : SV_Target
            {
                return half4(_ShadowColor.rgb, _ShadowColor.a * i.fade);
            }
            ENDHLSL
        }

        Pass
        {
            Name "DepthOnly"
            Tags { "LightMode"="DepthOnly" }
            ZWrite On ColorMask R
            HLSLPROGRAM
            #pragma vertex Ch23DepthOnlyVert
            #pragma fragment Ch23NullFrag
            #include "Assets/Cookbook/Ch23/Ch23Common.hlsl"
            ENDHLSL
        }
    }
}

Pass
{
    Name "PlanarShadow"
    Tags { "LightMode"="SRPDefaultUnlit" }   // URP 会把它和 UniversalForward 一起画

    Stencil
    {
        Ref 1
        Comp [_StencilComp]   // NotEqual：这个像素还没画过阴影才画
        Pass Replace          // 画过就把模板写成 1，后面的阴影三角形再来就被拒绝
    }
    Blend SrcAlpha OneMinusSrcAlpha
    ZWrite Off
    Cull Back

    HLSLPROGRAM
    #pragma vertex vert
    #pragma fragment frag

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

    Varyings vert(Attributes v)
    {
        Varyings o;
        float3 positionWS = TransformObjectToWorld(v.positionOS.xyz);
        // _MainLightPosition.xyz 对方向光来说是“指向光源”的单位向量 L
        float3 L = normalize(_MainLightPosition.xyz);

        // 求沿 -L 方向走多远能碰到平面 y = h：  P' = P - L * (P.y - h) / L.y
        float height = positionWS.y - _PlaneHeight;
        float3 projected = positionWS - L * (height / max(L.y, 1e-3));
        projected.y = _PlaneHeight + 0.002;   // 抬高 2 毫米，避免与地面 Z-Fighting

        o.positionCS = TransformWorldToHClip(projected);
        // 离地越高的部位投下的阴影越淡，模拟真实阴影随距离变软变淡
        o.fade = saturate(1.0 - height * _ShadowFalloff);
        return o;
    }

    half4 frag(Varyings i) : SV_Target
    {
        return half4(_ShadowColor.rgb, _ShadowColor.a * i.fade);
    }
    ENDHLSL
}

half4 frag(Varyings i) : SV_Target
{
    // d：0 在圆心，1 在 Quad 内切圆边缘
    half d = length(i.uv - 0.5) * 2.0;
    // 1 - smoothstep 做出中心实、边缘软的衰减；Softness 越大，实心区越小
    half mask = 1.0 - smoothstep(1.0 - _Softness, 1.0, d);
    mask *= mask;                               // 平方让过渡更接近真实半影
    half3 c = lerp(half3(1, 1, 1), _ShadowColor.rgb, mask * _Strength);
    return half4(c, 1);
}

public void Apply()
{
    if (target == null) return;
    if (m_Renderer == null) m_Renderer = GetComponent<Renderer>();

    Vector3 origin = target.position;
    Vector3 groundPos = new Vector3(origin.x, fallbackGroundY, origin.z);
    Vector3 groundNormal = Vector3.up;
    if (Physics.Raycast(origin, Vector3.down, out var hit, maxHeight * 4f, groundMask, QueryTriggerInteraction.Ignore))
    {
        groundPos = hit.point;
        groundNormal = hit.normal;
    }

    float height = Mathf.Max(0f, origin.y - groundPos.y);
    float t = Mathf.Clamp01(height / maxHeight);

    // Quad 默认朝 -Z，旋转到“正面朝上”并贴合地面法线
    transform.SetPositionAndRotation(groundPos + groundNormal * 0.005f,
        Quaternion.FromToRotation(Vector3.back, groundNormal));
    transform.localScale = Vector3.one * baseSize * (1f + growth * t);

    // 用 MaterialPropertyBlock 改每个阴影自己的浓度，不必为每个单位复制材质。
    // 注意：带 MPB 的 Renderer 不再走 SRP Batcher；单位很多时改用 GPU Instancing 或顶点色。
    m_Block ??= new MaterialPropertyBlock();
    m_Renderer.GetPropertyBlock(m_Block);
    m_Block.SetFloat(s_Strength, strength * (1f - t));
    m_Renderer.SetPropertyBlock(m_Block);
}

half4 frag(Varyings input) : SV_Target
{
    half3 albedo = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, input.uv).rgb * _BaseColor.rgb;
    half3 normalWS = normalize(input.normalWS);

    // 逐像素求阴影坐标：同时兼容单级联 / 多级联 / 屏幕空间阴影三种关键字
    float4 shadowCoord = TransformWorldToShadowCoord(input.positionWS);
    // 带 positionWS 的重载会顺带处理“阴影距离淡出”（GetMainLightShadowFade）
    Light mainLight = GetMainLight(shadowCoord, input.positionWS, half4(1, 1, 1, 1));

    half NdotL  = saturate(dot(normalWS, mainLight.direction));
    half shadow = mainLight.shadowAttenuation;

    // lit：0 = 完全不受光，1 = 完全受光
    // _TintTerminator=1 时背光面（NdotL 小）也算“阴影”，整体风格更统一；
    // _TintTerminator=0 时只给投射阴影上色，明暗交界线保持 Lambert 的自然过渡
    half lit = _TintTerminator > 0.5 ? NdotL * shadow : shadow;
    half3 shadowTint = lerp(half3(0, 0, 0), _ShadowColor.rgb, _ShadowColor.a);
    half3 direct = lerp(shadowTint, mainLight.color, lit);
    if (_TintTerminator < 0.5) direct *= NdotL;  // 只染投射阴影时仍需要 N·L

    half3 ambient = SampleSH(normalWS) * _AmbientScale;
    half3 color = albedo * (direct + ambient);
    color = MixFog(color, input.fogFactor);
    return half4(color, 1);
}

// 摘自 URP 14 Shaders/Utils/ScreenSpaceShadows.shader
float3 wpos = ComputeWorldSpacePosition(input.texcoord.xy, deviceDepth, unity_MatrixInvVP);
float4 coords = TransformWorldToShadowCoord(wpos);
half realtimeShadow = MainLightRealtimeShadow(coords);
return realtimeShadow;

// 4×4 Bayer 矩阵：相邻阈值尽量分散，丢弃的像素在空间上均匀
static const half kBayer4x4[16] =
{
     0,  8,  2, 10,
    12,  4, 14,  6,
     3, 11,  1,  9,
    15,  7, 13,  5
};

half4 frag(Varyings i) : SV_Target
{
    half alpha = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, i.uv).a * _BaseColor.a * _ShadowAlphaScale;
    if (_DitherShadow > 0.5)
    {
        // 在 ShadowCaster 里，SV_POSITION.xy 就是阴影贴图上的像素坐标
        uint2 p = uint2(i.positionCS.xy) & 3;
        half threshold = (kBayer4x4[p.y * 4 + p.x] + 0.5) / 16.0;
        clip(alpha - threshold);
    }
    return 0;
}

class ContactShadowPass : ScriptableRenderPass
{
    static readonly int s_Params = Shader.PropertyToID("_ContactParams");
    static readonly int s_LightDir = Shader.PropertyToID("_ContactLightDir");
    readonly ProfilingSampler m_Sampler = new ProfilingSampler("ContactShadows");

    RTHandle m_Target;
    Material m_Material;
    Settings m_Settings;
    Vector3 m_LightDir;

    public void Setup(Settings s, Material material, Vector3 lightDir)
    {
        m_Settings = s; m_Material = material; m_LightDir = lightDir;
        // 声明需要深度纹理：URP 会因此安排 DepthPrepass，保证此时 _CameraDepthTexture 已就绪
        ConfigureInput(ScriptableRenderPassInput.Depth);
    }

    public override void OnCameraSetup(CommandBuffer cmd, ref RenderingData renderingData)
    {
        var desc = renderingData.cameraData.cameraTargetDescriptor;
        desc.depthBufferBits = 0;
        desc.msaaSamples = 1;
        desc.graphicsFormat = RenderingUtils.SupportsGraphicsFormat(GraphicsFormat.R8_UNorm, FormatUsage.Linear | FormatUsage.Render)
            ? GraphicsFormat.R8_UNorm : GraphicsFormat.B8G8R8A8_UNorm;
        RenderingUtils.ReAllocateIfNeeded(ref m_Target, desc, FilterMode.Bilinear, TextureWrapMode.Clamp, name: "_ContactShadowTexture");
        cmd.SetGlobalTexture(m_Target.name, m_Target.nameID);
        ConfigureTarget(m_Target);
        ConfigureClear(ClearFlag.None, Color.white);
    }

    public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
    {
        // URP 14 里 renderingData.commandBuffer 是 internal，自己的 Feature 从池里借一个
        var cmd = CommandBufferPool.Get();
        using (new ProfilingScope(cmd, m_Sampler))
        {
            m_Material.SetVector(s_Params, new Vector4(m_Settings.length, m_Settings.steps, m_Settings.thickness, m_Settings.bias));
            m_Material.SetVector(s_LightDir, new Vector4(m_LightDir.x, m_LightDir.y, m_LightDir.z, m_Settings.intensity));
            // 源和目标是同一张图：Shader 根本不读 _BlitTexture，只借 Blitter 画一个全屏三角形
            Blitter.BlitCameraTexture(cmd, m_Target, m_Target, m_Material, 0);
        }
        context.ExecuteCommandBuffer(cmd);
        CommandBufferPool.Release(cmd);
    }

    public void Dispose() => m_Target?.Release();
}

half Frag(Varyings input) : SV_Target
{
    float2 uv = input.texcoord;
    float deviceDepth = SampleSceneDepth(uv);
#if UNITY_REVERSED_Z
    if (deviceDepth <= 0.0) return 1;              // 天空：不处理
#else
    if (deviceDepth >= 1.0) return 1;
    deviceDepth = deviceDepth * 2.0 - 1.0;
#endif
    // 1) 由深度重建这个像素的世界坐标
    float3 positionWS = ComputeWorldSpacePosition(uv, deviceDepth, UNITY_MATRIX_I_VP);

    int   steps     = (int)_ContactParams.y;
    float stepLen   = _ContactParams.x / _ContactParams.y;
    float thickness = _ContactParams.z;
    float3 L = _ContactLightDir.xyz;

    // 2) 用交错梯度噪声抖动起点，把条带状走样变成细噪点（软阴影 / TAA 会再把它抹平）
    float jitter = InterleavedGradientNoise(uv * _ScreenSize.xy, 0);
    float3 p = positionWS + L * (_ContactParams.w + stepLen * jitter);

    half occlusion = 0;
    [loop] for (int i = 0; i < steps; i++)
    {
        p += L * stepLen;
        // 3) 把采样点投回屏幕，读那里的场景深度
        float4 positionCS = TransformWorldToHClip(p);
        float2 sampleUV = ComputeNormalizedDeviceCoordinates(p, UNITY_MATRIX_VP);
        if (any(sampleUV < 0) || any(sampleUV > 1)) break;

        float sceneEyeDepth  = LinearEyeDepth(SampleSceneDepth(sampleUV), _ZBufferParams);
        float sampleEyeDepth = positionCS.w;           // 透视投影下 w 就是观察空间深度
        float delta = sampleEyeDepth - sceneEyeDepth;  // > 0：采样点在可见表面之后

        // 4) 在表面之后、但又没“穿透”太深 → 光线被这块表面挡住了
        if (delta > 0.002 && delta < thickness)
        {
            // 离起点越远的遮挡越弱，避免接触阴影末端出现硬边
            occlusion = 1.0 - (float)i / steps;
            break;
        }
    }
    return 1.0 - occlusion * _ContactLightDir.w;
}

half4 frag(Varyings i) : SV_Target
{
    half3 albedo = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, i.uv).rgb * _BaseColor.rgb;
    half3 n = normalize(i.normalWS);
    Light l = GetMainLight(TransformWorldToShadowCoord(i.positionWS), i.positionWS, half4(1, 1, 1, 1));

    half contact = 1;
    if (_UseContact > 0.5)
    {
        float2 screenUV = GetNormalizedScreenSpaceUV(i.positionCS);
        contact = SAMPLE_TEXTURE2D(_ContactShadowTexture, sampler_LinearClamp, screenUV).r;
    }
    if (_ShowContact > 0.5) return half4(contact.xxx, 1);

    half shadow = min(l.shadowAttenuation, contact);
    half3 c = albedo * (l.color * saturate(dot(n, l.direction)) * shadow + SampleSH(n));
    return half4(c, 1);
}