agentvfx 0.0.0-stage → 0.3.4

package/skills/agentvfx/templates/brutal/lattice/demo-vermilion.json

@@ -0,0 +1 @@
+{"version":1,"template":"lattice","preset":"vermilion","input":{"video":"test-media/clip-01.mp4","audio":"test-media/beat-132.mp3","startSec":0},"durationSec":4,"seed":11,"out":"lattice-vermilion"}

package/skills/agentvfx/templates/brutal/lattice/demo-violet-slow.json

@@ -0,0 +1 @@
+{"version":1,"template":"lattice","preset":"violet-slow","input":{"video":"test-media/clip-01.mp4","audio":"test-media/beat-132.mp3","startSec":0},"durationSec":4,"seed":23,"out":"lattice-violet-slow"}

package/skills/agentvfx/templates/brutal/lattice/fx.json

@@ -0,0 +1,130 @@
+{
+  "DESCRIPTION": "A full-frame dot lattice that sound physically deforms: kicks send radial shockwaves from a jumping origin, onsets tear rows apart sideways, highs jitter and sparkle single points, silence snaps back to a perfect grid; footage only sizes the dots",
+  "CREDIT": "agentvfx",
+  "ISFVSN": "2",
+  "CATEGORIES": ["brutal", "lattice", "audio"],
+  "INPUTS": [
+    { "NAME": "groundColor", "TYPE": "color", "DEFAULT": [0.035, 0.03, 0.03, 1] },
+    { "NAME": "dotColor", "TYPE": "color", "DEFAULT": [1, 0.2, 0.04, 1] },
+    { "NAME": "hotColor", "TYPE": "color", "DEFAULT": [1, 0.93, 0.8, 1] },
+    { "NAME": "pitch", "TYPE": "float", "MIN": 8, "MAX": 80, "DEFAULT": 22 },
+    { "NAME": "stagger", "TYPE": "float", "MIN": 0, "MAX": 0.5, "DEFAULT": 0 },
+    { "NAME": "dotBase", "TYPE": "float", "MIN": 0.02, "MAX": 0.4, "DEFAULT": 0.17 },
+    { "NAME": "dotLuma", "TYPE": "float", "MIN": 0, "MAX": 0.6, "DEFAULT": 0.27 },
+    { "NAME": "mediaAmount", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 1 },
+    { "NAME": "imgContrast", "TYPE": "float", "MIN": 0.5, "MAX": 3, "DEFAULT": 1.6 },
+    { "NAME": "imgBias", "TYPE": "float", "MIN": -0.5, "MAX": 0.5, "DEFAULT": -0.04 },
+    { "NAME": "invert", "TYPE": "bool", "DEFAULT": false },
+    { "NAME": "headline", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 1 },
+    { "NAME": "textKnock", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 0.9 },
+    { "NAME": "release", "TYPE": "float", "MIN": 0.02, "MAX": 0.4, "DEFAULT": 0.06 },
+    { "NAME": "kickBass", "TYPE": "float", "MIN": 1, "MAX": 6, "DEFAULT": 1.6 },
+    { "NAME": "kickPush", "TYPE": "float", "MIN": 0, "MAX": 2.2, "DEFAULT": 1.8 },
+    { "NAME": "waveSpeed", "TYPE": "float", "MIN": 200, "MAX": 8000, "DEFAULT": 3200 },
+    { "NAME": "waveWidth", "TYPE": "float", "MIN": 0.05, "MAX": 0.6, "DEFAULT": 0.2 },
+    { "NAME": "kickSwell", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 0.55 },
+    { "NAME": "tearShear", "TYPE": "float", "MIN": 0, "MAX": 16, "DEFAULT": 6 },
+    { "NAME": "tearSpread", "TYPE": "float", "MIN": 0.05, "MAX": 1, "DEFAULT": 0.22 },
+    { "NAME": "jitter", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 0.3 },
+    { "NAME": "sparkle", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 0.8 },
+    { "NAME": "stretch", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 0.8 },
+    { "NAME": "ghost", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 0.35 },
+    { "NAME": "links", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 0.8 }
+  ],
+  "PASSES": [
+    { "TARGET": "lat", "PERSISTENT": true, "FLOAT": true },
+    {}
+  ],
+  "X_AGENTVFX": {
+    "id": "lattice",
+    "family": "brutal",
+    "input": "either",
+    "spdx": "LicenseRef-agentvfx",
+    "flash": "possible",
+    "fps": 30,
+    "palette": false,
+    "presets": {
+      "vermilion": {},
+      "vermilion-fine": { "pitch": 12 },
+      "ink-yellow": {
+        "groundColor": [1, 0.82, 0, 1],
+        "dotColor": [0.03, 0.03, 0.03, 1],
+        "hotColor": [0.9, 0.08, 0, 1],
+        "pitch": 26,
+        "invert": true,
+        "imgContrast": 1.8,
+        "ghost": 0.5
+      },
+      "violet-slow": {
+        "groundColor": [0.03, 0.02, 0.05, 1],
+        "dotColor": [0.62, 0.3, 1, 1],
+        "hotColor": [1, 0.8, 1, 1],
+        "pitch": 19,
+        "stagger": 0.5,
+        "release": 0.12,
+        "waveWidth": 0.28
+      },
+      "cobalt-fine": {
+        "groundColor": [0.02, 0.025, 0.04, 1],
+        "dotColor": [0.1, 0.5, 1, 1],
+        "hotColor": [0.85, 0.97, 1, 1],
+        "pitch": 12,
+        "dotBase": 0.1,
+        "dotLuma": 0.4,
+        "tearShear": 14,
+        "kickPush": 2
+      },
+      "graphite-ice": {
+        "groundColor": [0.075, 0.08, 0.09, 1],
+        "dotColor": [0.88, 0.92, 0.96, 1],
+        "hotColor": [0.4, 0.85, 1, 1],
+        "pitch": 20,
+        "ghost": 0.3
+      },
+      "phosphor": {
+        "groundColor": [0.008, 0.02, 0.012, 1],
+        "dotColor": [0.15, 1, 0.35, 1],
+        "hotColor": [0.88, 1, 0.82, 1],
+        "pitch": 18,
+        "dotBase": 0.14,
+        "jitter": 0.4
+      },
+      "bone-ink": {
+        "groundColor": [0.92, 0.89, 0.8, 1],
+        "dotColor": [0.04, 0.04, 0.04, 1],
+        "hotColor": [0.95, 0.14, 0.02, 1],
+        "pitch": 24,
+        "invert": true,
+        "imgContrast": 1.8,
+        "ghost": 0.5
+      }
+    },
+    "audioBind": {
+      "kickPush": "bass",
+      "tearShear": "onset",
+      "jitter": "treble"
+    },
+    "safeSubstitute": {
+      "params": {
+        "kickSwell": 0,
+        "sparkle": 0
+      }
+    },
+    "text": [
+      {
+        "key": "headline",
+        "default": "LATTICE",
+        "x": 0.05,
+        "y": 0.66,
+        "size": 0.2,
+        "font": "grotesk",
+        "style": "fill",
+        "tracking": 0.1
+      }
+    ],
+    "credits": [
+      "Closed-form event motion: amplitude = strength * exp(-age / release) for a kick shockwave (travelling Gaussian front), a row shear (per-row x slide, exactly invertible so each row finds its own columns) and per-point hashed jitter",
+      "Rendering by neighbourhood search over displaced rest cells, capsule distance after the standard analytic form (Inigo Quilez, https://iquilezles.org/articles/distfunctions2d/)"
+    ]
+  }
+}

package/skills/agentvfx/templates/brutal/lattice/main.frag

@@ -0,0 +1,175 @@
+// lattice: a full-frame dot lattice that sound physically deforms. Written fresh.
+//   kick  -> a radial shockwave: points are pushed away from an origin that jumps to a new place on every kick
+//   onset -> a horizontal tear: rows shear apart either side of a line (rows slide in x by their own amount)
+//   highs -> per-point jitter and sparkle, new random numbers every frame
+//   quiet -> no ambient motion at all: the lattice is a perfect square (or hex) grid again the same frame
+// Footage only modulates dot radius, so the subject shows up inside the grid while the grid motion leads.
+// Every motion is a closed form of (age of the event, release): amplitude = strength * exp(-age / release),
+// so the attack is the frame of the onset and the release is the `release` parameter in seconds.
+// Rendering: for a fragment, the 5x5 rest cells around it are displaced by the same function the dots use
+// (tears are an exact per-row x shift, so each row looks up its own columns) and the nearest dot or
+// stretched dot wins; rest positions are drawn as faint ghost points so the deformation reads against order.
+const float TAU = 6.28318530718;
+float U;
+vec2 D;
+float W;
+
+vec2 coverUV(vec2 p) {
+  vec2 tex = IMG_SIZE(inputImage);
+  float ta = tex.x / tex.y;
+  float wa = W / 1080.0;
+  vec2 q = (p - vec2(0.5 * W, 540.0)) / vec2(W, 1080.0);
+  q.y = -q.y;
+  vec2 vis = wa > ta ? vec2(1.0, ta / wa) : vec2(wa / ta, 1.0);
+  return clamp(0.5 + q * vis, 0.0, 1.0);
+}
+float toneAt(vec2 p) {
+  if (mediaAmount <= 0.0) return 0.5;
+  float L;
+  if (HAS_INPUT) {
+    vec2 o = vec2(0.28 * pitch, 0.0);
+    L = 0.25 * (luma(texture(inputImage, coverUV(p + o)).rgb) + luma(texture(inputImage, coverUV(p - o)).rgb)
+      + luma(texture(inputImage, coverUV(p + o.yx)).rgb) + luma(texture(inputImage, coverUV(p - o.yx)).rgb));
+  } else {
+    vec2 uv = p / vec2(W, 1080.0);
+    L = smoothstep(0.3, 0.75, fbm(uv * 3.2 + vec2(TIME * 0.05, 0.0), 4));
+  }
+  L = clamp((pow(clamp(L, 0.0, 1.0), 0.4545) - 0.5) * imgContrast + 0.5 + imgBias, 0.0, 1.0);
+  L = invert ? 1.0 - L : L;
+  return mix(0.5, L, mediaAmount);
+}
+float inkAt(vec2 p) {
+  if (!HAS_TEXT) return 0.0;
+  vec2 o = vec2(0.3 * pitch, 0.0);
+  vec2 s = vec2(1.0, -1.0) / vec2(W, 1080.0);
+  vec2 uv = vec2(p.x, 1080.0 - p.y) / vec2(W, 1080.0);
+  return (texture(TEXTMASK, uv).r + 0.5 * (texture(TEXTMASK, uv + o * s).r + texture(TEXTMASK, uv - o * s).r)) * 0.5;
+}
+
+// horizontal slide of a lattice row (design units); rowY is the row's rest y, rowId decorrelates rows
+float tearX(float rowY, float rowId) {
+  float s = 0.0;
+  for (int k = 0; k < 3; k++) {
+    vec4 ev = texelFetch(lat, ivec2(6 + k, 0), 0);
+    if (ev.z <= 0.0) continue;
+    float env = exp(-max(TIME - ev.x, 0.0) / max(release, 0.004));
+    if (env < 0.004) continue;
+    float dy = rowY - ev.y * 1080.0;
+    float side = dy >= 0.0 ? 1.0 : -1.0;
+    float rh = hash12(vec2(rowId, ev.x * 13.7));
+    s += ev.w * ev.z * env * tearShear * pitch * exp(-abs(dy) / (tearSpread * 1080.0)) * (0.6 * side + (rh - 0.5) * 1.1);
+  }
+  return s;
+}
+// radial push from every live kick; swell is the local shock strength (dot radius boost)
+vec2 shockAt(vec2 p0, out float swell) {
+  vec2 disp = vec2(0.0);
+  swell = 0.0;
+  for (int k = 0; k < 4; k++) {
+    vec4 ev = texelFetch(lat, ivec2(2 + k, 0), 0);
+    if (ev.w <= 0.0) continue;
+    float age = max(TIME - ev.x, 0.0);
+    float env = exp(-age / max(release, 0.004));
+    if (env < 0.004) continue;
+    vec2 v = p0 - vec2(ev.y * W, ev.z * 1080.0);
+    float d = length(v);
+    float x = (d - 97.0 - waveSpeed * age) / (waveWidth * 1080.0);
+    float prof = x > 0.0 ? exp(-x * x * 5.0) : exp(x * 0.9);
+    float a = ev.w * env * prof;
+    disp += (d > 1e-3 ? v / d : vec2(0.0)) * a * kickPush * pitch * smoothstep(0.0, pitch, d);
+    swell += a;
+  }
+  float len = length(disp);
+  if (len > 2.2 * pitch) disp *= 2.2 * pitch / len;
+  return disp;
+}
+
+// spring between two neighbouring points: invisible at rest length, brighter the more it is stretched or
+// squeezed, and cut when the points have been torn further than 2.8 pitches apart
+float linkCov(vec2 a, vec2 b) {
+  float l = length(b - a);
+  float tens = clamp(abs(l - pitch) / pitch * 1.6, 0.0, 1.0);
+  if (tens < 0.04 || l > 2.8 * pitch) return 0.0;
+  vec2 pa = D - a;
+  vec2 ba = b - a;
+  float d = length(pa - ba * clamp(dot(pa, ba) / dot(ba, ba), 0.0, 1.0));
+  return links * tens * clamp(0.5 - (d * U - 0.9), 0.0, 1.0);
+}
+
+void main() {
+  U = RENDERSIZE.y / 1080.0;
+  W = RENDERSIZE.x / U;
+  D = vec2(gl_FragCoord.x, RENDERSIZE.y - gl_FragCoord.y) / U;
+  float hi = texelFetch(lat, ivec2(0, 0), 0).x;
+  float fsalt = float(FRAMEINDEX) * 1.37;
+  float rowH = pitch * mix(1.0, 0.866, clamp(stagger * 2.0, 0.0, 1.0));
+  float rmax = pitch * 0.75 * (1.0 + kickSwell);
+  float bestCov = 0.0;
+  float bestHeat = 0.0;
+  float bestLink = 0.0;
+  int j0 = int(floor(D.y / rowH));
+  int ib = int(floor(D.x / pitch)) - 4;
+  vec2 above[9];
+  int aboveRow[9];
+  for (int k = 0; k < 9; k++) aboveRow[k] = -100000;
+  for (int dj = -2; dj <= 2; dj++) {
+    int j = j0 + dj;
+    float restY = (float(j) + 0.5) * rowH;
+    float off = stagger * pitch * float(j & 1);
+    float tx = tearX(restY, float(j));
+    int i0 = int(floor((D.x - tx - off) / pitch));
+    vec2 left = vec2(0.0);
+    bool leftOk = false;
+    for (int di = -2; di <= 2; di++) {
+      int i = i0 + di;
+      vec2 p0 = vec2((float(i) + 0.5) * pitch + off, restY);
+      float swell;
+      vec2 disp = shockAt(p0, swell);
+      vec2 id = vec2(float(i), float(j));
+      vec2 jit = (hash22(id + fsalt) - 0.5) * 2.0 * hi * jitter * pitch;
+      vec2 pl = p0 + disp + vec2(tx, 0.0);
+      int slot = i - ib;
+      if (links > 0.0) {
+        if (leftOk) bestLink = max(bestLink, linkCov(left, pl));
+        if (slot >= 0 && slot < 9) {
+          if (aboveRow[slot] == j - 1 && stagger == 0.0) bestLink = max(bestLink, linkCov(above[slot], pl));
+          above[slot] = pl;
+          aboveRow[slot] = j;
+        }
+        left = pl;
+        leftOk = true;
+      }
+      vec2 pos = pl + jit;
+      vec2 trail = disp + vec2(tx, 0.0);
+      float tl = length(trail);
+      trail *= tl > 1e-4 ? min(tl, 1.4 * pitch) / tl * stretch * 0.5 : 0.0;
+      vec2 ba = -trail;
+      vec2 pa = D - pos;
+      float dist = length(pa - ba * clamp(dot(pa, ba) / max(dot(ba, ba), 1e-6), 0.0, 1.0));
+      if (dist > rmax) continue;
+      float spark = step(1.0 - sparkle * hi * 0.16, hash12(id * 1.7 + fsalt + 9.0));
+      float t = inkAt(p0) * headline;
+      float r = pitch * (dotBase + dotLuma * toneAt(p0)) * (1.0 + kickSwell * min(swell, 1.0)) * (1.0 + 0.5 * spark);
+      if (t < 0.5 && textKnock > 0.0 && headline > 0.0) {
+        float halo = max(max(inkAt(p0 + vec2(pitch, 0.0)), inkAt(p0 - vec2(pitch, 0.0))), max(inkAt(p0 + vec2(0.0, pitch)), inkAt(p0 - vec2(0.0, pitch))));
+        r *= 1.0 - 0.7 * textKnock * halo;
+      }
+      r = max(r, pitch * 0.47 * t);
+      float cov = clamp(0.5 - (dist - r) * U, 0.0, 1.0);
+      if (cov > bestCov) {
+        bestCov = cov;
+        bestHeat = clamp(length(disp + vec2(tx, 0.0)) / pitch * 0.12 + spark + t * 0.8, 0.0, 1.0);
+      }
+    }
+  }
+  vec3 col = groundColor.rgb;
+  if (ghost > 0.0) {
+    float gj = floor(D.y / rowH);
+    float goff = stagger * pitch * float(int(gj) & 1);
+    vec2 g = vec2((floor((D.x - goff) / pitch) + 0.5) * pitch + goff, (gj + 0.5) * rowH);
+    col = mix(col, mix(groundColor.rgb, dotColor.rgb, 0.45), ghost * clamp(0.5 - (length(D - g) - pitch * 0.05) * U, 0.0, 1.0));
+  }
+  col = mix(col, mix(dotColor.rgb, hotColor.rgb, 0.35), bestLink);
+  col = mix(col, mix(dotColor.rgb, hotColor.rgb, bestHeat), bestCov);
+  fragColor = vec4(col, 1.0);
+}

package/skills/agentvfx/templates/brutal/lattice/pass0.frag

@@ -0,0 +1,29 @@
+// lattice pass 0: sound events, persistent in `lat` (row 0). Written fresh.
+// Attack is the frame of the onset: an event is stamped with this frame's TIME and full strength, and the
+// only thing that ever fades is the release applied in main.frag (exp(-age / release)). The one running
+// envelope here (highs) is max(raw, previous * exp(-dt / release)), so it also rises with no smoothing.
+// texel (0,0): x highs envelope, y bass of the previous frame, z kick count, w tear count
+// texels (2..5,0): kick slots   (birth time, origin x, origin y as frame fractions, strength)
+// texels (6..8,0): tear slots   (birth time, line y as a frame fraction, strength, side sign)
+void main() {
+  ivec2 px = ivec2(gl_FragCoord.xy);
+  vec4 st = texelFetch(lat, ivec2(0, 0), 0);
+  vec4 out0 = texelFetch(lat, px, 0);
+  float fall = exp(-TIMEDELTA / max(release, 0.004));
+  bool kick = AUDIO_BASS >= kickBass && AUDIO_BASS > 1.5 * st.y;
+  bool tear = AUDIO_ONSET > 0.5 && !kick;
+  float kn = st.z;
+  float tn = st.w;
+  if (px == ivec2(0, 0)) {
+    float hi = max(clamp((AUDIO_TREB - 0.8) * 0.2, 0.0, 1.0), st.x * fall);
+    out0 = vec4(hi, AUDIO_BASS, kn + (kick ? 1.0 : 0.0), tn + (tear ? 1.0 : 0.0));
+  } else if (px.y == 0 && kick && px.x == 2 + int(mod(kn, 4.0))) {
+    float ox = fract(0.31 + kn * 0.6180339 + SEED) * 0.78 + 0.11;
+    float oy = fract(0.67 + kn * 0.7548776 + SEED * 1.7) * 0.62 + 0.19;
+    out0 = vec4(TIME, ox, oy, clamp((AUDIO_BASS - 1.0) * 0.25, 0.35, 1.0));
+  } else if (px.y == 0 && tear && px.x == 6 + int(mod(tn, 3.0))) {
+    float yc = fract(0.13 + tn * 0.4142136 + SEED * 3.1) * 0.8 + 0.1;
+    out0 = vec4(TIME, yc, clamp(0.5 + AUDIO_FLUX * 0.6, 0.5, 1.0), mod(tn, 2.0) < 1.0 ? 1.0 : -1.0);
+  }
+  fragColor = out0;
+}

package/skills/agentvfx/templates/glitch/block-glitch/demo-mosaic.json

@@ -0,0 +1 @@
+{"version":1,"template":"block-glitch","preset":"block-glitch-mosaic","input":{"video":"test-media/clip-02.mp4"},"palette":"lilac-terminal","durationSec":4,"seed":32,"out":"block-glitch-mosaic"}

package/skills/agentvfx/templates/glitch/block-glitch/demo-onset.json

@@ -0,0 +1 @@
+{"version":1,"template":"block-glitch","preset":"block-glitch-onset","input":{"video":"test-media/clip-01.mp4","audio":"test-media/beat-132.mp3"},"palette":"blood-red","durationSec":4,"seed":34,"out":"block-glitch-onset"}

package/skills/agentvfx/templates/glitch/block-glitch/demo-static.json

@@ -0,0 +1 @@
+{"version":1,"template":"block-glitch","preset":"block-glitch-static","input":{"video":"test-media/clip-01.mp4"},"palette":"hazard-orange","durationSec":4,"seed":33,"out":"block-glitch-static"}

package/skills/agentvfx/templates/glitch/block-glitch/demo-tear.json

@@ -0,0 +1 @@
+{"version":1,"template":"block-glitch","preset":"block-glitch-tear","input":{"video":"test-media/clip-01.mp4"},"palette":"brutal-acid","durationSec":4,"seed":31,"out":"block-glitch-tear"}

package/skills/agentvfx/templates/glitch/block-glitch/fx.json

@@ -0,0 +1,54 @@
+{
+  "DESCRIPTION": "Seeded pixel-block tears over footage: displaced, channel-swapped, inverted, palette-solid, mosaic, static and streak blocks in bursts",
+  "CREDIT": "agentvfx",
+  "ISFVSN": "2",
+  "CATEGORIES": ["glitch"],
+  "INPUTS": [
+    { "NAME": "blockSize", "TYPE": "float", "MIN": 8, "MAX": 240, "DEFAULT": 56 },
+    { "NAME": "density", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 0.42 },
+    { "NAME": "idleDensity", "TYPE": "float", "MIN": 0, "MAX": 0.4, "DEFAULT": 0.05 },
+    { "NAME": "shiftAmt", "TYPE": "float", "MIN": 0, "MAX": 2, "DEFAULT": 1 },
+    { "NAME": "swapAmt", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 0.7 },
+    { "NAME": "invertAmt", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 0.3 },
+    { "NAME": "solidAmt", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 0.35 },
+    { "NAME": "mosaicAmt", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 0.5 },
+    { "NAME": "staticAmt", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 0.45 },
+    { "NAME": "stretchAmt", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 0.5 },
+    { "NAME": "fringe", "TYPE": "float", "MIN": 0, "MAX": 40, "DEFAULT": 8 },
+    { "NAME": "joltAmt", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 0.5 },
+    { "NAME": "lockMode", "TYPE": "long", "MIN": 0, "MAX": 2, "VALUES": [0, 1, 2], "LABELS": ["rate", "onset", "beat"], "DEFAULT": 0 },
+    { "NAME": "burstRate", "TYPE": "float", "MIN": 0.25, "MAX": 12, "DEFAULT": 2.6 },
+    { "NAME": "burstProb", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 0.85 },
+    { "NAME": "burstFrames", "TYPE": "long", "MIN": 1, "MAX": 60, "DEFAULT": 8 },
+    { "NAME": "holdFrames", "TYPE": "long", "MIN": 1, "MAX": 8, "DEFAULT": 2 },
+    { "NAME": "audioKick", "TYPE": "float", "MIN": 0, "MAX": 2, "DEFAULT": 0 },
+    { "NAME": "saturation", "TYPE": "float", "MIN": 0, "MAX": 3, "DEFAULT": 1.25 },
+    { "NAME": "punch", "TYPE": "float", "MIN": 0.5, "MAX": 3, "DEFAULT": 1.2 },
+    { "NAME": "grain", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 0.1 }
+  ],
+  "PASSES": [
+    { "TARGET": "counter", "PERSISTENT": true, "FLOAT": true },
+    {}
+  ],
+  "X_AGENTVFX": {
+    "id": "block-glitch",
+    "family": "glitch",
+    "input": "footage",
+    "spdx": "LicenseRef-agentvfx",
+    "flash": "strobe",
+    "fps": 30,
+    "palette": true,
+    "presets": {
+      "block-glitch-tear": {},
+      "block-glitch-mosaic": { "blockSize": 36, "density": 0.55, "mosaicAmt": 1, "shiftAmt": 0.3, "swapAmt": 0.2, "invertAmt": 0, "solidAmt": 0.6, "staticAmt": 0.3, "stretchAmt": 0.2, "burstRate": 3.4, "burstFrames": 9, "joltAmt": 0.1 },
+      "block-glitch-static": { "blockSize": 72, "density": 0.5, "staticAmt": 1, "solidAmt": 0.5, "shiftAmt": 0.5, "swapAmt": 0.2, "invertAmt": 0.1, "mosaicAmt": 0.2, "stretchAmt": 0.2, "burstRate": 2, "burstFrames": 10, "fringe": 4 },
+      "block-glitch-onset": { "lockMode": 1, "burstProb": 1, "burstFrames": 7, "density": 0.5, "idleDensity": 0.03, "solidAmt": 0.5, "invertAmt": 0.5 }
+    },
+    "audioBind": { "audioKick": "onset" },
+    "safeSubstitute": { "params": { "burstRate": 0.8, "burstFrames": 4, "holdFrames": 6, "invertAmt": 0, "solidAmt": 0, "staticAmt": 0, "joltAmt": 0, "density": 0.2, "grain": 0.04 } },
+    "credits": [
+      "PCG integer hash, M. E. O'Neill, https://www.pcg-random.org/",
+      "Datamosh / block-corruption look as in showreel glitch graphics (grammar only, no code)"
+    ]
+  }
+}

package/skills/agentvfx/templates/glitch/block-glitch/main.frag

@@ -0,0 +1,132 @@
+// block-glitch: seeded pixel-block tears. Three grid scales (blockSize, x2, x4) of random-aspect blocks;
+// each live block is displaced, channel-swapped, inverted, filled with a palette colour, mosaiced,
+// replaced by static cells or smeared into a streak. The pattern re-seeds every holdFrames frames inside
+// a burst and every burst gets its own seed, so no two bursts look alike. Bursts run on a rate, or
+// lock to audio onsets / beats through the persistent trigger counter of pass0.
+// Grammar reference: pixel-block tears and static in showreel graphics. Written fresh for agentvfx.
+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)); }
+
+struct Blk { bool on; vec4 r; vec2 lo; vec2 sz; };
+
+Blk blockAt(vec2 px, int lvl, uint seed, float dens, float u) {
+  uint ls = pcg(seed + uint(lvl) * 7919u + 17u);
+  float c = blockSize * u * exp2(float(lvl));
+  int shape = int(h1(ls + 1u) * 4.0);
+  vec2 sz = shape == 0 ? vec2(c) : (shape == 1 ? vec2(c * 2.0, c) : (shape == 2 ? vec2(c * 5.0, c * 0.5) : vec2(c * 10.0, c * 0.25)));
+  sz = max(sz, vec2(2.0 * u));
+  vec2 off = vec2(h1(ls + 2u), h1(ls + 3u)) * sz;
+  vec2 id = floor((px - off) / sz);
+  uint idh = pcg(uint(int(id.x) + 4096) + pcg(uint(int(id.y) + 4096) + ls));
+  Blk b;
+  b.r = vec4(h1(idh), h1(idh + 1u), h1(idh + 2u), h1(idh + 3u));
+  b.on = b.r.x < dens;
+  b.lo = id * sz + off;
+  b.sz = sz;
+  return b;
+}
+
+// footage sample at a pixel position (wraps like a corrupted scan line), with an R/B split of f pixels
+vec3 samp(vec2 pos, float f) {
+  vec2 uv0 = fract(pos / RENDERSIZE);
+  vec2 d = vec2(f, 0.0) / RENDERSIZE;
+  return vec3(texture(inputImage, fract(uv0 + d)).r, texture(inputImage, uv0).g, texture(inputImage, fract(uv0 - d)).b);
+}
+
+vec3 perm(vec3 c, int p) {
+  if (p == 0) return c.rbg;
+  if (p == 1) return c.grb;
+  if (p == 2) return c.gbr;
+  if (p == 3) return c.brg;
+  if (p == 4) return c.bgr;
+  return c.ggr;
+}
+
+void main() {
+  float u = RENDERSIZE.y / 1080.0;
+  float fps = 1.0 / TIMEDELTA;
+  uint sd = seedU();
+  vec2 px = vUv * RENDERSIZE;
+  vec4 cnt = texelFetch(counter, ivec2(0), 0);
+
+  // burst clock: free-running rate, or the trigger counter when locked to audio
+  float idx;
+  float age;
+  if (lockMode == 0) {
+    float ph = TIME * burstRate;
+    idx = floor(ph);
+    age = fract(ph) / max(burstRate, 0.001) * fps;
+  } else {
+    idx = lockMode == 1 ? cnt.r : cnt.g;
+    age = cnt.b;
+  }
+  bool seen = lockMode == 0 || idx > 0.5;
+  bool burst = seen && h2(uint(idx), sd) < burstProb && age < float(burstFrames);
+  float k = (burst ? 1.0 : 0.0) + audioKick;
+  bool live = k > 0.05;
+  uint stp = uint(floor(age / float(holdFrames)));
+  uint seed = live ? pcg(uint(idx) * 2246822519u + sd) + stp * 3266489917u : pcg(sd + 99u) + uint(floor(TIME * 8.0)) * 1597334677u;
+  float dens = live ? clamp(density * (0.5 + 0.5 * k), 0.0, 1.0) : idleDensity;
+
+  // whole-frame vertical jolt on some bursts
+  vec2 pos0 = px;
+  if (live && h2(seed, 5u) < joltAmt * 0.5) pos0.y += (h2(seed, 6u) - 0.5) * 0.3 * RENDERSIZE.y;
+
+  float fr = fringe * u;
+  Blk hit;
+  hit.on = false;
+  for (int l = 2; l >= 0; l--) {
+    Blk b = blockAt(px, l, seed, dens * (l == 0 ? 1.0 : (l == 1 ? 0.55 : 0.3)), u);
+    if (b.on) {
+      hit = b;
+      break;
+    }
+  }
+
+  vec3 col;
+  if (!hit.on) {
+    col = samp(pos0, live ? fr * 0.25 : 0.0);
+  } else {
+    float wTotal = shiftAmt + swapAmt + invertAmt + solidAmt + mosaicAmt + staticAmt + stretchAmt;
+    float pick = hit.r.y * max(wTotal, 1e-4);
+    float msz = min(hit.sz.x, hit.sz.y);
+    if (pick < shiftAmt || wTotal <= 0.0) {
+      float dx = (hit.r.z * 2.0 - 1.0) * (0.05 * RENDERSIZE.x + hit.sz.x * 1.2) * min(shiftAmt, 2.0);
+      float dy = (hit.r.w * 2.0 - 1.0) * hit.sz.y * 0.6 * step(0.55, fract(hit.r.z * 13.7));
+      col = samp(pos0 + vec2(dx, dy), fr);
+    } else if ((pick -= shiftAmt) < swapAmt) {
+      col = perm(samp(pos0 + vec2((hit.r.z - 0.5) * hit.sz.x, 0.0), fr * 0.5), int(hit.r.w * 6.0));
+    } else if ((pick -= swapAmt) < invertAmt) {
+      col = vec3(1.0) - min(samp(pos0, fr * 0.5), vec3(1.0));
+    } else if ((pick -= invertAmt) < solidAmt) {
+      int pi = int(floor(hit.r.z * float(max(PALETTE_COUNT, 1))));
+      col = PALETTE[pi] * (0.85 + 0.6 * luma(samp(pos0, 0.0)));
+    } else if ((pick -= solidAmt) < mosaicAmt) {
+      float mz = max(4.0 * u, msz / (3.0 + 5.0 * hit.r.w));
+      col = samp((floor(pos0 / mz) + 0.5) * mz, 0.0);
+    } else if ((pick -= mosaicAmt) < staticAmt) {
+      float sn = max(3.0 * u, msz / 5.0);
+      vec2 cid = floor(pos0 / sn);
+      float n = h2(uint(int(cid.x) + 4096) + uint(int(cid.y) + 4096) * 8209u, stp + seed);
+      col = n < 0.5 ? vec3(0.012) : vec3(0.8);
+      if (n > 0.9) col = PALETTE[int(floor(hit.r.z * float(max(PALETTE_COUNT, 1))))] * 1.3;
+    } else {
+      vec2 q = hit.r.w > 0.5 ? vec2(hit.lo.x + hit.r.z * 0.5 * hit.sz.x, pos0.y) : vec2(pos0.x, hit.lo.y + hit.r.z * 0.5 * hit.sz.y);
+      col = samp(q, fr);
+    }
+  }
+
+  float lm = luma(col);
+  col = mix(vec3(lm), col, saturation);
+  col = max((col - 0.18) * punch + 0.18, 0.0);
+  float g = h2(uint(px.x) + uint(px.y) * 4099u, uint(FRAMEINDEX) + sd);
+  col += grain * (g - 0.5) * (live ? 1.0 : 0.4);
+  fragColor = vec4(max(col, 0.0), 1.0);
+}

package/skills/agentvfx/templates/glitch/block-glitch/pass0.frag

@@ -0,0 +1,12 @@
+// block-glitch pass0: persistent trigger counter (one value everywhere, read with texelFetch at 0,0).
+//   r = onsets seen so far, g = beats seen so far,
+//   b = frames since the last trigger of the locked kind (lock 1 = onset, lock 2 = beat), saturating.
+// Frames are rendered strictly in order, so the counter is deterministic.
+void main() {
+  vec4 prev = FRAMEINDEX == 0 ? vec4(0.0, 0.0, 255.0, 0.0) : texelFetch(counter, ivec2(0), 0);
+  float onset = AUDIO_ONSET > 0.5 ? 1.0 : 0.0;
+  float beat = AUDIO_BEAT > 0.5 ? 1.0 : 0.0;
+  float trig = lockMode == 1 ? onset : (lockMode == 2 ? beat : 0.0);
+  float age = trig > 0.5 ? 0.0 : min(prev.b + 1.0, 255.0);
+  fragColor = vec4(prev.r + onset, prev.g + beat, age, 1.0);
+}

package/skills/agentvfx/templates/glitch/pixel-sort/NOTES.md

@@ -0,0 +1,13 @@
+# pixel-sort notes
+
+The pass files (`pass0.frag` .. `pass8.frag`, `main.frag`) are generated: edit `build-passes.mjs`, then run
+`node build-passes.mjs` in this folder. The engine wants one file per pass, so the shared GLSL is pasted into each.
+
+- Idea credit: pixel sorting as in ASDFPixelSort by Kim Asendorf. No code from it is used.
+- Approach: a GPU cannot run a per-row sort loop, so spans are found by run-length doubling (pass1..pass8, each
+  pass doubles the known run, spans are at most 256 cells) and the last pass ranks up to 32 strided samples of
+  its own span. A span of 32 cells or fewer is sorted exactly; longer spans get a quantile approximation
+  (monotonic in the sort key, `softness` interpolates between ranks).
+- Cells: `cellSize` groups pixels into square cells, which is what gives the chunky look at larger values.
+- Span cuts sit at multiples of 256 cells, shifted per row by `cutJitter` so the cuts never line up in a column.
+- Reading order: horizontal sorts left to right, vertical sorts top to bottom; `descend` flips it.