// 色阶：把连续的 0~1 明暗压成“亮 / 暗”两档，softness 控制交界的宽度（0 = 硬边）
half ToonBand(half x, half threshold, half softness)
{
    return smoothstep(threshold - softness, threshold + softness, x);
}

half4 frag(ToonVaryings i) : SV_Target
{
    UNITY_SETUP_INSTANCE_ID(i);
    half3 N = normalize(i.normalWS);
    Light light = GetMainLight();
    half NoL = dot(N, light.direction);
    half halfLambert = NoL * 0.5 + 0.5;     // 0~1，比 saturate(NoL) 更适合当查表坐标

    half3 color;
#if defined(_RAMP_LAMBERT)
    color = _BaseColor.rgb * saturate(NoL);                      // 对照：普通 Lambert
#elif defined(_RAMP_TEXTURE)
    // Ramp 贴图：横向就是“明暗 → 颜色”的映射表，美术可以随意画色阶与色相
    half3 ramp = SAMPLE_TEXTURE2D(_RampTex, sampler_RampTex, float2(clamp(halfLambert, 0.01, 0.99), 0.5)).rgb;
    color = _BaseColor.rgb * ramp;
#else
  #if defined(_RAMP_STEP)
    half band = step(_Threshold, halfLambert);                   // 硬边：会有锯齿
  #else
    // 软一点的硬边：过渡宽度至少一个像素（fwidth = 这个量在相邻像素间的变化），硬边也不会出锯齿
    half band = ToonBand(halfLambert, _Threshold, max(_Softness, fwidth(halfLambert)));
  #endif
    // 亮部用固有色，暗部用美术指定的阴影色，而不是“固有色 × 0.5”
    color = lerp(_ShadeColor.rgb, _BaseColor.rgb, band);
    // 可选的第二层阴影：在更暗的位置再切一档
    half band2 = ToonBand(halfLambert, _Shade2Threshold, _Softness);
    color = lerp(lerp(color, _ShadeColor2.rgb, _Shade2Strength), color, band2);
#endif
    color *= light.color;

    // 环境光：只取球谐的常数项（平均环境色），避免环境光把色块又“抹圆”
    color += SampleSH(half3(0, 0, 0)) * _BaseColor.rgb * _AmbientStrength;
    color = MixFog(color, i.fogFactor);
    return half4(color, 1);
}

// 菲涅尔边缘光：越靠近轮廓（N·V → 0）越亮，再做一次色阶得到“一条线”
half FresnelRim(half3 N, half3 V, half width, half softness)
{
    half f = 1.0 - saturate(dot(N, V));
    return ToonBand(f, 1.0 - width, softness);
}

// 屏幕空间深度边缘光：沿法线在屏幕上的投影方向偏移若干像素读深度，
// 如果那里的深度比自己“深很多”，说明自己处在轮廓边上
half DepthRim(ToonVaryings i, half3 N)
{
    float3 normalCS = TransformWorldToHClipDir(N);
    float2 dirPx = normalize(normalCS.xy * _ScreenParams.xy + 1e-6);
#if UNITY_UV_STARTS_AT_TOP
    dirPx.y = -dirPx.y;   // 这些平台的像素坐标 y 朝下，与裁剪空间 y 相反
#endif
    int2 p = int2(i.positionCS.xy + dirPx * _RimWidthPx);
    p = clamp(p, int2(0, 0), int2(_ScreenParams.xy) - 1);
    float sceneDepth = LinearEyeDepth(LoadSceneDepth(p), _ZBufferParams);
    float selfDepth = LinearEyeDepth(i.positionCS.z, _ZBufferParams);
    return step(_RimDepthThreshold, sceneDepth - selfDepth);
}

half4 frag(ToonVaryings i) : SV_Target
{
    UNITY_SETUP_INSTANCE_ID(i);
    half3 N = normalize(i.normalWS);
    half3 T = normalize(i.tangentWS.xyz);
    half3 B = cross(N, T) * i.tangentWS.w;
    half3 V = GetWorldSpaceNormalizeViewDir(i.positionWS);
    Light light = GetMainLight();
    half3 L = light.direction;
    half NoL = dot(N, L);
    half band = ToonBand(NoL * 0.5 + 0.5, _Threshold, _Softness);
    half3 color = lerp(_ShadeColor.rgb, _BaseColor.rgb, band) * light.color;
    color += SampleSH(half3(0, 0, 0)) * _BaseColor.rgb * 0.3;

    // ---------- 高光 ----------
    half3 H = normalize(L + V);
    half spec = 0;
#if defined(_SPEC_BLINN)
    spec = pow(saturate(dot(N, H)), 64.0);                                // 对照：普通 Blinn-Phong
#elif defined(_SPEC_TOON)
    spec = ToonBand(saturate(dot(N, H)), _SpecThreshold, 0.005);          // 色阶化：一个硬边色块
#elif defined(_SPEC_STYLIZED)
    spec = StylizedSpecular(N, T, B, H, _SpecShiftScale, _SpecSplit.xy, _SpecSquare, _SpecThreshold, 0.005);
#endif
    color += spec * band * _SpecColor.rgb * light.color;                  // 只在亮部出现

    // ---------- 边缘光 ----------
    half rim = 0;
#if defined(_RIM_FRESNEL)
    rim = FresnelRim(N, V, _RimWidth, 0.02);
#elif defined(_RIM_LIGHTMASKED)
    // 只保留朝光一侧的边缘：边缘光“像是被主光勾出来的”，背光侧不会到处发亮
    rim = FresnelRim(N, V, _RimWidth, 0.02) * ToonBand(NoL, 0.0, 0.1);
#elif defined(_RIM_DEPTH)
    rim = DepthRim(i, N) * ToonBand(NoL, -0.2, 0.1);
#endif
    color = lerp(color, _RimColor.rgb * light.color, rim);

    color = MixFog(color, i.fogFactor);
    return half4(color, 1);
}

// 风格化高光（思路来自 Anjyo & Hiramitsu 2003）：在切线空间里对半角向量 H 做平移、缩放、分裂，
// 最后用“高光区域的形状”切出硬边。T/B 是表面的切线与副切线。
half StylizedSpecular(half3 N, half3 T, half3 B, half3 H, half4 shiftScale, half2 split, half square, half threshold, half softness)
{
    H = normalize(H + shiftScale.x * T + shiftScale.y * B);                 // 平移：整体挪动高光
    H = normalize(H - shiftScale.z * dot(H, T) * T - shiftScale.w * dot(H, B) * B);   // 方向缩放：拉长/压扁
    H = normalize(H - split.x * sign(dot(H, T)) * T - split.y * sign(dot(H, B)) * B); // 分裂：一分为二/四
    // 方形化：H 在切平面上的分量 (x, y) 的长度就是 sin(N,H)。“N·H ≥ 阈值”等价于“长度 ≤ sin(阈值角)”。
    // 把长度换成 Lp 范数，p = 2 是圆，p 越大越接近正方形
    half2 xy = abs(half2(dot(H, T), dot(H, B)));
    half p = lerp(2.0, 10.0, square);
    half d = pow(pow(xy.x, p) + pow(xy.y, p), 1.0 / p);
    half sinTh = sqrt(saturate(1.0 - threshold * threshold));
    return smoothstep(-softness, softness, sinTh - d) * step(0.0, dot(N, H));
}

Pass
{
    Name "Outline"
    // URP 的不透明队列会画 UniversalForward 和 SRPDefaultUnlit 两种 LightMode，
    // 所以第二个 Pass 用 SRPDefaultUnlit 就能自动被画到，不需要 Renderer Feature
    Tags { "LightMode"="SRPDefaultUnlit" }
    Cull Front      // 只画背面
    ZWrite On

    HLSLPROGRAM
    #pragma vertex vert
    #pragma fragment frag
    #pragma shader_feature_local_vertex _OUTLINESPACE_OBJECT _OUTLINESPACE_CLIP
    #pragma shader_feature_local_vertex _OUTLINENORMAL_MESH _OUTLINENORMAL_TANGENT _OUTLINENORMAL_VERTEXCOLOR
    #pragma multi_compile_fog
    #pragma multi_compile_instancing
    #include "Assets/Cookbook/Ch14/ToonCommon.hlsl"

    struct OutlineVaryings
    {
        float4 positionCS : SV_POSITION;
        float  fogFactor  : TEXCOORD0;
        UNITY_VERTEX_INPUT_INSTANCE_ID
    };

    // 取“用来外扩的法线”：原始法线 / 烘焙在切线里的平滑法线 / 烘焙在顶点色里的切线空间平滑法线
    float3 GetOutlineNormalOS(ToonAttributes v)
    {
    #if defined(_OUTLINENORMAL_TANGENT)
        return v.tangentOS.xyz;                               // 物体空间平滑法线
    #elif defined(_OUTLINENORMAL_VERTEXCOLOR)
        float3 nTS = v.color.rgb * 2.0 - 1.0;                  // 切线空间平滑法线
        float3 bitangentOS = cross(v.normalOS, v.tangentOS.xyz) * v.tangentOS.w;
        return normalize(nTS.x * v.tangentOS.xyz + nTS.y * bitangentOS + nTS.z * v.normalOS);
    #else
        return v.normalOS;
    #endif
    }

    OutlineVaryings vert(ToonAttributes v)
    {
        OutlineVaryings o;
        UNITY_SETUP_INSTANCE_ID(v);
        UNITY_TRANSFER_INSTANCE_ID(v, o);
        float3 n = GetOutlineNormalOS(v);
    #if defined(_OUTLINESPACE_OBJECT)
        o.positionCS = OutlinePositionCS_ObjectSpace(v.positionOS.xyz, n, _OutlineWidthOS);
    #else
        o.positionCS = OutlinePositionCS(v.positionOS.xyz, n, _OutlineWidth);
    #endif
        o.fogFactor = ComputeFogFactor(o.positionCS.z);
        return o;
    }

    half4 frag(OutlineVaryings i) : SV_Target
    {
        return half4(MixFog(_OutlineColor.rgb, i.fogFactor), 1);
    }
    ENDHLSL
}

// 描边外扩：在裁剪空间沿法线方向推开固定的像素宽度。
//   normalOS：用于外扩的法线（可以是平滑后的法线）；widthPx：线宽（像素）
float4 OutlinePositionCS(float3 positionOS, float3 normalOS, float widthPx)
{
    float4 positionCS = TransformObjectToHClip(positionOS);
    float3 normalWS = TransformObjectToWorldNormal(normalOS);
    float3 normalCS = TransformWorldToHClipDir(normalWS, true);   // 方向向量只受 VP 的 3×3 部分影响
    // 先把方向换到“像素空间”再归一化：NDC 的 x、y 一个单位对应的像素数不同（宽高比），
    // 直接 normalize(normalCS.xy) 会让横向和纵向的线宽不一致
    float2 dirPx = normalize(normalCS.xy * _ScreenParams.xy + 1e-6);
    // NDC 的 [-1,1] 对应整个屏幕，所以 1 像素 = 2 / 屏幕尺寸；乘 w 是为了抵消之后的透视除法
    float2 offset = dirPx * widthPx * 2.0 / _ScreenParams.xy;
    positionCS.xy += offset * positionCS.w;
    return positionCS;
}

// 对照组：物体空间外扩（线宽随距离变化，近粗远细）
float4 OutlinePositionCS_ObjectSpace(float3 positionOS, float3 normalOS, float width)
{
    return TransformObjectToHClip(positionOS + normalize(normalOS) * width);
}

public static void Bake(Mesh mesh, Target target)
{
    var verts = mesh.vertices;
    var tris = mesh.triangles;
    var normals = mesh.normals;
    var tangents = mesh.tangents;
    if (tangents == null || tangents.Length != verts.Length)
    {
        mesh.RecalculateTangents();
        tangents = mesh.tangents;
    }

    // 1) 按位置分组：硬边处同一个位置有好几个顶点（各自带不同法线）
    var groups = new Dictionary<Vector3Int, Vector3>();
    Vector3Int Key(Vector3 p) => new Vector3Int(Mathf.RoundToInt(p.x * 1e4f), Mathf.RoundToInt(p.y * 1e4f), Mathf.RoundToInt(p.z * 1e4f));

    // 2) 累加每个三角形的面法线，用“顶点处的夹角”加权（比按面积加权更不受三角剖分影响）
    for (int t = 0; t < tris.Length; t += 3)
    {
        Vector3 p0 = verts[tris[t]], p1 = verts[tris[t + 1]], p2 = verts[tris[t + 2]];
        Vector3 fn = Vector3.Cross(p1 - p0, p2 - p0).normalized;
        for (int k = 0; k < 3; k++)
        {
            Vector3 a = verts[tris[t + k]], b = verts[tris[t + (k + 1) % 3]], c = verts[tris[t + (k + 2) % 3]];
            float angle = Vector3.Angle(b - a, c - a) * Mathf.Deg2Rad;
            var key = Key(a);
            groups.TryGetValue(key, out var sum);
            groups[key] = sum + fn * angle;
        }
    }

    // 3) 写回
    var outTangents = new Vector4[verts.Length];
    var outColors = new Color[verts.Length];
    var oldColors = mesh.colors;
    for (int i = 0; i < verts.Length; i++)
    {
        Vector3 smooth = groups[Key(verts[i])].normalized;
        if (target == Target.Tangent)
        {
            outTangents[i] = new Vector4(smooth.x, smooth.y, smooth.z, 1);
        }
        else
        {
            // 物体空间 → 该顶点自己的切线空间（T, B, N）
            Vector3 n = normals[i];
            Vector3 tg = tangents[i];
            Vector3 bt = Vector3.Cross(n, tg) * tangents[i].w;
            var ts = new Vector3(Vector3.Dot(smooth, tg), Vector3.Dot(smooth, bt), Vector3.Dot(smooth, n));
            float alpha = oldColors != null && oldColors.Length == verts.Length ? oldColors[i].a : 1f;  // A 通道留给线宽遮罩
            outColors[i] = new Color(ts.x * 0.5f + 0.5f, ts.y * 0.5f + 0.5f, ts.z * 0.5f + 0.5f, alpha);
        }
    }
    if (target == Target.Tangent) mesh.tangents = outTangents;
    else mesh.colors = outColors;
}

[MenuItem("Cookbook/Ch14/Bake Smooth Normals (Tangent)")]
static void BakeToTangent() => BakeSelection(Target.Tangent);

[MenuItem("Cookbook/Ch14/Bake Smooth Normals (Vertex Color)")]
static void BakeToColor() => BakeSelection(Target.VertexColor);

static void BakeSelection(Target target)
{
    foreach (var obj in Selection.objects)
    {
        string path = AssetDatabase.GetAssetPath(obj);
        var meshes = new List<Mesh>();
        if (obj is Mesh m) meshes.Add(m);
        else foreach (var a in AssetDatabase.LoadAllAssetsAtPath(path)) if (a is Mesh mm) meshes.Add(mm);

        foreach (var src in meshes)
        {
            var copy = Object.Instantiate(src);   // 不改原始模型，另存一份
            copy.name = src.name + "_SmoothNormals";
            Bake(copy, target);
            string dir = System.IO.Path.GetDirectoryName(path);
            string outPath = AssetDatabase.GenerateUniqueAssetPath($"{dir}/{copy.name}.asset");
            AssetDatabase.CreateAsset(copy, outPath);
            Debug.Log($"[Ch14] 平滑法线已烘焙到 {target}：{outPath}");
        }
    }
    AssetDatabase.SaveAssets();
}

[MenuItem("Cookbook/Ch14/Bake Smooth Normals (Tangent)", true)]
[MenuItem("Cookbook/Ch14/Bake Smooth Normals (Vertex Color)", true)]
static bool Validate() => Selection.objects.Length > 0;

// 发丝高光的核心（Kajiya-Kay）：沿发丝方向 T 的“圆柱”高光，sin(T,H) 越接近 1 越亮
half StrandSpecular(half3 T, half3 N, half3 H, half shift, half exponent)
{
    T = normalize(T + shift * N);              // 沿法线挪动切线 = 让高光带上下移动
    half ToH = dot(T, H);
    half sinTH = sqrt(saturate(1.0 - ToH * ToH));
    return smoothstep(-1.0, 0.0, ToH) * pow(sinTH, exponent);
}

half4 frag(ToonVaryings i) : SV_Target
{
    UNITY_SETUP_INSTANCE_ID(i);
    half3 N = normalize(i.normalWS);
    half3 Tm = normalize(i.tangentWS.xyz);
    half3 Bm = cross(N, Tm) * i.tangentWS.w;
    half3 T = _StrandAlongV > 0.5 ? Bm : Tm;          // 发丝方向
    half3 V = GetWorldSpaceNormalizeViewDir(i.positionWS);
    Light light = GetMainLight();

    half band = ToonBand(dot(N, light.direction) * 0.5 + 0.5, 0.5, 0.02);
    half3 color = lerp(_ShadeColor.rgb, _BaseColor.rgb, band) * light.color;
    color += SampleSH(half3(0, 0, 0)) * _BaseColor.rgb * 0.3;

    // 天使环的“光源”：可以跟主光走，也可以固定在相机上方——后者让环始终出现在头顶，
    // 这是很多二次元项目的选择（美术要的是稳定的造型，而不是物理正确）
    half3 viewUp = normalize(UNITY_MATRIX_I_V._m01_m11_m21);
    half3 Lring = normalize(lerp(light.direction, normalize(V + viewUp * 0.6), _RingFollowView));
    half3 H = normalize(Lring + V);

    half noise = SAMPLE_TEXTURE2D(_ShiftTex, sampler_ShiftTex, TRANSFORM_TEX(i.uv, _ShiftTex)).r;
    half shift = _RingShift + (noise - 0.5) * _RingNoise;   // 每缕头发偏移不同 → 锯齿边
    half s = StrandSpecular(T, N, H, shift, _RingExponent);

    half ring = 0;
#if defined(_RING_SMOOTH)
    ring = s;                                               // 写实版：连续的发丝高光
#elif defined(_RING_TOON)
    ring = ToonBand(s, _RingThreshold, 0.02);               // 卡通版：切成硬边色块
#endif
    color = lerp(color, _RingColor.rgb * lerp(0.6, 1.0, band), ring * 0.9);

    return half4(MixFog(color, i.fogFactor), 1);
}

// 光从画面右侧、与脸正前方成 phi（弧度，0~π）时，第 y 行的明暗交界线在哪（X ∈ [-1, 1]）
static float Boundary(float phi, float y)
{
    // 鼻子：交界线在鼻子高度处向暗侧“凸出”一块（鼻子挡光，留下鼻影）
    float nose = Mathf.Exp(-Mathf.Pow((y - 0.47f) / 0.07f, 2));
    // 眼窝与下巴：上下两端各稍微内收，交界线不再是一条竖直线
    float shape = 0.18f * Mathf.Exp(-Mathf.Pow((y - 0.6f) / 0.12f, 2)) - 0.25f * Mathf.Pow(Mathf.Max(0, 0.35f - y) / 0.35f, 2);
    // 把起伏乘上 sin(phi)：正面光和背光时没有影子形状可言；系数 < 1 保证随 phi 单调
    float p = phi + (0.55f * nose + shape) * Mathf.Sin(phi);
    return -Mathf.Cos(Mathf.Clamp(p, 0, Mathf.PI));
}

// 第 k 张二值图：1 = 亮，0 = 暗
public static bool[] Mask(int size, float phi)
{
    var m = new bool[size * size];
    for (int y = 0; y < size; y++)
    {
        float b = Boundary(phi, (y + 0.5f) / size);
        for (int x = 0; x < size; x++)
            m[y * size + x] = ((x + 0.5f) / size * 2f - 1f) > b;
    }
    return m;
}

// 有符号距离场：亮区为正、暗区为负，单位是像素。
// 这里用最直白的做法：先找出所有边界像素，再对每个像素求到它们的最近距离。
// 256² 的图足够快；更大的图请用 8SSEDT 或 Jump Flooding。
public static float[] SignedDistance(bool[] mask, int size)
{
    var edge = new List<Vector2>();
    for (int y = 0; y < size; y++)
        for (int x = 0; x < size; x++)
        {
            bool v = mask[y * size + x];
            bool diff = (x + 1 < size && mask[y * size + x + 1] != v) || (y + 1 < size && mask[(y + 1) * size + x] != v);
            if (diff) edge.Add(new Vector2(x + 0.5f, y + 0.5f));
        }
    var d = new float[size * size];
    if (edge.Count == 0)
    {
        // 全亮（phi = 0）或全暗（phi = π）的图没有边界：把交界线视为在图的左缘 / 右缘
        for (int y = 0; y < size; y++)
            for (int x = 0; x < size; x++)
                d[y * size + x] = mask[y * size + x] ? x + 0.5f : -(size - x - 0.5f);
        return d;
    }
    for (int y = 0; y < size; y++)
        for (int x = 0; x < size; x++)
        {
            float best = float.MaxValue;
            foreach (var e in edge)
            {
                float dx = e.x - x, dy = e.y - y;
                float dd = dx * dx + dy * dy;
                if (dd < best) best = dd;
            }
            float dist = Mathf.Sqrt(best);
            d[y * size + x] = mask[y * size + x] ? dist : -dist;
        }
    return d;
}

// 合成阈值图：对每个像素，找到它“从亮变暗”的那两张相邻图 k、k+1，
// 用两张图的 SDF 线性插值求出过零点的位置 t，阈值 = (k + t) / (N - 1)
public static Texture2D Generate(int size, int count, out Texture2D maskViz, out Texture2D sdfViz, int vizIndex = 3)
{
    var masks = new bool[count][];
    var sdfs = new float[count][];
    for (int k = 0; k < count; k++)
    {
        float phi = Mathf.PI * k / (count - 1);
        masks[k] = Mask(size, phi);
        sdfs[k] = SignedDistance(masks[k], size);
    }

    var outPx = new Color[size * size];
    for (int i = 0; i < size * size; i++)
    {
        float th = 0;
        for (int k = 0; k < count - 1; k++)
        {
            float a = sdfs[k][i], b = sdfs[k + 1][i];
            if (a >= 0 && b < 0)
            {
                float t = a / (a - b);
                th = (k + t) / (count - 1);
                break;
            }
            if (a >= 0 && b >= 0) th = (k + 1f) / (count - 1);   // 这一段一直是亮的
        }
        outPx[i] = new Color(th, th, th, 1);
    }

    maskViz = ToTex(size, i => masks[vizIndex][i] ? 1f : 0f);
    sdfViz = ToTex(size, i => Mathf.Clamp01(0.5f + sdfs[vizIndex][i] / (size * 0.5f)));
    var tex = new Texture2D(size, size, TextureFormat.RGBAHalf, false, true)
    { name = "FaceThreshold", wrapMode = TextureWrapMode.Clamp, filterMode = FilterMode.Bilinear };
    tex.SetPixels(outPx); tex.Apply();
    return tex;
}