agentvfx 0.0.0-stage → 0.3.5

package/skills/agentvfx/templates/brutal/boot-log/main.frag

@@ -0,0 +1,242 @@
+// boot-log: monospace boot log typing over a field, dot-matrix emblem, corner + marks, side readouts,
+// progress bar, then a decode headline. Scanlines, slight bloom, phosphor flicker and beat tears.
+// brutal family shared GLSL (written fresh). Layout units are "design pixels" of a 1920x1080 frame:
+// U real pixels per design unit, D the fragment position in design units (origin top-left, y down).
+// Distance functions after the standard analytic forms (circle, box, segment, ellipse, equilateral
+// triangle: Inigo Quilez, https://iquilezles.org/articles/distfunctions2d/); the 3x5 digit font, the
+// dot screen, the Bayer matrix and the glyph icons are original.
+float U;
+vec2 D;
+const float TAU = 6.28318530718;
+
+void initDesign() {
+  U = RENDERSIZE.y / 1080.0;
+  D = vec2(gl_FragCoord.x, RENDERSIZE.y - gl_FragCoord.y) / U;
+}
+float designWidth() { return RENDERSIZE.x / U; }
+
+float fillAA(float d) { return clamp(0.5 - d * U, 0.0, 1.0); }
+float strokeAA(float d, float w) { return clamp((0.5 * w - abs(d)) * U + 0.5, 0.0, 1.0); }
+float sdBox(vec2 p, vec2 h) { vec2 q = abs(p) - h; return length(max(q, 0.0)) + min(max(q.x, q.y), 0.0); }
+float sdRound(vec2 p, vec2 h, float r) { return sdBox(p, h - r) - r; }
+// chamfered (octagon) rectangle: box cut by a diamond; c is the leg of each 45 degree corner cut
+float sdChamfer(vec2 p, vec2 h, float c, float r) {
+  vec2 hh = h - r;
+  return max(sdBox(p, hh), (abs(p.x) + abs(p.y) - (hh.x + hh.y - c)) * 0.70710678) - r;
+}
+float sdSeg(vec2 p, vec2 a, vec2 b) {
+  vec2 pa = p - a;
+  vec2 ba = b - a;
+  return length(pa - ba * clamp(dot(pa, ba) / dot(ba, ba), 0.0, 1.0));
+}
+float sdEll(vec2 p, vec2 r) {
+  float k0 = length(p / r);
+  float k1 = length(p / (r * r));
+  return k0 * (k0 - 1.0) / max(k1, 1e-4);
+}
+float sdTri(vec2 p, float r) {
+  const float k = 1.7320508;
+  p.x = abs(p.x) - r;
+  p.y = p.y + r / k;
+  if (p.x + k * p.y > 0.0) p = vec2(p.x - k * p.y, -k * p.x - p.y) / 2.0;
+  p.x -= clamp(p.x, -2.0 * r, 0.0);
+  return -length(p) * sign(p.y);
+}
+float sdRhomb(vec2 p, vec2 h) { return (abs(p.x) / h.x + abs(p.y) / h.y - 1.0) * min(h.x, h.y) * 0.9; }
+
+float plusMark(vec2 p, float arm) {
+  return max(strokeAA(sdSeg(p, vec2(-arm, 0.0), vec2(arm, 0.0)), 1.5), strokeAA(sdSeg(p, vec2(0.0, -arm), vec2(0.0, arm)), 1.5));
+}
+// radial lines between r0 and r1, n of them; spin rotates the whole burst, twist curls them
+float burst(vec2 p, float r0, float r1, float n, float w, float spin, float twist) {
+  float r = length(p);
+  float a = atan(p.y, p.x) + spin + twist * r / max(r1, 1.0);
+  float sec = TAU / n;
+  float da = mod(a + 0.5 * sec, sec) - 0.5 * sec;
+  return strokeAA(r * sin(da), w) * step(r0, r) * step(r, r1);
+}
+
+// pixel-snapped origin, so the pixel fonts stay crisp
+vec2 snapPx(vec2 o) { return floor(o * U + 0.5) / U; }
+float cellPx(float cell) { return max(1.0, floor(cell * U + 0.5)) / U; }
+
+// 3x5 digit font: 0-9, '-' (10), '.' (11); rows top to bottom, 3 bits per row
+const int F3[12] = int[12](0x7B6F, 0x2C97, 0x73E7, 0x73CF, 0x5BC9, 0x79CF, 0x79EF, 0x7292, 0x7BEF, 0x7BCF, 0x01C0, 0x0002);
+float glyph3(vec2 p, int g, float cell) {
+  ivec2 c = ivec2(floor(p / cell));
+  if (c.x < 0 || c.x > 2 || c.y < 0 || c.y > 4) return 0.0;
+  return float((F3[g] >> ((4 - c.y) * 3 + (2 - c.x))) & 1);
+}
+int digitOf(float a, int power) { return int(mod(floor(a * pow(10.0, -float(power))), 10.0)); }
+// fixed-width number: sign slot, nInt integer digits, then '.' and nDec decimals; p from the top-left
+float printNum(vec2 p, float v, int nInt, int nDec, float cell) {
+  float adv = 4.0 * cell;
+  int total = 1 + nInt + (nDec > 0 ? 1 + nDec : 0);
+  if (p.x < 0.0 || p.x >= float(total) * adv || p.y < 0.0 || p.y >= 5.0 * cell) return 0.0;
+  int idx = int(floor(p.x / adv));
+  vec2 q = vec2(p.x - float(idx) * adv, p.y);
+  int g = 11;
+  if (idx == 0) {
+    if (v >= 0.0) return 0.0;
+    g = 10;
+  } else if (idx <= nInt) {
+    g = digitOf(abs(v), nInt - idx);
+  } else if (idx > nInt + 1) {
+    g = digitOf(abs(v), -(idx - nInt - 1));
+  }
+  return glyph3(q, g, cell);
+}
+float numWidth(int nInt, int nDec, float cell) { return float(1 + nInt + (nDec > 0 ? 1 + nDec : 0)) * 4.0 * cell; }
+
+// 8x8 Bayer threshold 0..1 for an integer pixel cell
+float bayer8(vec2 cell) {
+  ivec2 i = ivec2(mod(floor(cell), 8.0));
+  int x = i.x;
+  int xy = i.x ^ i.y;
+  int v = ((xy & 1) << 5) | ((x & 1) << 4) | ((xy & 2) << 2) | ((x & 2) << 1) | ((xy & 4) >> 1) | ((x & 4) >> 2);
+  return (float(v) + 0.5) / 64.0;
+}
+
+float beatPulse(float rate) { return AUDIO_BPM > 1.0 ? exp(-AUDIO_BEATPHASE * rate) : 0.0; }
+
+// cover-fit UV into inputImage for a design-space point p inside a box (centre c, full size s)
+vec2 coverUV(vec2 p, vec2 c, vec2 s) {
+  vec2 tex = IMG_SIZE(inputImage);
+  float ta = tex.x / tex.y;
+  float wa = s.x / s.y;
+  vec2 q = (p - c) / s;
+  q.y = -q.y;
+  vec2 vis = wa > ta ? vec2(1.0, ta / wa) : vec2(wa / ta, 1.0);
+  return 0.5 + q * vis;
+}
+vec3 mediaRaw(vec2 uv) {
+  if (HAS_INPUT) return texture(inputImage, uv).rgb;
+  float n = fbm(uv * 3.6 + vec2(TIME * 0.06, 0.0), 4);
+  float m = fbm(uv * 7.0 - vec2(0.0, TIME * 0.05) + 3.1, 3);
+  return vec3(smoothstep(0.3, 0.75, n) * (0.35 + 0.65 * m)) * vec3(1.0, 0.9, 0.78);
+}
+// dot-matrix emblem: a mirrored 13x13 cell pattern that re-rolls on beats, inside a bracket frame
+float emblem(vec2 p, vec2 o, float pitch, float rollSeed) {
+  vec2 q = (p - o) / pitch;
+  vec2 id = floor(q);
+  if (id.x < 0.0 || id.y < 0.0 || id.x > 12.0 || id.y > 12.0) return 0.0;
+  vec2 m = vec2(abs(id.x - 6.0), id.y);
+  float reach = max(abs(id.x - 6.0), abs(id.y - 6.0));
+  float body = step(0.5, hash12(m + vec2(rollSeed * 1.7, 3.0)));
+  float rim = step(0.35, hash12(m + vec2(1.0, rollSeed)));
+  float on = mix(body, rim, step(5.5, reach));
+  on = max(on, step(reach, 1.5) * step(0.4, hash12(m + 9.0)));
+  vec2 f = fract(q) - 0.5;
+  return on * fillAA((length(f) - 0.34) * pitch);
+}
+
+// side readout column: rows of 4-digit codes that scroll and re-roll
+float sideColumn(vec2 p, float x0, float y0, float seed, float cell) {
+  float rowH = 7.4 * cell;
+  float r = floor((p.y - y0) / rowH);
+  if (r < 0.0 || r > 38.0) return 0.0;
+  float scroll = floor(TIME * 6.0 + seed);
+  float v = floor(hash12(vec2(r + scroll, seed)) * 9999.0);
+  vec2 o = snapPx(vec2(x0, y0 + r * rowH));
+  float fade = step(0.18, hash12(vec2(r, seed + 4.0)));
+  return printNum(p - o, v, 4, 0, cell) * fade;
+}
+
+float bloomTaps(vec2 uv, float rad) {
+  float s = 0.0;
+  for (int i = 0; i < 12; i++) {
+    float a = float(i) * 0.5236 + rad;
+    s += texture(TEXTMASK, uv + vec2(cos(a), sin(a)) * rad * U / RENDERSIZE).r;
+  }
+  return s * 0.0833;
+}
+
+void main() {
+  initDesign();
+  float W = designWidth();
+  float pulse = beatPulse(9.0);
+  float beatOn = step(0.3, pulse);
+  vec2 uv = vUv;
+  // beat tear: row blocks slide
+  float row = floor(D.y / 16.0);
+  float f2 = float(FRAMEINDEX / 2);
+  uv.x += beatOn * tearAmount * (hash12(vec2(row, f2)) - 0.5) * 0.06 * step(0.7, hash12(vec2(row, f2 + 5.0)));
+
+  vec4 tm = HAS_TEXT ? texture(TEXTMASK, uv) : vec4(0.0);
+  float bloom = HAS_TEXT ? 0.4 * bloomTaps(uv, 3.0) + 0.35 * bloomTaps(uv, 8.0) + 0.25 * bloomTaps(uv, 16.0) : 0.0;
+  float tInk = tm.r;
+  bool headlineZone = D.y > 740.0 && D.y < 930.0;
+
+  vec3 col = fieldColor.rgb;
+  float ink = 0.0;
+  float dim = 0.0;
+
+  // pixel dust (clustered) and glowing data streaks
+  vec2 dc = floor(D / 8.0);
+  float cluster = smoothstep(0.55, 0.8, fbm(dc * 0.07 + vec2(TIME * 0.05, 0.0), 3));
+  dim = max(dim, cluster * step(0.955, hash12(dc + floor(TIME * 8.0))) * dustAmount);
+  for (int k = 0; k < 3; k++) {
+    float seedK = floor(TIME * 9.0) + float(k) * 13.0;
+    float yS = 240.0 + 640.0 * hash12(vec2(seedK, 1.0));
+    float x0 = W * hash12(vec2(seedK, 2.0));
+    float len = 120.0 + 520.0 * hash12(vec2(seedK, 3.0));
+    float on = step(0.45, hash12(vec2(seedK, 4.0))) * step(x0, D.x) * step(D.x, x0 + len);
+    float core = strokeAA(D.y - yS, 1.6) * on;
+    dim = max(dim, core * streakAmount);
+    col += inkColor.rgb * exp(-abs(D.y - yS) * 0.12) * on * streakAmount * 0.18 * (1.0 + pulse);
+  }
+
+  // emblem + brackets
+  float rv = clamp((TIME * 1000.0 - introMs * 0.2) / 140.0, 0.0, 1.0);
+  float roll = floor(TIME * 2.0) + float(FRAMEINDEX / 8) * beatOn;
+  ink = max(ink, emblem(D, vec2(64.0, 64.0), 10.0, roll) * rv);
+  vec2 ec = vec2(64.0 + 65.0, 64.0 + 65.0);
+  vec2 eq = abs(D - ec) / 74.0;
+  ink = max(ink, strokeAA(sdBox(D - ec, vec2(74.0)), 1.5) * step(0.62, min(eq.x, eq.y)) * rv);
+
+  // corner + marks
+  for (int i = 0; i < 4; i++) {
+    vec2 c = vec2(i % 2 == 0 ? 36.0 : W - 36.0, i < 2 ? 74.0 : 1006.0);
+    ink = max(ink, plusMark(D - c, 10.0));
+  }
+  // side readouts (right and a thin left tick column)
+  float cell = cellPx(2.6);
+  dim = max(dim, sideColumn(D, W - 150.0, 262.0, 3.0, cell) * rv);
+  dim = max(dim, sideColumn(D, W - 90.0, 262.0, 11.0, cell) * rv * 0.7);
+  for (int i = 0; i < 24; i++) {
+    float yT = 262.0 + float(i) * 29.6;
+    dim = max(dim, strokeAA(sdSeg(D, vec2(W - 170.0, yT), vec2(W - 170.0 + (i % 4 == 0 ? 14.0 : 7.0), yT)), 1.2));
+  }
+
+  // progress bar: dot-matrix blocks, completes with the log
+  float prog = clamp((TIME - 0.2) / max(logDone - 0.2, 0.1), 0.0, 1.0);
+  vec2 bo = vec2(64.0, 936.0);
+  vec2 bp = D - bo;
+  float blocks = step(0.0, bp.x) * step(bp.x, 640.0) * step(0.0, bp.y) * step(bp.y, 16.0);
+  float bi = floor(bp.x / 10.0);
+  float full = step(bi, prog * 64.0 - 1.0);
+  float cellIn = step(fract(bp.x / 10.0), 0.78) * step(2.0, bp.y) * step(bp.y, 14.0);
+  ink = max(ink, blocks * cellIn * full);
+  dim = max(dim, blocks * cellIn * (1.0 - full) * 0.6);
+  ink = max(ink, strokeAA(sdBox(bp - vec2(320.0, 8.0), vec2(324.0, 12.0)), 1.3));
+  ink = max(ink, printNum(D - snapPx(vec2(700.0, 936.0)), floor(prog * 100.0), 2, 0, cellPx(3.2)) * 1.0);
+
+  col = mix(col, inkColor.rgb, clamp(dim, 0.0, 1.0) * 0.55);
+  float t = tInk * clamp((TIME * 1000.0 - introMs * 0.05) / 100.0, 0.0, 1.0);
+  vec3 textCol = headlineZone ? hotColor.rgb : inkColor.rgb;
+  col = mix(col, inkColor.rgb, clamp(ink, 0.0, 1.0));
+  col = mix(col, textCol, clamp(t, 0.0, 1.0));
+  col = mix(col, inkColor.rgb, clamp(bloom * bloomAmount, 0.0, 1.0) * (1.0 - t) * 0.6);
+
+  // CRT: scanlines, flicker, vignette, curved letterbox
+  float scan = 1.0 - scanAmount * 0.5 * (1.0 + sin(gl_FragCoord.y * 3.14159));
+  float flick = 1.0 - flickerAmount * hash12(vec2(float(FRAMEINDEX), 3.0)) * (0.4 + pulse);
+  vec2 vq = vUv * 2.0 - 1.0;
+  float vig = 1.0 - vignette * dot(vq * vec2(0.7, 0.9), vq * vec2(0.7, 0.9));
+  col *= scan * flick * vig;
+  float u2 = pow(2.0 * vUv.x - 1.0, 2.0);
+  float edge = letterbox * (1.0 - 0.5 * (1.0 - u2));
+  float yd = min(D.y, 1080.0 - D.y);
+  col = mix(vec3(0.0), col, clamp((yd - edge) * U + 0.5, 0.0, 1.0));
+  fragColor = vec4(col, 1.0);
+}

package/skills/agentvfx/templates/brutal/collage/_src/00-lib.glsl

@@ -0,0 +1,73 @@
+// collage main (generated from _src/*.glsl by _src/build.mjs; edit the parts, not this file).
+// A collage on a 32 x 18 grid. Pass 0 decodes up to 16 cells (cell0.., style0.., src0.. inputs; or a seeded
+// partition rebuilt on every cut in reshuffle mode) into the state texture; this pass draws them in list order.
+// A cell is either the old boxed "tile" panel (gutter, header strip, frame) or an editorial cell with no box
+// of its own: footage, hairline spectrum / scope / meters, live numbers, registration marks, rules and "type"
+// cells that window the engine text sheet. Pixel units: U = pixels per design pixel at 1080p. Cells hold their
+// place; only the instruments move, and nothing eases.
+float U;
+float HW;
+const int MAXL = 16;
+const float HEAD = 22.0;
+
+float hlw(float d, float w) { return clamp(w * 0.5 - abs(d) + 0.5, 0.0, 1.0); }
+float hl(float d) { return hlw(d, HW); }
+float cov(float d) { return clamp(0.5 - d, 0.0, 1.0); }
+float inBox(vec2 p, vec2 lo, vec2 hi) { return step(lo.x, p.x) * step(p.x, hi.x) * step(lo.y, p.y) * step(p.y, hi.y); }
+float boxLnW(vec2 p, vec2 lo, vec2 hi, float w) {
+  vec2 q = abs(p - (lo + hi) * 0.5) - (hi - lo) * 0.5;
+  return hlw(max(q.x, q.y), w);
+}
+float dashed(float x, float period, float duty) { return step(fract(x / (period * U)), duty); }
+float plusAt(vec2 p, vec2 c, float arm) {
+  vec2 d = abs(p - c);
+  return max(hl(d.y) * step(d.x, arm), hl(d.x) * step(d.y, arm));
+}
+
+vec4 stClock() { return texelFetch(state, ivec2(0, 0), 0); }
+vec4 stLevel() { return texelFetch(state, ivec2(1, 0), 0); }
+vec4 stHit() { return texelFetch(state, ivec2(3, 0), 0); }
+float stBand(int i) { return texelFetch(state, ivec2(i, 1), 0).r; }
+
+// 3 x 5 pixel font, 3 bits per row, row 0 at the top. Index: 0-9, A-Z (10..35), . - + / : % (36..41).
+//@FONT@
+int fontIndex(int ch) {
+  if (ch >= 48 && ch <= 57) { return ch - 48; }
+  if (ch >= 65 && ch <= 90) { return ch - 55; }
+  if (ch == 46) { return 36; }
+  if (ch == 45) { return 37; }
+  if (ch == 43) { return 38; }
+  if (ch == 47) { return 39; }
+  if (ch == 58) { return 40; }
+  if (ch == 37) { return 41; }
+  return -1;
+}
+float cellPx(float c) { return max(1.0, floor(c + 0.5)); }
+float glyphAt(vec2 p, int ch, float cell) {
+  int gi = fontIndex(ch);
+  if (gi < 0 || p.x < 0.0 || p.y < 0.0) { return 0.0; }
+  ivec2 c = ivec2(floor(p / cell));
+  if (c.x > 2 || c.y > 4) { return 0.0; }
+  return float((FONT[gi] >> ((4 - c.y) * 3 + (2 - c.x))) & 1);
+}
+// up to four characters (ASCII codes, 0 = none) from the top-left o; advance is 4 cells
+float txt4(vec2 p, vec2 o, float cell, int a, int b, int c, int d) {
+  vec2 q = p - o;
+  if (q.x < 0.0 || q.y < 0.0) { return 0.0; }
+  float adv = 4.0 * cell;
+  int i = int(floor(q.x / adv));
+  if (i > 3) { return 0.0; }
+  int ch = i == 0 ? a : (i == 1 ? b : (i == 2 ? c : d));
+  return glyphAt(vec2(q.x - float(i) * adv, q.y), ch, cell);
+}
+// non-negative integer with nd digits
+float numTxt(vec2 p, vec2 o, float cell, float v, int nd) {
+  vec2 q = p - o;
+  if (q.x < 0.0 || q.y < 0.0) { return 0.0; }
+  float adv = 4.0 * cell;
+  int i = int(floor(q.x / adv));
+  if (i >= nd) { return 0.0; }
+  int dg = int(mod(floor(v / pow(10.0, float(nd - 1 - i)) + 0.001), 10.0));
+  return glyphAt(vec2(q.x - float(i) * adv, q.y), 48 + dg, cell);
+}
+float numW(int nd, float cell) { return float(nd) * 4.0 * cell - cell; }

package/skills/agentvfx/templates/brutal/collage/_src/10-spectrum-scope.glsl

@@ -0,0 +1,73 @@
+// Panels return vec3(ink, accent, negative) coverage; q is in pixels from the panel's top-left, S its size.
+
+// spectrum steps: columns of dashes that light in whole rows, accent on the top row of each column
+vec3 pSpectrum(vec2 q, vec2 S) {
+  float pad = 10.0 * U;
+  vec2 lo = vec2(pad, HEAD * U + pad);
+  vec2 hi = vec2(S.x - pad, S.y - pad - 14.0 * U);
+  vec2 sz = hi - lo;
+  float ink = 0.0;
+  float acc = 0.0;
+  float xr = step(lo.x, q.x) * step(q.x, hi.x);
+  for (int r = 1; r < 4; r++) {
+    float yr = hi.y - sz.y * float(r) / 4.0;
+    ink = max(ink, hl(q.y - yr) * dashed(q.x, 6.0, 0.35) * xr * 0.4);
+  }
+  ink = max(ink, hl(q.y - hi.y) * xr);
+  float pitch = sz.x / float(bands);
+  float cx = q.x - lo.x;
+  int b = int(floor(cx / pitch));
+  if (cx >= 0.0 && b < bands) {
+    float rows = max(floor(sz.y / (6.0 * U)), 4.0);
+    float rowH = sz.y / rows;
+    float lit = floor(stBand(b) * rows + 0.5);
+    float y = hi.y - q.y;
+    float xin = mod(cx, pitch);
+    float on = step(0.0, y) * step(floor(y / rowH), lit - 1.0) * step(U, xin) * step(xin, pitch - U) * step(fract(y / rowH), 0.7) * step(0.5, lit);
+    ink = max(ink, on * 0.6);
+    acc = max(acc, on * step(lit - 1.5, floor(y / rowH)));
+  }
+  float span = log(endFreq / startFreq);
+  for (int k = 0; k < 3; k++) {
+    float f = k == 0 ? 100.0 : (k == 1 ? 1000.0 : 10000.0);
+    float tx = log(f / startFreq) / span;
+    if (tx <= 0.0 || tx >= 1.0) { continue; }
+    float x = lo.x + tx * sz.x;
+    ink = max(ink, hl(q.x - x) * step(hi.y, q.y) * step(q.y, hi.y + 5.0 * U));
+    float c = cellPx(2.0 * U);
+    ink = max(ink, k == 0 ? txt4(q, vec2(x + 3.0 * U, hi.y + 5.0 * U), c, 49, 48, 48, 0) : (k == 1 ? txt4(q, vec2(x + 3.0 * U, hi.y + 5.0 * U), c, 49, 75, 0, 0) : txt4(q, vec2(x + 3.0 * U, hi.y + 5.0 * U), c, 49, 48, 75, 0)));
+  }
+  return vec3(ink, acc, 0.0);
+}
+
+float waveAt(float i) { return texture(audio, vec2((clamp(i, 0.0, 511.0) + 0.5) / 512.0, 0.25)).r - 0.5; }
+float waveI(float i) {
+  float f = floor(i);
+  return mix(waveAt(f), waveAt(f + 1.0), i - f);
+}
+
+// scope trace: dashed graticule, centre axis with ticks, a trigger-aligned trace drawn as the vertical
+// extent of the wave across each pixel column so steep edges stay solid
+vec3 pScope(vec2 q, vec2 S) {
+  float pad = 10.0 * U;
+  vec2 lo = vec2(pad, HEAD * U + pad);
+  vec2 hi = S - vec2(pad);
+  vec2 sz = hi - lo;
+  float yc = (lo.y + hi.y) * 0.5;
+  float inb = inBox(q, lo, hi);
+  float ink = 0.0;
+  for (int k = 1; k < 8; k++) { ink = max(ink, hl(q.x - (lo.x + sz.x * float(k) / 8.0)) * dashed(q.y, 6.0, 0.3) * inb * 0.35); }
+  for (int k = 1; k < 4; k++) { ink = max(ink, hl(q.y - (lo.y + sz.y * float(k) / 4.0)) * dashed(q.x, 6.0, 0.3) * inb * 0.35); }
+  float tick = step(abs(q.y - yc), (fract((q.x - lo.x) / (sz.x / 40.0) + 0.5) < 0.1 ? 3.0 : 0.0) * U) * inb;
+  ink = max(ink, max(hl(q.y - yc) * inb * 0.7, tick * 0.7));
+  ink = max(ink, max(hl(q.x - lo.x + 5.0 * U), 0.0) * step(abs(q.y - yc), 4.0 * U) * step(q.x, lo.x));
+  float dx = 0.5 / sz.x * 511.0;
+  float t = (q.x - lo.x) / sz.x * 511.0;
+  float yA = yc - waveI(t - dx) * scopeGain * sz.y;
+  float yB = yc - waveI(t + dx) * scopeGain * sz.y;
+  float yMin = clamp(min(yA, yB), lo.y, hi.y);
+  float yMax = clamp(max(yA, yB), lo.y, hi.y);
+  float d = max(max(yMin - q.y, q.y - yMax), 0.0);
+  float acc = hlw(d, HW * 1.15) * step(lo.x, q.x) * step(q.x, hi.x);
+  return vec3(ink, acc, 0.0);
+}

package/skills/agentvfx/templates/brutal/collage/_src/20-meter-readout-cross.glsl

@@ -0,0 +1,87 @@
+// level meter: four segmented channels (bass, mid, treble, rms) that fill in whole segments, accent on the
+// top lit segment and the clip zone; the long side of the panel is the scale
+vec3 pMeter(vec2 q, vec2 S) {
+  vec4 lv = stLevel();
+  float pad = 10.0 * U;
+  vec2 lo = vec2(pad, HEAD * U + pad);
+  vec2 hi = vec2(S.x - pad, S.y - pad - 12.0 * U);
+  vec2 a = q - lo;
+  vec2 sz = hi - lo;
+  bool vert = S.y >= S.x * 0.75;
+  float len = vert ? sz.y : sz.x;
+  float wid = vert ? sz.x : sz.y;
+  float along = vert ? sz.y - a.y : a.x;
+  float across = vert ? a.x : a.y;
+  float chW = wid / 4.0;
+  float c = cellPx(2.0 * U);
+  vec2 lp = q - vec2(lo.x, hi.y + 4.0 * U);
+  int lc = int(clamp(floor(lp.x / chW), 0.0, 3.0));
+  vec2 lo_ = vec2(lp.x - float(lc) * chW - (chW * 0.5 - 6.0 * c), lp.y);
+  float labels = !vert || lp.x < 0.0 ? 0.0 : (lc == 0 ? txt4(lo_, vec2(0.0), c, 66, 83, 83, 0) : (lc == 1 ? txt4(lo_, vec2(0.0), c, 77, 73, 68, 0) : (lc == 2 ? txt4(lo_, vec2(0.0), c, 84, 82, 66, 0) : txt4(lo_, vec2(0.0), c, 82, 77, 83, 0))));
+  if (along < 0.0 || across < 0.0 || along >= len || across >= wid) { return vec3(labels, 0.0, 0.0); }
+  int ch = int(floor(across / chW));
+  float within = fract(across / chW);
+  float nseg = max(floor(len / (6.0 * U)), 8.0);
+  float segLen = len / nseg;
+  float seg = floor(along / segLen);
+  float lit = floor(lv[ch] * nseg + 0.5);
+  float shape = step(fract(along / segLen), 0.68) * step(0.16, within) * step(within, 0.84);
+  float on = shape * step(seg, lit - 1.0) * step(0.5, lit);
+  float off = shape * (1.0 - on) * 0.16;
+  float clip = step(nseg * 0.8, seg);
+  float top = step(lit - 1.5, seg);
+  float acc = on * max(clip, top);
+  float ink = max(on * (1.0 - acc) * 0.85, off);
+  return vec3(max(ink, labels), acc, 0.0);
+}
+
+// readout: one large three digit number (rms x 999), then smaller rows for tempo, cut index and frame
+vec3 pReadout(vec2 q, vec2 S, vec4 clk) {
+  vec4 lv = stLevel();
+  float pad = 10.0 * U;
+  float top = HEAD * U + pad;
+  float big = cellPx(min((S.x - 2.0 * pad) / 11.0, (S.y - top) * 0.42 / 5.0));
+  float ink = numTxt(q, vec2(pad, top), big, floor(lv.a * 999.0), 3);
+  float small = cellPx(min(4.0 * U, big * 0.5));
+  float rowStep = 5.0 * small + 8.0 * U;
+  float y0 = S.y - pad - 5.0 * small - 2.0 * rowStep;
+  ink = max(ink, hl(q.y - (y0 - 6.0 * U)) * step(pad, q.x) * step(q.x, S.x - pad) * 0.6);
+  float valX = pad + 16.0 * small;
+  ink = max(ink, txt4(q, vec2(pad, y0), small, 66, 80, 77, 0) + numTxt(q, vec2(valX, y0), small, floor(AUDIO_BPM), 3));
+  ink = max(ink, txt4(q, vec2(pad, y0 + rowStep), small, 67, 85, 84, 0) + numTxt(q, vec2(valX, y0 + rowStep), small, mod(clk.x, 1000.0), 3));
+  ink = max(ink, txt4(q, vec2(pad, y0 + 2.0 * rowStep), small, 70, 82, 77, 0) + numTxt(q, vec2(valX, y0 + 2.0 * rowStep), small, mod(float(FRAMEINDEX), 1000.0), 3));
+  float pulse = step(float(FRAMEINDEX) - clk.w, 1.5) * step(0.5, clk.z);
+  float lamp = inBox(q, vec2(S.x - pad - 10.0 * U, top), vec2(S.x - pad, top + 10.0 * U));
+  return vec3(min(ink, 1.0), lamp * pulse, 0.0);
+}
+
+// crosshair: hairlines through a target that follows the spectral balance (x) and loudness (y), tick
+// scales, a ring that tracks rms and a second ring that steps outward for three frames after each onset
+vec3 pCross(vec2 q, vec2 S, vec4 clk) {
+  vec4 lv = stLevel();
+  float pad = 10.0 * U;
+  vec2 lo = vec2(pad, HEAD * U + pad);
+  vec2 hi = S - vec2(pad);
+  vec2 ctr = (lo + hi) * 0.5;
+  vec2 half_ = (hi - lo) * 0.5;
+  vec2 tp = ctr + half_ * vec2(0.6 * (lv.b - lv.r), -0.7 * (lv.a * 1.8 - 0.7));
+  tp = clamp(tp, lo + 8.0 * U, hi - 8.0 * U);
+  float inb = inBox(q, lo, hi);
+  vec2 d = q - tp;
+  float ink = max(hl(d.y) * inb, hl(d.x) * inb) * 0.8;
+  float tickX = step(abs(d.y), (fract(d.x / (8.0 * U) + 0.5) < 0.12 ? (fract(d.x / (40.0 * U) + 0.5) < 0.12 ? 7.0 : 3.5) : 0.0) * U);
+  float tickY = step(abs(d.x), (fract(d.y / (8.0 * U) + 0.5) < 0.12 ? (fract(d.y / (40.0 * U) + 0.5) < 0.12 ? 7.0 : 3.5) : 0.0) * U);
+  ink = max(ink, max(tickX, tickY) * inb);
+  float r = length(d);
+  float base = min(half_.x, half_.y);
+  float ringA = hl(r - base * (0.2 + 0.45 * lv.a));
+  float hitF = float(FRAMEINDEX) - clk.w;
+  float ringB = hitF < 3.0 && clk.z > 0.5 ? hl(r - base * (0.8 + 0.3 * hitF)) : 0.0;
+  float dot_ = inBox(d, vec2(-3.0 * U), vec2(3.0 * U));
+  float mid = hl(length(q - ctr) - base * 0.75) * dashed(atan(q.y - ctr.y, q.x - ctr.x) * base * 0.75, 7.0, 0.35) * 0.4;
+  float acc = max(max(ringA, ringB), dot_) * inb;
+  float c = cellPx(2.0 * U);
+  float xy = numTxt(q, vec2(lo.x + 4.0 * U, hi.y - 12.0 * U), c, floor(clamp((tp.x - lo.x) / (hi.x - lo.x), 0.0, 1.0) * 999.0), 3)
+           + numTxt(q, vec2(hi.x - numW(3, c) - 4.0 * U, hi.y - 12.0 * U), c, floor(clamp(1.0 - (tp.y - lo.y) / (hi.y - lo.y), 0.0, 1.0) * 999.0), 3);
+  return vec3(min(max(ink, max(mid, xy)), 1.0), acc, 0.0);
+}

package/skills/agentvfx/templates/brutal/collage/_src/30-footage-fillers.glsl

@@ -0,0 +1,92 @@
+// footage: cover-fit into the cell below `top` (the tile header height, 0 for editorial cells), contrast curve,
+// optional single-tone mix, saturation and dim, scanlines. Variants 1..4 lay a dark scrim over it (bottom, top,
+// left, vignette, bottom plus vignette) so type reads on top. Without an input the cell shows a crossed empty-media mark.
+vec3 footageBody(vec2 q, vec2 S, float top, int variant) {
+  vec2 lo = vec2(0.0, top);
+  vec2 sz = S - lo;
+  vec2 d = (q - (lo + S) * 0.5) / sz;
+  vec2 tex = IMG_SIZE(inputImage);
+  float ta = tex.x / tex.y;
+  float wa = sz.x / sz.y;
+  vec2 vis = wa > ta ? vec2(1.0, ta / wa) : vec2(wa / ta, 1.0);
+  vec3 c = texture(inputImage, vec2(0.5 + d.x * vis.x, 0.5 - d.y * vis.y)).rgb;
+  c = max((c - 0.18) * footageContrast + 0.18, 0.0);
+  vec3 duo = mix(groundColor.rgb, inkColor.rgb, smoothstep(0.02, 0.6, luma(c)));
+  c = mix(c, duo, footageTone);
+  c = mix(vec3(luma(c)), c, footageSat) * (1.0 - footageDim);
+  vec2 u = (q - lo) / sz;
+  float scrim = 1.0;
+  if (variant == 1) { scrim = smoothstep(0.32, 1.0, u.y); }
+  if (variant == 2) { scrim = smoothstep(0.68, 0.0, u.y); }
+  if (variant == 3) { scrim = smoothstep(0.7, 0.0, u.x); }
+  if (variant == 4) { scrim = smoothstep(0.35, 1.0, length((u - 0.5) * vec2(1.0, 1.15)) * 1.6); }
+  if (variant == 5) { scrim = max(smoothstep(0.3, 0.95, u.y), smoothstep(0.3, 1.0, length((u - 0.5) * vec2(1.0, 1.25)) * 1.5) * 0.85); }
+  if (variant == 6) { scrim = 0.93; }
+  if (variant == 7) { scrim = 0.55; }
+  c *= mix(1.0, 0.1, scrim * step(0.5, float(variant)));
+  return c * (1.0 - footageScan * step(0.5, fract(q.y / (3.0 * U))));
+}
+
+float hatch(vec2 q, float pitch) { return hl(mod(q.x + q.y, pitch * U) - pitch * 0.5 * U); }
+
+// fillers: 7 = ruler or pixel cluster, 8 = accent plate with the cut number or hatching, 9 = sparse hatch
+vec3 pFiller(int role, vec2 q, vec2 S, float hs, vec4 clk) {
+  float pad = 10.0 * U;
+  float top = HEAD * U;
+  bool wide = S.x >= S.y;
+  if (role == 7 && hs < 0.5) {
+    float along = wide ? q.x : S.y - q.y;
+    float across = wide ? S.y - q.y : q.x;
+    float k = floor(along / (8.0 * U) + 0.5);
+    float len = (mod(k, 5.0) < 0.5 ? 14.0 : 6.0) * U;
+    float tk = step(abs(along - k * 8.0 * U), HW * 0.5 + 0.5) * step(across, len) * step(top, q.y) * step(pad * 0.5, along);
+    float base = hl(across) * step(top, q.y);
+    float c = cellPx(2.0 * U);
+    float mj = floor((along - 3.0 * U) / (40.0 * U));
+    vec2 o = wide ? vec2(mj * 40.0 * U + 3.0 * U, S.y - 18.0 * U - 5.0 * c) : vec2(18.0 * U, S.y - (mj * 40.0 * U + 3.0 * U) - 5.0 * c);
+    float nTxt = mj >= 0.0 ? numTxt(q, o, c, mod(mj, 100.0), 2) * step(top + 3.0 * U, q.y) : 0.0;
+    return vec3(max(max(tk, base) * 0.8, nTxt), 0.0, 0.0);
+  }
+  if (role == 7) {
+    vec2 g = (q - vec2(pad, top + pad)) / (11.0 * U);
+    vec2 id = floor(g + 0.5);
+    float lit = step(0.72, fract(sin(dot(id + clk.x * 1.7, vec2(12.9898, 78.233))) * 43758.5453));
+    float dotc = cov(length((g - id) * 11.0 * U) - (1.2 + 1.3 * lit) * U) * inBox(q, vec2(pad, top + pad), S - vec2(pad));
+    return vec3(dotc * (1.0 - lit) * 0.7, dotc * lit, 0.0);
+  }
+  if (role == 8 && hs < 0.6 && plateAmount > 0.5) {
+    float cn = cellPx(min(S.x * 0.78 / 11.0, S.y * 0.5 / 5.0));
+    vec2 o = vec2(pad, S.y - pad - 5.0 * cn);
+    return vec3(0.0, 1.0, numTxt(q, o, cn, mod(clk.x, 1000.0), 3));
+  }
+  float hp = role == 8 ? 9.0 : 16.0;
+  float amt = role == 8 ? 0.5 : 0.28;
+  float h = hatch(q, hp) * step(top, q.y) * amt;
+  float cr = role == 9 ? plusAt(q, (vec2(0.0, top) + S) * 0.5, min(S.x, S.y) * 0.12) : 0.0;
+  return vec3(max(h, cr), 0.0, 0.0);
+}
+
+// header strip: frame, rule under the label, role tag, and the cut number (or timecode for the footage panel)
+vec3 panelHead(int role, float hs, vec2 q, vec2 S, vec4 clk, float snap) {
+  float w = snap > 0.5 ? HW * 3.0 : HW;
+  float frame = boxLnW(q, vec2(0.0), S, w);
+  float rule = hl(q.y - HEAD * U) * step(0.0, q.x) * step(q.x, S.x);
+  float c = cellPx(2.5 * U);
+  vec2 o = vec2(8.0 * U, (HEAD * U - 5.0 * c) * 0.5);
+  float tag = role == 1 ? txt4(q, o, c, 83, 82, 67, 0) : (role == 2 ? txt4(q, o, c, 70, 70, 84, 0) : (role == 3 ? txt4(q, o, c, 79, 83, 67, 0)
+    : (role == 4 ? txt4(q, o, c, 76, 86, 76, 0) : (role == 5 ? txt4(q, o, c, 78, 85, 77, 0) : (role == 6 ? txt4(q, o, c, 88, 72, 82, 0)
+    : (role == 7 ? (hs < 0.5 ? txt4(q, o, c, 82, 85, 76, 0) : txt4(q, o, c, 80, 73, 88, 0)) : txt4(q, o, c, 72, 67, 72, 0)))))));
+  float right = 0.0;
+  if (role == 1) {
+    float tc = TIME;
+    float x0 = S.x - 8.0 * U - 31.0 * c;
+    vec2 p = vec2(x0, o.y);
+    right = numTxt(q, p, c, floor(tc / 60.0), 2) + glyphAt(q - p - vec2(8.0 * c, 0.0), 58, c)
+          + numTxt(q, p + vec2(12.0 * c, 0.0), c, mod(floor(tc), 60.0), 2) + glyphAt(q - p - vec2(20.0 * c, 0.0), 58, c)
+          + numTxt(q, p + vec2(24.0 * c, 0.0), c, mod(float(FRAMEINDEX), 30.0), 2);
+  } else {
+    right = numTxt(q, vec2(S.x - 8.0 * U - numW(3, c), o.y), c, mod(clk.x, 1000.0), 3);
+  }
+  float ink = max(max(frame, rule * (role == 8 ? 0.0 : 1.0)), max(tag, min(right, 1.0)));
+  return vec3(ink, snap > 0.5 ? frame : 0.0, 0.0);
+}