Musical Notation Dance

by Zu Phạm, progress bar

Một bản hòa tấu sắc màu, nơi những ký hiệu âm nhạc hóa thành những vũ công tinh nghịch, cùng nhau tạo nên khu vườn nghệ thuật đầy mê hoặc 🎶 (Một phiên bản đã cải tiến của Notation Dance)

124 downloads Download file, 47.6 KB
How it installs, its SHA-256 and its code

Click Apply: MusicBar downloads it, checks its SHA-256 and puts it on the taskbar, or just puts it on if it already has it. Needs MusicBar 1.8 or newer.

SHA-256 78d99549092fedd2c1a016c1ce4a92961b0474aa35f02b7652dbafa9a66603cf

//! name: Notation Dancee
//! author: Zuu Phạm
//! kind: progress
//! description: Ký hiệu âm nhạc nhảy múa trên khuông nhạc: nốt, dấu lặng, f / p, coda mọc theo tiến trình bài, mỗi bài một khu vườn riêng theo bảng màu. Khóa Sol, Fa, Đô đổi chỗ trên vòng quay mỗi khi sang đoạn mới, phấn hoa và đom đóm bay theo nhịp.


float hash(float n) { return frac(sin(n * 12.9898 + 4.1414) * 43758.5453); }

float mel(float t) { return 2.6 * sin(t * 0.45) + 1.4 * sin(t * 1.1 + 1.3) + 0.8 * sin(t * 0.23 + 0.5); }

float rareKind(float f)
{
    float k = 6.0 + floor(f * 13.999);
    return k + 2.0 * step(10.5, k);
}

float noteKind(float seed)
{
    float rk = hash(seed + 2.6);
    float u = frac(rk * 91.7);
    return lerp(floor(u * sqrt(u) * 5.999), rareKind(frac(rk * 53.3)), step(0.85 - 0.3 * frac(seed), rk));
}

float songSeedOf()
{
    return hash(dot(floor(colorA.rgb * 16.0) + floor(colorB.rgb * 16.0) * 1.7, float3(3.7, 5.1, 2.3))) * 997.0;
}

float clefIdx(float n) { return step(0.5, n) * floor(hash(n + songSeedOf() + 31.7) * 2.999); }

float clefLift(float n) { return fmod(2.0 * clefIdx(n), 3.0); }

float isNoteKind(float kind) { return step(kind, 2.5) + step(4.5, kind) * step(kind, 5.5); }

float pairLinked(float jo)
{
    return step(0.35, hash(jo + 11.0)) * isNoteKind(noteKind(jo)) * isNoteKind(noteKind(jo - 1.0));
}

float segd(float2 p, float2 a, float2 b)
{
    float2 pa = p - a;
    float2 ba = b - a;
    float h = saturate(dot(pa, ba) / dot(ba, ba));
    return length(pa - ba * h);
}

float cover(float d, float w) { return 1.0 - smoothstep(w * 0.5, w * 0.5 + 0.8, d); }

float stroke(float d, float w, float aa)
{
    w = max(w, 1.3 * aa);
    return 1.0 - smoothstep(w * 0.5, w * 0.5 + aa, d);
}

float noteHead(float2 q, float2 c, float aa, float hollow, float hs)
{
    float2 h = q - c;
    float2 r = float2(h.x * 0.94 - h.y * 0.34, h.x * 0.34 + h.y * 0.94);
    float d = length(float2(r.x / 1.38, r.y)) - 0.25 * hs;
    float filled = 1.0 - smoothstep(-aa, aa, d);
    float2 r2 = float2(h.x * 0.77 - h.y * 0.64, h.x * 0.64 + h.y * 0.77);
    float d2 = length(float2(r2.x / 1.55, r2.y)) - 0.14 * hs;
    float hole = 1.0 - smoothstep(-aa, aa, d2);
    return filled * (1.0 - hollow * hole);
}

float dotc(float2 q, float2 c, float r, float aa) { return 1.0 - smoothstep(r - aa, r + aa, length(q - c)); }

float boxc(float2 q, float2 c, float2 h, float aa)
{
    float2 d = abs(q - c) - h;
    float s = length(max(d, 0.0)) + min(max(d.x, d.y), 0.0);
    return 1.0 - smoothstep(-aa, aa, s);
}

float slurArc(float2 p, float2 a, float2 b, float maxBulge, float up, float sc)
{
    float2 ab = b - a;
    float len = max(length(ab), 1.0);
    float2 dir = ab / len;
    float sgn = step(0.0, dir.x) * 2.0 - 1.0;
    float2 nrm = float2(dir.y, -dir.x) * sgn;
    float2 pa = p - a;
    float t = dot(pa, dir) / len;
    float s = dot(pa, nrm);
    float tt = 4.0 * t * (1.0 - t);
    float d = abs(s - up * min(0.28 * len, maxBulge) * tt);
    return cover(d, lerp(0.5, 1.6, tt) * sc) * step(0.0, t) * step(t, 1.0);
}

float flagArc(float2 u, float aa, float len)
{
    float d = abs(length(u - float2(-0.15, 0.38)) - 0.45);
    float w = lerp(0.16, 0.05, saturate(u.y / 0.75));
    return stroke(d, w, aa) * step(0.0, u.x) * step(-0.02, u.y) * step(u.y, 0.78 * len);
}

float3 clefPoint(int k, float t)
{
    float2 a = float2(0.0, 0.0);
    float2 b = float2(0.0, 0.0);
    float2 c = float2(0.0, 0.0);
    float2 e = float2(0.0, 0.0);
    float3 ww = float3(0.0, 0.0, 0.0);
    [branch] if (k == 0)
    {
        a = float2(-0.253, 1.179); b = float2(-0.440, 1.237);
        c = float2(-0.127, 1.635); e = float2(0.117, 1.360);
        ww = float3(0.400, -0.010, 0.060);
    }
    [branch] if (k == 1)
    {
        a = float2(0.117, 1.360); b = float2(0.242, 1.329);
        c = float2(0.051, 0.222); e = float2(0.117, -0.037);
        ww = float3(0.060, 0.060, 0.060);
    }
    [branch] if (k == 2)
    {
        a = float2(0.117, -0.037); b = float2(0.023, -0.110);
        c = float2(0.132, -0.675); e = float2(0.018, -0.333);
        ww = float3(0.060, 0.060, 0.060);
    }
    [branch] if (k == 3)
    {
        a = float2(0.018, -0.333); b = float2(-0.133, -0.329);
        c = float2(0.524, -0.603); e = float2(0.050, -0.523);
        ww = float3(0.060, 0.180, 0.100);
    }
    [branch] if (k == 4)
    {
        a = float2(0.050, -0.523); b = float2(0.004, -0.756);
        c = float2(0.045, -1.106); e = float2(0.251, -1.158);
        ww = float3(0.100, -0.070, 0.210);
    }
    [branch] if (k == 5)
    {
        a = float2(0.251, -1.158); b = float2(0.257, -1.263);
        c = float2(0.488, -0.998); e = float2(0.361, -0.729);
        ww = float3(0.210, -0.070, 0.130);
    }
    [branch] if (k == 6)
    {
        a = float2(0.361, -0.729); b = float2(0.278, -0.402);
        c = float2(-0.293, -0.350); e = float2(-0.484, 0.155);
        ww = float3(0.130, 0.360, 0.150);
    }
    [branch] if (k == 7)
    {
        a = float2(-0.484, 0.155); b = float2(-0.675, 0.710);
        c = float2(0.150, 0.975); e = float2(0.421, 0.650);
        ww = float3(0.150, 0.010, 0.110);
    }
    [branch] if (k == 8)
    {
        a = float2(0.421, 0.650); b = float2(0.651, 0.332);
        c = float2(0.431, 0.012); e = float2(0.086, 0.020);
        ww = float3(0.110, 0.204, 0.110);
    }
    [branch] if (k >= 9)
    {
        a = float2(0.086, 0.020); b = float2(-0.254, 0.046);
        c = float2(-0.369, 0.496); e = float2(-0.053, 0.627);
        ww = float3(0.110, 0.120, 0.050);
    }
    float s = 1.0 - t;
    float2 p = s * s * s * a + 3.0 * s * s * t * b + 3.0 * s * t * t * c + t * t * t * e;
    float wd = s * s * ww.x + 2.0 * s * t * ww.y + t * t * ww.z;
    return float3(p, wd);
}

float penTime(float u)
{
    float x = u * 10.0;
    return 0.080097 * saturate(x) + 0.173625 * saturate(x - 1.0) + 0.050987 * saturate((x - 2.0) * 1.2)
         + 0.088742 * saturate(x - 4.0) + 0.065155 * saturate(x - 5.0) + 0.153723 * saturate(x - 6.0) + 0.169593 * saturate(x - 7.0)
         + 0.112459 * saturate(x - 8.0) + 0.105618 * saturate(x - 9.0);
}

float trebleGlyphPen(float2 q, float aa, float pen, float wm, out float lit)
{
    float d = 1e5;
    float w = 0.06;
    lit = 0.0;
    float3 prev = clefPoint(0, 0.0);
    [loop]
    for (int i = 1; i <= 60; i++)
    {
        int k = (i - 1) / 6;
        float3 cur = clefPoint(k, (i - k * 6) * 0.166667);
        float2 pa = q - prev.xy;
        float2 ba = cur.xy - prev.xy;
        float h = saturate(dot(pa, ba) / dot(ba, ba));
        float dd = length(pa - ba * h);
        if (dd < d)
        {
            d = dd;
            w = lerp(prev.z, cur.z, h);
        }
        float wi = max(lerp(prev.z, cur.z, h), 1.3 * aa);
        lit = max(lit, saturate((0.45 * wi - dd) / (0.25 * wi)) * exp(-6.0 * frac(pen - penTime(((float)(i - 1) + h) / 60.0)))
                       * (1.0 - step(17.5, (float)i) * step((float)i, 24.5)));
        prev = cur;
    }
    float botBoost = 1.0 + 0.9 * (1.0 - wm) * smoothstep(0.6, 1.3, q.y);
    return stroke(d, w * wm * min(pow(max(w, 0.01) / 0.09, 1.3 * (1.0 - wm)), 1.4) * botBoost, aa);
}

float rcone(float2 p, float2 a, float ra, float2 b, float rb)
{
    float2 pa = p - a;
    float2 ba = b - a;
    float h = saturate(dot(pa, ba) / dot(ba, ba));
    return length(pa - ba * h) - lerp(ra, rb, h);
}

float restQuarter(float2 q, float aa)
{
    float d = 1e5;
    d = min(d, rcone(q, float2(-0.087, -0.7), 0.046, float2(0.08, -0.439), 0.081));
    d = min(d, rcone(q, float2(0.086, -0.328), 0.113, float2(-0.04, -0.176), 0.128));
    d = min(d, rcone(q, float2(-0.047, -0.16), 0.123, float2(0.005, 0.1), 0.039));
    d = min(d, rcone(q, float2(-0.019, 0.093), 0.027, float2(0.149, 0.351), 0.084));
    d = min(d, rcone(q, float2(-0.087, 0.684), 0.032, float2(-0.16, 0.385), 0.098));
    d = min(d, rcone(q, float2(-0.158, 0.318), 0.073, float2(0.044, 0.258), 0.084));
    float r = 1.0 - smoothstep(-aa, aa, d);
    return r;
}

float flatSign(float2 q, float aa)
{
    float d = 1e5;
    d = min(d, rcone(q, float2(-0.264, 0.793), 0.021, float2(0.124, 0.408), 0.091));
    d = min(d, rcone(q, float2(0.127, 0.393), 0.096, float2(0.206, 0.206), 0.093));
    d = min(d, rcone(q, float2(0.201, 0.097), 0.096, float2(0.044, -0.043), 0.062));
    d = min(d, rcone(q, float2(-0.038, -0.049), 0.053, float2(-0.246, 0.055), 0.042));
    float r = 1.0 - smoothstep(-aa, aa, d);
    r = max(r, boxc(q, float2(-0.282, 0.0), float2(0.04, 0.85), aa));
    return r;
}

float3 forteKnot(int i)
{
    float3 p = float3(0.601, -0.591, 0.112);
    [branch] if (i == 1) p = float3(0.680, -0.681, 0.076);
    [branch] if (i == 2) p = float3(0.648, -0.796, 0.040);
    [branch] if (i == 3) p = float3(0.427, -0.792, 0.047);
    [branch] if (i == 4) p = float3(0.156, -0.485, 0.127);
    [branch] if (i == 5) p = float3(-0.029, 0.069, 0.145);
    [branch] if (i == 6) p = float3(-0.213, 0.536, 0.103);
    [branch] if (i == 7) p = float3(-0.436, 0.793, 0.057);
    [branch] if (i == 8) p = float3(-0.671, 0.762, 0.040);
    [branch] if (i >= 9) p = float3(-0.611, 0.597, 0.137);
    return p;
}

float forteGlyph(float2 q, float aa)
{
    float d = 1e5;
    float3 k0 = float3(0.0, 0.0, 0.0);
    float3 k1 = float3(0.0, 0.0, 0.0);
    float3 k2 = float3(0.0, 0.0, 0.0);
    float3 k3 = float3(0.0, 0.0, 0.0);
    [loop]
    for (int fk = -3; fk < 9; fk++)
    {
        k0 = k1;
        k1 = k2;
        k2 = k3;
        k3 = forteKnot(clamp(fk + 2, 0, 9));
        [branch] if (fk >= 0)
        {
            float3 c1 = k1 + (k2 - k0) / 6.0;
            float3 c2 = k2 - (k3 - k1) / 6.0;
            float3 kp = k1;
            [loop]
            for (int fj = 1; fj <= 4; fj++)
            {
                float ft = (float)fj * 0.25;
                float fs = 1.0 - ft;
                float3 kc = fs * fs * fs * k1 + 3.0 * fs * fs * ft * c1 + 3.0 * fs * ft * ft * c2 + ft * ft * ft * k2;
                float2 kpa = q - kp.xy;
                float2 kba = kc.xy - kp.xy;
                float kh = saturate(dot(kpa, kba) / dot(kba, kba));
                d = min(d, length(kpa - kba * kh) - max(lerp(kp.z, kc.z, kh), 0.008));
                kp = kc;
            }
        }
    }
    float r = 1.0 - smoothstep(-aa, aa, d);
    return max(r, boxc(q, float2(0.119, -0.328), float2(0.389, 0.049), aa));
}

float pianoGlyph(float2 q, float aa)
{
    float2 h1 = q - float2(0.291, -0.171);
    float2 r1 = float2(h1.x * 0.560 + h1.y * -0.828, h1.y * 0.560 - h1.x * -0.828);
    float2 ab1 = float2(0.451, 0.336);
    float k0 = length(r1 / ab1);
    float k1 = length(r1 / (ab1 * ab1));
    float dOut = k0 * (k0 - 1.0) / max(k1, 0.0001);
    float2 h2 = q - float2(0.217, -0.162);
    float2 r2 = float2(h2.x * 0.924 + h2.y * 0.381, h2.y * 0.924 - h2.x * 0.381);
    float2 ab2 = float2(0.134, 0.323);
    float j0 = length(r2 / ab2);
    float j1 = length(r2 / (ab2 * ab2));
    float dIn = j0 * (j0 - 1.0) / max(j1, 0.0001);
    float d = max(dOut, -dIn);
    d = min(d, rcone(q, float2(-0.066, -0.517), 0.084, float2(0.023, -0.386), 0.120));
    d = min(d, rcone(q, float2(0.023, -0.386), 0.120, float2(-0.263, 0.470), 0.134));
    d = min(d, rcone(q, float2(-0.607, 0.544), 0.057, float2(-0.026, 0.542), 0.062));
    d = min(d, rcone(q, float2(-0.392, -0.187), 0.068, float2(-0.199, -0.505), 0.053));
    return 1.0 - smoothstep(-aa, aa, d);
}

float codaGlyph(float2 q, float aa)
{
    float2 ab1 = float2(0.445, 0.503);
    float k0 = length(q / ab1);
    float k1 = length(q / (ab1 * ab1));
    float dOut = k0 * (k0 - 1.0) / max(k1, 0.0001);
    float2 ab2 = float2(0.219, 0.467);
    float j0 = length(q / ab2);
    float j1 = length(q / (ab2 * ab2));
    float dIn = j0 * (j0 - 1.0) / max(j1, 0.0001);
    float d = max(dOut, -dIn);
    float2 a = abs(q);
    float hw = lerp(0.029, 0.037, saturate(1.0 - a.x / 0.688));
    d = min(d, max(a.y - hw, a.x - 0.688));
    float vw = lerp(0.026, 0.034, saturate(1.0 - a.y / 0.750));
    d = min(d, max(a.x - vw, a.y - 0.750));
    return 1.0 - smoothstep(-aa, aa, d);
}

float3 segnoKnot(int i)
{
    float3 p = float3(-0.098, -0.552, 0.126);
    [branch] if (i == 1) p = float3(-0.164, -0.653, 0.089);
    [branch] if (i == 2) p = float3(-0.362, -0.686, 0.039);
    [branch] if (i == 3) p = float3(-0.499, -0.454, 0.067);
    [branch] if (i == 4) p = float3(-0.334, -0.167, 0.116);
    [branch] if (i == 5) p = float3(0.302, 0.195, 0.115);
    [branch] if (i == 6) p = float3(0.399, 0.555, 0.045);
    [branch] if (i == 7) p = float3(0.157, 0.697, 0.054);
    [branch] if (i >= 8) p = float3(0.021, 0.555, 0.124);
    return p;
}

float segnoGlyph(float2 q, float aa)
{
    float d = 1e5;
    float3 k0 = float3(0.0, 0.0, 0.0);
    float3 k1 = float3(0.0, 0.0, 0.0);
    float3 k2 = float3(0.0, 0.0, 0.0);
    float3 k3 = float3(0.0, 0.0, 0.0);
    [loop]
    for (int sk = -3; sk < 8; sk++)
    {
        k0 = k1;
        k1 = k2;
        k2 = k3;
        k3 = segnoKnot(clamp(sk + 2, 0, 8));
        [branch] if (sk >= 0)
        {
            float3 c1 = k1 + (k2 - k0) / 6.0;
            float3 c2 = k2 - (k3 - k1) / 6.0;
            float3 kp = k1;
            [loop]
            for (int sj = 1; sj <= 4; sj++)
            {
                float st = (float)sj * 0.25;
                float su = 1.0 - st;
                float3 kc = su * su * su * k1 + 3.0 * su * su * st * c1 + 3.0 * su * st * st * c2 + st * st * st * k2;
                float2 kpa = q - kp.xy;
                float2 kba = kc.xy - kp.xy;
                float kh = saturate(dot(kpa, kba) / dot(kba, kba));
                d = min(d, length(kpa - kba * kh) - max(lerp(kp.z, kc.z, kh), 0.008));
                kp = kc;
            }
        }
    }
    float sf = saturate((q.y + 0.739) / 1.472);
    float sw = lerp(0.062, 0.059, sf);
    d = min(d, max(abs(q.x - lerp(0.444, -0.513, sf)) - sw, abs(q.y + 0.003) - 0.736));
    d = min(d, length(q - float2(0.462, -0.196)) - 0.110);
    d = min(d, length(q - float2(-0.453, 0.194)) - 0.113);
    return 1.0 - smoothstep(-aa, aa, d);
}

float restFlagUnit(float2 p)
{
    float d = length(p - float2(-0.372, 0.113)) - 0.141;
    d = min(d, rcone(p, float2(-0.372, 0.113), 0.127, float2(-0.386, 0.225), 0.043));
    d = min(d, rcone(p, float2(-0.386, 0.225), 0.043, float2(-0.279, 0.259), 0.026));
    d = min(d, rcone(p, float2(-0.279, 0.259), 0.026, float2(-0.172, 0.230), 0.033));
    d = min(d, rcone(p, float2(-0.172, 0.230), 0.033, float2(-0.077, 0.150), 0.034));
    d = min(d, rcone(p, float2(-0.077, 0.150), 0.034, float2(0.0, 0.0), 0.005));
    return d;
}

float restFlag(float2 q, float n16, float aa)
{
    float2 T = lerp(float2(0.247, -0.460), float2(0.309, -0.720), n16);
    float2 B = lerp(float2(0.031, 0.488), float2(-0.036, 0.748), n16);
    float d = max(rcone(q, T, max(0.023, 0.65 * aa), B, max(0.029, 0.65 * aa)), q.y - B.y);
    float2 p = q - T;
    d = min(d, restFlagUnit(p));
    [branch] if (n16 > 0.5) d = min(d, restFlagUnit(p - float2(-0.123, 0.531)));
    return 1.0 - smoothstep(-aa, aa, d);
}

float3 cClefKnot(int i)
{
    float3 p = float3(0.070, -0.486, 0.101);
    [branch] if (i == 1) p = float3(0.065, -0.532, 0.113);
    [branch] if (i == 2) p = float3(0.053, -0.639, 0.045);
    [branch] if (i == 3) p = float3(0.177, -0.699, 0.048);
    [branch] if (i == 4) p = float3(0.325, -0.661, 0.042);
    [branch] if (i == 5) p = float3(0.415, -0.494, 0.059);
    [branch] if (i == 6) p = float3(0.422, -0.281, 0.064);
    [branch] if (i == 7) p = float3(0.339, -0.123, 0.052);
    [branch] if (i == 8) p = float3(0.197, -0.078, 0.047);
    [branch] if (i == 9) p = float3(0.069, -0.124, 0.039);
    [branch] if (i >= 10) p = float3(-0.007, -0.030, 0.047);
    return p;
}

float cClefGlyphPen(float2 q, float aa, float pen, out float lit)
{
    float2 f = float2(q.x, -abs(q.y));
    float d = 1e5;
    float bdd = 0.0;
    float br = 0.01;
    float bu = 0.0;
    float3 k0 = float3(0.0, 0.0, 0.0);
    float3 k1 = float3(0.0, 0.0, 0.0);
    float3 k2 = float3(0.0, 0.0, 0.0);
    float3 k3 = float3(0.0, 0.0, 0.0);
    [loop]
    for (int ck = -3; ck < 10; ck++)
    {
        k0 = k1;
        k1 = k2;
        k2 = k3;
        k3 = cClefKnot(clamp(ck + 2, 0, 10));
        [branch] if (ck >= 0)
        {
            float3 c1 = k1 + (k2 - k0) / 6.0;
            float3 c2 = k2 - (k3 - k1) / 6.0;
            float3 kp = k1;
            [loop]
            for (int cj = 1; cj <= 4; cj++)
            {
                float ct = (float)cj * 0.25;
                float cs = 1.0 - ct;
                float3 kc = cs * cs * cs * k1 + 3.0 * cs * cs * ct * c1 + 3.0 * cs * ct * ct * c2 + ct * ct * ct * k2;
                float2 kpa = f - kp.xy;
                float2 kba = kc.xy - kp.xy;
                float kh = saturate(dot(kpa, kba) / dot(kba, kba));
                float kdd = length(kpa - kba * kh);
                float krr = max(lerp(kp.z, kc.z, kh), 0.008);
                if (kdd - krr < d)
                {
                    d = kdd - krr;
                    bdd = kdd;
                    br = krr;
                    bu = ((float)(ck * 4 + cj - 1) + kh) * 0.02125;
                }
                kp = kc;
            }
        }
    }
    float bwi = max(2.0 * br, 1.3 * aa);
    lit = saturate((0.45 * bwi - bdd) / (0.25 * bwi)) * exp(-2.0 * frac(pen - bu));
    float dsp = rcone(f, float2(0.058, -0.251), 0.010, float2(0.071, -0.122), 0.049);
    float dds = length(f - float2(-0.052, 0.0)) - 0.095;
    float2 bq = abs(float2(q.x + 0.3769, q.y)) - float2(0.1125, 0.7501);
    float dT = length(max(bq, 0.0)) + min(max(bq.x, bq.y), 0.0);
    float2 nq = abs(float2(q.x + 0.1339, q.y)) - float2(0.0317, 0.7501);
    float dN = length(max(nq, 0.0)) + min(max(nq.x, nq.y), 0.0);
    d = min(d, min(min(dsp, dds), min(dT, dN)));
    lit = max(lit, saturate(-min(dsp, dds) / 0.05) * exp(-2.0 * frac(pen - 0.88)));
    lit = max(lit, saturate(-dN / 0.03) * exp(-2.0 * frac(pen - 0.93)));
    lit = max(lit, saturate(-dT / 0.06) * exp(-2.0 * frac(pen - 0.97)));
    return 1.0 - smoothstep(-aa, aa, d);
}

float glyphExtra(float2 q, float kind, float aa, float ink)
{
    float on = smoothstep(0.1, 0.5, ink);
    float hs = smoothstep(0.0, 0.25, ink);
    float r = 0.0;

    [branch] if (abs(kind - 6.0) < 0.5)
    {
        r = noteHead(q, float2(0.0, 0.15), aa, 1.0, hs * 1.3);
    }
    [branch] if (abs(kind - 7.0) < 0.5)
    {
        float nx = step(abs(q.x), 0.235);
        float yu = -0.29 - 0.35 * (q.x + 0.2);
        float yl = 0.41 - 0.35 * (q.x + 0.2);
        float bars = max(1.0 - smoothstep(0.1 - aa, 0.1 + aa, abs(q.y - yu)),
                         1.0 - smoothstep(0.1 - aa, 0.1 + aa, abs(q.y - yl))) * nx;
        r = max(max(boxc(q, float2(-0.2, -0.192), float2(0.034, 0.7), aa),
                    boxc(q, float2(0.2, 0.212), float2(0.034, 0.68), aa)), bars) * on;
    }
    [branch] if (abs(kind - 8.0) < 0.5)
    {
        r = restQuarter(q, aa) * on;
    }
    [branch] if (abs(kind - 9.0) < 0.5)
    {
        r = max(max(boxc(q, float2(-0.386, 0.0), float2(0.192, 0.85), aa),
                    boxc(q, float2(0.099, 0.0), float2(0.096, 0.85), aa)),
                max(dotc(q, float2(0.485, -0.207), 0.093, aa), dotc(q, float2(0.485, 0.182), 0.093, aa))) * on;
    }
    [branch] if (abs(kind - 10.0) < 0.5)
    {
        float2 fc = float2(0.0, 0.35);
        float ft = saturate(1.0 - q.x * q.x / 0.49);
        float fw = max(0.2 * ft, 0.8 * aa);
        float fArc = (1.0 - smoothstep(fw * 0.5, fw * 0.5 + aa, abs(length(q - fc) - 0.7))) * step(q.y, fc.y);
        r = max(fArc, dotc(q, fc + float2(0.0, 0.1), 0.1, aa)) * on;
    }
    [branch] if (abs(kind - 13.0) < 0.5)
    {
        r = max(stroke(segd(q, float2(-0.55, 0.0), float2(0.55, 0.0)), 0.05, aa),
                boxc(q, float2(0.0, 0.11), float2(0.3, 0.11), aa)) * on;
    }
    [branch] if (abs(kind - 14.0) < 0.5)
    {
        r = max(stroke(segd(q, float2(-0.55, 0.0), float2(0.55, 0.0)), 0.05, aa),
                boxc(q, float2(0.0, -0.11), float2(0.3, 0.11), aa)) * on;
    }
    [branch] if (abs(kind - 15.0) < 0.5)
    {
        if (abs(q.x) < 0.9 && abs(q.y) < 0.9)
        {
            r = restFlag(q, 0.0, aa) * on;
        }
    }
    [branch] if (abs(kind - 21.0) < 0.5)
    {
        if (abs(q.x) < 0.9 && abs(q.y) < 0.9)
        {
            r = restFlag(q, 1.0, aa) * on;
        }
    }
    [branch] if (abs(kind - 16.0) < 0.5)
    {
        if (abs(q.x) < 0.9 && abs(q.y) < 1.0)
        {
            r = forteGlyph(q, aa) * on;
        }
    }
    [branch] if (abs(kind - 17.0) < 0.5)
    {
        if (abs(q.x) < 0.9 && abs(q.y) < 0.9)
        {
            r = pianoGlyph(q, aa) * on;
        }
    }
    [branch] if (abs(kind - 18.0) < 0.5)
    {
        if (abs(q.x) < 0.9 && abs(q.y) < 0.9)
        {
            r = codaGlyph(q, aa) * on;
        }
    }
    [branch] if (abs(kind - 19.0) < 0.5)
    {
        if (abs(q.x) < 0.9 && abs(q.y) < 0.9)
        {
            r = segnoGlyph(q, aa) * on;
        }
    }
    [branch] if (abs(kind - 20.0) < 0.5)
    {
        float2 gq = float2(q.x, q.y - 0.05) * 1.6;
        float gaa = aa * 1.6;
        r = max(max(noteHead(gq, float2(0.0, 0.5), gaa, 0.0, hs),
                    stroke(segd(gq, float2(0.31, 0.45), float2(0.31, -0.9)), 0.08, gaa) * step(0.15, ink)),
                max(flagArc(float2(gq.x - 0.31, gq.y + 0.9), gaa, 1.0) * step(0.7, ink),
                    stroke(segd(gq, float2(0.05, -0.1), float2(0.58, -0.55)), 0.06, gaa) * step(0.5, ink)));
    }
    return r;
}

float notePic(float2 q, float e8, float aa, float hollow, float hs, float st, float stemOn)
{
    float cy = lerp(0.517, 0.554, e8);
    float2 h = q - float2(0.0, cy);
    float2 cs = float2(lerp(0.892, 0.850, e8), lerp(-0.452, -0.528, e8));
    float2 r = float2(h.x * cs.x + h.y * cs.y, h.y * cs.x - h.x * cs.y);
    float2 ab = float2(lerp(0.286, 0.262, e8), lerp(0.217, 0.177, e8)) * max(hs, 0.001);
    float k0 = length(r / ab);
    float k1 = length(r / (ab * ab));
    float head = 1.0 - smoothstep(-aa, aa, k0 * (k0 - 1.0) / max(k1, 0.0001));
    float2 r2 = float2(h.x * 0.622 + h.y * -0.783, h.y * 0.622 + h.x * 0.783);
    float2 ab2 = float2(lerp(0.19, 0.17, e8), lerp(0.105, 0.09, e8)) * max(hs, 0.001);
    float j0 = length(r2 / ab2);
    float j1 = length(r2 / (ab2 * ab2));
    float hole = 1.0 - smoothstep(-aa, aa, j0 * (j0 - 1.0) / max(j1, 0.0001));
    float top = lerp(0.4, lerp(-0.9, -0.84, e8), st);
    float stem = boxc(q, float2(lerp(0.233, 0.214, e8), 0.5 * (top + cy)), float2(lerp(0.0403, 0.0251, e8), max(0.5 * (cy - top), 0.001)), aa) * stemOn;
    return max(head * (1.0 - hollow * hole), stem);
}

float3 flagKnot(int i)
{
    float3 p = float3(-0.022, 0.011, 0.003);
    [branch] if (i == 1) p = float3(0.053, 0.321, 0.078);
    [branch] if (i == 2) p = float3(0.251, 0.492, 0.026);
    [branch] if (i == 3) p = float3(0.372, 0.650, 0.024);
    [branch] if (i == 4) p = float3(0.409, 0.829, 0.025);
    [branch] if (i == 5) p = float3(0.381, 1.006, 0.022);
    [branch] if (i >= 6) p = float3(0.292, 1.201, 0.004);
    return p;
}

float flagPic(float2 u, float aa, float len)
{
    float d = 1e5;
    float3 a = float3(0.0, 0.0, 0.0);
    float3 b = float3(0.0, 0.0, 0.0);
    [loop]
    for (int fi = 0; fi < 7; fi++)
    {
        a = b;
        b = flagKnot(fi);
        [branch] if (fi > 0) d = min(d, rcone(u, a.xy, a.z, b.xy, b.z));
    }
    return (1.0 - smoothstep(-aa, aa, d)) * step(u.y, 1.21 * len);
}

float beamHead(float2 h, float aa, float hollow, float hs)
{
    float k = max(hs, 0.001);
    float2 r = float2(h.x * 0.9169 - h.y * 0.3990, h.y * 0.9169 + h.x * 0.3990);
    float2 ab = float2(0.2844, 0.1694) * k;
    float k0 = length(r / ab);
    float k1 = length(r / (ab * ab));
    float head = 1.0 - smoothstep(-aa, aa, k0 * (k0 - 1.0) / max(k1, 0.0001));
    float2 r2 = float2(h.x * 0.6671 - h.y * 0.7449, h.y * 0.6671 + h.x * 0.7449);
    float2 ab2 = float2(0.185, 0.085) * k;
    float j0 = length(r2 / ab2);
    float j1 = length(r2 / (ab2 * ab2));
    float hole = 1.0 - smoothstep(-aa, aa, j0 * (j0 - 1.0) / max(j1, 0.0001));
    return head * (1.0 - hollow * hole);
}

float beamPic(float2 q, float aa, float hollow, float hs, float st, float stemOn, float fl, float flagOn, float s16)
{
    float heads = max(beamHead(q - float2(0.0, 0.517), aa, hollow, hs), beamHead(q - float2(0.8156, 0.2736), aa, hollow, hs));
    float ys = q.y + 0.3017 * (q.x - 0.1893);
    float cut = smoothstep(-aa, aa, (ys + 0.6611) * 0.9574);
    float t1 = lerp(0.4453, -0.70, st);
    float t2 = lerp(0.1992, -0.95, st);
    float s1 = boxc(q, float2(0.2293, 0.5 * (t1 + 0.4453)), float2(0.04, max(0.5 * (0.4453 - t1), 0.001)), aa);
    float s2 = boxc(q, float2(1.0447, 0.5 * (t2 + 0.1992)), float2(0.04, max(0.5 * (0.1992 - t2), 0.001)), aa);
    float stems = max(s1, s2) * cut * stemOn;
    float xe = lerp(0.2693, 1.0847, fl);
    float inx = smoothstep(-aa, aa, q.x - 0.1893) * (1.0 - smoothstep(-aa, aa, q.x - xe));
    float b1 = 1.0 - smoothstep(-aa, aa, (abs(ys + 0.5720) - 0.0891) * 0.9574);
    float b2 = 1.0 - smoothstep(-aa, aa, (abs(ys + 0.3698) - 0.0419) * 0.9574);
    return max(heads, max(stems, max(b1, b2 * s16) * inx * flagOn));
}

float glyph(float2 q, float kind, float aa, float e, float ink, float bl, float dn, float opt)
{
    if (kind > 5.5) return glyphExtra(q, kind, aa, ink);

    float hollow = 1.0 - smoothstep(0.15, 0.45, e);
    float hs = smoothstep(0.0, 0.25, ink);
    float st = saturate((ink - 0.25) / 0.45);
    float fl = max(saturate((ink - 0.7) / 0.3), 0.05);
    float stemOn = smoothstep(0.15, 0.3, ink);
    float flagOn = step(0.7, ink);

    float h1 = noteHead(q, float2(0.0, 0.5), aa, hollow, hs);
    float r = 0.0;

    [branch] if (kind < 0.5)
    {
        float aug = dotc(q, float2(lerp(0.5, -0.5, dn), 0.52), 0.085, aa) * hs * step(0.7, opt);
        float stc = dotc(q, float2(0.0, 0.98), 0.075, aa) * hs * step(0.4, opt) * (1.0 - step(0.7, opt));
        r = max(notePic(q, 0.0, aa, hollow, hs, st, stemOn), max(aug, stc));
    }
    else if (kind < 1.5)
    {
        float lf = 0.6 + 0.4 * smoothstep(0.1, 0.6, e);
        float s16 = max(smoothstep(0.55, 0.8, e), step(0.5, opt));
        float ux = lerp(q.x - 0.214, 0.214 - q.x, dn);
        float flag = flagPic(float2(ux, q.y + 0.9), aa, lf * fl) * flagOn;
        float flagB = flagPic(float2(ux, q.y + 0.6), aa, lf * fl * 0.85) * s16 * flagOn;
        r = max(max(notePic(q, 1.0, aa, hollow, hs, st, stemOn), flag), flagB);
    }
    else if (kind < 2.5)
    {
        float s16 = max(smoothstep(0.55, 0.8, e), step(0.5, opt));
        r = beamPic(q, aa, hollow, hs, st, stemOn, fl, flagOn, s16);
    }
    else if (kind < 3.5)
    {
        float sharpV = max(stroke(segd(q, float2(-0.14, -0.75), float2(-0.14, 0.7)), 0.07, aa),
                           stroke(segd(q, float2(0.14, -0.85), float2(0.14, 0.6)), 0.07, aa));
        float sharpH = max(stroke(segd(q, float2(-0.34, -0.05), float2(0.34, -0.28)), 0.13, aa),
                           stroke(segd(q, float2(-0.34, 0.38), float2(0.34, 0.15)), 0.13, aa));
        r = max(sharpV, sharpH) * smoothstep(0.1, 0.5, ink);
    }
    else if (kind < 4.5)
    {
        r = flatSign(q, aa) * smoothstep(0.1, 0.5, ink);
    }
    else
    {
        float c2 = noteHead(q, float2(0.0, 0.5 - 0.5 * bl), aa, hollow, hs * smoothstep(0.0, 0.3, bl));
        float c3 = noteHead(q, float2(0.0, 0.5 - 1.0 * bl), aa, hollow, hs * smoothstep(0.25, 0.6, bl));
        float cStem = (1.0 - smoothstep(0.5 * aa, 0.5 * aa + aa, segd(q, float2(0.31, 0.45), float2(0.31, lerp(0.4, -0.9 - 1.4 * bl, st))))) * stemOn;
        r = max(max(h1, c2), max(c3, cStem));
    }
    return r;
}

void blend(inout float3 acc, inout float accA, float3 c, float a)
{
    a = saturate(a);
    acc = c * a + acc * (1.0 - a);
    accA = a + accA * (1.0 - a);
}

float3 bassKnot(int i)
{
    float3 p = float3(-0.799, 0.805, 0.010);
    [branch] if (i == 1) p = float3(-0.588, 0.691, 0.026);
    [branch] if (i == 2) p = float3(-0.344, 0.540, 0.050);
    [branch] if (i == 3) p = float3(-0.099, 0.337, 0.088);
    [branch] if (i == 4) p = float3(0.072, 0.092, 0.118);
    [branch] if (i == 5) p = float3(0.112, -0.172, 0.130);
    [branch] if (i == 6) p = float3(0.043, -0.437, 0.120);
    [branch] if (i == 7) p = float3(-0.181, -0.636, 0.062);
    [branch] if (i == 8) p = float3(-0.425, -0.653, 0.050);
    [branch] if (i == 9) p = float3(-0.595, -0.545, 0.054);
    [branch] if (i >= 10) p = float3(-0.655, -0.345, 0.068);
    return p;
}

float smin(float a, float b, float k)
{
    float h = max(k - abs(a - b), 0.0) / k;
    return min(a, b) - h * h * k * 0.25;
}

float3 swapTint(float ck)
{
    return lerp(lerp(lerp(colorA.rgb, colorB.rgb, ck), colorC.rgb, 0.45), float3(1.0, 1.0, 1.0), 0.25 * (1.0 - ck));
}

float bassClefPen(float2 q, float aa, float pen, float wm, out float lit)
{
    float d = 1e5;
    float bdd = 0.0;
    float br = 0.01;
    float bu = 0.0;
    float3 k0 = float3(0.0, 0.0, 0.0);
    float3 k1 = float3(0.0, 0.0, 0.0);
    float3 k2 = float3(0.0, 0.0, 0.0);
    float3 k3 = float3(0.0, 0.0, 0.0);
    [loop]
    for (int bk = -3; bk < 10; bk++)
    {
        k0 = k1;
        k1 = k2;
        k2 = k3;
        k3 = bassKnot(clamp(bk + 2, 0, 10));
        [branch] if (bk >= 0)
        {
            float3 c1 = k1 + (k2 - k0) / 6.0;
            float3 c2 = k2 - (k3 - k1) / 6.0;
            float3 kp = k1;
            [loop]
            for (int bj = 1; bj <= 4; bj++)
            {
                float bt = (float)bj * 0.25;
                float bs = 1.0 - bt;
                float3 kc = bs * bs * bs * k1 + 3.0 * bs * bs * bt * c1 + 3.0 * bs * bt * bt * c2 + bt * bt * bt * k2;
                float2 kpa = q - kp.xy;
                float2 kba = kc.xy - kp.xy;
                float kh = saturate(dot(kpa, kba) / dot(kba, kba));
                float kdd = length(kpa - kba * kh);
                float krr = max(lerp(kp.z, kc.z, kh), 0.012) * wm;
                if (kdd - krr < d)
                {
                    d = kdd - krr;
                    bdd = kdd;
                    br = krr;
                    bu = ((float)(bk * 4 + bj - 1) + kh) * 0.0215;
                }
                kp = kc;
            }
        }
    }
    float bwi = max(2.0 * br, 1.3 * aa);
    lit = saturate((0.45 * bwi - bdd) / (0.25 * bwi)) * exp(-2.0 * frac(pen - bu));
    float dh = length(q - float2(-0.510, -0.302)) - 0.186 * wm;
    d = smin(d, dh, 0.06);
    lit = max(lit, saturate(-dh / 0.08) * exp(-2.0 * frac(pen - 0.90)));
    float d1 = length(q - float2(0.43, -0.49));
    float d2 = length(q - float2(0.43, -0.03));
    float r = 1.0 - smoothstep(-aa, aa, d);
    r = max(r, max(1.0 - smoothstep(0.135 * wm - aa, 0.135 * wm + aa, d1), 1.0 - smoothstep(0.135 * wm - aa, 0.135 * wm + aa, d2)));
    lit = max(lit, max(saturate((0.135 - d1) / 0.055) * exp(-2.0 * frac(pen - 0.95)),
                       saturate((0.135 - d2) / 0.055) * exp(-2.0 * frac(pen - 0.99))));
    return r;
}

float4 main(float2 uv : TEXCOORD) : COLOR
{
    float2 px = float2(uv.x * size.x, uv.y * size.y);
    float mid = size.y * 0.5;
    float head = progress * size.x;
    const float spawn = 0.25;
    const float gap = 28.0;
    // Host không có biến `duration`. Tạm dùng độ dài cố định (giây);
    // khi biết tên biến độ dài bài của host thì thay dòng dưới bằng biến đó.
    const float trackSec = 240.0;
    float dur = max(trackSec, 1.0);
    float pxPerSec = size.x / dur;
    float tScale = pxPerSec / 30.0;
    float endStart = max(1.0 - 14.0 / dur, 0.5);
    float endT = smoothstep(endStart, 1.0, progress);

    float3 acc = float3(0.0, 0.0, 0.0);
    float accA = 0.0;

    float playedPx = 1.0 - smoothstep(head - 2.0, head + 2.0, px.x);
    float dim = 0.6 + 0.4 * smoothstep(0.08, 0.3, abs(px.y - mid) / size.y);


    float sp = size.y / 9.0;
    float q = (px.y - mid) / sp;
    float li = round(q);
    float wob = 0.4 * level * sin(px.x * 0.045 + time * 6.0 + li * 1.7);
    float lineD = abs(px.y - wob - (mid + li * sp));
    float onStaff = 1.0 - step(2.5, abs(li));
    float lineBase = lerp(0.08, 0.4, playedPx);
    float lineA = cover(lineD, 0.8) * onStaff * (lineBase + 0.22 * level * playedPx);
    blend(acc, accA, lerp(colorB.rgb, colorA.rgb, playedPx * 0.6), lineA);

    float barW = gap * 8.0;
    float seamLen = barW;
    float bx = round(px.x / barW) * barW;
    float barOn = step(1.0, bx) * (1.0 - step(2.0 * sp + 0.8, abs(px.y - mid)));
    float barLit = exp(-max(head - bx, 0.0) / (90.0 * tScale)) * step(bx, head);
    float bn = round(px.x / barW);
    float bChg = step(0.5, bn) * step(0.5, abs(clefIdx(bn) - clefIdx(bn - 1.0))) * step(bx, head);
    float barA = cover(abs(px.x - bx), 1.0) * barOn * (1.0 - bChg)
               * (0.07 + 0.12 * step(bx, head) + 0.55 * barLit * (0.4 + lerp(level, spectrum(0.05), 0.6) + 0.5 * beat));
    blend(acc, accA, lerp(colorB.rgb, colorC.rgb, barLit), barA);

    float endX = size.x - 3.0;
    float endOn = 1.0 - step(2.0 * sp + 0.8, abs(px.y - mid));
    float endA = max(cover(abs(px.x - (endX - 7.0)), 1.0), cover(abs(px.x - endX), 3.5)) * endOn
               * (0.15 + 0.6 * endT);
    blend(acc, accA, lerp(colorB.rgb, colorC.rgb, endT), endA);

    float clefS = sp * 2.6;
    float2 home = float2(clefS * 0.9 + 4.0, mid);
    float swapR = size.y * 0.62;
    float2 swapC = home - float2(0.0, swapR);
    float seamN = floor(head / seamLen) + 1.0;
    float sPrev = clefIdx(seamN - 1.0);
    float sCur  = clefIdx(seamN);
    float delta = fmod(sCur - sPrev + 3.0, 3.0);
    float turns = floor(hash(seamN + songSeedOf() + 37.3) * 2.999);
    float totSteps = step(0.5, delta) * (3.0 * turns + delta);
    const float swapSecBase = 3.0;  // giây cho vòng quay 1 bước, tăng để chậm hơn
    const float dropSec = 2.5;      // giây để khóa nhỏ rơi xuống, tăng để chậm hơn
    float swapSec = swapSecBase * sqrt(max(totSteps, 1.0));
    float swapLen = min(pxPerSec * swapSec, seamLen * 0.95);
    float sx = saturate((head - (seamN * seamLen - swapLen)) / swapLen);
    float kf = 1.5;
    float ekf = exp(-kf);
    float swx = ((1.0 - exp(-kf * sx)) / kf - ekf * sx) / ((1.0 - ekf) / kf - ekf);
    float swv = (exp(-kf * sx) - ekf) / (1.0 - ekf);
    float sw = sPrev + totSteps * swx;
    float ang = sw * (2.0 * 3.14159265 / 3.0);
    float pen = frac(time * 0.14);
    float penB = frac(time * 0.413);
    float penC = frac(time * 0.4);

    float swGate = smoothstep(0.0, 0.06, sx) * smoothstep(0.0, 0.25, swv) * step(0.5, totSteps);
    float swK = 1.0 - cos(ang) + 0.5774 * sin(ang);

    float swapDist = abs(length(px - swapC) - swapR);
    float swapA = (1.0 - smoothstep(0.5, 1.7, swapDist)) * swGate * (0.5 + 0.1 * beat);
    blend(acc, accA, colorC.rgb, swapA * dim);

    float lnS = round(px.x / seamLen);
    float lDs = head - lnS * seamLen;
    float lType = clefIdx(lnS);
    float lChg = step(0.5, lnS) * step(0.5, abs(lType - clefIdx(lnS - 1.0))) * step(0.0, lDs);
    float lGust = sin(lnS * 1.7 - time * 2.5) * 2.5;
    float lT = saturate(lDs / (pxPerSec * dropSec));
    float lE = lT * lT * (3.0 - 2.0 * lT);
    float lA = smoothstep(0.0, pxPerSec * 0.25, lDs);
    float2 lc = float2(lnS * seamLen - 1.1 * sp - 2.0 + lGust, mid - (mid + 2.5 * sp) * (1.0 - lE));
    float uL = lChg * (1.0 - step(1.6 * sp, abs(px.x - lc.x)));
    float clefK = lerp(1.0, 0.6, uL);
    float gS = 1.0 - uL * step(0.5, lType);
    float gF = 1.0 - uL * (1.0 - step(abs(lType - 1.0), 0.5));
    float gC = 1.0 - uL * (1.0 - step(1.5, lType));
    float lcov = 0.0;
    blend(acc, accA, lerp(colorB.rgb, colorC.rgb, 0.5), cover(abs(px.x - lnS * seamLen), 1.0) * step(0.5, frac(px.y / 6.0)) * lChg * smoothstep(0.0, 10.0 * tScale, lDs) * 0.35 * dim);
    float dkk = abs((floor(px.y / 6.0) + 0.5) * 6.0 - mid) / (size.y * 0.5);
    float gLit = exp(-5.0 * frac(frac(time * 0.55 + lnS * 0.37) - dkk * 0.7));
    float gTip = pow(gLit, 4.0);
    lcov = cover(abs(px.x - lnS * seamLen), 1.4) * step(0.5, frac(px.y / 6.0)) * lChg * lA * saturate(0.7 * gLit + 0.6 * gTip);

    float2 dSol = swapR * float2(sin(ang), cos(ang));
    float2 cq = (px - lerp(swapC + dSol, lc + float2(0.0, -0.184 * sp), uL)) / (clefS * clefK);
    cq.x -= 0.1 * cq.y;
    float clefCov = 0.0;
    float lit = 0.0;
    if (gS > 0.5 && abs(cq.x) < 1.2 && abs(cq.y) < 1.65)
        clefCov = trebleGlyphPen(cq, 1.0 / (clefS * clefK), pen, lerp(1.0, 0.45, uL), lit);
    float trail = lit * lerp(0.55, 1.0, playing);
    float tip = pow(lit, 11.67) * (0.7 + 0.6 * beat);
    float3 clefCol = lerp(lerp(colorB.rgb, colorA.rgb, 0.7), colorC.rgb, saturate(trail * 1.1));
    clefCol = lerp(clefCol, float3(1.0, 1.0, 1.0), saturate(tip * 1.2));
    lcov = max(lcov, clefCov * uL);
    blend(acc, accA, clefCol, clefCov * (1.0 - uL) * dim * (0.4 + 0.25 * level + 0.2 * beat + 1.4 * trail + 1.8 * tip));

    float bassS = sp * 2.2;
    float2 dFa = swapR * float2(sin(ang - 2.094395), cos(ang - 2.094395));
    float2 bq = (px - lerp(swapC + dFa + float2(0.0, -0.382 * sp), lc + float2(0.0, -0.058 * sp), uL)) / (bassS * clefK);
    float bCov = 0.0;
    float bLit = 0.0;
    if (gF > 0.5 && abs(bq.x) < 0.95 && abs(bq.y) < 1.0)
        bCov = bassClefPen(bq, 1.0 / (bassS * clefK), penB, lerp(1.0, 1.35, uL), bLit);
    float bTrail = bLit * lerp(0.55, 1.0, playing);
    float bTip = pow(bLit, 11.67) * (0.7 + 0.6 * beat);
    float3 bCol = lerp(lerp(colorB.rgb, colorA.rgb, 0.7), colorC.rgb, saturate(bTrail * 1.1));
    bCol = lerp(bCol, float3(1.0, 1.0, 1.0), saturate(bTip * 1.2));
    lcov = max(lcov, bCov * uL);
    blend(acc, accA, bCol, bCov * (1.0 - uL) * dim * (0.4 + 0.25 * level + 0.2 * beat + 1.4 * bTrail + 1.8 * bTip));

    float cS = sp * 2.55;
    float2 dC = swapR * float2(sin(ang - 4.188790), cos(ang - 4.188790));
    float2 cqC = (px - lerp(swapC + dC, lc, uL)) / (cS * clefK);
    float cCov = 0.0;
    float cLit = 0.0;
    if (gC > 0.5 && abs(cqC.x) < 0.75 && abs(cqC.y) < 0.9)
        cCov = cClefGlyphPen(cqC, 1.0 / (cS * clefK), penC, cLit);
    float cTrail = cLit * lerp(0.55, 1.0, playing);
    float cTip = pow(cLit, 11.67) * (0.7 + 0.6 * beat);
    float3 cCol = lerp(lerp(colorB.rgb, colorA.rgb, 0.7), colorC.rgb, saturate(cTrail * 1.1));
    cCol = lerp(cCol, float3(1.0, 1.0, 1.0), saturate(cTip * 1.2));
    lcov = max(lcov, cCov * uL);
    blend(acc, accA, cCol, cCov * (1.0 - uL) * dim * (0.4 + 0.25 * level + 0.2 * beat + 1.4 * cTrail + 1.8 * cTip));

    float2 ap = px - float2(head + 12.0, mid - size.y * 0.36);
    float accD = min(segd(ap, float2(-3.0, -3.0), float2(3.0, 0.0)), segd(ap, float2(-3.0, 3.0), float2(3.0, 0.0)));
    blend(acc, accA, colorC.rgb, cover(accD, 1.1) * beat * 0.8);

    const float ringSec = 2.5;      // giây cho mỗi vòng sóng, tăng để chậm hơn
    float phase = frac(head / (pxPerSec * ringSec) + 0.5);
    float ringR = phase * size.y * 0.55;
    float ringA = cover(abs(length(px - float2(head, mid)) - ringR), 1.2) * (1.0 - phase) * 0.45;
    blend(acc, accA, colorC.rgb, ringA);

    float plCell = floor(px.x / 22.0);
    float plA = 0.0;
    [unroll]
    for (int po = -1; po <= 1; po++)
    {
        [unroll]
        for (int pq = 0; pq < 2; pq++)
        {
            float pc = plCell + (float)po + (float)pq * 0.37;
            float pu = hash(pc * 2.9 + 5.0);
            float prise = frac(hash(pc * 1.3 + 61.0) + time * (0.03 + 0.05 * pu));
            float2 pp = float2((floor(pc) + 0.15 + 0.7 * hash(pc * 1.7 + 29.0)) * 22.0 + sin(time * (0.5 + pu) + pu * 40.0) * 6.0,
                               size.y * (1.05 - 1.1 * prise));
            float pr = (1.1 + 0.9 * pu) * (1.0 + 0.45 * beat);
            plA = max(plA, (1.0 - smoothstep(pr * 0.4, pr + 0.7, length(px - pp))) * sin(3.1416 * prise)
                           * step(0.4, hash(pc * 4.1 + 13.0)) * (0.55 + 0.45 * sin(time * (2.0 + 3.0 * pu) + pu * 30.0)));
        }
    }
    blend(acc, accA, lerp(colorC.rgb, float3(1.0, 1.0, 1.0), 0.5), plA * (0.55 + 0.5 * beat) * (0.4 + 0.6 * smoothstep(0.55, 1.0, dim)));

    float2 vPrev = float2(0.0, 0.0);
    [loop]
    for (int m = 0; m < 7; m++)
    {
        float vj = floor(px.x / gap) - 3.0 + (float)m;
        float vSeed = vj + songSeedOf();
        float vHome = (vj + 0.5) * gap;
        float vDist = head - vHome;
        float vDg = vDist + 420.0 * tScale * endT;
        float vKeep = step(1.0, vj) * step(0.0, vDist);
        float vPh = hash(vSeed + 0.1) * 6.2832;
        float vLk = pairLinked(vSeed + 1.0 - step(0.25, frac(vj * 0.5)));
        float vGrow = smoothstep(0.0, lerp(360.0, 160.0, vLk) * tScale, vDg);
        float vSpread = smoothstep(0.0, 200.0 * tScale, vDg);
        float vFar = smoothstep(400.0 * tScale, 1500.0 * tScale, vDist);
        float vS0 = lerp(0.07, 0.15, vLk);
        float vSz = size.y * (vS0 + (0.24 - vS0) * vGrow) * (1.0 + 0.25 * spectrum(frac(vSeed * 0.618034)) + 0.15 * beat) * lerp(1.0, 0.82, vFar);

        float2 vPos;
        vPos.y = clamp(lerp(mid - clamp(mel(vSeed * 0.6) * 0.85, -4.0, 4.0) * (size.y / 18.0),
                            mid + (0.5 - frac(vSeed * 0.618034)) * size.y * 0.42 + (hash(vSeed + 4.2) - 0.5) * size.y * 0.16, vSpread)
                       - sp * 0.55 * clefLift(floor(vHome / seamLen)) + sin(time * 0.6 + vPh) * size.y * 0.07 * vSpread, vSz, size.y - vSz);
        vPos.x = vHome + (hash(vSeed + 1.9) - 0.5) * gap * 0.8 * vSpread
               + sin(time * 0.45 + hash(vSeed + 0.7) * 6.2832) * gap * 0.45 * vSpread
               + sin(vDist * 0.035 - time * 2.5) * exp(-vDist / (350.0 * tScale)) * (0.25 + 0.5 * level + 0.4 * beat) * 5.0;

        float vFdn = step(0.5, hash(vSeed + 13.0));
        float vUp = 1.0 - 2.0 * (1.0 - step(0.5, hash(vSeed + 12.0))) * (1.0 - vFdn);
        float2 vHp = vPos + float2(0.0, lerp(0.5, -0.5, vFdn) * vSz);
        float vLit = exp(-max(vDist + 0.5 * gap, 0.0) / (140.0 * tScale));
        float vGs = (vS0 + (0.24 - vS0) * vGrow) / 0.24;
        float vInk = smoothstep(0.0, lerp(160.0, 90.0, vLk) * tScale, vDg);
        float vLink = vLk * step(0.25, frac(vj * 0.5)) * step(2.0, vj) * vKeep;
        float vA = slurArc(px, vPrev, vHp, size.y * 0.25 * vGs, vUp, lerp(0.5, 1.0, vGs)) * vLink * smoothstep(0.2, 0.7, vInk)
                 * (0.14 + 0.62 * vLit * (0.5 + level)) * dim * lerp(1.0, 0.6, vFar);
        blend(acc, accA, lerp(colorB.rgb, colorC.rgb, vLit), vA);
        vPrev = vHp;
    }

    [loop]
    for (int k = 0; k < 37; k++)
    {
        float seed = 0.0;
        float2 pos = float2(0.0, 0.0);
        float tx = 1.0;
        float sz = 1.0;
        float vis = 0.0;
        float tint = 0.0;
        float ph = 0.0;
        float windAng = 0.0;
        float spec = 0.0;
        float ink = 1.0;
        float bl = 0.0;
        float nK = swK;

        if (k < 30)
        {
            float j = floor(time / spawn) - (29.0 - (float)k);
            seed = j + 0.5;
            float age = time - j * spawn;
            ph = hash(seed + 0.1) * 6.2832;
            float ph2 = hash(seed + 0.7) * 6.2832;
            float rnd = hash(seed + 1.9);
            float vx = lerp(-30.0, 30.0, rnd);
            float grow = smoothstep(0.0, 7.0, age);
            spec = spectrum(frac(seed * 0.618034));
            sz = size.y * (0.06 + 0.15 * grow) * (1.0 + 0.25 * spec + 0.15 * beat);

            float y0 = mid - clamp(mel(seed * 0.6) * 0.85, -4.0, 4.0) * (size.y / 18.0);
            float yT = mid + (0.5 - frac(seed * 0.618034)) * size.y * 0.42 + (hash(seed + 4.2) - 0.5) * size.y * 0.16;
            float ty = lerp(y0, yT, smoothstep(0.0, 5.0, age));
            pos.y = clamp(ty + sin(age * 0.7 + ph) * size.y * 0.06 * grow, sz, size.y - sz);
            pos.x = head + vx * age + sin(age * 0.5 + ph2) * (2.0 + 1.0 * age);

            tx = vx * (0.3 + 1.0 * level);

            ink = smoothstep(0.0, 3.0, age);
            bl = smoothstep(0.5, 5.0, age);
            vis = smoothstep(0.0, 0.5, age) * (1.0 - smoothstep(4.5, 7.2, age)) * saturate((1.0 - 0.5 / dur - progress) * (dur / 1.5));
            vis *= step(hash(seed + 5.5), lerp(0.3, 1.0, smoothstep(0.2, 0.55, rnd)));
            tint = smoothstep(0.0, 2.5, age);
        }
        else
        {
            float j = floor(px.x / gap) - 3.0 + (float)(k - 30);
            seed = j + songSeedOf();
            float homeX = (j + 0.5) * gap;
            float dist = head - homeX;
            float dg = dist + 420.0 * tScale * endT;
            float keep = step(1.0, j) * step(0.0, dist);
            ph = hash(seed + 0.1) * 6.2832;
            float ph2 = hash(seed + 0.7) * 6.2832;
            float lk = pairLinked(seed + 1.0 - step(0.25, frac(j * 0.5)));
            float grow = smoothstep(0.0, lerp(360.0, 160.0, lk) * tScale, dg);
            float spread = smoothstep(0.0, 200.0 * tScale, dg);
            spec = spectrum(frac(seed * 0.618034));
            float s0 = lerp(0.07, 0.15, lk);
            sz = size.y * (s0 + (0.24 - s0) * grow) * (1.0 + 0.25 * spec + 0.15 * beat);

            float y0 = mid - clamp(mel(seed * 0.6) * 0.85, -4.0, 4.0) * (size.y / 18.0);
            float yT = mid + (0.5 - frac(seed * 0.618034)) * size.y * 0.42 + (hash(seed + 4.2) - 0.5) * size.y * 0.16;
            float ty = lerp(y0, yT, spread);
            nK = clefLift(floor(homeX / seamLen));
            pos.y = clamp(ty - sp * 0.55 * nK + sin(time * 0.6 + ph) * size.y * 0.07 * spread, sz, size.y - sz);
            pos.x = homeX + (hash(seed + 1.9) - 0.5) * gap * 0.8 * spread
                  + sin(time * 0.45 + ph2) * gap * 0.45 * spread;

            float gust = sin(dist * 0.035 - time * 2.5) * exp(-dist / (350.0 * tScale));
            float windAmp = 0.25 + 0.5 * level + 0.4 * beat;
            windAng = gust * windAmp;
            pos.x += gust * windAmp * 5.0;

            ink = smoothstep(0.0, lerp(160.0, 90.0, lk) * tScale, dg);
            bl = smoothstep(100.0 * tScale, 420.0 * tScale, dg);
            vis = keep * smoothstep(0.0, 14.0 * tScale, dist);
            tint = smoothstep(0.0, 90.0 * tScale, dg);

        }

        vis *= dim;
        if (vis <= 0.001) continue;

        float3 nc = lerp(colorC.rgb, lerp(colorA.rgb, colorB.rgb, hash(seed + 3.3)), tint);
        float ckc = saturate(0.5 * nK);
        nc = lerp(nc, float3(1.0, 1.0, 1.0), 0.2 - 0.2 * ckc);
        nc = lerp(nc, lerp(colorA.rgb, colorB.rgb, ckc), 0.75 * tint);

        float ed = segd(px, pos, pos - float2(tx, 0.0));
        blend(acc, accA, nc, exp(-ed / (sz * 0.6)) * 0.22 * step((float)k, 29.5) * level * vis);

        float2 dp = px - pos;
        if (dot(dp, dp) > sz * sz * 9.0) continue;

        float nAng = 0.45 * sin(time * 0.5 + ph) + windAng;
        float cs = cos(nAng);
        float sn = sin(nAng);
        float2 lq = float2(dp.x * cs + dp.y * sn, -dp.x * sn + dp.y * cs) / sz;

        float kind = noteKind(seed);

        float stemmed = isNoteKind(kind);
        float flip = step(0.5, hash(seed + 13.0)) * stemmed;
        lq *= lerp(1.0, -1.0, flip);

        float twk = 0.5 + 0.5 * sin(time * (1.2 + 2.0 * hash(seed + 7.7)) + ph * 3.0);
        float breathe = 1.0 + (1.0 - playing) * 0.5 * sin(time * 1.3 + ph);
        float haloV = exp(-length(dp) / (sz * 1.1)) * (0.11 + 0.56 * spec * twk) * breathe * (1.25 * dim - 0.25) * vis;
        float covK = (0.64 + 0.3 * spec) * vis;

        float noteE = lerp(level, saturate(spec * 1.3), 0.6);
        blend(acc, accA, nc, glyph(lq, kind, 1.0 / sz, noteE, ink, bl, flip, hash(seed + 17.0)) * covK + haloV);
    }

    float core = exp(-length(px - float2(head, mid)) / (3.0 + 4.0 * beat));
    float glow = exp(-abs(px.x - head) / 5.0) * (0.15 + 0.35 * level);
    blend(acc, accA, colorC.rgb, glow);
    blend(acc, accA, lerp(colorC.rgb, float3(1.0, 1.0, 1.0), 0.6), core);

    float2 fp = px - float2(head, mid - size.y * 0.3);
    float fR = size.y * 0.16;
    float fArc = cover(abs(length(fp) - fR), 1.0) * step(fp.y, 0.0);
    float fDot = 1.0 - smoothstep(0.8, 1.6, length(fp - float2(0.0, fR * 0.35)));
    blend(acc, accA, colorC.rgb, max(fArc, fDot) * (1.0 - playing) * (0.7 + 0.3 * sin(time * 2.5)));

    float lCkT = saturate(0.5 * clefLift(round(px.x / seamLen)));
    blend(acc, accA, lerp(swapTint(lCkT), float3(1.0, 1.0, 1.0), 0.8), lcov * lerp(0.78, 1.0, step(0.01, lCkT)));

    float fin = saturate((progress - endStart) / (1.0 - endStart)) * (0.75 + 0.25 * sin(time * 3.0));
    float3 color = lerp(acc / max(accA, 0.001), float3(1.0, 1.0, 1.0), 0.35 * fin);
    accA = saturate(accA * (1.0 + 0.8 * fin));
    return paint(color, accA);
}