half4 frag(Varyings i) : SV_Target
{
    // 时间：运行时用 _Time.y，配图时 _Time 不可控，用 _Phase 指定“第几秒”
    // frac 把偏移量限制在 0..1：贴图是 Repeat 寻址，结果不变，但避免长时间运行后浮点精度下降
    float t = _Time.y + _Phase;
    float2 off1 = frac(_Layer1.zw * t);
    float2 off2 = frac(_Layer2.zw * t);

    // 第二层：既参与叠加，也用来扰动第一层的 UV
    half n2 = SAMPLE_TEXTURE2D(_NoiseTex, sampler_NoiseTex, i.uv * _Layer2.xy + off2).r;
    float2 distort = (n2 - 0.5) * _Distort * _SecondLayer;
    half n1 = SAMPLE_TEXTURE2D(_NoiseTex, sampler_NoiseTex, i.uv * _Layer1.xy + off1 + distort).r;

    half v = lerp(n1, n1 * n2 * 2.0, _SecondLayer);     // 两层相乘再 ×2，保持平均亮度
    v = saturate(v);

    half3 col = v.xxx;
    if (_UseRamp > 0.5)
    {
        // 渐变映射：灰度 → 颜色。暗处是冷却的黑色岩壳，亮处是高温的黄白色
        half k = smoothstep(0.3, 1.0, v);
        col = SAMPLE_TEXTURE2D(_RampTex, sampler_RampTex, float2(k, 0.5)).rgb * (k * k * _Intensity);
    }
    col = MixFog(col, i.fog);
    return half4(col, 1);
}

// 第 frame 帧在图集中的 UV。约定：第 0 帧在左上角，从左到右、从上到下排列（与 Unity 粒子的 Texture Sheet Animation 一致）。
// 纹理坐标的 V 轴向上，所以“第 0 行”对应 V 最大的那一行。
float2 FlipbookUV(float2 uv, float frame, float2 grid)
{
    float total = grid.x * grid.y;
    frame = fmod(floor(frame), total);           // 播完从头循环
    float col = fmod(frame, grid.x);
    float row = floor(frame / grid.x);
    return (uv + float2(col, grid.y - 1.0 - row)) / grid;
}

half4 frag(Varyings i) : SV_Target
{
    float frame = _Time.y * _FPS + _Frame;       // 连续的“帧号”，小数部分就是两帧之间的进度

#if defined(_DEBUG_ATLAS)
    // 调试：整张图集 + 网格线；当前帧描橙框，下一帧描蓝框
    half4 atlas = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, i.uv);
    half3 bg = lerp(half3(0.12, 0.16, 0.2), atlas.rgb, atlas.a);
    float2 cell = i.uv * _Grid.xy;
    float2 f = frac(cell);
    float line_ = step(min(min(f.x, 1 - f.x), min(f.y, 1 - f.y)), 0.015);
    float idx = (_Grid.y - 1 - floor(cell.y)) * _Grid.x + floor(cell.x);
    float total = _Grid.x * _Grid.y;
    float cur = fmod(floor(frame), total), nxt = fmod(floor(frame) + 1, total);
    float border = step(min(min(f.x, 1 - f.x), min(f.y, 1 - f.y)), 0.05);
    bg = lerp(bg, half3(0.5, 0.55, 0.6), line_);
    bg = lerp(bg, half3(1.0, 0.45, 0.15), border * (idx == cur));
    bg = lerp(bg, half3(0.25, 0.6, 1.0), border * (idx == nxt));
    return half4(bg, 1);
#endif

    float2 uvA = FlipbookUV(i.uv, frame, _Grid.xy);
    half4 c = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, uvA);
#if defined(_FLIPBOOK_BLEND)
    // 帧间混合：再采一张“下一帧”，按小数部分线性插值。代价是多一次采样
    float2 uvB = FlipbookUV(i.uv, frame + 1.0, _Grid.xy);
    half4 cB = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, uvB);
    c = lerp(c, cB, frac(frame));
#endif
    c *= _BaseColor * i.color;
    return c;
}

// Flowmap 双相位采样：两套相位差半个周期的 UV，各自沿流向“漂”，权重呈三角波交替。
// 某一相位重置（跳回原位）的瞬间，它的权重恰好为 0，所以看不到跳变。
struct FlowSample
{
    float2 uv0, uv1;
    float  w0;           // 第一套的权重，第二套为 1 - w0
};

FlowSample FlowUV(float2 uv, float2 flow, float time)
{
    FlowSample s;
    float p0 = frac(time);
    float p1 = frac(time + 0.5);
    s.uv0 = uv - flow * p0;
    s.uv1 = uv - flow * p1 + float2(0.37, 0.21);  // 第二套错开一点，避免两层图案重合时出现“重影节拍”
    s.w0 = 1.0 - abs(1.0 - 2.0 * p0);             // p0 = 0 或 1（重置时）权重为 0，p0 = 0.5 时为 1
    return s;
}

half4 frag(Varyings i) : SV_Target
{
    half4 flowTex = SAMPLE_TEXTURE2D(_FlowMap, sampler_FlowMap, i.uv);
    if (_Mode < 0.5) return half4(flowTex.rg, 0, 1);          // 直接显示流向图

    // RG 存的是 0..1，映射回 -1..1 的方向向量（0.5 灰 = 静止）
    float2 flow = (flowTex.rg * 2.0 - 1.0) * _FlowStrength;
    float t = (_Time.y + _Phase) * _Speed;
    float2 uv = TRANSFORM_TEX(i.uv, _BaseMap);

    half4 c;
    if (_Mode < 1.5)
    {
        // 单相位：UV 沿流向越漂越远，到 frac 归零时整张图“啪”地跳回原位
        c = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, uv - flow * frac(t));
    }
    else
    {
        FlowSample fs = FlowUV(uv, flow, t);
        half4 c0 = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, fs.uv0);
        half4 c1 = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, fs.uv1);
        c = c0 * fs.w0 + c1 * (1.0 - fs.w0);
    }

    if (_UseRamp > 0.5)
    {
        half k = smoothstep(0.2, 0.9, c.r);
        c.rgb = SAMPLE_TEXTURE2D(_RampTex, sampler_RampTex, float2(k, 0.5)).rgb * (k * k * _Intensity);
    }
    return half4(c.rgb, 1);
}

// 直角坐标 → 极坐标：x = 角度（0..1，一圈），y = 半径（中心 0，四边中点 1）
float2 ToPolar(float2 uv, float2 center)
{
    float2 d = uv - center;
    float angle = atan2(d.y, d.x) * (0.5 * INV_PI) + 0.5;
    float radius = length(d) * 2.0;
    return float2(angle, radius);
}

float2 SwirlUV(float2 polar, float t, float spin)
{
    // x：角度 × 臂数（必须是整数才能首尾相接）+ 半径 × 扭转（越往里转得越多）+ 时间旋转
    // y：半径 × 平铺 − 时间（图案不断向中心流）
    return float2(polar.x * _Arms + polar.y * _Twist + t * spin,
                  polar.y * _RadialTiling - t * _Inward);
}

// 带接缝修正的采样：atan2 在 ±π 处从 1 跳回 0，硬件按 2×2 像素块求导会得到巨大的 ddx，
// 于是选中最低一级 mip，在接缝上画出一条线。修正：另算一份“接缝挪到对面”的角度，取较小的导数
half SampleSwirl(float2 polar, float t, float spin)
{
    float2 uv = SwirlUV(polar, t, spin);
    float2 dx = ddx(uv), dy = ddy(uv);
    if (_FixSeam > 0.5)
    {
        float2 uvAlt = SwirlUV(float2(frac(polar.x + 0.5), polar.y), t, spin);
        float2 dxAlt = ddx(uvAlt), dyAlt = ddy(uvAlt);
        dx.x = abs(dx.x) < abs(dxAlt.x) ? dx.x : dxAlt.x;
        dy.x = abs(dy.x) < abs(dyAlt.x) ? dy.x : dyAlt.x;
    }
    return SAMPLE_TEXTURE2D_GRAD(_NoiseTex, sampler_NoiseTex, uv, dx, dy).r;
}

half4 frag(Varyings i) : SV_Target
{
    float2 polar = ToPolar(i.uv, float2(0.5, 0.5));
    float t = _Time.y + _Phase;

    if (_Debug > 0.5 && _Debug < 1.5) return half4(polar.x, polar.y, 0, 1);
    if (_Debug > 1.5 && _Debug < 2.5) return half4(frac(SwirlUV(polar, t, _Spin)), 0, 1);
    // 只看一层漩涡噪声并二值化：接缝处取到最低级 mip（≈ 平均灰），在黑白图案里显出一道灰线
    if (_Debug > 3.5) { float2 u = SwirlUV(polar, t, _Spin); float d = max(length(ddx(u)), length(ddy(u))); return half4(saturate(log2(d * 512.0) / 10.0).xxx, 1); }
    if (_Debug > 2.5) return half4(smoothstep(0.5, 0.7, SampleSwirl(polar, t, _Spin)).xxx, 1);

    // 两层速度不同的漩涡相乘，图案更“活”
    half n1 = SampleSwirl(polar, t, _Spin);
    half n2 = SampleSwirl(polar * float2(1, 0.7), t * 1.3, -_Spin * 0.6);
    half swirl = pow(saturate(n1 * n2 * 2.0), _Contrast);

    half r = polar.y;
    half disc = smoothstep(1.0, 0.8, r);                     // 外缘淡出
    half rim  = exp(-pow((r - 0.86) * 9.0, 2.0));            // 外圈一道亮环
    half core = exp(-r * r * 18.0);                          // 中心光核
    half3 col = lerp(_ColorInner.rgb, _ColorOuter.rgb, saturate(r * 1.2));
    half3 result = col * (swirl * disc + rim * 0.8) + _ColorInner.rgb * core;
    return half4(result, 1);
}

// 与粒子系统 Renderer › Custom Vertex Streams 的顺序一一对应：
//   Position(POSITION) · Color(COLOR) · UV(TEXCOORD0.xy) · UV2(TEXCOORD0.zw) · AnimBlend(TEXCOORD1.x)
struct Attributes
{
    float4 positionOS : POSITION;
    half4  color      : COLOR;
#if defined(_FLIPBOOKBLENDING_ON)
    float4 texcoords  : TEXCOORD0;   // xy = 当前帧 UV，zw = 下一帧 UV
    float  animBlend  : TEXCOORD1;   // 两帧之间的进度 0..1
#else
    float2 texcoords  : TEXCOORD0;
#endif
    UNITY_VERTEX_INPUT_INSTANCE_ID
};

half4 frag(Varyings i) : SV_Target
{
    half4 tex = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, i.uv.xy);
#if defined(_FLIPBOOKBLENDING_ON)
    half4 tex2 = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, i.uv.zw);
    tex = lerp(tex, tex2, i.extra.x);
#endif

    // 顶点色 = 粒子系统的 Start Color × Color over Lifetime：整个粒子系统的颜色变化都从这里进来
    half4 c = tex * i.color * _BaseColor;

#if defined(_RAMP_ON)
    // 渐变映射：用“贴图浓度 × 粒子剩余寿命（顶点色 alpha）”去查火焰渐变，越老越暗红
    half k = saturate(tex.a * i.color.a * _RampScale);
    c.rgb = SAMPLE_TEXTURE2D(_RampTex, sampler_RampTex, float2(k, 0.5)).rgb * _BaseColor.rgb;
    c.a = saturate(k);
#endif

    float thisZ = i.screenData.z;
#if defined(_SOFTPARTICLES_ON)
    // 软粒子：比较场景深度与粒子自身深度，越接近（快要插进物体）越透明
    float2 suv = i.screenData.xy / i.screenData.w;
    float sceneZ = LinearEyeDepth(SampleSceneDepth(suv), _ZBufferParams);
    c.a *= saturate((sceneZ - thisZ) / _SoftDistance);
#endif
#if defined(_CAMERAFADE_ON)
    // 近相机淡出：粒子贴脸时会糊满屏幕、产生巨大 Overdraw，提前淡掉
    c.a *= saturate((thisZ - _CameraFadeNear) / max(_CameraFadeFar - _CameraFadeNear, 1e-3));
#endif

    c.rgb *= lerp(1.0, c.a, _Premultiply);   // 预乘：Blend One OneMinusSrcAlpha 时需要
    // 正片叠底（Blend DstColor Zero）没有 alpha 参与：把 alpha 折算进颜色，透明处趋向白色（=不改变背景）
    c.rgb = lerp(c.rgb, lerp(1.0, c.rgb, c.a), _Modulate);
    // 雾：Alpha 混合直接 MixFog；叠加模式应往黑色雾化 MixFogColor(c.rgb, 0, fog)，否则雾里越叠越亮
    c.rgb = MixFog(c.rgb, i.extra.y);
    return c;
}

/// 用一组朝向相机的 Quad 摆出“一团粒子”，每个 Quad 带不同的顶点色（模拟粒子的 Start Color）
static void FakeParticles(Shot s, Material m, Vector3 center, int count, Vector3 spread, float size, Color c0, Color c1, int seed)
{
    var rnd = new System.Random(seed);
    for (int i = 0; i < count; i++)
    {
        var p = center + Vector3.Scale(new Vector3((float)rnd.NextDouble() - 0.5f, (float)rnd.NextDouble() - 0.5f, (float)rnd.NextDouble() - 0.5f), spread);
        var q = s.Quad(m, p, size * Mathf.Lerp(0.7f, 1.2f, (float)rnd.NextDouble()));
        q.transform.rotation = Quaternion.LookRotation(p - s.Cam.transform.position) * Quaternion.Euler(0, 0, (float)rnd.NextDouble() * 360);
        var mesh = Object.Instantiate(q.GetComponent<MeshFilter>().sharedMesh);
        var col = Color.Lerp(c0, c1, (float)rnd.NextDouble());
        mesh.colors = new[] { col, col, col, col };
        q.GetComponent<MeshFilter>().sharedMesh = mesh;
        s.Temp.Add(mesh);
    }
}

float SoftParticles(float near, float far, float4 projection)
{
    float fade = 1;
    if (near > 0.0 || far > 0.0)
    {
        float2 uv = UnityStereoTransformScreenSpaceTex(projection.xy / projection.w);
        uv = FoveatedRemapLinearToNonUniform(uv);
        float rawDepth = SAMPLE_TEXTURE2D_X(_CameraDepthTexture, sampler_CameraDepthTexture, uv).r;
        float sceneZ = (unity_OrthoParams.w == 0) ? LinearEyeDepth(rawDepth, _ZBufferParams) : LinearDepthToEyeDepth(rawDepth);
        float thisZ = LinearEyeDepth(projection.z / projection.w, _ZBufferParams);
        fade = saturate(far * ((sceneZ - near) - thisZ));
    }
    return fade;
}

/// 建一个用本章 Shader 的粒子系统：Texture Sheet Animation 4×4 + Custom Vertex Streams（UV2 + AnimBlend）
static ParticleSystem MakeSystem(Shot s, Material m, Vector3 pos, float rate, Vector2 life, Vector2 speed, Vector2 size,
                                 Gradient colorOverLife, AnimationCurve sizeOverLife, float coneAngle, float radius, int seed)
{
    var go = new GameObject("Particles");
    go.transform.position = pos;
    go.transform.rotation = Quaternion.Euler(-90, 0, 0);      // Cone 默认沿 +Z 发射，转到朝上
    var ps = go.AddComponent<ParticleSystem>();
    ps.Stop(true, ParticleSystemStopBehavior.StopEmittingAndClear);
    ps.randomSeed = (uint)seed; ps.useAutoRandomSeed = false;

    var main = ps.main;
    main.duration = 5; main.loop = true;
    main.startLifetime = new ParticleSystem.MinMaxCurve(life.x, life.y);
    main.startSpeed = new ParticleSystem.MinMaxCurve(speed.x, speed.y);
    main.startSize = new ParticleSystem.MinMaxCurve(size.x, size.y);
    main.startRotation = new ParticleSystem.MinMaxCurve(0, Mathf.PI * 2);
    main.simulationSpace = ParticleSystemSimulationSpace.World;
    main.maxParticles = 500;

    var em = ps.emission; em.rateOverTime = rate;
    var sh = ps.shape; sh.shapeType = ParticleSystemShapeType.Cone; sh.angle = coneAngle; sh.radius = radius;
    var col = ps.colorOverLifetime; col.enabled = true; col.color = colorOverLife;
    var sz = ps.sizeOverLifetime; sz.enabled = true; sz.size = new ParticleSystem.MinMaxCurve(1, sizeOverLife);

    var tsa = ps.textureSheetAnimation;
    tsa.enabled = true; tsa.numTilesX = 4; tsa.numTilesY = 4;
    tsa.frameOverTime = new ParticleSystem.MinMaxCurve(1, AnimationCurve.Linear(0, 0, 1, 1));

    var r = go.GetComponent<ParticleSystemRenderer>();
    r.sharedMaterial = m;
    r.sortMode = ParticleSystemSortMode.Distance;
    // 与 Shader 里 Attributes 的顺序一一对应
    r.SetActiveVertexStreams(new List<ParticleSystemVertexStream>
    {
        ParticleSystemVertexStream.Position,
        ParticleSystemVertexStream.Color,
        ParticleSystemVertexStream.UV,
        ParticleSystemVertexStream.UV2,
        ParticleSystemVertexStream.AnimBlend,
    });
    return ps;
}

half4 frag(Varyings i) : SV_Target
{
    float t = _Time.y + _Phase;
    // 两次错位采样单通道噪声，拼成一个二维偏移向量；整体向上滚动，像热空气上升
    float2 nuv = i.uv * _NoiseTiling.xy + float2(0, -frac(t * _RiseSpeed));
    half nx = SAMPLE_TEXTURE2D(_NoiseTex, sampler_NoiseTex, nuv).r - 0.5;
    half ny = SAMPLE_TEXTURE2D(_NoiseTex, sampler_NoiseTex, nuv * 1.31 + 0.37).r - 0.5;
    half mask = SAMPLE_TEXTURE2D(_MaskTex, sampler_MaskTex, i.uv).a * i.color.a;

    // 屏幕上的偏移量除以深度：同样的“空气扰动”，离得越远在屏幕上越小
    float2 offset = float2(nx, ny) * (_Strength * mask) / max(i.screenData.z * 0.2, 1.0);

    // 调试：把偏移量放大后显示，R/G = 水平/竖直偏移，0.5 灰为不偏移
    if (_ShowOffset > 0.5) return half4(offset * (1.5 / max(_Strength, 1e-4)) + 0.5, 0.5, 1);

    float2 suv = i.screenData.xy / i.screenData.w;
    half3 scene = SampleSceneColor(suv + offset);
    return half4(scene, saturate(mask * 3.0));
}