agentvfx 0.0.0-stage → 0.3.5

package/skills/agentvfx/templates/light/light-stage/fx.json

@@ -0,0 +1,29 @@
+{
+  "DESCRIPTION": "Black HUD ground: hairline brackets, crosshair and a dashed rule, with optional hot points for streaks and bloom",
+  "CREDIT": "agentvfx",
+  "ISFVSN": "2",
+  "CATEGORIES": ["light"],
+  "INPUTS": [
+    { "NAME": "hotPoints", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 0 },
+    { "NAME": "pointScale", "TYPE": "float", "MIN": 0.5, "MAX": 6, "DEFAULT": 1 },
+    { "NAME": "rule", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 1 }
+  ],
+  "PASSES": [ {} ],
+  "X_AGENTVFX": {
+    "id": "light-stage",
+    "family": "light",
+    "input": "generative",
+    "spdx": "Apache-2.0",
+    "flash": "none",
+    "fps": 30,
+    "palette": false,
+    "presets": {
+      "deck": { "hotPoints": 0, "rule": 1 },
+      "emitters": { "hotPoints": 1, "rule": 1 },
+      "cross": { "hotPoints": 0, "rule": 0 }
+    },
+    "credits": [
+      "Segment SDF for the hairlines, Inigo Quilez distance functions, https://iquilezles.org/articles/distfunctions2d/"
+    ]
+  }
+}

package/skills/agentvfx/templates/light/light-stage/main.frag

@@ -0,0 +1,56 @@
+// Near-black ground. Hairlines stay under the highlight knee. Hot points are the only emitters.
+
+float seg(vec2 p, vec2 a, vec2 b) {
+  vec2 pa = p - a;
+  vec2 ba = b - a;
+  float h = clamp(dot(pa, ba) / max(dot(ba, ba), 1e-5), 0.0, 1.0);
+  return length(pa - ba * h);
+}
+
+float stroke(float d) {
+  float w = 1.25 / max(RENDERSIZE.y, 1.0);
+  return 1.0 - smoothstep(w * 0.45, w * 1.35, d);
+}
+
+float bracket(vec2 p, vec2 c, vec2 arm) {
+  return min(seg(p, c, c + vec2(arm.x, 0.0)), seg(p, c, c + vec2(0.0, arm.y)));
+}
+
+void main() {
+  vec2 aspect = vec2(RENDERSIZE.x / max(RENDERSIZE.y, 1.0), 1.0);
+  vec2 p = (vUv - 0.5) * aspect + 0.5;
+  vec3 col = HAS_INPUT ? texture(inputImage, vUv).rgb : vec3(0.003);
+  float ink = 0.0;
+  float arm = 0.055;
+  ink = max(ink, stroke(bracket(p, vec2(0.06, 0.08), vec2(arm, arm))));
+  ink = max(ink, stroke(bracket(p, vec2(0.94, 0.08), vec2(-arm, arm))));
+  ink = max(ink, stroke(bracket(p, vec2(0.06, 0.92), vec2(arm, -arm))));
+  ink = max(ink, stroke(bracket(p, vec2(0.94, 0.92), vec2(-arm, -arm))));
+  ink = max(ink, stroke(seg(p, vec2(0.5, 0.22), vec2(0.5, 0.44))));
+  ink = max(ink, stroke(seg(p, vec2(0.5, 0.56), vec2(0.5, 0.78))));
+  ink = max(ink, stroke(seg(p, vec2(0.38, 0.5), vec2(0.46, 0.5))));
+  ink = max(ink, stroke(seg(p, vec2(0.54, 0.5), vec2(0.62, 0.5))));
+  ink = max(ink, stroke(seg(p, vec2(0.08, 0.2), vec2(0.08, 0.8))));
+  ink = max(ink, stroke(seg(p, vec2(0.92, 0.2), vec2(0.92, 0.8))));
+  ink = max(ink, stroke(seg(p, vec2(0.08, 0.2), vec2(0.22, 0.2))));
+  ink = max(ink, stroke(seg(p, vec2(0.08, 0.8), vec2(0.22, 0.8))));
+  ink = max(ink, stroke(seg(p, vec2(0.78, 0.2), vec2(0.92, 0.2))));
+  ink = max(ink, stroke(seg(p, vec2(0.78, 0.8), vec2(0.92, 0.8))));
+  if (rule > 0.5) {
+    for (int i = 0; i < 18; i++) {
+      float x0 = 0.18 + float(i) * 0.036;
+      ink = max(ink, stroke(seg(p, vec2(x0, 0.9), vec2(x0 + 0.016, 0.9))));
+    }
+  }
+  col = max(col, vec3(0.16) * ink);
+  if (hotPoints > 0.5) {
+    float d0 = length((vUv - vec2(0.32, 0.62)) * aspect);
+    float d1 = length((vUv - vec2(0.5, 0.42)) * aspect);
+    float d2 = length((vUv - vec2(0.7, 0.66)) * aspect);
+    float r0 = 0.005 * pointScale;
+    float r1 = 0.012 * pointScale;
+    float disk = max(1.0 - smoothstep(r0, r1, d0), max(1.0 - smoothstep(r0, r1, d1), 1.0 - smoothstep(r0, r1, d2)));
+    col = max(col, vec3(disk));
+  }
+  fragColor = vec4(col, 1.0);
+}

package/skills/agentvfx/templates/light/light-sweep/demo-hard-bar.json

@@ -0,0 +1,12 @@
+{
+  "version": 1,
+  "template": "light-sweep",
+  "preset": "hard-bar",
+  "stack": [{ "template": "light-stage", "preset": "deck" }],
+  "input": { "audio": "test-media/beat-132.mp3" },
+  "bindings": [{ "param": "audioKick", "feature": "onset", "gain": 1.4, "offset": 0, "attackMs": 8, "releaseMs": 160 }],
+  "palette": ["#0b0b0c", "#e9e9e4"],
+  "durationSec": 4,
+  "seed": 21,
+  "out": "light-sweep-hard-bar"
+}

package/skills/agentvfx/templates/light/light-sweep/demo-logo-sweep.json

@@ -0,0 +1,10 @@
+{
+  "version": 1,
+  "template": "light-sweep",
+  "preset": "logo-sweep",
+  "input": { "video": "test-media/clip-02.mp4" },
+  "palette": "brutal-acid",
+  "durationSec": 4,
+  "seed": 12,
+  "out": "light-sweep-logo-sweep"
+}

package/skills/agentvfx/templates/light/light-sweep/demo-onset.json

@@ -0,0 +1,11 @@
+{
+  "version": 1,
+  "template": "light-sweep",
+  "preset": "logo-sweep",
+  "input": { "video": "test-media/clip-02.mp4", "audio": "test-media/beat-132.mp3" },
+  "bindings": [{ "param": "audioKick", "feature": "onset", "gain": 1.2, "offset": 0, "attackMs": 10, "releaseMs": 180 }],
+  "palette": "brutal-acid",
+  "durationSec": 4,
+  "seed": 21,
+  "out": "light-sweep-onset"
+}

package/skills/agentvfx/templates/light/light-sweep/fx.json

@@ -0,0 +1,45 @@
+{
+  "DESCRIPTION": "A rotated HDR gleam band that crosses the frame, bloomed before the display fit",
+  "CREDIT": "agentvfx",
+  "ISFVSN": "2",
+  "CATEGORIES": ["light"],
+  "INPUTS": [
+    { "NAME": "sweepAngle", "TYPE": "float", "MIN": -1.5708, "MAX": 1.5708, "DEFAULT": 0.4 },
+    { "NAME": "sweepSpeed", "TYPE": "float", "MIN": 0.04, "MAX": 1.2, "DEFAULT": 0.3 },
+    { "NAME": "bandFrac", "TYPE": "float", "MIN": 0.003, "MAX": 0.08, "DEFAULT": 0.008 },
+    { "NAME": "gleamGain", "TYPE": "float", "MIN": 1, "MAX": 24, "DEFAULT": 14 },
+    { "NAME": "bloomFrac", "TYPE": "float", "MIN": 0.004, "MAX": 0.22, "DEFAULT": 0.018 },
+    { "NAME": "audioKick", "TYPE": "float", "MIN": 0, "MAX": 2, "DEFAULT": 0 },
+    { "NAME": "sweepMix", "TYPE": "float", "MIN": 0.2, "MAX": 2, "DEFAULT": 1.15 },
+    { "NAME": "paletteMix", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 0.75 },
+    { "NAME": "tint", "TYPE": "color", "DEFAULT": [1, 1, 1, 1] },
+    { "NAME": "toneMap", "TYPE": "long", "MIN": 0, "MAX": 1, "VALUES": [0, 1], "LABELS": ["AgX", "ACES"], "DEFAULT": 1 }
+  ],
+  "PASSES": [
+    { "TARGET": "gleam", "FLOAT": true },
+    { "TARGET": "glow", "FLOAT": true },
+    {}
+  ],
+  "X_AGENTVFX": {
+    "id": "light-sweep",
+    "family": "light",
+    "input": "either",
+    "spdx": "Apache-2.0",
+    "flash": "possible",
+    "fps": 30,
+    "palette": true,
+    "safeSubstitute": { "params": { "gleamGain": 2, "sweepSpeed": 0.08, "audioKick": 0 } },
+    "audioBind": { "audioKick": "onset" },
+    "presets": {
+      "logo-sweep": { "sweepAngle": 0.55, "sweepSpeed": 0.32, "bandFrac": 0.007, "gleamGain": 16, "bloomFrac": 0.016, "paletteMix": 0.9, "sweepMix": 1.15, "toneMap": 1 },
+      "diagonal-hit": { "sweepAngle": 0.95, "sweepSpeed": 0.5, "bandFrac": 0.01, "gleamGain": 18, "bloomFrac": 0.02, "paletteMix": 0.95, "sweepMix": 1.25, "toneMap": 1 },
+      "slow-sheen": { "sweepAngle": 0.15, "sweepSpeed": 0.12, "bandFrac": 0.012, "gleamGain": 8, "bloomFrac": 0.02, "paletteMix": 0.45, "sweepMix": 0.9, "toneMap": 1 },
+      "hard-bar": { "sweepAngle": 0, "sweepSpeed": 0.42, "bandFrac": 0.0035, "gleamGain": 20, "bloomFrac": 0.008, "paletteMix": 0, "sweepMix": 1.35, "tint": [1, 1, 1, 1], "toneMap": 1 }
+    },
+    "credits": [
+      "Soft analytic band (Gaussian across a rotated axis) with HDR gain, blurred before the display transform",
+      "ACES fitted tone map, Krzysztof Narkowicz, https://knarkowicz.wordpress.com/2016/01/06/aces-filmic-tone-mapping-curve/",
+      "AgX display fit, Troy Sobotka, https://github.com/sobotka/AgX"
+    ]
+  }
+}

package/skills/agentvfx/templates/light/light-sweep/main.frag

@@ -0,0 +1,29 @@
+// Sharp HDR band plus its bloom, over the picture, then AgX or ACES.
+
+vec3 acesFit(vec3 x) {
+  x = max(x, 0.0);
+  return clamp((x * (2.51 * x + 0.03)) / (x * (2.43 * x + 0.59) + 0.14), 0.0, 1.0);
+}
+
+vec3 agxFit(vec3 x) {
+  vec3 y = log2(max(x, 0.0) + 0.001);
+  vec3 u = clamp((y + 7.5) / 11.0, 0.0, 1.0);
+  vec3 s = u * u * (3.0 - 2.0 * u);
+  return clamp(s * 1.2 - 0.05, 0.0, 1.0);
+}
+
+vec3 addLight(vec3 scene, vec3 light) {
+  vec3 base = max(scene, 0.0);
+  vec3 hdr = base + max(light, 0.0);
+  vec3 curved = toneMap == 1 ? acesFit(hdr) : agxFit(hdr);
+  vec3 curvedBase = toneMap == 1 ? acesFit(base) : agxFit(base);
+  return base + max(curved - curvedBase, 0.0);
+}
+
+void main() {
+  vec3 scene = HAS_INPUT ? texture(inputImage, vUv).rgb : vec3(0.0);
+  vec3 gleamCol = texture(gleam, vUv).rgb;
+  vec3 glowCol = texture(glow, vUv).rgb;
+  vec3 light = gleamCol + max(glowCol - gleamCol, 0.0) * 0.45;
+  fragColor = vec4(addLight(scene, light * sweepMix), 1.0);
+}

package/skills/agentvfx/templates/light/light-sweep/pass0.frag

@@ -0,0 +1,17 @@
+// HDR gleam only. The picture is composited in the last pass, after this is bloomed.
+
+void main() {
+  vec2 aspect = vec2(RENDERSIZE.x / max(RENDERSIZE.y, 1.0), 1.0);
+  vec2 p = rot(-sweepAngle) * ((vUv - 0.5) * aspect);
+  float travel = fract(TIME * sweepSpeed + SEED * 0.17);
+  float pos = travel * 2.6 - 1.3;
+  float sigma = max(bandFrac * RENDERSIZE.y, 0.75);
+  float d = (p.x - pos) * RENDERSIZE.y;
+  float band = exp(-0.5 * (d * d) / (sigma * sigma));
+  band *= 1.0 - smoothstep(1.7 * sigma, 2.5 * sigma, abs(d));
+  float kick = 1.0 + clamp(audioKick, 0.0, 2.0);
+  vec3 accent = mix(tint.rgb, paletteRamp(0.92), paletteMix);
+  float core = smoothstep(0.45, 0.95, band);
+  float halo = band * (1.0 - core);
+  fragColor = vec4((vec3(core) + accent * halo) * gleamGain * kick, 1.0);
+}

package/skills/agentvfx/templates/light/light-sweep/pass1.frag

@@ -0,0 +1,15 @@
+// 3x3 tent of the gleam. Radius is a fraction of frame height.
+
+void main() {
+  vec2 t = vec2(max(bloomFrac * RENDERSIZE.y, 1.0)) / RENDERSIZE;
+  vec3 c = texture(gleam, vUv).rgb * 4.0;
+  c += texture(gleam, vUv + t * vec2(-1.0,  0.0)).rgb * 2.0;
+  c += texture(gleam, vUv + t * vec2( 1.0,  0.0)).rgb * 2.0;
+  c += texture(gleam, vUv + t * vec2( 0.0, -1.0)).rgb * 2.0;
+  c += texture(gleam, vUv + t * vec2( 0.0,  1.0)).rgb * 2.0;
+  c += texture(gleam, vUv + t * vec2(-1.0, -1.0)).rgb;
+  c += texture(gleam, vUv + t * vec2( 1.0, -1.0)).rgb;
+  c += texture(gleam, vUv + t * vec2(-1.0,  1.0)).rgb;
+  c += texture(gleam, vUv + t * vec2( 1.0,  1.0)).rgb;
+  fragColor = vec4(c / 16.0, 1.0);
+}

package/skills/agentvfx/templates/light/neon-saber/demo-hairline.json

@@ -0,0 +1,10 @@
+{
+  "version": 1,
+  "template": "light-stage",
+  "preset": "cross",
+  "stack": [{ "template": "neon-saber", "preset": "hairline" }],
+  "palette": ["#0b0b0c", "#c8ff00"],
+  "durationSec": 4,
+  "seed": 12,
+  "out": "neon-saber-hairline"
+}

package/skills/agentvfx/templates/light/neon-saber/demo-saber-laser.json

@@ -0,0 +1,10 @@
+{
+  "version": 1,
+  "template": "neon-saber",
+  "preset": "saber-laser",
+  "input": { "video": "test-media/clip-02.mp4" },
+  "palette": "brutal-acid",
+  "durationSec": 4,
+  "seed": 12,
+  "out": "neon-saber-saber-laser"
+}

package/skills/agentvfx/templates/light/neon-saber/fx.json

@@ -0,0 +1,48 @@
+{
+  "DESCRIPTION": "Neon saber: SDF core, Gaussian inner glow, Lorentzian outer glow, flicker, then a bloom pass",
+  "CREDIT": "agentvfx",
+  "ISFVSN": "2",
+  "CATEGORIES": ["light"],
+  "INPUTS": [
+    { "NAME": "saberA", "TYPE": "point2D", "DEFAULT": [0.12, 0.2] },
+    { "NAME": "saberB", "TYPE": "point2D", "DEFAULT": [0.88, 0.8] },
+    { "NAME": "coreFrac", "TYPE": "float", "MIN": 0.001, "MAX": 0.04, "DEFAULT": 0.006 },
+    { "NAME": "haloFrac", "TYPE": "float", "MIN": 0.008, "MAX": 0.14, "DEFAULT": 0.02 },
+    { "NAME": "flicker", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 0.62 },
+    { "NAME": "flickerHz", "TYPE": "float", "MIN": 0, "MAX": 18, "DEFAULT": 8 },
+    { "NAME": "flickerFloor", "TYPE": "float", "MIN": 0.15, "MAX": 1, "DEFAULT": 0.32 },
+    { "NAME": "twin", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 0 },
+    { "NAME": "trace", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 0 },
+    { "NAME": "saberGain", "TYPE": "float", "MIN": 1, "MAX": 20, "DEFAULT": 9 },
+    { "NAME": "paletteMix", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 0.85 },
+    { "NAME": "tint", "TYPE": "color", "DEFAULT": [0.7, 0.92, 1, 1] },
+    { "NAME": "toneMap", "TYPE": "long", "MIN": 0, "MAX": 1, "VALUES": [0, 1], "LABELS": ["AgX", "ACES"], "DEFAULT": 1 }
+  ],
+  "PASSES": [
+    { "TARGET": "beam", "FLOAT": true },
+    { "TARGET": "glow", "FLOAT": true },
+    {}
+  ],
+  "X_AGENTVFX": {
+    "id": "neon-saber",
+    "family": "light",
+    "input": "either",
+    "spdx": "Apache-2.0",
+    "flash": "possible",
+    "fps": 30,
+    "palette": true,
+    "safeSubstitute": { "params": { "flicker": 0 } },
+    "presets": {
+      "saber-laser": { "coreFrac": 0.0032, "haloFrac": 0.018, "flicker": 0.55, "flickerHz": 9, "saberGain": 14, "tint": [0.55, 0.95, 1, 1], "paletteMix": 0.95, "saberA": [0.08, 0.22], "saberB": [0.9, 0.78], "toneMap": 1 },
+      "neon-tube": { "coreFrac": 0.006, "haloFrac": 0.028, "flicker": 0.18, "flickerHz": 4, "saberGain": 9, "tint": [1, 0.08, 0.55, 1], "paletteMix": 0.35, "saberA": [0.1, 0.5], "saberB": [0.9, 0.5], "toneMap": 1 },
+      "twin-blade": { "twin": 1, "coreFrac": 0.003, "haloFrac": 0.016, "flicker": 0.4, "flickerHz": 6, "saberGain": 12, "paletteMix": 0.9, "toneMap": 1 },
+      "hairline": { "trace": 1, "coreFrac": 0.0014, "haloFrac": 0.008, "flicker": 0.12, "flickerHz": 3, "saberGain": 16, "paletteMix": 1, "toneMap": 1 }
+    },
+    "credits": [
+      "Segment SDF, Inigo Quilez distance functions, https://iquilezles.org/articles/distfunctions2d/",
+      "Gaussian core plus Lorentzian wings, the usual beam profile (narrow exp, wide 1/(1+x^2))",
+      "ACES fitted tone map, Krzysztof Narkowicz, https://knarkowicz.wordpress.com/2016/01/06/aces-filmic-tone-mapping-curve/",
+      "AgX display fit, Troy Sobotka, https://github.com/sobotka/AgX"
+    ]
+  }
+}

package/skills/agentvfx/templates/light/neon-saber/main.frag

@@ -0,0 +1,27 @@
+// Beam core on top of its bloom, over footage, then the display fit.
+
+vec3 acesFit(vec3 x) {
+  x = max(x, 0.0);
+  return clamp((x * (2.51 * x + 0.03)) / (x * (2.43 * x + 0.59) + 0.14), 0.0, 1.0);
+}
+
+vec3 agxFit(vec3 x) {
+  vec3 y = log2(max(x, 0.0) + 0.001);
+  vec3 u = clamp((y + 7.5) / 11.0, 0.0, 1.0);
+  vec3 s = u * u * (3.0 - 2.0 * u);
+  return clamp(s * 1.2 - 0.05, 0.0, 1.0);
+}
+
+vec3 addLight(vec3 scene, vec3 light) {
+  vec3 base = max(scene, 0.0);
+  vec3 hdr = base + max(light, 0.0);
+  vec3 curved = toneMap == 1 ? acesFit(hdr) : agxFit(hdr);
+  vec3 curvedBase = toneMap == 1 ? acesFit(base) : agxFit(base);
+  return base + max(curved - curvedBase, 0.0);
+}
+
+void main() {
+  vec3 scene = HAS_INPUT ? texture(inputImage, vUv).rgb : vec3(0.0);
+  vec3 light = texture(beam, vUv).rgb + texture(glow, vUv).rgb * 0.22;
+  fragColor = vec4(addLight(scene, light), 1.0);
+}

package/skills/agentvfx/templates/light/neon-saber/pass0.frag

@@ -0,0 +1,46 @@
+// HDR beam. Flicker is one value for the whole blade, seeded by time, not per-pixel noise.
+
+float sdSegment(vec2 p, vec2 a, vec2 b) {
+  vec2 pa = p - a;
+  vec2 ba = b - a;
+  float h = clamp(dot(pa, ba) / max(dot(ba, ba), 1e-6), 0.0, 1.0);
+  return length(pa - ba * h);
+}
+
+float bracket(vec2 p, vec2 c, vec2 arm) {
+  return min(sdSegment(p, c, c + vec2(arm.x, 0.0)), sdSegment(p, c, c + vec2(0.0, arm.y)));
+}
+
+void main() {
+  vec2 aspect = vec2(RENDERSIZE.x / max(RENDERSIZE.y, 1.0), 1.0);
+  vec2 p = vUv * aspect;
+  float d;
+  if (trace > 0.5) {
+    float a = 0.07;
+    d = bracket(p, vec2(0.07, 0.1) * aspect, vec2(a, a) * aspect);
+    d = min(d, bracket(p, vec2(0.93, 0.1) * aspect, vec2(-a, a) * aspect));
+    d = min(d, bracket(p, vec2(0.07, 0.9) * aspect, vec2(a, -a) * aspect));
+    d = min(d, bracket(p, vec2(0.93, 0.9) * aspect, vec2(-a, -a) * aspect));
+    d = min(d, sdSegment(p, vec2(0.2, 0.5) * aspect, vec2(0.44, 0.5) * aspect));
+    d = min(d, sdSegment(p, vec2(0.56, 0.5) * aspect, vec2(0.8, 0.5) * aspect));
+    d = min(d, sdSegment(p, vec2(0.5, 0.24) * aspect, vec2(0.5, 0.44) * aspect));
+    d = min(d, sdSegment(p, vec2(0.5, 0.56) * aspect, vec2(0.5, 0.76) * aspect));
+  } else {
+    d = sdSegment(p, saberA * aspect, saberB * aspect);
+    float dTwin = sdSegment(p, (saberA + vec2(0.0, 0.07)) * aspect, (saberB + vec2(0.0, 0.07)) * aspect);
+    d = min(d, mix(10.0, dTwin, twin));
+  }
+  d *= RENDERSIZE.y;
+  float coreW = max(coreFrac * RENDERSIZE.y, 0.75);
+  float haloW = max(haloFrac * RENDERSIZE.y, coreW * 2.0);
+  float core = exp(-0.5 * (d * d) / (coreW * coreW));
+  float wing = 1.0 / (1.0 + (d / haloW) * (d / haloW));
+  wing *= 1.0 - smoothstep(haloW * 1.8, haloW * 3.0, d);
+  float bucket = floor(TIME * flickerHz + SEED * 19.0);
+  float n = hash12(vec2(bucket, 2.3));
+  float fl = mix(1.0, mix(flickerFloor, 1.0, n), clamp(flicker, 0.0, 1.0));
+  vec3 accent = mix(tint.rgb, paletteRamp(0.92), paletteMix);
+  vec3 hdr = vec3(core) * saberGain * fl * 2.4;
+  hdr += accent * wing * saberGain * fl * 0.45;
+  fragColor = vec4(hdr, 1.0);
+}

package/skills/agentvfx/templates/light/neon-saber/pass1.frag

@@ -0,0 +1,15 @@
+// Cheap bloom of the beam so the Lorentzian wing blooms again instead of stopping hard.
+
+void main() {
+  vec2 t = vec2(max(RENDERSIZE.y * 0.006, 1.0)) / RENDERSIZE;
+  vec3 a = texture(beam, vUv).rgb * 4.0;
+  a += texture(beam, vUv + t * vec2(-1.0,  0.0)).rgb * 2.0;
+  a += texture(beam, vUv + t * vec2( 1.0,  0.0)).rgb * 2.0;
+  a += texture(beam, vUv + t * vec2( 0.0, -1.0)).rgb * 2.0;
+  a += texture(beam, vUv + t * vec2( 0.0,  1.0)).rgb * 2.0;
+  a += texture(beam, vUv + t * vec2(-1.0, -1.0)).rgb;
+  a += texture(beam, vUv + t * vec2( 1.0, -1.0)).rgb;
+  a += texture(beam, vUv + t * vec2(-1.0,  1.0)).rgb;
+  a += texture(beam, vUv + t * vec2( 1.0,  1.0)).rgb;
+  fragColor = vec4(a / 16.0, 1.0);
+}

package/skills/agentvfx/templates/psychedelic/echo-flow/demo-trail.json

@@ -0,0 +1 @@
+{"version":1,"template":"echo-flow","preset":"echo-trail","input":{"video":"test-media/clip-01.mp4"},"durationSec":4,"seed":11,"out":"echo-trail"}

package/skills/agentvfx/templates/psychedelic/echo-flow/fx.json

@@ -0,0 +1,38 @@
+{
+  "DESCRIPTION": "Echo flow: Horn-Schunck optical flow advecting a max-blend trail buffer with flow-scaled chroma split",
+  "CREDIT": "agentvfx",
+  "ISFVSN": "2",
+  "CATEGORIES": ["psychedelic"],
+  "INPUTS": [
+    { "NAME": "flowScale", "TYPE": "float", "MIN": 0, "MAX": 8, "DEFAULT": 2.5 },
+    { "NAME": "flowSmooth", "TYPE": "float", "MIN": 0.001, "MAX": 0.5, "DEFAULT": 0.05 },
+    { "NAME": "decay", "TYPE": "float", "MIN": 0.5, "MAX": 0.999, "DEFAULT": 0.94 },
+    { "NAME": "chromaSplit", "TYPE": "float", "MIN": 0, "MAX": 20, "DEFAULT": 6 },
+    { "NAME": "saturation", "TYPE": "float", "MIN": 0, "MAX": 3, "DEFAULT": 1.7 },
+    { "NAME": "blend", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 1 }
+  ],
+  "PASSES": [
+    { "TARGET": "f1", "FLOAT": true },
+    { "TARGET": "f2", "FLOAT": true },
+    { "TARGET": "trail", "PERSISTENT": true, "FLOAT": true },
+    { "TARGET": "prev", "PERSISTENT": true, "FLOAT": true },
+    {}
+  ],
+  "X_AGENTVFX": {
+    "id": "echo-flow",
+    "family": "psychedelic",
+    "input": "footage",
+    "spdx": "Apache-2.0",
+    "flash": "none",
+    "fps": 30,
+    "palette": true,
+    "presets": {
+      "echo-trail": { "decay": 0.96, "flowScale": 2.5, "chromaSplit": 6, "flowSmooth": 0.05 },
+      "echo-chroma": { "decay": 0.9, "flowScale": 3.5, "chromaSplit": 14, "flowSmooth": 0.03, "saturation": 1.9 },
+      "echo-tight": { "decay": 0.86, "flowScale": 1.5, "chromaSplit": 4, "flowSmooth": 0.12 }
+    },
+    "credits": [
+      "Horn-Schunck optical flow (Jacobi iteration), https://en.wikipedia.org/wiki/Horn%E2%80%93Schunck_method"
+    ]
+  }
+}

package/skills/agentvfx/templates/psychedelic/echo-flow/main.frag

@@ -0,0 +1,19 @@
+// echo-flow main: chroma split along the flow direction over the trail
+// buffer, then saturate and blend. (No builtin mix() calls.)
+void main() {
+  vec2 texel = vec2(1.0) / vec2(textureSize(trail, 0));
+  vec2 f = texture(f2, vUv).rg;
+  float mag = length(f);
+  vec2 dir = f / (mag + 1e-4);
+  float m = clamp(mag * chromaSplit * 0.15, 0.0, 12.0);
+  vec2 o = dir * m * texel;
+  vec3 col = vec3(
+    texture(trail, vUv + o).r,
+    texture(trail, vUv).g,
+    texture(trail, vUv - o).b);
+  float cl = luma(col);
+  col = vec3(cl) + (col - vec3(cl)) * clamp(saturation, 0.0, 3.0);
+  vec3 src = texture(inputImage, vUv).rgb;
+  float b = clamp(blend, 0.0, 1.0);
+  fragColor = vec4(src + (col - src) * b, 1.0);
+}

package/skills/agentvfx/templates/psychedelic/echo-flow/pass0.frag

@@ -0,0 +1,16 @@
+// echo-flow f1: Horn-Schunck Jacobi iteration 1 from a zero start.
+// Ix, Iy from Sobel on current luma; It against the previous frame.
+void main() {
+  vec2 texel = vec2(1.0) / vec2(textureSize(inputImage, 0));
+  float lC = luma(texture(inputImage, vUv).rgb);
+  float lx1 = luma(texture(inputImage, vUv - vec2(texel.x, 0.0)).rgb);
+  float lx2 = luma(texture(inputImage, vUv + vec2(texel.x, 0.0)).rgb);
+  float ly1 = luma(texture(inputImage, vUv - vec2(0.0, texel.y)).rgb);
+  float ly2 = luma(texture(inputImage, vUv + vec2(0.0, texel.y)).rgb);
+  float ix = lx2 - lx1;
+  float iy = ly2 - ly1;
+  float it = lC - texture(prev, vUv).r;
+  float denom = ix * ix + iy * iy + flowSmooth * flowSmooth;
+  float corr = it / max(denom, 1e-6);
+  fragColor = vec4(-ix * corr, -iy * corr, ix, iy);
+}

package/skills/agentvfx/templates/psychedelic/echo-flow/pass1.frag

@@ -0,0 +1,20 @@
+// echo-flow f2: Horn-Schunck Jacobi iteration 2, warm-started from f1.
+// Neighbourhood-averaged flow plus fresh local Sobel gradients.
+void main() {
+  vec2 texel = vec2(1.0) / vec2(textureSize(f1, 0));
+  vec2 ub = vec2(0.0);
+  for (int i = -1; i <= 1; i++) {
+    for (int j = -1; j <= 1; j++) {
+      ub = ub + texture(f1, vUv + vec2(float(i), float(j)) * texel).rg;
+    }
+  }
+  ub = ub / 9.0;
+  vec2 px = vec2(1.0) / vec2(textureSize(inputImage, 0));
+  float lC = luma(texture(inputImage, vUv).rgb);
+  float ix = luma(texture(inputImage, vUv + vec2(px.x, 0.0)).rgb) - luma(texture(inputImage, vUv - vec2(px.x, 0.0)).rgb);
+  float iy = luma(texture(inputImage, vUv + vec2(0.0, px.y)).rgb) - luma(texture(inputImage, vUv - vec2(0.0, px.y)).rgb);
+  float it = lC - texture(prev, vUv).r;
+  float denom = ix * ix + iy * iy + flowSmooth * flowSmooth;
+  float corr = (ix * ub.x + iy * ub.y + it) / max(denom, 1e-6);
+  fragColor = vec4(ub - vec2(ix, iy) * corr, 0.0, 1.0);
+}

package/skills/agentvfx/templates/psychedelic/echo-flow/pass2.frag

@@ -0,0 +1,11 @@
+// echo-flow trail: advect the previous output along the flow field and
+// max-blend with the lightly punched current frame (persistent trails).
+void main() {
+  vec2 texel = vec2(1.0) / vec2(textureSize(trail, 0));
+  vec2 f = texture(f2, vUv).rg * flowScale;
+  vec3 old = texture(trail, vUv - f * texel).rgb;
+  vec3 cur = texture(inputImage, vUv).rgb;
+  float cl = luma(cur);
+  cur = vec3(cl) + (cur - vec3(cl)) * 1.3;
+  fragColor = vec4(max(old * decay, cur), 1.0);
+}

package/skills/agentvfx/templates/psychedelic/echo-flow/pass3.frag

@@ -0,0 +1,4 @@
+// echo-flow prev: stash this frame's luma for next frame's It term.
+void main() {
+  fragColor = vec4(luma(texture(inputImage, vUv).rgb), 0.0, 0.0, 1.0);
+}

package/skills/agentvfx/templates/psychedelic/hologram-scan/demo-cyan.json

@@ -0,0 +1 @@
+{"version":1,"template":"hologram-scan","preset":"holo-cyan","input":{"video":"test-media/clip-01.mp4"},"durationSec":4,"seed":11,"out":"hologram-cyan"}

package/skills/agentvfx/templates/psychedelic/hologram-scan/fx.json

@@ -0,0 +1,36 @@
+{
+  "DESCRIPTION": "Hologram scan: Sobel edge neon over dimmed footage with scanlines, sweep bar, wobble, fringe, flicker and grain",
+  "CREDIT": "agentvfx",
+  "ISFVSN": "2",
+  "CATEGORIES": ["psychedelic"],
+  "INPUTS": [
+    { "NAME": "neon", "TYPE": "color", "DEFAULT": [0.1, 0.9, 1, 1] },
+    { "NAME": "edgeGain", "TYPE": "float", "MIN": 0, "MAX": 8, "DEFAULT": 3.5 },
+    { "NAME": "fillLevel", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 0.45 },
+    { "NAME": "scanScale", "TYPE": "float", "MIN": 10, "MAX": 400, "DEFAULT": 130 },
+    { "NAME": "sweepSpeed", "TYPE": "float", "MIN": 0, "MAX": 3, "DEFAULT": 0.8 },
+    { "NAME": "wobble", "TYPE": "float", "MIN": 0, "MAX": 0.05, "DEFAULT": 0.012 },
+    { "NAME": "fringe", "TYPE": "float", "MIN": 0, "MAX": 12, "DEFAULT": 2.5 },
+    { "NAME": "flicker", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 0.5 },
+    { "NAME": "grain", "TYPE": "float", "MIN": 0, "MAX": 0.5, "DEFAULT": 0.12 },
+    { "NAME": "blend", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 1 }
+  ],
+  "X_AGENTVFX": {
+    "id": "hologram-scan",
+    "family": "psychedelic",
+    "input": "footage",
+    "spdx": "Apache-2.0",
+    "flash": "possible",
+    "fps": 30,
+    "palette": true,
+    "presets": {
+      "holo-cyan": { "neon": [0.1, 0.9, 1, 1], "edgeGain": 3.5, "flicker": 0.5, "fringe": 2.5 },
+      "holo-magenta": { "neon": [1, 0.15, 0.85, 1], "edgeGain": 4, "fillLevel": 0.4, "flicker": 0.6, "sweepSpeed": 1.1 },
+      "holo-storm": { "neon": [0.6, 1, 0.3, 1], "edgeGain": 5, "fillLevel": 0.5, "flicker": 0.85, "wobble": 0.025, "grain": 0.2 }
+    },
+    "safeSubstitute": { "params": { "flicker": 0, "grain": 0.05 } },
+    "credits": [
+      "Sobel operator, https://en.wikipedia.org/wiki/Sobel_operator"
+    ]
+  }
+}

package/skills/agentvfx/templates/psychedelic/hologram-scan/main.frag

@@ -0,0 +1,30 @@
+// hologram-scan: edge neon over a dimmed fill, scanlines, a travelling
+// sweep bar, wobble, RGB fringe, per-frame flicker and grain.
+// (No builtin mix() calls: `blend` is an input name.)
+void main() {
+  vec2 texel = vec2(1.0) / vec2(textureSize(inputImage, 0));
+  vec2 wuv = vUv + vec2(sin(vUv.y * 40.0 + TIME * 3.0) * wobble, 0.0);
+  vec2 cuv = clamp(wuv, 0.0, 1.0);
+  float lx1 = luma(texture(inputImage, cuv - vec2(texel.x, 0.0)).rgb);
+  float lx2 = luma(texture(inputImage, cuv + vec2(texel.x, 0.0)).rgb);
+  float ly1 = luma(texture(inputImage, cuv - vec2(0.0, texel.y)).rgb);
+  float ly2 = luma(texture(inputImage, cuv + vec2(0.0, texel.y)).rgb);
+  float edge = clamp(length(vec2(lx2 - lx1, ly2 - ly1)) * edgeGain, 0.0, 1.5);
+  vec2 fuv = cuv + vec2(fringe * texel.x, 0.0);
+  vec2 buv = cuv - vec2(fringe * texel.x, 0.0);
+  vec3 src = vec3(
+    texture(inputImage, clamp(fuv, 0.0, 1.0)).r,
+    texture(inputImage, cuv).g,
+    texture(inputImage, clamp(buv, 0.0, 1.0)).b);
+  vec3 fill = src * fillLevel;
+  float scan = 0.72 + 0.28 * sin(vUv.y * RENDERSIZE.y * scanScale * 0.02418);
+  float sweepY = fract(TIME * sweepSpeed * 0.25);
+  float bar = exp(-pow((vUv.y - sweepY) * 9.0, 2.0));
+  float fl = 1.0 - flicker * hash12(vec2(float(FRAMEINDEX), 7.0));
+  vec3 col = fill * scan + neon.rgb * edge * (0.9 + 1.3 * bar);
+  col = col * (0.55 + 0.45 * bar + 0.6 * edge) * fl + neon.rgb * bar * 0.25 * fl;
+  col = col + vec3(hash12(vUv * RENDERSIZE + fract(TIME) * 13.0) - 0.5) * grain;
+  float m = clamp(blend, 0.0, 1.0);
+  vec3 base = texture(inputImage, vUv).rgb;
+  fragColor = vec4(base + (max(col, 0.0) - base) * m, 1.0);
+}

package/skills/agentvfx/templates/psychedelic/kaleido-fold/demo-six.json

@@ -0,0 +1 @@
+{"version":1,"template":"kaleido-fold","preset":"kaleido-six","input":{"video":"test-media/clip-01.mp4"},"durationSec":4,"seed":11,"out":"kaleido-six"}

package/skills/agentvfx/templates/psychedelic/kaleido-fold/fx.json

@@ -0,0 +1,37 @@
+{
+  "DESCRIPTION": "Kaleido fold: mirror-folded footage through a spinning segment kaleidoscope with zooming feedback trails",
+  "CREDIT": "agentvfx",
+  "ISFVSN": "2",
+  "CATEGORIES": ["psychedelic"],
+  "INPUTS": [
+    { "NAME": "segments", "TYPE": "long", "MIN": 2, "MAX": 16, "DEFAULT": 8 },
+    { "NAME": "zoom", "TYPE": "float", "MIN": 1, "MAX": 1.1, "DEFAULT": 1.01 },
+    { "NAME": "spin", "TYPE": "float", "MIN": -2, "MAX": 2, "DEFAULT": 0.3 },
+    { "NAME": "hueSpin", "TYPE": "float", "MIN": 0, "MAX": 10, "DEFAULT": 2 },
+    { "NAME": "feedback", "TYPE": "float", "MIN": 0, "MAX": 0.99, "DEFAULT": 0.9 },
+    { "NAME": "saturation", "TYPE": "float", "MIN": 0, "MAX": 3, "DEFAULT": 1.7 },
+    { "NAME": "blend", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 1 }
+  ],
+  "PASSES": [
+    { "TARGET": "fold", "PERSISTENT": true, "FLOAT": true },
+    {}
+  ],
+  "X_AGENTVFX": {
+    "id": "kaleido-fold",
+    "family": "psychedelic",
+    "input": "either",
+    "spdx": "Apache-2.0",
+    "flash": "none",
+    "fps": 30,
+    "palette": true,
+    "presets": {
+      "kaleido-six": { "segments": 6, "zoom": 1.012, "spin": 0.35, "hueSpin": 2, "feedback": 0.78, "saturation": 1.9 },
+      "kaleido-twelve": { "segments": 12, "zoom": 1.02, "spin": 0.6, "hueSpin": 3.5, "feedback": 0.93, "saturation": 1.9 },
+      "kaleido-mirror": { "segments": 8, "zoom": 1.005, "spin": 0.15, "hueSpin": 1, "feedback": 0.86, "saturation": 1.6 }
+    },
+    "credits": [
+      "iq cosine palette, https://iquilezles.org/articles/palettes/",
+      "fbm, The Book of Shaders ch.13, https://thebookofshaders.com/13/"
+    ]
+  }
+}