// ---------- 法线分布函数 D(h) ----------
// GGX / Trowbridge-Reitz：D = α² / (π · ((n·h)²(α²-1) + 1)²)
float C9_D_GGX(float NoH, float a)
{
    float a2 = a * a;
    float d = NoH * NoH * (a2 - 1.0) + 1.0;
    return a2 / (PI * d * d);
}

// Beckmann：D = exp(-tan²θh / α²) / (π α² cos⁴θh)
float C9_D_Beckmann(float NoH, float a)
{
    float a2 = a * a;
    float c2 = max(NoH * NoH, 1e-6);
    float t2 = (1.0 - c2) / c2;                 // tan²θh
    return exp(-t2 / a2) / (PI * a2 * c2 * c2);
}

// 归一化的 Blinn-Phong NDF：D = (n+2)/(2π) · cosⁿθh，指数 n 由 α 换算：n = 2/α² - 2
float C9_D_BlinnPhong(float NoH, float a)
{
    float n = 2.0 / max(a * a, 1e-4) - 2.0;
    return (n + 2.0) / (2.0 * PI) * pow(max(NoH, 0.0), n);
}

// 第 9 章：BRDF 单项可视化。
// 用一个 _Mode 参数切换输出 D、G、F、镜面项、漫反射项或完整的直接光照，
// 配合一排粗糙度递增的小球，就能“看见”每一项随粗糙度怎么变。
Shader "Cookbook/Ch09/BRDFTerms"
{
    Properties
    {
        [Enum(D,0,G,1,F_NoV,2,F_VoH,3,Specular,4,Diffuse,5,Full,6)] _Mode("Output", Float) = 6
        [Enum(GGX,0,Beckmann,1,BlinnPhong,2)] _NDF("NDF", Float) = 0
        [Enum(SmithSeparable,0,SmithHeightCorrelated,1,SchlickGGX,2,DiffX10,3)] _GModel("Geometry", Float) = 1
        [Enum(Lambert,0,Disney,1)] _DiffuseModel("Diffuse", Float) = 0
        _Roughness("Perceptual Roughness", Range(0.02, 1)) = 0.5
        _F0("F0 (linear)", Color) = (0.04, 0.04, 0.04, 1)
        _Albedo("Diffuse Albedo", Color) = (0.8, 0.8, 0.8, 1)
        [Enum(Raw,0,Exp,1)] _Display("Display", Float) = 0
        _Exposure("Exposure", Float) = 1
    }

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

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

            HLSLPROGRAM
            #pragma target 3.0
            #pragma vertex vert
            #pragma fragment frag

            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"
            #include "Assets/Cookbook/Ch09/BRDFLib.hlsl"

            CBUFFER_START(UnityPerMaterial)
                float _Mode, _NDF, _GModel, _DiffuseModel;
                float _Roughness;
                float4 _F0, _Albedo;
                float _Display, _Exposure;
            CBUFFER_END

            struct Attributes { float4 positionOS : POSITION; float3 normalOS : NORMAL; };
            struct Varyings
            {
                float4 positionCS : SV_POSITION;
                float3 positionWS : TEXCOORD0;
                float3 normalWS   : TEXCOORD1;
            };

            Varyings vert(Attributes v)
            {
                Varyings o;
                VertexPositionInputs p = GetVertexPositionInputs(v.positionOS.xyz);
                o.positionCS = p.positionCS;
                o.positionWS = p.positionWS;
                o.normalWS = TransformObjectToWorldNormal(v.normalOS);
                return o;
            }

            float EvalD(float NoH, float a)
            {
                if (_NDF < 0.5) return C9_D_GGX(NoH, a);
                if (_NDF < 1.5) return C9_D_Beckmann(NoH, a);
                return C9_D_BlinnPhong(NoH, a);
            }

            float EvalG(float NoL, float NoV, float a)
            {
                if (_GModel < 0.5) return C9_G_SmithSeparable(NoL, NoV, a);
                if (_GModel < 1.5) return C9_G_SmithHeightCorrelated(NoL, NoV, a);
                if (_GModel < 2.5) return C9_G_SchlickGGX(NoL, NoV, a);
                // 两种 Smith 形式之差放大 10 倍，看它们在哪儿不一样
                return abs(C9_G_SmithHeightCorrelated(NoL, NoV, a) - C9_G_SmithSeparable(NoL, NoV, a)) * 10.0;
            }

            half4 frag(Varyings i) : SV_Target
            {
                float3 N = normalize(i.normalWS);
                float3 V = GetWorldSpaceNormalizeViewDir(i.positionWS);
                Light light = GetMainLight();
                float3 L = light.direction;
                float3 H = SafeNormalize(L + V);

                float NoL = saturate(dot(N, L));
                float NoV = max(dot(N, V), 1e-4);     // 防止边缘处除零
                float NoH = saturate(dot(N, H));
                float VoH = saturate(dot(V, H));
                float LoH = VoH;                       // h 是 l、v 的角平分线，两者相等

                float a = _Roughness * _Roughness;     // α = perceptualRoughness²

                float  D = EvalD(NoH, a);
                float  G = EvalG(NoL, NoV, a);
                float3 F = C9_F_Schlick(_F0.rgb, VoH);

                // Cook-Torrance 镜面 BRDF：D·G·F / (4 (n·l)(n·v))
                float3 fSpec = D * G * F / max(4.0 * NoL * NoV, 1e-4);
                float3 fDiff = (_DiffuseModel < 0.5)
                    ? C9_Lambert(_Albedo.rgb)
                    : C9_DisneyDiffuse(_Albedo.rgb, NoL, NoV, LoH, _Roughness);

                // Unity 的灯光“颜色×强度”约定：白色 Lambert 面正对强度 1 的灯时输出 1，
                // 相当于入射辐照度 E = π · lightColor，所以出射辐射率 = f · π · lightColor · (n·l)。
                float3 E = PI * light.color * NoL;

                float3 c;
                if      (_Mode < 0.5) c = D.xxx;
                else if (_Mode < 1.5) c = (NoL > 0.0 ? G : 0.0).xxx;
                else if (_Mode < 2.5) c = C9_F_Schlick(_F0.rgb, NoV);
                else if (_Mode < 3.5) c = F;
                else if (_Mode < 4.5) c = fSpec * E;
                else if (_Mode < 5.5) c = fDiff * E;
                else                  c = ((1.0 - F) * fDiff + fSpec) * E;   // 漫反射只拿“没被镜面反射走”的那部分

                // 显示映射：Raw 直接输出（超过 1 会被截断）；Exp 用 1 - e^(-x·k) 把大范围数值压进 0..1
                if (_Display > 0.5) c = 1.0 - exp(-c * _Exposure);
                else                c *= _Exposure;
                return half4(c, 1);
            }
            ENDHLSL
        }
    }
}

[BookShot("ch09-ndf-compare", W = 420, H = 360, Panels = 3)]
static void NdfCompare(Shot s)
{
    var m = Terms(s, 0, 0.45f);
    m.SetFloat("_NDF", s.Panel);           // GGX / Beckmann / Blinn-Phong
    m.SetFloat("_Display", 1); m.SetFloat("_Exposure", 0.6f);
    Single(s, m, 30, 25);
}

// ---------- 几何遮蔽 G ----------
// GGX 的 Smith Λ 函数：Λ(θ) = (-1 + sqrt(1 + α² tan²θ)) / 2
float C9_Lambda_GGX(float NoX, float a)
{
    float c2 = max(NoX * NoX, 1e-6);
    float t2 = (1.0 - c2) / c2;
    return 0.5 * (-1.0 + sqrt(1.0 + a * a * t2));
}

// 单方向遮蔽 G1 = 1 / (1 + Λ)
float C9_G1_GGX(float NoX, float a) { return 1.0 / (1.0 + C9_Lambda_GGX(NoX, a)); }

// Smith 分离形式：G = G1(l) · G1(v)，假设“遮光”和“遮挡视线”互不相关
float C9_G_SmithSeparable(float NoL, float NoV, float a)
{
    return C9_G1_GGX(NoL, a) * C9_G1_GGX(NoV, a);
}

// Smith 高度相关形式（Height-Correlated）：G = 1 / (1 + Λ(l) + Λ(v))
float C9_G_SmithHeightCorrelated(float NoL, float NoV, float a)
{
    return 1.0 / (1.0 + C9_Lambda_GGX(NoL, a) + C9_Lambda_GGX(NoV, a));
}

// Schlick-GGX 近似：G1 ≈ n·x / (n·x (1-k) + k)，k = α/2
float C9_G_SchlickGGX(float NoL, float NoV, float a)
{
    float k = a * 0.5;
    float gl = NoL / (NoL * (1.0 - k) + k);
    float gv = NoV / (NoV * (1.0 - k) + k);
    return gl * gv;
}

// 可见性项 V = G / (4 (n·l)(n·v))，用高度相关 Smith 化简后的形式（Heitz 2014）
// V = 0.5 / ( n·l · sqrt((n·v)²(1-α²) + α²) + n·v · sqrt((n·l)²(1-α²) + α²) )
float C9_V_SmithHeightCorrelated(float NoL, float NoV, float a)
{
    float a2 = a * a;
    float lv = NoL * sqrt(NoV * NoV * (1.0 - a2) + a2);
    float ll = NoV * sqrt(NoL * NoL * (1.0 - a2) + a2);
    return 0.5 / max(lv + ll, 1e-5);
}

// ---------- 菲涅尔 F ----------
// Schlick 近似：F = F0 + (1 - F0)(1 - cosθ)⁵
float3 C9_F_Schlick(float3 F0, float cosTheta)
{
    float x = 1.0 - saturate(cosTheta);
    float x2 = x * x;
    return F0 + (1.0 - F0) * (x2 * x2 * x);
}

[BookShot("ch09-fresnel-angle", W = 420, H = 300, Panels = 3)]
static void FresnelAngle(Shot s)
{
    // 一块光滑的电介质地板，相机仰角从高到低；灯放在相机的镜面方向上，让高光正好落在画面中央。
    // 高光中心处 v·h = sin(仰角)：70° → 0.94，35° → 0.57，12° → 0.21
    float e = new[] { 70f, 35f, 12f }[s.Panel];
    var m = Terms(s, 4, 0.35f);
    m.SetVector("_F0", V(0.04f));
    m.SetFloat("_Display", 1); m.SetFloat("_Exposure", 1.0f);
    s.Background(new Color(0.16f, 0.17f, 0.19f));
    s.Grid(m, Vector3.zero, 40f, 8);
    float r = e * Mathf.Deg2Rad;
    s.LookAt(new Vector3(0, 6 * Mathf.Sin(r), -6 * Mathf.Cos(r)), Vector3.zero, 40);
    s.SunDir(e, 180, 1f);
    s.Sun.shadows = LightShadows.None;
}

// ---------- 漫反射 ----------
// Lambert：f = ρ / π
float3 C9_Lambert(float3 albedo) { return albedo * INV_PI; }

// Disney（Burley 2012）漫反射：在 Lambert 基础上按粗糙度调整掠射角的明暗
// fd90 = 0.5 + 2 · (l·h)² · perceptualRoughness
float3 C9_DisneyDiffuse(float3 albedo, float NoL, float NoV, float LoH, float perceptualRoughness)
{
    float fd90 = 0.5 + 2.0 * LoH * LoH * perceptualRoughness;
    float lightScatter = 1.0 + (fd90 - 1.0) * pow(1.0 - NoL, 5.0);
    float viewScatter  = 1.0 + (fd90 - 1.0) * pow(1.0 - NoV, 5.0);
    return albedo * INV_PI * lightScatter * viewScatter;
}

float3 N = normalize(i.normalWS);
float3 V = GetWorldSpaceNormalizeViewDir(i.positionWS);
Light light = GetMainLight();
float3 L = light.direction;
float3 H = SafeNormalize(L + V);

float NoL = saturate(dot(N, L));
float NoV = max(dot(N, V), 1e-4);     // 防止边缘处除零
float NoH = saturate(dot(N, H));
float VoH = saturate(dot(V, H));
float LoH = VoH;                       // h 是 l、v 的角平分线，两者相等

float a = _Roughness * _Roughness;     // α = perceptualRoughness²

float  D = EvalD(NoH, a);
float  G = EvalG(NoL, NoV, a);
float3 F = C9_F_Schlick(_F0.rgb, VoH);

// Cook-Torrance 镜面 BRDF：D·G·F / (4 (n·l)(n·v))
float3 fSpec = D * G * F / max(4.0 * NoL * NoV, 1e-4);
float3 fDiff = (_DiffuseModel < 0.5)
    ? C9_Lambert(_Albedo.rgb)
    : C9_DisneyDiffuse(_Albedo.rgb, NoL, NoV, LoH, _Roughness);

// Unity 的灯光“颜色×强度”约定：白色 Lambert 面正对强度 1 的灯时输出 1，
// 相当于入射辐照度 E = π · lightColor，所以出射辐射率 = f · π · lightColor · (n·l)。
float3 E = PI * light.color * NoL;

float3 c;
if      (_Mode < 0.5) c = D.xxx;
else if (_Mode < 1.5) c = (NoL > 0.0 ? G : 0.0).xxx;
else if (_Mode < 2.5) c = C9_F_Schlick(_F0.rgb, NoV);
else if (_Mode < 3.5) c = F;
else if (_Mode < 4.5) c = fSpec * E;
else if (_Mode < 5.5) c = fDiff * E;
else                  c = ((1.0 - F) * fDiff + fSpec) * E;   // 漫反射只拿“没被镜面反射走”的那部分

// 显示映射：Raw 直接输出（超过 1 会被截断）；Exp 用 1 - e^(-x·k) 把大范围数值压进 0..1
if (_Display > 0.5) c = 1.0 - exp(-c * _Exposure);
else                c *= _Exposure;
return half4(c, 1);