Pop Art
by MusicBar, visualizer
A 60s comic panel: halftone dot waves ride the spectrum under bold black outlines, speed lines streak past and jagged starbursts explode on every beat.
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 ff413d27c6e3bc8dedd53bd96332d0c71c3af8842b10b920a53e5fad6f05bec9
//! name: Pop Art
//! author: MusicBar
//! kind: visualizer
//! description: A 60s comic panel: halftone waves ride the spectrum under bold black outlines, speed lines streak past and jagged starbursts explode on every beat.
float hash2(float2 p)
{
float3 q = frac(float3(p.x, p.y, p.x) * 0.1031);
q += dot(q, q.yzx + 33.33);
return frac((q.x + q.y) * q.z);
}
// 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);
}
// Ben-Day dots on a 45 degree grid: distance in pixels to the nearest dot, dots grow with the ink amount f.
float benday(float2 px, float cell, float f)
{
float2 r = float2(px.x + px.y, px.y - px.x) * 0.7071 / cell;
return (length(frac(r) - 0.5) - 0.74 * sqrt(saturate(f))) * cell;
}
// A jagged comic starburst: spikes of random length around a ring, an even count so the seam stays clean.
float burstD(float2 d, float R, float sd)
{
float a = atan2(d.y, d.x) / 6.2832 * 14.0;
float amp = 0.45 + 0.55 * hash2(float2(floor(a), sd));
float tri = 1.0 - abs(2.0 * frac(a) - 1.0);
return (length(d) - R * (0.55 + 0.45 * amp * tri)) * 0.55;
}
float4 main(float2 uv : TEXCOORD) : COLOR
{
float u = size.y;
float2 px = float2(uv.x * size.x, rise(uv) * u); // pixels: along the bar, up from the screen edge
float x = px.x / u;
float lw = max(1.3, 0.05 * u); // the bold black outline
float3 ink = float3(0.04, 0.04, 0.05);
float3 paper = float3(1.0, 0.98, 0.92);
float mirror = abs(frac(x / 10.0) - 0.5) * 2.0; // the spectrum, mirrored every ten bar heights
float sBass = (spectrum(saturate(mirror - 0.03)) + spectrum(mirror) + spectrum(saturate(mirror + 0.03))) / 3.0;
float sHigh = (spectrum(saturate(0.97 - mirror)) + spectrum(saturate(1.03 - mirror))) * 0.5;
float3 acc = float3(0, 0, 0);
float cover = 0;
// Back wave: fine blue Ben-Day dots under a black contour, riding the treble.
float h2 = u * (0.26 + 0.5 * sHigh + 0.08 * sin(x * 1.1 + time * 1.4));
float t2 = saturate((h2 - px.y) / h2);
float in2 = smoothstep(0.5, -0.5, px.y - h2);
layer(acc, cover, colorB.rgb, in2 * smoothstep(0.5, -0.5, benday(px + float2(0.06 * u, 0.0), 0.12 * u, 0.04 + 0.3 * t2)));
layer(acc, cover, ink, smoothstep(lw * 0.5 + 0.5, lw * 0.5 - 0.5, abs(px.y - h2)));
// Front wave: red dots riding the bass, growing with depth and on the beat, a paper-white sheen under its contour.
float h1 = u * (0.12 + 0.45 * sBass * (0.85 + 0.35 * beat) + (0.05 + 0.07 * level) * sin(x * 1.3 - time * 2.2));
float t1 = saturate((h1 - px.y) / h1);
float in1 = smoothstep(0.5, -0.5, px.y - h1);
layer(acc, cover, colorA.rgb, in1 * smoothstep(0.5, -0.5, benday(px, 0.13 * u, 0.07 + 0.42 * t1 + 0.1 * beat)));
layer(acc, cover, paper, in1 * smoothstep(lw * 0.4 + 0.5, lw * 0.4 - 0.5, abs(h1 - px.y - lw * 1.4)) * 0.85);
layer(acc, cover, ink, smoothstep(lw * 0.5 + 0.5, lw * 0.5 - 0.5, abs(px.y - h1)));
// Speed lines streaking left, inked edge and white core, more of them when the song is loud.
float rowH = 0.085 * u;
float row = floor(px.y / rowH);
float rh = hash2(float2(row, 7.0));
float lx = x + time * (5.0 + 7.0 * rh) + rh * 50.0;
float seg = floor(lx / 2.2);
float len = 0.5 + 1.2 * hash2(float2(seg, row + 3.0));
float lf = saturate(frac(lx / 2.2) * 2.2 / len);
float thick = 0.024 * u * sin(lf * 3.1416) + 0.3;
float onLine = step(hash2(float2(seg, row)), 0.18 + 0.4 * level) * step(frac(lx / 2.2) * 2.2, len) * step(0.42 * u, px.y) * step(px.y, 0.94 * u);
float dl = abs(px.y - (row + 0.5) * rowH);
layer(acc, cover, ink, onLine * smoothstep(thick + 1.0, thick, dl) * 0.9);
layer(acc, cover, paper, onLine * smoothstep(thick * 0.5 + 0.5, thick * 0.5 - 0.5, dl));
// Starbursts: each slot pops one in for a while, and the beat inflates them and throws extra ones out.
float slot = floor(x / 3.3);
float h0 = hash2(float2(slot, 1.0));
float tt = time / 1.7 + h0 * 5.0;
float win = floor(tt);
float f = frac(tt);
float hv = hash2(float2(slot, win));
float shown = step(hv, 0.42 + 0.3 * level) * smoothstep(0.0, 0.05, f) * (1.0 + 0.3 * exp(-f * 25.0)) * smoothstep(1.0, 0.93, f);
float extra = step(0.42 + 0.3 * level, hv) * smoothstep(0.0, 0.4, beat);
float sc = max(shown, extra) * (1.0 + 0.25 * beat);
float2 bc = float2((slot + 0.5 + 0.35 * (h0 - 0.5)) * 3.3 * u, u * (0.52 + 0.1 * (hash2(float2(slot, win + 9.0)) - 0.5)));
float2 d = px - bc;
float ra = hv * 6.0 + 0.06 * sin(time * 3.0 + h0 * 9.0);
d = float2(cos(ra) * d.x + sin(ra) * d.y, -sin(ra) * d.x + cos(ra) * d.y);
float R = 0.43 * u * sc;
float outer = burstD(d, R, win + slot * 7.0);
float inner = burstD(d, R * 0.6, win + slot * 7.0 + 50.0);
float vis = step(0.02, sc);
// Action rays flung out of the burst on the beat.
float ray = atan2(d.y, d.x) / 6.2832 * 28.0;
float rayOn = step(hash2(float2(floor(ray), slot + win)), 0.5) * vis * beat;
float rd = length(d);
float rayW = (0.5 - abs(frac(ray) - 0.5)) * 6.2832 / 28.0 * rd;
float rayLen = step(R * 1.05, rd) * step(rd, R * (1.35 + 0.5 * beat));
layer(acc, cover, ink, rayOn * rayLen * smoothstep(lw * 0.9 + 0.5, lw * 0.9 - 0.5, rayW));
layer(acc, cover, paper, rayOn * rayLen * smoothstep(lw * 0.4 + 0.5, lw * 0.4 - 0.5, rayW));
// The burst: black outline, yellow with orange dots, a red core and a white flash at its heart.
float3 yel = lerp(colorC.rgb, lerp(colorC.rgb, colorA.rgb, 0.45), step(benday(px, 0.11 * u, 0.25), 0.0));
float3 bcol = lerp(yel, colorA.rgb, step(inner, 0.0));
bcol = lerp(bcol, paper, smoothstep(R * 0.22, R * 0.08, rd) * (0.6 + 0.4 * beat));
layer(acc, cover, ink, vis * smoothstep(lw + 0.5, lw - 0.5, outer));
layer(acc, cover, bcol, vis * smoothstep(0.5, -0.5, outer));
layer(acc, cover, ink, vis * smoothstep(lw * 0.45 + 0.5, lw * 0.45 - 0.5, abs(inner)) * step(outer, 0.0));
return paint(acc / max(cover, 0.001), cover);
}