agentvfx 0.0.0-stage → 0.3.4

package/skills/agentvfx/templates/glitch/pixel-sort/pass5.frag

@@ -0,0 +1,66 @@
+// pixel-sort (pass5 run5: run lengths to the left (r) and right (g), capped at 32). Idea: pixel sorting as in ASDFPixelSort by Kim Asendorf (concept only; code written fresh).
+// Spans of cells whose luma lies in a threshold window are sorted along an axis. Span extents come from
+// log2 run-length doubling (pass1..pass8); the sort itself ranks 32 strided samples of the span in the
+// last pass (exact when a span has <= 32 cells, a quantile approximation above that).
+uint pcg(uint v) {
+  uint s = v * 747796405u + 2891336453u;
+  uint w = ((s >> ((s >> 28u) + 4u)) ^ s) * 277803737u;
+  return (w >> 22u) ^ w;
+}
+float h1(uint a) { return float(pcg(a)) / 4294967295.0; }
+float h2(uint a, uint b) { return h1(a * 2654435761u + pcg(b + 1013904223u)); }
+
+// SEED is the score seed / 2^32, so small integer seeds are tiny floats; recover the integer.
+uint seedU() { return uint(min(SEED * 4294967296.0 + 0.5, 4294967040.0)); }
+
+// The sort works on cells of cellPx x cellPx pixels (1 cell = 1 "pixel" of the sort).
+// Reading order: left to right for the horizontal axis, top to bottom for the vertical one.
+float cellPx() { return max(1.0, floor(cellSize * RENDERSIZE.y / 1080.0 + 0.5)); }
+vec2 axisDir() { return sortAxis == 0 ? vec2(1.0, 0.0) : vec2(0.0, -1.0); }
+vec2 cellDims() { return ceil(RENDERSIZE / cellPx()); }
+bool inCells(vec2 c) { vec2 d = cellDims(); return c.x >= 0.0 && c.y >= 0.0 && c.x < d.x && c.y < d.y; }
+ivec2 cellTexel(vec2 c) { return ivec2(min(c * cellPx(), RENDERSIZE - 1.0)); }
+float acrossOf(vec2 c) { return sortAxis == 0 ? c.y : c.x; }
+float alongOf(vec2 c) { return sortAxis == 0 ? c.x : cellDims().y - 1.0 - c.y; }
+
+// Span mask: a cell takes part when its row is gated in and its perceptual luma lies in [lo, hi].
+bool maskOf(vec2 c) {
+  if (!inCells(c)) return false;
+  uint across = uint(acrossOf(c));
+  uint st = uint(floor(TIME * stutterHz));
+  uint sd = seedU();
+  float kick = clamp(audioKick, 0.0, 2.0);
+  if (h2(across + 7u, st * 977u + sd) > clamp(rowsFrac + 0.4 * kick, 0.0, 1.0)) return false;
+  float sw = sweep * sin(6.2832 * (TIME * sweepRate + h1(sd + 17u)));
+  float lo = threshLo + sw - 0.25 * kick + (h2(across, st + sd + 3u) - 0.5) * rowVar;
+  float hi = threshHi + sw + 0.2 * kick + (h2(across, st + sd + 5u) - 0.5) * rowVar;
+  float l = linearToSrgb(vec3(luma(texelFetch(keyBuf, cellTexel(c), 0).rgb))).r;
+  return l >= lo && l <= hi;
+}
+// Spans are cut at multiples of 256 cells; the cut grid is shifted per row so cuts do not line up.
+float cutShift(vec2 c) { return floor(h2(uint(acrossOf(c)), seedU() + 99u) * 256.0) * cutJitter; }
+
+void main() {
+  float cp = cellPx();
+  vec2 c = floor(vUv * RENDERSIZE / cp);
+  if (!maskOf(c)) { fragColor = vec4(0.0); return; }
+  vec2 dv = axisDir();
+  float posIn = mod(alongOf(c) + cutShift(c), 256.0);
+  float capL = posIn + 1.0;
+  float capR = 256.0 - posIn;
+  float kk = 16.0;
+  vec2 own = texelFetch(run4, cellTexel(c), 0).rg;
+  float L = own.x;
+  float R = own.y;
+  if (L >= kk) {
+    vec2 cn = c - dv * kk;
+    float ln = inCells(cn) ? texelFetch(run4, cellTexel(cn), 0).r : 0.0;
+    L = min(min(2.0 * kk, kk + ln), capL);
+  }
+  if (R >= kk) {
+    vec2 cn = c + dv * kk;
+    float rn = inCells(cn) ? texelFetch(run4, cellTexel(cn), 0).g : 0.0;
+    R = min(min(2.0 * kk, kk + rn), capR);
+  }
+  fragColor = vec4(L, R, 0.0, 1.0);
+}

package/skills/agentvfx/templates/glitch/pixel-sort/pass6.frag

@@ -0,0 +1,66 @@
+// pixel-sort (pass6 run6: run lengths to the left (r) and right (g), capped at 64). Idea: pixel sorting as in ASDFPixelSort by Kim Asendorf (concept only; code written fresh).
+// Spans of cells whose luma lies in a threshold window are sorted along an axis. Span extents come from
+// log2 run-length doubling (pass1..pass8); the sort itself ranks 32 strided samples of the span in the
+// last pass (exact when a span has <= 32 cells, a quantile approximation above that).
+uint pcg(uint v) {
+  uint s = v * 747796405u + 2891336453u;
+  uint w = ((s >> ((s >> 28u) + 4u)) ^ s) * 277803737u;
+  return (w >> 22u) ^ w;
+}
+float h1(uint a) { return float(pcg(a)) / 4294967295.0; }
+float h2(uint a, uint b) { return h1(a * 2654435761u + pcg(b + 1013904223u)); }
+
+// SEED is the score seed / 2^32, so small integer seeds are tiny floats; recover the integer.
+uint seedU() { return uint(min(SEED * 4294967296.0 + 0.5, 4294967040.0)); }
+
+// The sort works on cells of cellPx x cellPx pixels (1 cell = 1 "pixel" of the sort).
+// Reading order: left to right for the horizontal axis, top to bottom for the vertical one.
+float cellPx() { return max(1.0, floor(cellSize * RENDERSIZE.y / 1080.0 + 0.5)); }
+vec2 axisDir() { return sortAxis == 0 ? vec2(1.0, 0.0) : vec2(0.0, -1.0); }
+vec2 cellDims() { return ceil(RENDERSIZE / cellPx()); }
+bool inCells(vec2 c) { vec2 d = cellDims(); return c.x >= 0.0 && c.y >= 0.0 && c.x < d.x && c.y < d.y; }
+ivec2 cellTexel(vec2 c) { return ivec2(min(c * cellPx(), RENDERSIZE - 1.0)); }
+float acrossOf(vec2 c) { return sortAxis == 0 ? c.y : c.x; }
+float alongOf(vec2 c) { return sortAxis == 0 ? c.x : cellDims().y - 1.0 - c.y; }
+
+// Span mask: a cell takes part when its row is gated in and its perceptual luma lies in [lo, hi].
+bool maskOf(vec2 c) {
+  if (!inCells(c)) return false;
+  uint across = uint(acrossOf(c));
+  uint st = uint(floor(TIME * stutterHz));
+  uint sd = seedU();
+  float kick = clamp(audioKick, 0.0, 2.0);
+  if (h2(across + 7u, st * 977u + sd) > clamp(rowsFrac + 0.4 * kick, 0.0, 1.0)) return false;
+  float sw = sweep * sin(6.2832 * (TIME * sweepRate + h1(sd + 17u)));
+  float lo = threshLo + sw - 0.25 * kick + (h2(across, st + sd + 3u) - 0.5) * rowVar;
+  float hi = threshHi + sw + 0.2 * kick + (h2(across, st + sd + 5u) - 0.5) * rowVar;
+  float l = linearToSrgb(vec3(luma(texelFetch(keyBuf, cellTexel(c), 0).rgb))).r;
+  return l >= lo && l <= hi;
+}
+// Spans are cut at multiples of 256 cells; the cut grid is shifted per row so cuts do not line up.
+float cutShift(vec2 c) { return floor(h2(uint(acrossOf(c)), seedU() + 99u) * 256.0) * cutJitter; }
+
+void main() {
+  float cp = cellPx();
+  vec2 c = floor(vUv * RENDERSIZE / cp);
+  if (!maskOf(c)) { fragColor = vec4(0.0); return; }
+  vec2 dv = axisDir();
+  float posIn = mod(alongOf(c) + cutShift(c), 256.0);
+  float capL = posIn + 1.0;
+  float capR = 256.0 - posIn;
+  float kk = 32.0;
+  vec2 own = texelFetch(run5, cellTexel(c), 0).rg;
+  float L = own.x;
+  float R = own.y;
+  if (L >= kk) {
+    vec2 cn = c - dv * kk;
+    float ln = inCells(cn) ? texelFetch(run5, cellTexel(cn), 0).r : 0.0;
+    L = min(min(2.0 * kk, kk + ln), capL);
+  }
+  if (R >= kk) {
+    vec2 cn = c + dv * kk;
+    float rn = inCells(cn) ? texelFetch(run5, cellTexel(cn), 0).g : 0.0;
+    R = min(min(2.0 * kk, kk + rn), capR);
+  }
+  fragColor = vec4(L, R, 0.0, 1.0);
+}

package/skills/agentvfx/templates/glitch/pixel-sort/pass7.frag

@@ -0,0 +1,66 @@
+// pixel-sort (pass7 run7: run lengths to the left (r) and right (g), capped at 128). Idea: pixel sorting as in ASDFPixelSort by Kim Asendorf (concept only; code written fresh).
+// Spans of cells whose luma lies in a threshold window are sorted along an axis. Span extents come from
+// log2 run-length doubling (pass1..pass8); the sort itself ranks 32 strided samples of the span in the
+// last pass (exact when a span has <= 32 cells, a quantile approximation above that).
+uint pcg(uint v) {
+  uint s = v * 747796405u + 2891336453u;
+  uint w = ((s >> ((s >> 28u) + 4u)) ^ s) * 277803737u;
+  return (w >> 22u) ^ w;
+}
+float h1(uint a) { return float(pcg(a)) / 4294967295.0; }
+float h2(uint a, uint b) { return h1(a * 2654435761u + pcg(b + 1013904223u)); }
+
+// SEED is the score seed / 2^32, so small integer seeds are tiny floats; recover the integer.
+uint seedU() { return uint(min(SEED * 4294967296.0 + 0.5, 4294967040.0)); }
+
+// The sort works on cells of cellPx x cellPx pixels (1 cell = 1 "pixel" of the sort).
+// Reading order: left to right for the horizontal axis, top to bottom for the vertical one.
+float cellPx() { return max(1.0, floor(cellSize * RENDERSIZE.y / 1080.0 + 0.5)); }
+vec2 axisDir() { return sortAxis == 0 ? vec2(1.0, 0.0) : vec2(0.0, -1.0); }
+vec2 cellDims() { return ceil(RENDERSIZE / cellPx()); }
+bool inCells(vec2 c) { vec2 d = cellDims(); return c.x >= 0.0 && c.y >= 0.0 && c.x < d.x && c.y < d.y; }
+ivec2 cellTexel(vec2 c) { return ivec2(min(c * cellPx(), RENDERSIZE - 1.0)); }
+float acrossOf(vec2 c) { return sortAxis == 0 ? c.y : c.x; }
+float alongOf(vec2 c) { return sortAxis == 0 ? c.x : cellDims().y - 1.0 - c.y; }
+
+// Span mask: a cell takes part when its row is gated in and its perceptual luma lies in [lo, hi].
+bool maskOf(vec2 c) {
+  if (!inCells(c)) return false;
+  uint across = uint(acrossOf(c));
+  uint st = uint(floor(TIME * stutterHz));
+  uint sd = seedU();
+  float kick = clamp(audioKick, 0.0, 2.0);
+  if (h2(across + 7u, st * 977u + sd) > clamp(rowsFrac + 0.4 * kick, 0.0, 1.0)) return false;
+  float sw = sweep * sin(6.2832 * (TIME * sweepRate + h1(sd + 17u)));
+  float lo = threshLo + sw - 0.25 * kick + (h2(across, st + sd + 3u) - 0.5) * rowVar;
+  float hi = threshHi + sw + 0.2 * kick + (h2(across, st + sd + 5u) - 0.5) * rowVar;
+  float l = linearToSrgb(vec3(luma(texelFetch(keyBuf, cellTexel(c), 0).rgb))).r;
+  return l >= lo && l <= hi;
+}
+// Spans are cut at multiples of 256 cells; the cut grid is shifted per row so cuts do not line up.
+float cutShift(vec2 c) { return floor(h2(uint(acrossOf(c)), seedU() + 99u) * 256.0) * cutJitter; }
+
+void main() {
+  float cp = cellPx();
+  vec2 c = floor(vUv * RENDERSIZE / cp);
+  if (!maskOf(c)) { fragColor = vec4(0.0); return; }
+  vec2 dv = axisDir();
+  float posIn = mod(alongOf(c) + cutShift(c), 256.0);
+  float capL = posIn + 1.0;
+  float capR = 256.0 - posIn;
+  float kk = 64.0;
+  vec2 own = texelFetch(run6, cellTexel(c), 0).rg;
+  float L = own.x;
+  float R = own.y;
+  if (L >= kk) {
+    vec2 cn = c - dv * kk;
+    float ln = inCells(cn) ? texelFetch(run6, cellTexel(cn), 0).r : 0.0;
+    L = min(min(2.0 * kk, kk + ln), capL);
+  }
+  if (R >= kk) {
+    vec2 cn = c + dv * kk;
+    float rn = inCells(cn) ? texelFetch(run6, cellTexel(cn), 0).g : 0.0;
+    R = min(min(2.0 * kk, kk + rn), capR);
+  }
+  fragColor = vec4(L, R, 0.0, 1.0);
+}

package/skills/agentvfx/templates/glitch/pixel-sort/pass8.frag

@@ -0,0 +1,66 @@
+// pixel-sort (pass8 run8: run lengths to the left (r) and right (g), capped at 256). Idea: pixel sorting as in ASDFPixelSort by Kim Asendorf (concept only; code written fresh).
+// Spans of cells whose luma lies in a threshold window are sorted along an axis. Span extents come from
+// log2 run-length doubling (pass1..pass8); the sort itself ranks 32 strided samples of the span in the
+// last pass (exact when a span has <= 32 cells, a quantile approximation above that).
+uint pcg(uint v) {
+  uint s = v * 747796405u + 2891336453u;
+  uint w = ((s >> ((s >> 28u) + 4u)) ^ s) * 277803737u;
+  return (w >> 22u) ^ w;
+}
+float h1(uint a) { return float(pcg(a)) / 4294967295.0; }
+float h2(uint a, uint b) { return h1(a * 2654435761u + pcg(b + 1013904223u)); }
+
+// SEED is the score seed / 2^32, so small integer seeds are tiny floats; recover the integer.
+uint seedU() { return uint(min(SEED * 4294967296.0 + 0.5, 4294967040.0)); }
+
+// The sort works on cells of cellPx x cellPx pixels (1 cell = 1 "pixel" of the sort).
+// Reading order: left to right for the horizontal axis, top to bottom for the vertical one.
+float cellPx() { return max(1.0, floor(cellSize * RENDERSIZE.y / 1080.0 + 0.5)); }
+vec2 axisDir() { return sortAxis == 0 ? vec2(1.0, 0.0) : vec2(0.0, -1.0); }
+vec2 cellDims() { return ceil(RENDERSIZE / cellPx()); }
+bool inCells(vec2 c) { vec2 d = cellDims(); return c.x >= 0.0 && c.y >= 0.0 && c.x < d.x && c.y < d.y; }
+ivec2 cellTexel(vec2 c) { return ivec2(min(c * cellPx(), RENDERSIZE - 1.0)); }
+float acrossOf(vec2 c) { return sortAxis == 0 ? c.y : c.x; }
+float alongOf(vec2 c) { return sortAxis == 0 ? c.x : cellDims().y - 1.0 - c.y; }
+
+// Span mask: a cell takes part when its row is gated in and its perceptual luma lies in [lo, hi].
+bool maskOf(vec2 c) {
+  if (!inCells(c)) return false;
+  uint across = uint(acrossOf(c));
+  uint st = uint(floor(TIME * stutterHz));
+  uint sd = seedU();
+  float kick = clamp(audioKick, 0.0, 2.0);
+  if (h2(across + 7u, st * 977u + sd) > clamp(rowsFrac + 0.4 * kick, 0.0, 1.0)) return false;
+  float sw = sweep * sin(6.2832 * (TIME * sweepRate + h1(sd + 17u)));
+  float lo = threshLo + sw - 0.25 * kick + (h2(across, st + sd + 3u) - 0.5) * rowVar;
+  float hi = threshHi + sw + 0.2 * kick + (h2(across, st + sd + 5u) - 0.5) * rowVar;
+  float l = linearToSrgb(vec3(luma(texelFetch(keyBuf, cellTexel(c), 0).rgb))).r;
+  return l >= lo && l <= hi;
+}
+// Spans are cut at multiples of 256 cells; the cut grid is shifted per row so cuts do not line up.
+float cutShift(vec2 c) { return floor(h2(uint(acrossOf(c)), seedU() + 99u) * 256.0) * cutJitter; }
+
+void main() {
+  float cp = cellPx();
+  vec2 c = floor(vUv * RENDERSIZE / cp);
+  if (!maskOf(c)) { fragColor = vec4(0.0); return; }
+  vec2 dv = axisDir();
+  float posIn = mod(alongOf(c) + cutShift(c), 256.0);
+  float capL = posIn + 1.0;
+  float capR = 256.0 - posIn;
+  float kk = 128.0;
+  vec2 own = texelFetch(run7, cellTexel(c), 0).rg;
+  float L = own.x;
+  float R = own.y;
+  if (L >= kk) {
+    vec2 cn = c - dv * kk;
+    float ln = inCells(cn) ? texelFetch(run7, cellTexel(cn), 0).r : 0.0;
+    L = min(min(2.0 * kk, kk + ln), capL);
+  }
+  if (R >= kk) {
+    vec2 cn = c + dv * kk;
+    float rn = inCells(cn) ? texelFetch(run7, cellTexel(cn), 0).g : 0.0;
+    R = min(min(2.0 * kk, kk + rn), capR);
+  }
+  fragColor = vec4(L, R, 0.0, 1.0);
+}

package/skills/agentvfx/templates/glitch/rgb-split/demo-diagonal-stutter.json

@@ -0,0 +1 @@
+{"version":1,"template":"rgb-split","preset":"rgb-split-diagonal-stutter","input":{"video":"test-media/clip-01.mp4"},"durationSec":4,"seed":23,"out":"rgb-split-diagonal-stutter"}

package/skills/agentvfx/templates/glitch/rgb-split/demo-hard.json

@@ -0,0 +1 @@
+{"version":1,"template":"rgb-split","preset":"rgb-split-hard","input":{"video":"test-media/clip-01.mp4"},"durationSec":4,"seed":21,"out":"rgb-split-hard"}

package/skills/agentvfx/templates/glitch/rgb-split/demo-kick.json

@@ -0,0 +1 @@
+{"version":1,"template":"rgb-split","preset":"rgb-split-kick","input":{"video":"test-media/clip-01.mp4","audio":"test-media/beat-132.mp3"},"bindings":[{"param":"audioKick","feature":"onset","gain":1.4,"offset":0,"attackMs":0,"releaseMs":240}],"durationSec":4,"seed":24,"out":"rgb-split-kick"}

package/skills/agentvfx/templates/glitch/rgb-split/demo-radial.json

@@ -0,0 +1 @@
+{"version":1,"template":"rgb-split","preset":"rgb-split-radial","input":{"video":"test-media/clip-02.mp4"},"durationSec":4,"seed":22,"out":"rgb-split-radial"}

package/skills/agentvfx/templates/glitch/rgb-split/fx.json

@@ -0,0 +1,46 @@
+{
+  "DESCRIPTION": "Spectral RGB split with seeded bursts, direction jitter and sideways row tears over footage",
+  "CREDIT": "agentvfx",
+  "ISFVSN": "2",
+  "CATEGORIES": ["glitch"],
+  "INPUTS": [
+    { "NAME": "splitAmount", "TYPE": "float", "MIN": 0, "MAX": 200, "DEFAULT": 22 },
+    { "NAME": "splitMode", "TYPE": "long", "MIN": 0, "MAX": 1, "VALUES": [0, 1], "LABELS": ["axis", "radial"], "DEFAULT": 0 },
+    { "NAME": "splitAngle", "TYPE": "float", "MIN": -3.1416, "MAX": 3.1416, "DEFAULT": 0 },
+    { "NAME": "center", "TYPE": "point2D", "DEFAULT": [0.5, 0.5] },
+    { "NAME": "splitTaps", "TYPE": "long", "MIN": 3, "MAX": 12, "DEFAULT": 9 },
+    { "NAME": "jitter", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 0.8 },
+    { "NAME": "jitterRate", "TYPE": "float", "MIN": 1, "MAX": 60, "DEFAULT": 18 },
+    { "NAME": "burstRate", "TYPE": "float", "MIN": 0.25, "MAX": 12, "DEFAULT": 2.4 },
+    { "NAME": "burstProb", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 0.85 },
+    { "NAME": "burstFrames", "TYPE": "long", "MIN": 1, "MAX": 60, "DEFAULT": 7 },
+    { "NAME": "burstBoost", "TYPE": "float", "MIN": 0, "MAX": 8, "DEFAULT": 3.5 },
+    { "NAME": "tear", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 0.8 },
+    { "NAME": "audioKick", "TYPE": "float", "MIN": 0, "MAX": 2, "DEFAULT": 0 },
+    { "NAME": "saturation", "TYPE": "float", "MIN": 0, "MAX": 3, "DEFAULT": 1.35 },
+    { "NAME": "punch", "TYPE": "float", "MIN": 0.5, "MAX": 3, "DEFAULT": 1.25 },
+    { "NAME": "scanlines", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 0.3 },
+    { "NAME": "grain", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 0.12 }
+  ],
+  "X_AGENTVFX": {
+    "id": "rgb-split",
+    "family": "glitch",
+    "input": "footage",
+    "spdx": "LicenseRef-agentvfx",
+    "flash": "possible",
+    "fps": 30,
+    "palette": false,
+    "presets": {
+      "rgb-split-hard": {},
+      "rgb-split-radial": { "splitMode": 1, "splitAmount": 30, "burstBoost": 4, "tear": 0.3, "jitter": 0.4, "burstRate": 2 },
+      "rgb-split-diagonal-stutter": { "splitAngle": 0.7854, "splitAmount": 34, "jitterRate": 30, "burstRate": 4, "burstFrames": 5, "burstBoost": 4.5, "tear": 1, "splitTaps": 5 },
+      "rgb-split-kick": { "splitAmount": 8, "burstProb": 0, "burstBoost": 6, "tear": 1, "audioKick": 0, "jitter": 1 }
+    },
+    "audioBind": { "audioKick": "onset" },
+    "safeSubstitute": { "params": { "burstRate": 0.5, "burstBoost": 0.6, "tear": 0, "jitter": 0.2, "grain": 0.05 } },
+    "credits": [
+      "Chromatic aberration as spectral tap accumulation, https://en.wikipedia.org/wiki/Chromatic_aberration",
+      "PCG integer hash, M. E. O'Neill, https://www.pcg-random.org/"
+    ]
+  }
+}

package/skills/agentvfx/templates/glitch/rgb-split/main.frag

@@ -0,0 +1,76 @@
+// rgb-split: spectral channel split with burst gating, direction jitter and horizontal band tears.
+// Idea: chromatic aberration as a smear of spectral taps along an offset path (taps = 3 is the classic
+// three-copy split; more taps blend the copies into a rainbow smear). Written fresh for agentvfx.
+// Bursts: every 1/burstRate seconds a burst may fire (seeded by SEED); during `burstFrames` frames the
+// offset is multiplied by burstBoost, the direction jumps around and rows tear sideways.
+uint pcg(uint v) {
+  uint s = v * 747796405u + 2891336453u;
+  uint w = ((s >> ((s >> 28u) + 4u)) ^ s) * 277803737u;
+  return (w >> 22u) ^ w;
+}
+float h1(uint a) { return float(pcg(a)) / 4294967295.0; }
+float h2(uint a, uint b) { return h1(a * 2654435761u + pcg(b + 1013904223u)); }
+// SEED is the score seed / 2^32, so small integer seeds are tiny floats; recover the integer.
+uint seedU() { return uint(min(SEED * 4294967296.0 + 0.5, 4294967040.0)); }
+
+void main() {
+  float u = RENDERSIZE.y / 1080.0;
+  float fps = 1.0 / TIMEDELTA;
+  uint sd = seedU();
+  vec2 px = vUv * RENDERSIZE;
+
+  // burst gate
+  float ph = TIME * burstRate;
+  uint bi = uint(floor(ph));
+  float age = fract(ph) / max(burstRate, 0.001) * fps;
+  float env = (h2(bi, sd) < burstProb && age < float(burstFrames)) ? 1.0 : 0.0;
+  float k = clamp(env + audioKick, 0.0, 1.6);
+
+  // jitter step: the offset direction and size re-roll jitterRate times per second
+  uint js = uint(floor(TIME * jitterRate));
+  float jr = h2(js, sd + 11u);
+  float jd = h2(js, sd + 29u);
+  float amt = splitAmount * u * (1.0 + burstBoost * k) * (1.0 + jitter * (jr * 2.0 - 1.0) * 0.6);
+
+  // sample position with optional band tear
+  vec2 pos = px;
+  if (tear > 0.0 && k > 0.0) {
+    float bandH = max(2.0, (10.0 + 90.0 * h2(js, sd + 3u))) * u;
+    uint band = uint(floor(px.y / bandH));
+    float on = step(h2(band, js * 31u + sd), 0.35 * min(k, 1.0));
+    pos.x += on * (h2(band, js + sd + 77u) * 2.0 - 1.0) * tear * 0.12 * RENDERSIZE.x * min(k, 1.0);
+  }
+
+  // direction of the split
+  vec2 dir;
+  float aspect = RENDERSIZE.x / RENDERSIZE.y;
+  if (splitMode == 1) {
+    vec2 p = (vUv - center) * vec2(aspect, 1.0);
+    float r = length(p);
+    dir = p / max(r, 1e-4) * (0.35 + 1.4 * r);
+  } else {
+    float ang = splitAngle + (jd - 0.5) * jitter * (3.1416 * 1.2 * k + 0.5);
+    dir = vec2(cos(ang), sin(ang));
+  }
+
+  vec3 acc = vec3(0.0);
+  vec3 ws = vec3(0.0);
+  for (int i = 0; i < 12; i++) {
+    if (i >= splitTaps) break;
+    float t = splitTaps > 1 ? float(i) / float(splitTaps - 1) : 0.5;
+    vec3 w = vec3(max(0.0, 1.0 - 2.0 * t), 1.0 - abs(2.0 * t - 1.0), max(0.0, 2.0 * t - 1.0));
+    vec2 q = pos + dir * amt * (t - 0.5) * 2.0;
+    acc += w * texture(inputImage, q / RENDERSIZE).rgb;
+    ws += w;
+  }
+  vec3 col = acc / max(ws, vec3(1e-4));
+
+  // punch: saturation + contrast, scanlines, grain
+  float lm = luma(col);
+  col = mix(vec3(lm), col, saturation);
+  col = max((col - 0.18) * punch + 0.18, 0.0);
+  col *= 1.0 - scanlines * (0.5 + 0.5 * sin(px.y * 3.14159 / max(u, 0.25)));
+  float g = h2(uint(px.x) + uint(px.y) * 4099u, uint(FRAMEINDEX) + sd);
+  col += grain * (g - 0.5) * (0.4 + 0.6 * k);
+  fragColor = vec4(max(col, 0.0), 1.0);
+}

package/skills/agentvfx/templates/glitch/vhs/demo-clean.json

@@ -0,0 +1 @@
+{"version":1,"template":"vhs","preset":"vhs-clean","input":{"video":"test-media/clip-01.mp4"},"durationSec":4,"seed":44,"out":"vhs-clean"}

package/skills/agentvfx/templates/glitch/vhs/demo-crash.json

@@ -0,0 +1 @@
+{"version":1,"template":"vhs","preset":"vhs-crash","input":{"video":"test-media/clip-01.mp4"},"durationSec":4,"seed":43,"out":"vhs-crash"}

package/skills/agentvfx/templates/glitch/vhs/demo-tape.json

@@ -0,0 +1 @@
+{"version":1,"template":"vhs","preset":"vhs-tape","input":{"video":"test-media/clip-01.mp4"},"durationSec":4,"seed":41,"out":"vhs-tape"}

package/skills/agentvfx/templates/glitch/vhs/demo-worn.json

@@ -0,0 +1 @@
+{"version":1,"template":"vhs","preset":"vhs-worn","input":{"video":"test-media/clip-02.mp4"},"durationSec":4,"seed":42,"out":"vhs-worn"}

package/skills/agentvfx/templates/glitch/vhs/fx.json

@@ -0,0 +1,46 @@
+{
+  "DESCRIPTION": "Worn VHS tape over footage: chroma bleed, tracking-noise band, head-switching skew, scanlines, wobble and dropouts",
+  "CREDIT": "agentvfx",
+  "ISFVSN": "2",
+  "CATEGORIES": ["glitch", "retro"],
+  "INPUTS": [
+    { "NAME": "chromaBleed", "TYPE": "float", "MIN": 0, "MAX": 80, "DEFAULT": 26 },
+    { "NAME": "lumaBlur", "TYPE": "float", "MIN": 0, "MAX": 6, "DEFAULT": 1.6 },
+    { "NAME": "ringing", "TYPE": "float", "MIN": 0, "MAX": 2, "DEFAULT": 0.6 },
+    { "NAME": "wobble", "TYPE": "float", "MIN": 0, "MAX": 2, "DEFAULT": 0.8 },
+    { "NAME": "trackAmount", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 0.85 },
+    { "NAME": "trackSpeed", "TYPE": "float", "MIN": -1, "MAX": 1, "DEFAULT": 0.17 },
+    { "NAME": "trackHeight", "TYPE": "float", "MIN": 0.02, "MAX": 0.5, "DEFAULT": 0.14 },
+    { "NAME": "headSwitch", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 1 },
+    { "NAME": "headHeight", "TYPE": "float", "MIN": 0.01, "MAX": 0.2, "DEFAULT": 0.06 },
+    { "NAME": "scanlines", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 0.6 },
+    { "NAME": "tapeNoise", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 0.35 },
+    { "NAME": "dropouts", "TYPE": "float", "MIN": 0, "MAX": 2, "DEFAULT": 0.8 },
+    { "NAME": "chromaNoise", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 0.5 },
+    { "NAME": "saturation", "TYPE": "float", "MIN": 0, "MAX": 3, "DEFAULT": 1.4 },
+    { "NAME": "contrast", "TYPE": "float", "MIN": 0.5, "MAX": 3, "DEFAULT": 1.2 },
+    { "NAME": "flicker", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 0.5 },
+    { "NAME": "audioKick", "TYPE": "float", "MIN": 0, "MAX": 2, "DEFAULT": 0 }
+  ],
+  "X_AGENTVFX": {
+    "id": "vhs",
+    "family": "glitch",
+    "input": "footage",
+    "spdx": "LicenseRef-agentvfx",
+    "flash": "possible",
+    "fps": 30,
+    "palette": false,
+    "presets": {
+      "vhs-tape": {},
+      "vhs-worn": { "chromaBleed": 42, "dropouts": 1.6, "trackHeight": 0.22, "tapeNoise": 0.6, "scanlines": 0.75, "wobble": 1.2, "ringing": 0.9 },
+      "vhs-clean": { "chromaBleed": 12, "wobble": 0.3, "trackAmount": 0.35, "dropouts": 0.2, "tapeNoise": 0.15, "headSwitch": 0.6, "scanlines": 0.35, "flicker": 0.15, "saturation": 1.15 },
+      "vhs-crash": { "trackAmount": 1, "trackSpeed": 0.55, "trackHeight": 0.34, "wobble": 1.7, "chromaBleed": 64, "dropouts": 2, "tapeNoise": 0.75, "flicker": 0.9 }
+    },
+    "audioBind": { "audioKick": "onset" },
+    "safeSubstitute": { "params": { "flicker": 0, "dropouts": 0.2, "tapeNoise": 0.2, "trackAmount": 0.3 } },
+    "credits": [
+      "NTSC YIQ colour space, https://en.wikipedia.org/wiki/YIQ",
+      "PCG integer hash, M. E. O'Neill, https://www.pcg-random.org/"
+    ]
+  }
+}

package/skills/agentvfx/templates/glitch/vhs/main.frag

@@ -0,0 +1,96 @@
+// vhs: analog tape. Luma/chroma separation in YIQ (chroma smears to the right and loses resolution),
+// luma edge ringing, per-line wobble, a scrolling tracking-noise band of blocky static, bottom
+// head-switching skew, scanlines, dropout streaks, flicker. Written fresh for agentvfx; the YIQ matrices
+// are the standard NTSC ones (https://en.wikipedia.org/wiki/YIQ).
+uint pcg(uint v) {
+  uint s = v * 747796405u + 2891336453u;
+  uint w = ((s >> ((s >> 28u) + 4u)) ^ s) * 277803737u;
+  return (w >> 22u) ^ w;
+}
+float h1(uint a) { return float(pcg(a)) / 4294967295.0; }
+float h2(uint a, uint b) { return h1(a * 2654435761u + pcg(b + 1013904223u)); }
+// SEED is the score seed / 2^32, so small integer seeds are tiny floats; recover the integer.
+uint seedU() { return uint(min(SEED * 4294967296.0 + 0.5, 4294967040.0)); }
+
+vec3 toYiq(vec3 c) {
+  return vec3(dot(c, vec3(0.299, 0.587, 0.114)), dot(c, vec3(0.596, -0.274, -0.322)), dot(c, vec3(0.211, -0.523, 0.312)));
+}
+vec3 fromYiq(vec3 q) {
+  return vec3(q.x + 0.956 * q.y + 0.621 * q.z, q.x - 0.272 * q.y - 0.647 * q.z, q.x - 1.106 * q.y + 1.703 * q.z);
+}
+
+void main() {
+  float u = RENDERSIZE.y / 1080.0;
+  uint fr = uint(FRAMEINDEX);
+  uint sd = seedU();
+  vec2 px = vUv * RENDERSIZE;
+  float lineH = 3.0 * u;
+  uint line = uint(floor(px.y / lineH));
+  float kick = clamp(audioKick, 0.0, 2.0);
+
+  // tracking band: scrolls upward, wraps; kicks make it wider and harder
+  float yb = fract(trackSpeed * TIME + h1(sd + 5u));
+  float hw = trackHeight * (1.0 + 0.5 * kick) * 0.5;
+  float dd = abs(fract(vUv.y - yb + 0.5) - 0.5);
+  float inBand = (1.0 - smoothstep(hw * 0.55, hw, dd)) * clamp(trackAmount + 0.4 * kick, 0.0, 1.5);
+
+  // head switching: bottom rows skew sideways
+  float ht = clamp(1.0 - vUv.y / max(headHeight, 0.001), 0.0, 1.0);
+
+  float lineNoise = h2(line, fr + sd) - 0.5;
+  float dx = wobble * u * (6.0 * sin(px.y / (u * 40.0) + TIME * 2.3) + 3.0 * sin(px.y / (u * 9.0) - TIME * 5.0) + 5.0 * lineNoise);
+  dx += inBand * u * (140.0 * lineNoise + 50.0 * sin(px.y / (u * 7.0) + TIME * 9.0));
+  dx += headSwitch * (ht * ht * ht * 0.09 * RENDERSIZE.x + ht * u * 30.0 * lineNoise);
+  vec2 base = vec2(px.x + dx, px.y);
+
+  // luma: small blur + ringing (unsharp)
+  float lb = max(lumaBlur, 0.05) * u;
+  float y0 = 0.0;
+  float yw = 0.0;
+  float yWide = 0.0;
+  for (int i = -4; i <= 4; i++) {
+    float w = 1.0 - abs(float(i)) / 5.0;
+    vec3 s = texture(inputImage, (base + vec2(float(i) * lb, 0.0)) / RENDERSIZE).rgb;
+    float yy = toYiq(s).x;
+    y0 += w * yy;
+    yw += w;
+    yWide += yy / 9.0;
+  }
+  float Y = y0 / yw;
+  Y += ringing * (Y - yWide);
+
+  // chroma: exponential smear from the left, coarse
+  vec2 iq = vec2(0.0);
+  float cw = 0.0;
+  for (int i = 0; i < 12; i++) {
+    float w = exp(-float(i) * 0.3);
+    vec3 s = texture(inputImage, (base - vec2(float(i) * chromaBleed * u / 12.0, 0.0)) / RENDERSIZE).rgb;
+    iq += w * toYiq(s).yz;
+    cw += w;
+  }
+  iq /= cw;
+  iq *= saturation;
+  iq += chromaNoise * vec2(h2(line, fr + sd + 7u) - 0.5, h2(line, fr + sd + 13u) - 0.5) * 0.25;
+
+  vec3 col = fromYiq(vec3(Y, iq));
+
+  // static inside the tracking band, blocky cells; head-switch noise
+  float cell = 4.0 * u;
+  vec2 cid = floor(px / vec2(cell * 3.0, cell));
+  float sn = h2(uint(int(cid.x)) + uint(int(cid.y)) * 8209u, fr + sd);
+  col = mix(col, vec3(sn * 0.9), clamp(inBand * 0.55 + ht * headSwitch * 0.5, 0.0, 0.95));
+  col += inBand * 0.12 * step(0.985, h2(line, fr + sd + 3u));
+
+  // dropout streaks
+  uint chunk = uint(floor(px.x / (60.0 * u)));
+  float dr = h2(line * 131u + chunk, fr + sd + 41u);
+  col = mix(col, vec3(0.95), step(1.0 - dropouts * 0.008, dr) * 0.85);
+
+  // scanlines, grain, flicker, contrast
+  col *= 1.0 - scanlines * 0.5 * (0.5 + 0.5 * cos(6.2832 * px.y / lineH));
+  float g = h2(uint(px.x) + uint(px.y) * 4099u, fr + sd + 91u);
+  col += tapeNoise * (g - 0.5) * 0.45;
+  col *= 1.0 + flicker * (h1(fr + sd) - 0.5) * 0.25;
+  col = max((col - 0.18) * contrast + 0.18, 0.0);
+  fragColor = vec4(col, 1.0);
+}

package/skills/agentvfx/templates/impact/impact-1bit/demo-onebit-bayer.json

@@ -0,0 +1 @@
+{"version":1,"template":"sacred","preset":"sacred-classic","params":{"blend":0},"input":{"video":"test-media/clip-01.mp4","audio":"test-media/beat-132.mp3"},"durationSec":4,"seed":11,"hits":[{"beat":0,"template":"impact-1bit","preset":"onebit-hard","durationFrames":2},{"beat":1,"template":"impact-1bit","preset":"onebit-bayer","durationFrames":3},{"beat":2,"template":"impact-1bit","preset":"onebit-flip","durationFrames":3},{"beat":3,"template":"impact-1bit","preset":"onebit-blood","durationFrames":3},{"beat":4,"template":"impact-1bit","preset":"onebit-bayer","durationFrames":3}],"out":"impact-1bit-bayer"}

package/skills/agentvfx/templates/impact/impact-1bit/fx.json

@@ -0,0 +1,45 @@
+{
+  "DESCRIPTION": "Impact frame: the layer below crushes to hard black and white (or a two-colour duotone, optional ordered dither) for 1-3 frames, then dissolves back in chunky blocks",
+  "CREDIT": "agentvfx",
+  "ISFVSN": "2",
+  "CATEGORIES": ["impact"],
+  "INPUTS": [
+    { "NAME": "hitFrames", "TYPE": "long", "MIN": 1, "MAX": 12, "DEFAULT": 3 },
+    { "NAME": "holdFrames", "TYPE": "long", "MIN": 0, "MAX": 6, "DEFAULT": 2 },
+    { "NAME": "decayCurve", "TYPE": "float", "MIN": 0.3, "MAX": 4, "DEFAULT": 1 },
+    { "NAME": "threshold", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 0.48 },
+    { "NAME": "preContrast", "TYPE": "float", "MIN": 0.5, "MAX": 5, "DEFAULT": 1.6 },
+    { "NAME": "adapt", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 0.5 },
+    { "NAME": "adaptRadius", "TYPE": "float", "MIN": 1, "MAX": 40, "DEFAULT": 14 },
+    { "NAME": "dither", "TYPE": "long", "MIN": 0, "MAX": 2, "VALUES": [0, 1, 2], "LABELS": ["hard", "bayer 8x8", "noise"], "DEFAULT": 0 },
+    { "NAME": "ditherAmount", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 0.35 },
+    { "NAME": "ditherPx", "TYPE": "float", "MIN": 1, "MAX": 12, "DEFAULT": 3 },
+    { "NAME": "inkColor", "TYPE": "color", "DEFAULT": [0, 0, 0, 1] },
+    { "NAME": "paperColor", "TYPE": "color", "DEFAULT": [1, 1, 1, 1] },
+    { "NAME": "useScorePalette", "TYPE": "bool", "DEFAULT": false },
+    { "NAME": "flip", "TYPE": "bool", "DEFAULT": false },
+    { "NAME": "blockPx", "TYPE": "float", "MIN": 2, "MAX": 160, "DEFAULT": 40 }
+  ],
+  "X_AGENTVFX": {
+    "id": "impact-1bit",
+    "family": "impact",
+    "input": "either",
+    "spdx": "LicenseRef-agentvfx",
+    "flash": "possible",
+    "fps": 30,
+    "palette": true,
+    "presets": {
+      "onebit-hard": { "hitFrames": 2, "holdFrames": 2, "threshold": 0.48, "preContrast": 1.8 },
+      "onebit-bayer": { "hitFrames": 3, "holdFrames": 2, "dither": 1, "ditherAmount": 0.45, "ditherPx": 3, "adapt": 0.25 },
+      "onebit-flip": { "hitFrames": 3, "holdFrames": 2, "flip": true, "adapt": 0.7, "preContrast": 2.2 },
+      "onebit-duotone": { "hitFrames": 4, "holdFrames": 2, "useScorePalette": true, "dither": 1, "ditherAmount": 0.3 },
+      "onebit-blood": { "hitFrames": 3, "holdFrames": 2, "inkColor": [0.02, 0, 0, 1], "paperColor": [0.9, 0.02, 0.02, 1], "adapt": 0.6 }
+    },
+    "safeSubstitute": { "template": "punch-shake" },
+    "credits": [
+      "Impact-frame grammar (1-bit black/white on contact), Roblox DevForum VFX notes and sakugabooru wiki",
+      "Bayer ordered dither, https://en.wikipedia.org/wiki/Ordered_dithering",
+      "Local-mean adaptive threshold, https://en.wikipedia.org/wiki/Thresholding_(image_processing)"
+    ]
+  }
+}