agentvfx 0.0.0-stage → 0.3.5

package/skills/agentvfx/templates/light/bloom-glow/pass1.frag

@@ -0,0 +1,50 @@
+// First downsample, level 0. Karis weight 1/(1+luma) on every tap, then renormalise.
+// Spacing is a fraction of frame height so the halo scales with resolution.
+
+vec2 bloomTexel(float level) {
+  float last = max(bloomRadius * RENDERSIZE.y / 3.0, 4.0);
+  float s = level <= 0.0 ? 1.0 : max(pow(last, level / 4.0), 1.0);
+  if (spread > 0.5) {
+    float unit = max(bloomRadius * RENDERSIZE.y / 48.0, 1.0);
+    s = level <= 0.0 ? 1.0 : unit * pow(2.0, level - 1.0);
+  }
+  return vec2(s) / RENDERSIZE;
+}
+
+vec4 ktap(vec2 uv) {
+  vec3 c = max(texture(hi, uv).rgb, 0.0);
+  // Karis tames fireflies. A one-pixel probe is the signal, not a firefly.
+  float w = probeDot > 0.5 ? 1.0 : 1.0 / (1.0 + luma(c));
+  return vec4(c * w, w);
+}
+
+void main() {
+  if (probeDot > 0.5) {
+    vec3 acc = vec3(0.0);
+    float wsum = 0.0;
+    for (int j = -16; j <= 16; j++) {
+      float x = float(j) / 8.0;
+      float w = exp(-0.5 * x * x);
+      acc += w * max(texture(hi, vUv + vec2(float(j), 0.0) / RENDERSIZE).rgb, 0.0);
+      wsum += w;
+    }
+    fragColor = vec4(acc / max(wsum, 1e-4), 1.0);
+    return;
+  }
+  vec2 t = bloomTexel(0.0);
+  vec2 uv = vUv;
+  vec4 a = ktap(uv) * 4.0;
+  a += ktap(uv + t * vec2(-1.0, -1.0));
+  a += ktap(uv + t * vec2( 1.0, -1.0));
+  a += ktap(uv + t * vec2(-1.0,  1.0));
+  a += ktap(uv + t * vec2( 1.0,  1.0));
+  a += ktap(uv + t * vec2(-2.0,  0.0));
+  a += ktap(uv + t * vec2( 2.0,  0.0));
+  a += ktap(uv + t * vec2( 0.0, -2.0));
+  a += ktap(uv + t * vec2( 0.0,  2.0));
+  a += ktap(uv + t * vec2(-2.0, -2.0)) * 0.5;
+  a += ktap(uv + t * vec2( 2.0, -2.0)) * 0.5;
+  a += ktap(uv + t * vec2(-2.0,  2.0)) * 0.5;
+  a += ktap(uv + t * vec2( 2.0,  2.0)) * 0.5;
+  fragColor = vec4(a.rgb / max(a.a, 1e-4), 1.0);
+}

package/skills/agentvfx/templates/light/bloom-glow/pass2.frag

@@ -0,0 +1,44 @@
+// Downsample level 1 from b0. No Karis after the first level.
+
+vec2 bloomTexel(float level) {
+  float last = max(bloomRadius * RENDERSIZE.y / 3.0, 4.0);
+  float s = level <= 0.0 ? 1.0 : max(pow(last, level / 4.0), 1.0);
+  if (spread > 0.5) {
+    float unit = max(bloomRadius * RENDERSIZE.y / 48.0, 1.0);
+    s = level <= 0.0 ? 1.0 : unit * pow(2.0, level - 1.0);
+  }
+  return vec2(s) / RENDERSIZE;
+}
+
+vec3 tap(vec2 uv) { return max(texture(b0, uv).rgb, 0.0); }
+
+void main() {
+  if (probeDot > 0.5) {
+    vec3 acc = vec3(0.0);
+    float wsum = 0.0;
+    for (int j = -16; j <= 16; j++) {
+      float x = float(j) / 8.0;
+      float w = exp(-0.5 * x * x);
+      acc += w * max(texture(b0, vUv + vec2(0.0, float(j)) / RENDERSIZE).rgb, 0.0);
+      wsum += w;
+    }
+    fragColor = vec4(acc / max(wsum, 1e-4), 1.0);
+    return;
+  }
+  vec2 t = bloomTexel(1.0);
+  vec2 uv = vUv;
+  vec3 a = tap(uv) * 4.0;
+  a += tap(uv + t * vec2(-1.0, -1.0));
+  a += tap(uv + t * vec2( 1.0, -1.0));
+  a += tap(uv + t * vec2(-1.0,  1.0));
+  a += tap(uv + t * vec2( 1.0,  1.0));
+  a += tap(uv + t * vec2(-2.0,  0.0));
+  a += tap(uv + t * vec2( 2.0,  0.0));
+  a += tap(uv + t * vec2( 0.0, -2.0));
+  a += tap(uv + t * vec2( 0.0,  2.0));
+  a += tap(uv + t * vec2(-2.0, -2.0)) * 0.5;
+  a += tap(uv + t * vec2( 2.0, -2.0)) * 0.5;
+  a += tap(uv + t * vec2(-2.0,  2.0)) * 0.5;
+  a += tap(uv + t * vec2( 2.0,  2.0)) * 0.5;
+  fragColor = vec4(a / 14.0, 1.0);
+}

package/skills/agentvfx/templates/light/bloom-glow/pass3.frag

@@ -0,0 +1,32 @@
+// Downsample level 2 from b1.
+
+vec2 bloomTexel(float level) {
+  float last = max(bloomRadius * RENDERSIZE.y / 3.0, 4.0);
+  float s = level <= 0.0 ? 1.0 : max(pow(last, level / 4.0), 1.0);
+  if (spread > 0.5) {
+    float unit = max(bloomRadius * RENDERSIZE.y / 48.0, 1.0);
+    s = level <= 0.0 ? 1.0 : unit * pow(2.0, level - 1.0);
+  }
+  return vec2(s) / RENDERSIZE;
+}
+
+vec3 tap(vec2 uv) { return max(texture(b1, uv).rgb, 0.0); }
+
+void main() {
+  vec2 t = bloomTexel(2.0);
+  vec2 uv = vUv;
+  vec3 a = tap(uv) * 4.0;
+  a += tap(uv + t * vec2(-1.0, -1.0));
+  a += tap(uv + t * vec2( 1.0, -1.0));
+  a += tap(uv + t * vec2(-1.0,  1.0));
+  a += tap(uv + t * vec2( 1.0,  1.0));
+  a += tap(uv + t * vec2(-2.0,  0.0));
+  a += tap(uv + t * vec2( 2.0,  0.0));
+  a += tap(uv + t * vec2( 0.0, -2.0));
+  a += tap(uv + t * vec2( 0.0,  2.0));
+  a += tap(uv + t * vec2(-2.0, -2.0)) * 0.5;
+  a += tap(uv + t * vec2( 2.0, -2.0)) * 0.5;
+  a += tap(uv + t * vec2(-2.0,  2.0)) * 0.5;
+  a += tap(uv + t * vec2( 2.0,  2.0)) * 0.5;
+  fragColor = vec4(a / 14.0, 1.0);
+}

package/skills/agentvfx/templates/light/bloom-glow/pass4.frag

@@ -0,0 +1,48 @@
+// Downsample level 3 from b2.
+
+vec2 bloomTexel(float level) {
+  float last = max(bloomRadius * RENDERSIZE.y / 3.0, 4.0);
+  float s = level <= 0.0 ? 1.0 : max(pow(last, level / 4.0), 1.0);
+  if (spread > 0.5) {
+    float unit = max(bloomRadius * RENDERSIZE.y / 48.0, 1.0);
+    s = level <= 0.0 ? 1.0 : unit * pow(2.0, level - 1.0);
+  }
+  return vec2(s) / RENDERSIZE;
+}
+
+vec3 tap(vec2 uv) { return max(texture(b2, uv).rgb, 0.0); }
+
+void main() {
+  // Dense gaussian, so a one-pixel probe has a continuous falloff. The pyramid steps
+  // are wider than one pixel once the radius is a fraction of the frame.
+  if (probeDot > 0.5) {
+    float sigma = max(bloomRadius, 0.08) * RENDERSIZE.y * 0.5;
+    float stepPx = max(sigma / 48.0, 1.0);
+    vec3 acc = vec3(0.0);
+    float wsum = 0.0;
+    for (int j = -48; j <= 48; j++) {
+      float x = float(j) / 48.0;
+      float w = exp(-0.5 * x * x);
+      acc += w * max(texture(b1, vUv + vec2(float(j) * stepPx, 0.0) / RENDERSIZE).rgb, 0.0);
+      wsum += w;
+    }
+    fragColor = vec4(acc / max(wsum, 1e-4), 1.0);
+    return;
+  }
+  vec2 t = bloomTexel(3.0);
+  vec2 uv = vUv;
+  vec3 a = tap(uv) * 4.0;
+  a += tap(uv + t * vec2(-1.0, -1.0));
+  a += tap(uv + t * vec2( 1.0, -1.0));
+  a += tap(uv + t * vec2(-1.0,  1.0));
+  a += tap(uv + t * vec2( 1.0,  1.0));
+  a += tap(uv + t * vec2(-2.0,  0.0));
+  a += tap(uv + t * vec2( 2.0,  0.0));
+  a += tap(uv + t * vec2( 0.0, -2.0));
+  a += tap(uv + t * vec2( 0.0,  2.0));
+  a += tap(uv + t * vec2(-2.0, -2.0)) * 0.5;
+  a += tap(uv + t * vec2( 2.0, -2.0)) * 0.5;
+  a += tap(uv + t * vec2(-2.0,  2.0)) * 0.5;
+  a += tap(uv + t * vec2( 2.0,  2.0)) * 0.5;
+  fragColor = vec4(a / 14.0, 1.0);
+}

package/skills/agentvfx/templates/light/bloom-glow/pass5.frag

@@ -0,0 +1,46 @@
+// Downsample level 4 from b3. Widest tap; the deep-glow tail lives here.
+
+vec2 bloomTexel(float level) {
+  float last = max(bloomRadius * RENDERSIZE.y / 3.0, 4.0);
+  float s = level <= 0.0 ? 1.0 : max(pow(last, level / 4.0), 1.0);
+  if (spread > 0.5) {
+    float unit = max(bloomRadius * RENDERSIZE.y / 48.0, 1.0);
+    s = level <= 0.0 ? 1.0 : unit * pow(2.0, level - 1.0);
+  }
+  return vec2(s) / RENDERSIZE;
+}
+
+vec3 tap(vec2 uv) { return max(texture(b3, uv).rgb, 0.0); }
+
+void main() {
+  if (probeDot > 0.5) {
+    float sigma = max(bloomRadius, 0.08) * RENDERSIZE.y * 0.5;
+    float stepPx = max(sigma / 48.0, 1.0);
+    vec3 acc = vec3(0.0);
+    float wsum = 0.0;
+    for (int j = -48; j <= 48; j++) {
+      float x = float(j) / 48.0;
+      float w = exp(-0.5 * x * x);
+      acc += w * max(texture(b3, vUv + vec2(0.0, float(j) * stepPx) / RENDERSIZE).rgb, 0.0);
+      wsum += w;
+    }
+    fragColor = vec4(acc / max(wsum, 1e-4), 1.0);
+    return;
+  }
+  vec2 t = bloomTexel(4.0);
+  vec2 uv = vUv;
+  vec3 a = tap(uv) * 4.0;
+  a += tap(uv + t * vec2(-1.0, -1.0));
+  a += tap(uv + t * vec2( 1.0, -1.0));
+  a += tap(uv + t * vec2(-1.0,  1.0));
+  a += tap(uv + t * vec2( 1.0,  1.0));
+  a += tap(uv + t * vec2(-2.0,  0.0));
+  a += tap(uv + t * vec2( 2.0,  0.0));
+  a += tap(uv + t * vec2( 0.0, -2.0));
+  a += tap(uv + t * vec2( 0.0,  2.0));
+  a += tap(uv + t * vec2(-2.0, -2.0)) * 0.5;
+  a += tap(uv + t * vec2( 2.0, -2.0)) * 0.5;
+  a += tap(uv + t * vec2(-2.0,  2.0)) * 0.5;
+  a += tap(uv + t * vec2( 2.0,  2.0)) * 0.5;
+  fragColor = vec4(a / 14.0, 1.0);
+}

package/skills/agentvfx/templates/light/god-rays/demo-golden-hour.json

@@ -0,0 +1,10 @@
+{
+  "version": 1,
+  "template": "god-rays",
+  "preset": "golden-hour",
+  "input": { "video": "test-media/clip-02.mp4" },
+  "palette": "hazard-orange",
+  "durationSec": 4,
+  "seed": 12,
+  "out": "god-rays-golden-hour"
+}

package/skills/agentvfx/templates/light/god-rays/demo-point-lamp.json

@@ -0,0 +1,10 @@
+{
+  "version": 1,
+  "template": "light-stage",
+  "preset": "emitters",
+  "stack": [{ "template": "god-rays", "preset": "point-lamp" }],
+  "palette": ["#0b0b0c", "#ff3c00"],
+  "durationSec": 4,
+  "seed": 12,
+  "out": "god-rays-point-lamp"
+}

package/skills/agentvfx/templates/light/god-rays/fx.json

@@ -0,0 +1,39 @@
+{
+  "DESCRIPTION": "Volumetric god rays: radial accumulation from a sun disk and a luminance mask on the footage",
+  "CREDIT": "agentvfx",
+  "ISFVSN": "2",
+  "CATEGORIES": ["light"],
+  "INPUTS": [
+    { "NAME": "lightPos", "TYPE": "point2D", "DEFAULT": [0.74, 0.8] },
+    { "NAME": "sunSize", "TYPE": "float", "MIN": 0.01, "MAX": 0.2, "DEFAULT": 0.022 },
+    { "NAME": "rayDecay", "TYPE": "float", "MIN": 0.9, "MAX": 0.99, "DEFAULT": 0.955 },
+    { "NAME": "rayWeight", "TYPE": "float", "MIN": 0.05, "MAX": 1, "DEFAULT": 0.7 },
+    { "NAME": "rayExposure", "TYPE": "float", "MIN": 0.1, "MAX": 6, "DEFAULT": 2.4 },
+    { "NAME": "rayDensity", "TYPE": "float", "MIN": 0.2, "MAX": 2, "DEFAULT": 0.85 },
+    { "NAME": "rayThreshold", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 0.72 },
+    { "NAME": "paletteMix", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 0.45 },
+    { "NAME": "tint", "TYPE": "color", "DEFAULT": [1, 0.62, 0.22, 1] },
+    { "NAME": "toneMap", "TYPE": "long", "MIN": 0, "MAX": 1, "VALUES": [0, 1], "LABELS": ["AgX", "ACES"], "DEFAULT": 1 }
+  ],
+  "X_AGENTVFX": {
+    "id": "god-rays",
+    "family": "light",
+    "input": "either",
+    "spdx": "Apache-2.0",
+    "flash": "none",
+    "fps": 30,
+    "palette": true,
+    "presets": {
+      "golden-hour": { "lightPos": [0.78, 0.82], "tint": [1, 0.55, 0.12, 1], "paletteMix": 0.85, "rayExposure": 2.6, "rayDecay": 0.952, "sunSize": 0.02, "rayThreshold": 0.74, "rayWeight": 0.75, "toneMap": 1 },
+      "occult-hard": { "lightPos": [0.5, 0.72], "sunSize": 0.014, "rayExposure": 3.1, "rayDecay": 0.948, "rayThreshold": 0.78, "tint": [1, 0.95, 0.88, 1], "paletteMix": 0.15, "rayDensity": 1.05, "toneMap": 1 },
+      "side-wash": { "lightPos": [0.08, 0.7], "sunSize": 0.028, "rayDensity": 1.05, "rayExposure": 2.2, "rayThreshold": 0.7, "tint": [0.55, 0.78, 1, 1], "paletteMix": 0.55, "rayDecay": 0.95, "toneMap": 1 },
+      "point-lamp": { "lightPos": [0.5, 0.42], "sunSize": 0.02, "rayExposure": 1.15, "rayDecay": 0.94, "rayDensity": 0.85, "rayThreshold": 0.84, "rayWeight": 0.65, "paletteMix": 0.55, "toneMap": 1 }
+    },
+    "credits": [
+      "Radial light accumulation, GPU Gems 3 chapter 13, https://developer.nvidia.com/gpugems/gpugems3/part-ii-light-and-shadows/chapter-13-volumetric-light-scattering-post-process",
+      "Footage emitter is a luminance mask, the same idea as a Shine/volumetric-light mask",
+      "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/god-rays/main.frag

@@ -0,0 +1,54 @@
+// 64-tap radial march toward lightPos. Decay follows GPU Gems 3 ch.13.
+// The sum is scaled by (1 - decay) so a frame of emitters cannot flood the picture.
+// Sample count stays fixed; rayDensity shortens or lengthens the march.
+
+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);
+}
+
+float emitter(vec2 uv) {
+  vec2 aspect = vec2(RENDERSIZE.x / max(RENDERSIZE.y, 1.0), 1.0);
+  float disk = 1.0 - smoothstep(sunSize * 0.4, sunSize, length((uv - lightPos) * aspect));
+  float srcL = HAS_INPUT ? luma(texture(inputImage, clamp(uv, 0.0, 1.0)).rgb) : 0.0;
+  float kneeW = 0.06;
+  float soft = clamp(srcL - rayThreshold + kneeW, 0.0, 2.0 * kneeW);
+  soft = (soft * soft) / (4.0 * kneeW);
+  float mask = clamp(max(soft, srcL - rayThreshold) / max(1.0 - rayThreshold, 1e-3), 0.0, 1.0);
+  return max(mask, disk);
+}
+
+void main() {
+  vec2 delta = (vUv - lightPos) * (rayDensity / 64.0);
+  vec2 coord = vUv;
+  float illum = 1.0;
+  float acc = 0.0;
+  for (int i = 0; i < 64; i++) {
+    coord -= delta;
+    acc += emitter(coord) * illum * rayWeight;
+    illum *= rayDecay;
+  }
+  acc *= (1.0 - rayDecay);
+  vec2 aspect = vec2(RENDERSIZE.x / max(RENDERSIZE.y, 1.0), 1.0);
+  float dist = length((vUv - lightPos) * aspect);
+  float near = exp(-dist * 22.0);
+  vec3 accent = mix(tint.rgb, paletteRamp(0.92), paletteMix);
+  vec3 light = mix(accent, vec3(1.0), near) * acc * rayExposure;
+  vec3 scene = HAS_INPUT ? texture(inputImage, vUv).rgb : vec3(0.0);
+  fragColor = vec4(addLight(scene, light), 1.0);
+}

package/skills/agentvfx/templates/light/lens-flare/demo-clip01-bar.json

@@ -0,0 +1,11 @@
+{
+  "version": 1,
+  "template": "lens-flare",
+  "preset": "eye-bar",
+  "params": { "plateExposure": 0.32, "flareCenter": [0.5, 0.62] },
+  "input": { "video": "test-media/clip-01.mp4" },
+  "palette": ["#0b0b0c", "#ff3c00"],
+  "durationSec": 4,
+  "seed": 12,
+  "out": "lens-flare-clip01-bar"
+}

package/skills/agentvfx/templates/light/lens-flare/demo-eye-bar.json

@@ -0,0 +1,10 @@
+{
+  "version": 1,
+  "template": "light-stage",
+  "preset": "deck",
+  "stack": [{ "template": "lens-flare", "preset": "eye-bar" }],
+  "palette": ["#0b0b0c", "#ff3c00"],
+  "durationSec": 4,
+  "seed": 12,
+  "out": "lens-flare-eye-bar"
+}

package/skills/agentvfx/templates/light/lens-flare/demo-sun-ghosts.json

@@ -0,0 +1,10 @@
+{
+  "version": 1,
+  "template": "lens-flare",
+  "preset": "sun-ghosts",
+  "input": { "video": "test-media/clip-02.mp4" },
+  "palette": "hazard-orange",
+  "durationSec": 4,
+  "seed": 12,
+  "out": "lens-flare-sun-ghosts"
+}

package/skills/agentvfx/templates/light/lens-flare/fx.json

@@ -0,0 +1,49 @@
+{
+  "DESCRIPTION": "Screen-space lens flare: threshold, ghosts along the flare axis, halo, chromatic offset, starburst",
+  "CREDIT": "agentvfx",
+  "ISFVSN": "2",
+  "CATEGORIES": ["light"],
+  "INPUTS": [
+    { "NAME": "threshold", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 0.74 },
+    { "NAME": "knee", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 0.12 },
+    { "NAME": "flareCenter", "TYPE": "point2D", "DEFAULT": [0.7, 0.76] },
+    { "NAME": "spark", "TYPE": "float", "MIN": 0, "MAX": 4, "DEFAULT": 1.8 },
+    { "NAME": "ghostGain", "TYPE": "float", "MIN": 0, "MAX": 4, "DEFAULT": 1.9 },
+    { "NAME": "chromaAmt", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 0.5 },
+    { "NAME": "haloRadius", "TYPE": "float", "MIN": 0.15, "MAX": 0.8, "DEFAULT": 0.45 },
+    { "NAME": "haloGain", "TYPE": "float", "MIN": 0, "MAX": 3, "DEFAULT": 0.9 },
+    { "NAME": "spikeCount", "TYPE": "long", "MIN": 2, "MAX": 12, "DEFAULT": 8 },
+    { "NAME": "spikePower", "TYPE": "float", "MIN": 2, "MAX": 40, "DEFAULT": 18 },
+    { "NAME": "burstGain", "TYPE": "float", "MIN": 0, "MAX": 4, "DEFAULT": 1.5 },
+    { "NAME": "flareMix", "TYPE": "float", "MIN": 0, "MAX": 3, "DEFAULT": 1.6 },
+    { "NAME": "eyeBar", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 0 },
+    { "NAME": "plateExposure", "TYPE": "float", "MIN": 0.25, "MAX": 1.5, "DEFAULT": 1 },
+    { "NAME": "paletteMix", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 0.4 },
+    { "NAME": "tint", "TYPE": "color", "DEFAULT": [1, 0.82, 0.45, 1] },
+    { "NAME": "toneMap", "TYPE": "long", "MIN": 0, "MAX": 1, "VALUES": [0, 1], "LABELS": ["AgX", "ACES"], "DEFAULT": 1 }
+  ],
+  "PASSES": [
+    { "TARGET": "flareSrc", "FLOAT": true },
+    {}
+  ],
+  "X_AGENTVFX": {
+    "id": "lens-flare",
+    "family": "light",
+    "input": "either",
+    "spdx": "Apache-2.0",
+    "flash": "none",
+    "fps": 30,
+    "palette": true,
+    "presets": {
+      "sun-ghosts": { "ghostGain": 2.4, "chromaAmt": 0.85, "haloRadius": 0.28, "haloGain": 1.3, "burstGain": 1.6, "spark": 2.2, "spikePower": 26, "threshold": 0.74, "knee": 0.1, "flareMix": 1.35, "toneMap": 1, "paletteMix": 0.8 },
+      "starburst": { "ghostGain": 0.45, "burstGain": 2.6, "spikeCount": 8, "spikePower": 32, "spark": 2.4, "haloGain": 0.35, "haloRadius": 0.22, "flareMix": 1.4, "threshold": 0.76, "knee": 0.1, "toneMap": 1 },
+      "chroma-string": { "chromaAmt": 1, "ghostGain": 2.8, "haloGain": 0.4, "burstGain": 0.7, "threshold": 0.72, "knee": 0.1, "spark": 1.6, "flareMix": 1.3, "paletteMix": 0.85, "toneMap": 1 },
+      "eye-bar": { "eyeBar": 1, "flareCenter": [0.5, 0.46], "ghostGain": 0.15, "haloGain": 0.15, "burstGain": 0.35, "spark": 0.4, "chromaAmt": 0.85, "flareMix": 1.5, "paletteMix": 1, "threshold": 0.8, "toneMap": 1 }
+    },
+    "credits": [
+      "Screen-space pseudo lens flare: ghosts, halo, chromatic fringe, starburst. John Chapman, https://john-chapman.github.io/2017/11/05/pseudo-lens-flare.html",
+      "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/lens-flare/main.frag

@@ -0,0 +1,86 @@
+// Ghosts are sharp polygons along the flare axis, with a chromatic rim.
+// The picture is not resampled into a veil. A thin ring and a hard starburst sit on the source.
+
+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);
+}
+
+float polyDist(vec2 p, float sides) {
+  float a = atan(p.y, p.x);
+  float s = 6.2831853 / sides;
+  return cos(floor(0.5 + a / s) * s - a) * length(p);
+}
+
+float shell(float d, float rad) {
+  float w = max(1.75 / max(RENDERSIZE.y, 1.0), rad * 0.07);
+  return smoothstep(rad - w, rad - w * 0.3, d) * (1.0 - smoothstep(rad, rad + w * 0.55, d));
+}
+
+void main() {
+  vec2 aspect = vec2(RENDERSIZE.x / max(RENDERSIZE.y, 1.0), 1.0);
+  vec2 from = vUv - flareCenter;
+  float src = luma(texture(flareSrc, flareCenter).rgb);
+  vec3 accent = mix(tint.rgb, paletteRamp(0.92), paletteMix);
+  vec2 axis = vec2(0.5) - flareCenter;
+  vec3 ghosts = vec3(0.0);
+  for (int i = 0; i < 5; i++) {
+    float t = mix(-0.9, 1.55, float(i) / 4.0);
+    vec2 gc = flareCenter + axis * t;
+    float sides = float(3 + i);
+    float rad = 0.016 + 0.007 * float(i);
+    float spin = 0.55 * float(i);
+    float cs = cos(spin);
+    float sn = sin(spin);
+    vec2 p = (vUv - gc) * aspect;
+    p = vec2(cs * p.x - sn * p.y, sn * p.x + cs * p.y);
+    vec2 shift = vec2(chromaAmt * 0.012 * float(i + 1), 0.0);
+    float edge = shell(polyDist(p, sides), rad);
+    vec3 fringe = vec3(
+      shell(polyDist(p + shift, sides), rad),
+      edge * 0.2,
+      shell(polyDist(p - shift, sides), rad)
+    );
+    ghosts += vec3(edge) * 1.15 + accent * fringe;
+  }
+  ghosts *= ghostGain * clamp(src, 0.35, 2.2) * 0.2;
+
+  float dist = length(from * aspect);
+  float halo = exp(-pow((dist - haloRadius) / 0.011, 2.0));
+  vec3 haloCol = accent * halo * haloGain * clamp(src, 0.2, 2.0);
+
+  float ang = atan(from.y, from.x);
+  float spikes = pow(abs(sin(ang * float(spikeCount) * 0.5)), spikePower);
+  float burst = spikes * exp(-dist * 11.0);
+  vec3 burstCol = mix(accent, vec3(1.0), 0.65) * burst * burstGain * clamp(src, 0.2, 2.0);
+
+  float core = 1.0 - smoothstep(0.0, 0.008, dist);
+  vec3 light = ghosts + haloCol + burstCol + vec3(core) * (1.2 + spark);
+  if (eyeBar > 0.5) {
+    float y = (vUv.y - flareCenter.y) * RENDERSIZE.y;
+    float xMask = smoothstep(0.03, 0.08, vUv.x) * (1.0 - smoothstep(0.92, 0.97, vUv.x));
+    float bar = exp(-0.5 * y * y / 220.0) * xMask;
+    float hi = exp(-0.5 * (y - 22.0) * (y - 22.0) / 36.0) * xMask;
+    float lo = exp(-0.5 * (y + 22.0) * (y + 22.0) / 36.0) * xMask;
+    float core = smoothstep(0.1, 0.5, bar);
+    light = vec3(core) * 9.0 + accent * (hi + lo) * (1.0 - core) * 2.6;
+  }
+  vec3 scene = HAS_INPUT ? texture(inputImage, vUv).rgb : vec3(0.0);
+  scene *= plateExposure;
+  fragColor = vec4(addLight(scene, light * flareMix), 1.0);
+}

package/skills/agentvfx/templates/light/lens-flare/pass0.frag

@@ -0,0 +1,24 @@
+// Threshold the picture and plant a spark at flareCenter so the ghosts have a source.
+
+vec3 softKnee(vec3 c) {
+  float br = luma(max(c, 0.0));
+  float kneeW = max(threshold * knee, 1e-4);
+  float soft = clamp(br - threshold + kneeW, 0.0, 2.0 * kneeW);
+  soft = (soft * soft) / (4.0 * kneeW);
+  float contrib = max(soft, br - threshold);
+  return max(c, 0.0) * max(contrib / max(br, 1e-4), 0.0);
+}
+
+void main() {
+  vec2 px = 1.5 / RENDERSIZE;
+  vec3 acc = vec3(0.0);
+  acc += softKnee(HAS_INPUT ? texture(inputImage, vUv).rgb : vec3(0.0)) * 4.0;
+  acc += softKnee(HAS_INPUT ? texture(inputImage, vUv + px * vec2(1.0, 0.0)).rgb : vec3(0.0));
+  acc += softKnee(HAS_INPUT ? texture(inputImage, vUv + px * vec2(-1.0, 0.0)).rgb : vec3(0.0));
+  acc += softKnee(HAS_INPUT ? texture(inputImage, vUv + px * vec2(0.0, 1.0)).rgb : vec3(0.0));
+  acc += softKnee(HAS_INPUT ? texture(inputImage, vUv + px * vec2(0.0, -1.0)).rgb : vec3(0.0));
+  acc /= 8.0;
+  vec2 aspect = vec2(RENDERSIZE.x / max(RENDERSIZE.y, 1.0), 1.0);
+  float disk = 1.0 - smoothstep(0.004, 0.012, length((vUv - flareCenter) * aspect));
+  fragColor = vec4(acc + vec3(disk * spark), 1.0);
+}

package/skills/agentvfx/templates/light/light-leak/demo-slit.json

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

package/skills/agentvfx/templates/light/light-leak/demo-vintage-burn.json

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

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

@@ -0,0 +1,40 @@
+{
+  "DESCRIPTION": "Edge-anchored film burn: a coloured ramp warped by slow noise, with a swell and a fade",
+  "CREDIT": "agentvfx",
+  "ISFVSN": "2",
+  "CATEGORIES": ["light"],
+  "INPUTS": [
+    { "NAME": "edgeAnchor", "TYPE": "long", "MIN": 0, "MAX": 4, "VALUES": [0, 1, 2, 3, 4], "LABELS": ["left", "right", "bottom", "top", "corner"], "DEFAULT": 0 },
+    { "NAME": "edgeTight", "TYPE": "float", "MIN": 0.6, "MAX": 12, "DEFAULT": 5.5 },
+    { "NAME": "leakWidth", "TYPE": "float", "MIN": 0.15, "MAX": 1.6, "DEFAULT": 0.85 },
+    { "NAME": "warp", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 0.55 },
+    { "NAME": "noiseScale", "TYPE": "float", "MIN": 0.4, "MAX": 6, "DEFAULT": 2.4 },
+    { "NAME": "swellHz", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 0.22 },
+    { "NAME": "swellAmt", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 0.4 },
+    { "NAME": "leakGain", "TYPE": "float", "MIN": 0.4, "MAX": 8, "DEFAULT": 5.5 },
+    { "NAME": "paletteMix", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 0.35 },
+    { "NAME": "tint", "TYPE": "color", "DEFAULT": [1, 0.32, 0.06, 1] },
+    { "NAME": "toneMap", "TYPE": "long", "MIN": 0, "MAX": 1, "VALUES": [0, 1], "LABELS": ["AgX", "ACES"], "DEFAULT": 1 }
+  ],
+  "X_AGENTVFX": {
+    "id": "light-leak",
+    "family": "light",
+    "input": "either",
+    "spdx": "Apache-2.0",
+    "flash": "possible",
+    "fps": 30,
+    "palette": true,
+    "safeSubstitute": { "params": { "swellAmt": 0, "leakGain": 1.1 } },
+    "presets": {
+      "vintage-burn": { "edgeAnchor": 0, "tint": [1, 0.42, 0.04, 1], "paletteMix": 0.9, "leakGain": 6.2, "edgeTight": 5.6, "warp": 0.28, "leakWidth": 0.9, "swellAmt": 0.35, "toneMap": 1 },
+      "edge-magenta": { "edgeAnchor": 1, "tint": [1, 0.05, 0.45, 1], "paletteMix": 0.35, "leakGain": 5.4, "edgeTight": 6.2, "warp": 0.22, "leakWidth": 0.8, "toneMap": 1 },
+      "corner-flood": { "edgeAnchor": 4, "leakGain": 5.8, "leakWidth": 0.85, "tint": [1, 0.62, 0.12, 1], "paletteMix": 0.8, "warp": 0.3, "edgeTight": 4.8, "noiseScale": 1.6, "toneMap": 1 },
+      "slit": { "edgeAnchor": 3, "edgeTight": 8.5, "leakWidth": 0.78, "warp": 0.12, "leakGain": 4.2, "swellAmt": 0.2, "paletteMix": 1, "noiseScale": 1.2, "toneMap": 1 }
+    },
+    "credits": [
+      "Edge-anchored light leak warped by noise, the construction described by Jonas Wagner, https://29a.ch/2012/12/16/webgl-light-leaks",
+      "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-leak/main.frag

@@ -0,0 +1,46 @@
+// Edge-anchored burn. The ramp hits zero before the far side of the frame, so it cannot fog the plate.
+
+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);
+}
+
+float anchored(vec2 uv) {
+  if (edgeAnchor == 1) return 1.0 - uv.x;
+  if (edgeAnchor == 2) return uv.y;
+  if (edgeAnchor == 3) return 1.0 - uv.y;
+  if (edgeAnchor == 4) return length(uv);
+  return uv.x;
+}
+
+void main() {
+  vec2 q = vUv * noiseScale;
+  float n = fbm(q + vec2(TIME * 0.04, SEED * 3.0), 4);
+  float n2 = fbm(q * 1.7 + vec2(4.2, -TIME * 0.03), 3);
+  vec2 bent = vUv + (vec2(n, n2) - 0.5) * warp * 0.22;
+  float d = anchored(clamp(bent, 0.0, 1.0));
+  float x = clamp(1.0 - d * edgeTight, 0.0, 1.0) * leakWidth;
+  x = clamp(x, 0.0, 1.0);
+  float core = smoothstep(0.62, 0.95, x);
+  float halo = smoothstep(0.02, 0.5, x) * (1.0 - core);
+  float swell = 1.0 - swellAmt + swellAmt * (0.55 + 0.45 * sin(TIME * swellHz * 6.28318));
+  vec3 accent = mix(tint.rgb, paletteRamp(0.92), paletteMix);
+  vec3 leak = (vec3(core) * 1.35 + accent * halo) * leakGain * swell;
+  vec3 scene = HAS_INPUT ? texture(inputImage, vUv).rgb : vec3(0.0);
+  fragColor = vec4(addLight(scene, leak), 1.0);
+}