agentvfx 0.0.0-stage → 0.3.5

package/skills/agentvfx/templates/brutal/_src/halftone-field/main.src.frag

@@ -0,0 +1,94 @@
+// halftone-field: footage as one-tone dot matrix (dot screen, ordered dither or ASCII cells) on a full solid
+// field, framed by a hairline with pink / cyan micro bars on the image edges and a tall thin headline.
+//@include lib.glsl
+
+vec2 gC;
+vec2 gH;
+
+// beat tears: rows of the image slide sideways for a couple of frames after a beat
+vec2 tearP(vec2 p) {
+  float on = step(0.3, beatPulse(8.0)) * tearAmount;
+  if (on <= 0.0) return p;
+  float row = floor(p.y / 18.0);
+  float f = float(FRAMEINDEX / 2);
+  p.x += (hash12(vec2(row, f)) - 0.5) * 2.0 * on * 120.0 * step(0.6, hash12(vec2(row, f + 2.3)));
+  return p;
+}
+float lumAt(vec2 p) {
+  vec2 uv = coverUV(tearP(p), gC, gH * 2.0);
+  float L = pow(clamp(luma(mediaRaw(uv)), 0.0, 1.0), 0.4545);
+  L = clamp((L - 0.5) * imgContrast + 0.5 + imgBias, 0.0, 1.0);
+  return invert ? 1.0 - L : L;
+}
+//@include screen.glsl
+
+// edge bars: short horizontal ticks hung inward from the left / right image edges, lengths ride the bands
+float edgeBars(vec2 p, vec2 lo, vec2 hi, out vec3 tint) {
+  tint = vec3(0.0);
+  float m = 0.0;
+  float slotH = 7.0;
+  float y = p.y - lo.y;
+  if (y < 0.0 || p.y > hi.y) return 0.0;
+  float slot = floor(y / slotH);
+  float fy = fract(y / slotH);
+  for (int side = 0; side < 2; side++) {
+    float sid = slot * 2.0 + float(side);
+    float h1 = hash12(vec2(sid, 4.0));
+    float h2 = hash12(vec2(sid, 9.0));
+    float band = AUDIO_BANDS[int(mod(slot * 3.0 + float(side) * 7.0, 28.0))];
+    float len = (6.0 + 70.0 * h2 * h2) * (0.45 + 1.1 * band * reactivity);
+    float edge = side == 0 ? p.x - lo.x : hi.x - p.x;
+    float on = step(0.0, edge) * step(edge, len) * step(0.1, fy) * step(fy, 0.62) * step(1.0 - barDensity, h1);
+    if (on > m) tint = h2 > 0.5 ? barA.rgb : barB.rgb;
+    m = max(m, on);
+  }
+  return m;
+}
+
+void main() {
+  initDesign();
+  float W = designWidth();
+  gC = vec2(imgX * W, imgY * 1080.0);
+  gH = vec2(imgW * W, imgH * 1080.0) * 0.5;
+  float kick = clamp((AUDIO_BASS - 1.0) / 3.0, 0.0, 1.0);
+  vec3 col = fieldColor.rgb;
+  vec2 lo = gC - gH;
+  vec2 hi = gC + gH;
+  float inRect = step(lo.x, D.x) * step(D.x, hi.x) * step(lo.y, D.y) * step(D.y, hi.y);
+
+  vec4 tm = HAS_TEXT ? texture(TEXTMASK, vUv) : vec4(0.0);
+  float halo = 0.0;
+  if (HAS_TEXT && inRect > 0.0) {
+    for (int i = 0; i < 8; i++) {
+      float a = float(i) * 0.7854;
+      halo = max(halo, texture(TEXTMASK, vUv + vec2(cos(a), sin(a)) * 4.0 / RENDERSIZE).r);
+    }
+  }
+
+  float dots = 0.0;
+  if (inRect > 0.0) {
+    float gain = dotGain * (1.0 + kickGain * kick * 0.3);
+    if (screenMode == 0) dots = dotScreen(D, cell, dotAngle, gain, 1.0);
+    else if (screenMode == 1) dots = orderedDither(D, max(2.0, cell * 0.36));
+    else dots = asciiScreen(D, cell * 1.5);
+    dots *= 1.0 - halo * textKnock;
+  }
+  col = mix(col, dotColor.rgb, dots);
+
+  vec2 fc = 0.5 * (lo + hi);
+  float ink = strokeAA(sdBox(D - fc, gH + 10.0), 1.5) * frameAmount;
+  ink = max(ink, strokeAA(sdBox(D - fc, gH), 1.0) * frameAmount * 0.5);
+  if (marks) {
+    for (int i = 0; i < 4; i++) {
+      vec2 corner = vec2(i % 2 == 0 ? lo.x : hi.x, i < 2 ? lo.y : hi.y);
+      ink = max(ink, plusMark(D - (corner + (corner - fc) / gH * 28.0), 9.0));
+    }
+  }
+  vec3 tint;
+  float bars = edgeBars(D, lo, hi, tint) * clamp((TIME * 1000.0 - introMs * 0.4) / 160.0, 0.0, 1.0) * barAmount;
+  col = mix(col, tint, bars);
+  col = mix(col, inkColor.rgb, clamp(ink, 0.0, 1.0));
+  float t = tm.r * clamp((TIME * 1000.0 - introMs * 0.1) / 120.0, 0.0, 1.0);
+  col = mix(col, textColor.rgb, clamp(t, 0.0, 1.0));
+  fragColor = vec4(col, 1.0);
+}

package/skills/agentvfx/templates/brutal/_src/hud-deck/deck-left.src.glsl

@@ -0,0 +1,100 @@
+// Night deck, bottom desk (design units): desk rules, label rules, waveform strip and a hatched spectrum area.
+float boxLine(vec2 p, vec2 lo, vec2 hi, float r) { return strokeAA(sdRound(p - 0.5 * (lo + hi), 0.5 * (hi - lo), r), 1.5); }
+
+// Seeded point cloud that drifts as an elongated blob; density follows the music.
+float dkCloud(vec2 p, vec2 size, float drive) {
+  float t = TIME * driftSpeed;
+  vec2 c = size * 0.5 + vec2(sin(t * 0.37) * size.x * 0.1, sin(t * 0.23 + 1.0) * size.y * 0.07);
+  float ang = 0.8 + 0.6 * sin(t * 0.17);
+  mat2 R = rot(ang);
+  vec2 axes = vec2(size.x * (0.22 + 0.1 * drive), size.y * (0.09 + 0.13 * drive));
+  float cell = 6.0;
+  vec2 g = floor(p / cell);
+  float m = 0.0;
+  for (int j = -1; j <= 1; j++) {
+    for (int i = -1; i <= 1; i++) {
+      vec2 id = g + vec2(float(i), float(j));
+      vec2 h = hash22(id);
+      vec2 pt = (id + 0.1 + 0.8 * h) * cell;
+      pt += vec2(sin(t * (0.7 + h.x) + h.y * TAU), cos(t * (0.6 + h.y) + h.x * TAU)) * (1.2 + 2.5 * drive);
+      vec2 q = R * (pt - c) / axes;
+      float w = exp(-dot(q, q) * 1.15) * (0.7 + 1.6 * drive) * particleDensity;
+      float keep = step(hash12(id + 7.7), w);
+      m = max(m, keep * fillAA(length(p - pt) - 1.15));
+    }
+  }
+  return m;
+}
+
+// vertical hairlines min..max of the waveform per pixel column (trigger-aligned wave texture, row 0)
+float dkWave(vec2 p, float w, float amp) {
+  float x0 = clamp((p.x - 0.5) / w, 0.0, 1.0);
+  float x1 = clamp((p.x + 0.5) / w, 0.0, 1.0);
+  float lo = 1e3;
+  float hi = -1e3;
+  for (int k = 0; k < 3; k++) {
+    float s = (texture(audio, vec2(mix(x0, x1, float(k) * 0.5), 0.25)).r - 0.5) * 2.0 * amp * waveGain;
+    lo = min(lo, s);
+    hi = max(hi, s);
+  }
+  lo = min(lo, -0.4);
+  hi = max(hi, 0.4);
+  return clamp(min(p.y - lo + 0.5, hi - p.y + 0.5) * U, 0.0, 1.0);
+}
+
+float dkSpecValue(float xd, vec2 lo, float w) {
+  float u = clamp((xd - lo.x) / w, 0.0, 1.0);
+  return texture(specState, vec2(u * 256.0 / RENDERSIZE.x, 0.5 / RENDERSIZE.y)).r;
+}
+
+// spectrum as an area: a solid top edge over a vertical hatch down to the floor
+vec2 dkSpecArea(vec2 p, vec2 lo, vec2 hi) {
+  float w = hi.x - lo.x;
+  float y0 = hi.y - 2.0;
+  float span = (hi.y - lo.y - 8.0) * spectrumGain;
+  float a = y0 - dkSpecValue(p.x - 0.5, lo, w) * span;
+  float b = y0 - dkSpecValue(p.x + 0.5, lo, w) * span;
+  float c = y0 - dkSpecValue(p.x, lo, w) * span;
+  float top = min(c, min(a, b)) - 0.8;
+  float bot = max(c, max(a, b)) + 0.8;
+  float inX = step(lo.x + 1.0, p.x) * step(p.x, hi.x - 1.0);
+  float edge = clamp(min(p.y - top, bot - p.y) * U + 0.5, 0.0, 1.0);
+  float hatch = step(c, p.y) * step(p.y, y0) * step(fract(p.x / 4.0), 0.4);
+  return vec2(max(edge * step(p.y, y0 + 0.6), hatch) * inX, 0.0);
+}
+
+vec2 deckLeft(vec2 p, float drive) {
+  float ink = 0.0;
+  float dim = 0.0;
+  if (p.y < 776.0 || p.x > 1352.0) return vec2(0.0);
+  float k = rev(0.3);
+  // desk rule, label rules, column dividers
+  ink = max(ink, k * strokeAA(p.y - 780.0, 1.2) * step(30.0, p.x));
+  ink = max(ink, k * strokeAA(p.y - 890.0, 1.2) * step(30.0, p.x) * step(p.x, 520.0));
+  dim = max(dim, k * strokeAA(p.x - 540.0, 1.2) * step(796.0, p.y) * step(p.y, 1046.0));
+  dim = max(dim, k * strokeAA(p.x - 1350.0, 1.2) * step(796.0, p.y) * step(p.y, 1046.0));
+  ink = max(ink, k * fillAA(sdBox(p - vec2(512.0, 798.0), vec2(8.0, 4.0))));
+  ink = max(ink, k * fillAA(sdBox(p - vec2(512.0, 900.0), vec2(8.0, 4.0))));
+  // waveform strip with a dotted baseline
+  if (p.y > 994.0 && p.x < 530.0) {
+    float k2 = rev(0.7);
+    float x0 = 30.0;
+    float w = 490.0;
+    ink = max(ink, k2 * dkWave(vec2(p.x - x0, p.y - 1022.0), w, 20.0) * step(x0, p.x) * step(p.x, x0 + w));
+    dim = max(dim, k2 * strokeAA(p.y - 1046.0, 1.2) * step(0.5, fract(p.x / 6.0)) * step(x0, p.x) * step(p.x, x0 + w));
+  }
+  // hatched spectrum area with dashed guides at the label columns
+  vec2 sLo = vec2(560.0, 800.0);
+  vec2 sHi = vec2(1330.0, 1000.0);
+  if (p.x > 550.0 && p.y < 1004.0) {
+    float k2 = rev(0.45);
+    vec2 s = dkSpecArea(p, sLo, sHi);
+    ink = max(ink, k2 * s.x);
+    ink = max(ink, k2 * strokeAA(p.y - (sHi.y - 2.0), 1.4) * step(sLo.x, p.x) * step(p.x, sHi.x));
+    for (int i = 0; i < 5; i++) {
+      float xi = sLo.x + float(i) * (sHi.x - sLo.x) / 4.0;
+      dim = max(dim, k2 * strokeAA(p.x - xi, 1.2) * step(0.5, fract(p.y / 8.0)) * step(sLo.y, p.y) * step(p.y, sHi.y));
+    }
+  }
+  return vec2(ink, dim);
+}

package/skills/agentvfx/templates/brutal/_src/hud-deck/deck-right.src.glsl

@@ -0,0 +1,61 @@
+// Night deck, right rail: contour map with readouts, chamfered particle box, 16-step beat sequencer.
+// iso-lines of fbm: a line wherever the field crosses a level, anti-aliased with the screen derivative
+float dkField(vec2 p, vec2 lo, float drive) {
+  float t = TIME * driftSpeed * 0.035;
+  return fbm((p - lo) / 150.0 * contourScale + vec2(t, -t * 0.6) + drive * 0.12, 4) * contourLevels;
+}
+float dkContour(vec2 p, vec2 lo, float drive) {
+  float s = dkField(p, lo, drive);
+  float gx = dkField(p + vec2(1.0, 0.0), lo, drive) - s;
+  float gy = dkField(p + vec2(0.0, 1.0), lo, drive) - s;
+  float fw = max(length(vec2(gx, gy)) / U, 0.006);
+  float dist = (0.5 - abs(fract(s) - 0.5)) / fw;
+  return clamp(1.15 - dist, 0.0, 1.0);
+}
+
+vec2 deckRight(vec2 p, float drive) {
+  float ink = 0.0;
+  float dim = 0.0;
+  if (p.x < 1360.0) return vec2(0.0);
+  // contour map: frame, corner ticks, a dashed mid line, readouts beneath
+  vec2 cLo = vec2(1370.0, 30.0);
+  vec2 cHi = vec2(1890.0, 330.0);
+  if (p.y < 370.0) {
+    float k = rev(0.2);
+    ink = max(ink, k * boxLine(p, cLo, cHi, 0.0));
+    float inside = step(cLo.x + 1.0, p.x) * step(p.x, cHi.x - 1.0) * step(cLo.y + 1.0, p.y) * step(p.y, cHi.y - 1.0);
+    ink = max(ink, k * inside * dkContour(p, cLo, drive));
+    dim = max(dim, k * inside * strokeAA(p.y - 0.5 * (cLo.y + cHi.y), 1.2) * step(0.5, fract(p.x / 10.0)));
+    vec2 q = abs(p - 0.5 * (cLo + cHi)) - (0.5 * (cHi - cLo) - 14.0);
+    ink = max(ink, k * step(0.0, q.x) * step(0.0, q.y) * max(strokeAA(q.x, 3.0), strokeAA(q.y, 3.0)) * inside);
+    float cell = cellPx(2.8);
+    float va = 212.4 + 90.0 * sin(TIME * 0.9) + 60.0 * drive;
+    float vb = 3.71 + 2.0 * sin(TIME * 1.7 + 1.0) + 4.0 * AUDIO_PEAK;
+    ink = max(ink, k * printNum(p - snapPx(vec2(1366.0, 344.0)), va, 3, 1, cell));
+    ink = max(ink, k * printNum(p - snapPx(vec2(1890.0 - numWidth(1, 3, cell), 344.0)), vb, 1, 3, cell));
+  }
+  // particle box with cut corners
+  vec2 bLo = vec2(1370.0, 400.0);
+  vec2 bHi = vec2(1890.0, 750.0);
+  if (p.y > 394.0 && p.y < 756.0) {
+    float k = rev(0.5);
+    float sd = sdChamfer(p - 0.5 * (bLo + bHi), 0.5 * (bHi - bLo), 22.0, 0.0);
+    ink = max(ink, k * strokeAA(sd, 1.5));
+    ink = max(ink, k * dkCloud(p - bLo, bHi - bLo, drive) * step(sd, -4.0));
+  }
+  // beat sequencer: 16 cells, the current step filled, every fourth cell heavier
+  if (p.y > 796.0 && p.y < 834.0) {
+    float k = rev(0.65);
+    float cw = (1890.0 - 1370.0) / 16.0;
+    float i = floor((p.x - 1370.0) / cw);
+    if (i >= 0.0 && i < 16.0) {
+      vec2 cc = vec2(1370.0 + (i + 0.5) * cw, 815.0);
+      float box = sdBox(p - cc, vec2(cw * 0.5 - 4.0, 15.0));
+      float beats = AUDIO_BPM > 1.0 ? TIME * AUDIO_BPM / 60.0 : TIME * 2.0;
+      float cur = mod(floor(beats), 16.0);
+      float heavy = step(mod(i, 4.0), 0.5);
+      ink = max(ink, k * max(strokeAA(box, mix(1.2, 2.4, heavy)), fillAA(box + 3.0) * step(abs(i - cur), 0.5)));
+    }
+  }
+  return vec2(ink, dim);
+}

package/skills/agentvfx/templates/brutal/_src/hud-deck/deck-tiles.src.glsl

@@ -0,0 +1,153 @@
+// Tile layout (octagon window, off-centre): dial gauge, segment meter, readout column, pad matrix,
+// bar meters, scan ruler, timeline with a barcode strip, nested rhombus target and crop brackets.
+// four-point astroid star (also used by the night layout's icon rows)
+float dkAstroid(vec2 p, float R) {
+  float f = sqrt(abs(p.x)) + sqrt(abs(p.y)) - sqrt(R);
+  return strokeAA(f * R * 0.22, 1.4);
+}
+float dkOutlineRect(vec2 p, vec2 lo, vec2 hi) { return strokeAA(sdRound(p - 0.5 * (lo + hi), 0.5 * (hi - lo), 2.0), 1.5); }
+float dkBand(int i) { return clamp(AUDIO_BANDS[clamp(i, 0, 31)] * reactivity, 0.0, 1.0); }
+
+// upper half dial: two arcs, 40 ticks (every 5th long), a lit level band and a needle at value v
+vec2 dkDial(vec2 p, vec2 c, float R, float v) {
+  vec2 q = p - c;
+  if (q.y > 2.0 || length(q) > R + 4.0) return vec2(0.0);
+  float r = length(q);
+  float a = atan(-q.y, q.x);
+  float up = step(q.y, 0.0);
+  float ink = up * max(strokeAA(r - R, 1.5), strokeAA(r - R * 0.6, 1.2));
+  float sec = 3.14159265 / 40.0;
+  float idx = floor((a + 0.5 * sec) / sec);
+  float da = a - idx * sec;
+  bool major = mod(idx, 5.0) < 0.5;
+  float rin = R - (major ? 26.0 : 12.0);
+  ink = max(ink, up * strokeAA(r * sin(da), major ? 2.0 : 1.2) * step(rin, r) * step(r, R - 4.0));
+  float seg = up * step(R * 0.64, r) * step(r, R * 0.74) * step(abs(da), sec * 0.32);
+  float lit = step(1.0 - idx / 40.0, v);
+  float an = 3.14159265 * (1.0 - v);
+  vec2 tip = c + R * 0.9 * vec2(cos(an), -sin(an));
+  ink = max(ink, max(seg * lit, strokeAA(sdSeg(p, c, tip), 2.0)));
+  ink = max(ink, max(fillAA(r - 6.0), strokeAA(r - 14.0, 1.2) * up));
+  ink = max(ink, strokeAA(sdSeg(p, c - vec2(R, 0.0), c + vec2(R, 0.0)), 1.2));
+  return vec2(ink, seg * (1.0 - lit));
+}
+
+// L-shaped crop mark just outside a window corner; sx, sy = -1 or 1 point away from the window
+float dkBracket(vec2 p, vec2 corner, float sx, float sy) {
+  vec2 a = corner + vec2(sx, sy) * 16.0;
+  return strokeAA(min(sdSeg(p, a, a - vec2(sx * 44.0, 0.0)), sdSeg(p, a, a - vec2(0.0, sy * 44.0))), 2.0);
+}
+
+vec2 deckTiles(vec2 p, float drive) {
+  float ink = 0.0;
+  float dim = 0.0;
+  float W = designWidth();
+  vec2 lo = gWC - gWH;
+  vec2 hi = gWC + gWH;
+  float lv = clamp(drive, 0.0, 1.0);
+
+  // top: header rule with tabs and a running time readout
+  float k = rev(0.15);
+  ink = max(ink, k * strokeAA(p.y - 96.0, 1.2) * step(lo.x, p.x) * step(p.x, hi.x));
+  ink = max(ink, k * dkOutlineRect(p, vec2(lo.x, 52.0), vec2(lo.x + 224.0, 84.0)));
+  ink = max(ink, k * dkOutlineRect(p, vec2(lo.x + 244.0, 52.0), vec2(lo.x + 304.0, 84.0)));
+  ink = max(ink, k * dkOutlineRect(p, vec2(hi.x - 100.0, 52.0), vec2(hi.x, 84.0)));
+  ink = max(ink, k * printNum(p - snapPx(vec2(lo.x + 14.0, 58.0)), mod(TIME, 1000.0), 3, 2, 4.0));
+  ink = max(ink, k * plusMark(p - vec2(lo.x - 30.0, 96.0), 8.0));
+  ink = max(ink, k * plusMark(p - vec2(hi.x + 30.0, 96.0), 8.0));
+  ink = max(ink, k * dkBracket(p, lo, -1.0, -1.0));
+  ink = max(ink, k * dkBracket(p, vec2(hi.x, lo.y), 1.0, -1.0));
+  ink = max(ink, k * dkBracket(p, vec2(lo.x, hi.y), -1.0, 1.0));
+  ink = max(ink, k * dkBracket(p, hi, 1.0, 1.0));
+
+  // left: dial, segment meter, readout column, pad matrix
+  k = rev(0.3);
+  if (p.x < 420.0 && p.y < 270.0) {
+    vec2 d = dkDial(p, vec2(214.0, 250.0), 180.0, lv);
+    ink = max(ink, k * d.x);
+    dim = max(dim, k * d.y);
+  }
+  if (p.y > 290.0 && p.y < 340.0 && p.x < 420.0) {
+    float i = floor((p.x - 28.0) / 16.0);
+    vec2 cc = vec2(28.0 + i * 16.0 + 6.5, 314.0);
+    float box = sdBox(p - cc, vec2(6.5, 18.0));
+    float inRow = step(0.0, i) * step(i, 23.0);
+    float lit = step(i / 24.0, lv - 0.02);
+    ink = max(ink, k * inRow * max(strokeAA(box, 1.2), fillAA(box) * lit));
+    dim = max(dim, k * inRow * fillAA(box) * (1.0 - lit));
+  }
+  k = rev(0.45);
+  if (p.x > 290.0 && p.x < 440.0 && p.y > 400.0 && p.y < 720.0) {
+    for (int i = 0; i < 5; i++) {
+      float y = 412.0 + float(i) * 62.0;
+      float v = dkBand(2 + i * 6);
+      ink = max(ink, k * printNum(p - snapPx(vec2(304.0, y)), v, 1, 2, 4.0));
+      ink = max(ink, k * strokeAA(p.y - (y + 30.0), 2.0) * step(304.0, p.x) * step(p.x, 304.0 + 120.0 * v));
+      dim = max(dim, k * strokeAA(p.y - (y + 30.0), 2.0) * step(304.0, p.x) * step(p.x, 424.0));
+      ink = max(ink, k * strokeAA(sdSeg(p, vec2(294.0, y), vec2(294.0, y + 30.0)), 1.2));
+    }
+  }
+  if (p.x < 320.0 && p.y > 766.0) {
+    vec2 g = floor((p - vec2(28.0, 776.0)) / 70.0);
+    if (g.x >= 0.0 && g.x < 4.0 && g.y >= 0.0 && g.y < 4.0) {
+      vec2 cc = vec2(28.0, 776.0) + g * 70.0 + 29.0;
+      float cell = sdRound(p - cc, vec2(29.0), 6.0);
+      float lit = step(0.5, dkBand(int(g.y * 4.0 + g.x) * 2));
+      ink = max(ink, k * max(strokeAA(cell, 1.4), fillAA(cell + 9.0) * lit));
+      dim = max(dim, k * fillAA(cell + 9.0) * (1.0 - lit));
+    }
+  }
+
+  // right: scan ruler beside the window, bar meters, BPM and frame readouts, rhombus target
+  k = rev(0.6);
+  float rx = hi.x + 16.0;
+  if (p.x > rx - 14.0 && p.x < rx + 18.0 && p.y > lo.y - 2.0 && p.y < hi.y + 2.0) {
+    float t = mod(p.y - lo.y, 12.0);
+    float major = step(mod(p.y - lo.y, 60.0), 1.0);
+    ink = max(ink, k * strokeAA(p.x - rx, 1.2));
+    ink = max(ink, k * step(min(t, 12.0 - t), 0.6) * step(rx, p.x) * step(p.x, rx + mix(6.0, 14.0, major)));
+    float sy = lo.y + fract(TIME * 0.125) * (hi.y - lo.y);
+    ink = max(ink, k * max(fillAA(sdRhomb(p - vec2(rx, sy), vec2(7.0, 9.0))), strokeAA(p.y - sy, 1.2) * step(rx - 14.0, p.x)));
+  }
+  if (p.x > W - 262.0 && p.y > 130.0 && p.y < 346.0) {
+    float i = floor((p.x - (W - 260.0)) / 29.0);
+    if (i >= 0.0 && i < 8.0) {
+      vec2 cc = vec2(W - 260.0 + i * 29.0 + 10.0, 240.0);
+      float box = sdBox(p - cc, vec2(10.0, 100.0));
+      float h = dkBand(2 + int(i) * 3);
+      ink = max(ink, k * max(strokeAA(box, 1.2), fillAA(box + 3.0) * step(340.0 - h * 200.0, p.y)));
+    }
+  }
+  k = rev(0.75);
+  ink = max(ink, k * printNum(p - snapPx(vec2(W - 268.0, 770.0)), AUDIO_BPM, 3, 0, 7.0));
+  ink = max(ink, k * printNum(p - snapPx(vec2(W - 268.0, 822.0)), float(FRAMEINDEX % 10000), 4, 0, 4.0));
+  ink = max(ink, k * strokeAA(sdSeg(p, vec2(W - 268.0, 812.0), vec2(W - 28.0, 812.0)), 1.2));
+  if (p.x > W - 250.0 && p.y > 890.0) {
+    vec2 q = p - vec2(W - 150.0, 975.0);
+    float an = TIME * 0.2 + drive * 0.4;
+    q = mat2(cos(an), -sin(an), sin(an), cos(an)) * q;
+    float rh = min(abs(sdRhomb(q, vec2(66.0))), min(abs(sdRhomb(q, vec2(44.0))), abs(sdRhomb(q, vec2(22.0)))));
+    ink = max(ink, k * max(strokeAA(rh, 1.4), fillAA(length(q) - 4.0)));
+  }
+
+  // bottom: timeline with ticks and a playhead over a barcode strip that follows the bands
+  k = rev(0.85);
+  if (p.y > 900.0 && p.x > lo.x - 2.0 && p.x < hi.x + 2.0) {
+    float span = hi.x - lo.x;
+    float step48 = span / 48.0;
+    float lx = p.x - lo.x;
+    float tk = mod(lx + 0.5 * step48, step48) - 0.5 * step48;
+    float major = step(mod(floor((lx + 0.5 * step48) / step48), 8.0), 0.5);
+    ink = max(ink, k * strokeAA(p.y - 930.0, 1.4));
+    ink = max(ink, k * strokeAA(tk, 1.2) * step(930.0 - mix(8.0, 18.0, major), p.y) * step(p.y, 930.0));
+    float ph = lo.x + fract(TIME / 8.0) * span;
+    ink = max(ink, k * max(fillAA(sdRhomb(p - vec2(ph, 914.0), vec2(7.0, 9.0))), strokeAA(p.x - ph, 1.2) * step(930.0, p.y) * step(p.y, 1048.0)));
+    float col = floor(lx / 7.0);
+    float on = step(fract(lx / 7.0), 0.58) * step(hash12(vec2(col, 31.0)), 0.82);
+    float h = 90.0 * clamp(0.12 + 0.85 * dkBand(int(mod(col, 32.0))), 0.0, 1.0);
+    float bar = on * step(1040.0 - h, p.y) * step(p.y, 1040.0) * step(946.0, p.y);
+    ink = max(ink, k * bar);
+    dim = max(dim, k * on * (1.0 - bar) * step(946.0, p.y) * step(p.y, 1040.0) * 0.5);
+  }
+  return vec2(ink, dim);
+}

package/skills/agentvfx/templates/brutal/_src/hud-deck/def.mjs

@@ -0,0 +1,82 @@
+import { b, c, f, hex, l, microLines } from "../shared/defs.mjs";
+
+const mono = (key, def, x, y, size, extra = {}) => ({ key, default: def, x, y, size, font: "mono", ...extra });
+const freq = (key, def, x) => mono(key, def, x, 0.9361, 0.0098, { align: "center" });
+
+const INPUTS = [
+  c("groundColor", [0.043, 0.043, 0.047, 1]), c("inkColor", [0.914, 0.914, 0.894, 1]), c("winBg", [0.02, 0.02, 0.022, 1]),
+  c("tone", [0.914, 0.914, 0.894, 1]), f("dimAmount", 0, 1, 0.5),
+  l("deckLayout", [0, 1], ["night-deck", "tiles"], 0), l("winShape", [0, 1, 2], ["rect", "rounded", "octagon"], 0),
+  f("winX", 0.2, 0.8, 0.3542), f("winY", 0.3, 0.7, 0.3657), f("winW", 0.3, 0.85, 0.6771), f("winH", 0.4, 0.98, 0.6759),
+  f("chamfer", 20, 300, 150), b("marks", true),
+  l("mediaMode", [0, 1, 2, 3], ["natural", "mono", "halftone", "duotone"], 0), f("mediaContrast", 0.5, 3, 1.25), f("mediaBias", -0.5, 0.5, 0),
+  f("dotSize", 3, 24, 8), f("dotAngle", 0, 1.5708, 0.7854),
+  f("flare", 0, 1, 0.85), f("flareX", 0, 1, 0.5), f("flareY", 0, 1, 0.5), f("flareW", 0.05, 0.6, 0.42), f("flareBeat", 0, 1, 0.8),
+  f("tearAmount", 0, 1, 0.4),
+  f("reactivity", 0, 2, 1), f("spectrumGain", 0.2, 1.5, 1), f("waveGain", 0.2, 4, 2.4), f("particleDensity", 0.3, 2.5, 1.1),
+  f("driftSpeed", 0, 3, 1), f("contourScale", 0.5, 4, 1.7), f("contourLevels", 2, 8, 3.6), f("introMs", 0, 3000, 600),
+  f("startFreq", 20, 400, 50), f("endFreq", 3000, 20000, 12800), f("floorLevel", 0, 0.6, 0.14), f("ceilLevel", 0.2, 1, 0.72),
+  f("specExp", 0.5, 3, 1.5), f("attackMs", 1, 300, 16), f("releaseMs", 20, 1500, 240),
+];
+
+const TEXT = [
+  { key: "artist", default: "SIGMA7", x: 0.0156, y: 0.752, size: 0.066, font: "display", style: "fill" },
+  mono("artistTag", "ARTIST", 0.0156, 0.7333, 0.0098),
+  { key: "track", default: "RELAY", x: 0.0156, y: 0.8463, size: 0.066, font: "display", style: "fill" },
+  mono("trackTag", "TRACK", 0.0156, 0.8278, 0.0098),
+  { key: "title", default: "SIGNAL//04", x: 0.9844, y: 0.8852, size: 0.066, font: "tall", style: "fill", weight: 500, align: "right", tracking: 0.14 },
+  freq("f1", "50Hz", 0.2917), freq("f2", "200Hz", 0.3919), freq("f3", "800Hz", 0.4922), freq("f4", "3.2k", 0.5924), freq("f5", "12.8k", 0.6927),
+  mono("winTag", "LV-0417 *", 0.0156, 0.712, 0.0095),
+  mono("code", microLines(31, 3, 34), 0.7135, 0.7852, 0.0105, { lineHeight: 2.2, reveal: "type", revealStart: 0.6, revealDur: 1.4 }),
+  mono("microL", microLines(7, 15, 40), 0.0151, 0.372, 0.0085, { lineHeight: 1.25 }),
+  mono("microR", microLines(19, 15, 40), 0.8604, 0.372, 0.0085, { lineHeight: 1.25 }),
+];
+
+const NIGHT = {};
+const ULTRA = {
+  groundColor: hex("#1414ff"), inkColor: hex("#dcd3ff"), winBg: hex("#0a0a9e"), tone: hex("#c9b8ff"), mediaMode: 2, dotSize: 8,
+  mediaContrast: 1.45, flare: 0.55, dimAmount: 0.55,
+};
+const ACID = {
+  groundColor: hex("#c8ff00"), inkColor: hex("#0b0b0c"), winBg: hex("#0b0b0c"), tone: hex("#c8ff00"), mediaMode: 3, dimAmount: 0.6,
+  mediaContrast: 1.3, flare: 0.7,
+};
+const OCTAGON = {
+  winShape: 2, deckLayout: 1, winX: 0.55, winY: 0.47, winW: 0.58, winH: 0.7, chamfer: 96, flare: 0, marks: false, mediaContrast: 1.15,
+  inkColor: hex("#ffb21a"), dimAmount: 0.2,
+};
+const ORANGE = {
+  groundColor: hex("#ff3c00"), inkColor: hex("#0b0b0c"), winBg: hex("#0b0b0c"), tone: hex("#ff3c00"), mediaMode: 1, dimAmount: 0.6,
+  mediaContrast: 1.5, flare: 0.6,
+};
+
+const fx = {
+  DESCRIPTION: "Neo-brutalist control desk: a wide framed media window (rect, rounded or chamfered octagon) over a desk of artist and track labels, waveform strip and hatched spectrum, beside a rail with a contour map, particle box, beat sequencer and micro code, all following the music",
+  CREDIT: "agentvfx",
+  ISFVSN: "2",
+  CATEGORIES: ["brutal", "hud", "audio"],
+  INPUTS,
+  PASSES: [{ TARGET: "specState", PERSISTENT: true, FLOAT: true }, {}],
+  X_AGENTVFX: {
+    id: "hud-deck", family: "brutal", input: "either", spdx: "Apache-2.0", flash: "possible", fps: 30, palette: false,
+    presets: { night: NIGHT, ultramarine: ULTRA, acid: ACID, octagon: OCTAGON, "orange-mono": ORANGE },
+    audioBind: { spectrumGain: "bands", flare: "beat" },
+    safeSubstitute: { params: { flare: 0, tearAmount: 0 } },
+    text: TEXT,
+    credits: [
+      "Instrument-panel grammar (original drawing; no names, marks, fonts or footage from other works)",
+      "2D signed distance functions after Inigo Quilez, https://iquilezles.org/articles/distfunctions2d/ (circle, box, segment, ellipse, triangle); 3x5 digit font, dot screen, Bayer 8x8 index and glyph icons are original",
+      "Spectrum column mapping: log-spaced columns, peak-preserving neighbour smoothing, attack/release follower (same structure as the agentvfx spectrum family)",
+    ],
+  },
+};
+
+const MUSIC = "test-media/beat-132.mp3";
+const demo = (video, seed, labels, startSec = 2) => ({ input: { video, audio: MUSIC, startSec }, durationSec: 4, seed, labels });
+const demos = {
+  night: demo("test-media/clip-02.mp4", 41, { artist: "SIGMA7", track: "RELAY", title: "SIGNAL//04" }, 4),
+  ultramarine: demo("test-media/clip-01.mp4", 42, { artist: "VANTA", track: "HALO-9", title: "PLATE//77", winTag: "UM-3301 *" }),
+  acid: demo("test-media/clip-02.mp4", 43, { artist: "KRAIT", track: "DRIFT", title: "NODE//7G", winTag: "AC-0075 *" }, 4),
+  octagon: demo("test-media/clip-01.mp4", 44, {}),
+};
+export default { fx, demos };

package/skills/agentvfx/templates/brutal/_src/hud-deck/main.src.frag

@@ -0,0 +1,110 @@
+// hud-deck: central media window (rect / rounded / chamfered octagon) with instrument columns drawn
+// in GLSL hairlines, plus engine text for labels. Pass 0 (specState) holds the smoothed spectrum.
+//@include lib.glsl
+//@include icons.glsl
+
+// staggered power-on: panel k (0..1) flickers in between k*introMs and k*introMs + 140 ms
+float rev(float k) {
+  float a = (TIME * 1000.0 - introMs * k) / 140.0;
+  if (a >= 1.0) return 1.0;
+  if (a <= 0.0) return 0.0;
+  return step(0.45, hash12(vec2(k * 37.0, float(FRAMEINDEX))));
+}
+
+vec2 gWC;
+vec2 gWH;
+
+// beat tears: blocks of rows slide sideways for a couple of frames after each beat
+vec2 tearP(vec2 p) {
+  float on = step(0.3, beatPulse(8.0)) * tearAmount;
+  if (on <= 0.0) return p;
+  float row = floor(p.y / 20.0);
+  float f = float(FRAMEINDEX / 2);
+  p.x += (hash12(vec2(row, f)) - 0.5) * 2.0 * on * 150.0 * step(0.55, hash12(vec2(row, f + 1.7)));
+  return p;
+}
+float lumAt(vec2 p) {
+  vec2 uv = coverUV(tearP(p), gWC, gWH * 2.0);
+  float L = pow(clamp(luma(mediaRaw(uv)), 0.0, 1.0), 0.4545);
+  return clamp((L - 0.5) * mediaContrast + 0.5 + mediaBias, 0.0, 1.0);
+}
+//@include screen.glsl
+
+float winSD(vec2 p) {
+  vec2 q = p - gWC;
+  if (winShape == 0) return sdRound(q, gWH, 8.0);
+  if (winShape == 1) return sdRound(q, gWH, min(gWH.x, gWH.y) * 0.12);
+  return sdChamfer(q, gWH, chamfer, 14.0);
+}
+
+vec3 windowColor(vec2 p) {
+  if (mediaMode == 2) return mix(winBg.rgb, tone.rgb, dotScreen(p, dotSize, dotAngle, 1.18, 1.0));
+  if (mediaMode == 3) return mix(winBg.rgb, tone.rgb, smoothstep(0.06, 0.94, lumAt(p)));
+  vec3 c = mediaRaw(coverUV(tearP(p), gWC, gWH * 2.0));
+  c = max((c - 0.18) * mediaContrast + 0.18 + (mediaBias * 0.2), 0.0);
+  return mediaMode == 1 ? vec3(luma(c)) : c;
+}
+
+// white-hot horizontal light bar (eye flare) that breathes with the beat
+vec3 flareAdd(vec2 p) {
+  float amt = flare * (0.5 + 0.5 * mix(1.0, beatPulse(5.0), flareBeat));
+  vec2 c = gWC + (vec2(flareX, flareY) - 0.5) * gWH * 2.0;
+  float len = flareW * gWH.x * 2.0;
+  float dx = (p.x - c.x) / len;
+  float dy = p.y - c.y;
+  float tap = clamp(1.0 - dx * dx, 0.0, 1.0);
+  float s1 = 4.5 * tap + 0.8;
+  float s2 = 28.0 * tap + 2.0;
+  float core = exp(-dy * dy / (2.0 * s1 * s1)) * tap;
+  float halo = exp(-dy * dy / (2.0 * s2 * s2)) * tap * 0.4;
+  return (core * vec3(2.4) + halo * vec3(1.0, 0.78, 0.45)) * amt;
+}
+
+//@include deck-tiles.src.glsl
+//@include deck-left.src.glsl
+//@include deck-right.src.glsl
+
+void main() {
+  initDesign();
+  float W = designWidth();
+  gWC = vec2(winX * W, winY * 1080.0);
+  gWH = vec2(winW * W, winH * 1080.0) * 0.5;
+  float kick = clamp((AUDIO_BASS - 1.0) / 3.0, 0.0, 1.0);
+  float drive = clamp(0.5 * AUDIO_BANDS[1] + 0.4 * AUDIO_BANDS[3] + 0.4 * kick, 0.0, 1.3) * reactivity;
+
+  vec3 col = groundColor.rgb;
+  float wd = winSD(D);
+  float inside = fillAA(wd);
+  if (inside > 0.0) {
+    vec3 m = windowColor(D);
+    if (flare > 0.0) m += flareAdd(D);
+    col = mix(col, m, inside);
+  }
+  float ink = strokeAA(wd, 1.5 + 2.0 * beatPulse(10.0) * reactivity) * rev(0.1);
+  float dim = 0.0;
+
+  vec2 pan = vec2(0.0);
+  if (deckLayout == 0) {
+    pan = max(deckLeft(D, drive), deckRight(D, drive));
+    if (marks) {
+      vec2 o = gWH + 12.0;
+      pan.x = max(pan.x, plusMark(D - (gWC + o * vec2(-1.0, -1.0)), 6.0));
+      pan.x = max(pan.x, plusMark(D - (gWC + o * vec2(1.0, -1.0)), 6.0));
+      pan.x = max(pan.x, plusMark(D - (gWC + o * vec2(-1.0, 1.0)), 6.0));
+      pan.x = max(pan.x, plusMark(D - (gWC + o * vec2(1.0, 1.0)), 6.0));
+    }
+  } else {
+    pan = deckTiles(D, drive);
+  }
+  ink = max(ink, pan.x);
+  dim = max(dim, pan.y);
+
+  vec4 tm = HAS_TEXT ? texture(TEXTMASK, vUv) : vec4(0.0);
+  bool micro = D.y > 395.0 && D.y < 720.0 && (D.x < 276.0 || D.x > W - 276.0);
+  float gate = (deckLayout == 0) != micro ? 1.0 : 0.0;
+  ink = max(ink, tm.r * gate * rev(0.25));
+
+  col = mix(col, inkColor.rgb, clamp(dim, 0.0, 1.0) * dimAmount);
+  col = mix(col, inkColor.rgb, clamp(ink, 0.0, 1.0));
+  fragColor = vec4(col, 1.0);
+}

package/skills/agentvfx/templates/brutal/_src/hud-deck/pass0.src.frag

@@ -0,0 +1,38 @@
+// hud-deck pass 0: pro-smoothed spectrum columns, persistent in specState (row 0 of the buffer).
+// 256 log-spaced columns startFreq..endFreq. Each column takes the maximum of four taps of the 512-bin
+// audioFFT (bin s sits near 29.3 + 46.875 * s Hz), is windowed by floorLevel / ceilLevel and shaped by
+// a power, lifts its neighbours by 0.78^distance (peak preserving), then follows with attack / release.
+const int NCOL = 256;
+float specAtHz(float hz) {
+  float s = (hz - 29.3) / 46.875;
+  return texture(audioFFT, vec2(clamp((s + 0.5) / 512.0, 0.0, 1.0), 0.5)).r;
+}
+float colRaw(int i) {
+  float ratio = endFreq / startFreq;
+  float f0 = startFreq * pow(ratio, float(i) / float(NCOL));
+  float f1 = startFreq * pow(ratio, float(i + 1) / float(NCOL));
+  float v = 0.0;
+  for (int k = 0; k < 4; k++) v = max(v, specAtHz(mix(f0, f1, (float(k) + 0.5) / 4.0)));
+  float x = clamp((v - floorLevel) / max(ceilLevel - floorLevel, 0.01), 0.0, 1.0);
+  return pow(x, specExp);
+}
+float colSmooth(int i) {
+  float v = colRaw(i);
+  for (int d = 1; d <= 3; d++) {
+    float w = pow(0.78, float(d));
+    if (i - d >= 0) v = max(v, colRaw(i - d) * w);
+    if (i + d < NCOL) v = max(v, colRaw(i + d) * w);
+  }
+  return v;
+}
+void main() {
+  ivec2 px = ivec2(gl_FragCoord.xy);
+  vec4 prev = texelFetch(specState, px, 0);
+  if (px.y == 0 && px.x < NCOL) {
+    float raw = colSmooth(px.x);
+    float k = 1.0 - exp(-TIMEDELTA / max((raw > prev.r ? attackMs : releaseMs) * 0.001, 0.0005));
+    fragColor = vec4(prev.r + (raw - prev.r) * k, 0.0, 0.0, 1.0);
+    return;
+  }
+  fragColor = vec4(0.0);
+}

package/skills/agentvfx/templates/brutal/_src/shared/defs.mjs

@@ -0,0 +1,28 @@
+// Shared helpers for the brutal family definitions (parameter builders, invented micro-text, colours).
+export const f = (NAME, MIN, MAX, DEFAULT) => ({ NAME, TYPE: "float", MIN, MAX, DEFAULT });
+export const b = (NAME, DEFAULT) => ({ NAME, TYPE: "bool", DEFAULT });
+export const c = (NAME, DEFAULT) => ({ NAME, TYPE: "color", DEFAULT });
+export const l = (NAME, VALUES, LABELS, DEFAULT) => ({ NAME, TYPE: "long", MIN: Math.min(...VALUES), MAX: Math.max(...VALUES), VALUES, LABELS, DEFAULT });
+
+/** "#rrggbb" -> [r, g, b, 1] in sRGB 0..1, rounded to 3 places. */
+export const hex = (s) => {
+  const n = parseInt(s.slice(1), 16);
+  return [(n >> 16) & 255, (n >> 8) & 255, n & 255].map((v) => Math.round((v / 255) * 1000) / 1000).concat(1);
+};
+
+/** Seeded invented code lines ("7G75-0A4F 91C2 LV//09"): decoration only, never real data or marks. */
+export function microLines(seed, rows, cols) {
+  let s = seed >>> 0;
+  const rnd = () => ((s = (Math.imul(s, 1664525) + 1013904223) >>> 0) / 4294967296);
+  const pick = (a) => a[Math.floor(rnd() * a.length)];
+  const hexd = "0123456789ABCDEF";
+  const word = (n) => Array.from({ length: n }, () => hexd[Math.floor(rnd() * 16)]).join("");
+  const tags = ["LV//", "NODE", "SIG", "RLY", "0x", "7G-", "AX", "KRN"];
+  const lines = [];
+  for (let r = 0; r < rows; r++) {
+    let line = "";
+    while (line.length < cols - 10) line += `${rnd() < 0.3 ? pick(tags) : ""}${word(2 + Math.floor(rnd() * 3))} `;
+    lines.push(line.slice(0, cols).trimEnd());
+  }
+  return lines.join("\n");
+}