Dino No Internet

by Rinz, progress bar

Chrome Dino with constant real-time speed for long playlists, still scene on pause, long-uptime safe, optimized Monument Valley mesas and horizon EQ

33 downloads Download file, 37.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 6f04c36a59fb4d0b83493c8e986e567d2b04740acef3a858798944f8662d46b2

//! name: Dino No Internet
//! author: Rinz
//! kind: progress
//! description: Chrome Dino with constant real-time speed for long playlists, still scene on pause, long-uptime safe, optimized Monument Valley mesas and horizon EQ

static const float USE_APP_COLOR = 1.0;
static const float SCROLL_SPEED = 1.65;
static const float WRAP_SECONDS = 7200.0;

float hash1(float n)
{
    return frac(sin(n * 127.1 + 31.7) * 43758.5453);
}

float box2(float2 p, float x0, float y0, float x1, float y1)
{
    return step(x0, p.x) * step(p.x, x1) * step(y0, p.y) * step(p.y, y1);
}

float sdRoundBox(float2 p, float2 b, float r)
{
    float2 q = abs(p) - b + r;
    return length(max(q, 0.0)) + min(max(q.x, q.y), 0.0) - r;
}

void layer(inout float3 acc, inout float cover, float3 rgb, float a)
{
    a = saturate(a);
    acc = rgb * a + acc * (1.0 - a);
    cover = a + cover * (1.0 - a);
}

float digit3x5(float d, float2 c)
{
    if (c.x < 0.0 || c.x > 2.0 || c.y < 0.0 || c.y > 4.0) return 0.0;
    float top = step(3.5, c.y);
    float mid = step(1.5, c.y) * step(c.y, 2.5);
    float bot = step(c.y, 0.5);
    float lft = step(c.x, 0.5);
    float rgt = step(1.5, c.x);
    float upL = lft * step(2.5, c.y) * step(c.y, 3.5);
    float dnL = lft * step(0.5, c.y) * step(c.y, 1.5);
    float upR = rgt * step(2.5, c.y) * step(c.y, 3.5);
    float dnR = rgt * step(0.5, c.y) * step(c.y, 1.5);

    float on = 0.0;
    if (abs(d - 0.0) < 0.25) on = max(max(top, bot), max(lft, rgt));
    else if (abs(d - 1.0) < 0.25) on = rgt;
    else if (abs(d - 2.0) < 0.25) on = max(max(top, max(mid, bot)), max(upR, dnL));
    else if (abs(d - 3.0) < 0.25) on = max(max(top, max(mid, bot)), rgt);
    else if (abs(d - 4.0) < 0.25) on = max(mid, max(rgt, upL));
    else if (abs(d - 5.0) < 0.25) on = max(max(top, max(mid, bot)), max(upL, dnR));
    else if (abs(d - 6.0) < 0.25) on = max(max(top, max(mid, bot)), max(lft, dnR));
    else if (abs(d - 7.0) < 0.25) on = max(top, rgt);
    else if (abs(d - 8.0) < 0.25) on = max(max(top, max(mid, bot)), max(lft, rgt));
    else if (abs(d - 9.0) < 0.25) on = max(max(top, max(mid, bot)), max(rgt, upL));
    return saturate(on);
}

float letter3x5(float ch, float2 c)
{
    if (c.x < 0.0 || c.x > 2.0 || c.y < 0.0 || c.y > 4.0) return 0.0;
    float top = step(3.5, c.y);
    float mid = step(1.5, c.y) * step(c.y, 2.5);
    float bot = step(c.y, 0.5);
    float lft = step(c.x, 0.5);
    float rgt = step(1.5, c.x);
    float upL = lft * step(2.5, c.y) * step(c.y, 3.5);
    float upR = rgt * step(2.5, c.y) * step(c.y, 3.5);
    float dnR = rgt * step(0.5, c.y) * step(c.y, 1.5);

    float on = 0.0;
    if (abs(ch - 0.0) < 0.25) on = max(max(lft, top), max(mid, upR));
    else if (abs(ch - 1.0) < 0.25) on = max(max(lft, rgt), max(top, mid));
    else if (abs(ch - 2.0) < 0.25) on = max(max(lft, rgt), bot);
    else if (abs(ch - 3.0) < 0.25) on = max(max(top, max(mid, bot)), max(upL, dnR));
    else if (abs(ch - 4.0) < 0.25) on = max(lft, max(top, max(mid, bot)));
    else if (abs(ch - 5.0) < 0.25) on = max(max(top, max(bot, lft)), max(dnR, box2(c, 2.0, 2.0, 2.0, 2.0)));
    else if (abs(ch - 6.0) < 0.25) on = max(max(lft, rgt), box2(c, 1.0, 3.0, 1.0, 3.0));
    return saturate(on);
}

float cloudShapeMask(float2 p, float variant)
{
    if (variant < 0.5)
    {
        float m = box2(p, -11.0, 0.0, 10.0, 0.0);
        m = max(m, box2(p, -9.0, 1.0, 9.0, 1.0));
        m = max(m, box2(p, -6.0, 2.0, 8.0, 2.0));
        m = max(m, box2(p, -4.0, 3.0, 6.0, 3.0));
        m = max(m, box2(p, -3.0, 4.0, 2.0, 4.0));
        m = max(m, box2(p, 4.0, 4.0, 5.0, 4.0));
        m = max(m, box2(p, -2.0, 5.0, 1.0, 5.0));
        return m;
    }
    else
    {
        float m = box2(p, -7.0, 0.0, 7.0, 0.0);
        m = max(m, box2(p, -5.0, 1.0, 6.0, 1.0));
        m = max(m, box2(p, -3.0, 2.0, 4.0, 2.0));
        m = max(m, box2(p, -2.0, 3.0, 1.0, 3.0));
        return m;
    }
}

float sampleChromeCloud(float2 cp, float variant, out float isOutline)
{
    float2 p = floor(cp + 0.5);
    isOutline = 0.0;
    if (p.x < -12.0 || p.x > 11.0 || p.y < 0.0 || p.y > 6.0) return 0.0;

    float fill = cloudShapeMask(p, variant);
    if (fill > 0.5)
    {
        float nL = cloudShapeMask(p + float2(-1.0, 0.0), variant);
        float nR = cloudShapeMask(p + float2(1.0, 0.0), variant);
        float nU = cloudShapeMask(p + float2(0.0, 1.0), variant);
        float nD = cloudShapeMask(p + float2(0.0, -1.0), variant);
        isOutline = 1.0 - min(min(nL, nR), min(nU, nD));
    }
    return fill;
}

float sampleSmallCactus(float2 p, float flipArm)
{
    if (abs(p.x) > 3.0 || p.y < 0.0 || p.y > 9.0) return 0.0;
    float m = box2(p, 0.0, 0.0, 1.0, 8.0);
    float lTop = (flipArm > 0.5) ? 6.0 : 5.0;
    float rTop = (flipArm > 0.5) ? 5.0 : 6.0;
    m = max(m, box2(p, -2.0, 3.0, -1.0, 3.0));
    m = max(m, box2(p, -2.0, 3.0, -2.0, lTop));
    m = max(m, box2(p, 2.0, 4.0, 2.0, 4.0));
    m = max(m, box2(p, 2.0, 4.0, 2.0, rTop));
    return m;
}

float sampleLargeCactus(float2 p, float flipArm)
{
    if (abs(p.x) > 4.0 || p.y < 0.0 || p.y > 12.0) return 0.0;
    float m = box2(p, -1.0, 0.0, 1.0, 11.0);
    m = max(m, box2(p, 0.0, 12.0, 0.0, 12.0));
    float lBot = (flipArm > 0.5) ? 5.0 : 4.0;
    float lTop = (flipArm > 0.5) ? 9.0 : 8.0;
    float rBot = (flipArm > 0.5) ? 4.0 : 5.0;
    float rTop = (flipArm > 0.5) ? 8.0 : 10.0;
    m = max(m, box2(p, -3.0, lBot, -2.0, lBot));
    m = max(m, box2(p, -3.0, lBot, -3.0, lTop));
    m = max(m, box2(p, 2.0, rBot, 3.0, rBot));
    m = max(m, box2(p, 3.0, rBot, 3.0, rTop));
    return m;
}

float sampleCactusCluster(float2 cp, float cType, out float isLitSide)
{
    float2 p = floor(cp + 0.5);
    isLitSide = 0.0;
    if (abs(p.x) > 10.0 || p.y < 0.0 || p.y > 13.0) return 0.0;

    float m = 0.0;
    if (cType < 0.16)
    {
        m = sampleSmallCactus(p, 0.0);
        isLitSide = step(p.x, 0.0);
    }
    else if (cType < 0.36)
    {
        float c1 = sampleSmallCactus(p - float2(-3.0, 0.0), 0.0);
        float c2 = sampleSmallCactus(p - float2(2.0, 0.0), 1.0);
        m = max(c1, c2);
        isLitSide = max(c1 * step(p.x, -3.0), c2 * step(p.x, 2.0));
    }
    else if (cType < 0.54)
    {
        float c1 = sampleSmallCactus(p - float2(-5.0, 0.0), 0.0);
        float c2 = sampleSmallCactus(p - float2(0.0, 0.0), 1.0);
        float c3 = sampleSmallCactus(p - float2(5.0, 0.0), 0.0);
        m = max(c1, max(c2, c3));
        isLitSide = max(c1 * step(p.x, -5.0), max(c2 * step(p.x, 0.0), c3 * step(p.x, 5.0)));
    }
    else if (cType < 0.78)
    {
        m = sampleLargeCactus(p, 0.0);
        isLitSide = step(p.x, 0.0);
    }
    else
    {
        float c1 = sampleLargeCactus(p - float2(-5.0, 0.0), 0.0);
        float c2 = sampleSmallCactus(p - float2(0.0, 0.0), 1.0);
        float c3 = sampleLargeCactus(p - float2(5.0, 0.0), 1.0);
        m = max(c1, max(c2, c3));
        isLitSide = max(c1 * step(p.x, -5.0), max(c2 * step(p.x, 0.0), c3 * step(p.x, 5.0)));
    }
    return m;
}

float sampleUprightDino(float2 r, float legState, out float isEye)
{
    float2 p = floor(r + 0.5);
    isEye = 0.0;
    if (p.x < -7.0 || p.x > 6.0 || p.y < 0.0 || p.y > 14.0) return 0.0;

    float m = box2(p, 0.0, 13.0, 4.0, 13.0);
    m = max(m, box2(p, -1.0, 10.0, 5.0, 12.0));
    m = max(m, box2(p, -1.0, 9.0, 2.0, 9.0));
    m = max(m, box2(p, -1.0, 8.0, 4.0, 8.0));
    m = max(m, box2(p, -2.0, 7.0, 1.0, 7.0));
    m = max(m, box2(p, -3.0, 6.0, 1.0, 6.0));
    m = max(m, box2(p, -4.0, 5.0, 1.0, 5.0));
    m = max(m, box2(p, -5.0, 4.0, 1.0, 4.0));
    m = max(m, box2(p, -4.0, 3.0, 0.0, 3.0));
    m = max(m, box2(p, 2.0, 6.0, 3.0, 6.0));
    m = max(m, box2(p, 3.0, 5.0, 3.0, 5.0));
    m = max(m, box2(p, -5.0, 5.0, -5.0, 5.0));
    m = max(m, box2(p, -6.0, 6.0, -5.0, 6.0));
    m = max(m, box2(p, -6.0, 7.0, -6.0, 7.0));

    if (legState < 0.5)
    {
        m = max(m, box2(p, -3.0, 2.0, -2.0, 2.0));
        m = max(m, box2(p, 0.0, 1.0, 0.0, 2.0));
        m = max(m, box2(p, -3.0, 0.0, -3.0, 1.0));
        m = max(m, box2(p, -2.0, 0.0, -2.0, 0.0));
        m = max(m, box2(p, 0.0, 0.0, 1.0, 0.0));
    }
    else if (legState < 1.5)
    {
        m = max(m, box2(p, -3.0, 2.0, -2.0, 2.0));
        m = max(m, box2(p, 0.0, 2.0, 0.0, 2.0));
        m = max(m, box2(p, -3.0, 0.0, -3.0, 1.0));
        m = max(m, box2(p, -2.0, 0.0, -2.0, 0.0));
        m = max(m, box2(p, 0.0, 1.0, 1.0, 1.0));
    }
    else
    {
        m = max(m, box2(p, -3.0, 1.0, -3.0, 2.0));
        m = max(m, box2(p, -2.0, 1.0, -2.0, 1.0));
        m = max(m, box2(p, 0.0, 0.0, 0.0, 2.0));
        m = max(m, box2(p, 1.0, 0.0, 1.0, 0.0));
    }

    if (p.x == 1.0 && p.y == 12.0) isEye = 1.0;
    return m;
}

float sampleDuckingDino(float2 r, float legState, out float isEye)
{
    float2 p = floor(r + 0.5);
    isEye = 0.0;
    if (p.x < -9.0 || p.x > 7.0 || p.y < 0.0 || p.y > 9.0) return 0.0;

    float m = box2(p, -8.0, 8.0, -8.0, 8.0);
    m = max(m, box2(p, -8.0, 7.0, -6.0, 7.0));
    m = max(m, box2(p, -4.0, 7.0, 5.0, 7.0));
    m = max(m, box2(p, -7.0, 6.0, 6.0, 6.0));
    m = max(m, box2(p, -6.0, 5.0, 6.0, 5.0));
    m = max(m, box2(p, -5.0, 4.0, 3.0, 4.0));
    m = max(m, box2(p, 5.0, 4.0, 6.0, 4.0));
    m = max(m, box2(p, -4.0, 3.0, 5.0, 3.0));
    m = max(m, box2(p, -3.0, 2.0, 0.0, 2.0));
    m = max(m, box2(p, 2.0, 2.0, 2.0, 2.0));

    if (legState < 1.2)
    {
        m = max(m, box2(p, -3.0, 0.0, -3.0, 1.0));
        m = max(m, box2(p, -2.0, 0.0, -2.0, 0.0));
        m = max(m, box2(p, 0.0, 1.0, 0.0, 1.0));
    }
    else
    {
        m = max(m, box2(p, -2.0, 1.0, -2.0, 1.0));
        m = max(m, box2(p, 0.0, 0.0, 0.0, 1.0));
        m = max(m, box2(p, 1.0, 0.0, 1.0, 0.0));
    }

    if (p.x == 3.0 && p.y == 6.0) isEye = 1.0;
    return m;
}

float samplePterodactyl(float2 pp, float flapUp)
{
    float2 p = floor(pp + 0.5);
    if (p.x < -7.0 || p.x > 6.0 || p.y < -5.0 || p.y > 6.0) return 0.0;

    float m = box2(p, -6.0, 1.0, -2.0, 1.0);
    m = max(m, box2(p, -5.0, 2.0, -2.0, 2.0));
    m = max(m, box2(p, -4.0, 3.0, -2.0, 3.0));
    m = max(m, box2(p, -3.0, 4.0, -3.0, 4.0));
    m = max(m, box2(p, -2.0, 0.0, 3.0, 0.0));
    m = max(m, box2(p, -1.0, -1.0, 3.0, -1.0));
    m = max(m, box2(p, 2.0, 1.0, 5.0, 1.0));
    m = max(m, box2(p, 3.0, -1.0, 4.0, -1.0));

    if (flapUp > 0.5)
    {
        m = max(m, box2(p, -1.0, 1.0, 1.0, 1.0));
        m = max(m, box2(p, -1.0, 2.0, 1.0, 2.0));
        m = max(m, box2(p, -1.0, 3.0, 0.0, 3.0));
        m = max(m, box2(p, 0.0, 4.0, 0.0, 4.0));
    }
    else
    {
        m = max(m, box2(p, -1.0, -2.0, 1.0, -2.0));
        m = max(m, box2(p, -1.0, -3.0, 0.0, -3.0));
        m = max(m, box2(p, -1.0, -4.0, -1.0, -4.0));
    }
    return m;
}

float rockRidgeNoise(float x, float y, float seed)
{
    float warp = sin(y * 6.5 + seed * 11.0) * 0.28;
    float r1 = sin(x * 11.5 + warp + seed * 7.3);
    float r2 = cos(x * 23.0 - y * 2.5 + seed * 19.1) * 0.45;
    return r1 + r2;
}

float peakProfile(float nx, float h, float seed, float pSize)
{
    float dir = (frac(seed * 3.7) > 0.5) ? 1.0 : -1.0;
    float u = nx * dir;
    float pk = (u + 0.34) / 0.36;
    float pinnacle = exp(-pk * pk) * 0.14;
    float shoulder = smoothstep(0.65, -0.15, u) * 0.10;
    float crag = (sin(nx * 8.5 + seed * 13.0) * 0.025 + cos(nx * 16.0 + seed * 5.0) * 0.015);
    float edgeDrop = -pow(saturate((abs(nx) - 0.72) / 0.28), 1.6) * 0.22;
    float rawH = h * (0.86 + pinnacle + shoulder + crag + edgeDrop);
    return floor(rawH / pSize + 0.5) * pSize;
}

float sampleMonumentFormation(float lx, float y, float halfW, float h,
                              float style, float seed, float pSize,
                              out float shadeLevel)
{
    shadeLevel = 0.0;
    if (y < 0.0 || y > h * 1.18 || abs(lx) > halfW * 1.55) return 0.0;

    float yStep = floor(y / (pSize * 2.0));
    float t = saturate(y / max(h, pSize));
    float faceX = lx;
    float faceHalf = halfW;
    float actualTop = h;
    float visible = 0.0;
    float isTalus = 0.0;

    [branch] if (style < 0.42)
    {
        float mainC = -halfW * 0.16;
        float wallW = halfW * 0.52;
        float talusCurve = pow(saturate(1.0 - t / 0.40), 2.1);
        float ledgeStep = floor(talusCurve * 7.0) / 7.0;
        float benchL = step(t, 0.64) * halfW * 0.12;
        float benchR = step(t, 0.52) * halfW * 0.14;
        float jagL = floor((sin(yStep * 1.4 + seed * 13.0) + cos(yStep * 2.6 + seed * 5.0)) * 0.85) * pSize;
        float jagR = floor((cos(yStep * 1.5 + seed * 21.0) + sin(yStep * 2.8 + seed * 9.0)) * 0.85) * pSize;

        float leftEdge = mainC - wallW - benchL - halfW * 0.64 * ledgeStep + jagL;
        float rightEdge = mainC + wallW + benchR + halfW * 0.54 * ledgeStep + jagR;
        float nxTop = clamp((lx - mainC) / max(wallW + benchL * 0.5, pSize), -1.0, 1.0);
        float mainTop = peakProfile(nxTop, h, seed, pSize);
        float inMain = step(leftEdge, lx) * step(lx, rightEdge) * step(y, mainTop);

        float spireC = halfW * 0.76;
        float spireW = max(pSize * 1.6, halfW * 0.12);
        float spTalus = floor(pow(saturate(1.0 - t / 0.34), 1.9) * 5.0) / 5.0;
        float spL = spireC - spireW - halfW * 0.22 * spTalus;
        float spR = spireC + spireW + halfW * 0.32 * spTalus + jagR * 0.4;
        float spireTop = h * 0.84 + floor(sin(seed * 23.0) * 1.5) * pSize;
        float inSpire = step(spL, lx) * step(lx, spR) * step(y, spireTop);

        visible = max(inMain, inSpire);
        if (inMain > 0.5)
        {
            faceX = lx - mainC;
            faceHalf = max(0.5 * (rightEdge - leftEdge), pSize);
            actualTop = mainTop;
        }
        else
        {
            faceX = lx - spireC;
            faceHalf = max(0.5 * (spR - spL), pSize);
            actualTop = spireTop;
        }
        isTalus = 1.0 - step(0.40, t);
    }
    else if (style < 0.74)
    {
        float wallW = halfW * 0.66;
        float tc = saturate(1.0 - t / 0.42);
        float talusCurve = tc * tc;
        float ledgeStep = floor(talusCurve * 8.0) / 8.0;
        float tier1 = step(t, 0.72) * halfW * 0.13;
        float tier2 = step(t, 0.54) * halfW * 0.15;
        float jagL = floor(sin(yStep * 1.3 + seed * 17.0) * 1.1) * pSize;
        float jagR = floor(cos(yStep * 1.4 + seed * 29.0) * 1.1) * pSize;

        float leftEdge = -wallW - tier1 - tier2 - halfW * 0.56 * ledgeStep + jagL;
        float rightEdge = wallW + tier1 * 0.8 + tier2 * 0.9 + halfW * 0.54 * ledgeStep + jagR;
        float nxTop = clamp(lx / max(wallW, pSize), -1.0, 1.0);
        actualTop = peakProfile(nxTop, h * 0.94, seed + 0.41, pSize);
        visible = step(leftEdge, lx) * step(lx, rightEdge) * step(y, actualTop);
        faceX = lx;
        faceHalf = max(0.5 * (rightEdge - leftEdge), pSize);
        isTalus = 1.0 - step(0.42, t);
    }
    else
    {
        float tc = saturate(1.0 - t / 0.38);
        float talusCurve = tc * tc;
        float ledgeStep = floor(talusCurve * 7.0) / 7.0;
        float jagL = floor(sin(yStep * 1.5 + seed * 11.0) * 0.9) * pSize;
        float jagR = floor(cos(yStep * 1.4 + seed * 19.0) * 0.9) * pSize;

        float lC = -halfW * 0.42;
        float rC = halfW * 0.44;
        float lW = halfW * 0.35 + halfW * 0.48 * ledgeStep;
        float rW = halfW * 0.27 + halfW * 0.46 * ledgeStep;

        float nxL = clamp((lx - lC) / max(halfW * 0.35, pSize), -1.0, 1.0);
        float nxR = clamp((lx - rC) / max(halfW * 0.27, pSize), -1.0, 1.0);
        float lTop = peakProfile(nxL, h, seed, pSize);
        float rTop = peakProfile(nxR, h * 0.78, seed + 0.53, pSize);

        float inL = step(lC - lW + jagL, lx) * step(lx, lC + lW * 0.92) * step(y, lTop);
        float inR = step(rC - rW * 0.92, lx) * step(lx, rC + rW + jagR) * step(y, rTop);
        visible = max(inL, inR);
        if (inL > 0.5)
        {
            faceX = lx - lC;
            faceHalf = max(lW, pSize);
            actualTop = lTop;
        }
        else
        {
            faceX = lx - rC;
            faceHalf = max(rW, pSize);
            actualTop = rTop;
        }
        isTalus = 1.0 - step(0.38, t);
    }

    [branch] if (visible < 0.5) return 0.0;

    float nx = faceX / max(faceHalf, pSize);
    float pixelRow = floor(y / pSize + 0.01);
    float dFlute = rockRidgeNoise(lx + pSize, y, seed) - rockRidgeNoise(lx - pSize, y, seed);

    if (isTalus < 0.5)
    {
        float baseLight = lerp(0.68, 0.30, smoothstep(-0.65, 0.55, nx));
        shadeLevel = baseLight + dFlute * 0.20;

        float leftRim = step(nx, -0.82);
        float ridgeRim = step(nx, 0.15) * step(0.42, dFlute);
        if (max(leftRim, ridgeRim) > 0.5)
            shadeLevel = max(shadeLevel, 0.89);

        if (dFlute < -0.44 && nx > -0.35)
            shadeLevel = min(shadeLevel, 0.18);
    }
    else
    {
        float shelfPhase = frac(y / (pSize * 2.0));
        float shelfTop = step(0.50, shelfPhase);
        float baseTalus = lerp(0.62, 0.34, smoothstep(-0.70, 0.65, nx));
        shadeLevel = baseTalus + (shelfTop - 0.45) * 0.18 + dFlute * 0.06;
    }

    float stratum = fmod(pixelRow + floor(seed * 7.0), 4.0);
    if (stratum < 0.65 && y > pSize * 2.0)
        shadeLevel -= 0.08;

    if (y > actualTop - pSize * 1.1 && nx < -0.08)
        shadeLevel = max(shadeLevel, 0.88);

    shadeLevel = saturate(shadeLevel);
    return 1.0;
}

float distantMesaHeight(float worldX, float pitch, float seed,
                        float baseY, float relief, float pSize)
{
    float cell = floor(worldX / pitch);
    float x = frac(worldX / pitch);
    float rnd = hash1(cell * 23.71 + seed);
    float left = 0.14 + rnd * 0.10;
    float right = 0.75 + rnd * 0.12;
    float rise = saturate((x - left) / 0.16);
    float fall = saturate((right - x) / 0.13);
    float plateau = min(rise, fall);
    float crest = (sin(worldX * 2.4 + seed) * 0.012 + cos(worldX * 5.3 + seed * 2.1) * 0.006) * plateau;
    float height = baseY + relief * lerp(0.50, 1.0, rnd) * plateau + crest;
    return floor(height / pSize + 0.5) * pSize;
}

float4 main(float2 uv : TEXCOORD) : COLOR
{
    float u = max(size.y, 1.0);
    float2 px = float2(uv.x * size.x, rise(uv) * u);
    float2 q = px / u;
    float aspect = size.x / u;
    float aa = 1.25 / u;

    float cornerR = 0.095;
    float dFrame = sdRoundBox(q - float2(aspect * 0.5, 0.5), float2(aspect * 0.5 - 0.01, 0.49), cornerR);
    float frameMask = 1.0 - smoothstep(-aa, aa, dFrame);
    if (frameMask <= 0.001) return paint(float3(0.0, 0.0, 0.0), 0.0);

    float pSize = 1.0 / 32.0;
    float2 pid = floor(q / pSize);
    float2 pq = (pid + 0.5) * pSize;

    float isPlay = step(0.5, saturate(playing));
    float prog = saturate(progress);
    float kick = saturate(beat) * isPlay;

    // Playing: constant real-time speed for any track length; time wraps every WRAP_SECONDS so
    // float precision never degrades (no pixel jitter / broken obstacles after hours of uptime).
    // Paused: scene holds still at a progress-based frame (one cut on pause / resume).
    float scrollX = (isPlay > 0.5) ? (fmod(time, WRAP_SECONDS) * SCROLL_SPEED) : (prog * 680.0);

    float margin = 0.36;
    float headX = lerp(margin, max(aspect - margin, margin + 0.01), prog);
    float fadeCenter = headX + pSize * 2.5;
    float ditherFade = (frac(pid.x * 0.5 + pid.y * 0.25) - 0.5) * 0.16;
    float colorBlend = smoothstep(fadeCenter + 1.05, fadeCenter - 0.35, pq.x + ditherFade);

    float3 themeAccent = lerp(float3(1.0, 0.48, 0.18), saturate(colorA * 1.15), 0.25 * USE_APP_COLOR);
    float3 themeGlow = lerp(float3(1.0, 0.78, 0.32), saturate(colorB * 1.15), 0.25 * USE_APP_COLOR);

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

    // 1. Sunset Sky vs Chrome Offline Canvas
    float skyT = saturate((pq.y - 0.15) / 0.85);
    float dither = frac((pid.x + pid.y) * 0.5) * 0.025;
    float3 skyHor = float3(1.00, 0.78, 0.34);
    float3 skyLow = lerp(float3(0.98, 0.48, 0.20), themeAccent, 0.24);
    float3 skyMid = float3(0.84, 0.29, 0.28);
    float3 skyTop = float3(0.45, 0.21, 0.47);

    float3 colSkyColor = lerp(skyHor, skyLow, smoothstep(0.0, 0.32, skyT + dither));
    colSkyColor = lerp(colSkyColor, skyMid, smoothstep(0.28, 0.68, skyT + dither));
    colSkyColor = lerp(colSkyColor, skyTop, smoothstep(0.62, 0.98, skyT + dither));
    float3 monoSky = float3(0.985, 0.985, 0.985);
    layer(acc, cover, lerp(monoSky, colSkyColor, colorBlend), 1.0);

    // 2. Glowing Afternoon Sun
    float2 sunPos = float2(clamp(aspect * 0.22, 0.65, 1.95), 0.39);
    float dSun = length(pq - sunPos);
    float sunR = 0.24;
    if (dSun < sunR + pSize * 3.0)
    {
        float coreMask = step(dSun, sunR);
        float haloMask = step(dSun, sunR + pSize * (1.2 + step(0.35, kick))) * (1.0 - coreMask);
        float3 sunPlay = lerp(float3(1.0, 0.86, 0.46), float3(1.0, 0.98, 0.80), saturate((pq.y - 0.18) / 0.42));
        float3 sunMono = float3(0.93, 0.93, 0.94);
        layer(acc, cover, lerp(sunMono, float3(1.0, 0.68, 0.32), colorBlend), haloMask * 0.55);
        layer(acc, cover, lerp(sunMono, sunPlay, colorBlend), coreMask);
    }

    // 3. Classic Chrome Pixel-Art Stepped Clouds
    [branch] if (pq.y > 0.62)
    {
        float clPitch = 3.1;
        float clBand = floor((pq.y - 0.62) / (pSize * 6.0));
        float clWx = pq.x + scrollX * (0.11 + clBand * 0.03) + clBand * 1.45;
        float clId = floor(clWx / clPitch);
        float clSeed = hash1(clId * 19.7 + clBand * 11.3);
        if (clSeed > 0.30)
        {
            float baseY = 0.64 + clBand * (pSize * 6.0);
            float2 cp = (float2(clWx - (clId + 0.5) * clPitch, pq.y - baseY)) / pSize;
            float isOutline = 0.0;
            float inCloud = sampleChromeCloud(cp, frac(clSeed * 7.1), isOutline);
            if (inCloud > 0.5)
            {
                float isLit = step(2.5, cp.y) * (1.0 - isOutline * 0.4);
                float3 clPlay = lerp(float3(0.95, 0.56, 0.38), float3(1.0, 0.90, 0.68), isLit);
                float3 clMono = lerp(float3(0.985, 0.985, 0.985), float3(0.76, 0.76, 0.78), isOutline);
                layer(acc, cover, lerp(clMono, clPlay, colorBlend), 1.0);
            }
        }
    }

    // 4. Two Depth-Separated Far Horizon Ridges
    float farWx = pq.x + scrollX * 0.105;
    float farH = distantMesaHeight(farWx, 4.8, 3.7, 0.205, 0.10, pSize);
    if (pq.y >= 0.15 && pq.y <= farH)
    {
        float3 farPlay = float3(0.89, 0.43, 0.36);
        float3 farMono = float3(0.945, 0.945, 0.95);
        layer(acc, cover, lerp(farMono, farPlay, colorBlend), 1.0);
    }

    float midWx = pq.x + scrollX * 0.15 + 1.9;
    float midH = distantMesaHeight(midWx, 3.65, 51.1, 0.19, 0.095, pSize);
    if (pq.y >= 0.15 && pq.y <= midH)
    {
        float3 midPlay = float3(0.72, 0.29, 0.29);
        float3 midMono = float3(0.915, 0.915, 0.93);
        layer(acc, cover, lerp(midMono, midPlay, colorBlend), 1.0);
    }

    float dWx = pq.x + scrollX * 0.48;
    float duneH = 0.19 + floor((sin(dWx * 1.45) * 0.024 + cos(dWx * 2.8 + 1.1) * 0.014) / pSize) * pSize;

    // 5. High-Contrast Retro Pixel-LED Horizon Equalizer
    float eqStep = pSize * 3.0;
    float eqColId = floor(pq.x / eqStep);
    float eqLocalX = frac(pq.x / eqStep);
    [branch] if (isPlay > 0.5 && eqLocalX < 0.64 && pq.y > duneH && pq.y >= 0.20 && pq.y <= 0.54)
    {
        float eqCenterX = (eqColId + 0.5) * eqStep;
        float eqNorm = abs(eqCenterX / max(aspect, 0.01) - 0.5) * 2.0;
        float fBand = pow(saturate(eqNorm), 0.82);
        float gain = lerp(1.75, 2.65, fBand);
        float eqSpec = saturate((spectrum(fBand * 0.92) - 0.13) * gain);
        float eqBaseY = 0.20;
        float barCells = floor(eqSpec * 9.0 * saturate(level * 1.15 + 0.18) * isPlay);
        float eqTopY = eqBaseY + barCells * pSize;
        float cellGap = step(0.25, frac(pid.y * 0.5));
        if (barCells >= 1.0 && pq.y >= eqBaseY && pq.y <= eqTopY && max(cellGap, step(eqTopY - pSize * 1.1, pq.y)) > 0.5)
        {
            float isPeak = step(eqTopY - pSize * 1.1, pq.y);
            float hRatio = saturate((pq.y - eqBaseY) / (pSize * 9.0));
            float3 barBase = float3(0.58, 0.16, 0.18);
            float3 barMid = lerp(float3(0.96, 0.46, 0.18), themeGlow, 0.35);
            float3 barTop = float3(1.00, 0.82, 0.34);
            float3 eqPlayCol = lerp(barBase, barMid, smoothstep(0.0, 0.55, hRatio));
            eqPlayCol = lerp(eqPlayCol, barTop, smoothstep(0.50, 1.0, hRatio));
            eqPlayCol = lerp(eqPlayCol * (1.0 + kick * 0.15), float3(1.0, 0.97, 0.84), isPeak);

            float3 eqMonoCol = lerp(float3(0.62, 0.62, 0.65), float3(0.325, 0.325, 0.34), isPeak);
            float eqAlpha = lerp(0.58, lerp(0.74, 0.96, isPeak), colorBlend);
            layer(acc, cover, lerp(eqMonoCol, eqPlayCol, colorBlend), eqAlpha);
        }
    }

    // 6. Sculpted Terraced Monument Valley Buttes, Mesas & Spires
    float mesaPitch = 8.4;
    float mesaWx = pq.x + scrollX * 0.26;
    float mesaId = floor(mesaWx / mesaPitch);
    float mesaX = mesaWx - mesaId * mesaPitch;
    float mesaSeed = hash1(mesaId * 41.3 + 7.9);
    float mesaSeed2 = hash1(mesaId * 19.7 + 23.1);
    float mesaBase = 0.17;

    [branch] if (pq.y >= mesaBase && pq.y > duneH && pq.y < 0.78)
    {
        float yRel = pq.y - mesaBase;
        float shdBack = 0.0;
        float shdHero = 0.0;

        float heroX = 2.40 + (mesaSeed - 0.5) * 0.52;
        float heroH = 0.39 + mesaSeed2 * 0.10;
        float heroW = 0.98 + mesaSeed * 0.24;
        float heroStyle = (mesaSeed2 < 0.42) ? 0.22 : ((mesaSeed2 < 0.74) ? 0.58 : 0.88);
        float mHero = sampleMonumentFormation(mesaX - heroX, yRel,
                          heroW, heroH, heroStyle,
                          mesaSeed, pSize, shdHero);

        float mBack = 0.0;
        [branch] if (mHero < 0.5)
        {
            float backX = 5.75 + (mesaSeed2 - 0.5) * 0.45;
            float backH = 0.28 + mesaSeed * 0.08;
            float backW = 0.64 + mesaSeed2 * 0.16;
            mBack = sampleMonumentFormation(mesaX - backX, yRel,
                          backW, backH, frac(mesaSeed * 3.7),
                          mesaSeed2, pSize, shdBack);
        }

        if (mBack > 0.5 || mHero > 0.5)
        {
            float isHero = step(0.5, mHero);
            float light = (isHero > 0.5) ? shdHero : shdBack;

            float3 deep = float3(0.30, 0.11, 0.18);
            float3 dark = float3(0.49, 0.18, 0.21);
            float3 mid = float3(0.76, 0.31, 0.20);
            float3 sunFace = float3(0.94, 0.49, 0.23);
            float3 gold = float3(1.00, 0.75, 0.38);

            float3 mesaCol = (light > 0.85) ? gold :
                             ((light > 0.60) ? sunFace :
                             ((light > 0.40) ? mid :
                             ((light > 0.22) ? dark : deep)));

            float3 hazeCol = float3(0.90, 0.47, 0.33);
            if (isHero < 0.5) mesaCol = lerp(mesaCol, hazeCol, 0.26);

            float gray = (light > 0.85) ? 0.93 :
                         ((light > 0.60) ? 0.86 :
                         ((light > 0.40) ? 0.78 :
                         ((light > 0.22) ? 0.68 : 0.58)));
            if (isHero < 0.5) gray = lerp(gray, 0.92, 0.28);
            float3 mesaMono = float3(gray, gray, gray + 0.01);

            layer(acc, cover, lerp(mesaMono, mesaCol, colorBlend), 1.0);
        }
    }

    // 7. Rolling Desert Dunes & Distant Midground Saguaro Silhouettes
    float bgCacPitch = 4.6;
    float bgCacId = floor(dWx / bgCacPitch);
    float bgCacSeed = hash1(bgCacId * 31.7 + 3.3);
    if (bgCacSeed > 0.48 && pq.y >= 0.16 && pq.y < 0.40)
    {
        float bgCacX = (bgCacId + 0.35 + frac(bgCacSeed * 5.1) * 0.3) * bgCacPitch;
        float bgBaseY = 0.185 + floor((sin(bgCacX * 1.45) * 0.024 + cos(bgCacX * 2.8 + 1.1) * 0.014) / pSize) * pSize;
        float2 bcp = float2(dWx - bgCacX, pq.y - bgBaseY) / (pSize * 0.72);
        if (sampleSmallCactus(floor(bcp + 0.5), step(0.74, bgCacSeed)) > 0.5)
        {
            float3 bgCacPlay = float3(0.56, 0.21, 0.17);
            float3 bgCacMono = float3(0.84, 0.84, 0.86);
            layer(acc, cover, lerp(bgCacMono, bgCacPlay, colorBlend), 0.92);
        }
    }
    if (pq.y <= duneH && pq.y >= 0.14)
    {
        float crest = step(duneH - pSize * 1.1, pq.y);
        float3 dunePlay = lerp(float3(0.76, 0.32, 0.15), float3(0.96, 0.58, 0.24), crest);
        float3 duneMono = lerp(float3(0.92, 0.92, 0.93), float3(0.82, 0.82, 0.84), crest);
        layer(acc, cover, lerp(duneMono, dunePlay, colorBlend), 1.0);
    }

    // 7b. Subtle Wind-Blown Desert Dust Motes
    if (pq.y > 0.18 && pq.y < 0.52 && colorBlend > 0.05)
    {
        float mCell = floor((pq.x + scrollX * 0.62) / (pSize * 14.0));
        float mRow = floor(pq.y / (pSize * 5.0));
        float mSeed = hash1(mCell * 17.3 + mRow * 29.1);
        if (mSeed > 0.72)
        {
            float mx = (mCell + frac(mSeed * 7.3)) * (pSize * 14.0) - scrollX * 0.62;
            float my = (mRow + 0.5) * (pSize * 5.0);
            if (abs(pq.x - mx) < pSize * 0.55 && abs(pq.y - my) < pSize * 0.55)
            {
                layer(acc, cover, float3(1.0, 0.86, 0.52), 0.38 * colorBlend);
            }
        }
    }

    // 8. Ground Track with Chrome Bumps, Pebbles & Progress Trail
    float groundY = 0.15625;
    float gWx = pq.x + scrollX;
    float gPidX = floor(gWx / pSize);
    float bumpCell = fmod(abs(gPidX), 38.0);
    float bumpH = (step(1.5, bumpCell) * step(bumpCell, 4.5)) * pSize;
    float curGroundY = groundY + bumpH;

    if (pq.y <= curGroundY)
    {
        float isLine = step(curGroundY - pSize * 1.0, pq.y);
        float pebble = step(0.94, hash1(fmod(gPidX, 1024.0) * 13.7 + pid.y * 7.3)) * step(pq.y, groundY - pSize * 1.5) * step(groundY - pSize * 3.5, pq.y);
        float trailGlow = exp(-max(0.0, headX - pq.x) * 1.8) * step(pq.x, headX + pSize * 2.0);

        float3 groundPlay = float3(0.28, 0.11, 0.10);
        float3 linePlay = lerp(float3(0.98, 0.66, 0.28), float3(1.0, 0.92, 0.68), trailGlow * 0.55) * (1.0 + kick * 0.2);
        float3 pebPlay = float3(0.68, 0.32, 0.18);
        float3 colGroundPlay = lerp(groundPlay, pebPlay, pebble);
        colGroundPlay = lerp(colGroundPlay, linePlay, isLine);

        float3 colGroundMono = lerp(monoSky, float3(0.325, 0.325, 0.34), max(isLine, pebble));
        layer(acc, cover, lerp(colGroundMono, colGroundPlay, colorBlend), 1.0);
    }

    // 9. Authentic Chrome Obstacles (5 Cactus Cluster Types + 3 Pterodactyl Altitudes)
    float obsPitch = 2.85;
    float obsWx = pq.x + scrollX;
    float obsId = floor(obsWx / obsPitch);
    float obsSeed = hash1(obsId * 23.7 + 5.1);
    [branch] if (obsId > 0.0 && obsSeed >= 0.22)
    {
        float obsCenter = (obsId + 0.5) * obsPitch;
        if (obsSeed < 0.67 && pq.y >= groundY && pq.y < 0.62)
        {
            float cType = frac(obsSeed * 17.3);
            float2 cp = float2(obsWx - obsCenter, pq.y - groundY) / pSize;
            float isLitSide = 0.0;
            float inCactus = sampleCactusCluster(cp, cType, isLitSide);
            if (inCactus > 0.5)
            {
                float3 cacPlay = lerp(float3(0.14, 0.26, 0.16), float3(0.32, 0.54, 0.28), isLitSide);
                float3 cacMono = float3(0.325, 0.325, 0.34);
                layer(acc, cover, lerp(cacMono, cacPlay, colorBlend), 1.0);
            }
        }
        else if (obsSeed >= 0.67 && pq.y > 0.20 && pq.y < 0.92)
        {
            float altTier = floor(frac(obsSeed * 19.1) * 3.0);
            float birdY = groundY + pSize * ((altTier < 0.5) ? 5.0 : ((altTier < 1.5) ? 10.5 : 16.5));
            float2 pp = float2(obsWx - obsCenter, pq.y - birdY) / pSize;
            float flapUp = step(0.0, sin(scrollX * 7.0 + obsId * 3.7));
            float inBird = samplePterodactyl(pp, flapUp);
            if (inBird > 0.5)
            {
                float3 ptPlay = float3(0.28, 0.14, 0.18);
                float3 ptMono = float3(0.325, 0.325, 0.34);
                layer(acc, cover, lerp(ptMono, ptPlay, colorBlend), 1.0);
            }
        }
    }

    // 10. Chrome T-Rex with Contact Shadow & Running Dust Puff
    [branch] if (abs(pq.x - headX) < 0.44)
    {
        float headW = headX + scrollX;
        float id0 = floor(headW / obsPitch);
        float c0 = (id0 + 0.5) * obsPitch;
        float targetId = ((c0 - headW) < -0.95) ? (id0 + 1.0) : id0;

        float nearSeed = hash1(targetId * 23.7 + 5.1);
        float isCactus = step(0.22, nearSeed) * step(nearSeed, 0.67);
        float isBird = step(0.67, nearSeed);
        float cType = frac(nearSeed * 17.3);
        float altTier = floor(frac(nearSeed * 19.1) * 3.0);

        float isLowBird = isBird * step(altTier, 0.5);
        float isMidBird = isBird * step(0.5, altTier) * step(altTier, 1.5);

        float nearCenter = (targetId + 0.5) * obsPitch;
        float dxObs = nearCenter - headW;

        float clusterHalfW = (cType < 0.16) ? 0.06 : ((cType < 0.36) ? 0.12 : ((cType < 0.54) ? 0.20 : ((cType < 0.78) ? 0.08 : 0.22)));
        float jumpWindow = (isCactus > 0.5) ? (0.58 + clusterHalfW) : 0.62;
        float jumpPeak = (isCactus > 0.5 && cType >= 0.54) ? 0.42 : 0.34;

        float jumpH = 0.0;
        if (targetId > 0.0 && (isCactus + isLowBird) > 0.5 && abs(dxObs) < jumpWindow)
        {
            float uJ = dxObs / jumpWindow;
            jumpH = floor(((1.0 - uJ * uJ) * jumpPeak) / pSize + 0.5) * pSize;
        }

        float isDuck = 0.0;
        if (targetId > 0.0 && isMidBird > 0.5 && abs(dxObs) < 0.68)
        {
            isDuck = 1.0;
        }

        float inAir = step(pSize * 0.5, jumpH);
        float stridePhase = floor(frac(scrollX * 5.2) * 2.0);
        float legState = (inAir < 0.5) ? (1.0 + stridePhase) : 0.0;

        float shadowSpan = max(0.0, 4.5 - jumpH / pSize * 0.32);
        if (shadowSpan > 0.5 && abs(pq.y - (groundY - pSize * 0.5)) < pSize * 0.5 && abs(pq.x - (headX - pSize * 0.5)) < pSize * shadowSpan)
        {
            layer(acc, cover, lerp(float3(0.65, 0.65, 0.67), float3(0.24, 0.09, 0.08), colorBlend), 0.45);
        }

        if (inAir < 0.5)
        {
            float2 dp = floor((pq - float2(headX - pSize * (6.0 + stridePhase * 1.5), groundY + pSize * 0.5)) / pSize + 0.5);
            if ((dp.x == 0.0 && dp.y == 0.0) || (dp.x == -2.0 && dp.y == 1.0))
            {
                layer(acc, cover, lerp(float3(0.55, 0.55, 0.57), float3(0.98, 0.72, 0.36), colorBlend), 0.70);
            }
        }

        float trexBaseY = groundY + jumpH;
        float2 r = (pq - float2(headX, trexBaseY)) / pSize;
        float isEye = 0.0;
        float inDino = 0.0;
        [branch] if (isDuck > 0.5) inDino = sampleDuckingDino(r, legState, isEye);
        else inDino = sampleUprightDino(r, legState, isEye);

        if (inDino > 0.5)
        {
            float3 dinoBody = float3(0.25, 0.25, 0.27);
            float3 dinoCol = lerp(dinoBody, float3(0.985, 0.985, 0.985), isEye);
            layer(acc, cover, dinoCol, 1.0);
        }
    }

    // 11. Top-Right Retro Scoreboard
    float scoreRight = aspect - pSize * 4.0;
    float scoreTop = 1.0 - pSize * 3.0;
    [branch] if (pq.x > scoreRight - pSize * 13.0 && pq.y > scoreTop - pSize * 6.0)
    {
        float pct = floor(prog * 100.0 + 0.001);
        float dHundreds = floor(pct / 100.0);
        float dTens = floor(fmod(pct, 100.0) / 10.0);
        float dOnes = floor(fmod(pct, 10.0));

        float2 sc = floor((pq - float2(scoreRight - pSize * 11.0, scoreTop - pSize * 5.0)) / pSize);
        float bit = 0.0;
        if (sc.x >= 0.0 && sc.x <= 2.0) bit = digit3x5(dHundreds, sc);
        else if (sc.x >= 4.0 && sc.x <= 6.0) bit = digit3x5(dTens, sc - float2(4.0, 0.0));
        else if (sc.x >= 8.0 && sc.x <= 10.0) bit = digit3x5(dOnes, sc - float2(8.0, 0.0));

        if (bit > 0.5)
        {
            float3 scoreCol = lerp(float3(0.325, 0.325, 0.34), float3(1.0, 0.95, 0.82), colorBlend);
            layer(acc, cover, scoreCol, 0.95);
        }
    }

    // 12. Chrome-Style "P A U S E   G A M E" & Pause Icon Overlay when Paused
    float centerX = aspect * 0.5;
    [branch] if (isPlay < 0.5 && abs(pq.x - centerX) < pSize * 21.0 && pq.y >= pSize * 8.0 && pq.y <= pSize * 26.0)
    {
        float textLeft = centerX - pSize * 18.5;
        float textBot = pSize * 20.0;
        float2 tc = floor((pq - float2(textLeft, textBot)) / pSize);
        float txtBit = 0.0;
        if (tc.y >= 0.0 && tc.y <= 4.0 && tc.x >= 0.0 && tc.x <= 36.0)
        {
            if (tc.x <= 2.0) txtBit = letter3x5(0.0, tc);
            else if (tc.x >= 4.0 && tc.x <= 6.0) txtBit = letter3x5(1.0, tc - float2(4.0, 0.0));
            else if (tc.x >= 8.0 && tc.x <= 10.0) txtBit = letter3x5(2.0, tc - float2(8.0, 0.0));
            else if (tc.x >= 12.0 && tc.x <= 14.0) txtBit = letter3x5(3.0, tc - float2(12.0, 0.0));
            else if (tc.x >= 16.0 && tc.x <= 18.0) txtBit = letter3x5(4.0, tc - float2(16.0, 0.0));
            else if (tc.x >= 22.0 && tc.x <= 24.0) txtBit = letter3x5(5.0, tc - float2(22.0, 0.0));
            else if (tc.x >= 26.0 && tc.x <= 28.0) txtBit = letter3x5(1.0, tc - float2(26.0, 0.0));
            else if (tc.x >= 30.0 && tc.x <= 32.0) txtBit = letter3x5(6.0, tc - float2(30.0, 0.0));
            else if (tc.x >= 34.0 && tc.x <= 36.0) txtBit = letter3x5(4.0, tc - float2(34.0, 0.0));
        }

        float2 bc = floor((pq - float2(centerX - pSize * 6.0, pSize * 9.0)) / pSize);
        float inBtn = box2(bc, 1.0, 0.0, 10.0, 8.0) + box2(bc, 0.0, 1.0, 11.0, 7.0);
        float inBars = box2(bc, 3.0, 2.0, 4.0, 6.0) + box2(bc, 7.0, 2.0, 8.0, 6.0);

        float3 uiBoxCol = lerp(float3(0.325, 0.325, 0.34), float3(0.22, 0.11, 0.14), colorBlend);
        float3 uiIconCol = lerp(float3(0.985, 0.985, 0.985), float3(1.0, 0.93, 0.76), colorBlend);

        if (txtBit > 0.5) layer(acc, cover, lerp(uiBoxCol, uiIconCol, colorBlend), 0.96);
        if (inBtn > 0.5) layer(acc, cover, (inBars > 0.5) ? uiIconCol : uiBoxCol, 0.96);
    }

    // 13. Subtle Rounded Glass Frame Border
    float borderAlpha = smoothstep(-pSize * 1.1, -aa, dFrame) * frameMask;
    float3 borderCol = lerp(float3(0.78, 0.78, 0.80), lerp(themeAccent, float3(1.0, 0.88, 0.72), 0.5), colorBlend);
    layer(acc, cover, borderCol, borderAlpha * 0.70);

    return paint(acc / max(cover, 0.001), saturate(cover * frameMask));
}