struct Light
{
    half3   direction;
    half3   color;
    float   distanceAttenuation; // full-float precision required on some platforms
    half    shadowAttenuation;
    uint    layerMask;
};

Light GetMainLight()
{
    Light light;
    light.direction = half3(_MainLightPosition.xyz);
#if USE_FORWARD_PLUS
    ...
    light.distanceAttenuation = 1.0;
#else
    light.distanceAttenuation = unity_LightData.z; // 1 when not culled by the culling mask, otherwise 0.
#endif
    light.shadowAttenuation = 1.0;
    light.color = _MainLightColor.rgb;
    light.layerMask = _MainLightLayerMask;
    return light;
}

// 案例 5.1 Lambert 漫反射：只计算主光源的 N·L，再加一点球谐环境光
Shader "Cookbook/Ch05/Lambert"
{
    Properties
    {
        [MainColor] _BaseColor("Base Color", Color) = (0.85, 0.5, 0.25, 1)
        _AmbientStrength("Ambient Strength", Range(0, 1)) = 1
    }

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

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

        CBUFFER_START(UnityPerMaterial)
            half4 _BaseColor;
            half  _AmbientStrength;
        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;
                float3 normalWS   : TEXCOORD0;
            };

            Varyings vert(Attributes input)
            {
                Varyings output;
                output.positionCS = TransformObjectToHClip(input.positionOS.xyz);
                // 法线要用“逆转置矩阵”变换，TransformObjectToWorldNormal 已经处理了非等比缩放
                output.normalWS = TransformObjectToWorldNormal(input.normalOS);
                return output;
            }

            half4 frag(Varyings input) : SV_Target
            {
                // 插值后的法线长度不再是 1，必须重新归一化
                half3 N = normalize(input.normalWS);

                Light mainLight = GetMainLight();
                // direction 指向光源；color 已经乘过 Intensity，是线性空间的 HDR 值
                half3 radiance = mainLight.color * mainLight.distanceAttenuation;

                // 余弦定律：背光面 N·L < 0，必须截断到 0，否则会“吸收”别的光
                half NdotL = saturate(dot(N, mainLight.direction));
                half3 diffuse = _BaseColor.rgb * radiance * NdotL;

                // 环境光：来自天空的球谐光照，第 8 章细讲。没有它，背光面会是纯黑
                half3 ambient = _BaseColor.rgb * SampleSH(N) * _AmbientStrength;

                return half4(diffuse + ambient, 1);
            }
            ENDHLSL
        }

        // ---- 投影与深度：本章先照抄，原理见第 6 章 ----
        Pass
        {
            Name "ShadowCaster"
            Tags { "LightMode"="ShadowCaster" }
            ZWrite On
            ZTest LEqual
            ColorMask 0

            HLSLPROGRAM
            #pragma vertex ShadowDepthVert
            #pragma fragment ShadowDepthFrag
            #pragma multi_compile_vertex _ _CASTING_PUNCTUAL_LIGHT_SHADOW
            #include "Assets/Cookbook/Ch05/Ch05ShadowDepth.hlsl"
            ENDHLSL
        }

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

            HLSLPROGRAM
            #pragma vertex DepthOnlyVert
            #pragma fragment DepthOnlyFrag
            #include "Assets/Cookbook/Ch05/Ch05ShadowDepth.hlsl"
            ENDHLSL
        }
    }
}

half4 frag(Varyings input) : SV_Target
{
    // 插值后的法线长度不再是 1，必须重新归一化
    half3 N = normalize(input.normalWS);

    Light mainLight = GetMainLight();
    // direction 指向光源；color 已经乘过 Intensity，是线性空间的 HDR 值
    half3 radiance = mainLight.color * mainLight.distanceAttenuation;

    // 余弦定律：背光面 N·L < 0，必须截断到 0，否则会“吸收”别的光
    half NdotL = saturate(dot(N, mainLight.direction));
    half3 diffuse = _BaseColor.rgb * radiance * NdotL;

    // 环境光：来自天空的球谐光照，第 8 章细讲。没有它，背光面会是纯黑
    half3 ambient = _BaseColor.rgb * SampleSH(N) * _AmbientStrength;

    return half4(diffuse + ambient, 1);
}

// 第 5 章所有 Shader 共用的 ShadowCaster / DepthOnly 顶点与片元函数。
// 本章只关心“表面怎么被照亮”，这两个 Pass 只负责让物体能投影、能写进深度图，
// 它们的原理（ApplyShadowBias、_CASTING_PUNCTUAL_LIGHT_SHADOW 等）在第 6 章细讲。
#ifndef COOKBOOK_CH05_SHADOW_DEPTH_INCLUDED
#define COOKBOOK_CH05_SHADOW_DEPTH_INCLUDED

#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
// Shadows.hlsl 用到了 LerpWhiteTo()，它定义在 CommonMaterial.hlsl 里，但 Shadows.hlsl 自己没有 include。
// URP 自带的 Lit 之所以不报错，是因为 LitInput.hlsl 先 include 了它。自己写 ShadowCaster 时要补上。
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/CommonMaterial.hlsl"
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Shadows.hlsl"

// 由 URP 的阴影 Pass 在绘制每个投射光源前设置
float3 _LightDirection;
float3 _LightPosition;

half4 frag(Varyings input) : SV_Target
{
    half3 N = normalize(input.normalWS);
    Light mainLight = GetMainLight();
    half3 radiance = mainLight.color * mainLight.distanceAttenuation;

    // 注意这里没有 saturate：背光面的负值也要参与映射
    half NdotL = dot(N, mainLight.direction);
    half halfLambert = NdotL * 0.5 + 0.5;          // [-1,1] -> [0,1]
    halfLambert = pow(halfLambert, _Power);         // Valve 原版取平方，让暗部重新“沉下去”

    half3 diffuse = _BaseColor.rgb * radiance * halfLambert;
    half3 ambient = _BaseColor.rgb * SampleSH(N) * _AmbientStrength;
    return half4(diffuse + ambient, 1);
}

half WrapDiffuse(half NdotL, half w)
{
#if defined(_WRAP_ENERGY_CONSERVING)
    // 分母 (1+w)^2：被照亮的范围变大了，峰值相应压低，总能量与 Lambert 相同
    return saturate((NdotL + w) / ((1 + w) * (1 + w)));
#else
    // 经典写法：w = 0 时退化为 Lambert，w = 1 时等价于未平方的 Half-Lambert
    return saturate((NdotL + w) / (1 + w));
#endif
}

half4 frag(Varyings input) : SV_Target
{
    half3 N = normalize(input.normalWS);
    Light mainLight = GetMainLight();
    half3 radiance = mainLight.color * mainLight.distanceAttenuation;

    half NdotL = dot(N, mainLight.direction);
    half wrap = WrapDiffuse(NdotL, _Wrap);

    // 交界线染色：只在“Wrap 有、Lambert 没有”的那一圈加颜色，模拟光在皮下散射后带出的红色
    half scatter = saturate(wrap - saturate(NdotL));
    half3 diffuse = _BaseColor.rgb * radiance * wrap
                  + _TerminatorTint.rgb * radiance * scatter;

    half3 ambient = _BaseColor.rgb * SampleSH(N) * _AmbientStrength;
    return half4(diffuse + ambient, 1);
}

half4 frag(Varyings input) : SV_Target
{
    float3 N = normalize(input.normalWS);
    float3 V = GetWorldSpaceNormalizeViewDir(input.positionWS);   // 指向相机
    Light mainLight = GetMainLight();
    float3 L = mainLight.direction;                                // 指向光源
    half3 radiance = mainLight.color * mainLight.distanceAttenuation;

    float NdotL = dot(N, L);
    half3 diffuse = _BaseColor.rgb * saturate(NdotL);

    // reflect(i, n) 要求 i 是“射入”方向，所以传 -L
    float3 R = reflect(-L, N);
    float RdotV = saturate(dot(R, V));
    // 高光指数常常上百，用 float 计算，避免 half 精度下出现色带
    float spec = pow(RdotV, _Shininess);
    // 背光面不应该出现高光（R 可能恰好朝向相机）
    spec *= step(0.0, NdotL);

    half3 color = (diffuse + _SpecColor.rgb * spec) * radiance;
    color += _BaseColor.rgb * SampleSH(N) * _AmbientStrength;
    return half4(color, 1);
}

half4 frag(Varyings input) : SV_Target
{
    float3 N = normalize(input.normalWS);
    float3 V = GetWorldSpaceNormalizeViewDir(input.positionWS);
    Light mainLight = GetMainLight();
    float3 L = mainLight.direction;
    half3 radiance = mainLight.color * mainLight.distanceAttenuation;

    float NdotL = dot(N, L);
    half3 diffuse = _BaseColor.rgb * saturate(NdotL);

    // 半程向量：L 与 V 的“角平分线”。L、V 几乎相反时 L+V 接近零向量，用 SafeNormalize 防 NaN
    float3 H = SafeNormalize(L + V);
    float NdotH = saturate(dot(N, H));
    float spec = pow(NdotH, _Shininess) * step(0.0, NdotL);

    half3 color = (diffuse + _SpecColor.rgb * spec) * radiance;
    color += _BaseColor.rgb * SampleSH(N) * _AmbientStrength;
    return half4(color, 1);
}

half3 LightingSpecular(half3 lightColor, half3 lightDir, half3 normal, half3 viewDir, half4 specular, half smoothness)
{
    float3 halfVec = SafeNormalize(float3(lightDir) + float3(viewDir));
    half NdotH = half(saturate(dot(normal, halfVec)));
    half modifier = pow(NdotH, smoothness);
    float3 specularReflection = specular.rgb * modifier;
    return lightColor * specularReflection;
}

// CalculateBlinnPhong() 中：
half smoothness = exp2(10 * surfaceData.smoothness + 1);

// 返回“乘上 N·L 之后”的高光项，与 URP 的约定一致：漫反射写成 albedo * N·L（没有 1/π），
// 所以这里的归一化系数也整体乘了 π：Blinn-Phong 用 (n+8)/8，Phong 用 (n+2)/2
float SpecularTerm(float3 N, float3 L, float3 V, float n)
{
    float NdotL = saturate(dot(N, L));
#if defined(_MODEL_PHONG)
    float lobe = pow(saturate(dot(reflect(-L, N), V)), n);
    float norm = (n + 2.0) / 2.0;
#else
    float lobe = pow(saturate(dot(N, SafeNormalize(L + V))), n);
    float norm = (n + 8.0) / 8.0;
#endif
#if !defined(_NORMALIZE_SPECULAR)
    norm = 1.0;
#endif
    return norm * lobe * NdotL;
}

// Oren-Nayar 定性模型，返回值已乘 N·L（URP 约定，不含 1/π）。
// 原式 A + B·max(0, cos(φi-φr))·sinα·tanβ 里的三角函数可以全部消掉：
//   s = L·V - (N·L)(N·V) = sinθi·sinθr·cos(φi-φr)
//   sinα·tanβ = sinθi·sinθr / max(cosθi, cosθr)
// 于是 cos(φi-φr)·sinα·tanβ = s / max(N·L, N·V)
float OrenNayar(float3 N, float3 L, float3 V, float sigma)
{
    float NdotL = saturate(dot(N, L));
    float NdotV = saturate(dot(N, V));
    float s2 = sigma * sigma;
    float A = 1.0 - 0.5 * s2 / (s2 + 0.33);
    float B = 0.45 * s2 / (s2 + 0.09);
    float s = dot(L, V) - NdotL * NdotV;
    float t = max(max(NdotL, NdotV), 1e-4);
    return NdotL * (A + B * max(0.0, s) / t);
}

// Minnaert：k = 1 时就是 Lambert；k < 1 边缘变亮（天鹅绒、月面感），k > 1 边缘更暗
float Minnaert(float3 N, float3 L, float3 V, float k)
{
    float NdotL = saturate(dot(N, L));
    float NdotV = max(saturate(dot(N, V)), 1e-3);
    return pow(NdotL, k) * pow(NdotV, k - 1.0);
}

half3 ShadeBlinnPhong(float3 positionWS, float3 N)
{
    float3 V = GetWorldSpaceNormalizeViewDir(positionWS);
    Light mainLight = GetMainLight();
    float3 L = mainLight.direction;
    half3 radiance = mainLight.color * mainLight.distanceAttenuation;
    float NdotL = dot(N, L);
    float spec = pow(saturate(dot(N, SafeNormalize(L + V))), _Shininess) * step(0.0, NdotL);
    half3 color = (_BaseColor.rgb * saturate(NdotL) + _SpecColor.rgb * spec) * radiance;
    return color + _BaseColor.rgb * SampleSH(N) * _AmbientStrength;
}

Varyings vert(Attributes input)
{
    Varyings output;
    VertexPositionInputs pos = GetVertexPositionInputs(input.positionOS.xyz);
    float3 normalWS = TransformObjectToWorldNormal(input.normalOS);
    output.positionCS = pos.positionCS;
#if defined(_PER_VERTEX)
    output.color = ShadeBlinnPhong(pos.positionWS, normalWS);
#else
    output.positionWS = pos.positionWS;
    output.normalWS = normalWS;
#endif
    return output;
}

half4 frag(Varyings input) : SV_Target
{
#if defined(_PER_VERTEX)
    return half4(input.color, 1);
#else
    return half4(ShadeBlinnPhong(input.positionWS, normalize(input.normalWS)), 1);
#endif
}

// 案例 5.9 经典光照模型函数库。
// 约定（与 URP 一致）：所有函数的返回值都已经乘过 N·L（或它的替代品），
// 而且没有除以 π——URP 的漫反射写作 albedo * lightColor * N·L，高光的归一化系数因此也整体乘了 π。
#ifndef COOKBOOK_CH05_CLASSIC_LIGHTING_INCLUDED
#define COOKBOOK_CH05_CLASSIC_LIGHTING_INCLUDED

float DiffuseLambert(float3 N, float3 L)
{
    return saturate(dot(N, L));
}

float DiffuseHalfLambert(float3 N, float3 L, float power)
{
    return pow(dot(N, L) * 0.5 + 0.5, power);
}

// 能量守恒的 Wrap：w = 0 时等于 Lambert
float DiffuseWrap(float3 N, float3 L, float w)
{
    return saturate((dot(N, L) + w) / ((1.0 + w) * (1.0 + w)));
}

// Oren-Nayar 定性模型（无三角函数版本），sigma 为微表面坡度的标准差（弧度）
float DiffuseOrenNayar(float3 N, float3 L, float3 V, float sigma)
{
    float NdotL = saturate(dot(N, L));
    float NdotV = saturate(dot(N, V));
    float s2 = sigma * sigma;
    float A = 1.0 - 0.5 * s2 / (s2 + 0.33);
    float B = 0.45 * s2 / (s2 + 0.09);
    float s = dot(L, V) - NdotL * NdotV;
    return NdotL * (A + B * max(0.0, s) / max(max(NdotL, NdotV), 1e-4));
}

// 归一化 Phong：(n+2)/2 · (R·V)^n · N·L
float SpecularPhong(float3 N, float3 L, float3 V, float n)
{
    float RdotV = saturate(dot(reflect(-L, N), V));
    return (n + 2.0) * 0.5 * pow(RdotV, n) * saturate(dot(N, L));
}

// 归一化 Blinn-Phong：(n+8)/8 · (N·H)^n · N·L
float SpecularBlinnPhong(float3 N, float3 L, float3 V, float n)
{
    float3 H = SafeNormalize(L + V);
    return (n + 8.0) * 0.125 * pow(saturate(dot(N, H)), n) * saturate(dot(N, L));
}

// 用 0~1 的“光滑度”驱动高光指数，映射与 URP SimpleLit 相同：smoothness=0 → 2，=1 → 2048
float ShininessFromSmoothness(float smoothness)
{
    return exp2(10.0 * smoothness + 1.0);
}

#endif

half4 frag(Varyings input) : SV_Target
{
    half3 albedo = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, input.uv).rgb * _BaseColor.rgb;
    float3 N = normalize(input.normalWS);
    float3 V = GetWorldSpaceNormalizeViewDir(input.positionWS);
    Light mainLight = GetMainLight();
    float3 L = mainLight.direction;
    half3 radiance = mainLight.color * mainLight.distanceAttenuation;

#if defined(_DIFFUSE_HALFLAMBERT)
    float d = DiffuseHalfLambert(N, L, 2.0);
#elif defined(_DIFFUSE_WRAP)
    float d = DiffuseWrap(N, L, _Wrap);
#elif defined(_DIFFUSE_ORENNAYAR)
    float d = DiffuseOrenNayar(N, L, V, _Roughness);
#else
    float d = DiffuseLambert(N, L);
#endif

    float n = ShininessFromSmoothness(_Smoothness);
#if defined(_SPECULAR_PHONG)
    float s = SpecularPhong(N, L, V, n);
#elif defined(_SPECULAR_BLINNPHONG)
    float s = SpecularBlinnPhong(N, L, V, n);
#else
    float s = 0.0;
#endif

    half3 color = (albedo * d + _SpecColor.rgb * s) * radiance;
    color += albedo * SampleSH(N) * _AmbientStrength;
    return half4(color, 1);
}