agentvfx 0.0.0-stage → 0.3.5

package/skills/agentvfx/templates/brutal/collage/_src/649-scene-sticker.glsl

@@ -0,0 +1,72 @@
+// Scene 12 (variant 2, rot 1), sticker-slap: a black field and a pile of cream stickers. Every beat a new sticker slaps on with an
+// overshoot (scale 1.35, 1.12, 0.97, 1); the pile keeps the last eight. Every onset flips one sticker over to a 1-bit dither of the plate.
+// Stickers are filled Impact words, outlined Impact words, round Georgia tags, dither plates and small mustard pills (mustard stays under
+// about 15 percent); two rows of Impact text run along the top, filled and outlined in turn. Palette: ground (black), ink (cream),
+// accent (mustard), tintA (lilac). Text set 13: r the sticker words (centred anchors), g the two rows.
+vec2 stRot(vec2 p, float a) { float cs = cos(a); float sn = sin(a); return vec2(cs * p.x + sn * p.y, -sn * p.x + cs * p.y); }
+
+vec4 stSticker(vec2 q, vec2 c, float j, float cut, float age, float A, float flipJ) {
+  vec2 h1 = hash22(vec2(j, 1.7));
+  vec2 h2 = hash22(vec2(j, 8.3));
+  vec2 pos = vec2(0.22 + (A - 0.44) * h1.x, 0.22 + 0.56 * h1.y);
+  float rot = (h2.x - 0.5) * 0.6;
+  float sz = 0.17 + 0.1 * h2.y;
+  int type = int(floor(hash12(vec2(j, 4.4)) * 5.0));
+  if (j == flipJ) { type = 3; }
+  float sc = 1.0;
+  if (j == cut) { sc = age < 0.5 ? 1.35 : (age < 1.5 ? 1.12 : (age < 2.5 ? 0.97 : 1.0)); }
+  vec2 p = stRot(c - pos, rot) / sc;
+  vec3 cream = inkColor.rgb;
+  vec3 blk = groundColor.rgb;
+  vec2 hs = vec2(sz, sz * 0.62);
+  float cov = 0.0;
+  vec3 f = cream;
+  float k = RENDERSIZE.y;
+  if (type == 2) {
+    cov = scAA(length(p) - sz * 0.8);
+    f = tintA.rgb;
+    float m = crisp(sheetC(vec2(0.25 * RENDERSIZE.x, 0.774 * k) + p * (0.34 * k / (sz * 0.8)), 0), 1.0);
+    f = mix(f, blk, m);
+    f = mix(f, blk, scLine(length(p) - sz * 0.68, 1.5));
+  } else if (type == 4) {
+    vec2 hm = vec2(sz * 0.55, sz * 0.3);
+    cov = scAA(sdBox(p, -hm, hm) - 0.03);
+    f = accentColor.rgb;
+    f = mix(f, blk, step(0.5, fract(p.x * 14.0)) * 0.9 * step(abs(p.y), hm.y * 0.5));
+  } else {
+    cov = scAA(sdBox(p, -hs, hs) - 0.03);
+    if (type == 0 || type == 1) {
+      vec2 anchor = type == 0 ? vec2(0.25 * RENDERSIZE.x, 0.252 * k) : vec2(0.75 * RENDERSIZE.x, 0.252 * k);
+      float m = crisp(sheetC(anchor + p * (0.34 * k / sz), 0), 1.0);
+      f = mix(f, blk, m);
+    }
+    if (type == 3) {
+      float px = scPx();
+      vec2 pix = floor(q / px);
+      float l = scTone((pix + 0.5) * px, (pos - hs) * scU, (pos + hs) * scU, 1.6, 0.05);
+      f = mix(blk, cream, step(scBayer(pix), l));
+    }
+  }
+  return vec4(f, cov);
+}
+
+void sceneSticker(vec2 q, vec2 S, vec4 clk, inout vec3 col) {
+  vec2 c = q / scU;
+  float A = S.x / S.y;
+  float beat = floor(clk.x);
+  float cut = floor(beat * 0.5);
+  float age = mod(beat, 2.0) < 0.5 ? float(FRAMEINDEX) - clk.y : 9.0;
+  vec3 cream = inkColor.rgb;
+  col = groundColor.rgb;
+  // two rows of Impact text, filled then outlined
+  float rows = scSheet(q, 2);
+  col = mix(col, cream, rows * step(c.y, 0.17));
+  float flipJ = cut - mod(floor(clk.z / 3.0), 4.0);
+  for (int i = 7; i >= 0; i--) {
+    float j = cut - float(i);
+    vec4 s = stSticker(q, c, j, cut, age, A, flipJ);
+    col = mix(col, s.rgb, s.a);
+  }
+  col = mix(col, cream, max(scPlus(c, vec2(0.06, 0.94), 0.02), scPlus(c, vec2(A - 0.06, 0.94), 0.02)));
+  col = mix(col, cream, numTxt(q, vec2(A - 0.2, 0.9) * scU, scCell() * 2.0, mod(cut, 100.0), 2));
+}

package/skills/agentvfx/templates/brutal/collage/_src/65-scene-main.glsl

@@ -0,0 +1 @@
+// (the scene dispatcher is in 66-scene-main.glsl so it sorts after every scene file)

package/skills/agentvfx/templates/brutal/collage/_src/650-scene-ribbon.glsl

@@ -0,0 +1,55 @@
+// Scene 13 (variant 3, rot 1), ribbon-rays: an ochre field with a fan of white hairline rays (the ray count grows on every beat,
+// every third ray is a thin wedge), and a twisted ribbon that crosses the frame: its front face is black with a heavy condensed word
+// flowing along it (the flow steps on every beat), its back face is an ochre duotone of the plate; four echo copies trail behind in
+// colour steps. One DIN Condensed label sits at the root of the rays. Palette: ground (ochre), ink (white), accent (black),
+// tintA (dark ochre), tintB (pale ochre). Text set 14: r the ribbon line (Avenir Next Condensed), g the label.
+float rbY(float x, float ph) { return 0.5 + 0.2 * sin(x * 2.6 + ph); }
+float rbTw(float x) { return cos(x * 1.9 + 0.6); }
+
+void sceneRibbon(vec2 q, vec2 S, vec4 clk, inout vec3 col) {
+  vec2 c = q / scU;
+  float A = S.x / S.y;
+  vec3 white = inkColor.rgb;
+  vec3 blk = accentColor.rgb;
+  float cut = floor(clk.x);
+  col = groundColor.rgb;
+  // rays from the lower left, one more pair on every beat
+  vec2 ro = vec2(0.14, 0.9);
+  vec2 dr = c - ro;
+  float a = atan(dr.y, dr.x);
+  float nr = 6.0 + mod(cut, 14.0) * 2.0;
+  float ra = a * nr / 6.28318;
+  float da = (fract(ra) - 0.5) * 6.28318 / nr;
+  float ray = scLine(da * length(dr), 1.0);
+  float wedge = step(mod(floor(ra), 3.0), 0.5) * step(abs(da * length(dr)), 0.006 + 0.012 * length(dr));
+  col = mix(col, white, max(ray * 0.85, wedge * 0.9));
+  // the ribbon and its echoes, back to front
+  float flow = cut * 0.07;
+  for (int e = 4; e >= 0; e--) {
+    float fe = float(e);
+    float ph = cut * 0.35 - fe * 0.2;
+    float yy = rbY(c.x, ph) + fe * 0.03;
+    float tw = rbTw(c.x - fe * 0.08);
+    float wd = 0.02 + 0.11 * abs(tw);
+    float dy = c.y - yy;
+    float inside = scAA(abs(dy) - wd);
+    if (e > 0) {
+      vec3 ec = e == 4 ? tintA.rgb : (e == 3 ? tintB.rgb : (e == 2 ? blk : white));
+      col = mix(col, ec, scLine(abs(dy) - wd, 1.5) * 0.9);
+      continue;
+    }
+    vec3 face;
+    if (tw > 0.0) {
+      float m = crisp(sheetC(vec2(fract(c.x * 0.45 + flow) * 0.96 * RENDERSIZE.x, (0.012 + (0.5 + 0.5 * dy / max(wd, 0.004)) * 0.07) * RENDERSIZE.y), 0), 1.0);
+      face = mix(blk, white, m);
+    } else {
+      float l = clamp((luma(scPlate(q, vec2(0.0), S)) - 0.05) * 1.8, 0.0, 1.0);
+      face = mix(blk, vec3(1.0, 0.82, 0.38), l);
+    }
+    col = mix(col, face, inside);
+    col = mix(col, white, scLine(abs(dy) - wd, 1.0) * 0.9);
+  }
+  col = mix(col, blk, scAA(length(c - ro) - 0.012));
+  col = mix(col, blk, scSheet(q, 1));
+  col = mix(col, blk, max(scPlus(c, vec2(A - 0.07, 0.08), 0.02), scPlus(c, vec2(0.45 * A, 0.94), 0.02)));
+}

package/skills/agentvfx/templates/brutal/collage/_src/651-scene-slab.glsl

@@ -0,0 +1,38 @@
+// Scene 14 (variant 4, rot 1), slab-shear: a concrete-grey field with a giant Futura word that flows on a sine wave (the wave steps on
+// every beat) and is cut into nine horizontal slabs; on every beat some slabs slide sideways and two become safety-blue slabs holding
+// the plate as a 1-bit Bayer dither with the word in white; a typed Menlo label sits on a seam, with a crosshair target and ticks.
+// Palette: ground (concrete), ink (white), accent (safety blue), tintA (black). Text set 15: r the giant word, g the typed label.
+void sceneSlab(vec2 q, vec2 S, vec4 clk, inout vec3 col) {
+  vec2 c = q / scU;
+  float A = S.x / S.y;
+  vec3 blue = accentColor.rgb;
+  vec3 blk = tintA.rgb;
+  float cut = floor(clk.x);
+  float slab = floor(c.y / 0.1111);
+  float h = hash12(vec2(slab, cut));
+  float shift = (step(0.55, h) * (fract(h * 9.0) - 0.5)) * 0.2 * scU;
+  float isBlue = step(0.82, hash12(vec2(slab, cut + 31.0)));
+  float wave = 0.045 * sin(c.x * 7.0 + cut * 0.9) * scU;
+  float grain = fbm(c * 40.0, 3);
+  col = groundColor.rgb * (0.88 + 0.2 * grain);
+  vec2 sq = q + vec2(shift, wave);
+  float m = crisp(sheetC(sq * (RENDERSIZE / scS), 0), 1.0);
+  if (isBlue > 0.5) {
+    float px = scPx();
+    vec2 pix = floor(q / px);
+    float l = scTone((pix + 0.5) * px, vec2(0.0), S, 1.6, 0.05);
+    col = mix(blk, blue, step(scBayer(pix), l));
+    col = mix(col, inkColor.rgb, m);
+  } else {
+    col = mix(col, blk, m);
+  }
+  // seams between slabs and a typed label on one of them
+  float seam = scLine(fract(c.y / 0.1111 + 0.5) * 0.1111 - 0.0555, 1.0);
+  col = mix(col, blk, seam * 0.35);
+  col = mix(col, blk, step(mod(q.x, 0.03 * scU), 1.0) * step(abs(c.y - 0.2222), 0.008));
+  col = mix(col, blk, scSheet(q, 1));
+  vec2 t = vec2(A - 0.2, 0.5);
+  float rr = length(c - t);
+  col = mix(col, blk, max(scLine(rr - 0.09, 1.2), max(scLine(rr - 0.04, 1.0), max(scLine(c.x - t.x, 1.0) * step(abs(c.y - t.y), 0.12), scLine(c.y - t.y, 1.0) * step(abs(c.x - t.x), 0.12)))));
+  col = mix(col, blk, numTxt(q, vec2(0.04, 0.93) * scU, scCell() * 2.0, mod(cut * 14.0, 1000.0), 3));
+}

package/skills/agentvfx/templates/brutal/collage/_src/652-scene-framedial.glsl

@@ -0,0 +1,79 @@
+// Scene 15 (variant 5, rot 1), frame-loop-dial: a dark aubergine field with a line of Georgia text that runs round the border of the
+// frame (every onset jumps it ahead, a quick double speed); an arch window with the plate as a peach Bayer dither; a dial of 60 ticks
+// filled up on every beat with a split-flap countdown in its middle (the top half of the old digit folds away in 3 frames); a typed Menlo
+// input line. Palette: ground (aubergine), ink (off-white), accent (peach), tintA (plum). Text set 16: r the border line and the
+// MesloLGS NF atlas, g the typed line.
+float fdFlap(vec2 q, vec2 lo, vec2 sz, float oldD, float newD, float u) {
+  float fs = sz.y * 0.8;
+  vec2 org = lo + vec2((sz.x - 0.602 * fs) * 0.5, (sz.y - fs) * 0.5);
+  float mid = lo.y + 0.5 * sz.y;
+  vec2 pn = q - org * scU;
+  float dn = aNum(pn, fs * scU, newD, 1);
+  float dOld = 0.0;
+  float v = 0.0;
+  if (q.y >= mid * scU) {
+    v = u < 0.66 ? aNum(q - org * scU, fs * scU, oldD, 1) : dn;
+  } else {
+    float vis = 1.0 - u;
+    float yy = mid * scU - (mid * scU - q.y) / max(vis, 0.001);
+    if (u < 1.0 && (mid * scU - q.y) < 0.5 * sz.y * scU * vis) { v = aNum(vec2(q.x, yy) - org * scU, fs * scU, oldD, 1); }
+    else if (u < 1.0) { v = dn; }
+    else { v = dn; }
+  }
+  return crisp(v, 4.0);
+}
+
+void sceneFrameDial(vec2 q, vec2 S, vec4 clk, inout vec3 col) {
+  vec2 c = q / scU;
+  float A = S.x / S.y;
+  vec3 off = inkColor.rgb;
+  vec3 peach = accentColor.rgb;
+  vec3 plum = tintA.rgb;
+  float cut = floor(clk.x);
+  float age = float(FRAMEINDEX) - clk.y;
+  float u = cut < 0.5 ? 1.0 : clamp((age + 1.0) / 3.0, 0.0, 1.0);
+  col = groundColor.rgb;
+  // text round the border
+  float bnd = 0.055;
+  vec4 dd = vec4(c.y, A - c.x, 1.0 - c.y, c.x);
+  float mn = min(min(dd.x, dd.y), min(dd.z, dd.w));
+  float perim = 2.0 * A + 2.0;
+  float s;
+  float depth = mn;
+  if (mn == dd.x) { s = c.x; }
+  else if (mn == dd.y) { s = A + c.y; }
+  else if (mn == dd.z) { s = A + 1.0 + (A - c.x); }
+  else { s = 2.0 * A + 1.0 + (1.0 - c.y); }
+  float tflow = TIME * 0.06 * perim + clk.z * 0.06;
+  float k = RENDERSIZE.y;
+  float ux = mod((s - tflow) * k, 5.0 * 101.8 * k / 360.0);
+  float m = crisp(sheetC(vec2(ux, (0.012 + depth / bnd * 0.056) * k), 0), 1.0) * step(depth, bnd);
+  col = mix(col, plum, step(depth, bnd));
+  col = mix(col, peach, m);
+  col = mix(col, peach, scLine(depth - bnd, 1.0) * 0.8);
+  // arch window with a peach dither of the plate
+  vec2 lo = vec2(0.17, 0.14);
+  vec2 hi = vec2(0.84, 0.88);
+  float px = scPx();
+  vec2 pix = floor(q / px);
+  float l = scTone((pix + 0.5) * px, lo * scU, hi * scU, 1.6, 0.06);
+  col = mix(col, mix(plum, peach, step(scBayer(pix), l)), scAA(sdArch(c, lo, hi)));
+  col = mix(col, off, scLine(sdArch(c, lo - 0.012, hi + 0.012), 1.0));
+  // dial of 60 ticks and the split-flap countdown
+  vec2 ctr = vec2(1.3, 0.5);
+  float rr = length(c - ctr);
+  float ang = (atan(c.y - ctr.y, c.x - ctr.x) / 6.28318 + 0.5) * 60.0;
+  float tk = step(0.25, fract(ang)) * step(fract(ang), 0.75) * step(0.3, rr) * step(rr, 0.3 + 0.03 + 0.02 * step(mod(floor(ang), 5.0), 0.5));
+  float on = step(floor(ang) + 0.5, mod(cut, 60.0));
+  col = mix(col, mix(plum * 1.6, peach, on), tk);
+  float val = mod(60.0 - cut, 100.0);
+  float cw = 0.17;
+  float v1 = fdFlap(q, vec2(ctr.x - 0.185, ctr.y - 0.13), vec2(cw, 0.26), floor(mod(60.0 - cut + 1.0, 100.0) / 10.0), floor(val / 10.0), u);
+  float v2 = fdFlap(q, vec2(ctr.x + 0.015, ctr.y - 0.13), vec2(cw, 0.26), mod(60.0 - cut + 1.0, 10.0), mod(val, 10.0), u);
+  col = mix(col, off, scAA(sdBox(c, vec2(ctr.x - 0.185, ctr.y - 0.13), vec2(ctr.x - 0.015, ctr.y + 0.13)) - 0.02));
+  col = mix(col, off, scAA(sdBox(c, vec2(ctr.x + 0.015, ctr.y - 0.13), vec2(ctr.x + 0.185, ctr.y + 0.13)) - 0.02));
+  col = mix(col, groundColor.rgb, min(v1 + v2, 1.0));
+  col = mix(col, groundColor.rgb, scLine(c.y - ctr.y, 2.0) * scBox(c, vec2(ctr.x - 0.185, 0.0), vec2(ctr.x + 0.185, 1.0)));
+  col = mix(col, peach, scSheet(q, 1));
+  col = mix(col, off, max(scPlus(c, vec2(1.0, 0.18), 0.02), scPlus(c, vec2(1.6, 0.82), 0.02)));
+}

package/skills/agentvfx/templates/brutal/collage/_src/653-scene-tilt.glsl

@@ -0,0 +1,40 @@
+// Scene 16 (variant 6, rot 1), tilt-tiles: a lemon field tilted about 14 degrees into rows of Rockwell word tiles. Neighbouring rows flow
+// the other way and each beat every row jumps a different distance; filled and outlined rows alternate, and each onset swaps the kind
+// of one row. A tilted window holds the plate as a three-tone posterize (black, lemon, white); a white caption box, a numbered black disc.
+// Palette: ground (lemon), ink (black), accent (white), tintA (deep green). Text set 17: r filled word, g outlined word, b caption.
+void sceneTilt(vec2 q, vec2 S, vec4 clk, inout vec3 col) {
+  vec2 c = q / scU;
+  float A = S.x / S.y;
+  vec3 blk = inkColor.rgb;
+  vec3 wht = accentColor.rgb;
+  float cut = floor(clk.x * 0.5);
+  col = groundColor.rgb;
+  vec2 pr = stRot(c - vec2(0.5 * A, 0.5), 0.24);
+  float rowH = 0.14;
+  float n = floor(pr.y / rowH);
+  float v = pr.y - n * rowH;
+  float dir = mod(n, 2.0) < 0.5 ? 1.0 : -1.0;
+  float off = dir * cut * (0.14 + 0.05 * mod(abs(n), 3.0));
+  float u = mod(pr.x + off, 0.92);
+  float k = RENDERSIZE.y;
+  float swp = step(abs(mod(n, 7.0) - mod(clk.z, 7.0)), 0.5);
+  int ch = mod(n + swp, 2.0) < 0.5 ? 0 : 1;
+  float m = crisp(sheetC(vec2(u * 0.5 * k, (0.0478 + (v - 0.07) * 0.5) * k), ch), 1.0);
+  col = mix(col, blk, m);
+  col = mix(col, blk, scLine(v, 1.0) * 0.6);
+  // tilted window with the posterized plate
+  vec2 wc = vec2(0.04, 0.0);
+  vec2 wh = vec2(0.5, 0.25);
+  float inW = scAA(sdBox(pr, wc - wh, wc + wh));
+  float l = scTone(q, vec2(0.0), S, 1.5, 0.05);
+  vec3 pz = l < 0.3 ? blk : (l < 0.62 ? groundColor.rgb : wht);
+  col = mix(col, pz, inW);
+  col = mix(col, blk, scLine(sdBox(pr, wc - wh, wc + wh), 3.0));
+  // caption box, numbered disc
+  col = mix(col, wht, scAA(sdBox(c, vec2(0.04, 0.86), vec2(0.7, 0.97))));
+  col = mix(col, blk, scSheet(q, 2) * scBox(c, vec2(0.04, 0.86), vec2(0.7, 0.97)));
+  vec2 dc = vec2(A - 0.14, 0.15);
+  col = mix(col, blk, scAA(length(c - dc) - 0.09));
+  col = mix(col, wht, numTxt(q, (dc - vec2(0.035, 0.03)) * scU, scCell() * 2.0, mod(cut, 100.0), 2));
+  col = mix(col, tintA.rgb, scLine(length(c - dc) - 0.115, 2.0));
+}

package/skills/agentvfx/templates/brutal/collage/_src/654-scene-marquee.glsl

@@ -0,0 +1,45 @@
+// Scene 17 (variant 7, rot 1), marquee-stack: a teal field of six stacked word rows. Every beat each row jumps its own distance in its own
+// direction (a marquee that moves in steps, not a scroll); each row has three echo copies trailing in colour steps (dark teal,
+// tangerine, cream shade); the last row is Hangul. A cream-framed window holds the plate as a coarse four-colour mosaic. Palette: ground
+// (teal), ink (cream), accent (tangerine), tintA (dark teal). Text set 18: r the word (Gill Sans Bold), g the Hangul word, b the caption.
+void sceneMarquee(vec2 q, vec2 S, vec4 clk, inout vec3 col) {
+  vec2 c = q / scU;
+  float A = S.x / S.y;
+  vec3 cream = inkColor.rgb;
+  vec3 tang = accentColor.rgb;
+  vec3 deep = tintA.rgb;
+  float cut = floor(clk.x);
+  col = groundColor.rgb;
+  float n = floor((c.y - 0.05) / 0.15);
+  float v = (c.y - 0.05) - n * 0.15;
+  float k = RENDERSIZE.y;
+  if (n >= 0.0 && n < 6.0) {
+    float dk = n < 0.5 ? 0.25 : (n < 1.5 ? 0.42 : (n < 2.5 ? 0.6 : (n < 3.5 ? 0.33 : (n < 4.5 ? 0.5 : 0.7))));
+    float dir = mod(n, 2.0) < 0.5 ? 1.0 : -1.0;
+    float off = dir * (cut * dk + clk.z * 0.02 * dk);
+    int ch = n > 4.5 ? 1 : 0;
+    for (int e = 3; e >= 0; e--) {
+      float oe = off + dir * float(e) * 0.07;
+      float u = mod(c.x + oe, 0.95);
+      float m = crisp(sheetC(vec2(u * 0.5 * k, (0.0478 + (v - 0.075) * 0.5) * k), ch), 1.0);
+      vec3 ec = e == 3 ? deep : (e == 2 ? tang : (e == 1 ? cream * 0.78 : cream));
+      col = mix(col, ec, m);
+    }
+  }
+  col = mix(col, cream, scLine(fract((c.y - 0.05) / 0.15) * 0.15, 1.0) * 0.0);
+  // mosaic window
+  vec2 lo = vec2(1.1, 0.2);
+  vec2 hi = vec2(1.64, 0.8);
+  float blk = 0.022 * scU;
+  vec2 mq = (floor(q / blk) + 0.5) * blk;
+  float l = pow(scTone(mq, lo * scU, hi * scU, 1.5, 0.02), 0.6);
+  vec3 mc = l < 0.25 ? deep : (l < 0.5 ? groundColor.rgb * 1.25 : (l < 0.75 ? tang : cream));
+  col = mix(col, mc, scAA(sdBox(c, lo, hi)));
+  col = mix(col, cream, scLine(sdBox(c, lo - 0.012, hi + 0.012), 3.0));
+  // caption bar, disc, crosses
+  col = mix(col, cream, scAA(sdBox(c, vec2(0.04, 0.955), vec2(0.8, 1.01))));
+  col = mix(col, deep, scSheet(q, 2) * scBox(c, vec2(0.04, 0.955), vec2(0.8, 1.01)));
+  col = mix(col, tang, scAA(length(c - vec2(A - 0.12, 0.88)) - 0.07));
+  col = mix(col, deep, numTxt(q, vec2(A - 0.155, 0.855) * scU, scCell() * 2.0, mod(cut, 100.0), 2));
+  col = mix(col, cream, max(scPlus(c, vec2(1.05, 0.15), 0.02), scPlus(c, vec2(1.69, 0.85), 0.02)));
+}

package/skills/agentvfx/templates/brutal/collage/_src/655-scene-lens.glsl

@@ -0,0 +1,57 @@
+// Scene 18 (variant 8, rot 1), lens-wrap: an olive field; the plate wrapped on a sphere (longitude / latitude mapping, a red-blue lens
+// fringe, a specular patch) whose size swells with the bass; a perspective floor of pink tile lines that steps toward you on every beat;
+// a 4 x 3 block of small panels that each turn a quarter on every third onset; Didot and Courier New type. Palette: ground (olive),
+// ink (pink), accent (black), tintA (dark olive), tintB (cream). Text set 19: r the word (Didot), g the caption (Courier New).
+void sceneLens(vec2 q, vec2 S, vec4 clk, inout vec3 col) {
+  vec2 c = q / scU;
+  float A = S.x / S.y;
+  vec3 pink = inkColor.rgb;
+  vec3 blk = accentColor.rgb;
+  vec3 cream = tintB.rgb;
+  float cut = floor(clk.x);
+  col = groundColor.rgb;
+  // perspective floor
+  float hy = 0.58;
+  float t = 0.1 / max(c.y - hy + 0.004, 0.004);
+  float wx = (c.x - 0.5 * A) * t * 1.2;
+  float wz = t * 1.2 + cut * 0.5;
+  float gx = 1.0 - clamp((0.5 - abs(fract(wx) - 0.5)) / max(fwidth(wx) * 1.2, 1e-3), 0.0, 1.0);
+  float gz = 1.0 - clamp((0.5 - abs(fract(wz) - 0.5)) / max(fwidth(wz) * 1.2, 1e-3), 0.0, 1.0);
+  float below = step(hy, c.y);
+  col = mix(col, tintA.rgb, 0.6 * below);
+  col = mix(col, pink, max(gx, gz) * smoothstep(0.0, 0.08, c.y - hy) * 0.9 * below);
+  col = mix(col, pink, scLine(c.y - hy, 1.0) * 0.8);
+  // sphere
+  vec2 ctr = vec2(0.62, 0.45);
+  float R = 0.3 + 0.05 * stLevel().r;
+  vec2 d = (c - ctr) / R;
+  float r2 = dot(d, d);
+  float z = sqrt(max(1.0 - r2, 0.0));
+  vec2 uv = vec2(0.5 + atan(d.x, max(z, 0.001)) / 3.0, 0.5 + asin(clamp(d.y, -1.0, 1.0)) / 3.0);
+  vec3 f = vec3(scPlate((uv - 0.5) * S + 0.5 * S, vec2(0.0), S).r, scPlate((uv - 0.5) * 1.025 * S + 0.5 * S, vec2(0.0), S).g, scPlate((uv - 0.5) * 1.05 * S + 0.5 * S, vec2(0.0), S).b);
+  f = clamp((f - 0.06) * 1.3, 0.0, 1.0) * (0.35 + 0.65 * z);
+  float spec = smoothstep(0.28, 0.0, length((d - vec2(-0.38, -0.42)) * vec2(1.0, 1.6)));
+  f = mix(f, cream, spec * 0.55);
+  col = mix(col, f, scAA((sqrt(r2) - 1.0) * R));
+  col = mix(col, pink, scLine((sqrt(r2) - 1.0) * R, 2.0));
+  col = mix(col, pink, scLine(length((c - ctr) * vec2(1.0, 3.2)) - 0.46, 1.0) * 0.8);
+  // small panels that turn
+  vec2 g = (c - vec2(A - 0.62, 0.06)) / 0.14;
+  vec2 pid = floor(g);
+  if (pid.x >= 0.0 && pid.x < 4.0 && pid.y >= 0.0 && pid.y < 3.0) {
+    float i = pid.x + 4.0 * pid.y;
+    vec2 p = (fract(g) - 0.5) * 0.14;
+    if (abs(p.x) < 0.055 && abs(p.y) < 0.055) {
+      p = stRot(p, floor((clk.z + i) / 3.0) * 1.5708);
+      float bars = 0.0;
+      for (int j = 0; j < 3; j++) {
+        float h = 0.02 + 0.07 * hash12(vec2(i, float(j)));
+        bars = max(bars, step(abs(p.x - (-0.03 + 0.03 * float(j))), 0.009) * step(-0.045, p.y) * step(p.y, -0.045 + h));
+      }
+      col = mix(cream, blk, bars);
+    }
+  }
+  col = mix(col, cream, scSheet(q, 0));
+  col = mix(col, cream, scSheet(q, 1));
+  col = mix(col, blk, numTxt(q, vec2(0.05, 0.92) * scU, scCell() * 2.0, mod(cut * 3.0, 1000.0), 3));
+}

package/skills/agentvfx/templates/brutal/collage/_src/656-scene-liquid.glsl

@@ -0,0 +1,35 @@
+// Scene 19 (variant 9, rot 1), liquid-type: a sky-blue field; the plate blurred and thresholded into ink-blot shapes (mid blue, one
+// orange blot in the brightest part); a big Bodoni 72 word on a double sine ripple whose phase steps on every beat; a typed American
+// Typewriter note and a crosshair reticle that jumps to a new place on every beat. Palette: ground (sky), ink (navy), accent (orange),
+// tintA (pale), tintB (mid blue). Text set 20: r the word (Bodoni 72), g the typed note (American Typewriter).
+void sceneLiquid(vec2 q, vec2 S, vec4 clk, inout vec3 col) {
+  vec2 c = q / scU;
+  float A = S.x / S.y;
+  vec4 hit = stHit();
+  vec3 navy = inkColor.rgb;
+  vec3 org = accentColor.rgb;
+  float cut = floor(clk.x);
+  col = groundColor.rgb;
+  // ink blots: blurred plate luma thresholded
+  float b = 0.0;
+  float r = 7.0 * U * 3.0;
+  for (int i = 0; i < 8; i++) {
+    float a = float(i) * 0.7854;
+    b += luma(scPlate(q + r * vec2(cos(a), sin(a)), vec2(0.0), S));
+  }
+  b = b / 8.0;
+  float thr = 0.3 - 0.05 * hit.y;
+  col = mix(col, tintB.rgb, smoothstep(thr, thr + 0.025, b));
+  col = mix(col, org, smoothstep(0.5, 0.53, b));
+  // liquid word
+  float ph = cut * 0.9;
+  vec2 sq = q + scU * vec2(0.02 * sin(c.y * 14.0 + ph), 0.03 * sin(c.x * 6.0 + ph * 1.3));
+  float m = crisp(sheetC(sq * (RENDERSIZE / scS), 0), 1.0);
+  col = mix(col, navy, m);
+  // reticle
+  vec2 rp = vec2(0.3 + (A - 0.6) * hash12(vec2(cut, 2.0)), 0.25 + 0.5 * hash12(vec2(cut, 5.0)));
+  col = mix(col, navy, max(scLine(length(c - rp) - 0.06, 1.2), max(scLine(c.x - rp.x, 1.0) * step(abs(c.y - rp.y), 0.1) * step(0.03, abs(c.y - rp.y)), scLine(c.y - rp.y, 1.0) * step(abs(c.x - rp.x), 0.1) * step(0.03, abs(c.x - rp.x)))));
+  col = mix(col, navy, numTxt(q, (rp + vec2(0.07, 0.06)) * scU, scCell(), mod(cut * 17.0, 1000.0), 3));
+  col = mix(col, navy, scSheet(q, 1));
+  col = mix(col, navy, max(scPlus(c, vec2(0.06, 0.06), 0.02), scPlus(c, vec2(A - 0.06, 0.94), 0.02)));
+}

package/skills/agentvfx/templates/brutal/collage/_src/657-scene-panelgrid.glsl

@@ -0,0 +1,75 @@
+// Scene 20 (variant 0, rot 2), panel-grid: an ice-white sheet with a 6 x 4 grid of small square panels, each a thin-line instrument
+// (plate isolines, spectrum comb, bass gauge, big number, starburst, waveform, checker, reticle). On every onset one panel (in turn)
+// swings a quarter turn in three frames and shows its next instrument. Brick accents; Optima and SF Mono type. Palette: ground (ice),
+// ink (black), accent (brick), tintA (grey). Text set 21: r the Optima caption, g the SF Mono caption.
+vec2 pgPanel(int kind, vec2 p, vec2 ctr, vec4 clk) {
+  float h = 0.1;
+  vec2 pp = (p + h) * scU;
+  float cell = scCell();
+  if (kind == 0) {
+    float l = scTone((ctr + p) * scU, (ctr - h) * scU, (ctr + h) * scU, 1.4, 0.05);
+    return vec2(smoothstep(0.38, 0.46, abs(fract(l * 7.0) - 0.5)), 0.0);
+  }
+  if (kind == 1) {
+    float i = floor((p.x + h) / (2.0 * h) * 12.0);
+    float lv = bandAt((i + 0.5) / 12.0);
+    float bar = step(abs(fract((p.x + h) / (2.0 * h) * 12.0) - 0.5), 0.3) * step(h - lv * 2.0 * h * 0.9, p.y + h) * step(p.y, h * 0.9);
+    return vec2(bar * step(0.3, lv + 0.2), bar * step(0.7, lv));
+  }
+  if (kind == 2) {
+    float r = length(p);
+    float a = atan(p.x, -p.y);
+    float na = -2.3 + 4.6 * stLevel().r;
+    float needle = scLine(sdSeg(p, vec2(0.0), 0.075 * vec2(sin(na), -cos(na))), 1.5);
+    float tk = step(abs(fract(a * 3.8197) - 0.5), 0.12) * step(0.065, r) * step(r, 0.085) * step(abs(a), 2.4);
+    return vec2(max(scLine(r - 0.085, 1.0), tk), needle);
+  }
+  if (kind == 3) { return vec2(numTxt(pp, vec2(0.04, 0.07) * scU, cell * 2.0, mod(clk.x * 7.0, 100.0), 2), 0.0); }
+  if (kind == 4) { return vec2(scBurst(p, 0.09, 0.012, 0.0, 24.0), scAA(length(p) - 0.01)); }
+  if (kind == 5) {
+    float y = waveI((p.x + h) / (2.0 * h) * 400.0) * scopeGain * 0.3;
+    return vec2(scLine(p.y - y, 1.2) * step(abs(p.x), 0.09), scLine(p.y, 1.0) * 0.0);
+  }
+  if (kind == 6) {
+    vec2 g = floor(p / 0.033);
+    return vec2(step(1.0, mod(g.x + g.y, 2.0)) * step(abs(p.x), 0.09) * step(abs(p.y), 0.09), 0.0);
+  }
+  float rr = length(p);
+  return vec2(max(max(scLine(rr - 0.05, 1.0), scLine(p.x, 1.0) * step(abs(p.y), 0.085)), scLine(p.y, 1.0) * step(abs(p.x), 0.085)), 0.0);
+}
+
+void scenePanelGrid(vec2 q, vec2 S, vec4 clk, inout vec3 col) {
+  vec2 c = q / scU;
+  float A = S.x / S.y;
+  vec3 ink = inkColor.rgb;
+  vec3 brick = accentColor.rgb;
+  col = groundColor.rgb;
+  vec2 o = vec2((A - 1.38) * 0.5, 0.04);
+  vec2 g = (c - o) / 0.23;
+  vec2 id = floor(g);
+  if (id.x >= 0.0 && id.x < 6.0 && id.y >= 0.0 && id.y < 4.0) {
+    vec2 ctr = o + (id + 0.5) * 0.23;
+    vec2 p = c - ctr;
+    float i = id.x + 6.0 * id.y;
+    if (abs(p.x) < 0.105 && abs(p.y) < 0.105) {
+      float mine = mod(clk.z, 24.0) == i ? 1.0 : 0.0;
+      float age = float(FRAMEINDEX) - clk.w;
+      float u = (mine > 0.5 && clk.z > 0.5) ? clamp((age + 1.0) / 3.0, 0.0, 1.0) : 1.0;
+      float turns = floor((clk.z + 24.0 - i) / 24.0);
+      float ang = (turns - (1.0 - u)) * 1.5708;
+      float tcount = u < 0.5 ? turns - 1.0 : turns;
+      int kind = int(floor(hash12(vec2(i, 3.3 + tcount)) * 8.0));
+      vec2 pr = stRot(p, ang);
+      vec2 res = pgPanel(kind, pr, ctr, clk);
+      col = mix(col, tintA.rgb * 1.5, 0.0);
+      col = mix(col, ink, res.x * step(abs(pr.x), 0.1) * step(abs(pr.y), 0.1));
+      col = mix(col, brick, res.y);
+    }
+    col = mix(col, ink, scLine(sdBox(p, vec2(-0.105), vec2(0.105)), 1.0));
+  }
+  col = mix(col, brick, scAA(sdBox(c, vec2(0.0, 0.04), vec2(o.x - 0.04, 0.14))));
+  col = mix(col, ink, scLine(c.x - (o.x - 0.02), 1.0) * step(0.2, c.y) * step(c.y, 0.96) * 0.7);
+  col = mix(col, ink, scSheet(q, 0));
+  col = mix(col, ink, scSheet(q, 1));
+  col = mix(col, brick, scLine(c.y - 0.975, 2.0) * step(0.0, c.x) * step(c.x, A * (0.2 + 0.8 * stLevel().a)));
+}

package/skills/agentvfx/templates/brutal/collage/_src/658-scene-mirror.glsl

@@ -0,0 +1,49 @@
+// Scene 21 (variant 1, rot 2), mirror-track: a violet field and a central window holding the plate mirrored about its vertical axis and
+// solarized into navy / brick / cream. Five outline target squares with tiny number labels jump to new places on every beat and are
+// mirrored with the plate; a barcode strip re-seeds on every beat; a file-lookup text block with struck-through rows (D2Coding) and a big
+// Phosphate word. Palette: ground (dusty violet), ink (cream), accent (brick red), tintA (indigo), tintB (pale violet). Text set 22: r the word, g the file block.
+void sceneMirror(vec2 q, vec2 S, vec4 clk, inout vec3 col) {
+  vec2 c = q / scU;
+  float A = S.x / S.y;
+  vec4 hit = stHit();
+  vec3 cream = inkColor.rgb;
+  vec3 navy = accentColor.rgb;
+  vec3 dk = tintA.rgb;
+  float cut = floor(clk.x);
+  col = groundColor.rgb;
+  vec2 lo = vec2(0.34, 0.08);
+  vec2 hi = vec2(A - 0.06, 0.8);
+  float wc = 0.5 * (lo.x + hi.x);
+  vec2 qm = vec2(wc * scU + abs(q.x - wc * scU), q.y);
+  float l = scTone(qm, lo * scU, hi * scU, 1.4, 0.05);
+  float s = abs(l - (0.4 + 0.05 * mod(cut, 3.0))) * 2.0;
+  vec3 sol = s < 0.22 ? navy : (s < 0.55 ? dk : cream);
+  col = mix(col, sol, scAA(sdBox(c, lo, hi)));
+  col = mix(col, cream, scLine(sdBox(c, lo - 0.01, hi + 0.01), 1.5));
+  col = mix(col, cream, scLine(c.x - wc, 1.0) * step(lo.y, c.y) * step(c.y, hi.y) * 0.8);
+  // targets, mirrored
+  for (int i = 0; i < 5; i++) {
+    float fi = float(i);
+    vec2 h = hash22(vec2(fi + 1.0, cut));
+    vec2 tp = vec2(mix(lo.x + 0.05, wc, h.x), mix(lo.y + 0.06, hi.y - 0.06, h.y));
+    float sz = 0.03 + 0.03 * hash12(vec2(fi, 9.0));
+    for (int sd = 0; sd < 2; sd++) {
+      vec2 tq = sd == 0 ? tp : vec2(2.0 * wc - tp.x, tp.y);
+      float box = scLine(sdBox(c, tq - sz, tq + sz), 1.2);
+      vec2 br = abs(c - tq) - sz;
+      col = mix(col, cream, max(box, 0.0));
+      col = mix(col, cream, numTxt(q, (tq + vec2(sz + 0.01, -sz)) * scU, scCell(), mod(fi * 37.0 + cut * 11.0, 1000.0), 3));
+    }
+  }
+  // barcode
+  float bx = floor(c.x / 0.004);
+  float bar = step(0.5, hash12(vec2(bx, cut))) * step(0.04, c.x) * step(c.x, 0.3) * step(0.86, c.y) * step(c.y, 0.96);
+  col = mix(col, cream, bar);
+  // file block with struck-through rows
+  float row = floor((c.y - 0.1) / 0.034);
+  float strike = step(0.0, row) * step(mod(row, 3.0), 1.5) * step(0.5, mod(row, 3.0)) * step(abs(c.y - (0.1 + (row + 0.5) * 0.034)), 0.0012) * step(0.04, c.x) * step(c.x, 0.3);
+  col = mix(col, cream, scSheet(q, 1));
+  col = mix(col, cream, strike);
+  col = mix(col, cream, scSheet(q, 0));
+  col = mix(col, navy, scAA(sdBox(c, vec2(0.04, 0.03), vec2(0.04 + 0.26 * stLevel().a, 0.045))));
+}

package/skills/agentvfx/templates/brutal/collage/_src/66-scene-main.glsl

@@ -0,0 +1,27 @@
+// Scene dispatcher: variant 1..9 and 0 are the first ten scenes, rot 1 adds 10 (variant 0..5 + 10 are the round 9 scenes).
+void drawScene(int v, vec2 q, vec2 S, vec4 clk, inout vec3 col) {
+  scS = S;
+  scU = S.y;
+  if (v == 1) { sceneSpecimen(q, S, clk, col); }
+  if (v == 2) { sceneWiring(q, S, clk, col); }
+  if (v == 3) { sceneFieldCut(q, S, clk, col); }
+  if (v == 4) { scenePattern(q, S, clk, col); }
+  if (v == 5) { sceneAnatomy(q, S, clk, col); }
+  if (v == 6) { sceneDeck(q, S, clk, col); }
+  if (v == 7) { sceneBootlog(q, S, clk, col); }
+  if (v == 8) { sceneTunnel(q, S, clk, col); }
+  if (v == 9) { sceneRunner(q, S, clk, col); }
+  if (v == 0) { sceneAscii(q, S, clk, col); }
+  if (v == 10) { sceneCubeWall(q, S, clk, col); }
+  if (v == 11) { sceneVortex(q, S, clk, col); }
+  if (v == 12) { sceneSticker(q, S, clk, col); }
+  if (v == 13) { sceneRibbon(q, S, clk, col); }
+  if (v == 14) { sceneSlab(q, S, clk, col); }
+  if (v == 15) { sceneFrameDial(q, S, clk, col); }
+  if (v == 16) { sceneTilt(q, S, clk, col); }
+  if (v == 17) { sceneMarquee(q, S, clk, col); }
+  if (v == 18) { sceneLens(q, S, clk, col); }
+  if (v == 19) { sceneLiquid(q, S, clk, col); }
+  if (v == 20) { scenePanelGrid(q, S, clk, col); }
+  if (v == 21) { sceneMirror(q, S, clk, col); }
+}