Boot Sequence

của MusicBar, thanh tiến trình

Màn hình terminal xanh lá đời cũ đang load bài hát, thanh khối vuông trong ngoặc chạy tới chỗ đang phát kèm con trỏ nhấp nháy và số phần trăm thật, tới nhịp là màn hình chớp giật như CRT.

4 lượt tải Tải file, 5.7 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 081f2cb99abff0a5a7b22af1abb3b1accb5ce7cd9a9d5c2751b3770855d41980

//! name: Boot Sequence
//! author: MusicBar
//! kind: progress
//! description: An old green phosphor terminal loads the song in a bracketed bar of block characters, with a blinking cursor and a real percent counter riding the playhead, flickering and tearing on every beat.

// 3x5 pixel digits and a percent sign, one number per glyph: five rows of three bits, top row first.
float glyph(float n)
{
    return n < 0.5 ? 31599.0 : n < 1.5 ? 11415.0 : n < 2.5 ? 29671.0 : n < 3.5 ? 29391.0 : n < 4.5 ? 23497.0 :
           n < 5.5 ? 31183.0 : n < 6.5 ? 31215.0 : n < 7.5 ? 29266.0 : n < 8.5 ? 31727.0 : n < 9.5 ? 31695.0 : 21157.0;
}

// Is pixel (col 0..2, row 0..4 from the top) of glyph n lit?
float bit(float n, float col, float row)
{
    float idx = (4.0 - row) * 3.0 + (2.0 - col);
    return step(0.5, frac(glyph(n) / exp2(idx + 1.0)));
}

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

// Lays a color over what is there (premultiplied light, and how much of the pixel it covers).
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);
}

float4 main(float2 uv : TEXCOORD) : COLOR
{
    float u = size.y;
    float p = max(2.0, floor(u / 9.0));                         // one character pixel, whole screen pixels so it stays crisp
    float2 px = float2(uv.x * size.x, (1.0 - uv.y) * u - floor((u - 9.0 * p) * 0.5));   // screen-up, so digits never turn over
    float row = floor(px.y / p);

    // On the beat the picture flickers and a few scanlines tear sideways.
    float rnd = frac(sin(row * 12.9 + floor(time * 24.0) * 7.3) * 4375.85);
    px.x -= floor(beat * step(0.55, rnd) * p * (1.0 + 2.0 * rnd) + 0.5);

    float cw = 4.0 * p;                                         // a character cell: 3 pixels and a gap
    float m = floor(0.4 * u);
    float N = max(floor((size.x - 2.0 * m) / cw) - 2.0, 6.0);   // block cells between the brackets
    float j = floor((px.x - m) / cw);
    float col = floor((px.x - m) / p) - j * 4.0;
    float inCol = step(col, 2.5);

    float F = floor(progress * N + 0.0001);                      // filled blocks
    float pct = floor(progress * 100.0 + 0.0001);
    float cs = min(F + 3.0, N - 3.0);                            // first cell of the counter

    // What this cell holds: a filled block, the cursor, a placeholder, a bracket, or a counter glyph.
    float isBlock = step(0.5, j) * step(j, F + 0.1);
    float isCursor = step(abs(j - F - 1.0), 0.1) * step(j, N + 0.1);
    float k = j - cs;
    float isCount = step(-0.1, k) * step(k, 3.1);
    float digit = k < 0.5 ? floor(pct / 100.0) : (k < 1.5 ? fmod(floor(pct / 10.0), 10.0) : (k < 2.5 ? fmod(pct, 10.0) : 10.0));
    float shown = k < 0.5 ? step(99.5, pct) : (k < 1.5 ? step(9.5, pct) : 1.0);
    float isEmpty = step(F + 1.9, j) * step(j, N + 0.1) * (1.0 - isCount);

    // Pixels: a block fills 3 x 7, the digits sit in the middle 3 x 5; over filled blocks the counter shows inverted.
    float tall = step(0.5, row) * step(row, 7.5);
    float gr = 6.0 - row;
    float gOn = bit(digit, col, gr) * step(-0.1, gr) * step(gr, 4.1) * inCol * shown * isCount;
    float blockOn = isBlock * tall * inCol;
    float on = lerp(blockOn, abs(blockOn - gOn), isCount);
    float blink = saturate(step(0.45, frac(time * 1.9)) + beat);
    float cur = isCursor * tall * inCol * blink;

    // Brackets: as tall as the screen row, with two-pixel serifs.
    float cap = step(row, 0.5) + step(7.5, row);
    float full = step(-0.5, row) * step(row, 8.5);
    float lb = step(abs(j), 0.1) * full * saturate(step(col, 0.5) + step(col, 1.5) * cap);
    float rb = step(abs(j - N - 1.0), 0.1) * full * saturate(step(1.5, col) * step(col, 2.5) + step(0.5, col) * step(col, 2.5) * cap);

    // Placeholders ahead: a sparse light-shade dither, barely there.
    float dith = isEmpty * tall * inCol * step(0.5, frac((col + row) * 0.5)) * step(0.5, frac(row * 0.5 + 0.25));

    // The look of a phosphor screen: scanlines, a little mains hum, a flash on the beat, and newly filled
    // blocks still glowing hot; filled blocks shimmer with the spectrum.
    float s = spectrum(frac(j / 20.0));
    float flick = (0.93 + 0.07 * sin(time * 53.0)) * (1.0 + 0.5 * beat);
    float scan = 0.68 + 0.32 * step(0.5, frac(px.y * 0.5));
    float heat = 0.5 + 0.3 * s * s + 0.35 * exp(-(F - j) / 8.0) + 0.5 * exp(-(F - j) / 1.5) * isBlock;
    float3 phos = colorA.rgb;
    float3 hot = lerp(colorA.rgb, colorC.rgb, 0.7);
    float3 acc = float3(0, 0, 0);
    float cover = 0;

    // Bloom: a soft halo above and below the filled run, the cursor and the counter.
    float run = sdBox(float2(px.x - m - (0.5 + 0.5 * (F + 1.0)) * cw, px.y - 4.5 * p), float2(0.5 * F * cw, 3.5 * p));
    float cd = sdBox(float2(px.x - m - (F + 1.0 + 0.4) * cw, px.y - 4.5 * p), float2(1.5 * p, 3.5 * p));
    float bloom = exp(-max(run, 0.0) / (0.14 * u)) * step(0.5, F) * 0.22 + exp(-max(cd, 0.0) / (0.16 * u)) * 0.4 * blink;
    layer(acc, cover, phos, bloom * (0.6 + 0.4 * level) * flick);

    // A dark readout patch behind the counter, so the digits hold up on a light taskbar too.
    float plate = sdBox(float2(px.x - m - (cs + 2.0) * cw + 0.5 * p, px.y - 4.5 * p), float2(2.0 * cw + 0.5 * p, 3.5 * p)) - 0.5 * p;
    layer(acc, cover, colorB.rgb * 0.08, smoothstep(0.5, -0.5, plate) * 0.6);
    layer(acc, cover, colorB.rgb, dith * 0.45 * scan);
    layer(acc, cover, phos * heat * flick * scan + hot * 0.25 * isCount * (1.0 - isBlock), on);
    layer(acc, cover, phos * flick * scan, saturate(lb + rb) * 0.9);
    layer(acc, cover, lerp(hot, float3(1, 1, 1), 0.3) * flick * scan, cur);

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