Fin

by MusicBar, progress bar

A dorsal fin slices through dark water to the playhead, spreading a V wake behind it, with glints on the swell shimmering with the music and a tense red flash under the surface on every beat.

2 downloads Download file, 6.8 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 860a3f5873060db03b2d595b07781cfeb3499f66e253b1c55a7f4915aebd6f3e

//! name: Fin
//! author: MusicBar
//! kind: progress
//! description: A dorsal fin slices through dark water to the playhead, spreading a V wake behind it over a long dark shape below, with glints on the swell that shimmer with the music and a tense red flash under the surface on every beat.

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

// Smooth value noise, for foam and broken crests.
float vnoise(float2 p)
{
    float2 i = floor(p), f = frac(p);
    f = f * f * (3.0 - 2.0 * f);
    float n = i.x + i.y * 57.0;
    return lerp(lerp(hash1(n), hash1(n + 1.0), f.x), lerp(hash1(n + 57.0), hash1(n + 58.0), f.x), f.y);
}

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

// 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;
    float2 px = float2(uv.x * size.x, (1.0 - uv.y) * u);        // y up the screen: the far side of the water is at the top
    float head = progress * size.x;
    float3 acc = float3(0, 0, 0);
    float cover = 0;
    float back = (head - px.x) / u;                              // bar heights behind the fin
    float played = smoothstep(-0.3, 0.5, back);
    float yw = 0.37 * u + 0.025 * u * sin(time * 2.1);           // the waterline at the fin, riding the swell
    float sh = spectrum(saturate(abs(back) / 12.0));             // bass near the fin, treble far from it
    float3 foam = lerp(colorC.rgb, float3(1, 1, 1), 0.3);

    // The water: deep and dark where the fin has cut through, only a faint sheen ahead.
    float depth = px.y / u;
    float3 water = lerp(colorB.rgb * 0.3 + float3(0.0, 0.02, 0.05), colorB.rgb * 0.12 + 0.01, depth);
    layer(acc, cover, water, lerp(0.1, 0.8, played));

    // The long shape under the surface, its tail sweeping. On the beat a red flash pulses up through the water
    // behind it, so the shape stands out black against the red.
    float2 bq = (px - float2(head - 0.3 * u, yw - 0.07 * u)) / u;
    bq.y -= 0.05 * sin(time * 3.2 + bq.x * 3.0) * saturate(-bq.x - 0.1);
    float tailF = max(abs(abs(bq.y) - (-bq.x - 0.68) * 0.45) - 0.025, max(-bq.x - 0.95, bq.x + 0.66));
    float bodyD = min((length(bq / float2(0.68, 0.085)) - 1.0) * 0.085, tailF);
    float flash = beat * (0.75 + 0.5 * sh) + 0.1 + 0.05 * sin(time * 1.3);
    layer(acc, cover, colorA.rgb, exp(-max(bodyD, 0.0) / (0.1 + 0.06 * beat)) * flash * 0.8 * played);
    layer(acc, cover, float3(0.0, 0.01, 0.025), smoothstep(0.012, -0.012, bodyD) * (0.45 + 0.4 * beat) * played);
    layer(acc, cover, colorB.rgb * 1.3, smoothstep(0.015, 0.0, abs(bodyD)) * 0.2 * played);

    // Swells: crest lines packed tighter toward the far side, broken up, lit by the moon and shimmering with the music.
    float ph = pow(depth, 0.75) * 8.0 + 0.45 * sin(px.x / (0.9 * u) + time * 0.7) + 0.25 * sin(px.x / (0.37 * u) - time * 1.1) - time * 0.3;
    float crest = smoothstep(1.3, 0.0, abs(frac(ph) - 0.5) / max(fwidth(ph), 0.0001));
    float brk = smoothstep(0.5, 0.85, vnoise(float2(px.x / (0.45 * u) + time * 0.25, floor(ph) * 7.0)));
    layer(acc, cover, lerp(colorB.rgb, foam, 0.55), crest * brk * (0.12 + 0.5 * sh + 0.2 * level) * lerp(0.45, 1.0, played));

    // Glints: little stars of moonlight winking on the swell, more of them when it is loud.
    float2 gp = px / (0.17 * u), gc = floor(gp), gq = abs(frac(gp) - 0.5);
    float gh = hash1(gc.x * 17.0 + gc.y * 131.0);
    float glint = (exp(-gq.x * 40.0 - gq.y * 9.0) + exp(-gq.y * 40.0 - gq.x * 9.0)) * step(0.9 - 0.1 * level - 0.08 * sh, gh) * saturate(sin(time * (2.5 + 4.0 * gh) + gh * 40.0));
    layer(acc, cover, foam, glint * lerp(0.5, 1.0, played));

    // The wake: a V of foam spreading back from the fin (the far arm climbs, the near arm drops faster),
    // feathered with little Kelvin ripples, and a churned streak along the whole path behind.
    float wb = max(head - 0.12 * u - px.x, 0.0) / u;
    float behind = step(px.x, head - 0.12 * u);
    float wkw = (0.008 + 0.012 * wb) * u;
    float yUp = px.y - yw - 0.2 * wb * u, yDn = px.y - yw + 0.3 * wb * u;
    float arms = exp(-abs(yUp) / wkw) + exp(-abs(yDn) / wkw);
    float feather = 0.75 + 0.25 * sin(wb * 26.0 - time * 8.0);
    layer(acc, cover, foam, arms * feather * exp(-wb / 2.4) * behind * (0.75 + 0.3 * level));
    float churn = exp(-abs(px.y - yw) / ((0.03 + 0.012 * min(wb, 6.0)) * u)) * exp(-wb / 14.0) * behind;
    layer(acc, cover, lerp(colorB.rgb, foam, 0.5), churn * (0.2 + 0.35 * vnoise(float2(px.x / (0.2 * u) + time * 1.5, px.y / (0.1 * u)))));

    // The fin: a curved blade, convex up its leading edge and hooked back at the tip, rocking with the swell.
    float2 f = rot((px - float2(head, yw)) / (1.1 * u), 0.05 * sin(time * 1.7) + 0.06 * beat);
    float t = saturate(f.y / 0.5);
    float xl = -0.14 + 0.33 * pow(1.0 - t, 0.55);
    float xt = -0.19 + 0.06 * t + 0.035 * sin(3.1416 * t);
    float dFin = max(max(xt - f.x, f.x - xl), max(-f.y, f.y - 0.5));
    float fa = max(fwidth(dFin), 0.0001);
    float fin = smoothstep(fa, -fa, dFin);
    float lead = smoothstep(0.035, 0.0, xl - f.x);                      // moonlight along the leading edge
    float3 skin = lerp(float3(0.2, 0.24, 0.28), float3(0.36, 0.41, 0.46), saturate((f.x - xt) / max(xl - xt, 0.01)));
    skin = lerp(skin, float3(0.08, 0.1, 0.12), smoothstep(0.08, 0.0, f.y) * 0.6);   // wet and dark at the waterline
    skin += foam * lead * 0.55 + colorA.rgb * beat * 0.12 * smoothstep(0.2, 0.0, f.y);
    layer(acc, cover, float3(0.02, 0.03, 0.04), smoothstep(fa * 2.5, 0.0, dFin) * 0.6);   // a dark outline for light taskbars
    layer(acc, cover, skin, fin);

    // White water where the fin cuts: a curl of foam at the leading edge and froth along its base.
    float2 fq = (px - float2(head + 0.12 * u, yw)) / u;
    float froth = smoothstep(0.35, 0.75, vnoise(px / (0.05 * u) + float2(time * 6.0, 0.0)));
    float bow = smoothstep(1.0, 0.4, length(fq / float2(0.13, 0.05 + 0.03 * level))) * (0.6 + 0.4 * froth);
    float base = smoothstep(0.025 * u, 0.0, abs(px.y - yw)) * smoothstep(0.32 * u, 0.0, abs(px.x - head + 0.02 * u)) * froth;
    layer(acc, cover, foam, max(bow, base) * 0.9);

    // Spray flicked forward off the leading edge on the beat, falling back.
    for (int i = 0; i < 5; i++)
    {
        float fi = i, st = 1.0 - beat;
        float2 dp = float2(0.15, 0.03) + float2(0.12 + 0.4 * hash1(fi + 3.0), 0.35 + 0.5 * hash1(fi + 9.0)) * st * 0.7 - float2(0.0, 1.5 * st * st);
        layer(acc, cover, foam, step(0.05, beat) * beat * smoothstep(0.5, -0.5, length(px - float2(head, yw) - dp * u) - max(0.6, 0.016 * u)));
    }
    return paint(acc / max(cover, 0.001), cover);
}