agentvfx 0.0.0-stage → 0.3.5

package/skills/agentvfx/templates/scope/xy-phosphor/pass0.frag

@@ -0,0 +1,56 @@
+// xy-phosphor pass0: the beam segment table. Texel k holds segment k as (a.xy, b.xy) in height
+// units with the origin at the screen centre; unused texels hold 1000 (off screen).
+// srcMode 0: audio L -> X, R -> Y (a mono input is delay-embedded: Y = the signal a few samples later).
+// srcMode 1: Lissajous test signal x = sin(a*th + delta), y = sin(b*th). srcMode 2: the same, driven by the audio.
+const int NSEG = 511;
+const float TAU = 6.28318530718;
+
+float ch(int row, int i) { return texelFetch(audio, ivec2(clamp(i, 0, 511), row), 0).r * 2.0 - 1.0; }
+
+bool monoInput() {
+  float d = 0.0;
+  for (int i = 0; i < 512; i += 4) d = max(d, abs(ch(0, i) - ch(1, i)));
+  return d < 0.002;
+}
+
+vec2 lissajous(int i) {
+  float th = TAU * lissFreq * (TIME + float(i) / 48000.0);
+  float dl = lissDelta + lissDrift * TIME;
+  float amp = 1.0;
+  if (srcMode == 2) {
+    amp = 0.45 + 0.75 * clamp(AUDIO_RMS * 5.0, 0.0, 1.0);
+    dl += 0.2 * AUDIO_TREB_ATT;
+  }
+  vec2 v = vec2(sin(float(lissA) * th + TAU * dl), sin(float(lissB) * th));
+  vec2 f = sin(v * (1.0 + 3.0 * lissFold) * 1.57079633);
+  return mix(v, f, min(lissFold * 2.0, 1.0)) * amp;
+}
+
+vec2 beamPoint(int i, bool mono) {
+  vec2 v;
+  if (srcMode == 0) {
+    float r = mix(ch(1, i), ch(1, i + embedDelay), mono ? monoWiden : 0.0);
+    v = tanh(gain * vec2(ch(0, i), r));
+  } else {
+    v = lissajous(i);
+  }
+  v = rot(angle) * v * scale;
+  return v + (hash22(vec2(float(i), float(FRAMEINDEX))) - 0.5) * noise;
+}
+
+void main() {
+  ivec2 t = ivec2(gl_FragCoord.xy);
+  int cols = int(min(RENDERSIZE.x, 512.0));
+  int k = t.y * cols + t.x;
+  if (k >= NSEG) {
+    fragColor = vec4(1000.0);
+    return;
+  }
+  bool mono = srcMode == 0 && monoInput();
+  int reach = mono ? int(monoWiden * float(embedDelay)) : 0;
+  if (k + 1 + reach > 511) {
+    fragColor = vec4(1000.0);
+    return;
+  }
+  fragColor = vec4(beamPoint(k, mono), beamPoint(k + 1, mono));
+}

package/skills/agentvfx/templates/scope/xy-phosphor/pass1.frag

@@ -0,0 +1,44 @@
+// xy-phosphor pass1: the phosphor. Every pixel sums the Gaussian beam integral of all 511 segments
+// (woscope model: the beam covers a segment in equal time, so intensity ~ 1/segment length, a fast
+// sweep is dim and a slow one is bright), then adds it to the decayed previous frame.
+float erfa(float x) {
+  float s = sign(x);
+  x = abs(x);
+  float t = 1.0 / (1.0 + 0.3275911 * x);
+  float y = 1.0 - (((((1.061405429 * t - 1.453152027) * t) + 1.421413741) * t - 0.284496736) * t + 0.254829592) * t * exp(-x * x);
+  return s * y;
+}
+
+void main() {
+  float H = RENDERSIZE.y;
+  vec2 p = (gl_FragCoord.xy - 0.5 * RENDERSIZE) / H;
+  float sg = beamWidth / 1080.0;
+  float cut = 4.0 * sg;
+  int cols = int(min(RENDERSIZE.x, 512.0));
+  float acc = 0.0;
+  for (int k = 0; k < 511; k++) {
+    vec4 s = texelFetch(pts, ivec2(k % cols, k / cols), 0);
+    vec2 a = s.xy;
+    vec2 b = s.zw;
+    vec2 lo = min(a, b) - cut;
+    vec2 hi = max(a, b) + cut;
+    if (p.x < lo.x || p.y < lo.y || p.x > hi.x || p.y > hi.y) continue;
+    vec2 d = b - a;
+    float l = length(d);
+    vec2 q = p - a;
+    if (l < 0.05 * sg) {
+      vec2 m = q - 0.5 * d;
+      acc += exp(-dot(m, m) / (2.0 * sg * sg));
+    } else {
+      vec2 dir = d / l;
+      float x = dot(q, dir);
+      float y = dot(q, vec2(-dir.y, dir.x));
+      float inv = 0.70710678 / sg;
+      acc += exp(-y * y / (2.0 * sg * sg)) * 1.2533141 * sg * (erfa(x * inv) - erfa((x - l) * inv)) / l;
+    }
+  }
+  float kick = 1.0 + audioKick * (0.6 * AUDIO_BASS_ATT + 1.2 * AUDIO_ONSET);
+  float prev = FRAMEINDEX == 0 ? 0.0 : texture(beam, vUv).r;
+  float heat = max(prev * persistence - 0.0002, 0.0) + acc * intensity * kick * (1.0 - 0.6 * persistence);
+  fragColor = vec4(heat, 0.0, 0.0, 1.0);
+}

package/skills/agentvfx/templates/scope/xy-phosphor/pass2.frag

@@ -0,0 +1,12 @@
+// pass2: horizontal blur of the beam, tight scale (13 taps, stride 2 px at 1080p). Half-res style bloom, level 1.
+void main() {
+  float st = 2.0 * (RENDERSIZE.y / 1080.0) * bloomSize / RENDERSIZE.x;
+  vec4 acc = vec4(0.0);
+  float wt = 0.0;
+  for (int k = -6; k <= 6; k++) {
+    float w = exp(-0.5 * float(k * k) / 9.0);
+    acc += w * texture(beam, vUv + vec2(float(k) * st, 0.0));
+    wt += w;
+  }
+  fragColor = acc / wt;
+}

package/skills/agentvfx/templates/scope/xy-phosphor/pass3.frag

@@ -0,0 +1,12 @@
+// pass3: vertical blur, tight scale. Output bv1 = the beam blurred about 6 px (at 1080p).
+void main() {
+  float st = 2.0 * (RENDERSIZE.y / 1080.0) * bloomSize / RENDERSIZE.y;
+  vec4 acc = vec4(0.0);
+  float wt = 0.0;
+  for (int k = -6; k <= 6; k++) {
+    float w = exp(-0.5 * float(k * k) / 9.0);
+    acc += w * texture(bh1, vUv + vec2(0.0, float(k) * st));
+    wt += w;
+  }
+  fragColor = acc / wt;
+}

package/skills/agentvfx/templates/scope/xy-phosphor/pass4.frag

@@ -0,0 +1,12 @@
+// pass4: horizontal blur of bv1 at a wide stride (7 px at 1080p): the deep glow tail, level 2.
+void main() {
+  float st = 7.0 * (RENDERSIZE.y / 1080.0) * bloomSize / RENDERSIZE.x;
+  vec4 acc = vec4(0.0);
+  float wt = 0.0;
+  for (int k = -6; k <= 6; k++) {
+    float w = exp(-0.5 * float(k * k) / 9.0);
+    acc += w * texture(bv1, vUv + vec2(float(k) * st, 0.0));
+    wt += w;
+  }
+  fragColor = acc / wt;
+}

package/skills/agentvfx/templates/scope/xy-phosphor/pass5.frag

@@ -0,0 +1,12 @@
+// pass5: vertical blur at the wide stride. Output bv2 = the deep glow (about 20 px sigma at 1080p).
+void main() {
+  float st = 7.0 * (RENDERSIZE.y / 1080.0) * bloomSize / RENDERSIZE.y;
+  vec4 acc = vec4(0.0);
+  float wt = 0.0;
+  for (int k = -6; k <= 6; k++) {
+    float w = exp(-0.5 * float(k * k) / 9.0);
+    acc += w * texture(bh2, vUv + vec2(0.0, float(k) * st));
+    wt += w;
+  }
+  fragColor = acc / wt;
+}

package/skills/agentvfx/templates/scope/xy-phosphor/pass6.frag

@@ -0,0 +1,251 @@
+// xy-phosphor pass6: HUD chrome. Generated layout constants below match the text items in fx.json.
+#define KIND 0
+#define CLOUD_PTS 1
+#define DIAMOND 0
+#define C_LO vec2(0.286, 0.12)
+#define C_HI vec2(0.714, 0.88)
+#define GRID_X 8
+#define GRID_Y 8
+#define READ_B int(clamp(AUDIO_BPM, 0.0, 999.0))
+// HUD pass: chrome mask. R = hard ink (frames, ticks, digits, graph lines), G = faint ink (dashed grids, minor marks).
+// Layout constants here are shared with the text items of fx.json (x right, y up in uv; text y counts from the top).
+// KIND 0 = square XY panel, 1 = wide scope panel, 2 = polar panel, 3 = spectrogram panel.
+const float U = 1.0 / 1080.0;
+float ASP;
+float AA;
+
+float cov(float d) { return clamp(0.5 - d / AA, 0.0, 1.0); }
+float stroke(float d, float w) { return cov(abs(d) - 0.5 * w); }
+float sdBox(vec2 p, vec2 h) {
+  vec2 d = abs(p) - h;
+  return length(max(d, 0.0)) + min(max(d.x, d.y), 0.0);
+}
+vec2 hu(vec2 uv, vec2 c) { return (uv - c) * vec2(ASP, 1.0); }
+float panelSd(vec2 uv, vec2 lo, vec2 hi, float r) {
+  vec2 h = 0.5 * (hi - lo) * vec2(ASP, 1.0);
+  return sdBox(hu(uv, 0.5 * (lo + hi)), h - r) - r;
+}
+float inside(vec2 uv, vec2 lo, vec2 hi) { return cov(panelSd(uv, lo, hi, 0.0) + 2.0 * U); }
+
+float gridDashed(vec2 uv, vec2 lo, vec2 hi, int nx, int ny) {
+  vec2 n = vec2(float(nx), float(ny));
+  vec2 sz = (hi - lo) * vec2(ASP, 1.0);
+  vec2 f = abs(fract((uv - lo) / (hi - lo) * n + 0.5) - 0.5) * sz / n;
+  vec2 along = (uv - lo) * vec2(ASP, 1.0);
+  float vx = stroke(f.x, 1.0 * U) * step(fract(along.y / (9.0 * U)), 0.4);
+  float hy = stroke(f.y, 1.0 * U) * step(fract(along.x / (9.0 * U)), 0.4);
+  return max(vx, hy) * inside(uv, lo, hi);
+}
+
+float ticks(vec2 uv, vec2 lo, vec2 hi, int nx, int ny) {
+  vec2 sz = (hi - lo) * vec2(ASP, 1.0);
+  vec2 loc = max((uv - lo) * vec2(ASP, 1.0), 0.0);
+  vec2 n = vec2(float(nx * 5), float(ny * 5));
+  vec2 k = loc / (sz / n);
+  vec2 f = abs(fract(k + 0.5) - 0.5) * sz / n;
+  ivec2 ik = ivec2(floor(k + 0.5));
+  float lx = (ik.x % 5 == 0) ? 14.0 * U : 7.0 * U;
+  float ly = (ik.y % 5 == 0) ? 14.0 * U : 7.0 * U;
+  float tb = stroke(f.x, 1.2 * U) * step(loc.y, lx);
+  float tl = stroke(f.y, 1.2 * U) * step(loc.x, ly);
+  return max(tb, tl) * inside(uv, lo, hi);
+}
+
+float plusAt(vec2 uv, vec2 c, float arm) {
+  vec2 d = hu(uv, c);
+  return max(stroke(d.y, 1.2 * U) * step(abs(d.x), arm), stroke(d.x, 1.2 * U) * step(abs(d.y), arm));
+}
+
+float brackets(vec2 uv, vec2 lo, vec2 hi) {
+  vec2 a = abs(hu(uv, 0.5 * (lo + hi)));
+  vec2 h = 0.5 * (hi - lo) * vec2(ASP, 1.0) + 10.0 * U;
+  float arm = 36.0 * U;
+  float w = 2.6 * U;
+  float hz = stroke(a.y - h.y, w) * step(h.x - arm, a.x) * step(a.x, h.x + 0.5 * w);
+  float vt = stroke(a.x - h.x, w) * step(h.y - arm, a.y) * step(a.y, h.y + 0.5 * w);
+  return max(hz, vt);
+}
+
+float icon(vec2 uv, vec2 c, int k) {
+  vec2 q = hu(uv, c) / (9.0 * U);
+  float d;
+  if (k == 0) d = abs(length(q) - 1.0);
+  else if (k == 1) d = abs(max(abs(q.x), abs(q.y)) - 0.85);
+  else if (k == 2) d = min(abs(length(q) - 1.0), min(abs(q.x) + 9.0 * step(0.7, abs(q.y)), abs(q.y) + 9.0 * step(0.7, abs(q.x))));
+  else {
+    q.y += 0.15;
+    d = abs(max(abs(q.x) * 0.866 + q.y * 0.5, -q.y) - 0.6);
+  }
+  return cov(d * 9.0 * U - 0.6 * U);
+}
+
+float rowv(int row, int i) { return texelFetch(audio, ivec2(clamp(i, 0, 511), row), 0).r * 2.0 - 1.0; }
+
+float specU(float t) {
+  float f = 40.0 * pow(400.0, clamp(t, 0.0, 1.0));
+  float v = texture(audioFFT, vec2(((f - 29.3) / 46.875 + 0.5) / 512.0, 0.5)).r;
+  return clamp((v * 70.0 - 70.0 + 3.0 * log2(f / 1000.0) + 62.0) / 38.0, 0.0, 1.0);
+}
+
+float trace(vec2 uv, vec2 lo, vec2 hi, float y0, float y1) {
+  float lo_ = min(y0, y1);
+  float hi_ = max(y0, y1);
+  return cov(max(lo_ - uv.y, uv.y - hi_) - 0.7 * U) * inside(uv, lo, hi);
+}
+
+float specGraph(vec2 uv, vec2 lo, vec2 hi) {
+  float t = (uv.x - lo.x) / (hi.x - lo.x);
+  float st = 1.5 * AA / ((hi.x - lo.x) * ASP);
+  float v0 = max(specU(t - st), specU(t));
+  float v1 = max(specU(t), specU(t + st));
+  return trace(uv, lo, hi, lo.y + v0 * (hi.y - lo.y) * 0.96, lo.y + v1 * (hi.y - lo.y) * 0.96);
+}
+
+float waveStrip(vec2 uv, vec2 lo, vec2 hi) {
+  float t = (uv.x - lo.x) / (hi.x - lo.x);
+  int i = int(t * 511.0);
+  float c = 0.5 * (lo.y + hi.y);
+  float h = 0.45 * (hi.y - lo.y);
+  float a = clamp(rowv(0, i) * 2.5, -1.0, 1.0);
+  float b = clamp(rowv(0, i + 1) * 2.5, -1.0, 1.0);
+  return trace(uv, lo, hi, c + a * h, c + b * h);
+}
+
+float cloud(vec2 uv, vec2 lo, vec2 hi) {
+  vec2 hs = 0.5 * (hi - lo) * vec2(ASP, 1.0);
+  vec2 q = hu(uv, 0.5 * (lo + hi));
+  float m = 1.0e3;
+  for (int k = 0; k < 127; k++) {
+    int i = k * 4;
+#if CLOUD_PTS
+    int cols = int(min(RENDERSIZE.x, 512.0));
+    vec2 v = texelFetch(pts, ivec2(i % cols, i / cols), 0).xy / 0.4;
+#else
+    vec2 v = tanh(2.0 * vec2(rowv(0, i), rowv(1, i)));
+#endif
+    m = min(m, length(q - v * hs * 0.9));
+  }
+  return cov(m - 1.3 * U) * inside(uv, lo, hi);
+}
+
+float segD(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 digit(vec2 p, int d) {
+  int m = d == 0 ? 63 : d == 1 ? 6 : d == 2 ? 91 : d == 3 ? 79 : d == 4 ? 102 : d == 5 ? 109 : d == 6 ? 125 : d == 7 ? 7 : d == 8 ? 127 : 111;
+  float b = 1.0e3;
+  if ((m & 1) != 0) b = min(b, segD(p, vec2(0.0, 1.0), vec2(0.5, 1.0)));
+  if ((m & 2) != 0) b = min(b, segD(p, vec2(0.5, 1.0), vec2(0.5, 0.5)));
+  if ((m & 4) != 0) b = min(b, segD(p, vec2(0.5, 0.5), vec2(0.5, 0.0)));
+  if ((m & 8) != 0) b = min(b, segD(p, vec2(0.0, 0.0), vec2(0.5, 0.0)));
+  if ((m & 16) != 0) b = min(b, segD(p, vec2(0.0, 0.5), vec2(0.0, 0.0)));
+  if ((m & 32) != 0) b = min(b, segD(p, vec2(0.0, 1.0), vec2(0.0, 0.5)));
+  if ((m & 64) != 0) b = min(b, segD(p, vec2(0.0, 0.5), vec2(0.5, 0.5)));
+  return b;
+}
+
+float number(vec2 uv, vec2 org, float h, int val, int n) {
+  vec2 q = hu(uv, org);
+  float best = 1.0e3;
+  for (int i = 0; i < 4; i++) {
+    if (i >= n) break;
+    int pw = 1;
+    for (int j = 1; j < 4; j++) if (j < n - i) pw *= 10;
+    int dv = (max(val, 0) / pw) % 10;
+    vec2 p = vec2(q.x - float(i) * 0.8 * h, q.y + h) / h;
+    if (p.x > -0.3 && p.x < 0.85 && p.y > -0.3 && p.y < 1.3) best = min(best, digit(p, dv) * h);
+  }
+  return cov(best - 0.8 * U);
+}
+
+#if KIND == 2
+float polarGrid(vec2 uv, out float hard) {
+  vec2 q = hu(uv, vec2(0.5));
+  float r = length(q);
+  float a = atan(q.y, q.x);
+  hard = stroke(r - ringRadius, 1.3 * U) + stroke(r - 0.36, 1.1 * U);
+  float f = stroke(r - ringRadius - depth, 1.0 * U) + stroke(r - max(ringRadius - depth, 0.01), 1.0 * U);
+  if (spokes > 0) {
+    float st = 6.28318530718 / float(spokes);
+    float da = abs(mod(a + 0.5 * st, st) - 0.5 * st) * r;
+    f += stroke(da, 1.0 * U) * step(ringRadius - depth, r) * step(r, ringRadius + depth) * 0.8;
+  }
+  return f;
+}
+#endif
+
+void main() {
+  ASP = RENDERSIZE.x / RENDERSIZE.y;
+  AA = 1.0 / RENDERSIZE.y;
+  vec2 uv = vUv;
+  float hard = 0.0;
+  float faint = 0.0;
+  vec2 cLo = C_LO;
+  vec2 cHi = C_HI;
+
+  hard = max(hard, stroke(panelSd(uv, cLo, cHi, 0.0), 1.4 * U));
+  hard = max(hard, brackets(uv, cLo, cHi));
+  faint = max(faint, gridDashed(uv, cLo, cHi, GRID_X, GRID_Y));
+  hard = max(hard, ticks(uv, cLo, cHi, GRID_X, GRID_Y) * 0.9);
+  hard = max(hard, plusAt(uv, 0.5 * (cLo + cHi), 14.0 * U));
+#if KIND == 0
+  vec2 hs = 0.5 * (cHi - cLo) * vec2(ASP, 1.0);
+  vec2 q = hu(uv, 0.5 * (cLo + cHi));
+  float dm = (abs(q.x) / hs.x + abs(q.y) / hs.y - 1.0) * hs.y * 0.7;
+  float dg = min(abs(q.x - q.y), abs(q.x + q.y)) * 0.7071;
+#if DIAMOND
+  hard = max(hard, stroke(dm, 1.3 * U) * inside(uv, cLo, cHi));
+  faint = max(faint, stroke(dg, 1.0 * U) * inside(uv, cLo, cHi) * step(fract(length(q) / (9.0 * U)), 0.4));
+  faint = max(faint, stroke(length(q) - 0.5 * hs.y, 1.0 * U) * 0.8);
+#endif
+#elif KIND == 1
+  hard = max(hard, stroke(uv.y - 0.5 * (cLo.y + cHi.y), 1.3 * U) * inside(uv, cLo, cHi));
+#elif KIND == 2
+  float ph;
+  faint = max(faint, polarGrid(uv, ph));
+  hard = max(hard, ph * inside(uv, cLo, cHi));
+#elif KIND == 3
+  for (int i = 0; i < 3; i++) {
+    float f = i == 0 ? 100.0 : (i == 1 ? 1000.0 : 10000.0);
+    float v = freqScale == 1 ? (f - fMin) / (fMax - fMin) : (freqScale == 2 ? (sqrt(f) - sqrt(fMin)) / (sqrt(fMax) - sqrt(fMin)) : log(f / fMin) / log(fMax / fMin));
+    float y = cLo.y + v * (cHi.y - cLo.y);
+    faint = max(faint, stroke(uv.y - y, 1.0 * U) * inside(uv, cLo, cHi) * step(fract(hu(uv, cLo).x / (9.0 * U)), 0.5));
+  }
+#endif
+
+  vec2 clo = vec2(0.022, 0.25);
+  vec2 chi = vec2(0.175, 0.64);
+  vec2 wlo = vec2(0.022, 0.07);
+  vec2 whi = vec2(0.175, 0.16);
+  vec2 slo = vec2(0.855, 0.57);
+  vec2 shi = vec2(0.975, 0.77);
+  vec2 rlo = vec2(0.855, 0.20);
+  vec2 rhi = vec2(0.975, 0.46);
+  hard = max(hard, stroke(panelSd(uv, clo, chi, 6.0 * U), 1.3 * U));
+  hard = max(hard, cloud(uv, clo, chi));
+  faint = max(faint, gridDashed(uv, clo, chi, 4, 6) * 0.8);
+  hard = max(hard, stroke(panelSd(uv, wlo, whi, 4.0 * U), 1.3 * U));
+  hard = max(hard, waveStrip(uv, wlo, whi));
+  hard = max(hard, ticks(uv, wlo, whi, 5, 1) * 0.8);
+  hard = max(hard, stroke(panelSd(uv, slo, shi, 0.0), 1.3 * U));
+  faint = max(faint, gridDashed(uv, slo, shi, 4, 6));
+  hard = max(hard, specGraph(uv, slo, shi));
+  hard = max(hard, stroke(panelSd(uv, rlo, rhi, 6.0 * U), 1.3 * U));
+  for (int i = 0; i < 4; i++) {
+    hard = max(hard, icon(uv, vec2(0.04 + 0.04 * float(i), 0.69), i));
+    hard = max(hard, icon(uv, vec2(0.868 + 0.034 * float(i), 0.51), (i + 2) % 4));
+  }
+  float lvl = 0.0;
+  lvl = max(lvl, number(uv, vec2(0.915, 0.415), 0.03, int(clamp(AUDIO_RMS * 100.0, 0.0, 99.0)), 2));
+  lvl = max(lvl, number(uv, vec2(0.915, 0.335), 0.03, READ_B, 3));
+  lvl = max(lvl, number(uv, vec2(0.915, 0.255), 0.03, FRAMEINDEX % 10000, 4));
+  hard = max(hard, lvl);
+  hard = max(hard, plusAt(uv, vec2(0.012, 0.975), 8.0 * U));
+  hard = max(hard, plusAt(uv, vec2(0.988, 0.975), 8.0 * U));
+  hard = max(hard, plusAt(uv, vec2(0.012, 0.025), 8.0 * U));
+  hard = max(hard, plusAt(uv, vec2(0.988, 0.025), 8.0 * U));
+  fragColor = vec4(hard, faint, 0.0, 1.0);
+}

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

@@ -0,0 +1,61 @@
+{
+  "DESCRIPTION": "Thin-line spectrum graph in a framed panel: dashed grid, numbered rows, frequency labels, hairline curve, peak dots, scan cursor; black ground or a full colour field",
+  "CREDIT": "agentvfx",
+  "ISFVSN": "2",
+  "CATEGORIES": ["spectrum", "audio", "hud"],
+  "INPUTS": [
+    { "NAME": "bandCount", "TYPE": "long", "MIN": 16, "MAX": 160, "DEFAULT": 120 },
+    { "NAME": "displayMode", "TYPE": "long", "MIN": 0, "MAX": 3, "VALUES": [0, 1, 2, 3], "LABELS": ["line", "steps", "hairline-bars", "dots"], "DEFAULT": 0 },
+    { "NAME": "areaFill", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 0.35 },
+    { "NAME": "floorHeight", "TYPE": "float", "MIN": 0, "MAX": 10, "DEFAULT": 2 },
+    { "NAME": "scanCursor", "TYPE": "bool", "DEFAULT": true }
+  ],
+  "use": ["pro", "stage", "hud"],
+  "defaults": { "startFreq": 20, "endFreq": 1200, "freqCurve": 2.2, "floorLevel": 0.22, "ceilLevel": 0.7, "expLow": 2.2, "expHigh": 1.5, "releaseMs": 130 },
+  "PASSES": [
+    { "TARGET": "barState", "PERSISTENT": true, "FLOAT": true },
+    {}
+  ],
+  "X_AGENTVFX": {
+    "id": "bars-linear",
+    "family": "spectrum",
+    "input": "either",
+    "spdx": "Apache-2.0",
+    "flash": "possible",
+    "fps": 30,
+    "palette": true,
+    "presets": {
+      "graph-black": {},
+      "graph-acid": { "$field": "acid" },
+      "graph-ultramarine": { "$field": "ultramarine", "displayMode": 1 },
+      "graph-orange": { "$field": "orange", "displayMode": 2, "bandCount": 96, "areaFill": 0 },
+      "dots-phosphor": { "$field": "phosphor", "displayMode": 3, "bandCount": 64 },
+      "rainbow-glow": { "colorMode": 1, "glow": 1.4, "bandCount": 96, "lineWidth": 2.4 }
+    },
+    "audioBind": { "glow": "bass" },
+    "safeSubstitute": { "params": { "kickZoom": 0, "shake": 0 } },
+    "text": [
+      { "key": "title", "default": "SPECTRUM", "x": 0.045, "y": 0.06, "size": 0.075, "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": "tag", "default": "SIG 04 // 20-1200HZ", "x": 0.3, "y": 0.095, "size": 0.017, "font": "mono", "reveal": "type", "revealStart": 0.1, "revealDur": 1.2 },
+      { "key": "f0", "default": "20Hz", "x": 0.16, "y": 0.2, "size": 0.016, "font": "mono", "align": "center" },
+      { "key": "f1", "default": "100Hz", "x": 0.394, "y": 0.2, "size": 0.016, "font": "mono", "align": "center" },
+      { "key": "f2", "default": "250Hz", "x": 0.527, "y": 0.2, "size": 0.016, "font": "mono", "align": "center" },
+      { "key": "f3", "default": "500Hz", "x": 0.675, "y": 0.2, "size": 0.016, "font": "mono", "align": "center" },
+      { "key": "f4", "default": "1200Hz", "x": 0.94, "y": 0.2, "size": 0.016, "font": "mono", "align": "center" },
+      { "key": "r0", "default": "0", "x": 0.125, "y": 0.262, "size": 0.016, "font": "mono", "align": "right" },
+      { "key": "r1", "default": "1", "x": 0.125, "y": 0.349, "size": 0.016, "font": "mono", "align": "right" },
+      { "key": "r2", "default": "2", "x": 0.125, "y": 0.436, "size": 0.016, "font": "mono", "align": "right" },
+      { "key": "r3", "default": "3", "x": 0.125, "y": 0.522, "size": 0.016, "font": "mono", "align": "right" },
+      { "key": "r4", "default": "4", "x": 0.125, "y": 0.609, "size": 0.016, "font": "mono", "align": "right" },
+      { "key": "r5", "default": "5", "x": 0.125, "y": 0.696, "size": 0.016, "font": "mono", "align": "right" },
+      { "key": "r6", "default": "6", "x": 0.125, "y": 0.782, "size": 0.016, "font": "mono", "align": "right" },
+      { "key": "code", "default": "KX   7G2   R4   D9\n41A  TQP  118  3  ZRM  80215", "x": 0.16, "y": 0.83, "size": 0.016, "font": "mono", "reveal": "type", "revealStart": 0.4, "revealDur": 1.5 }
+    ],
+    "credits": [
+      "Thin-line analyser panel grammar (framed graph, dashed grid, numbered rows, frequency labels): style description only, no marks, fonts or text copied",
+      "Power-curve bin mapping and peak-preserving neighbour smoothing as described for open-source bar-visualiser recreations (algorithm described, no code used)",
+      "Distance estimate |y - f(x)| / sqrt(1 + f'(x)^2) for a graph, https://iquilezles.org/articles/distance/"
+    ]
+  }
+}

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

@@ -0,0 +1,112 @@
+// bars-linear main: a thin-line spectrum graph in a framed panel. Dashed row grid (rows 0..6 numbered
+// at the left, row 6 is the baseline), dashed vertical lines at the frequency labels (20Hz 100Hz 250Hz
+// 500Hz 1200Hz for the default 20..1200 Hz power-curve mapping), corner brackets, + marks, a scan
+// cursor and boxed code rows. Labels are engine text (TEXTMASK). The curve is the pro-motion bar state
+// (power-curve bins, peak-preserving smoothing, per-bar exponent, attack / release) drawn as a hairline
+// polyline (displayMode 0), steps (1), tiny hairline bars (2) or dots (3), with peak-hold dots in the
+// accent colour. A strong onset (hitFlux) flashes the frame in the accent colour for ~3 frames.
+//@include stage.glsl
+//@include hud.glsl
+
+vec4 barAt(int i) { return texelFetch(barState, ivec2(clamp(i, 0, bandCount - 1), 0), 0); }
+
+void main() {
+  vec2 res = RENDERSIZE;
+  float U = hudU();
+  vec4 clk = texelFetch(barState, ivec2(0, 1), 0);
+  vec2 sp = vUv * res;
+  vec2 px = stageUv(clk, vUv) * res;
+  vec2 lo = vec2(0.16 * res.x, 0.21 * res.y);
+  vec2 hi = vec2(0.94 * res.x, 0.73 * res.y);
+  float W = hi.x - lo.x;
+  float H = hi.y - lo.y;
+  float n = float(bandCount);
+  float pitch = W / n;
+  float span = introSpan();
+  float grow = introK();
+  float inX = step(lo.x, px.x) * step(px.x, hi.x);
+  float t = (px.x - lo.x) / W;
+  float seen = inX * step(abs(t - 0.5) * 2.0, span);
+  float ext = H * 0.94 * grow;
+  float floorPx = floorHeight * U;
+  float w = hudW();
+
+  float fi = t * n - 0.5;
+  int i0 = int(floor(fi));
+  float fr = fi - floor(fi);
+  vec4 b0 = barAt(i0);
+  vec4 b1 = barAt(i0 + 1);
+  float hs = mix(b0.r, b1.r, fr);
+  float yv = lo.y + hs * ext + floorPx;
+  float slope = (b1.r - b0.r) * ext * n / W;
+  float u = clamp(t, 0.0, 1.0);
+
+  float curve = 0.0;
+  float dist = 1.0e4;
+  if (displayMode == 0) {
+    dist = abs(px.y - yv) / sqrt(1.0 + slope * slope);
+    curve = hair(dist);
+  } else if (displayMode == 1) {
+    int b = int(clamp(floor(t * n), 0.0, n - 1.0));
+    float yb = lo.y + barAt(b).r * ext + floorPx;
+    float yp = lo.y + barAt(b - 1).r * ext + floorPx;
+    float xl = px.x - (lo.x + float(b) * pitch);
+    dist = abs(px.y - yb);
+    curve = max(hair(dist), hair(xl) * step(min(yb, yp) - w, px.y) * step(px.y, max(yb, yp) + w));
+  } else if (displayMode == 2) {
+    float bc = (floor(t * n) + 0.5) * pitch + lo.x;
+    int b = int(clamp(floor(t * n), 0.0, n - 1.0));
+    float yb = lo.y + barAt(b).r * ext + floorPx;
+    dist = max(abs(px.x - bc) * 1.0, max(px.y - yb, lo.y - px.y));
+    curve = hair(px.x - bc) * step(px.y, yb) * step(lo.y, px.y);
+  } else {
+    float bc = (floor(t * n) + 0.5) * pitch + lo.x;
+    int b = int(clamp(floor(t * n), 0.0, n - 1.0));
+    float yb = lo.y + barAt(b).r * ext + floorPx;
+    dist = length(vec2(px.x - bc, px.y - yb));
+    curve = cov(dist - 2.0 * U);
+  }
+  curve *= seen * step(lo.y - 1.0, px.y);
+
+  int bc = int(clamp(floor(t * n), 0.0, n - 1.0));
+  float capY = lo.y + barAt(bc).g * ext + floorPx;
+  float capX = lo.x + (float(bc) + 0.5) * pitch;
+  float capDot = cov(length(vec2(px.x - capX, px.y - capY)) - 1.7 * U) * seen * step(0.012, barAt(bc).g);
+
+  float area = displayMode == 0 ? areaFill * 0.5 * step(px.y, yv) * step(lo.y, px.y) * step(0.5, fract(px.x / (4.0 * U))) * step(0.5, fract(px.y / (4.0 * U))) * seen : 0.0;
+
+  float rows = 0.0;
+  float ticks = 0.0;
+  for (int r = 0; r <= 6; r++) {
+    float yr = hi.y - float(r) * H / 6.0;
+    float onRow = hair(sp.y - yr);
+    rows = max(rows, onRow * inRect(sp, lo, hi) * dashes(sp.x, 7.0, 0.3));
+    ticks = max(ticks, onRow * step(lo.x - 16.0 * U, sp.x) * step(sp.x, lo.x - 6.0 * U));
+  }
+  float cols = 0.0;
+  for (int k = 0; k < 5; k++) {
+    float tk = k == 0 ? 0.0 : (k == 1 ? 0.30 : (k == 2 ? 0.47 : (k == 3 ? 0.66 : 1.0)));
+    float xk = lo.x + tk * W;
+    cols = max(cols, hair(sp.x - xk) * inRect(sp, lo, hi) * dashes(sp.y, 7.0, 0.3));
+  }
+
+  float hit = step(0.5, hitEnv(clk, 0.1)) * step(0.5, clk.x);
+  float frame = boxLine(sp, lo, hi);
+  float brk = brackets(sp, lo - 9.0 * U, hi + 9.0 * U, 22.0 * U);
+  float cursor = scanCursor ? hair(px.x - (lo.x + fract(TIME * 0.5) * W)) * inRect(px, lo, hi) * 0.55 * seen : 0.0;
+  float glowTerm = glow > 0.0 ? exp(-dist / max(glowRadius * res.y, 1.0)) * glow * seen : 0.0;
+
+  vec3 ink = inkColor.rgb;
+  vec3 acc = accentAt(u);
+  vec3 col = stageBackground(vUv, ink, kickEnv(clk));
+  col = mix(col, ink, max(rows, cols) * 0.5 * span * gridAmount);
+  col = mix(col, ink, max(ticks, cursor) * span * gridAmount);
+  col = mix(col, ink, area * 0.8);
+  col += acc * glowTerm * 0.4;
+  col = mix(col, ink, curve);
+  col = mix(col, acc, capDot);
+  col = mix(col, mix(ink, acc, hit), max(frame, brk) * gridAmount);
+  if (marks) { col = mix(col, ink, hudChrome(sp)); }
+  col = mix(col, ink, textInk());
+  fragColor = vec4(stageFinish(col, vUv), 1.0);
+}

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

@@ -0,0 +1,2 @@
+// bars-linear pass 0: pro-motion bar state (see the shared block below), persistent in barState.
+//@include bars-pass.glsl

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

@@ -0,0 +1,51 @@
+{
+  "DESCRIPTION": "Full-frame field instrument: four-way mirrored hairline spectrum bars in black or white ink on an acid, ultramarine or orange field; hard colour swap on strong onsets",
+  "CREDIT": "agentvfx",
+  "ISFVSN": "2",
+  "CATEGORIES": ["spectrum", "audio", "hud"],
+  "INPUTS": [
+    { "NAME": "bandCount", "TYPE": "long", "MIN": 8, "MAX": 120, "DEFAULT": 84 },
+    { "NAME": "maxHeight", "TYPE": "float", "MIN": 0.05, "MAX": 1, "DEFAULT": 1 },
+    { "NAME": "thickness", "TYPE": "float", "MIN": 0.05, "MAX": 1, "DEFAULT": 0.3 },
+    { "NAME": "mirrorMode", "TYPE": "long", "MIN": 0, "MAX": 2, "VALUES": [0, 1, 2], "LABELS": ["four-way", "top-bottom", "left-right"], "DEFAULT": 0 },
+    { "NAME": "centreGap", "TYPE": "float", "MIN": 0, "MAX": 0.1, "DEFAULT": 0.01 },
+    { "NAME": "floorHeight", "TYPE": "float", "MIN": 0, "MAX": 10, "DEFAULT": 2 },
+    { "NAME": "tipDots", "TYPE": "bool", "DEFAULT": true },
+    { "NAME": "invertHit", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 1 },
+    { "NAME": "flashDecayMs", "TYPE": "float", "MIN": 30, "MAX": 600, "DEFAULT": 110 }
+  ],
+  "use": ["pro", "stage", "hud"],
+  "defaults": { "groundColor": [0.784, 1, 0, 1], "inkColor": [0.04, 0.04, 0.04, 1], "accentColor": [0.04, 0.04, 0.04, 1], "startFreq": 20, "endFreq": 12000, "freqCurve": 2.4, "floorLevel": 0.2, "ceilLevel": 0.64 },
+  "PASSES": [
+    { "TARGET": "barState", "PERSISTENT": true, "FLOAT": true },
+    {}
+  ],
+  "X_AGENTVFX": {
+    "id": "bars-mirror",
+    "family": "spectrum",
+    "input": "either",
+    "spdx": "Apache-2.0",
+    "flash": "strobe",
+    "fps": 30,
+    "palette": true,
+    "presets": {
+      "field-acid": {},
+      "field-ultramarine": { "$field": "ultramarine", "thickness": 0.45 },
+      "field-orange": { "$field": "orange", "mirrorMode": 1, "bandCount": 100 },
+      "black-hairline": { "groundColor": [0.043, 0.043, 0.047, 1], "inkColor": [0.914, 0.914, 0.894, 1], "accentColor": [0.784, 1, 0, 1], "invertHit": 0, "mirrorMode": 2 },
+      "rainbow-glow": { "groundColor": [0.02, 0.02, 0.03, 1], "inkColor": [1, 1, 1, 1], "colorMode": 1, "glow": 1, "invertHit": 0, "thickness": 0.6 }
+    },
+    "audioBind": { "invertHit": "onset" },
+    "safeSubstitute": { "params": { "invertHit": 0, "kickZoom": 0, "shake": 0 } },
+    "text": [
+      { "key": "title", "default": "FIELD 04", "x": 0.06, "y": 0.09, "size": 0.07, "font": "display", "style": "outline", "box": "tab" },
+      { "key": "node", "default": "SIGNAL", "x": 0.94, "y": 0.075, "size": 0.09, "font": "tall", "align": "right" },
+      { "key": "log", "default": "AGENT//VFX  NODE 7G-75\nCACHE OK  0x04F2", "x": 0.06, "y": 0.84, "size": 0.017, "font": "mono", "reveal": "type", "revealStart": 0.2, "revealDur": 1.4 },
+      { "key": "num", "default": "0   1   2   3   4   5   6", "x": 0.94, "y": 0.865, "size": 0.017, "font": "mono", "align": "right" }
+    ],
+    "credits": [
+      "Hairline analyser instrument and full-colour field grammar: original drawing, no marks, fonts or text from other works",
+      "Power-curve bin mapping and peak-preserving neighbour smoothing as described for open-source bar-visualiser recreations (algorithm described, no code used)"
+    ]
+  }
+}