agentvfx 0.0.0-stage → 0.3.5

package/skills/agentvfx/templates/spectrum/_src/shared/hud.glsl

@@ -0,0 +1,50 @@
+// ---- HUD line language (shared by the spectrum family) ----
+// Ground and ink: near-black ground with off-white hairlines by default, or one full colour field with
+// black / white ink (groundColor, inkColor, accentColor). Everything is drawn as 1-2 px hairlines
+// (lineWidth, in pixels at 1080p): framed panels, dashed grids, corner brackets, + crosshairs, tick
+// rulers. Labels come from the engine text layer (TEXTMASK: R = ink, G = box fill).
+float hudU() { return RENDERSIZE.y / 1080.0; }
+float hudW() { return max(lineWidth * hudU(), 1.0); }
+float hair(float d) { return clamp(hudW() * 0.5 - abs(d) + 0.5, 0.0, 1.0); }
+float cov(float d) { return clamp(0.5 - d, 0.0, 1.0); }
+float dashes(float x, float period, float duty) { return step(fract(x / (period * hudU())), duty); }
+
+// outline of the rectangle lo..hi (pixels)
+float boxLine(vec2 p, vec2 lo, vec2 hi) {
+  vec2 q = abs(p - (lo + hi) * 0.5) - (hi - lo) * 0.5;
+  return hair(max(q.x, q.y));
+}
+float inRect(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); }
+
+// + crosshair centred on c with arm length len
+float plusAt(vec2 p, vec2 c, float len) {
+  vec2 q = abs(p - c);
+  return max(hair(q.y) * step(q.x, len), hair(q.x) * step(q.y, len));
+}
+
+// four L-shaped corner brackets of the rectangle lo..hi, arm length len
+float brackets(vec2 p, vec2 lo, vec2 hi, float len) {
+  vec2 c = (lo + hi) * 0.5;
+  vec2 q = abs(p - c);
+  vec2 h = (hi - lo) * 0.5;
+  float onV = hair(q.x - h.x) * step(h.y - len, q.y) * step(q.y, h.y + 0.5);
+  float onH = hair(q.y - h.y) * step(h.x - len, q.x) * step(q.x, h.x + 0.5);
+  return max(onV, onH);
+}
+
+vec3 accentAt(float u) { return colorMode == 1 ? paletteCycle(u + paletteShift) : accentColor.rgb; }
+
+float textInk() { return HAS_TEXT ? texture(TEXTMASK, vUv).r : 0.0; }
+float textFill() { return HAS_TEXT ? texture(TEXTMASK, vUv).g : 0.0; }
+
+// frame chrome common to every instrument: corner + marks and an inset hairline frame
+float hudChrome(vec2 sp) {
+  vec2 res = RENDERSIZE;
+  float u = hudU();
+  float a = 0.0;
+  for (int c = 0; c < 4; c++) {
+    vec2 centre = vec2((c & 1) == 0 ? 22.0 * u : res.x - 22.0 * u, (c & 2) == 0 ? 22.0 * u : res.y - 22.0 * u);
+    a = max(a, plusAt(sp, centre, 7.0 * u));
+  }
+  return a;
+}

package/skills/agentvfx/templates/spectrum/_src/shared/stage.glsl

@@ -0,0 +1,74 @@
+// ---- stage (shared by the spectrum family) ----
+// Camera: bass onsets (bass ratio >= kickBass) zoom the frame by kickZoom and shake it by up to `shake`
+// pixels at 1080p, both decaying over kickDecayMs (both 0 by default: the HUD look is locked down).
+// Background: the flat groundColor; with an input, bgMode 1 = blurred and dimmed footage, 2 = single-tone
+// halftone dots of the footage in the ink colour (dot radius follows luminance). Optional field of
+// drifting flecks (fieldAmount), vignette and film grain. The clock texel is (hit count, last hit frame,
+// kick count, last kick frame), written by the template's state pass.
+float stageSince(float count, float last) { return count > 0.5 ? (float(FRAMEINDEX) - last) * TIMEDELTA : 99.0; }
+float kickEnv(vec4 clk) { return exp(-stageSince(clk.z, clk.w) / max(kickDecayMs * 0.001, 0.001)); }
+float hitEnv(vec4 clk, float seconds) { return exp(-stageSince(clk.x, clk.y) / seconds); }
+
+vec2 stageUv(vec4 clk, vec2 uv) {
+  float ke = kickEnv(clk);
+  vec2 sh = (hash22(vec2(clk.z, 3.7)) - 0.5) * 2.0 * shake * ke * (RENDERSIZE.y / 1080.0) / RENDERSIZE;
+  return (uv - 0.5) / (1.0 + kickZoom * ke) + 0.5 + sh;
+}
+
+float introK() { return introMs > 0.5 ? smoothstep(introMs * 0.0005, introMs * 0.0012, TIME) : 1.0; }
+float introSpan() { return introMs > 0.5 ? smoothstep(0.0, introMs * 0.0006, TIME) : 1.0; }
+
+float stageField(vec2 uv, float lift) {
+  float aspect = RENDERSIZE.x / RENDERSIZE.y;
+  float acc = 0.0;
+  for (int l = 0; l < 2; l++) {
+    float fl = float(l);
+    float sc = l == 0 ? 11.0 : 34.0;
+    vec2 p = vec2(uv.x * aspect, uv.y) * sc - vec2(TIME * fieldSpeed * (0.35 + 0.3 * fl), -TIME * fieldSpeed * (0.05 + 0.04 * fl));
+    vec2 c = floor(p);
+    vec2 fr = fract(p);
+    vec2 h = hash22(c + fl * 17.0);
+    float h2 = hash12(c + 31.0 + fl * 5.0);
+    float r = (l == 0 ? 0.05 : 0.035) * (0.5 + 0.7 * h2);
+    float tw = 0.55 + 0.45 * sin(TIME * (1.0 + 3.0 * h2) + h.x * 6.2832);
+    acc += step(length(fr - (0.3 + 0.4 * h)), r) * tw * step(0.45, h2);
+  }
+  return acc * (0.7 + 0.6 * lift);
+}
+
+float stageHalftone(vec2 uv) {
+  float u = RENDERSIZE.y / 1080.0;
+  float cell = max(halftoneSize * u, 2.0);
+  mat2 m = mat2(0.9659, 0.2588, -0.2588, 0.9659);
+  vec2 g = m * (uv * RENDERSIZE) / cell;
+  vec2 f = fract(g) - 0.5;
+  vec2 centre = (transpose(m) * ((floor(g) + 0.5) * cell)) / RENDERSIZE;
+  float L = luma(texture(inputImage, centre).rgb);
+  float rad = 0.62 * sqrt(clamp(L * 1.25, 0.0, 1.0));
+  return clamp((rad - length(f)) * cell + 0.5, 0.0, 1.0);
+}
+
+vec3 stageBackground(vec2 uv, vec3 tint, float lift) {
+  float aspect = RENDERSIZE.x / RENDERSIZE.y;
+  vec3 g = groundColor.rgb;
+  if (HAS_INPUT && bgMode == 1) {
+    vec3 s = texture(inputImage, uv).rgb;
+    float rad = 0.018;
+    for (int k = 0; k < 12; k++) {
+      float a = float(k) * 0.5236;
+      s += texture(inputImage, uv + vec2(cos(a) / aspect, sin(a)) * rad * (k % 2 == 0 ? 1.0 : 0.5)).rgb;
+    }
+    g = mix(g, s / 13.0, bgDim);
+  } else if (HAS_INPUT && bgMode == 2) {
+    g = mix(g, inkColor.rgb, stageHalftone(uv) * bgDim);
+  }
+  return g + tint * stageField(uv, lift) * fieldAmount;
+}
+
+vec3 stageFinish(vec3 col, vec2 uv) {
+  float aspect = RENDERSIZE.x / RENDERSIZE.y;
+  float v = length((uv - 0.5) * vec2(aspect, 1.0)) / (0.5 * sqrt(aspect * aspect + 1.0));
+  col *= 1.0 - vignette * smoothstep(0.35, 1.0, v);
+  float n = hash12(gl_FragCoord.xy + float(FRAMEINDEX) * 13.37) - 0.5;
+  return max(col + n * grain, vec3(0.0));
+}

package/skills/agentvfx/templates/spectrum/_src/spectrum-particles/fx.src.json

@@ -0,0 +1,58 @@
+{
+  "DESCRIPTION": "Particle-cloud box: a framed panel with a ruler and a hairline spectrum floor that fires bursts of one-tone dots on every strong onset",
+  "CREDIT": "agentvfx",
+  "ISFVSN": "2",
+  "CATEGORIES": ["spectrum", "audio", "particles", "hud"],
+  "INPUTS": [
+    { "NAME": "bandCount", "TYPE": "long", "MIN": 8, "MAX": 64, "DEFAULT": 48 },
+    { "NAME": "particleCount", "TYPE": "long", "MIN": 8, "MAX": 64, "DEFAULT": 56 },
+    { "NAME": "particleSize", "TYPE": "float", "MIN": 1, "MAX": 30, "DEFAULT": 9 },
+    { "NAME": "sparkShape", "TYPE": "long", "MIN": 0, "MAX": 2, "VALUES": [0, 1, 2], "LABELS": ["square", "circle", "cross"], "DEFAULT": 0 },
+    { "NAME": "speed", "TYPE": "float", "MIN": 0.1, "MAX": 3, "DEFAULT": 1.7 },
+    { "NAME": "spread", "TYPE": "float", "MIN": 0.2, "MAX": 6.28, "DEFAULT": 2.6 },
+    { "NAME": "drag", "TYPE": "float", "MIN": 0.1, "MAX": 8, "DEFAULT": 1.4 },
+    { "NAME": "gravity", "TYPE": "float", "MIN": -1, "MAX": 3, "DEFAULT": 0.3 },
+    { "NAME": "lifeSec", "TYPE": "float", "MIN": 0.3, "MAX": 2, "DEFAULT": 1.5 },
+    { "NAME": "barDim", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 0.9 }
+  ],
+  "use": ["pro", "stage", "hud"],
+  "defaults": { "hitFlux": 0.7, "startFreq": 25, "endFreq": 9000, "freqCurve": 2.3 },
+  "PASSES": [
+    { "TARGET": "partState", "PERSISTENT": true, "FLOAT": true },
+    {}
+  ],
+  "X_AGENTVFX": {
+    "id": "spectrum-particles",
+    "family": "spectrum",
+    "input": "either",
+    "spdx": "Apache-2.0",
+    "flash": "none",
+    "fps": 30,
+    "palette": true,
+    "presets": {
+      "cloud-black": {},
+      "cloud-ultramarine": { "$field": "ultramarine", "sparkShape": 1, "particleSize": 8 },
+      "cloud-acid": { "$field": "acid", "particleCount": 64, "particleSize": 9 },
+      "cross-orange": { "$field": "orange", "sparkShape": 2, "particleSize": 14, "particleCount": 36 },
+      "rainbow-glow": { "colorMode": 1, "glow": 2.2, "particleSize": 9, "sparkShape": 1 }
+    },
+    "audioBind": { "speed": "flux" },
+    "safeSubstitute": { "params": { "kickZoom": 0, "shake": 0 } },
+    "text": [
+      { "key": "title", "default": "CLOUD", "x": 0.02, "y": 0.04, "size": 0.065, "font": "display", "style": "outline", "box": "tab" },
+      { "key": "node", "default": "BURST 7G", "x": 0.97, "y": 0.03, "size": 0.07, "font": "tall", "align": "right" },
+      { "key": "n0", "default": "0", "x": 0.125, "y": 0.152, "size": 0.016, "font": "mono", "align": "right" },
+      { "key": "n1", "default": "1", "x": 0.125, "y": 0.296, "size": 0.016, "font": "mono", "align": "right" },
+      { "key": "n2", "default": "2", "x": 0.125, "y": 0.44, "size": 0.016, "font": "mono", "align": "right" },
+      { "key": "n3", "default": "3", "x": 0.125, "y": 0.584, "size": 0.016, "font": "mono", "align": "right" },
+      { "key": "n4", "default": "4", "x": 0.125, "y": 0.728, "size": 0.016, "font": "mono", "align": "right" },
+      { "key": "n5", "default": "5", "x": 0.125, "y": 0.872, "size": 0.016, "font": "mono", "align": "right" },
+      { "key": "log", "default": "N=56  FLUX GATE 0.7\nEMIT ON ONSET", "x": 0.14, "y": 0.91, "size": 0.015, "font": "mono", "reveal": "type", "revealStart": 0.3, "revealDur": 1.4 }
+    ],
+    "credits": [
+      "Particle-cloud box grammar: original drawing, no marks, fonts or text from other works",
+      "Closed-form ballistic particles with linear drag: x(t) = x0 + v (1 - exp(-k t)) / k, a standard result for velocity-proportional drag",
+      "Power-curve bin mapping and peak-preserving neighbour smoothing as described for open-source bar-visualiser recreations (algorithm described, no code used)"
+    ]
+  }
+}

package/skills/agentvfx/templates/spectrum/_src/spectrum-particles/main.src.frag

@@ -0,0 +1,119 @@
+// spectrum-particles main: the particle-cloud box. A framed panel with corner brackets and a 0..5 ruler
+// down the left edge; along its floor a hairline spectrum (one tick per bar, tip dot, peak dot). On every
+// hit (an onset at or above hitFlux) a burst of dots launches from the bar tips of that instant with
+// speed scaled by the hit's spectral flux; dots are clipped to the panel. Each of the last 8 hits owns a
+// slot in partState and its particles are evaluated in closed form:
+//   position = tip + v (1 - exp(-drag t)) / drag + (0, -gravity t^2 / 2)
+// with hashed launch angle, speed and size, so a frame needs no simulation. Shapes: 0 square, 1 circle,
+// 2 cross. Dots are ink-coloured (one tone), accent for the freshest ones; optional glow halo.
+//@include stage.glsl
+//@include hud.glsl
+
+float shapeCover(vec2 d, float s) {
+  if (sparkShape == 1) { return cov(length(d) - s); }
+  if (sparkShape == 2) {
+    vec2 a = abs(d);
+    return max(cov(a.x - s * 0.18) * step(a.y, s), cov(a.y - s * 0.18) * step(a.x, s));
+  }
+  return cov(max(abs(d.x), abs(d.y)) - s);
+}
+
+void main() {
+  vec2 res = RENDERSIZE;
+  float U = hudU();
+  vec4 clk = texelFetch(partState, ivec2(0, 9), 0);
+  vec2 sp = vUv * res;
+  vec2 px = stageUv(clk, vUv) * res;
+  vec2 lo = vec2(0.14 * res.x, 0.12 * res.y);
+  vec2 hi = vec2(0.94 * res.x, 0.84 * res.y);
+  float W = hi.x - lo.x;
+  float H = hi.y - lo.y;
+  float n = float(bandCount);
+  float span = introSpan();
+  float grow = introK();
+  float baseY = lo.y + 0.08 * H;
+  float extent = 0.5 * H * grow;
+  float pitch = W * 0.94 / n;
+  float x0 = lo.x + W * 0.03;
+  float inP = inRect(px, lo, hi);
+
+  float fb = floor((px.x - x0) / pitch);
+  float spec = 0.0;
+  float tipD = 0.0;
+  float capD = 0.0;
+  if (fb >= 0.0 && fb < n && abs(px.x / res.x - 0.5) * 2.0 < span * 0.9 + 0.001) {
+    vec4 st = texelFetch(partState, ivec2(int(fb), 8), 0);
+    float bc = x0 + (fb + 0.5) * pitch;
+    float hP = st.r * extent;
+    spec = hair(px.x - bc) * step(baseY, px.y) * step(px.y, baseY + hP * 0.45) * barDim;
+    tipD = cov(length(vec2(px.x - bc, px.y - baseY - hP * 0.45 - 3.0 * U)) - 1.4 * U) * step(0.012, st.r) * barDim;
+    capD = cov(length(vec2(px.x - bc, px.y - baseY - st.g * extent * 0.45 - 6.0 * U)) - 1.2 * U) * step(0.03, st.g);
+  }
+  float floorLine = hair(px.y - baseY) * step(x0, px.x) * step(px.x, x0 + pitch * n) * span;
+
+  float aspect = res.x / res.y;
+  vec2 pp = vec2((px.x - lo.x) / H * 1.0, (px.y - lo.y) / H);
+  float cloud = 0.0;
+  float fresh = 0.0;
+  float glowSum = 0.0;
+  for (int j = 0; j < 8; j++) {
+    vec4 meta = texelFetch(partState, ivec2(96, j), 0);
+    float age = (float(FRAMEINDEX) - meta.x) * TIMEDELTA;
+    if (meta.z < 0.5 || age < 0.0 || age > lifeSec) { continue; }
+    float life01 = age / lifeSec;
+    for (int p = 0; p < 64; p++) {
+      if (p >= particleCount) { break; }
+      vec2 h = hash22(vec2(float(p) * 1.618 + 3.0, meta.x * 0.731 + float(j)));
+      vec2 h2 = hash22(vec2(meta.x * 1.31 + 7.0, float(p) * 2.17 + 1.0));
+      int b = int(floor(h.x * n));
+      float hb = texelFetch(partState, ivec2(b, j), 0).r;
+      if (hb < 0.1) { continue; }
+      vec2 o = vec2((x0 - lo.x + pitch * (float(b) + h.y)) / H, (baseY - lo.y + hb * extent * 0.45) / H);
+      float ang = 1.5707963 + (h2.x - 0.5) * spread;
+      float spd = speed * meta.y * (0.35 + 0.65 * h2.y) * (0.5 + hb);
+      vec2 v = spd * vec2(cos(ang), sin(ang));
+      vec2 pos = o + v * (1.0 - exp(-drag * age)) / drag + vec2(0.0, -0.5 * gravity * age * age);
+      float s = particleSize * U * (0.4 + 0.6 * h.y) * (1.0 - life01 * 0.6) / H;
+      vec2 d = (pp - pos) * H;
+      float cv = shapeCover(d, s * H) * (1.0 - life01 * life01);
+      cloud = max(cloud, cv);
+      fresh = max(fresh, cv * step(age, 0.12));
+      float hd = length(d) / max(s * H, 1.0);
+      glowSum += (1.0 - life01) / (1.0 + hd * hd * hd * hd);
+    }
+  }
+  cloud *= inP;
+  fresh *= inP;
+
+  float rows = 0.0;
+  for (int r = 0; r <= 5; r++) {
+    float yr = hi.y - float(r) * H / 5.0;
+    float tk = hair(sp.y - yr) * step(lo.x - 14.0 * U, sp.x) * step(sp.x, lo.x - 4.0 * U);
+    rows = max(rows, tk);
+  }
+  float ticksMinor = 0.0;
+  for (int r = 0; r < 25; r++) {
+    float yr = hi.y - float(r) * H / 25.0;
+    ticksMinor = max(ticksMinor, hair(sp.y - yr) * step(lo.x - 8.0 * U, sp.x) * step(sp.x, lo.x - 4.0 * U));
+  }
+  float frame = boxLine(sp, lo, hi) * gridAmount;
+  float brk = brackets(sp, lo - 10.0 * U, hi + 10.0 * U, 26.0 * U) * gridAmount;
+  float dgrid = (hair(sp.y - (baseY + 0.25 * H)) + hair(sp.y - (baseY + 0.5 * H))) * dashes(sp.x, 8.0, 0.25) * inRect(sp, lo, hi) * 0.4 * gridAmount;
+  float plus = 0.0;
+  for (int c = 0; c < 4; c++) {
+    vec2 centre = vec2((c & 1) == 0 ? 0.03 * res.x : 0.97 * res.x, (c & 2) == 0 ? 0.04 * res.y : 0.96 * res.y);
+    plus = max(plus, plusAt(sp, centre, 8.0 * U));
+  }
+
+  vec3 ink = inkColor.rgb;
+  vec3 acc = accentAt(0.5);
+  vec3 col = stageBackground(vUv, ink, kickEnv(clk));
+  col += acc * glowSum * glow * 0.05 * inP;
+  col = mix(col, ink, max(max(rows, ticksMinor * 0.7), max(dgrid, floorLine * 0.8)) * span);
+  col = mix(col, ink, max(spec, cloud));
+  col = mix(col, acc, max(max(fresh, tipD), capD));
+  col = mix(col, ink, max(frame, brk));
+  if (marks) { col = mix(col, ink, plus); }
+  col = mix(col, ink, textInk());
+  fragColor = vec4(stageFinish(col, vUv), 1.0);
+}

package/skills/agentvfx/templates/spectrum/_src/spectrum-particles/pass0.src.frag

@@ -0,0 +1,33 @@
+// spectrum-particles pass 0: persistent state in `partState` (one texel per value, read with texelFetch).
+//   rows 0..7, x 0..bandCount-1 : spectrum snapshot (pro-motion bar values) taken at each hit, ring of 8 slots
+//   rows 0..7, x 96             : (birth frame, strength = spectral flux, 1, 1) of the hit stored in that slot
+//   row 8,   x 0..bandCount-1   : live bars, r = smoothed height, g = cap, b = cap speed, a = cap hold
+//   texel (0, 9)                : clock (hit count, last hit frame, kick count, last kick frame); the next
+//                                 slot is hit count mod 8
+// A hit is an onset whose spectral flux reaches hitFlux. Particles are then evaluated analytically in
+// main from the slot data, so they are exactly reproducible and never smear like advected sprites.
+//@include bars-fn.glsl
+
+void main() {
+  ivec2 px = ivec2(gl_FragCoord.xy);
+  vec4 prev = texelFetch(partState, px, 0);
+  vec4 clk = texelFetch(partState, ivec2(0, 9), 0);
+  bool hit = AUDIO_ONSET > 0.5 && AUDIO_FLUX >= hitFlux;
+  if (px.y == 8 && px.x < bandCount) {
+    fragColor = barStep(prev, px.x, bandCount);
+    return;
+  }
+  if (px.y < 8 && px.x <= 96) {
+    if (hit && px.y == int(mod(clk.x, 8.0))) {
+      fragColor = px.x < 96 ? vec4(px.x < bandCount ? smoothedBar(px.x, bandCount) : 0.0, 0.0, 0.0, 1.0) : vec4(float(FRAMEINDEX), clamp(AUDIO_FLUX, 0.4, 1.6), 1.0, 1.0);
+    } else {
+      fragColor = prev;
+    }
+    return;
+  }
+  if (px.x == 0 && px.y == 9) {
+    fragColor = clockStep(prev);
+    return;
+  }
+  fragColor = vec4(0.0);
+}

package/skills/agentvfx/templates/spectrum/_src/spectrum-radial/fx.src.json

@@ -0,0 +1,56 @@
+{
+  "DESCRIPTION": "Starburst instrument: mirrored hairline spectrum spokes with tip dots, echo ghosts, tick ring, dashed outer circle and a bracketed frame; the ring snaps on strong onsets",
+  "CREDIT": "agentvfx",
+  "ISFVSN": "2",
+  "CATEGORIES": ["spectrum", "audio", "hud"],
+  "INPUTS": [
+    { "NAME": "bandCount", "TYPE": "long", "MIN": 8, "MAX": 120, "DEFAULT": 64 },
+    { "NAME": "maxHeight", "TYPE": "float", "MIN": 0.05, "MAX": 1, "DEFAULT": 1 },
+    { "NAME": "displayMode", "TYPE": "long", "MIN": 0, "MAX": 2, "VALUES": [0, 1, 2], "LABELS": ["hairline", "stepped", "dots"], "DEFAULT": 0 },
+    { "NAME": "side", "TYPE": "long", "MIN": 0, "MAX": 1, "VALUES": [0, 1], "LABELS": ["outward", "inward"], "DEFAULT": 0 },
+    { "NAME": "lobes", "TYPE": "long", "MIN": 1, "MAX": 8, "DEFAULT": 2 },
+    { "NAME": "echoLayers", "TYPE": "long", "MIN": 0, "MAX": 6, "DEFAULT": 3 },
+    { "NAME": "echoDelay", "TYPE": "long", "MIN": 1, "MAX": 4, "DEFAULT": 2 },
+    { "NAME": "innerRadius", "TYPE": "float", "MIN": 0.06, "MAX": 0.4, "DEFAULT": 0.12 },
+    { "NAME": "spin", "TYPE": "float", "MIN": -6, "MAX": 6, "DEFAULT": 0.12 },
+    { "NAME": "snapDeg", "TYPE": "float", "MIN": 0, "MAX": 90, "DEFAULT": 9 },
+    { "NAME": "pulse", "TYPE": "float", "MIN": 0, "MAX": 0.5, "DEFAULT": 0.08 },
+    { "NAME": "tickCount", "TYPE": "float", "MIN": 12, "MAX": 360, "DEFAULT": 120 },
+    { "NAME": "floorHeight", "TYPE": "float", "MIN": 0, "MAX": 10, "DEFAULT": 3 }
+  ],
+  "use": ["pro", "stage", "hud"],
+  "defaults": { "startFreq": 25, "endFreq": 9000, "freqCurve": 2.3 },
+  "PASSES": [
+    { "TARGET": "barState", "PERSISTENT": true, "FLOAT": true },
+    {}
+  ],
+  "X_AGENTVFX": {
+    "id": "spectrum-radial",
+    "family": "spectrum",
+    "input": "either",
+    "spdx": "Apache-2.0",
+    "flash": "possible",
+    "fps": 30,
+    "palette": true,
+    "presets": {
+      "starburst-black": {},
+      "starburst-ultramarine": { "$field": "ultramarine", "displayMode": 1 },
+      "starburst-acid": { "$field": "acid", "lobes": 3, "bandCount": 48 },
+      "dots-orange": { "$field": "orange", "displayMode": 2, "bandCount": 40 },
+      "rainbow-glow": { "colorMode": 1, "glow": 1.4, "lineWidth": 2.4 }
+    },
+    "audioBind": { "pulse": "onset" },
+    "safeSubstitute": { "params": { "pulse": 0, "snapDeg": 0, "kickZoom": 0, "shake": 0 } },
+    "text": [
+      { "key": "title", "default": "RADIAL", "x": 0.03, "y": 0.06, "size": 0.07, "font": "display", "style": "outline", "box": "tab" },
+      { "key": "node", "default": "NODE 7G-75", "x": 0.97, "y": 0.045, "size": 0.085, "font": "tall", "align": "right" },
+      { "key": "log", "default": "SIG 04 // 25-9000HZ\nRING LOCK  0x04F2\nCACHE OK", "x": 0.03, "y": 0.8, "size": 0.017, "font": "mono", "reveal": "type", "revealStart": 0.2, "revealDur": 1.5 },
+      { "key": "num", "default": "KX  7G2  R4  D9\n41A TQP  118  3", "x": 0.97, "y": 0.9, "size": 0.016, "font": "mono", "align": "right" }
+    ],
+    "credits": [
+      "Starburst glyph and bracketed frame grammar: original drawing, no marks, fonts or text from other works",
+      "After Effects Audio Spectrum polar path vocabulary, https://helpx.adobe.com/after-effects/using/audio-effects.html",
+      "Power-curve bin mapping and peak-preserving neighbour smoothing as described for open-source bar-visualiser recreations (algorithm described, no code used)"
+    ]
+  }
+}

package/skills/agentvfx/templates/spectrum/_src/spectrum-radial/main.src.frag

@@ -0,0 +1,95 @@
+// spectrum-radial main: a starburst instrument. The spectrum is mirrored and repeated `lobes` times
+// around a centre as hairline spokes (a spoke per bar, length = bar height) with tip dots, older echoes
+// of the bars as dim hairline ghosts (echoLayers), a tick ring (tickCount), a dashed outer circle, a
+// bracketed square frame with corner + marks, and a centre disc. The ring spins at `spin` rad/s and snaps
+// snapDeg on every hit (an onset at or above hitFlux), when the centre disc fills with ink for ~3 frames.
+// displayMode 0 = hairline spokes, 1 = spokes with step ticks, 2 = dots. Labels come from the text layer.
+//@include stage.glsl
+//@include hud.glsl
+const float TAU = 6.28318530718;
+
+vec4 barAt(int i, int d) { return texelFetch(barState, ivec2(clamp(i, 0, bandCount - 1), d == 0 ? 0 : 3 + d), 0); }
+
+void main() {
+  vec2 res = RENDERSIZE;
+  float U = hudU();
+  float px1 = 1.0 / res.y;
+  vec4 ev = texelFetch(barState, ivec2(0, 1), 0);
+  vec2 sp = vUv * res;
+  vec2 uv = stageUv(ev, vUv);
+  vec2 p = (uv * res - res * 0.5) * px1;
+  float n = float(bandCount);
+  float since = stageSince(ev.x, ev.y);
+  float hitOn = step(0.5, ev.x) * step(0.5, exp(-since / 0.11));
+  float rot = TIME * spin + (ev.x > 0.5 ? radians(snapDeg) * (ev.x - exp(-since / 0.05)) : 0.0);
+  float R0 = innerRadius * (1.0 + pulse * hitOn) * (0.4 + 0.6 * introSpan());
+  float r = length(p);
+  float a = atan(p.y, p.x) - rot - 1.5707963;
+  float turns = fract(a / TAU * float(lobes));
+  float m = abs(turns * 2.0 - 1.0);
+  float fm = m * n;
+  int i = int(clamp(floor(fm), 0.0, n - 1.0));
+  float ap = TAU / (float(lobes) * 2.0 * n);
+  float lx = (fract(fm) - 0.5) * ap * max(r, 0.02);
+  float room = 0.4;
+  float extent = (side == 1 ? R0 * 0.92 : room - R0) * maxHeight * introK();
+  float dr = side == 1 ? R0 - r : r - R0;
+  float wU = hudW() * px1;
+  float spoke = abs(lx) < wU * 0.5 + px1 * 0.5 ? clamp(wU * 0.5 - abs(lx) + px1 * 0.5, 0.0, px1) / px1 : 0.0;
+  vec4 bar = barAt(i, 0);
+  float u1 = 1.0 / 1080.0;
+  float hj = bar.r * extent + floorHeight * u1;
+  float body = 0.0;
+  if (displayMode == 0) {
+    body = spoke * step(0.0, dr) * step(dr, hj);
+  } else if (displayMode == 1) {
+    float stepH = extent / 14.0;
+    body = spoke * step(0.0, dr) * step(dr, hj) * (0.45 + 0.55 * step(0.5, fract(dr / stepH)));
+  } else {
+    float cellD = 9.0 * u1;
+    float j = floor(dr / cellD);
+    body = dr >= 0.0 && j * cellD < hj ? cov((length(vec2(lx, dr - (j + 0.5) * cellD)) - 1.4 * u1) / px1) : 0.0;
+  }
+  float tip = cov((length(vec2(lx, dr - hj - 5.0 * u1)) - 1.6 * u1) / px1) * step(0.012, bar.r);
+  float capY = bar.g * extent;
+  float cap = capY > hj + 9.0 * u1 ? cov((length(vec2(lx * 0.5, dr - capY - 6.0 * u1)) - 1.3 * u1) / px1) : 0.0;
+
+  float ghosts = 0.0;
+  for (int l = 6; l >= 1; l--) {
+    if (l > echoLayers) { continue; }
+    float hl = barAt(i, l * echoDelay).r * extent;
+    ghosts = max(ghosts, spoke * step(0.0, dr) * step(dr, hl) * (0.4 - 0.05 * float(l)));
+  }
+
+  float ring0 = hair((r - R0 * 0.96) / px1);
+  float ringO = hair((r - 0.43) / px1) * dashes(a * 0.43 / px1, 9.0, 0.5);
+  float tickLen = 0.014;
+  float tk = abs(fract(a / TAU * tickCount) - 0.5) * (TAU * 0.4 / tickCount);
+  float ticks = step(abs(r - 0.4), tickLen * (mod(floor(a / TAU * tickCount), 5.0) < 0.5 ? 1.0 : 0.5)) * cov((tk - wU * 0.5) / px1);
+  float discFill = hitOn * step(r, R0 * 0.88);
+
+  float inner = hair((r - R0 * 0.88) / px1) * 0.7;
+  vec2 qc = abs(p);
+  float cross = max(hair(qc.y / px1) * step(qc.x, 0.014), hair(qc.x / px1) * step(qc.y, 0.014));
+  vec2 flo = vec2(0.5 * res.x - 0.47 * res.y, 0.03 * res.y);
+  vec2 fhi = vec2(0.5 * res.x + 0.47 * res.y, 0.97 * res.y);
+  float brk = brackets(sp, flo, fhi, 30.0 * U);
+  float plus = 0.0;
+  for (int c = 0; c < 4; c++) {
+    vec2 centre = vec2((c & 1) == 0 ? flo.x - 18.0 * U : fhi.x + 18.0 * U, (c & 2) == 0 ? flo.y : fhi.y);
+    plus = max(plus, plusAt(sp, centre, 7.0 * U));
+  }
+
+  float mk = max(max(body, ghosts), max(max(tip, cap), max(ring0, inner)));
+  mk = max(mk, max(ringO * 0.6, ticks * 0.8));
+  mk = max(mk, max(discFill, cross * 0.6 * float(marks)));
+  mk = max(mk, max(brk * gridAmount, plus * float(marks)));
+  mk = max(mk, textInk());
+  vec3 ink = inkColor.rgb;
+  vec3 gnd = stageBackground(vUv, ink, kickEnv(ev));
+  vec3 acc = accentAt((float(i) + 0.5) / n);
+  vec3 col = mix(gnd, ink, mk);
+  col = mix(col, acc, max(tip, cap));
+  col += acc * exp(-max(dr - hj, 0.0) / max(glowRadius, px1)) * glow * 0.25 * step(0.0, dr) * step(r, 0.45) * bar.r;
+  fragColor = vec4(stageFinish(col, vUv), 1.0);
+}

package/skills/agentvfx/templates/spectrum/_src/spectrum-radial/pass0.src.frag

@@ -0,0 +1,2 @@
+// spectrum-radial pass 0: pro-motion bar state plus a shift register of past bar rows (echo layers).
+//@include bars-pass.glsl

package/skills/agentvfx/templates/spectrum/_src/waveform-line/fx.src.json

@@ -0,0 +1,60 @@
+{
+  "DESCRIPTION": "Waveform strip instrument: framed panel with a 0..5 ruler, dashed axis and a smoothed multi-layer hairline waveform (line, hair columns or dots)",
+  "CREDIT": "agentvfx",
+  "ISFVSN": "2",
+  "CATEGORIES": ["spectrum", "audio", "hud"],
+  "INPUTS": [
+    { "NAME": "amplitude", "TYPE": "float", "MIN": 0.05, "MAX": 0.5, "DEFAULT": 0.5 },
+    { "NAME": "gain", "TYPE": "float", "MIN": 0.5, "MAX": 12, "DEFAULT": 8 },
+    { "NAME": "smoothWin", "TYPE": "float", "MIN": 1, "MAX": 200, "DEFAULT": 60 },
+    { "NAME": "flow", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 0.35 },
+    { "NAME": "pinch", "TYPE": "float", "MIN": 0, "MAX": 4, "DEFAULT": 0.8 },
+    { "NAME": "layers", "TYPE": "long", "MIN": 1, "MAX": 8, "DEFAULT": 4 },
+    { "NAME": "layerDelay", "TYPE": "long", "MIN": 1, "MAX": 3, "DEFAULT": 2 },
+    { "NAME": "displayMode", "TYPE": "long", "MIN": 0, "MAX": 2, "VALUES": [0, 1, 2], "LABELS": ["line", "hair-columns", "dots"], "DEFAULT": 0 },
+    { "NAME": "columns", "TYPE": "long", "MIN": 16, "MAX": 400, "DEFAULT": 240 },
+    { "NAME": "mirror", "TYPE": "bool", "DEFAULT": false },
+    { "NAME": "hitBoost", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 1 }
+  ],
+  "use": ["stage", "hud"],
+  "defaults": { "hitFlux": 0.9 },
+  "PASSES": [
+    { "TARGET": "wstate", "PERSISTENT": true, "FLOAT": true },
+    {}
+  ],
+  "X_AGENTVFX": {
+    "id": "waveform-line",
+    "family": "spectrum",
+    "input": "either",
+    "spdx": "Apache-2.0",
+    "flash": "none",
+    "fps": 30,
+    "palette": true,
+    "presets": {
+      "strip-black": {},
+      "hair-columns": { "displayMode": 1, "mirror": true, "layers": 2 },
+      "strip-ultramarine": { "$field": "ultramarine", "layers": 5 },
+      "strip-acid": { "$field": "acid", "displayMode": 1, "columns": 300 },
+      "dots-orange": { "$field": "orange", "displayMode": 2, "columns": 120, "layers": 3 },
+      "rainbow-glow": { "colorMode": 1, "glow": 1.4, "lineWidth": 2.6, "layers": 7 }
+    },
+    "audioBind": { "hitBoost": "onset" },
+    "safeSubstitute": { "params": { "hitBoost": 0, "kickZoom": 0, "shake": 0 } },
+    "text": [
+      { "key": "title", "default": "WAVEFORM", "x": 0.08, "y": 0.07, "size": 0.07, "font": "display", "style": "outline", "box": "tab" },
+      { "key": "node", "default": "STRIP 04", "x": 0.92, "y": 0.045, "size": 0.085, "font": "tall", "align": "right" },
+      { "key": "n0", "default": "0", "x": 0.08, "y": 0.28, "size": 0.018, "font": "mono", "align": "center" },
+      { "key": "n1", "default": "1", "x": 0.248, "y": 0.28, "size": 0.018, "font": "mono", "align": "center" },
+      { "key": "n2", "default": "2", "x": 0.416, "y": 0.28, "size": 0.018, "font": "mono", "align": "center" },
+      { "key": "n3", "default": "3", "x": 0.584, "y": 0.28, "size": 0.018, "font": "mono", "align": "center" },
+      { "key": "n4", "default": "4", "x": 0.752, "y": 0.28, "size": 0.018, "font": "mono", "align": "center" },
+      { "key": "n5", "default": "5", "x": 0.92, "y": 0.28, "size": 0.018, "font": "mono", "align": "center" },
+      { "key": "log", "default": "L/R MONO  48K  16BIT\nTRIG RISING 0X  LOCK", "x": 0.08, "y": 0.8, "size": 0.017, "font": "mono", "reveal": "type", "revealStart": 0.3, "revealDur": 1.4 }
+    ],
+    "credits": [
+      "Waveform strip with a numbered ruler: original drawing, no marks, fonts or text from other works",
+      "After Effects Audio Waveform parameter vocabulary, https://helpx.adobe.com/after-effects/using/audio-effects.html",
+      "Distance estimate |y - f(x)| / sqrt(1 + f'(x)^2) for a graph, https://iquilezles.org/articles/distance/"
+    ]
+  }
+}