Rainy Lo-fi Sanctuary

của Rinz, visualizer

Căn phòng anime lo-fi ấm cúng bên cửa sổ mưa đêm mờ ánh đèn thành phố, đèn bàn LED chữ L, dàn PC & loa 2 tầng đổi màu theo nhạc, mèo tam thể sưởi ấm và bể thủy sinh hòn non bộ bonsai cùng đàn cá Neon Tetra.

47 lượt tải Tải file, 57.6 KB
Cách cài, mã SHA-256 và mã nguồn

Bấm Áp dụng: MusicBar tự tải về, kiểm tra mã SHA-256 rồi mặc lên taskbar; có rồi thì mặc luôn. Cần MusicBar 1.8 trở lên.

SHA-256 96f3ac32f834790efc37e2f91a297a9471da1c5a1c506c8f2b4c53a06ce765c9

//! name: Rainy Lo-fi Sanctuary
//! author: Rinz
//! kind: visualizer
//! description: Warm anime rainy-night desk with L-shaped LED lamp, bokeh city window, app-synced ultrawide visualizer, dual-tier speakers, RGB PC, calico cat, and Neon Tetra bonsai aquascape

static const float USE_APP_COLOR = 1.0;

float hash1(float n)
{
    n = frac(n * 0.1031);
    n *= n + 33.33;
    n *= n + n;
    return frac(n);
}

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);
}

float2 rot(float2 p, float a)
{
    float c = cos(a), s = sin(a);
    return float2(c * p.x + s * p.y, -s * p.x + c * p.y);
}

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

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

float sdSegment(float2 p, float2 a, float2 b)
{
    float2 pa = p - a, ba = b - a;
    float h = saturate(dot(pa, ba) / max(dot(ba, ba), 1e-5));
    return length(pa - ba * h);
}

float sdTriangle(float2 p, float2 p0, float2 p1, float2 p2)
{
    float2 e0 = p1 - p0, e1 = p2 - p1, e2 = p0 - p2;
    float2 v0 = p - p0,  v1 = p - p1,  v2 = p - p2;
    float2 pq0 = v0 - e0 * saturate(dot(v0, e0) / max(dot(e0, e0), 1e-5));
    float2 pq1 = v1 - e1 * saturate(dot(v1, e1) / max(dot(e1, e1), 1e-5));
    float2 pq2 = v2 - e2 * saturate(dot(v2, e2) / max(dot(e2, e2), 1e-5));
    float s = sign(e0.x * e2.y - e0.y * e2.x);
    float2 d = min(min(float2(dot(pq0, pq0), s * (v0.x * e0.y - v0.y * e0.x)),
                       float2(dot(pq1, pq1), s * (v1.x * e1.y - v1.y * e1.x))),
                       float2(dot(pq2, pq2), s * (v2.x * e2.y - v2.y * e2.x)));
    return -sqrt(d.x) * sign(d.y);
}

float smin(float a, float b, float k)
{
    float h = saturate(0.5 + 0.5 * (b - a) / k);
    return lerp(b, a, h) - k * h * (1.0 - h);
}

void drawAnimeShape(inout float3 acc, inout float cover, float d, float3 baseCol, float3 shadeCol, float shadeMask, float3 inkCol, float aa, float inkW)
{
    float fillA = smoothstep(aa, -aa, d);
    if (fillA > 0.001)
    {
        float3 col = lerp(baseCol, shadeCol, saturate(shadeMask));
        layer(acc, cover, col, fillA);
    }
    float inkA = smoothstep(inkW + aa, inkW - aa, abs(d));
    if (inkA > 0.001)
    {
        layer(acc, cover, inkCol, inkA);
    }
}

void drawSpeaker(inout float3 acc, inout float cover, float2 q, float spkX, float deskY, float beatPulse, float3 accentCol, float3 warmRim, float3 inkCol, float aa, float inkW)
{
    float spkHalfH = 0.315;
    float2 pSpk = q - float2(spkX, deskY + spkHalfH);

    // Tang duoi: Thung loa bass lon (Low-tier Woofer Cabinet)
    float2 pLow = pSpk - float2(0.0, -0.155);
    float dLowBox = sdRoundBox(pLow, float2(0.245, 0.160), 0.026);
    float lowShade = max(step(0.09, pLow.x), step(pLow.y, -0.10));
    drawAnimeShape(acc, cover, dLowBox, float3(0.24, 0.18, 0.21), float3(0.11, 0.09, 0.12), lowShade, inkCol, aa, inkW);

    // Tang tren: Loa ve tinh mid-treble chong tren (Upper-tier Satellite Cabinet)
    float2 pTop = pSpk - float2(0.0, 0.162);
    float dTopBox = sdRoundBox(pTop, float2(0.228, 0.150), 0.024);
    float topShade = max(step(0.08, pTop.x), step(pTop.y, -0.10));
    drawAnimeShape(acc, cover, dTopBox, float3(0.26, 0.20, 0.23), float3(0.12, 0.10, 0.13), topShade, inkCol, aa, inkW);

    // Vien sang am hat tu ban vao mep loa
    float dAllBox = min(dLowBox, dTopBox);
    float rimEdge = smoothstep(0.036, 0.0, abs(dAllBox)) * step(dAllBox, 0.0) * step(pSpk.x, 0.02);
    layer(acc, cover, warmRim, rimEdge * 0.44);

    // Mat truoc tang duoi + Loa Bass lon
    float dLowBaffle = sdRoundBox(pLow, float2(0.192, 0.122), 0.018);
    layer(acc, cover, float3(0.08, 0.07, 0.10), smoothstep(aa, -aa, dLowBaffle));
    layer(acc, cover, inkCol, smoothstep(0.008 + aa, 0.008 - aa, abs(dLowBaffle)));

    float wooferR = 0.098 + 0.017 * beatPulse;
    float dWoof = length(pLow) - wooferR;
    drawAnimeShape(acc, cover, dWoof, float3(0.16, 0.14, 0.19), float3(0.07, 0.06, 0.10), smoothstep(0.02, 0.095, length(pLow)), inkCol, aa, 0.010);
    layer(acc, cover, float3(0.30, 0.25, 0.32), smoothstep(aa, -aa, length(pLow) - (0.034 + 0.006 * beatPulse)));
    layer(acc, cover, accentCol, smoothstep(0.016, 0.002, abs(dWoof + 0.013)) * (0.38 + 0.62 * beatPulse) * 0.96);

    // Mat truoc tang tren + Loa Mid & Treble
    float dTopBaffle = sdRoundBox(pTop, float2(0.175, 0.114), 0.016);
    layer(acc, cover, float3(0.08, 0.07, 0.10), smoothstep(aa, -aa, dTopBaffle));
    layer(acc, cover, inkCol, smoothstep(0.008 + aa, 0.008 - aa, abs(dTopBaffle)));

    float2 pMid = pTop - float2(0.0, -0.025);
    float midR = 0.062 + 0.010 * beatPulse;
    float dMid = length(pMid) - midR;
    drawAnimeShape(acc, cover, dMid, float3(0.16, 0.14, 0.19), float3(0.07, 0.06, 0.10), smoothstep(0.015, 0.06, length(pMid)), inkCol, aa, 0.009);
    layer(acc, cover, float3(0.28, 0.24, 0.30), smoothstep(aa, -aa, length(pMid) - 0.022));
    layer(acc, cover, accentCol, smoothstep(0.013, 0.002, abs(dMid + 0.010)) * (0.32 + 0.55 * beatPulse) * 0.85);

    float dTweet = length(pTop - float2(0.0, 0.072)) - 0.030;
    drawAnimeShape(acc, cover, dTweet, float3(0.22, 0.18, 0.24), float3(0.10, 0.09, 0.13), 0.4, inkCol, aa, 0.008);
}

// Nhieu khe da doc kieu van nui (tham khao ky thuat tao khoi ridge-fluting, render muot kieu anime)
float nonboRidgeNoise(float x, float y, float seed)
{
    float warp = sin(y * 14.0 + seed * 11.0) * 0.16;
    return sin(x * 18.0 + warp + seed * 7.3) + 0.45 * cos(x * 34.0 - y * 6.0 + seed * 19.1);
}

// Hon non bo thuy sinh tang bac & khe da go ghe tu nhien (anti-aliased, khong pixel hoa)
float sampleNonBo(float lx, float yRel, float halfW, float h, float lean, float seed, float aa, out float shade)
{
    shade = 0.0;
    if (yRel <= -aa || yRel > h * 1.18 || abs(lx) > halfW * 1.32) return 0.0;

    float t = saturate(yRel / max(h, 0.04));
    float talus = pow(max(1.0 - t, 1e-4), 1.50);
    // Bac da & khe lom go ghe hai ben suon nui
    float shelf = (0.032 * sin(t * 18.0 + seed * 5.0) + 0.018 * cos(t * 32.0 + seed * 2.1)) * (1.0 - t * 0.75);
    float crag = 0.022 * sin(yRel * 31.0 + seed * 13.0) + 0.013 * cos(yRel * 57.0 + seed * 5.0);
    float sideShift = lean * t * halfW * 0.24 + 0.018 * sin(t * 9.0 + seed * 3.7);

    float curHalfW = halfW * (0.16 + 0.84 * talus) + shelf + crag;
    float dSide = abs(lx - sideShift) - curHalfW;

    float nx = clamp(lx / max(halfW, 0.05), -1.0, 1.0);
    float p1 = (nx - lean) / 0.34;
    float p2 = (nx + lean * 1.2 + 0.38) / 0.26;
    float crestNoise = 0.042 * sin(nx * 11.0 + seed * 9.0) + 0.024 * cos(nx * 23.0 + seed * 3.0);
    float topH = h * saturate(0.22 + 0.74 * exp(-p1 * p1) + 0.38 * exp(-p2 * p2) + crestNoise);

    float dTop = yRel - topH;
    float dBot = -yRel;
    float dRock = max(dSide, max(dTop, dBot));
    float mask = smoothstep(aa, -aa, dRock);
    if (mask <= 0.001) return 0.0;

    float dFlute = nonboRidgeNoise(lx + 0.010, yRel, seed) - nonboRidgeNoise(lx - 0.010, yRel, seed);
    float dirLight = lerp(0.78, 0.24, smoothstep(-0.52, 0.62, nx));
    float strata = 0.09 * sin(yRel * 54.0 + lx * 14.0 + seed * 4.0);
    float topRim = smoothstep(0.034, 0.0, max(topH - yRel, 0.0));
    float ridgeRim = smoothstep(0.14, 0.72, dFlute) * smoothstep(0.45, -0.35, nx);

    shade = saturate(dirLight + dFlute * 0.25 + strata + topRim * 0.28 + ridgeRim * 0.18);
    return mask;
}

// Dan ca Neon Tetra nho nhan, vach xanh dien phat sang & duoi do ruby
void drawNeonTetra(inout float3 acc, inout float cover, float2 tp, float tankHalfW, float tAnim, float spd, float ph, float baseY, float fishScale, float3 inkCol, float aa)
{
    float arg = tAnim * spd + ph;
    float fx = sin(arg) * max(tankHalfW - 0.30, 0.35);
    float dir = (cos(arg) >= 0.0) ? 1.0 : -1.0;
    float fy = baseY + sin(arg * 1.9 + ph * 2.3) * 0.038;

    float2 fp = float2((tp.x - fx) * dir, tp.y - fy) / fishScale;
    if (abs(fp.x) < 0.15 && abs(fp.y) < 0.07)
    {
        float wag = sin(tAnim * 12.0 + ph * 3.5) * 0.009;
        float bx = fp.x / 0.062;
        float bodyProfile = 0.0175 * sqrt(saturate(1.0 - bx * bx)) * (0.62 + 0.42 * smoothstep(-0.90, 0.30, bx));
        float dBody = max(abs(fp.x) - 0.062, abs(fp.y) - bodyProfile) - 0.002;

        // Duoi che thanh manh trong suot
        float dTailTop = sdTriangle(fp, float2(-0.056,  0.001), float2(-0.105,  0.028 + wag), float2(-0.086,  0.002 + wag * 0.4));
        float dTailBot = sdTriangle(fp, float2(-0.056, -0.001), float2(-0.086, -0.002 + wag * 0.4), float2(-0.105, -0.028 + wag));
        float dDorsal  = sdTriangle(fp, float2(-0.018, 0.011), float2(0.006, 0.012), float2(-0.024, 0.029));
        float dFins = min(min(dTailTop, dTailBot), dDorsal);

        float fishAA = aa / fishScale;
        float bodyMask = smoothstep(fishAA, -fishAA, dBody);
        float finMask  = smoothstep(fishAA, -fishAA, dFins) * (1.0 - bodyMask);

        if (finMask > 0.001)
        {
            float3 finCol = lerp(float3(0.86, 0.36, 0.36), float3(0.74, 0.94, 0.96), smoothstep(-0.06, -0.10, fp.x));
            layer(acc, cover, finCol, finMask * 0.62);
        }

        if (bodyMask > 0.001)
        {
            // Bung bac -> lung olive -> vach xanh dien neon doc than -> dai do ruby nua sau
            float3 bellyCol  = float3(0.88, 0.94, 0.96);
            float3 backCol   = float3(0.18, 0.30, 0.36);
            float3 neonCyan  = float3(0.18, 0.98, 1.00);
            float3 rubyRed   = float3(0.98, 0.16, 0.24);

            float yNorm = saturate((fp.y + 0.017) / 0.034);
            float3 fCol = lerp(bellyCol, backCol, smoothstep(0.48, 0.92, yNorm));

            float redBand = smoothstep(0.008, -0.016, fp.x) * smoothstep(0.005, -0.004, fp.y);
            fCol = lerp(fCol, rubyRed, redBand * 0.95);

            float neonStripe = smoothstep(0.0065, 0.0012, abs(fp.y - 0.0032)) * smoothstep(0.045, 0.025, fp.x) * smoothstep(-0.054, -0.036, fp.x);
            fCol = lerp(fCol, neonCyan, neonStripe * 0.98);

            layer(acc, cover, fCol, bodyMask * 0.96);
        }

        layer(acc, cover, inkCol, smoothstep(0.0028 + fishAA, 0.0028 - fishAA, abs(dBody)) * 0.38);

        float dEye = length(fp - float2(0.038, 0.004)) - 0.0052;
        layer(acc, cover, inkCol, smoothstep(fishAA, -fishAA, dEye));
        float dEyeGlint = length(fp - float2(0.0395, 0.0055)) - 0.0020;
        layer(acc, cover, float3(0.70, 0.98, 1.00), smoothstep(fishAA, -fishAA, dEyeGlint) * 0.90);
    }
}

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

    float live = saturate(playing);
    float vol = saturate(level);
    float beatVal = saturate(beat);
    float beatPulse = beatVal * (0.25 + 0.75 * live);
    float tAnim = fmod(time, 3600.0);

    // Phong am cung co do sang vua phai (Warm Lo-fi Interior) + Nguon sang tuong phan
    float3 cInk        = float3(0.06, 0.04, 0.06);
    float3 cWallTop    = float3(0.205, 0.152, 0.162);
    float3 cWallBot    = float3(0.135, 0.098, 0.112);
    float3 cAmber      = float3(1.00, 0.72, 0.34);
    float3 cAmberDeep  = float3(0.95, 0.52, 0.20);
    float3 cEmerald    = float3(0.16, 0.78, 0.58);
    float3 cWoodLight  = float3(0.47, 0.30, 0.21);
    float3 cWoodMid    = float3(0.32, 0.20, 0.15);
    float3 cWoodDark   = float3(0.19, 0.12, 0.12);

    // Cum may tinh doi mau hoan toan theo app
    float3 appA = lerp(float3(0.36, 0.80, 0.90), max(colorA.rgb, float3(0.18, 0.18, 0.22)), USE_APP_COLOR);
    float3 appB = lerp(float3(0.56, 0.44, 0.88), max(colorB.rgb, float3(0.14, 0.14, 0.20)), USE_APP_COLOR);
    float3 appC = lerp(cAmber,                   max(colorC.rgb, float3(0.24, 0.20, 0.20)), USE_APP_COLOR);

    float deskY = 0.095;

    float sidePad = min(0.45, aspect * 0.035);
    float centerX = aspect * 0.5;
    float monHalfW = clamp(aspect * 0.130, 1.25, 3.15);
    float monX = centerX - 0.50;
    float spkLX = monX - monHalfW - 0.44;
    float spkRX = monX + monHalfW + 0.44;
    float pcX = spkRX + 0.68;
    float clusterL = spkLX - 0.27;
    float clusterR = pcX + 0.30;

    float leftSpace = max(clusterL - sidePad, 1.5);
    float winHalfW = clamp(leftSpace * 0.30, 0.85, 2.05);
    float winX = clamp(sidePad + leftSpace * 0.28, sidePad + winHalfW + 0.15, max(sidePad + winHalfW + 0.15, clusterL - winHalfW - 0.62));

    float rightSpace = max(aspect - clusterR - sidePad, 2.2);
    float tankHalfW = clamp(rightSpace * 0.32, 0.95, 2.00);
    float tankX = aspect - sidePad - tankHalfW;

    float catZoneStart = clusterR + 0.42;
    float catZoneEnd = tankX - tankHalfW - 0.40;
    float catX = clamp((catZoneStart + catZoneEnd) * 0.48, catZoneStart, max(catZoneStart, catZoneEnd));

    float gapLeft = clusterL - (winX + winHalfW);
    float hasLamp = step(0.58, gapLeft);
    float lampX = (hasLamp > 0.5) ? lerp(winX + winHalfW, clusterL, 0.55) : (spkLX - 0.48);

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

    // ---------------------------------------------------------
    // 1. TUONG PHONG TOI & CAC NGUON SANG MANH ME HON
    // ---------------------------------------------------------
    float3 wallCol = lerp(cWallBot, cWallTop, saturate((q.y - deskY) / (1.0 - deskY)));

    if (q.y >= deskY && q.y < 0.27)
    {
        float panelRib = 0.95 + 0.05 * sin(q.x * 16.0);
        float3 wainscot = float3(0.175, 0.126, 0.132) * panelRib;
        float rail = smoothstep(0.015, 0.003, abs(q.y - 0.255));
        wallCol = lerp(wallCol, wainscot, smoothstep(0.26 + aa, 0.25 - aa, q.y));
        wallCol = lerp(wallCol, float3(0.28, 0.20, 0.20), rail * 0.85);
    }

    // Nguon sang 1 (Lanh): Anh trang / bokeh thanh pho hat tu cua so trai
    float winDist = length((q - float2(winX, 0.56)) * float2(0.95 / max(winHalfW, 1.0), 1.3));
    wallCol += float3(0.10, 0.17, 0.36) * exp(-winDist * 1.30) * 0.88;

    // Nguon sang 2 (Am): Den ban LED chu L toa anh vang am ra tuong
    float lampDist = length((q - float2(lampX + 0.04, 0.50)) * float2(0.68, 1.05));
    wallCol += cAmberDeep * exp(-lampDist * 1.02) * 0.54;
    wallCol += cAmber * exp(-length((q - float2(lampX + 0.06, 0.56)) * float2(0.95, 1.35)) * 1.8) * 0.50;

    // Nguon sang 3 (App): Anh sang man hinh desktop & PC hat manh ra tuong
    float monDist = length((q - float2(monX, 0.56)) * float2(0.90 / max(monHalfW, 1.0), 1.35));
    wallCol += lerp(appB, appA, 0.5) * exp(-monDist * 1.55) * (0.36 + 0.22 * vol + 0.14 * beatPulse);

    // Nguon sang 4 (Ngoc luc bao): Anh sang be ca fade muot tu mep kinh ra tuong (khong tao dai cung)
    float dTankWall = max(sdRoundBox(q - float2(tankX, 0.545), float2(tankHalfW, 0.325), 0.018), 0.0);
    float tankFade = exp(-dTankWall * 4.2) * smoothstep(0.65, 0.0, dTankWall);
    wallCol += cEmerald * tankFade * (0.32 + 0.05 * beatPulse);

    layer(acc, cover, wallCol, 0.99);

    // ---------------------------------------------------------
    // 2. DEN BAN LED CHU L HIEN DAI (Theo anh tham khao)
    // ---------------------------------------------------------
    [branch] if (hasLamp > 0.5 && abs(q.x - lampX) < 0.55 && q.y >= deskY - 0.01)
    {
        float2 lp = q - float2(lampX, deskY);
        float2 armTip = float2(0.30, 0.62);
        float2 corner = float2(-0.18, 0.53);
        float2 stemBot = float2(-0.18, 0.02);

        // Quang sang vang am hat xuong tu thanh LED ngang & doc (huong vao trong ban)
        float dArmLight = sdSegment(lp, armTip + float2(-0.02, -0.01), corner + float2(0.02, -0.01));
        float dStemLight = sdSegment(lp, corner + float2(0.012, -0.02), float2(-0.168, 0.12));
        float ledDist = min(dArmLight, dStemLight);

        float coneDx = (lp.x - 0.06) / max(0.12 + (0.55 - lp.y) * 0.70, 0.10);
        float coneWash = exp(-(coneDx * coneDx) * 1.3) * smoothstep(0.68, 0.45, lp.y) * smoothstep(-0.03, 0.16, lp.y);
        layer(acc, cover, cAmber, coneWash * 0.30);
        layer(acc, cover, float3(1.00, 0.84, 0.52), exp(-ledDist * 10.5) * 0.55);

        // De den hinh chu nhat mong dat tren ban
        float dBase = sdRoundBox(lp - float2(-0.10, 0.012), float2(0.145, 0.013), 0.005);
        drawAnimeShape(acc, cover, dBase, float3(0.14, 0.11, 0.12), float3(0.06, 0.05, 0.07), 0.4, cInk, aa, 0.008);

        // Thanh LED sang ruc chay doc mep trong than & tay den (nam duoi khung den)
        float dLedCore = min(
            sdSegment(lp, armTip + float2(-0.018, -0.014), corner + float2(0.014, -0.014)),
            sdSegment(lp, corner + float2(0.014, -0.014), float2(-0.166, 0.132))
        ) - 0.0085;
        layer(acc, cover, float3(1.00, 0.96, 0.84), smoothstep(aa, -aa, dLedCore));

        // Khop tru den ngan o chan (che phan cuoi thanh LED)
        float dCollar = sdRoundBox(lp - float2(-0.18, 0.075), float2(0.022, 0.062), 0.006);
        drawAnimeShape(acc, cover, dCollar, float3(0.16, 0.13, 0.14), float3(0.07, 0.06, 0.08), step(-0.185, lp.x), cInk, aa, 0.008);

        // Khung kim loai den manh bao ben ngoai & dau mut phai thanh LED
        float dFrameArm = sdSegment(lp, armTip, corner) - 0.010;
        float dFrameStem = sdSegment(lp, corner, float2(-0.18, 0.12)) - 0.010;
        float dTipCap = sdSegment(lp, armTip + float2(-0.004, 0.002), armTip + float2(-0.004, -0.021)) - 0.007;
        float dLampFrame = min(min(dFrameArm, dFrameStem), dTipCap);
        layer(acc, cover, float3(0.10, 0.08, 0.10), smoothstep(aa, -aa, dLampFrame));
    }

    // ---------------------------------------------------------
    // 3. CUA SO DEM MUA KHONG KHUNG: THANH PHO BOKEH, VET MUA MANH & CHAU SEN DA
    // ---------------------------------------------------------
    float winY = 0.58;
    float winHalfH = 0.34;
    float2 wp = q - float2(winX, winY);
    [branch] if (abs(wp.x) < winHalfW + 0.12 && abs(wp.y) < winHalfH + 0.12)
    {
        float dGlass = sdRoundBox(wp, float2(winHalfW, winHalfH), 0.022);
        float glassMask = smoothstep(aa, -aa, dGlass);

        if (glassMask > 0.001)
        {
            float skyT = saturate((wp.y + winHalfH) / (2.0 * winHalfH));
            float3 nightSky = lerp(float3(0.085, 0.15, 0.30), float3(0.024, 0.042, 0.105), skyT);
            nightSky += float3(0.06, 0.11, 0.24) * exp(-abs(wp.y + 0.12) * 4.5) * 0.55;
            layer(acc, cover, nightSky, glassMask);

            float cityX = q.x * 1.55;
            float bId1 = floor(cityX);
            float bH1 = -0.13 + 0.18 * hash1(bId1 * 23.7 + 3.0);
            float cityFar = smoothstep(bH1 + 0.030, bH1 - 0.030, wp.y);
            layer(acc, cover, float3(0.035, 0.068, 0.15), cityFar * glassMask * 0.90);

            float cityX2 = q.x * 2.3 + 0.4;
            float bId2 = floor(cityX2);
            float bLoc2 = frac(cityX2);
            float bSeed2 = hash1(bId2 * 41.3 + 9.0);
            float hasB = step(0.12, bLoc2) * step(bLoc2, 0.88);
            float bH2 = -0.17 + 0.20 * bSeed2;
            float cityNear = smoothstep(bH2 + 0.022, bH2 - 0.022, wp.y) * hasB;
            layer(acc, cover, float3(0.022, 0.044, 0.105), cityNear * glassMask * 0.94);

            // Anh den thanh pho bokeh sang ro & lung linh hon
            float2 bkGrid = float2(q.x * 3.8, wp.y * 7.5);
            float bkId = hash1(floor(bkGrid.x) * 31.1 + floor(bkGrid.y) * 67.3);
            if (bkId > 0.54 && wp.y < 0.05)
            {
                float2 bkPos = frac(bkGrid) - 0.5;
                float bkGlow = exp(-dot(bkPos, bkPos) * 9.5);
                float3 bkCol = float3(1.00, 0.74, 0.36);
                if (bkId > 0.84)      bkCol = float3(0.38, 0.88, 0.96);
                else if (bkId > 0.70) bkCol = float3(0.95, 0.48, 0.68);
                float flicker = 0.78 + 0.22 * sin(tAnim * 1.8 + bkId * 25.0);
                layer(acc, cover, bkCol, bkGlow * flicker * glassMask * 0.72);
            }

            // Mua roi cheo nhe ngoai troi dem (manh va diu hon)
            float2 rainQ = rot(q, -0.22);
            [unroll]
            for (int rL = 0; rL < 2; rL++)
            {
                float fR = (float)rL;
                float rW = 0.28 - fR * 0.06;
                float rH = 0.48 - fR * 0.10;
                float gx = (rainQ.x + tAnim * (0.85 - fR * 0.28)) / rW;
                float gy = (rainQ.y + tAnim * (3.90 - fR * 1.15)) / rH;
                float rId = hash1(floor(gx) * 29.1 + floor(gy) * 73.9 + fR * 11.0);
                if (rId > 0.48)
                {
                    float2 cellP = (float2(frac(gx), frac(gy)) - 0.5) * float2(rW, rH);
                    float drop = smoothstep(0.0055 - fR * 0.0015, 0.0008, abs(cellP.x))
                               * smoothstep(0.095 - fR * 0.025, 0.0, abs(cellP.y));
                    layer(acc, cover, float3(0.62, 0.82, 0.98), drop * glassMask * (0.44 - fR * 0.14));
                }
            }

            // Hat mua dong tren kinh & vai giot truot cham rai chan thuc (it nhung tinh te)
            float trGridX = wp.x * 3.6;
            float trCol = floor(trGridX);
            float trId = hash1(trCol * 17.9 + 5.0);
            if (trId > 0.68)
            {
                float meander = 0.042 * sin(wp.y * 16.0 + trId * 18.0) + 0.022 * cos(wp.y * 29.0 + trId * 7.0);
                float trLocX = (frac(trGridX) - 0.5) * 0.28 + meander * 0.28;
                float trPhase = frac(wp.y * 0.68 + tAnim * (0.14 + 0.10 * trId) + trId * 3.1);
                float trDy = (trPhase - 0.12) * 1.45;

                // Giot nuoc dau giot co bong phan chieu va diem sang day giot
                float headDist = length(float2(trLocX * 1.35, trDy * 0.90));
                float headBead = smoothstep(0.015, 0.004, headDist);
                float headGlint = smoothstep(0.007, 0.001, length(float2(trLocX * 1.35, trDy * 0.90 + 0.004)));
                float headRim = smoothstep(0.017, 0.010, headDist) * (1.0 - headBead);

                // Vet nuoc manh mo uon luon phia sau giot
                float trStreak = smoothstep(0.006, 0.001, abs(trLocX)) * smoothstep(0.55, 0.12, trPhase) * step(0.12, trPhase);

                layer(acc, cover, float3(0.06, 0.10, 0.18), headRim * 0.45 * glassMask);
                layer(acc, cover, float3(0.64, 0.84, 0.98), (headBead * 0.42 + trStreak * 0.18) * glassMask);
                layer(acc, cover, float3(0.92, 0.97, 1.00), headGlint * 0.85 * glassMask);
            }

            // Vai hat suong nho li ti bam tinh tren mat kinh
            float2 mistCell = wp * float2(14.0, 11.0);
            float mSeed = hash1(floor(mistCell.x) * 31.7 + floor(mistCell.y) * 53.3);
            if (mSeed > 0.90)
            {
                float2 mOff = float2(hash1(mSeed * 19.1) - 0.5, hash1(mSeed * 43.7) - 0.5) * 0.55;
                float mDist = length(frac(mistCell) - 0.5 - mOff);
                float mDrop = smoothstep(0.11, 0.03, mDist);
                float mGlint = smoothstep(0.06, 0.01, length(frac(mistCell) - 0.5 - mOff - float2(0.0, -0.025)));
                layer(acc, cover, float3(0.60, 0.80, 0.96), mDrop * 0.22 * glassMask);
                layer(acc, cover, float3(0.90, 0.96, 1.00), mGlint * 0.35 * glassMask);
            }

            float recessSh = smoothstep(0.06, 0.0, winHalfH - wp.y) * 0.36 + smoothstep(0.05, 0.0, winHalfW + wp.x) * 0.26;
            layer(acc, cover, cInk, saturate(recessSh) * glassMask);

            // Rem cua toi mem o hai mep cua so
            float curEdge = winHalfW - abs(wp.x);
            float curCurve = 0.15 + 0.04 * sin(wp.y * 8.0 + tAnim * 1.1) * smoothstep(0.28, -0.28, wp.y);
            float curMask = smoothstep(curCurve + aa, curCurve - aa, curEdge) * glassMask;
            if (curMask > 0.001)
            {
                float fold = 0.84 + 0.16 * sin(curEdge * 65.0);
                float3 curCol = float3(0.14, 0.13, 0.20) * fold + float3(0.12, 0.18, 0.30) * smoothstep(0.15, 0.02, curEdge);
                layer(acc, cover, curCol, curMask * 0.92);
                layer(acc, cover, cInk, smoothstep(0.009 + aa, 0.009 - aa, abs(curEdge - curCurve)) * glassMask * 0.75);
            }

            // Chau cay sen da o goc duoi ben phai cua so
            float2 pSen = (wp - float2(winHalfW - 0.34, -winHalfH + 0.005)) / 1.05;
            if (abs(pSen.x) < 0.24 && pSen.y > -0.02 && pSen.y < 0.34)
            {
                float2 rp = pSen - float2(0.0, 0.125);
                float dPetalC  = sdTriangle(rp, float2(-0.036, -0.01), float2(0.036, -0.01), float2(0.0, 0.145)) - 0.018;
                float dPetalL1 = sdTriangle(rot(rp - float2(-0.020, -0.006),  0.48), float2(-0.036, -0.01), float2(0.036, -0.01), float2(0.0, 0.132)) - 0.017;
                float dPetalR1 = sdTriangle(rot(rp - float2( 0.020, -0.006), -0.48), float2(-0.036, -0.01), float2(0.036, -0.01), float2(0.0, 0.132)) - 0.017;
                float dPetalL2 = sdTriangle(rot(rp - float2(-0.038, -0.014),  0.94), float2(-0.035, -0.01), float2(0.035, -0.01), float2(0.0, 0.118)) - 0.016;
                float dPetalR2 = sdTriangle(rot(rp - float2( 0.038, -0.014), -0.94), float2(-0.035, -0.01), float2(0.035, -0.01), float2(0.0, 0.118)) - 0.016;

                float dPot = sdRoundBox(pSen - float2(0.0, 0.058), float2(0.088, 0.056), 0.014);
                float dRim = sdRoundBox(pSen - float2(0.0, 0.112), float2(0.100, 0.016), 0.007);
                float dPotAll = min(dPot, dRim);

                float dLeaves = min(dPetalC, min(min(dPetalL1, dPetalR1), min(dPetalL2, dPetalR2)));
                float dSenTot = min(dPotAll, dLeaves);

                layer(acc, cover, cInk, smoothstep(0.012, 0.002, dSenTot) * glassMask);

                float tipPink = smoothstep(0.080, 0.145, length(rp));
                float leafLight = smoothstep(0.05, -0.06, rp.x);
                float3 senCol = lerp(float3(0.09, 0.28, 0.29), float3(0.22, 0.56, 0.52), leafLight * 0.85);
                senCol = lerp(senCol, float3(0.62, 0.46, 0.56), tipPink * 0.55);

                layer(acc, cover, senCol * 0.80, smoothstep(0.002, -0.002, min(dPetalL2, dPetalR2)) * glassMask);
                layer(acc, cover, senCol * 0.92, smoothstep(0.002, -0.002, min(dPetalL1, dPetalR1)) * glassMask);
                layer(acc, cover, senCol * 1.04, smoothstep(0.002, -0.002, dPetalC) * glassMask);

                float pShade = smoothstep(0.01, 0.075, pSen.x);
                float3 potCol = lerp(float3(0.50, 0.30, 0.25), float3(0.26, 0.15, 0.17), pShade * 0.78);
                layer(acc, cover, potCol, smoothstep(0.002, -0.002, dPot) * glassMask);
                layer(acc, cover, potCol * 1.08, smoothstep(0.002, -0.002, dRim) * glassMask);
            }
        }

        layer(acc, cover, cInk, smoothstep(0.011 + aa, 0.011 - aa, abs(dGlass)) * 0.92);
    }

    // ---------------------------------------------------------
    // 4. BE CA THUY SINH: DA SEIRYU IWAGUMI + CA CANH DUOI XOE THUC HON
    // ---------------------------------------------------------
    float standTop = deskY + 0.125;
    float tankY = 0.545;
    float tankHalfH = 0.325;
    [branch] if (abs(q.x - tankX) < tankHalfW + 0.24 && q.y >= deskY - 0.02)
    {
        float2 pStand = q - float2(tankX, (deskY + standTop) * 0.5);
        float dStand = sdRoundBox(pStand, float2(tankHalfW + 0.04, (standTop - deskY) * 0.5), 0.016);
        float standShade = max(step(tankHalfW - 0.15, pStand.x), step(pStand.y, -0.02));
        drawAnimeShape(acc, cover, dStand, cWoodLight, cWoodDark, standShade, cInk, aa, inkW);
        layer(acc, cover, cInk, smoothstep(0.007, 0.002, abs(pStand.x)) * smoothstep(aa, -aa, dStand) * 0.75);

        float2 tp = q - float2(tankX, tankY);
        float dTank = sdRoundBox(tp, float2(tankHalfW, tankHalfH), 0.018);
        float tankMask = smoothstep(aa, -aa, dTank);

        // Quang sang nhe quanh vien kinh (fade tat hoan toan truoc ria vung [branch])
        float dTankOut = max(dTank, 0.0);
        float aura = exp(-dTankOut * 11.0) * smoothstep(0.20, 0.0, dTankOut) * (0.20 + 0.05 * beatPulse);
        layer(acc, cover, cEmerald, aura * (1.0 - tankMask * 0.6));

        if (tankMask > 0.001)
        {
            float waterT = saturate((tp.y + tankHalfH) / (2.0 * tankHalfH));
            float3 waterCol = lerp(float3(0.02, 0.14, 0.21), float3(0.10, 0.40, 0.44), pow(max(waterT, 1e-4), 0.78));

            // Tia sang xien & quang sang roi giua khe nui (diu nhe vung sat mat nuoc)
            float topDamp = 0.45 + 0.55 * smoothstep(0.32, 0.04, tp.y);
            float rays = pow(max(0.5 + 0.5 * sin(tp.x * 4.6 - tp.y * 2.5 + tAnim * 1.1), 1e-4), 2.6) * smoothstep(-0.24, 0.28, tp.y);
            float canyonShaft = exp(-((tp.x + 0.03) * 2.1) * ((tp.x + 0.03) * 2.1)) * smoothstep(-0.30, 0.25, tp.y);
            waterCol += float3(0.26, 0.78, 0.68) * (rays * (0.24 + 0.08 * vol) + canyonShaft * 0.18) * topDamp;
            layer(acc, cover, waterCol, tankMask);

            // Lop cay thuy sinh hau canh hai ria (Vallisneria xanh tham)
            float bgPlantX = tp.x * 6.8;
            float bgIdx = floor(bgPlantX);
            float bgSeed = hash1(bgIdx * 19.3 + 4.0);
            if (bgSeed > 0.28 && abs(tp.x) > tankHalfW * 0.44)
            {
                float bladeWave = sin(tp.y * 11.0 - tAnim * 1.9 + bgIdx * 1.7) * 0.10;
                float bladeDist = abs(frac(bgPlantX) - 0.5 + bladeWave);
                float bladeH = -tankHalfH + 0.18 + 0.38 * bgSeed;
                float inBlade = smoothstep(0.18, 0.06, bladeDist) * smoothstep(bladeH + 0.02, bladeH - 0.02, tp.y);
                float3 bgPlCol = lerp(float3(0.05, 0.28, 0.24), float3(0.22, 0.72, 0.48), saturate((tp.y + tankHalfH) * 1.8));
                layer(acc, cover, bgPlCol, inBlade * tankMask * 0.85);
            }

            // Bui cay thuy sinh la do Rotala / Ludwigia tao diem nhan tuong phan ruc ro sau khe da
            float redZoneL = exp(-((tp.x + tankHalfW * 0.24) * 3.8) * ((tp.x + tankHalfW * 0.24) * 3.8));
            float redZoneR = exp(-((tp.x - tankHalfW * 0.55) * 4.2) * ((tp.x - tankHalfW * 0.55) * 4.2));
            if (redZoneL > 0.08 || redZoneR > 0.08)
            {
                float rStemX = tp.x * 11.5;
                float rIdx = floor(rStemX);
                float rSeed = hash1(rIdx * 23.1 + 9.0);
                float rSway = sin(tp.y * 10.0 - tAnim * 1.7 + rIdx * 1.9) * 0.12;
                float leafW = 0.22 + 0.12 * sin(tp.y * 38.0 + rIdx * 2.3);
                float inRedStem = smoothstep(leafW + 0.06, leafW - 0.05, abs(frac(rStemX) - 0.5 + rSway));
                float maxRedH = -tankHalfH + 0.22 + 0.26 * rSeed * max(redZoneL, redZoneR);
                float redMask = inRedStem * smoothstep(maxRedH + 0.02, maxRedH - 0.03, tp.y) * smoothstep(-tankHalfH + 0.05, -tankHalfH + 0.14, tp.y) * tankMask;
                float redH = saturate((tp.y + tankHalfH - 0.06) / 0.36);
                float3 redCol = lerp(float3(0.45, 0.08, 0.14), float3(0.95, 0.36, 0.28), redH);
                redCol = lerp(redCol, float3(1.00, 0.58, 0.40), smoothstep(0.65, 1.0, redH) * 0.65);
                layer(acc, cover, redCol, redMask * 0.94);
            }

            // Hon non bo thuy sinh kho lon (cao toi ~80% be) & tach mau da trung tinh am khoi nuoc xanh
            float yNb = tp.y - (-tankHalfH + 0.066);

            // Lop nui hau canh mo tao chieu sau khe nui
            float shdBg1 = 0.0, shdBg2 = 0.0;
            float mBg1 = sampleNonBo(tp.x + tankHalfW * 0.15, yNb, 0.26, 0.35, -0.14, 7.1, aa, shdBg1);
            float mBg2 = sampleNonBo(tp.x - tankHalfW * 0.14, yNb, 0.22, 0.29,  0.18, 3.3, aa, shdBg2);
            float mBg = saturate(max(mBg1, mBg2)) * tankMask;
            if (mBg > 0.001)
            {
                float shdBg = (mBg1 >= mBg2) ? shdBg1 : shdBg2;
                float3 bgStone = lerp(float3(0.14, 0.22, 0.26), float3(0.28, 0.42, 0.44), shdBg);
                layer(acc, cover, lerp(bgStone, waterCol, 0.38), mBg);
            }

            // Lop chinh: Dinh chu Oyaishi cao be the ben trai + Hon phu lech phai + Nui doi ben phai
            float shd1 = 0.0, shd2 = 0.0, shd3 = 0.0;
            float m1 = sampleNonBo(tp.x + tankHalfW * 0.42, yNb, 0.31, 0.49, -0.22, 1.3, aa, shd1);
            float m2 = sampleNonBo(tp.x + tankHalfW * 0.19, yNb, 0.17, 0.27,  0.28, 4.7, aa, shd2);
            float m3 = sampleNonBo(tp.x - tankHalfW * 0.40, yNb, 0.25, 0.39,  0.18, 8.9, aa, shd3);

            float rockMask = saturate(max(m1, max(m2, m3))) * tankMask;
            if (rockMask > 0.001)
            {
                float shdHero = (m1 >= m2 && m1 >= m3) ? shd1 : ((m2 >= m3) ? shd2 : shd3);
                float3 rDeep   = float3(0.17, 0.16, 0.19);
                float3 rMid    = float3(0.37, 0.36, 0.35);
                float3 rBright = float3(0.62, 0.59, 0.53);
                float3 rRim    = float3(0.86, 0.84, 0.76);

                float3 rockCol = (shdHero < 0.42) ? lerp(rDeep, rMid, shdHero / 0.42)
                               : ((shdHero < 0.76) ? lerp(rMid, rBright, (shdHero - 0.42) / 0.34)
                                                   : lerp(rBright, rRim, (shdHero - 0.76) / 0.24));
                rockCol = lerp(rockCol, waterCol, 0.10);

                // Reu xanh non bam tren cac bac suon da hon non bo
                float ledgeMoss = smoothstep(0.026, 0.005, abs(yNb - 0.185)) * step(abs(tp.x + tankHalfW * 0.42), 0.17)
                                + smoothstep(0.022, 0.005, abs(yNb - 0.125)) * step(abs(tp.x - tankHalfW * 0.40), 0.13);
                rockCol = lerp(rockCol, float3(0.28, 0.76, 0.42), saturate(ledgeMoss) * 0.68);

                layer(acc, cover, rockCol, rockMask);
            }

            // Cay Bonsai thuy sinh nghe thuat: nhanh go uon mem mai & cum tan reu bong benh tu nhien
            float2 bRoot  = float2(-tankHalfW * 0.33, -tankHalfH + 0.220);
            float2 bKnee  = float2(-tankHalfW * 0.26, -tankHalfH + 0.285);
            float2 bElbow = float2(-tankHalfW * 0.19, -tankHalfH + 0.320);
            float2 bTipU  = float2(-tankHalfW * 0.24, -tankHalfH + 0.375);
            float2 bTipR  = float2(-tankHalfW * 0.10, -tankHalfH + 0.355);
            float2 bTwig  = float2(-tankHalfW * 0.15, -tankHalfH + 0.305);
            float dTrunk1 = sdSegment(tp, bRoot, bKnee)   - lerp(0.024, 0.016, saturate((tp.y - bRoot.y) / max(bKnee.y - bRoot.y, 0.04)));
            float dTrunk2 = sdSegment(tp, bKnee, bElbow)  - lerp(0.016, 0.011, saturate((tp.x - bKnee.x) / max(bElbow.x - bKnee.x, 0.04)));
            float dTrunk3 = sdSegment(tp, bElbow, bTipR)  - 0.008;
            float dTrunk4 = sdSegment(tp, bKnee, bTipU)   - 0.009;
            float dTrunk5 = sdSegment(tp, bElbow, bTwig)  - 0.007;
            float dBonsaiWood = min(min(dTrunk1, dTrunk2), min(dTrunk3, min(dTrunk4, dTrunk5)));
            drawAnimeShape(acc, cover, dBonsaiWood, float3(0.42, 0.24, 0.16), float3(0.22, 0.12, 0.09), step(tp.y, bKnee.y), float3(0.10, 0.06, 0.05), aa, 0.0035);

            // Tan reu Bonsai mem mai bang nhieu khoi tron hoa quyen smin (khong vien den cung)
            float2 cU = bTipU + float2(-0.015, 0.018);
            float dCloudU = smin(
                length((tp - cU) * float2(0.85, 1.25)) - 0.052,
                smin(length((tp - (cU + float2(-0.045, -0.010))) * float2(0.95, 1.30)) - 0.042,
                     length((tp - (cU + float2( 0.042, -0.006))) * float2(0.95, 1.30)) - 0.040, 0.025),
                0.025);

            float2 cR = bTipR + float2(0.015, 0.012);
            float dCloudR = smin(
                length((tp - cR) * float2(0.82, 1.30)) - 0.054,
                smin(length((tp - (cR + float2(-0.048, -0.008))) * float2(0.95, 1.35)) - 0.040,
                     length((tp - (cR + float2( 0.048, -0.010))) * float2(0.95, 1.35)) - 0.038, 0.025),
                0.025);

            float dCloudL = length((tp - (bTwig + float2(0.015, -0.006))) * float2(0.88, 1.35)) - 0.038;
            float dCanopy = smin(dCloudU, min(dCloudR, dCloudL), 0.018);
            float canopyMask = smoothstep(aa * 1.4, -aa * 1.4, dCanopy) * tankMask;
            if (canopyMask > 0.001)
            {
                float dapple = 0.5 + 0.5 * sin(tp.x * 92.0 + sin(tp.y * 78.0)) * cos(tp.y * 84.0);
                float domeLight = saturate((tp.y - (bTwig.y - 0.03)) / 0.14);
                float3 mossShad  = float3(0.10, 0.36, 0.22);
                float3 mossMid   = float3(0.24, 0.66, 0.36);
                float3 mossCrown = float3(0.50, 0.90, 0.44);
                float3 canCol = lerp(mossShad, mossMid, smoothstep(0.15, 0.68, domeLight));
                canCol = lerp(canCol, mossCrown, smoothstep(0.55, 0.98, domeLight) * (0.45 + 0.55 * dapple));
                layer(acc, cover, canCol, canopyMask);
                // Vien la mem mong tu nhien phia duoi tan
                layer(acc, cover, float3(0.07, 0.24, 0.15), smoothstep(0.004 + aa, 0.004 - aa, abs(dCanopy)) * tankMask * 0.42);
            }

            // Vai vien da cuoi sang nhe hai ben chan non bo
            float dPebL = length((tp - float2(-tankHalfW * 0.65, -tankHalfH + 0.074)) * float2(0.82, 1.3)) - 0.038;
            float dPebR = length((tp - float2( tankHalfW * 0.58, -tankHalfH + 0.070)) * float2(0.80, 1.35)) - 0.034;
            float dPebs = min(dPebL, dPebR);
            drawAnimeShape(acc, cover, dPebs, float3(0.54, 0.52, 0.48), float3(0.28, 0.27, 0.28), step(yNb, 0.014), float3(0.14, 0.15, 0.17), aa, 0.005);

            // Bui reu & co trung canh ven chan nui
            float bush1 = length((tp - float2(-tankHalfW * 0.56, -tankHalfH + 0.084)) * float2(0.82, 1.35)) - 0.072;
            float bush2 = length((tp - float2( tankHalfW * 0.50, -tankHalfH + 0.082)) * float2(0.82, 1.35)) - 0.068;
            float dBushes = min(bush1, bush2);
            drawAnimeShape(acc, cover, dBushes, float3(0.34, 0.82, 0.44), float3(0.12, 0.44, 0.28), step(tp.y, -tankHalfH + 0.092), float3(0.08, 0.22, 0.16), aa, 0.005);

            // Tham co xanh hai ben & Con duong cat trang kem uon luon giua khe nui
            float valleyDip = -0.014 * exp(-((tp.x + 0.02) * 3.0) * ((tp.x + 0.02) * 3.0));
            float subTop = -tankHalfH + 0.074 + 0.018 * sin(tp.x * 2.3 + 0.8) + valleyDip;
            float inSub = smoothstep(subTop + aa, subTop - aa, tp.y) * tankMask;
            if (inSub > 0.001)
            {
                float subDepth = saturate((subTop - tp.y) / 0.09);
                float pathCenter = -0.02 * tankHalfW + 0.042 * sin((tp.y + tankHalfH) * 28.0);
                float pathHalfW = lerp(0.18, 0.07, saturate((tp.y + tankHalfH) / 0.09));
                float pathMask = smoothstep(pathHalfW + 0.03, pathHalfW - 0.03, abs(tp.x - pathCenter));

                float sandGrain = 0.96 + 0.04 * sin(tp.x * 34.0 + tp.y * 55.0);
                float3 grassCol = lerp(float3(0.38, 0.86, 0.42), float3(0.16, 0.52, 0.32), smoothstep(0.0, 0.55, subDepth));
                float3 sandCol  = lerp(float3(0.92, 0.88, 0.76), float3(0.72, 0.67, 0.56), smoothstep(0.0, 0.85, abs(tp.x - pathCenter) / max(pathHalfW, 0.05))) * sandGrain;

                float3 floorCol = lerp(grassCol, sandCol, pathMask);
                layer(acc, cover, floorCol, inSub);
            }
            float pathEdgeMoss = smoothstep(0.018, 0.002, abs(tp.y - subTop)) * smoothstep(0.10, 0.22, abs(tp.x + 0.02 * tankHalfW)) * tankMask;
            layer(acc, cover, float3(0.46, 0.90, 0.46), pathEdgeMoss * 0.90);

            // Bot khi oxy phan bo deu khap be, hat nho li ti troi nhe
            if (abs(tp.x) < tankHalfW - 0.08 && tp.y > subTop + 0.01 && tp.y < tankHalfH - 0.06)
            {
                float colIdx = floor(tp.x * 4.2);
                float sway = 0.08 * sin(tp.y * 8.0 + colIdx * 2.1 + tAnim * 1.6);
                float2 bubG = float2(tp.x * 4.2 + sway, (tp.y + tankHalfH) * 5.2 - tAnim * (0.95 + 0.35 * hash1(colIdx * 7.3)));
                float bCell = floor(bubG.x) * 13.7 + floor(bubG.y) * 41.3;
                float bId = hash1(bCell);
                if (bId > 0.72)
                {
                    float2 bOff = float2(hash1(bCell + 1.9) - 0.5, hash1(bCell + 5.1) - 0.5) * 0.45;
                    float bDist = length(frac(bubG) - 0.5 - bOff);
                    float bRad = 0.08 + 0.05 * hash1(bCell + 9.4);
                    float bRim = smoothstep(0.04, 0.0, abs(bDist - bRad * 0.65)) + smoothstep(bRad, 0.0, bDist) * 0.35;
                    layer(acc, cover, float3(0.76, 0.99, 0.92), saturate(bRim) * tankMask * 0.58);
                }
            }

            // Dan 6 ca Neon Tetra nho nhan boi thanh 2 nhom tach biet, khong tu cuc
            drawNeonTetra(acc, cover, tp, tankHalfW, tAnim, 0.44, 0.3,  0.14, 0.72, cInk, aa);
            drawNeonTetra(acc, cover, tp, tankHalfW, tAnim, 0.44, 0.9,  0.07, 0.64, cInk, aa);
            drawNeonTetra(acc, cover, tp, tankHalfW, tAnim, 0.44, 1.5,  0.17, 0.58, cInk, aa);
            drawNeonTetra(acc, cover, tp, tankHalfW, tAnim, 0.36, 3.4, -0.02, 0.70, cInk, aa);
            drawNeonTetra(acc, cover, tp, tankHalfW, tAnim, 0.36, 4.1, -0.09, 0.62, cInk, aa);
            drawNeonTetra(acc, cover, tp, tankHalfW, tAnim, 0.50, 5.2,  0.03, 0.66, cInk, aa);

            float surfY = tankHalfH - 0.045 + 0.006 * sin(tp.x * 6.0 + tAnim * 2.5);
            float waterSurf = smoothstep(0.012, 0.002, abs(tp.y - surfY)) * tankMask;
            layer(acc, cover, float3(0.72, 0.98, 0.90), waterSurf * 0.65);

            float glassSheen = smoothstep(0.14, 0.0, abs(tp.x + tp.y * 0.95 + tankHalfW * 0.35)) * 0.08;
            layer(acc, cover, float3(0.78, 0.98, 0.92), glassSheen * tankMask);
        }

        layer(acc, cover, float3(0.38, 0.88, 0.72), smoothstep(0.012 + aa, 0.012 - aa, abs(dTank)) * 0.62);
        layer(acc, cover, cInk, smoothstep(0.010 + aa, 0.010 - aa, abs(dTank)));

        float dLedHood = sdRoundBox(tp - float2(0.0, tankHalfH + 0.018), float2(tankHalfW * 0.88, 0.018), 0.008);
        drawAnimeShape(acc, cover, dLedHood, float3(0.15, 0.15, 0.20), float3(0.07, 0.07, 0.11), 0.4, cInk, aa, 0.009);
        float ledStrip = smoothstep(0.011, 0.002, abs(tp.y - tankHalfH + 0.002)) * step(abs(tp.x), tankHalfW * 0.82);
        layer(acc, cover, float3(0.78, 1.00, 0.92), ledStrip * 0.98);
    }

    // ---------------------------------------------------------
    // 5. BAN GO THAP & PHAN CHIEU ANH SANG MANH HON
    // ---------------------------------------------------------
    if (q.y < deskY + 0.03)
    {
        float dDeskTop = sdBox(q - float2(aspect * 0.5, deskY - 0.014), float2(aspect * 0.5 + 0.1, 0.015));
        float dDeskFront = sdBox(q - float2(aspect * 0.5, (deskY - 0.028) * 0.5), float2(aspect * 0.5 + 0.1, (deskY - 0.028) * 0.5));

        float grain = 0.94 + 0.06 * sin(q.x * 3.5 + sin(q.y * 95.0));
        float3 topCol = cWoodLight * grain;

        float dxW = (q.x - winX) / max(winHalfW, 1.0);
        float dxL = (q.x - (lampX + 0.06)) / 0.85;
        float dxLSpot = (q.x - (lampX + 0.08)) / 0.34;
        float dxM = (q.x - monX) / max(monHalfW, 1.0);
        float dxT = (q.x - tankX) / max(tankHalfW, 1.0);
        topCol += float3(0.08, 0.16, 0.32) * exp(-(dxW * dxW)) * 0.72;
        topCol += cAmber * exp(-(dxL * dxL)) * 0.62 + float3(1.00, 0.88, 0.56) * exp(-(dxLSpot * dxLSpot)) * 0.38;
        topCol += lerp(appB, appA, 0.5) * exp(-(dxM * dxM)) * (0.36 + 0.22 * vol);
        topCol += cEmerald * exp(-(dxT * dxT)) * 0.44;

        drawAnimeShape(acc, cover, dDeskFront, cWoodMid * grain, cWoodDark * grain, step(q.y, 0.035), cInk, aa, inkW);
        drawAnimeShape(acc, cover, dDeskTop, topCol, cWoodMid * grain, step(q.y, deskY - 0.018), cInk, aa, inkW);

        float matHalfW = monHalfW + 0.12;
        float dMat = sdRoundBox(q - float2(monX, deskY - 0.005), float2(matHalfW, 0.010), 0.004);
        drawAnimeShape(acc, cover, dMat, float3(0.12, 0.10, 0.16), float3(0.07, 0.06, 0.10), 0.25, cInk, aa, 0.008);
    }

    if (abs(q.y - deskY) < 0.025)
    {
        float shMask = smoothstep(0.016, 0.0, abs(q.y - deskY + 0.002));
        float dxMon  = (q.x - monX) / 0.62;
        float dxSpkL = (q.x - spkLX) / 0.30;
        float dxSpkR = (q.x - spkRX) / 0.30;
        float dxPC   = (q.x - pcX) / 0.35;
        float dxCat  = (q.x - catX) / 0.34;
        float dxLamp = (q.x - (lampX + 0.10)) / 0.18;
        float shMon  = exp(-(dxMon * dxMon));
        float shSpkL = exp(-(dxSpkL * dxSpkL));
        float shSpkR = exp(-(dxSpkR * dxSpkR));
        float shPC   = exp(-(dxPC * dxPC));
        float shCat  = exp(-(dxCat * dxCat));
        float shLamp = exp(-(dxLamp * dxLamp)) * hasLamp;
        float shAll  = saturate(shMon + shSpkL + shSpkR + shPC + shCat + shLamp) * shMask;
        layer(acc, cover, cInk, shAll * 0.48);
    }

    // ---------------------------------------------------------
    // 6. MAN HINH DESKTOP & VISUALIZER DOI MAU THEO APP (SANG MANH HON)
    // ---------------------------------------------------------
    [branch] if (abs(q.x - monX) < monHalfW + 0.18 && q.y >= deskY - 0.01)
    {
        float dNeck = sdBox(q - float2(monX, deskY + 0.088), float2(0.10, 0.088));
        float dBase = sdRoundBox(q - float2(monX, deskY + 0.014), float2(0.42, 0.016), 0.007);
        drawAnimeShape(acc, cover, dNeck, float3(0.22, 0.18, 0.22), float3(0.11, 0.09, 0.13), step(monX + 0.02, q.x), cInk, aa, 0.010);
        drawAnimeShape(acc, cover, dBase, float3(0.26, 0.21, 0.25), float3(0.13, 0.11, 0.15), 0.3, cInk, aa, 0.010);

        float2 pMon = q - float2(monX, 0.585);
        float dBezel = sdRoundBox(pMon, float2(monHalfW, 0.365), 0.036);
        float bezelShade = max(step(monHalfW - 0.15, pMon.x), step(pMon.y, -0.31));
        drawAnimeShape(acc, cover, dBezel, float3(0.13, 0.11, 0.16), float3(0.07, 0.06, 0.10), bezelShade, cInk, aa, inkW);

        float dPwr = length(pMon - float2(monHalfW - 0.14, -0.340)) - 0.011;
        layer(acc, cover, lerp(appA, appC, live), smoothstep(aa, -aa, dPwr));

        float2 scrHalf = float2(monHalfW - 0.070, 0.305);
        float2 pScr = pMon - float2(0.0, 0.014);
        float dScr = sdRoundBox(pScr, scrHalf, 0.022);
        float scrMask = smoothstep(aa, -aa, dScr);

        if (scrMask > 0.001)
        {
            float scrGrad = saturate((pScr.y + scrHalf.y) / (2.0 * scrHalf.y));
            float3 scrBg = lerp(float3(0.05, 0.05, 0.10), float3(0.12, 0.11, 0.20), scrGrad);
            scrBg += appB * exp(-length(pScr * float2(0.45, 1.2)) * 1.8) * (0.24 + 0.16 * vol);
            layer(acc, cover, scrBg, scrMask);

            float uCenter = saturate((pScr.x + scrHalf.x) / (2.0 * scrHalf.x));
            float wStep = 0.045;
            float wAmp = 0.110 * (0.22 + 0.78 * live) * (0.65 + 0.45 * vol);
            float wBaseY = 0.060;
            float w0 = wBaseY + wave(saturate(uCenter - 0.015)) * wAmp;
            float w1 = wBaseY + wave(uCenter) * wAmp;
            float w2 = wBaseY + wave(saturate(uCenter + 0.015)) * wAmp;
            float dWave = min(
                sdSegment(pScr, float2(pScr.x - wStep, w0), float2(pScr.x, w1)),
                sdSegment(pScr, float2(pScr.x, w1), float2(pScr.x + wStep, w2))
            );
            float waveGlow = exp(-dWave * 21.0) * 0.56;
            float waveCore = smoothstep(0.012, 0.002, dWave) * 0.85;
            layer(acc, cover, appA, waveGlow * scrMask);
            layer(acc, cover, lerp(appC, float3(1.0, 0.96, 0.92), 0.58), waveCore * scrMask);

            float pitch = 0.132;
            float usableW = scrHalf.x * 2.0 - 0.12;
            float nBars = max(floor(usableW / pitch), 6.0);
            float totalBarsW = nBars * pitch;
            float barAreaX = pScr.x + totalBarsW * 0.5;

            if (barAreaX > 0.0 && barAreaX < totalBarsW)
            {
                float bIdx = floor(barAreaX / pitch);
                float bLocX = barAreaX - (bIdx + 0.5) * pitch;
                float normIdx = (bIdx + 0.5) / nBars;
                float symFreq = saturate(abs(normIdx - 0.5) * 2.0);
                float specSample = spectrum(clamp(pow(max(symFreq, 1e-4), 1.15) * 0.88 + 0.03, 0.02, 0.94));

                float idleRipple = 0.028 * (0.5 + 0.5 * sin(tAnim * 2.4 + bIdx * 0.55));
                float barHeight = saturate(0.08 + idleRipple + specSample * (0.28 + 0.74 * live) + 0.10 * beatPulse * (1.0 - symFreq * 0.6));
                float maxBarH = scrHalf.y * 1.48;
                float pillH = clamp(barHeight * maxBarH, 0.052, maxBarH);
                float pillR = min(0.035, pillH * 0.49);

                float barBot = -scrHalf.y + 0.042;
                float2 pillCenter = float2(bLocX, pScr.y - (barBot + pillH * 0.5));
                float dPill = sdRoundBox(pillCenter, float2(0.036, pillH * 0.5), pillR);

                float pillAlpha = smoothstep(aa, -aa, dPill) * scrMask;
                float hNorm = saturate((pScr.y - barBot) / max(maxBarH, 0.01));
                float3 pillCol = lerp(appB, lerp(appA, appC, smoothstep(0.35, 0.95, hNorm)), smoothstep(0.0, 0.55, hNorm));

                float pillHalo = exp(-max(dPill, 0.0) * 19.0) * (0.22 + 0.28 * specSample * live) * scrMask;
                layer(acc, cover, pillCol, pillHalo);
                layer(acc, cover, pillCol, pillAlpha * 0.96);
            }

            float baseGlow = smoothstep(0.010, 0.002, abs(pScr.y - (-scrHalf.y + 0.034))) * step(abs(pScr.x), totalBarsW * 0.5);
            layer(acc, cover, appA, baseGlow * scrMask * 0.52);
            float scrSheen = smoothstep(0.24, 0.0, abs(pScr.x + pScr.y * 1.1 + scrHalf.x * 0.45)) * 0.06;
            layer(acc, cover, float3(1.0, 0.96, 0.92), scrSheen * scrMask);
        }
        layer(acc, cover, cInk, smoothstep(0.010 + aa, 0.010 - aa, abs(dScr)));
    }

    // ---------------------------------------------------------
    // 7. CAP LOA MAY TINH & THUNG PC DOI MAU THEO APP
    // ---------------------------------------------------------
    [branch] if (abs(q.x - spkLX) < 0.34 && q.y >= deskY - 0.01)
    {
        drawSpeaker(acc, cover, q, spkLX, deskY, beatPulse, appC, cAmber, cInk, aa, inkW);
    }

    [branch] if (abs(q.x - spkRX) < 0.34 && q.y >= deskY - 0.01)
    {
        drawSpeaker(acc, cover, q, spkRX, deskY, beatPulse, appC, cAmber, cInk, aa, inkW);
    }

    [branch] if (abs(q.x - pcX) < 0.40 && q.y >= deskY - 0.01)
    {
        float pcHalfH = 0.380;
        float2 pPC = q - float2(pcX, deskY + pcHalfH);
        float dCase = sdRoundBox(pPC, float2(0.280, pcHalfH), 0.028);
        float caseShade = max(step(0.15, pPC.x), step(pPC.y, -pcHalfH + 0.05));
        drawAnimeShape(acc, cover, dCase, float3(0.22, 0.17, 0.21), float3(0.11, 0.09, 0.13), caseShade, cInk, aa, inkW);

        float pcRim = smoothstep(0.04, 0.0, abs(dCase)) * step(dCase, 0.0) * step(0.05, pPC.x);
        layer(acc, cover, cEmerald, pcRim * 0.40);

        float2 pGlass = pPC - float2(-0.01, 0.028);
        float dGlassPC = sdRoundBox(pGlass, float2(0.205, 0.275), 0.018);
        float gMask = smoothstep(aa, -aa, dGlassPC);
        if (gMask > 0.001)
        {
            layer(acc, cover, float3(0.06, 0.05, 0.10), gMask);

            float dPSU = sdBox(pGlass - float2(0.0, -0.22), float2(0.200, 0.054));
            layer(acc, cover, float3(0.10, 0.09, 0.15), smoothstep(aa, -aa, dPSU) * gMask);

            [unroll]
            for (int f = 0; f < 2; f++)
            {
                float fy = (f == 0) ? 0.125 : -0.058;
                float2 pFan = pGlass - float2(-0.040, fy);
                float rFan = length(pFan);
                float3 fanCol = (f == 0) ? appA : appC;

                float fanRing = smoothstep(0.017, 0.003, abs(rFan - 0.074));
                float fanGlow = exp(-abs(rFan - 0.074) * 19.0) * (0.48 + 0.52 * beatPulse);
                layer(acc, cover, fanCol, (fanRing * 0.95 + fanGlow) * gMask);

                if (rFan < 0.068)
                {
                    float fAng = atan2(pFan.y, pFan.x) + tAnim * (2.6 + 3.2 * live);
                    float blades = smoothstep(0.2, 0.7, sin(fAng * 5.0));
                    layer(acc, cover, lerp(float3(0.14, 0.12, 0.18), fanCol, 0.45), blades * gMask * 0.82);
                    layer(acc, cover, float3(0.88, 0.90, 0.96), smoothstep(0.019, 0.008, rFan) * gMask);
                }
            }

            float dRam = sdRoundBox(pGlass - float2(0.096, 0.065), float2(0.019, 0.076), 0.006);
            layer(acc, cover, appB, smoothstep(aa, -aa, dRam) * gMask * (0.80 + 0.20 * beatPulse));

            float pcSheen = smoothstep(0.08, 0.0, abs(pGlass.x + pGlass.y * 0.85 - 0.05)) * 0.10;
            layer(acc, cover, float3(1.0, 0.94, 0.90), pcSheen * gMask);
        }
        layer(acc, cover, cInk, smoothstep(0.008 + aa, 0.008 - aa, abs(dGlassPC)));

        float dBtn = length(pPC - float2(-0.16, pcHalfH - 0.034)) - 0.013;
        layer(acc, cover, appA, smoothstep(aa, -aa, dBtn));
    }

    // ---------------------------------------------------------
    // 8. MEO TAM THE VAY DUOI & LIEM CHAN (Suoi am + Rim ngoc luc bao manh hon)
    // ---------------------------------------------------------
    float catScale = 2.80;
    float2 cp = float2(-(q.x - catX), q.y - deskY) / catScale;
    [branch] if (abs(cp.x) < 0.26 && cp.y > -0.02 && cp.y < 0.28)
    {
        float catCycle = frac(tAnim * 0.12);
        float groom = smoothstep(0.55, 0.62, catCycle) * (1.0 - smoothstep(0.90, 0.97, catCycle));
        float lickBob = sin(tAnim * 11.5) * 0.010 * groom;

        float dHaunch = length((cp - float2(-0.015, 0.036)) * float2(1.05, 1.35)) - 0.052;
        float dTorso  = length((cp - float2(0.002, 0.072)) * float2(1.30, 0.90)) - 0.066;
        float dBody   = smin(dHaunch, dTorso, 0.022);

        float2 headCenter = lerp(float2(0.015, 0.160), float2(0.044, 0.118 + lickBob), groom);
        float dHead = length(cp - headCenter) - 0.046;
        float dCat = smin(dBody, dHead, 0.022);

        float2 earP = rot(cp - headCenter, -0.34 * groom);
        float earL = sdTriangle(earP, float2(-0.042, 0.020), float2(-0.010, 0.035), float2(-0.033, 0.075));
        float earR = sdTriangle(earP, float2(0.008, 0.035), float2(0.039, 0.020), float2(0.029, 0.075));
        dCat = min(dCat, min(earL, earR));

        float2 pawCenter = lerp(float2(0.024, 0.032), float2(0.066, 0.082 - lickBob * 0.45), groom);
        float dPaw = length((cp - pawCenter) * float2(0.82, 1.35)) - (0.013 + 0.012 * groom);
        dCat = smin(dCat, dPaw, 0.014);

        float tailCurve = -0.052 - 0.024 * sin(cp.y * 23.0 - tAnim * 3.6) * smoothstep(0.01, 0.16, cp.y)
                        + sin(tAnim * 2.3 + beatPulse * 0.4) * 0.022 * (cp.y * 6.0);
        float rTail = lerp(0.012, 0.007, saturate(cp.y / 0.180));
        float dTail = abs(cp.x - tailCurve) - rTail;
        float dTailClip = max(dTail, max(0.012 - cp.y, cp.y - 0.180));
        float dCatFull = min(dCat, dTailClip);

        float catAA = aa / catScale;
        float catFill = smoothstep(catAA, -catAA, dCatFull) * step(-0.002, cp.y);

        if (catFill > 0.001)
        {
            float3 furWhite = float3(0.88, 0.82, 0.78);
            float3 furShade = float3(0.46, 0.41, 0.44);
            float3 furOrange = float3(0.92, 0.52, 0.24);
            float3 furOrangeShade = float3(0.52, 0.26, 0.16);
            float3 furDark = float3(0.14, 0.11, 0.14);

            float patchOrangeHead = smoothstep(0.008, -0.008, length(earP - float2(0.022, 0.042)) - 0.036);
            float patchOrangeBack = smoothstep(0.010, -0.010, length((cp - float2(-0.006, 0.095)) * float2(1.0, 1.25)) - 0.036);
            float patchOrange = saturate(max(patchOrangeHead, patchOrangeBack));

            float patchDarkHead = smoothstep(0.008, -0.008, length(earP - float2(-0.026, 0.044)) - 0.034);
            float patchDarkHip  = smoothstep(0.010, -0.010, length((cp - float2(-0.040, 0.048)) * float2(1.1, 1.0)) - 0.038);
            float patchDarkTail = step(dTailClip, 0.003) * smoothstep(0.04, 0.08, cp.y);
            float patchDark = saturate(max(patchDarkHead, max(patchDarkHip, patchDarkTail)));

            float shadeM = max(smoothstep(0.02, -0.03, cp.x), smoothstep(0.035, 0.005, cp.y));
            float3 catCol = lerp(furWhite, furShade, shadeM * 0.70);
            catCol = lerp(catCol, lerp(furOrange, furOrangeShade, shadeM * 0.70), patchOrange);
            catCol = lerp(catCol, float3(0.24, 0.22, 0.26), patchDark);

            float innerEar = smoothstep(0.004, -0.004, sdTriangle(earP, float2(0.014, 0.034), float2(0.032, 0.026), float2(0.026, 0.058)));
            catCol = lerp(catCol, float3(0.76, 0.48, 0.50), innerEar * 0.80);

            float emRim = smoothstep(0.011, 0.0, abs(dCatFull)) * step(cp.x, 0.02);
            float warmRim = smoothstep(0.010, 0.0, abs(dCat)) * step(0.01, cp.x);
            catCol += cEmerald * emRim * 0.95 + cAmber * warmRim * 0.50;

            // Dem nam nho am ap duoi chan meo
            float dCushion = sdRoundBox(cp - float2(-0.006, 0.006), float2(0.082, 0.014), 0.010);
            drawAnimeShape(acc, cover, dCushion, float3(0.68, 0.42, 0.30), float3(0.42, 0.24, 0.18), smoothstep(-0.02, 0.04, cp.x), cInk, catAA, 0.005);

            layer(acc, cover, catCol, catFill);
        }

        float catInk = smoothstep(0.0052 + catAA, 0.0052 - catAA, abs(dCatFull)) * step(-0.002, cp.y);
        layer(acc, cover, cInk, catInk);

        float blink = step(0.955, frac(tAnim * 0.34));
        float eyeOpen = lerp(1.0 - blink * 0.85, 0.22, groom);
        float2 eyeP = (cp - (headCenter + float2(0.024, 0.005))) * float2(1.0, 1.0 / max(eyeOpen, 0.16));
        float eyeM = smoothstep(0.010, 0.003, length(eyeP));
        layer(acc, cover, cInk, eyeM);
        layer(acc, cover, float3(1.00, 0.80, 0.30), smoothstep(0.007, 0.002, length(eyeP)) * (1.0 - groom * 0.7));

        float noseM = smoothstep(0.005, 0.001, length(cp - (headCenter + float2(0.041, -0.006))));
        layer(acc, cover, float3(0.84, 0.50, 0.54), noseM);

        float collar = smoothstep(0.004, 0.001, sdBox(cp - float2(0.018, 0.112), float2(0.025, 0.004))) * (1.0 - groom * 0.7);
        float bell = smoothstep(0.012, 0.004, length(cp - float2(0.033, 0.108)));
        layer(acc, cover, float3(0.82, 0.24, 0.28), collar);
        layer(acc, cover, float3(1.00, 0.84, 0.34), bell);
    }

    // ---------------------------------------------------------
    // 9. SUONG MO DIU LO-FI & NHIEU HAT NHIEU ANIME
    // ---------------------------------------------------------
    float3 baseRgb = acc / max(cover, 0.001);
    baseRgb = lerp(baseRgb, float3(0.14, 0.11, 0.13), 0.04);
    float grainSeed = dot(floor(px), float2(12.9898, 78.233)) + floor(tAnim * 8.0) * 19.19;
    float filmGrain = (hash1(grainSeed) - 0.5) * 0.020;

    return paint(saturate(baseRgb + filmGrain), saturate(cover));
}