float4 _AdditionalLightsPosition[MAX_VISIBLE_LIGHTS];
// In Forward+, .a stores whether the light is using subtractive mixed mode.
half4 _AdditionalLightsColor[MAX_VISIBLE_LIGHTS];
half4 _AdditionalLightsAttenuation[MAX_VISIBLE_LIGHTS];
half4 _AdditionalLightsSpotDir[MAX_VISIBLE_LIGHTS];
half4 _AdditionalLightsOcclusionProbes[MAX_VISIBLE_LIGHTS];
float _AdditionalLightsLayerMasks[MAX_VISIBLE_LIGHTS]; // we want uint[] but Unity api does not support it.

#if USE_FORWARD_PLUS
    #define LIGHT_LOOP_BEGIN(lightCount) { \
    uint lightIndex; \
    ClusterIterator _urp_internal_clusterIterator = ClusterInit(inputData.normalizedScreenSpaceUV, inputData.positionWS, 0); \
    [loop] while (ClusterNext(_urp_internal_clusterIterator, lightIndex)) { \
        lightIndex += URP_FP_DIRECTIONAL_LIGHTS_COUNT; \
        FORWARD_PLUS_SUBTRACTIVE_LIGHT_CHECK
    #define LIGHT_LOOP_END } }
#elif !_USE_WEBGL1_LIGHTS
    #define LIGHT_LOOP_BEGIN(lightCount) \
    for (uint lightIndex = 0u; lightIndex < lightCount; ++lightIndex) {

    #define LIGHT_LOOP_END }
#else
    ...
#endif

// 案例 6.1 多光源 Lambert：主光 + 附加光循环，同时支持 Forward 与 Forward+
Shader "Cookbook/Ch06/MultiLightLambert"
{
    Properties
    {
        [MainTexture] _BaseMap("Base Map", 2D) = "white" {}
        [MainColor] _BaseColor("Base Color", Color) = (0.8, 0.8, 0.8, 1)
        _AmbientStrength("Ambient Strength", Range(0, 1)) = 0.3
    }

    SubShader
    {
        Tags { "RenderType"="Opaque" "RenderPipeline"="UniversalPipeline" "Queue"="Geometry" }

        HLSLINCLUDE
        #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"

        CBUFFER_START(UnityPerMaterial)
            float4 _BaseMap_ST;
            half4  _BaseColor;
            half   _AmbientStrength;
        CBUFFER_END
        ENDHLSL

        Pass
        {
            Name "ForwardLit"
            Tags { "LightMode"="UniversalForward" }

            HLSLPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            // Forward 路径：URP 按 Asset 的“Additional Lights”设置打开 _ADDITIONAL_LIGHTS（逐像素）
            // 或 _ADDITIONAL_LIGHTS_VERTEX（逐顶点）；Forward+ 路径打开 _FORWARD_PLUS，
            // Core.hlsl 会据此自动定义 _ADDITIONAL_LIGHTS 和 USE_FORWARD_PLUS
            #pragma multi_compile _ _ADDITIONAL_LIGHTS_VERTEX _ADDITIONAL_LIGHTS
            #pragma multi_compile _ _FORWARD_PLUS

            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"

            TEXTURE2D(_BaseMap);
            SAMPLER(sampler_BaseMap);

            struct Attributes
            {
                float4 positionOS : POSITION;
                float3 normalOS   : NORMAL;
                float2 uv         : TEXCOORD0;
            };

            struct Varyings
            {
                float4 positionCS : SV_POSITION;
                float2 uv         : TEXCOORD0;
                float3 positionWS : TEXCOORD1;
                float3 normalWS   : TEXCOORD2;
            #if defined(_ADDITIONAL_LIGHTS_VERTEX)
                half3  vertexLight : TEXCOORD3;
            #endif
            };

            Varyings vert(Attributes input)
            {
                Varyings output;
                VertexPositionInputs pos = GetVertexPositionInputs(input.positionOS.xyz);
                output.positionCS = pos.positionCS;
                output.positionWS = pos.positionWS;
                output.normalWS = TransformObjectToWorldNormal(input.normalOS);
                output.uv = TRANSFORM_TEX(input.uv, _BaseMap);
            #if defined(_ADDITIONAL_LIGHTS_VERTEX)
                // 逐顶点模式：URP 的 VertexLighting() 在顶点里把所有附加光的 Lambert 累加好
                output.vertexLight = VertexLighting(pos.positionWS, output.normalWS);
            #endif
                return output;
            }

            half3 LambertLight(Light light, half3 normalWS)
            {
                half3 radiance = light.color * (light.distanceAttenuation * light.shadowAttenuation);
                return radiance * saturate(dot(normalWS, light.direction));
            }

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

                // LIGHT_LOOP_BEGIN 在 Forward+ 下会直接读取名为 inputData 的变量
                // （inputData.positionWS 与 inputData.normalizedScreenSpaceUV），所以名字不能改
                InputData inputData = (InputData)0;
                inputData.positionWS = input.positionWS;
                inputData.normalWS = normalWS;
                inputData.normalizedScreenSpaceUV = GetNormalizedScreenSpaceUV(input.positionCS);

                // 主光源
                half3 lighting = LambertLight(GetMainLight(), normalWS);

            #if defined(_ADDITIONAL_LIGHTS)
                uint lightCount = GetAdditionalLightsCount();   // Forward+ 下恒为 0，循环靠 cluster 迭代器

                #if USE_FORWARD_PLUS
                // Forward+：附加的“方向光”不进入分簇结构，排在光源数组最前面，要单独循环
                for (uint lightIndex = 0; lightIndex < min(URP_FP_DIRECTIONAL_LIGHTS_COUNT, MAX_VISIBLE_LIGHTS); lightIndex++)
                {
                    lighting += LambertLight(GetAdditionalLight(lightIndex, inputData.positionWS), normalWS);
                }
                #endif

                // Forward：for (lightIndex = 0; lightIndex < lightCount; ...)
                // Forward+：遍历当前像素所在 tile 与 z-bin 的光源位掩码
                LIGHT_LOOP_BEGIN(lightCount)
                    Light light = GetAdditionalLight(lightIndex, inputData.positionWS);
                    lighting += LambertLight(light, normalWS);
                LIGHT_LOOP_END
            #endif

            #if defined(_ADDITIONAL_LIGHTS_VERTEX)
                lighting += input.vertexLight;
            #endif

                half3 color = albedo * lighting + albedo * SampleSH(normalWS) * _AmbientStrength;
                return half4(color, 1);
            }
            ENDHLSL
        }

        // ---- 投影与深度：见案例 6.4 与 6.8 ----
        Pass
        {
            Name "ShadowCaster"
            Tags { "LightMode"="ShadowCaster" }
            ZWrite On
            ZTest LEqual
            ColorMask 0

            HLSLPROGRAM
            #pragma vertex ShadowCasterVertex
            #pragma fragment ShadowCasterFragment
            #pragma multi_compile_vertex _ _CASTING_PUNCTUAL_LIGHT_SHADOW
            #include "Assets/Cookbook/Ch06/ShadowCasterPass.hlsl"
            ENDHLSL
        }

        Pass
        {
            Name "DepthOnly"
            Tags { "LightMode"="DepthOnly" }
            ZWrite On
            ColorMask R

            HLSLPROGRAM
            #pragma vertex DepthOnlyVertex
            #pragma fragment DepthOnlyFragment
            #include "Assets/Cookbook/Ch06/DepthOnlyPass.hlsl"
            ENDHLSL
        }
    }
}

// Forward 路径：URP 按 Asset 的“Additional Lights”设置打开 _ADDITIONAL_LIGHTS（逐像素）
// 或 _ADDITIONAL_LIGHTS_VERTEX（逐顶点）；Forward+ 路径打开 _FORWARD_PLUS，
// Core.hlsl 会据此自动定义 _ADDITIONAL_LIGHTS 和 USE_FORWARD_PLUS
#pragma multi_compile _ _ADDITIONAL_LIGHTS_VERTEX _ADDITIONAL_LIGHTS
#pragma multi_compile _ _FORWARD_PLUS

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

    // LIGHT_LOOP_BEGIN 在 Forward+ 下会直接读取名为 inputData 的变量
    // （inputData.positionWS 与 inputData.normalizedScreenSpaceUV），所以名字不能改
    InputData inputData = (InputData)0;
    inputData.positionWS = input.positionWS;
    inputData.normalWS = normalWS;
    inputData.normalizedScreenSpaceUV = GetNormalizedScreenSpaceUV(input.positionCS);

    // 主光源
    half3 lighting = LambertLight(GetMainLight(), normalWS);

#if defined(_ADDITIONAL_LIGHTS)
    uint lightCount = GetAdditionalLightsCount();   // Forward+ 下恒为 0，循环靠 cluster 迭代器

    #if USE_FORWARD_PLUS
    // Forward+：附加的“方向光”不进入分簇结构，排在光源数组最前面，要单独循环
    for (uint lightIndex = 0; lightIndex < min(URP_FP_DIRECTIONAL_LIGHTS_COUNT, MAX_VISIBLE_LIGHTS); lightIndex++)
    {
        lighting += LambertLight(GetAdditionalLight(lightIndex, inputData.positionWS), normalWS);
    }
    #endif

    // Forward：for (lightIndex = 0; lightIndex < lightCount; ...)
    // Forward+：遍历当前像素所在 tile 与 z-bin 的光源位掩码
    LIGHT_LOOP_BEGIN(lightCount)
        Light light = GetAdditionalLight(lightIndex, inputData.positionWS);
        lighting += LambertLight(light, normalWS);
    LIGHT_LOOP_END
#endif

#if defined(_ADDITIONAL_LIGHTS_VERTEX)
    lighting += input.vertexLight;
#endif

    half3 color = albedo * lighting + albedo * SampleSH(normalWS) * _AmbientStrength;
    return half4(color, 1);
}

float DistanceAttenuation(float distanceSqr, half2 distanceAttenuation)
{
    float lightAtten = rcp(distanceSqr);
    float2 distanceAttenuationFloat = float2(distanceAttenuation);

    // Use the smoothing factor also used in the Unity lightmapper.
    half factor = half(distanceSqr * distanceAttenuationFloat.x);
    half smoothFactor = saturate(half(1.0) - factor * factor);
    smoothFactor = smoothFactor * smoothFactor;

    return lightAtten * smoothFactor;
}

// 不用 GetAdditionalLight()，直接读 URP 上传的光源数组，自己算衰减。
// URP 14 在所有平台都走常量数组（USE_STRUCTURED_BUFFER_FOR_LIGHT_DATA 恒为 0）
half3 PunctualLight(uint loopIndex, float3 positionWS, half3 normalWS)
{
#if USE_FORWARD_PLUS
    int i = int(loopIndex);                       // Forward+：循环变量就是全局光源下标
#else
    int i = GetPerObjectLightIndex(loopIndex);    // Forward：先查“本物体的第几盏灯”对应的全局下标
#endif
    float4 lightPos   = _AdditionalLightsPosition[i];     // w = 0 表示方向光
    half3  color      = _AdditionalLightsColor[i].rgb;
    half4  attenParam = _AdditionalLightsAttenuation[i];  // x = 1/range²，zw = 聚光角度参数
    half4  spotDir    = _AdditionalLightsSpotDir[i];

    float3 lightVector = lightPos.xyz - positionWS * lightPos.w;
    float  d2 = max(dot(lightVector, lightVector), HALF_MIN);
    half3  L = half3(lightVector * rsqrt(d2));

#if defined(_FALLOFF_INVERSESQUARE)
    float atten = rcp(d2);                                         // 物理上的平方反比，没有窗口
#elif defined(_FALLOFF_LINEAR)
    float atten = saturate(1.0 - sqrt(d2 * attenParam.x));         // 1 - d/range
#else
    float atten = DistanceAttenuation(d2, attenParam.xy);          // URP：平方反比 × 平滑窗口
#endif
    atten *= AngleAttenuation(spotDir.xyz, L, attenParam.zw);      // 聚光锥；点光的参数让它恒为 1

    return color * atten * saturate(dot(normalWS, L));
}

uint meshRenderingLayers = GetMeshRenderingLayer();          // 来自 unity_RenderingLayer
...
#if defined(_LIGHT_LAYERS)
    if (IsMatchingLightLayer(light.layerMask, meshRenderingLayers))
#endif
        color += ShadeOneLight(light, ...);

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;
}

// depth and normal bias scale is in shadowmap texel size in world space
float texelSize = frustumSize / shadowResolution;
float depthBias = -shadowData.bias[shadowLightIndex].x * texelSize;
float normalBias = -shadowData.bias[shadowLightIndex].y * texelSize;
...
if (shadowLight.lightType == LightType.Point)
    normalBias = 0.0f;
...
// For now we scale it by the PCF kernel size of non-mobile platforms (5x5)
depthBias *= kernelRadius;   // Low 1.5 / Medium 2.5 / High 3.5（仅软阴影）
normalBias *= kernelRadius;

// 主光阴影：无 / 单张阴影图 / 级联 / 屏幕空间（由 URP Asset 与 Renderer 设置决定，运行时自动开关）
#pragma multi_compile _ _MAIN_LIGHT_SHADOWS _MAIN_LIGHT_SHADOWS_CASCADE _MAIN_LIGHT_SHADOWS_SCREEN
// 软阴影：_SHADOWS_SOFT 在运行时按每盏灯的质量分支；LOW/MEDIUM/HIGH 是给“必须静态分支”的平台准备的
#pragma multi_compile_fragment _ _SHADOWS_SOFT _SHADOWS_SOFT_LOW _SHADOWS_SOFT_MEDIUM _SHADOWS_SOFT_HIGH
// 材质级开关：不接收阴影
#pragma shader_feature_local _RECEIVE_SHADOWS_OFF

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

    // 世界坐标 -> 阴影图坐标（xy = 阴影图 UV，z = 在光源空间里的深度）。
    // 开了级联时，这里会先按距离选出级联号，再用对应的矩阵变换
    float4 shadowCoord = TransformWorldToShadowCoord(input.positionWS);

    // 采样阴影图并与 z 比较：1 = 受光，0 = 在阴影里（软阴影时是 0~1 的过渡）
    half shadow = MainLightRealtimeShadow(shadowCoord);

    // 超出“阴影距离”的地方，阴影要平滑淡出，而不是突然消失
    shadow = lerp(shadow, 1.0, GetMainLightShadowFade(input.positionWS));

    Light mainLight = GetMainLight();
    half3 radiance = mainLight.color * mainLight.distanceAttenuation * shadow;
    half3 color = albedo * radiance * saturate(dot(normalWS, mainLight.direction));
    color += albedo * SampleSH(normalWS) * _AmbientStrength;
    return half4(color, 1);
}

// 案例 6.4 手写 ShadowCaster Pass：把物体画进光源的阴影图（只写深度）。
// 用法：在 Pass 里先声明好材质 CBUFFER（需要 Alpha 裁剪时要有 _BaseMap/_BaseColor/_Cutoff），再 include 本文件。
#ifndef COOKBOOK_CH06_SHADOW_CASTER_PASS_INCLUDED
#define COOKBOOK_CH06_SHADOW_CASTER_PASS_INCLUDED

#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
// Shadows.hlsl 里的 SampleShadowmap 用到 LerpWhiteTo()，它在 CommonMaterial.hlsl 里，必须先 include
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/CommonMaterial.hlsl"
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Shadows.hlsl"

// 由 URP 的 MainLightShadowCasterPass / AdditionalLightsShadowCasterPass 在画每个阴影切片前设置
// （见 Runtime/ShadowUtils.cs 的 SetupShadowCasterConstantBuffer）
float3 _LightDirection;   // 方向光：指向光源的方向
float3 _LightPosition;    // 点光 / 聚光：光源的世界坐标

struct ShadowCasterAttributes
{
    float4 positionOS : POSITION;
    float3 normalOS   : NORMAL;
    float2 texcoord   : TEXCOORD0;
    UNITY_VERTEX_INPUT_INSTANCE_ID
};

struct ShadowCasterVaryings
{
#if defined(_ALPHATEST_ON)
    float2 uv         : TEXCOORD0;
#endif
    float4 positionCS : SV_POSITION;
    UNITY_VERTEX_INPUT_INSTANCE_ID
};

float4 GetShadowCasterPositionCS(float3 positionWS, float3 normalWS)
{
    // 1) 求“指向光源”的方向：方向光处处相同；点光/聚光每个顶点不同
#if defined(_CASTING_PUNCTUAL_LIGHT_SHADOW)
    float3 lightDirectionWS = normalize(_LightPosition - positionWS);
#else
    float3 lightDirectionWS = _LightDirection;
#endif

    // 2) 在世界空间里做深度偏移 + 法线偏移，再变换到光源的裁剪空间
    //    （此刻 UNITY_MATRIX_VP 已被 URP 设成了“光源相机”的 VP 矩阵）
    float4 positionCS = TransformWorldToHClip(ApplyShadowBias(positionWS, normalWS, lightDirectionWS));

    // 3) 把跑到近平面之外的顶点“压扁”到近平面上（Shadow Pancaking），
    //    否则光源近平面之前的投射体会被裁掉，阴影凭空缺一块
#if UNITY_REVERSED_Z
    positionCS.z = min(positionCS.z, UNITY_NEAR_CLIP_VALUE);
#else
    positionCS.z = max(positionCS.z, UNITY_NEAR_CLIP_VALUE);
#endif
    return positionCS;
}

ShadowCasterVaryings ShadowCasterVertex(ShadowCasterAttributes input)
{
    ShadowCasterVaryings output = (ShadowCasterVaryings)0;
    UNITY_SETUP_INSTANCE_ID(input);
    UNITY_TRANSFER_INSTANCE_ID(input, output);

    float3 positionWS = TransformObjectToWorld(input.positionOS.xyz);
    float3 normalWS = TransformObjectToWorldNormal(input.normalOS);
    output.positionCS = GetShadowCasterPositionCS(positionWS, normalWS);
#if defined(_ALPHATEST_ON)
    output.uv = TRANSFORM_TEX(input.texcoord, _BaseMap);
#endif
    return output;
}

half4 ShadowCasterFragment(ShadowCasterVaryings input) : SV_Target
{
    UNITY_SETUP_INSTANCE_ID(input);
#if defined(_ALPHATEST_ON)
    // 镂空材质的影子也要镂空：和颜色 Pass 用同样的 clip
    half alpha = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, input.uv).a * _BaseColor.a;
    clip(alpha - _Cutoff);
#endif
    return 0;
}

#endif

float4 GetShadowCasterPositionCS(float3 positionWS, float3 normalWS)
{
    // 1) 求“指向光源”的方向：方向光处处相同；点光/聚光每个顶点不同
#if defined(_CASTING_PUNCTUAL_LIGHT_SHADOW)
    float3 lightDirectionWS = normalize(_LightPosition - positionWS);
#else
    float3 lightDirectionWS = _LightDirection;
#endif

    // 2) 在世界空间里做深度偏移 + 法线偏移，再变换到光源的裁剪空间
    //    （此刻 UNITY_MATRIX_VP 已被 URP 设成了“光源相机”的 VP 矩阵）
    float4 positionCS = TransformWorldToHClip(ApplyShadowBias(positionWS, normalWS, lightDirectionWS));

    // 3) 把跑到近平面之外的顶点“压扁”到近平面上（Shadow Pancaking），
    //    否则光源近平面之前的投射体会被裁掉，阴影凭空缺一块
#if UNITY_REVERSED_Z
    positionCS.z = min(positionCS.z, UNITY_NEAR_CLIP_VALUE);
#else
    positionCS.z = max(positionCS.z, UNITY_NEAR_CLIP_VALUE);
#endif
    return positionCS;
}

Pass
{
    Name "ShadowCaster"
    Tags { "LightMode"="ShadowCaster" }
    ZWrite On
    ZTest LEqual
    ColorMask 0
    Cull [_Cull]

    HLSLPROGRAM
    #pragma target 2.0
    #pragma vertex ShadowCasterVertex
    #pragma fragment ShadowCasterFragment
    #pragma shader_feature_local_fragment _ALPHATEST_ON
    #pragma multi_compile_instancing
    // 区分方向光与点光/聚光：两者计算“指向光源方向”的方式不同
    #pragma multi_compile_vertex _ _CASTING_PUNCTUAL_LIGHT_SHADOW
    #include "Assets/Cookbook/Ch06/ShadowCasterPass.hlsl"
    ENDHLSL
}

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

    Light mainLight = GetMainLight(TransformWorldToShadowCoord(input.positionWS));
    half3 color = albedo * mainLight.color * mainLight.shadowAttenuation * saturate(dot(normalWS, mainLight.direction));
    color += albedo * SampleSH(normalWS) * 0.4;

    // ComputeCascadeIndex：依次判断像素是否落在 4 个“级联包围球”里，返回第一个命中的序号；
    // 4 表示超出了所有级联（阴影距离之外）
#if defined(_MAIN_LIGHT_SHADOWS_CASCADE)
    half cascade = ComputeCascadeIndex(input.positionWS);
#else
    half cascade = 0;   // 只有一个级联时 URP 不会更新包围球数据，直接当作第 0 级
#endif
    const half3 kCascadeColors[5] =
    {
        half3(1.0, 0.25, 0.2), half3(0.25, 0.85, 0.3), half3(0.25, 0.45, 1.0), half3(1.0, 0.85, 0.2), half3(1, 1, 1)
    };
    half3 tint = kCascadeColors[(uint)cascade];
    color = lerp(color, color * tint * 1.6, _TintStrength);
    return half4(color, 1);
}

#pragma multi_compile_fragment _ _ADDITIONAL_LIGHT_SHADOWS

LIGHT_LOOP_BEGIN(pixelLightCount)
    // 带 shadowMask 参数的重载：内部调用 AdditionalLightShadow()，还会乘上 Cookie
    Light light = GetAdditionalLight(lightIndex, inputData.positionWS, shadowMask);
    color += Shade(light, ...);   // Shade 里已经乘了 light.shadowAttenuation
LIGHT_LOOP_END

// DepthOnly Pass：只写深度。URP 做深度预渲染（Depth Prepass）、生成 _CameraDepthTexture 时会用到它。
#ifndef COOKBOOK_CH06_DEPTH_ONLY_PASS_INCLUDED
#define COOKBOOK_CH06_DEPTH_ONLY_PASS_INCLUDED

#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"

struct DepthOnlyAttributes
{
    float4 positionOS : POSITION;
    float2 texcoord   : TEXCOORD0;
    UNITY_VERTEX_INPUT_INSTANCE_ID
};

struct DepthOnlyVaryings
{
#if defined(_ALPHATEST_ON)
    float2 uv         : TEXCOORD0;
#endif
    float4 positionCS : SV_POSITION;
    UNITY_VERTEX_INPUT_INSTANCE_ID
    UNITY_VERTEX_OUTPUT_STEREO
};

DepthOnlyVaryings DepthOnlyVertex(DepthOnlyAttributes input)
{
    DepthOnlyVaryings output = (DepthOnlyVaryings)0;
    UNITY_SETUP_INSTANCE_ID(input);
    UNITY_TRANSFER_INSTANCE_ID(input, output);
    UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output);
    output.positionCS = TransformObjectToHClip(input.positionOS.xyz);
#if defined(_ALPHATEST_ON)
    output.uv = TRANSFORM_TEX(input.texcoord, _BaseMap);
#endif
    return output;
}

half DepthOnlyFragment(DepthOnlyVaryings input) : SV_Target
{
    UNITY_SETUP_INSTANCE_ID(input);
    UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);
#if defined(_ALPHATEST_ON)
    clip(SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, input.uv).a * _BaseColor.a - _Cutoff);
#endif
    // 深度由硬件写入；某些路径会把深度作为颜色写进 R 通道（Pass 里 ColorMask R），所以照 URP 的做法返回 z
    return input.positionCS.z;
}

#endif

// DepthNormals Pass：同时写深度和世界空间法线到 _CameraNormalsTexture。
// SSAO（Depth Normals 模式）、贴花、部分自定义屏幕空间效果都依赖它。
#ifndef COOKBOOK_CH06_DEPTH_NORMALS_PASS_INCLUDED
#define COOKBOOK_CH06_DEPTH_NORMALS_PASS_INCLUDED

#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"

struct DepthNormalsAttributes
{
    float4 positionOS : POSITION;
    float3 normalOS   : NORMAL;
    float2 texcoord   : TEXCOORD0;
    UNITY_VERTEX_INPUT_INSTANCE_ID
};

struct DepthNormalsVaryings
{
    float4 positionCS : SV_POSITION;
    float2 uv         : TEXCOORD0;
    float3 normalWS   : TEXCOORD1;
    UNITY_VERTEX_INPUT_INSTANCE_ID
    UNITY_VERTEX_OUTPUT_STEREO
};

DepthNormalsVaryings DepthNormalsVertex(DepthNormalsAttributes input)
{
    DepthNormalsVaryings output = (DepthNormalsVaryings)0;
    UNITY_SETUP_INSTANCE_ID(input);
    UNITY_TRANSFER_INSTANCE_ID(input, output);
    UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output);
    output.positionCS = TransformObjectToHClip(input.positionOS.xyz);
    output.normalWS = TransformObjectToWorldNormal(input.normalOS);
    output.uv = input.texcoord;
#if defined(_ALPHATEST_ON)
    output.uv = TRANSFORM_TEX(input.texcoord, _BaseMap);
#endif
    return output;
}

void DepthNormalsFragment(DepthNormalsVaryings input
    , out half4 outNormalWS : SV_Target0
#ifdef _WRITE_RENDERING_LAYERS
    , out float4 outRenderingLayers : SV_Target1
#endif
)
{
    UNITY_SETUP_INSTANCE_ID(input);
    UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);
#if defined(_ALPHATEST_ON)
    clip(SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, input.uv).a * _BaseColor.a - _Cutoff);
#endif
    // URP 14 的 _CameraNormalsTexture 直接存归一化的世界空间法线（不做 0.5 偏移）
    outNormalWS = half4(NormalizeNormalPerPixel(input.normalWS), 0.0);
#ifdef _WRITE_RENDERING_LAYERS
    // 开启“渲染层”且有贴花等需求时，URP 会让这个 Pass 顺便写出网格的渲染层
    outRenderingLayers = float4(EncodeMeshRenderingLayer(GetMeshRenderingLayer()), 0, 0, 0);
#endif
}

#endif

// 案例 6.9 ClassicLit：完整的 Blinn-Phong + 多光源 + 阴影 Shader（后续章节会以它为基础扩展）
Shader "Cookbook/Ch06/ClassicLit"
{
    Properties
    {
        [MainTexture] _BaseMap("Base Map", 2D) = "white" {}
        [MainColor] _BaseColor("Base Color", Color) = (1, 1, 1, 1)
        _SpecColor("Specular Color", Color) = (0.2, 0.2, 0.2, 1)
        _Smoothness("Smoothness", Range(0, 1)) = 0.5
        [HDR] _EmissionColor("Emission", Color) = (0, 0, 0, 1)

        [Toggle(_ALPHATEST_ON)] _AlphaClip("Alpha Clip", Float) = 0
        _Cutoff("Alpha Cutoff", Range(0, 1)) = 0.5
        [Toggle(_RECEIVE_SHADOWS_OFF)] _ReceiveShadowsOff("Receive Shadows Off", Float) = 0
        [Enum(UnityEngine.Rendering.CullMode)] _Cull("Cull", Float) = 2
    }

    SubShader
    {
        Tags { "RenderType"="Opaque" "RenderPipeline"="UniversalPipeline" "Queue"="Geometry" }

        HLSLINCLUDE
        #include "Assets/Cookbook/Ch06/ClassicLitInput.hlsl"
        ENDHLSL

        Pass
        {
            Name "ForwardLit"
            // 没有 GBuffer Pass 的自定义光照 Shader 要标成 UniversalForwardOnly：
            // Forward / Forward+ 下它和 UniversalForward 一样被绘制；Deferred 下它会进入“Forward Only”通道，
            // 而只标 UniversalForward 的物体在 Deferred 里会直接消失
            Tags { "LightMode"="UniversalForwardOnly" }
            Cull [_Cull]

            HLSLPROGRAM
            #pragma target 2.0
            #pragma vertex ClassicLitVertex
            #pragma fragment ClassicLitFragment

            // 材质关键字
            #pragma shader_feature_local _RECEIVE_SHADOWS_OFF
            #pragma shader_feature_local_fragment _ALPHATEST_ON

            // URP 关键字（与 URP 14 Lit.shader 的 ForwardLit 保持一致的子集）
            #pragma multi_compile _ _MAIN_LIGHT_SHADOWS _MAIN_LIGHT_SHADOWS_CASCADE _MAIN_LIGHT_SHADOWS_SCREEN
            #pragma multi_compile _ _ADDITIONAL_LIGHTS_VERTEX _ADDITIONAL_LIGHTS
            #pragma multi_compile_fragment _ _ADDITIONAL_LIGHT_SHADOWS
            #pragma multi_compile_fragment _ _SHADOWS_SOFT _SHADOWS_SOFT_LOW _SHADOWS_SOFT_MEDIUM _SHADOWS_SOFT_HIGH
            #pragma multi_compile_fragment _ _SCREEN_SPACE_OCCLUSION
            #pragma multi_compile_fragment _ _LIGHT_COOKIES
            #pragma multi_compile _ _LIGHT_LAYERS
            #pragma multi_compile _ _FORWARD_PLUS
            #pragma multi_compile_fog
            #pragma multi_compile_instancing

            #include "Assets/Cookbook/Ch06/ClassicLitForwardPass.hlsl"
            ENDHLSL
        }

        Pass
        {
            Name "ShadowCaster"
            Tags { "LightMode"="ShadowCaster" }
            ZWrite On
            ZTest LEqual
            ColorMask 0
            Cull [_Cull]

            HLSLPROGRAM
            #pragma target 2.0
            #pragma vertex ShadowCasterVertex
            #pragma fragment ShadowCasterFragment
            #pragma shader_feature_local_fragment _ALPHATEST_ON
            #pragma multi_compile_instancing
            // 区分方向光与点光/聚光：两者计算“指向光源方向”的方式不同
            #pragma multi_compile_vertex _ _CASTING_PUNCTUAL_LIGHT_SHADOW
            #include "Assets/Cookbook/Ch06/ShadowCasterPass.hlsl"
            ENDHLSL
        }

        Pass
        {
            Name "DepthOnly"
            Tags { "LightMode"="DepthOnly" }
            ZWrite On
            ColorMask R
            Cull [_Cull]

            HLSLPROGRAM
            #pragma target 2.0
            #pragma vertex DepthOnlyVertex
            #pragma fragment DepthOnlyFragment
            #pragma shader_feature_local_fragment _ALPHATEST_ON
            #pragma multi_compile_instancing
            #include "Assets/Cookbook/Ch06/DepthOnlyPass.hlsl"
            ENDHLSL
        }

        Pass
        {
            Name "DepthNormalsOnly"
            // 与 UniversalForwardOnly 配套：Deferred 的深度法线预渲染只收 DepthNormalsOnly；
            // Forward 下 DepthNormals 与 DepthNormalsOnly 都会被绘制，所以两者只能二选一
            Tags { "LightMode"="DepthNormalsOnly" }
            ZWrite On
            Cull [_Cull]

            HLSLPROGRAM
            #pragma target 2.0
            #pragma vertex DepthNormalsVertex
            #pragma fragment DepthNormalsFragment
            #pragma shader_feature_local_fragment _ALPHATEST_ON
            #pragma multi_compile_instancing
            #include_with_pragmas "Packages/com.unity.render-pipelines.universal/ShaderLibrary/RenderingLayers.hlsl"
            #include "Assets/Cookbook/Ch06/DepthNormalsPass.hlsl"
            ENDHLSL
        }
    }
}

// 案例 6.9 ClassicLit 的材质输入：所有 Pass 共享同一个 UnityPerMaterial，保证 SRP Batcher 兼容
#ifndef COOKBOOK_CH06_CLASSIC_LIT_INPUT_INCLUDED
#define COOKBOOK_CH06_CLASSIC_LIT_INPUT_INCLUDED

#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"

CBUFFER_START(UnityPerMaterial)
    float4 _BaseMap_ST;
    half4  _BaseColor;
    half4  _SpecColor;
    half   _Smoothness;
    half4  _EmissionColor;
    half   _Cutoff;
CBUFFER_END

TEXTURE2D(_BaseMap);
SAMPLER(sampler_BaseMap);

#endif

Varyings ClassicLitVertex(Attributes input)
{
    Varyings output = (Varyings)0;
    UNITY_SETUP_INSTANCE_ID(input);
    UNITY_TRANSFER_INSTANCE_ID(input, output);
    UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output);

    VertexPositionInputs vertexInput = GetVertexPositionInputs(input.positionOS.xyz);
    half3 normalWS = TransformObjectToWorldNormal(input.normalOS);

    output.positionCS = vertexInput.positionCS;
    output.positionWS = vertexInput.positionWS;
    output.normalWS = normalWS;
    output.uv = TRANSFORM_TEX(input.texcoord, _BaseMap);

    half fogFactor = ComputeFogFactor(vertexInput.positionCS.z);
    half3 vertexLight = VertexLighting(vertexInput.positionWS, normalWS);   // 只有 _ADDITIONAL_LIGHTS_VERTEX 时非零
    output.fogFactorAndVertexLight = half4(fogFactor, vertexLight);

#if defined(REQUIRES_VERTEX_SHADOW_COORD_INTERPOLATOR)
    output.shadowCoord = GetShadowCoord(vertexInput);
#endif
    return output;
}

InputData BuildInputData(Varyings input, half3 normalWS)
{
    InputData inputData = (InputData)0;
    inputData.positionWS = input.positionWS;
    inputData.positionCS = input.positionCS;
    inputData.normalWS = normalWS;
    inputData.viewDirectionWS = GetWorldSpaceNormalizeViewDir(input.positionWS);
#if defined(REQUIRES_VERTEX_SHADOW_COORD_INTERPOLATOR)
    inputData.shadowCoord = input.shadowCoord;
#elif defined(MAIN_LIGHT_CALCULATE_SHADOWS)
    inputData.shadowCoord = TransformWorldToShadowCoord(input.positionWS);   // 级联：逐像素选级联
#else
    inputData.shadowCoord = float4(0, 0, 0, 0);
#endif
    // URP 14 强制逐像素算雾（ShaderVariablesFunctions.hlsl 里 #define _FOG_FRAGMENT 1），顶点雾因子只作后备
    inputData.fogCoord = InitializeInputDataFog(float4(input.positionWS, 1.0), input.fogFactorAndVertexLight.x);
    inputData.vertexLighting = input.fogFactorAndVertexLight.yzw;
    inputData.bakedGI = SampleSH(normalWS);                     // 本章只用球谐环境光，光照贴图见第 8 章
    inputData.normalizedScreenSpaceUV = GetNormalizedScreenSpaceUV(input.positionCS);
    inputData.shadowMask = half4(1, 1, 1, 1);                   // 没有烘焙阴影时为 1
    return inputData;
}