// 第 4 章所有“图案 Shader”共用的顶点部分：只需要位置和 UV。
#ifndef COOKBOOK_CH04_PROCEDURAL_COMMON_INCLUDED
#define COOKBOOK_CH04_PROCEDURAL_COMMON_INCLUDED

#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
#include "Assets/Cookbook/Ch04/ProceduralLib.hlsl"

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

struct Varyings
{
    float4 positionCS : SV_POSITION;
    float2 uv         : TEXCOORD0;
};

Varyings ProceduralVert(Attributes input)
{
    Varyings output;
    output.positionCS = TransformObjectToHClip(input.positionOS.xyz);
    output.uv = input.uv;
    return output;
}

#endif

// ---------------------------------------------------------------- 重映射与插值
// 把 x 从 [inMin, inMax] 线性映射到 [outMin, outMax]（不夹取）
float Remap(float x, float inMin, float inMax, float outMin, float outMax)
{
    return outMin + (x - inMin) * (outMax - outMin) / (inMax - inMin);
}

// smoothstep 去掉两端 S 形：纯线性的 0→1 过渡（Unity core 里也有同名思路的 Remap01）
float LinearStep(float edge0, float edge1, float x)
{
    return saturate((x - edge0) / (edge1 - edge0));
}

float2 q      = uv * N;       // 放大：[0,1] → [0,N]
float2 cellId = floor(q);     // 第几个格子（整数）：决定“这一格长什么样”
float2 local  = frac(q);      // 格子内的局部坐标 [0,1)：决定“格子里画什么”
float2 c      = local - 0.5;  // 以格子中心为原点，方便画圆、画方

float d  = ...;                 // 某个“到边缘的距离”，边缘处为 0
float aa = fwidth(d);           // 一个像素对应的 d 的变化量
float m  = smoothstep(-aa, aa, d);   // 恰好在一两个像素内完成过渡

// 第 k 条曲线 y = f(x)。改这里就能画任意函数
float Curve(int mode, int k, float x)
{
    if (mode == 0)          // 阈值类：step / smoothstep / 线性 step
    {
        if (k == 0) return step(0.5, x);
        if (k == 1) return smoothstep(0.2, 0.8, x);
        return LinearStep(0.2, 0.8, x);
    }
    if (mode == 1)          // 重复类：floor 阶梯 / frac 锯齿 / 三角波
    {
        if (k == 0) return floor(x * 4.0) / 4.0;
        if (k == 1) return frac(x * 2.0);
        return abs(frac(x) - 0.5) * 2.0;
    }
    // 形状类：脉冲（两个 smoothstep 相减）/ 正弦重映射 / 幂函数
    if (k == 0) return smoothstep(0.25, 0.35, x) - smoothstep(0.65, 0.75, x);
    if (k == 1) return 0.5 + 0.5 * sin(x * TWO_PI * 2.0);
    return x * x * x;
}

// 抗锯齿画线：把曲线在当前像素附近近似成一小段折线（左右各一个像素），
// 求到这段线段的距离，再换算成“像素单位”。跳变处线段几乎竖直，竖线也能自然连上
float PlotCurve(int mode, int k, float2 q, float pixel)
{
    float2 a = float2(q.x - pixel, Curve(mode, k, q.x - pixel));
    float2 b = float2(q.x + pixel, Curve(mode, k, q.x + pixel));
    float dist = SdSegment(q, a, b);
    return saturate(_LineWidth * 0.5 + 0.5 - dist / pixel);
}

// 到 d=0 处一条宽 widthPx 像素的线
float LineAt(float d, float pixel, float widthPx)
{
    return saturate(widthPx * 0.5 + 0.5 - abs(d) / pixel);
}

// 每隔 spacing 一条网格线：frac 把坐标折回到最近网格线附近
float GridLine(float v, float spacing, float pixel, float widthPx)
{
    float d = (frac(v / spacing + 0.5) - 0.5) * spacing;
    return LineAt(d, pixel, widthPx);
}

float Checker(float2 q)
{
    // floor 得到格子编号，横纵编号之和的奇偶决定颜色；abs 处理负数格子
    return abs(fmod(floor(q.x) + floor(q.y), 2.0));
}

float Stripes(float2 q, float duty)
{
    // 三角波：在条纹中心为 0、两条纹交界处为 1，宽度用阈值 duty 控制
    float tri = abs(frac(q.x) - 0.5) * 2.0;
    float aa = fwidth(tri);                         // 一个像素内 tri 变化了多少
    return 1.0 - smoothstep(duty - aa, duty + aa, tri);
}

float Dots(float2 q, float radius)
{
    // 奇数行错开半格，得到更紧凑的“蜂窝”排布
    float row = floor(q.y);
    q.x += 0.5 * abs(fmod(row, 2.0));
    float2 cell = frac(q) - 0.5;                    // 每格内以中心为原点的局部坐标
    float d = SdCircle(cell, radius * 0.5);
    return FillAA(d);
}

// ---------------------------------------------------------------- 旋转与极坐标
// 绕原点逆时针旋转 angle 弧度
float2 Rotate2D(float2 p, float angle)
{
    float s, c;
    sincos(angle, s, c);
    return mul(float2x2(c, -s, s, c), p);
}

// 笛卡尔 → 极坐标：x = 半径 r，y = 角度归一化到 [0,1)（从 +X 轴逆时针）
float2 ToPolar(float2 p)
{
    float r = length(p);
    float a = atan2(p.y, p.x);              // (-PI, PI]
    return float2(r, frac(a / TWO_PI + 1.0)); // 映射到 [0,1)
}

float r = length(p);
// 从 12 点方向开始、顺时针增加的角度，归一化到 [0,1)
float a01 = frac(atan2(p.x, p.y) / TWO_PI + 1.0);
float hw = _Thickness * 0.5;

float ring = abs(r - _Radius) - hw;              // 整圈环带的 SDF
// 已走过的部分：角度在进度内就用环带距离，否则用到两个“圆头”的距离
float endAngle = _Progress * TWO_PI;
float2 capStart = float2(0.0, _Radius);
float2 capEnd   = _Radius * float2(sin(endAngle), cos(endAngle));
float caps = min(length(p - capStart), length(p - capEnd)) - hw;
float arc = (a01 <= _Progress) ? ring : caps;
if (_Progress <= 0.0) arc = 1.0;                  // 进度为 0 时什么都不画

// 乘以宽高比，让 SDF 在拉长的面片上仍然是“正”的（圆角不会被压扁）
float2 p = (input.uv - 0.5) * float2(_Aspect, 1.0);
float2 halfSize = float2(_Aspect * 0.5, 0.5);
float outer = SdRoundBox(p, halfSize - 0.04, 0.22);     // 外框
float inner = SdRoundBox(p, halfSize - 0.14, 0.13);     // 槽
// 槽内的横向进度 0..1
float innerHalfW = halfSize.x - 0.14;
float x01 = saturate((p.x + innerHalfW) / (2.0 * innerHalfW));

// 血量颜色：低于阈值后快速变红
half3 hpCol = lerp(_ColorLow.rgb, _ColorFull.rgb, smoothstep(_LowThreshold * 0.6, _LowThreshold * 1.6, _Health));
// 低血量闪烁：_Time 驱动；静帧时用 _FlashPhase
float flash = 0.5 + 0.5 * sin(_Time.y * _FlashSpeed + _FlashPhase);
hpCol *= (_Health < _LowThreshold) ? lerp(0.7, 1.4, flash) : 1.0;

float px = fwidth(x01);
float hpMask    = 1.0 - smoothstep(_Health - px, _Health + px, x01);
float trailMask = 1.0 - smoothstep(_Trail  - px, _Trail  + px, x01);

half3 col = _EmptyColor.rgb;
col = lerp(col, _TrailColor.rgb, trailMask);           // 先画拖尾，再盖上当前血量
col = lerp(col, hpCol, hpMask);
// 上亮下暗，做出一点体积感
col *= lerp(0.75, 1.15, smoothstep(-0.35, 0.35, p.y));
// 分段刻度：frac 重复出竖线
float seg = abs(frac(x01 * _Segments + 0.5) - 0.5) / _Segments;   // 到最近刻度的距离（x01 单位）
col *= lerp(0.55, 1.0, smoothstep(px * 0.5, px * 1.5, seg));

half3 Flower(float2 p)
{
    float2 pol = ToPolar(p);
    float theta = pol.y * TWO_PI;
    // 半径随角度起伏：r(θ) = 基础半径 + 振幅·cos(Nθ)，N 片花瓣
    float edge = 0.55 + 0.25 * cos(_Count * theta);
    float petal = FillAA(pol.x - edge);
    // 花瓣内部再按半径做一层渐变，中心是一颗小圆
    half3 col = lerp(_BgColor.rgb, lerp(_ColorA.rgb, _ColorA.rgb * 0.55, pol.x / edge), petal);
    col = lerp(col, _ColorB.rgb, FillAA(SdCircle(p, 0.2)));
    return col;
}

half3 Spiral(float2 p)
{
    float2 pol = ToPolar(p);
    // 角度 + log(半径)：沿径向每走 e 倍，条纹转过 _Twist 圈 → 对数螺线
    float s = frac(pol.y * _Count + log(max(pol.x, 1e-4)) * _Twist);
    float band = abs(s - 0.5) * 2.0;
    float aa = fwidth(band);
    float m = smoothstep(0.5 - aa, 0.5 + aa, band);
    half3 col = lerp(_ColorA.rgb, _ColorB.rgb, m);
    // 中心处条纹无限变细，必然出摩尔纹；用一个圆盖住
    return lerp(col, _BgColor.rgb, FillAA(SdCircle(p, 0.06)));
}

half3 Sunburst(float2 p)
{
    float2 pol = ToPolar(p);
    float t = pol.y * _Count;                  // 每条光芒占 1 个单位
    float tri = abs(frac(t) - 0.5) * 2.0;
    // 坑：pol.y 在 +X 轴处从 1 跳回 0，fwidth 会在那条线上暴涨，画出一道“裂缝”。
    // 解决：用另一个在别处断开的角度（偏移半圈）求导，两者取小。
    float a2 = frac(pol.y + 0.5) * _Count;
    float aa = min(fwidth(t), fwidth(a2)) * 2.0;
    float ray = smoothstep(0.5 - aa, 0.5 + aa, tri);
    half3 col = lerp(_ColorA.rgb, _ColorB.rgb, ray);
    // 向外渐暗 + 中心太阳
    col *= lerp(1.15, 0.55, saturate(pol.x));
    return lerp(col, half3(1.0, 0.85, 0.45), FillAA(SdCircle(p, 0.22)));
}

// ---------------------------------------------------------------- 哈希：坐标 → 伪随机数
// PCG 风格的整数哈希：输入相同输出必相同，相邻输入的输出看起来毫无关联
uint PcgHash(uint v)
{
    uint state = v * 747796405u + 2891336453u;
    uint word = ((state >> ((state >> 28u) + 4u)) ^ state) * 277803737u;
    return (word >> 22u) ^ word;
}

// 2D 整数格子 → [0,1) 浮点
float Hash21(float2 cell)
{
    int2 i = (int2)floor(cell);
    uint h = PcgHash((uint)i.x + PcgHash((uint)i.y));
    return h * (1.0 / 4294967296.0);
}

// 2D 整数格子 → 两个 [0,1) 浮点
float2 Hash22(float2 cell)
{
    int2 i = (int2)floor(cell);
    uint h1 = PcgHash((uint)i.x + PcgHash((uint)i.y));
    uint h2 = PcgHash(h1 ^ 0x9E3779B9u);
    return float2(h1, h2) * (1.0 / 4294967296.0);
}

// ---------------------------------------------------------------- 噪声
// Value Noise：格点上放随机“值”，格内平滑插值。结果在 [0,1]
float ValueNoise(float2 p)
{
    float2 i = floor(p);
    float2 f = frac(p);
    float a = Hash21(i);
    float b = Hash21(i + float2(1, 0));
    float c = Hash21(i + float2(0, 1));
    float d = Hash21(i + float2(1, 1));
    float2 u = f * f * (3.0 - 2.0 * f);      // smoothstep 曲线 3t²-2t³
    return lerp(lerp(a, b, u.x), lerp(c, d, u.x), u.y);
}

// 格点上的随机单位梯度方向
float2 RandomGradient(float2 cell)
{
    float a = Hash21(cell) * TWO_PI;
    return float2(cos(a), sin(a));
}

// Gradient Noise（Perlin 思路）：格点上放随机“方向”，每个格点贡献 dot(梯度, 到该点的偏移)。结果约在 [-1,1]
float GradientNoise(float2 p)
{
    float2 i = floor(p);
    float2 f = frac(p);
    float2 u = f * f * f * (f * (f * 6.0 - 15.0) + 10.0);  // 五次曲线 6t⁵-15t⁴+10t³，二阶导连续
    float n00 = dot(RandomGradient(i),                 f);
    float n10 = dot(RandomGradient(i + float2(1, 0)), f - float2(1, 0));
    float n01 = dot(RandomGradient(i + float2(0, 1)), f - float2(0, 1));
    float n11 = dot(RandomGradient(i + float2(1, 1)), f - float2(1, 1));
    return lerp(lerp(n00, n10, u.x), lerp(n01, n11, u.x), u.y) * 1.41421356;
}

// Simplex Noise（2D）：把平面切成等边三角形，每个点只受所在三角形 3 个顶点影响。结果约在 [-1,1]
float SimplexNoise(float2 p)
{
    const float F2 = 0.36602540378;   // (√3 - 1) / 2：把平面“斜切”成方格
    const float G2 = 0.21132486540;   // (3 - √3) / 6：再切回来
    float2 i  = floor(p + (p.x + p.y) * F2);           // 所在斜切格
    float2 x0 = p - i + (i.x + i.y) * G2;              // 到第 1 个顶点的偏移
    float2 o  = (x0.x > x0.y) ? float2(1, 0) : float2(0, 1); // 在上三角还是下三角
    float2 x1 = x0 - o + G2;
    float2 x2 = x0 - 1.0 + 2.0 * G2;
    float3 w = max(0.5 - float3(dot(x0, x0), dot(x1, x1), dot(x2, x2)), 0.0);
    w = w * w; w = w * w;                               // (0.5 - r²)⁴ 的径向衰减核
    float3 n = float3(dot(RandomGradient(i), x0),
                      dot(RandomGradient(i + o), x1),
                      dot(RandomGradient(i + 1.0), x2));
    return dot(w, n) * 70.0;
}

if (_Mode < 0.5)      n = Hash21(p);                         // 每格一个随机值，格内不变
else if (_Mode < 1.5) n = ValueNoise(p);                     // [0,1]
else if (_Mode < 2.5) n = GradientNoise(p) * 0.5 + 0.5;      // [-1,1] → [0,1]
else                  n = SimplexNoise(p) * 0.5 + 0.5;

// Worley / Voronoi：每格放一个随机特征点，求到最近（F1）和次近（F2）特征点的距离
// phase 让特征点在格子内绕圈移动，用来做动画
float2 VoronoiPoint(float2 cell, float phase)
{
    float2 h = Hash22(cell);
    return 0.5 + 0.4 * sin(phase + TWO_PI * h);   // 特征点在格内的位置，始终留在 [0.1,0.9]
}

void Voronoi(float2 p, float phase, out float f1, out float f2, out float2 nearestCell)
{
    float2 i = floor(p);
    float2 f = frac(p);
    f1 = 8.0; f2 = 8.0; nearestCell = i;
    // F1 用 3×3 邻域就够；F2（次近点）可能在更远的格子里，所以搜 5×5
    [unroll] for (int y = -2; y <= 2; y++)
    [unroll] for (int x = -2; x <= 2; x++)
    {
        float2 g = float2(x, y);                       // 邻居格子相对偏移
        float d = length(g + VoronoiPoint(i + g, phase) - f);
        if (d < f1)      { f2 = f1; f1 = d; nearestCell = i + g; }
        else if (d < f2) { f2 = d; }
    }
}

// 到细胞边界的“真实”距离：边界是两个特征点连线的中垂线，
// 点到中垂线的距离 = dot(两点中点 - 当前点, 两点连线方向)
float VoronoiBorder(float2 p, float phase)
{
    float2 i = floor(p);
    float2 f = frac(p);
    // 第一遍：找最近点（相对当前点的向量 mr）
    float2 mg = 0, mr = 0; float md = 8.0;
    [unroll] for (int y = -1; y <= 1; y++)
    [unroll] for (int x = -1; x <= 1; x++)
    {
        float2 g = float2(x, y);
        float2 r = g + VoronoiPoint(i + g, phase) - f;
        float d = dot(r, r);
        if (d < md) { md = d; mr = r; mg = g; }
    }
    // 第二遍：以最近点所在格为中心，对其余每个点求到中垂线的距离，取最小
    md = 8.0;
    [unroll] for (int y2 = -2; y2 <= 2; y2++)
    [unroll] for (int x2 = -2; x2 <= 2; x2++)
    {
        float2 g = mg + float2(x2, y2);
        float2 r = g + VoronoiPoint(i + g, phase) - f;
        float2 diff = r - mr;
        if (dot(diff, diff) > 1e-5)
            md = min(md, dot(0.5 * (mr + r), normalize(diff)));
    }
    return md;
}