agentvfx 0.0.0-stage → 0.3.5

package/skills/agentvfx/templates/glitch/pixel-sort/build-passes.mjs

@@ -0,0 +1,162 @@
+// Regenerates the pixel-sort pass files (pass0..pass8 and main.frag) from the shared GLSL below.
+// The engine gives every pass its own file, so the shared helpers are pasted into each one.
+//   node build-passes.mjs
+// Passes: pass0 keyBuf (cell average colour + sort key), pass1..pass8 run lengths by doubling
+// (run<j> holds min(run length, 2^j) to the left in .r and to the right in .g), main = the sort.
+import { writeFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+
+const dir = path.dirname(fileURLToPath(import.meta.url));
+const K = 8;
+
+const COMMON = `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 ${2 ** K} 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) * ${2 ** K}.0) * cutJitter; }
+`;
+
+const header = (title) => `// pixel-sort (${title}). 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..pass${K}); 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).
+`;
+
+const pass0 = `${header("pass0 keyBuf: cell average colour in rgb, sort key in a")}${COMMON}
+float sortKey(vec3 c) {
+  if (sortBy == 1) return rgb2hsv(c).x;
+  if (sortBy == 2) return rgb2hsv(c).y;
+  if (sortBy == 3) return linearToSrgb(c).b;
+  return linearToSrgb(vec3(luma(c))).r;
+}
+void main() {
+  float cp = cellPx();
+  vec2 c = floor(vUv * RENDERSIZE / cp);
+  vec2 cen = (c + 0.5) * cp;
+  vec3 acc;
+  if (cp < 1.5) acc = texture(inputImage, vUv).rgb;
+  else {
+    acc = vec3(0.0);
+    for (int i = 0; i < 4; i++) {
+      vec2 o = vec2(i % 2 == 0 ? -0.25 : 0.25, i < 2 ? -0.25 : 0.25) * cp;
+      acc += texture(inputImage, (cen + o) / RENDERSIZE).rgb;
+    }
+    acc *= 0.25;
+  }
+  fragColor = vec4(acc, sortKey(acc));
+}
+`;
+
+function runPass(j) {
+  const prevR = j === 1 ? "(maskOf(cn) ? 1.0 : 0.0)" : `texelFetch(run${j - 1}, cellTexel(cn), 0).r`;
+  const prevG = j === 1 ? "(maskOf(cn) ? 1.0 : 0.0)" : `texelFetch(run${j - 1}, cellTexel(cn), 0).g`;
+  const own = j === 1 ? "vec2(1.0)" : `texelFetch(run${j - 1}, cellTexel(c), 0).rg`;
+  return `${header(`pass${j} run${j}: run lengths to the left (r) and right (g), capped at ${2 ** j}`)}${COMMON}
+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), ${2 ** K}.0);
+  float capL = posIn + 1.0;
+  float capR = ${2 ** K}.0 - posIn;
+  float kk = ${2 ** (j - 1)}.0;
+  vec2 own = ${own};
+  float L = own.x;
+  float R = own.y;
+  if (L >= kk) {
+    vec2 cn = c - dv * kk;
+    float ln = inCells(cn) ? ${prevR} : 0.0;
+    L = min(min(2.0 * kk, kk + ln), capL);
+  }
+  if (R >= kk) {
+    vec2 cn = c + dv * kk;
+    float rn = inCells(cn) ? ${prevG} : 0.0;
+    R = min(min(2.0 * kk, kk + rn), capR);
+  }
+  fragColor = vec4(L, R, 0.0, 1.0);
+}
+`;
+}
+
+const main = `${header("main: sort each span")}${COMMON}
+void main() {
+  vec3 orig = texture(inputImage, vUv).rgb;
+  float cp = cellPx();
+  vec2 c = floor(vUv * RENDERSIZE / cp);
+  if (!maskOf(c)) { fragColor = vec4(orig, 1.0); return; }
+  vec2 dv = axisDir();
+  vec2 rl = texelFetch(run${K}, cellTexel(c), 0).rg;
+  float L = max(rl.x + rl.y - 1.0, 1.0);
+  float pos = rl.x - 1.0;
+  int sn = int(min(L, 32.0));
+  float ks[32];
+  vec3 cs[32];
+  vec2 first = c - dv * pos;
+  for (int i = 0; i < 32; i++) {
+    if (i >= sn) break;
+    float idx = floor((float(i) + 0.5) * L / float(sn));
+    vec4 kc = texelFetch(keyBuf, cellTexel(first + dv * idx), 0);
+    float key = descend ? -kc.a : kc.a;
+    int j = i;
+    while (j > 0 && ks[j - 1] > key) {
+      ks[j] = ks[j - 1];
+      cs[j] = cs[j - 1];
+      j--;
+    }
+    ks[j] = key;
+    cs[j] = kc.rgb;
+  }
+  float fq = clamp((pos + 0.5) / L * float(sn) - 0.5, 0.0, float(sn - 1));
+  int i0 = int(floor(fq));
+  int i1 = min(i0 + 1, sn - 1);
+  float f = fract(fq);
+  float w = mix(step(0.5, f), f, softness);
+  vec3 col = mix(cs[i0], cs[i1], w);
+  float key = mix(ks[i0], ks[i1], w);
+  if (descend) key = -key;
+  float lm = luma(col);
+  col = mix(vec3(lm), col, saturation);
+  col = max((col - 0.18) * punch + 0.18, 0.0);
+  col = mix(col, paletteRamp(clamp(key, 0.0, 1.0)) * (0.6 + 0.8 * lm), paletteMix);
+  fragColor = vec4(mix(orig, col, blend), 1.0);
+}
+`;
+
+writeFileSync(path.join(dir, "pass0.frag"), pass0);
+for (let j = 1; j <= K; j++) writeFileSync(path.join(dir, `pass${j}.frag`), runPass(j));
+writeFileSync(path.join(dir, "main.frag"), main);
+console.log(`wrote pass0..pass${K} and main.frag in ${dir}`);

package/skills/agentvfx/templates/glitch/pixel-sort/demo-chunk.json

@@ -0,0 +1 @@
+{"version":1,"template":"pixel-sort","preset":"pixel-sort-chunk","input":{"video":"test-media/clip-01.mp4"},"palette":"acid-data","durationSec":4,"seed":53,"out":"pixel-sort-chunk"}

package/skills/agentvfx/templates/glitch/pixel-sort/demo-hue.json

@@ -0,0 +1 @@
+{"version":1,"template":"pixel-sort","preset":"pixel-sort-hue","input":{"video":"test-media/clip-01.mp4"},"durationSec":4,"seed":54,"out":"pixel-sort-hue"}

package/skills/agentvfx/templates/glitch/pixel-sort/demo-kick.json

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

package/skills/agentvfx/templates/glitch/pixel-sort/demo-streak.json

@@ -0,0 +1 @@
+{"version":1,"template":"pixel-sort","preset":"pixel-sort-streak","input":{"video":"test-media/clip-01.mp4"},"durationSec":4,"seed":51,"out":"pixel-sort-streak"}

package/skills/agentvfx/templates/glitch/pixel-sort/demo-vertical.json

@@ -0,0 +1 @@
+{"version":1,"template":"pixel-sort","preset":"pixel-sort-vertical","input":{"video":"test-media/clip-02.mp4"},"durationSec":4,"seed":52,"out":"pixel-sort-vertical"}

package/skills/agentvfx/templates/glitch/pixel-sort/fx.json

@@ -0,0 +1,60 @@
+{
+  "DESCRIPTION": "Pixel sorting over footage: luma-threshold spans sorted along an axis into streaks, with sweeping thresholds and row stutter",
+  "CREDIT": "agentvfx",
+  "ISFVSN": "2",
+  "CATEGORIES": ["glitch"],
+  "INPUTS": [
+    { "NAME": "sortAxis", "TYPE": "long", "MIN": 0, "MAX": 1, "VALUES": [0, 1], "LABELS": ["horizontal", "vertical"], "DEFAULT": 0 },
+    { "NAME": "cellSize", "TYPE": "float", "MIN": 1, "MAX": 16, "DEFAULT": 3 },
+    { "NAME": "threshLo", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 0.28 },
+    { "NAME": "threshHi", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 0.97 },
+    { "NAME": "rowVar", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 0.25 },
+    { "NAME": "rowsFrac", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 0.9 },
+    { "NAME": "sweep", "TYPE": "float", "MIN": 0, "MAX": 0.5, "DEFAULT": 0.12 },
+    { "NAME": "sweepRate", "TYPE": "float", "MIN": 0, "MAX": 4, "DEFAULT": 0.35 },
+    { "NAME": "stutterHz", "TYPE": "float", "MIN": 1, "MAX": 30, "DEFAULT": 8 },
+    { "NAME": "sortBy", "TYPE": "long", "MIN": 0, "MAX": 3, "VALUES": [0, 1, 2, 3], "LABELS": ["luma", "hue", "saturation", "blue"], "DEFAULT": 0 },
+    { "NAME": "descend", "TYPE": "bool", "DEFAULT": false },
+    { "NAME": "softness", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 0.4 },
+    { "NAME": "cutJitter", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 1 },
+    { "NAME": "paletteMix", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 0 },
+    { "NAME": "saturation", "TYPE": "float", "MIN": 0, "MAX": 3, "DEFAULT": 1.5 },
+    { "NAME": "punch", "TYPE": "float", "MIN": 0.5, "MAX": 3, "DEFAULT": 1.3 },
+    { "NAME": "blend", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 1 },
+    { "NAME": "audioKick", "TYPE": "float", "MIN": 0, "MAX": 2, "DEFAULT": 0 }
+  ],
+  "PASSES": [
+    { "TARGET": "keyBuf", "FLOAT": true },
+    { "TARGET": "run1", "FLOAT": true },
+    { "TARGET": "run2", "FLOAT": true },
+    { "TARGET": "run3", "FLOAT": true },
+    { "TARGET": "run4", "FLOAT": true },
+    { "TARGET": "run5", "FLOAT": true },
+    { "TARGET": "run6", "FLOAT": true },
+    { "TARGET": "run7", "FLOAT": true },
+    { "TARGET": "run8", "FLOAT": true },
+    {}
+  ],
+  "X_AGENTVFX": {
+    "id": "pixel-sort",
+    "family": "glitch",
+    "input": "footage",
+    "spdx": "Apache-2.0",
+    "flash": "possible",
+    "fps": 30,
+    "palette": true,
+    "presets": {
+      "pixel-sort-streak": {},
+      "pixel-sort-vertical": { "sortAxis": 1, "cellSize": 2, "threshLo": 0.2, "threshHi": 0.85, "sweep": 0.2, "sweepRate": 0.5, "descend": true, "rowVar": 0.35 },
+      "pixel-sort-chunk": { "cellSize": 9, "threshLo": 0.18, "threshHi": 1, "softness": 0, "rowVar": 0.4, "stutterHz": 12, "paletteMix": 0.5, "saturation": 1.5 },
+      "pixel-sort-hue": { "sortBy": 1, "cellSize": 2, "threshLo": 0.1, "threshHi": 0.92, "rowsFrac": 1, "rowVar": 0.1, "sweep": 0.18, "saturation": 1.6 },
+      "pixel-sort-kick": { "rowsFrac": 0.25, "threshLo": 0.45, "threshHi": 0.8, "sweep": 0.05, "cellSize": 3 }
+    },
+    "audioBind": { "audioKick": "onset" },
+    "credits": [
+      "ASDFPixelSort by Kim Asendorf (the pixel-sorting idea, by name only; no code used)",
+      "Run-length doubling (pointer jumping), https://en.wikipedia.org/wiki/Pointer_jumping",
+      "PCG integer hash, M. E. O'Neill, https://www.pcg-random.org/"
+    ]
+  }
+}

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

@@ -0,0 +1,83 @@
+// pixel-sort (main: sort each span). 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() {
+  vec3 orig = texture(inputImage, vUv).rgb;
+  float cp = cellPx();
+  vec2 c = floor(vUv * RENDERSIZE / cp);
+  if (!maskOf(c)) { fragColor = vec4(orig, 1.0); return; }
+  vec2 dv = axisDir();
+  vec2 rl = texelFetch(run8, cellTexel(c), 0).rg;
+  float L = max(rl.x + rl.y - 1.0, 1.0);
+  float pos = rl.x - 1.0;
+  int sn = int(min(L, 32.0));
+  float ks[32];
+  vec3 cs[32];
+  vec2 first = c - dv * pos;
+  for (int i = 0; i < 32; i++) {
+    if (i >= sn) break;
+    float idx = floor((float(i) + 0.5) * L / float(sn));
+    vec4 kc = texelFetch(keyBuf, cellTexel(first + dv * idx), 0);
+    float key = descend ? -kc.a : kc.a;
+    int j = i;
+    while (j > 0 && ks[j - 1] > key) {
+      ks[j] = ks[j - 1];
+      cs[j] = cs[j - 1];
+      j--;
+    }
+    ks[j] = key;
+    cs[j] = kc.rgb;
+  }
+  float fq = clamp((pos + 0.5) / L * float(sn) - 0.5, 0.0, float(sn - 1));
+  int i0 = int(floor(fq));
+  int i1 = min(i0 + 1, sn - 1);
+  float f = fract(fq);
+  float w = mix(step(0.5, f), f, softness);
+  vec3 col = mix(cs[i0], cs[i1], w);
+  float key = mix(ks[i0], ks[i1], w);
+  if (descend) key = -key;
+  float lm = luma(col);
+  col = mix(vec3(lm), col, saturation);
+  col = max((col - 0.18) * punch + 0.18, 0.0);
+  col = mix(col, paletteRamp(clamp(key, 0.0, 1.0)) * (0.6 + 0.8 * lm), paletteMix);
+  fragColor = vec4(mix(orig, col, blend), 1.0);
+}

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

@@ -0,0 +1,64 @@
+// pixel-sort (pass0 keyBuf: cell average colour in rgb, sort key in a). 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; }
+
+float sortKey(vec3 c) {
+  if (sortBy == 1) return rgb2hsv(c).x;
+  if (sortBy == 2) return rgb2hsv(c).y;
+  if (sortBy == 3) return linearToSrgb(c).b;
+  return linearToSrgb(vec3(luma(c))).r;
+}
+void main() {
+  float cp = cellPx();
+  vec2 c = floor(vUv * RENDERSIZE / cp);
+  vec2 cen = (c + 0.5) * cp;
+  vec3 acc;
+  if (cp < 1.5) acc = texture(inputImage, vUv).rgb;
+  else {
+    acc = vec3(0.0);
+    for (int i = 0; i < 4; i++) {
+      vec2 o = vec2(i % 2 == 0 ? -0.25 : 0.25, i < 2 ? -0.25 : 0.25) * cp;
+      acc += texture(inputImage, (cen + o) / RENDERSIZE).rgb;
+    }
+    acc *= 0.25;
+  }
+  fragColor = vec4(acc, sortKey(acc));
+}

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

@@ -0,0 +1,66 @@
+// pixel-sort (pass1 run1: run lengths to the left (r) and right (g), capped at 2). 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 = 1.0;
+  vec2 own = vec2(1.0);
+  float L = own.x;
+  float R = own.y;
+  if (L >= kk) {
+    vec2 cn = c - dv * kk;
+    float ln = inCells(cn) ? (maskOf(cn) ? 1.0 : 0.0) : 0.0;
+    L = min(min(2.0 * kk, kk + ln), capL);
+  }
+  if (R >= kk) {
+    vec2 cn = c + dv * kk;
+    float rn = inCells(cn) ? (maskOf(cn) ? 1.0 : 0.0) : 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/pass2.frag

@@ -0,0 +1,66 @@
+// pixel-sort (pass2 run2: run lengths to the left (r) and right (g), capped at 4). 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 = 2.0;
+  vec2 own = texelFetch(run1, 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(run1, 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(run1, 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/pass3.frag

@@ -0,0 +1,66 @@
+// pixel-sort (pass3 run3: run lengths to the left (r) and right (g), capped at 8). 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 = 4.0;
+  vec2 own = texelFetch(run2, 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(run2, 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(run2, 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/pass4.frag

@@ -0,0 +1,66 @@
+// pixel-sort (pass4 run4: run lengths to the left (r) and right (g), capped at 16). 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 = 8.0;
+  vec2 own = texelFetch(run3, 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(run3, 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(run3, cellTexel(cn), 0).g : 0.0;
+    R = min(min(2.0 * kk, kk + rn), capR);
+  }
+  fragColor = vec4(L, R, 0.0, 1.0);
+}