agentvfx 0.0.0-stage → 0.3.4

package/skills/agentvfx/templates/brutal/collage/_src/40-editorial.glsl

@@ -0,0 +1,232 @@
+// Editorial roles. The engine text layer (TEXTMASK) is a "sheet" of type slots (see fx.json X_AGENTVFX.text);
+// a type cell shows a window of that sheet, scaled and optionally turned 90 degrees, and the shader only
+// colours it. Live numbers and labels come from the mono "atlas" row of the sheet (digits, colon, A..Z).
+// Every role below returns vec3(ink, hot, 0) coverage in the cell's own pixel space (q from its top-left).
+const float ATLAS_X = 0.35938;
+const float ATLAS_Y = 0.93333;
+const float ATLAS_PX = 0.05;
+const float MONO_ADV = 0.602;
+vec2 UN;
+
+// one text-sheet channel (0 R the editorial sheet, 1 G, 2 B) at sheet pixel sp (origin top left)
+float sheetC(vec2 sp, int ch) {
+  vec2 res = RENDERSIZE;
+  if (!HAS_TEXT || sp.x < 0.0 || sp.y < 0.0 || sp.x >= res.x || sp.y >= res.y) { return 0.0; }
+  vec3 t = texture(TEXTMASK, vec2(sp.x, res.y - sp.y) / res).rgb;
+  return ch == 1 ? t.g : (ch == 2 ? t.b : t.r);
+}
+float sheetAt(vec2 sp) { return sheetC(sp, 0); }
+
+int aIdx(int ch) {
+  if (ch >= 48 && ch <= 57) { return ch - 48; }
+  if (ch == 58) { return 10; }
+  if (ch >= 65 && ch <= 90) { return ch - 54; }
+  return -1;
+}
+// one atlas glyph; p is in pixels from the top-left of its character box (MONO_ADV * fs wide, fs high)
+float aGlyph(vec2 p, int ch, float fs) {
+  int idx = aIdx(ch);
+  if (idx < 0 || p.x < 0.0 || p.y < 0.0 || p.x >= MONO_ADV * fs || p.y >= fs) { return 0.0; }
+  float apx = ATLAS_PX * RENDERSIZE.y;
+  vec2 o = vec2(ATLAS_X * RENDERSIZE.x + float(idx) * MONO_ADV * apx, ATLAS_Y * RENDERSIZE.y);
+  return sheetAt(o + p * (apx / fs));
+}
+float aTxt(vec2 p, float fs, int a, int b, int c, int d) {
+  if (p.x < 0.0) { return 0.0; }
+  float adv = MONO_ADV * fs;
+  int i = int(floor(p.x / adv));
+  if (i > 3) { return 0.0; }
+  int ch = i == 0 ? a : (i == 1 ? b : (i == 2 ? c : d));
+  return aGlyph(vec2(p.x - float(i) * adv, p.y), ch, fs);
+}
+float aNum(vec2 p, float fs, float v, int nd) {
+  if (p.x < 0.0) { return 0.0; }
+  float adv = MONO_ADV * fs;
+  int i = int(floor(p.x / adv));
+  if (i >= nd) { return 0.0; }
+  int dg = int(mod(floor(v / pow(10.0, float(nd - 1 - i)) + 0.001), 10.0));
+  return aGlyph(vec2(p.x - float(i) * adv, p.y), 48 + dg, fs);
+}
+
+float bandAt(float x) {
+  float f = x * float(bands) - 0.5;
+  float i0 = floor(f);
+  return mix(stBand(clamp(int(i0), 0, bands - 1)), stBand(clamp(int(i0) + 1, 0, bands - 1)), f - i0);
+}
+
+// spectrum, hairline family. 1: one line over the bands; 2: comb of single-pixel bars. Both stand on a
+// baseline with a tick scale under it and an accent dot on the loudest band.
+vec3 pSpecHair(vec2 q, vec2 S, int v) {
+  float y0 = S.y - 14.0 * U;
+  float amp = y0 - 2.0 * U;
+  float inx = step(0.0, q.x) * step(q.x, S.x);
+  float pitch = S.x / float(bands);
+  float ink = hl(q.y - y0) * inx * 0.85;
+  float tk = floor(q.x / pitch + 0.5);
+  float isMaj = mod(tk, 5.0) < 0.5 ? 1.0 : 0.0;
+  ink = max(ink, step(abs(q.x - tk * pitch), HW * 0.5 + 0.25) * step(y0, q.y) * step(q.y, y0 + (3.0 + 3.5 * isMaj) * U) * 0.8);
+  float hot = 0.0;
+  if (v == 2) {
+    int b = int(clamp(floor(q.x / pitch), 0.0, float(bands - 1)));
+    float top = y0 - stBand(b) * amp;
+    float bar = hl(q.x - (float(b) + 0.5) * pitch) * step(top, q.y) * step(q.y, y0) * inx;
+    ink = max(ink, bar * 0.8);
+    hot = max(hot, bar * step(q.y, top + 3.0 * U));
+  } else {
+    float yA = y0 - bandAt((q.x - 0.5) / S.x) * amp;
+    float yB = y0 - bandAt((q.x + 0.5) / S.x) * amp;
+    float d = max(max(min(yA, yB) - q.y, q.y - max(yA, yB)), 0.0);
+    ink = max(ink, hlw(d, HW * 1.15) * inx);
+  }
+  vec4 pk = texelFetch(state, ivec2(2, 0), 0);
+  vec2 pp = vec2((pk.x + 0.5) * pitch, y0 - pk.y * amp);
+  float lit = step(0.06, pk.y);
+  hot = max(hot, lit * max(inBox(q - pp, vec2(-3.0 * U), vec2(3.0 * U)), hl(q.x - pp.x) * step(q.y, pp.y - 3.0 * U) * step(pp.y - 12.0 * U, q.y)));
+  return vec3(ink, hot, 0.0);
+}
+
+// scope as one line crossing the cell: faint axis, trigger-free wave trace. 1: trace hot; 2: trace ink
+vec3 pScopeLine(vec2 q, vec2 S, int v) {
+  float yc = S.y * 0.5;
+  float inx = step(0.0, q.x) * step(q.x, S.x);
+  float dx = 0.5 / S.x * 511.0;
+  float t = q.x / S.x * 511.0;
+  float yA = yc - waveI(t - dx) * scopeGain * S.y;
+  float yB = yc - waveI(t + dx) * scopeGain * S.y;
+  float d = max(max(clamp(min(yA, yB), 0.0, S.y) - q.y, q.y - clamp(max(yA, yB), 0.0, S.y)), 0.0);
+  float tr = hlw(d, HW * 1.15) * inx;
+  float axis = hl(q.y - yc) * inx * 0.22;
+  return vec3(max(axis, v == 2 ? tr : 0.0), v == 2 ? 0.0 : tr, 0.0);
+}
+
+// hairline track with a heavier fill up to the level and a cap tick, along the long side of the cell
+vec3 levelBar(vec2 q, vec2 S, int ch) {
+  float lv = stLevel()[ch];
+  bool wide = S.x >= S.y;
+  float len = wide ? S.x : S.y;
+  float along = wide ? q.x : S.y - q.y;
+  float across = wide ? q.y - S.y * 0.5 : q.x - S.x * 0.5;
+  if (along < -1.0 || along > len + 1.0) { return vec3(0.0); }
+  float track = hl(across) * 0.3;
+  float fillv = hlw(across, HW * 2.4) * step(0.0, along) * step(along, lv * len);
+  float cap = step(abs(along - lv * len), HW * 0.75 + 0.5) * step(abs(across), 5.0 * U) * step(0.04, lv);
+  float ends = step(abs(along), HW * 0.5 + 0.25) * step(abs(across), 3.0 * U);
+  return vec3(max(max(track, fillv), ends * 0.6), cap, 0.0);
+}
+
+// four thin level bars (bass, mid, treble, rms) with mono labels: rows in a wide cell, columns in a tall one
+vec3 pMeterEd(vec2 q, vec2 S) {
+  bool wide = S.x >= S.y * 1.2;
+  if (wide) {
+    float rh = S.y / 4.0;
+    int ch = int(clamp(floor(q.y / rh), 0.0, 3.0));
+    vec2 lq = vec2(q.x, q.y - float(ch) * rh);
+    float fs = min(rh * 0.8, 15.0 * U);
+    float lw = 4.2 * MONO_ADV * fs;
+    vec2 gp = lq - vec2(0.0, (rh - fs) * 0.5);
+    float lab = ch == 0 ? aTxt(gp, fs, 66, 83, 83, 0) : (ch == 1 ? aTxt(gp, fs, 77, 73, 68, 0) : (ch == 2 ? aTxt(gp, fs, 84, 82, 66, 0) : aTxt(gp, fs, 82, 77, 83, 0)));
+    vec3 b = levelBar(lq - vec2(lw, 0.0), vec2(S.x - lw, rh), ch);
+    return vec3(max(lab * 0.9, b.x), b.y, 0.0);
+  }
+  float cw = S.x / 4.0;
+  int ch = int(clamp(floor(q.x / cw), 0.0, 3.0));
+  float fs = min(cw * 0.7, 15.0 * U);
+  float lh = fs * 1.5;
+  vec2 lq = vec2(q.x - float(ch) * cw, q.y);
+  vec2 gp = lq - vec2((cw - 3.0 * MONO_ADV * fs) * 0.5, S.y - lh);
+  float lab = ch == 0 ? aTxt(gp, fs, 66, 83, 83, 0) : (ch == 1 ? aTxt(gp, fs, 77, 73, 68, 0) : (ch == 2 ? aTxt(gp, fs, 84, 82, 66, 0) : aTxt(gp, fs, 82, 77, 83, 0)));
+  vec3 b = levelBar(lq, vec2(cw, S.y - lh), ch);
+  return vec3(max(lab * 0.9, b.x), b.y, 0.0);
+}
+
+// live number, left aligned and sized to the cell width: 1 rms, 2 cut count (flashes hot for 4 frames), 3 frame, 4 timecode, 5 bpm
+vec3 pReadEd(vec2 q, vec2 S, int v, vec4 clk) {
+  int nch = v == 4 ? 8 : (v == 3 ? 4 : 3);
+  float fs = min(S.x / (float(nch) * MONO_ADV), S.y / 0.86);
+  vec2 p = q - vec2(0.0, S.y * 0.5 - fs * 0.455);
+  float ink = 0.0;
+  if (v == 1) { ink = aNum(p, fs, floor(stLevel().a * 999.0), 3); }
+  if (v == 2) { ink = aNum(p, fs, mod(clk.x, 1000.0), 3); }
+  if (v == 3) { ink = aNum(p, fs, mod(float(FRAMEINDEX), 10000.0), 4); }
+  if (v == 5) { ink = aNum(p, fs, floor(AUDIO_BPM), 3); }
+  if (v == 4) {
+    float adv = MONO_ADV * fs;
+    ink = aNum(p, fs, mod(floor(TIME / 60.0), 100.0), 2) + aGlyph(p - vec2(2.0 * adv, 0.0), 58, fs)
+        + aNum(p - vec2(3.0 * adv, 0.0), fs, mod(floor(TIME), 60.0), 2) + aGlyph(p - vec2(5.0 * adv, 0.0), 58, fs)
+        + aNum(p - vec2(6.0 * adv, 0.0), fs, mod(float(FRAMEINDEX), 30.0), 2);
+  }
+  ink = min(ink, 1.0);
+  float pulse = v == 2 && clk.x > 0.5 && float(FRAMEINDEX) - clk.y < 3.5 ? 1.0 : 0.0;
+  return vec3(ink, ink * pulse, 0.0);
+}
+
+// registration mark: ring, inner ring and a cross reaching past the ring; an accent dot follows the spectral
+// balance (x) and loudness (y) and an onset throws a second ring for three frames
+vec3 pRegMark(vec2 q, vec2 S, vec4 clk) {
+  vec4 lv = stLevel();
+  vec2 c = S * 0.5;
+  float R = min(S.x, S.y) * 0.5;
+  vec2 d = q - c;
+  float r = length(d);
+  float r0 = R * 0.6;
+  float ink = max(hl(r - r0), hl(r - r0 * 0.28)) * 0.9;
+  ink = max(ink, max(hl(d.y) * step(abs(d.x), R * 0.96), hl(d.x) * step(abs(d.y), R * 0.96)) * 0.9);
+  vec2 tp = c + vec2(0.5 * r0 * (lv.b - lv.r), -0.6 * r0 * (lv.a * 1.8 - 0.7));
+  float hitF = float(FRAMEINDEX) - clk.w;
+  float ringB = hitF < 3.0 && clk.z > 0.5 ? hl(r - r0 * (1.0 + 0.22 * (hitF + 1.0))) : 0.0;
+  float hot = max(inBox(q - tp, vec2(-3.5 * U), vec2(3.5 * U)), ringB);
+  return vec3(ink, hot, 0.0);
+}
+
+// a type cell: window of the text sheet; 1..4 level fill (bass, mid, treble, rms) with a level hairline; 5 hot sweep per onset
+vec3 pType(vec2 q, vec2 S, int v, int rot, vec3 src, int ch, vec4 clk) {
+  vec2 tq = rot == 1 ? vec2(S.y - q.y, q.x) : (rot == 2 ? vec2(q.y, S.x - q.x) : q);
+  float m = sheetC(src.xy * (RENDERSIZE / vec2(32.0, 18.0)) + tq / src.z, ch);
+  float hot = 0.0;
+  float line = 0.0;
+  if (v >= 1 && v <= 4) {
+    float lv = stLevel()[v - 1];
+    float yl = S.y * (1.0 - lv);
+    hot = m * step(yl, q.y);
+    line = hl(q.y - yl) * 0.55 * step(0.03, lv);
+  }
+  if (v == 5) {
+    float age = float(FRAMEINDEX) - clk.w;
+    float x0 = S.x * (age / 7.0 - 0.18);
+    hot = m * step(0.0, age) * step(age, 7.5) * step(x0, q.x) * step(q.x, x0 + S.x * 0.18) * step(0.5, clk.z);
+  }
+  return vec3(m, max(hot, line), 0.0);
+}
+
+// rules. 1: horizontal hairline; 2: vertical hairline; 3: baseline with a tick scale; 4..7: level bar (bass, mid, treble, rms);
+// 8: ruled rows, one hairline per grid unit
+vec3 pRule(vec2 q, vec2 S, int v) {
+  float inx = step(-0.5, q.x) * step(q.x, S.x + 0.5);
+  float iny = step(-0.5, q.y) * step(q.y, S.y + 0.5);
+  if (v == 1) { return vec3(hl(q.y - S.y * 0.5) * inx, 0.0, 0.0); }
+  if (v == 2) { return vec3(hl(q.x - S.x * 0.5) * iny, 0.0, 0.0); }
+  if (v == 3) {
+    float k = floor(q.x / (8.0 * U) + 0.5);
+    float len = (mod(k, 5.0) < 0.5 ? 12.0 : 5.0) * U;
+    float tk = step(abs(q.x - k * 8.0 * U), HW * 0.5 + 0.25) * step(S.y - len, q.y) * step(q.y, S.y);
+    return vec3(max(hl(q.y - (S.y - HW * 0.5)) * inx, tk) * 0.85, 0.0, 0.0);
+  }
+  if (v >= 4 && v <= 7) { return levelBar(q, S, v - 4); }
+  if (v == 8) {
+    float rows = max(floor(S.y / UN.y + 0.5), 1.0);
+    float k = floor(q.y / (S.y / rows) + 0.5);
+    return vec3(hl(q.y - k * S.y / rows) * inx * 0.7, 0.0, 0.0);
+  }
+  return vec3(0.0);
+}
+
+float frameCov(int frame, vec2 q, vec2 S) {
+  if (frame == 2) { return boxLnW(q, vec2(0.5 * HW), S - vec2(0.5 * HW), HW); }
+  if (frame == 3) {
+    vec2 a = min(q, S - q);
+    float arm = 16.0 * U;
+    float inb = step(-0.5, q.x) * step(q.x, S.x + 0.5) * step(-0.5, q.y) * step(q.y, S.y + 0.5);
+    return max(hl(a.y - 0.5 * HW) * step(a.x, arm), hl(a.x - 0.5 * HW) * step(a.y, arm)) * inb;
+  }
+  return 0.0;
+}

package/skills/agentvfx/templates/brutal/collage/_src/50-typefx.glsl

@@ -0,0 +1,163 @@
+// Role 13, typefx: type that the shader warps every frame. The text sheet is a static mask, so every effect below samples
+// it through a changed coordinate (slices, stretch, history shear, smear taps, echo copies, band-cut fills). The cell holds
+// its place; the letters inside it move on the music. Variants: 1 micro-type field, 2 glyph window, 3 slit-scan word,
+// 4 echo stack, 5 echo ripple, 6 type equalizer. A cell reads one text-sheet channel (0 R, 1 G, 2 B) through its src window.
+// Hits (stHit): x is an onset pulse, y a beat pulse; both jump on the event frame and fall in `release` seconds.
+// The input typeWarp scales every audio-driven warp below (0 holds the type still, 1 default, 1.5 harder).
+vec2 gP;
+
+float winM(vec2 tq, vec3 src, int ch) { return sheetC(src.xy * (RENDERSIZE / vec2(32.0, 18.0)) + tq / src.z, ch); }
+// re-sharpen a magnified glyph edge back to about one pixel
+float crisp(float m, float s) {
+  float k = 0.5 / max(s, 1.0);
+  return smoothstep(0.5 - k, 0.5 + k, m);
+}
+float edgeOf(float raw) { return clamp(4.0 * raw * (1.0 - raw), 0.0, 1.0); }
+// history (x beat pulse signed per hit, y mid, z treble, w rms), delay in frames, linear between frames
+vec4 stHist(float delay) {
+  float d = clamp(delay, 0.0, 62.0);
+  float i0 = floor(d);
+  return mix(texelFetch(state, ivec2(63 - int(i0), 7), 0), texelFetch(state, ivec2(62 - int(i0), 7), 0), d - i0);
+}
+vec3 fxFootage(vec2 p) {
+  if (!HAS_INPUT) { return inkColor.rgb * 0.4; }
+  return footageBody(p, RENDERSIZE, 0.0, 0);
+}
+
+// micro-type lines live in the bottom band of the G sheet (5 lines from 84 percent of the height) and the B sheet (8 lines
+// from 78 percent), one line per 2.5 percent of the height, as the text items microK and microM
+vec3 microBand(int ch) { return ch == 1 ? vec3(0.84, 5.0, 0.025) : vec3(0.78, 8.0, 0.025); }
+
+// rows of real text (system fonts through the sheet); each row is one spectrum band (bass at the bottom), lit up to its level,
+// the front glyphs hot. Active rows pick another line and start on every onset. Returns (ink coverage, hot coverage).
+vec2 microCov(vec2 q, vec2 S, vec4 clk, vec3 src, int ch) {
+  if (ch == 0) { return vec2(0.0); }
+  vec3 band = microBand(ch);
+  float rowH = band.z * RENDERSIZE.y * src.z;
+  float row = floor(q.y / rowH);
+  float lvl = bandAt(clamp(1.0 - (row + 0.5) * rowH / S.y, 0.0, 1.0));
+  float seed = row * 1.7 + step(0.3, lvl) * clk.z * 3.1;
+  float line = floor(hash12(vec2(seed, 2.0)) * band.y);
+  float xo = hash12(vec2(seed, 5.0)) * RENDERSIZE.x;
+  vec2 sp = vec2(mod(q.x / src.z + xo, RENDERSIZE.x), band.x * RENDERSIZE.y + line * band.z * RENDERSIZE.y + (q.y - row * rowH) / src.z);
+  float g = crisp(sheetC(sp, ch), src.z);
+  float lit = step(q.x, lvl * S.x);
+  float front = lit * step(lvl * S.x - q.x, 28.0 * U + 12.0) * step(0.25, lvl);
+  return vec2(g * mix(0.2, 0.85, lit), g * front);
+}
+
+// 2: giant glyph window. Footage (or, with tone accent, a solid fill) shows through the letter with the micro-type running on
+// over it; a hard extrusion (darker the deeper it goes) runs down-left behind it and grows on each onset; the letter stretches
+// taller on the onset and tears into horizontal slices that jump sideways on every beat.
+void fxGlyph(vec2 q, vec2 S, vec3 src, int ch, int tone, vec4 clk, vec3 cInk, vec3 cHot, inout vec3 col) {
+  vec4 hit = stHit() * typeWarp;
+  float band = floor(q.y / (S.y / 9.0));
+  float h = hash12(vec2(band, clk.z * 1.37 + 5.0));
+  float dx = (fract(h * 7.0) * 2.0 - 1.0) * step(0.4, h) * max(hit.y, hit.x * 0.45) * S.x * 0.13;
+  vec2 qq = vec2(q.x - dx, S.y * 0.5 + (q.y - S.y * 0.5) / (1.0 + 0.2 * hit.x));
+  float raw = winM(qq, src, ch);
+  float m = crisp(raw, src.z);
+  float reach = (30.0 + 90.0 * hit.x) * U;
+  for (int i = 10; i >= 1; i--) {
+    float t = float(i) / 10.0;
+    float me = crisp(winM(qq - vec2(-0.8, 0.6) * reach * t, src, ch), src.z);
+    col = mix(col, cHot * (1.0 - 0.6 * t), me);
+  }
+  bool solid = tone == 2;
+  vec2 mc = microCov(gP, RENDERSIZE, clk, vec3(0.0, 0.0, 1.0), 2);
+  vec3 f = solid ? cInk : mix(fxFootage(gP), groundColor.rgb, mc.x * 0.6);
+  col = mix(col, f, m);
+  col = mix(col, solid ? groundColor.rgb : cInk, edgeOf(raw) * 0.9);
+}
+
+// 3: slit-scan word. Every row reads the hit history (beat pulse, onsets at 0.4) at its own delay, so each hit enters at the
+// bottom row and travels up the letters as a sideways shear (direction chosen per hit); rows inside a shear jitter; the word
+// smears into a streak on the beat (onsets smear at 0.3). The footage stays still behind the moving letter window.
+void fxSlit(vec2 q, vec2 S, vec3 src, int ch, vec4 clk, vec3 cInk, vec3 cHot, inout vec3 col) {
+  vec4 hits = stHit() * typeWarp;
+  float hp = max(hits.y, 0.3 * hits.x);
+  float delay = (1.0 - clamp(q.y / S.y, 0.0, 1.0)) * 22.0;
+  float sh = 0.0;
+  for (int i = -2; i <= 2; i++) { sh += stHist(delay + float(i)).x * (i == 0 ? 0.32 : (abs(i) == 1 ? 0.22 : 0.12)); }
+  sh *= typeWarp;
+  float jit = (hash12(vec2(floor(q.y / max(U * 6.0, 2.0)), clk.z)) - 0.5) * abs(sh);
+  float dx = sh * S.x * 0.075 + jit * S.x * 0.04;
+  float dir = hash12(vec2(clk.z, 4.0)) < 0.5 ? 1.0 : -1.0;
+  float len = S.x * 0.2 * hp;
+  float streak = 0.0;
+  for (int i = 1; i < 13; i++) {
+    float t = float(i) / 12.0;
+    streak = max(streak, crisp(winM(vec2(q.x - dx - dir * t * len, q.y), src, ch), src.z) * (1.0 - t));
+  }
+  float raw = winM(vec2(q.x - dx, q.y), src, ch);
+  float m = crisp(raw, src.z);
+  col = mix(col, cHot, streak * (1.0 - m));
+  col = mix(col, fxFootage(gP), m);
+  col = mix(col, cInk, edgeOf(raw) * 0.9);
+}
+
+// 4: echo stack. The word repeats 2..10 times (the count follows the rms and jumps by up to 4 on the beat frame, by 1.6 on
+// an onset), each copy stepped up-right and a little larger, painted back to front: odd copies solid hot, even copies knocked
+// out to the ground, every edge in ink, and the footage in the front copy.
+void fxEcho(vec2 q, vec2 S, vec3 src, int ch, vec3 cInk, vec3 cHot, vec3 cGnd, inout vec3 col) {
+  vec4 hits = stHit();
+  int n = min(2 + int(floor(typeWarp * (4.0 * stLevel().a + 4.0 * max(hits.y, 0.4 * hits.x)) + 0.5)), 11);
+  vec2 c = S * 0.5;
+  vec2 stp = vec2(S.x * 0.017, -S.y * 0.034);
+  for (int j = 0; j < 11; j++) {
+    int k = n - 1 - j;
+    if (k < 0) { break; }
+    float sk = 1.0 + 0.05 * float(k);
+    float raw = winM((q - c - stp * float(k)) / sk + c, src, ch);
+    float m = crisp(raw, src.z * sk);
+    bool odd = mod(float(k), 2.0) > 0.5;
+    col = mix(col, odd ? cHot : cGnd, m);
+    col = mix(col, cInk, edgeOf(raw) * (odd ? 0.95 : 0.8));
+    if (k == 0) { col = mix(col, fxFootage(gP), m); }
+  }
+}
+
+// 5: echo ripple. The word is ringed by 2..12 hairline outlines growing out of it from the centre of the cell (alternate rings
+// hot, ink), the count following the rms and the beat as in the stack; the footage fills the word itself.
+void fxRipple(vec2 q, vec2 S, vec3 src, int ch, vec3 cInk, vec3 cHot, inout vec3 col) {
+  vec4 hits = stHit();
+  int n = min(2 + int(floor(typeWarp * (5.0 * stLevel().a + 5.0 * max(hits.y, 0.4 * hits.x)) + 0.5)), 12);
+  vec2 c = S * 0.5;
+  for (int j = 0; j < 12; j++) {
+    int k = n - 1 - j;
+    if (k < 0) { break; }
+    float raw = winM((q - c) / (1.0 + 0.11 * float(k)) + c, src, ch);
+    if (k > 0) { col = mix(col, mod(float(k), 2.0) > 0.5 ? cHot : cInk, edgeOf(raw) * 0.9); continue; }
+    col = mix(col, fxFootage(gP), crisp(raw, src.z));
+    col = mix(col, cInk, edgeOf(raw) * 0.9);
+  }
+}
+
+// 6: type equalizer. The word is the analyzer: every column of the letters is filled solid up to the level of the spectrum band
+// under it (bass at the left); above the level the letters are only an outline over a dim footage ghost.
+void fxEq(vec2 q, vec2 S, vec3 src, int ch, vec3 cInk, vec3 cHot, inout vec3 col) {
+  float raw = winM(q, src, ch);
+  float m = crisp(raw, src.z);
+  float lv = clamp(bandAt(clamp(q.x / S.x, 0.0, 1.0)) + 0.3 * stHit().y * typeWarp, 0.0, 1.0);
+  float on = step(S.y * (1.0 - lv), q.y);
+  col = mix(col, fxFootage(gP), m * (1.0 - on) * 0.45);
+  col = mix(col, cHot, m * on);
+  col = mix(col, cInk, edgeOf(raw) * mix(0.9, 0.35, on));
+}
+
+void drawTypeFx(int v, vec4 aux, int ch, int tone, vec2 q, vec2 S, vec4 clk, vec3 cInk, vec3 cHot, inout vec3 col) {
+  int rot = int(aux.x + 0.5);
+  vec3 src = vec3(aux.yz, aux.w);
+  vec2 tq = rot == 1 ? vec2(S.y - q.y, q.x) : (rot == 2 ? vec2(q.y, S.x - q.x) : q);
+  vec2 TS = rot == 0 ? S : S.yx;
+  if (v == 1) {
+    vec2 mc = microCov(tq, TS, clk, src, ch);
+    col = mix(col, cInk, mc.x);
+    col = mix(col, cHot, mc.y);
+  }
+  if (v == 2) { fxGlyph(tq, TS, src, ch, tone, clk, cInk, cHot, col); }
+  if (v == 3) { fxSlit(tq, TS, src, ch, clk, cInk, cHot, col); }
+  if (v == 4) { fxEcho(tq, TS, src, ch, cInk, cHot, groundColor.rgb, col); }
+  if (v == 5) { fxRipple(tq, TS, src, ch, cInk, cHot, col); }
+  if (v == 6) { fxEq(tq, TS, src, ch, cInk, cHot, col); }
+}

package/skills/agentvfx/templates/brutal/collage/_src/60-scene-lib.glsl

@@ -0,0 +1,104 @@
+// Role 14, scene: a whole mixed-material collage in one cell (flat fields, an image treatment of the plate, geometric
+// primitives, pixel matter, leader lines, instruments and several type roles). Compositions are written in unit space
+// (height 1, width = cell aspect) so a scene scales with its cell. The scene reads the text sheet of its own set
+// (input textSet) through its own positions, and the tint colours for what the three palette colours cannot hold.
+// Hits: stHit().x onset pulse, .y beat pulse; the cut count (clk.x) moves on the beat.
+vec2 scS;
+float scU;
+
+float scAA(float d) { return clamp(0.5 - d * scU, 0.0, 1.0); }
+float scLine(float d, float w) { return clamp(0.5 * w - abs(d * scU) + 0.5, 0.0, 1.0); }
+float scPx() { return max(2.0, floor(6.0 * U + 0.5)); }
+float scCell() { return max(2.0, floor(3.0 * U + 0.5)); }
+float scPlus(vec2 c, vec2 p, float arm) {
+  vec2 d = abs(c - p);
+  return max(scLine(c.y - p.y, 1.0) * step(d.x, arm), scLine(c.x - p.x, 1.0) * step(d.y, arm));
+}
+float scBox(vec2 c, vec2 lo, vec2 hi) { return step(lo.x, c.x) * step(c.x, hi.x) * step(lo.y, c.y) * step(c.y, hi.y); }
+float sdBox(vec2 p, vec2 lo, vec2 hi) {
+  vec2 d = abs(p - 0.5 * (lo + hi)) - 0.5 * (hi - lo);
+  return length(max(d, 0.0)) + min(max(d.x, d.y), 0.0);
+}
+float sdArch(vec2 p, vec2 lo, vec2 hi) {
+  float r = 0.5 * (hi.x - lo.x);
+  vec2 ctr = vec2(0.5 * (lo.x + hi.x), lo.y + r);
+  return p.y < ctr.y ? length(p - ctr) - r : sdBox(p, vec2(lo.x, ctr.y), hi);
+}
+float sdSeg(vec2 p, vec2 a, vec2 b) {
+  vec2 pa = p - a;
+  vec2 ba = b - a;
+  return length(pa - ba * clamp(dot(pa, ba) / dot(ba, ba), 0.0, 1.0));
+}
+// rectangle with its four corners cut at 45 degrees by ch (the octagon media window)
+float sdChamfer(vec2 p, vec2 lo, vec2 hi, float ch) {
+  vec2 q = abs(p - 0.5 * (lo + hi)) - 0.5 * (hi - lo);
+  return max(max(q.x, q.y), (q.x + q.y + ch) * 0.7071);
+}
+// starburst glyph: n thin rays from radius inner out to R (each ray as long as the spectrum band it is hashed to), turned by rot
+float scBurst(vec2 p, float R, float inner, float rot, float n) {
+  float a = atan(p.y, p.x) + rot;
+  float id = floor(a * n / 6.28318);
+  float da = (fract(a * n / 6.28318) - 0.5) * 6.28318 / n;
+  float len = R * (0.45 + 0.55 * bandAt(fract(id * 0.37)));
+  float r = length(p);
+  return scLine(da * r, 1.0) * step(inner, r) * step(r, len);
+}
+float scBayer(vec2 pix) {
+  ivec2 p = ivec2(mod(pix, 8.0));
+  int v = 0;
+  for (int i = 0; i < 3; i++) { v = (v << 2) | ((((p.x ^ p.y) >> i) & 1) << 1) | ((p.y >> i) & 1); }
+  return (float(v) + 0.5) / 64.0;
+}
+
+// the plate cover-fitted into the window lo..hi (cell px)
+vec3 scPlate(vec2 q, vec2 lo, vec2 hi) { return HAS_INPUT ? footageBody(q - lo, hi - lo, 0.0, 0) : vec3(0.3); }
+float scTone(vec2 q, vec2 lo, vec2 hi, float gain, float lift) { return clamp((luma(scPlate(q, lo, hi)) - lift) * gain, 0.0, 1.0); }
+
+// plate edge strength (central differences of the luma at step d px): the wireframe look
+float scEdge(vec2 q, vec2 lo, vec2 hi, float d) {
+  float gx = luma(scPlate(q + vec2(d, 0.0), lo, hi)) - luma(scPlate(q - vec2(d, 0.0), lo, hi));
+  float gy = luma(scPlate(q + vec2(0.0, d), lo, hi)) - luma(scPlate(q - vec2(0.0, d), lo, hi));
+  return length(vec2(gx, gy));
+}
+// the text sheet at the same place on screen (1 : 1 for a full-frame cell)
+float scSheet(vec2 q, int ch) { return sheetC(q * (RENDERSIZE / scS), ch); }
+// a sheet word drawn with its own scale k (screen px per sheet px) so it can be squeezed or stretched: sheet point sheetLo lands at screen px o
+float scWord(vec2 q, vec2 o, vec2 sheetLo, vec2 k, int ch) {
+  float m = sheetC(sheetLo + (q - o) / (k * scS.y / RENDERSIZE.y), ch);
+  return crisp(m, max(max(k.x, k.y), 1.0));
+}
+// the same with the horizontal strokes thinned (vertical erosion of d sheet px), for faux-tall type whose crossbars stretch
+float scWordThin(vec2 q, vec2 o, vec2 sheetLo, vec2 k, int ch, float d) {
+  vec2 sp = sheetLo + (q - o) / (k * scS.y / RENDERSIZE.y);
+  float m = min(sheetC(sp, ch), min(sheetC(sp - vec2(0.0, d), ch), sheetC(sp + vec2(0.0, d), ch)));
+  return crisp(m, max(max(k.x, k.y), 1.0));
+}
+
+// dot halftone on a 30 degree grid: dot radius follows the plate under the dot centre; 1 where the dot is
+float scDots(vec2 q, vec2 lo, vec2 hi, float pitch, float gain, float lift, float inv) {
+  mat2 R = mat2(0.866, 0.5, -0.5, 0.866);
+  vec2 g = R * q / pitch;
+  vec2 id = floor(g) + 0.5;
+  vec2 cq = transpose(R) * (id * pitch);
+  float l = scTone(cq, lo, hi, gain, lift);
+  l = mix(l, 1.0 - l, inv);
+  float r = 0.62 * sqrt(l);
+  return clamp((r - length(g - id)) * pitch + 0.5, 0.0, 1.0);
+}
+// QR-like stamp of 21 x 21 modules: 1 dark, 0 light, -1 outside; three finder squares, the rest re-seeded by seed
+float scFinder(vec2 m, vec2 o) {
+  vec2 d = m - o;
+  if (d.x < 0.0 || d.y < 0.0 || d.x > 6.0 || d.y > 6.0) { return -1.0; }
+  bool ring = d.x < 0.5 || d.x > 5.5 || d.y < 0.5 || d.y > 5.5;
+  bool core = d.x > 1.5 && d.x < 4.5 && d.y > 1.5 && d.y < 4.5;
+  return ring || core ? 1.0 : 0.0;
+}
+float scQR(vec2 p, vec2 lo, float size, float seed) {
+  vec2 u = (p - lo) / size;
+  if (u.x < 0.0 || u.y < 0.0 || u.x >= 1.0 || u.y >= 1.0) { return -1.0; }
+  vec2 m = floor(u * 21.0);
+  float f = max(max(scFinder(m, vec2(0.0)), scFinder(m, vec2(14.0, 0.0))), scFinder(m, vec2(0.0, 14.0)));
+  if (f >= 0.0) { return f; }
+  if ((m.x < 8.0 && m.y < 8.0) || (m.x > 12.0 && m.y < 8.0) || (m.x < 8.0 && m.y > 12.0)) { return 0.0; }
+  return step(0.5, hash12(m + seed * 17.3));
+}

package/skills/agentvfx/templates/brutal/collage/_src/61-scene-specimen.glsl

@@ -0,0 +1,71 @@
+// Scene 1, specimen: a deep ultramarine field; the plate as a single-tone lavender dither inside a tall arch; one ultra-tall
+// thin word as a column; pink and cyan micro bars on the arch edges that are spectrum band levels; a solid black square with a
+// semicircle that snaps to a new place of a fixed set on every cut; mono captions with live numbers. Palette: ground (field),
+// ink (lavender), accent (pink), tintA (cyan), tintB (black). Text set 1.
+vec2 spPair(float i) {
+  if (i < 0.5) { return vec2(1.44, 0.10); }
+  if (i < 1.5) { return vec2(0.50, 0.70); }
+  if (i < 2.5) { return vec2(1.44, 0.62); }
+  if (i < 3.5) { return vec2(1.14, 0.78); }
+  if (i < 4.5) { return vec2(0.50, 0.08); }
+  return vec2(1.22, 0.34);
+}
+
+void sceneSpecimen(vec2 q, vec2 S, vec4 clk, inout vec3 col) {
+  vec2 c = q / scU;
+  float A = S.x / S.y;
+  vec4 hit = stHit();
+  vec3 lav = inkColor.rgb;
+  vec3 pink = accentColor.rgb;
+  vec3 cyan = tintA.rgb;
+  vec3 blk = tintB.rgb;
+  col = groundColor.rgb;
+  col = mix(col, mix(groundColor.rgb, blk, 0.45), scAA(sdBox(c, vec2(0.03, 0.035), vec2(0.70, 0.965))));
+  vec2 lo = vec2(0.76, 0.07);
+  vec2 hi = vec2(1.36, 0.93);
+  // dithered plate in the arch
+  float px = scPx();
+  vec2 pix = floor(q / px);
+  float inside = scAA(sdArch(c, lo, hi));
+  float l = pow(scTone((pix + 0.5) * px, lo * scU, hi * scU, 1.6, 0.15), 0.65) * 0.92 + 0.08 * hit.y;
+  col = mix(col, mix(mix(groundColor.rgb, blk, 0.6), lav, step(scBayer(pix), l)), inside);
+  col = mix(col, lav, scLine(sdArch(c, lo - 0.016, hi + 0.016), 1.0));
+  // band-level micro bars on the straight sides of the arch: pink on the left, cyan on the right
+  float y0 = (lo.y + 0.5 * (hi.x - lo.x)) * scU;
+  float y1 = (hi.y - 0.02) * scU;
+  float row = floor((q.y - y0) / 4.0);
+  float t = clamp((row * 4.0 + 2.0) / (y1 - y0), 0.0, 1.0);
+  float inRow = step(0.0, q.y - y0) * step(q.y, y1) * step(mod(q.y - y0, 4.0), 2.0);
+  float lenL = floor((0.012 + 0.095 * bandAt(t)) * scU / 2.0) * 2.0;
+  float lenR = floor((0.012 + 0.095 * bandAt(1.0 - t * 0.8)) * scU / 2.0) * 2.0;
+  float xl = (lo.x - 0.016) * scU;
+  float xr = (hi.x + 0.016) * scU;
+  col = mix(col, pink, inRow * step(xl - lenL, q.x) * step(q.x, xl - 1.0));
+  col = mix(col, cyan, inRow * step(xr + 1.0, q.x) * step(q.x, xr + lenR));
+  // rules, ticks and a dot grid
+  float rule = max(scLine(c.y - 0.035, 1.0), scLine(c.y - 0.965, 1.0)) * step(0.05, c.x) * step(c.x, A - 0.05);
+  float tick = step(mod(q.x, 0.04 * scU), 1.0) * step(abs(c.y - 0.965), 0.014) * step(0.05, c.x) * step(c.x, A - 0.05);
+  col = mix(col, lav, max(rule * 0.8, tick * 0.8));
+  col = mix(col, lav, max(max(scPlus(c, vec2(0.03, 0.035), 0.016), scPlus(c, vec2(0.70, 0.035), 0.016)), max(scPlus(c, vec2(0.03, 0.965), 0.016), scPlus(c, vec2(0.70, 0.965), 0.016))));
+  vec2 dg = (c - vec2(1.44, 0.83)) / 0.026;
+  float dots = scAA((length(fract(dg) - 0.5) * 0.026 - 0.004)) * step(0.0, dg.x) * step(dg.x, 9.0) * step(0.0, dg.y) * step(dg.y, 4.0);
+  col = mix(col, lav, dots * 0.7);
+  // the tall word: Pretendard Thin stretched up and squeezed in
+  float w = scWordThin(q, vec2(0.05, -0.05) * scU, vec2(0.0, 0.0), vec2(0.35, 1.43), 0, 3.5);
+  col = mix(col, lav, w);
+  // the black square and semicircle: a new place of the fixed set on every cut
+  float i = mod(floor(clk.x) * 5.0 + floor(hash12(vec2(floor(clk.x / 6.0), 7.0)) * 6.0), 6.0);
+  vec2 P = spPair(i);
+  float s = 0.13;
+  float sq = scAA(sdBox(c, P, P + s));
+  vec2 sc = P + vec2(s, 0.5 * s);
+  sc.x += 0.03;
+  float semi = scAA(max(length(c - sc) - 0.5 * s, -(c.x - sc.x)));
+  col = mix(col, blk, max(sq, semi));
+  // captions and live numbers (MesloLGS NF)
+  col = mix(col, lav, scSheet(q, 1));
+  vec2 np = q - vec2(1.44, 0.50) * scU;
+  float fs = 0.03 * scU;
+  float num = aNum(np, fs, floor(stLevel().r * 99.0), 2) + aNum(np - vec2(3.0 * MONO_ADV * fs, 0.0), fs, floor(stLevel().g * 99.0), 2) + aNum(np - vec2(6.0 * MONO_ADV * fs, 0.0), fs, floor(stLevel().b * 99.0), 2);
+  col = mix(col, pink, min(num, 1.0));
+}

package/skills/agentvfx/templates/brutal/collage/_src/62-scene-wiring.glsl

@@ -0,0 +1,96 @@
+// Scene 2, wiring: a black ground, the plate as a cyan / yellow duotone with scanline bands that re-seed on every cut, five yellow
+// cables from fixed points on the CRT wall to boxed annotations (small Monument Extended caps and live readouts in a pixel font),
+// quarter pixel arcs and a dot grid in the bottom-left corner, and a small crimson pixel glyph that blinks on every onset.
+// Each onset sends a packet down the next cable and flashes its box. Palette: ground (black), ink (label white), accent (yellow),
+// tintA (cyan), tintB (crimson). Text set 2.
+const vec2 W_A[5] = vec2[5](vec2(0.663, 0.4355), vec2(0.573, 0.5775), vec2(0.663, 0.7195), vec2(1.115, 0.4355), vec2(1.025, 0.7195));
+const vec2 W_B[5] = vec2[5](vec2(0.05, 0.14), vec2(0.05, 0.40), vec2(0.05, 0.62), vec2(1.43, 0.10), vec2(1.43, 0.62));
+const vec2 W_SZ = vec2(0.30, 0.105);
+const int W_GLYPH[7] = int[7](20, 62, 107, 127, 62, 34, 65);
+
+vec2 wTail(int i) { return W_B[i] + (i < 3 ? vec2(W_SZ.x, 0.5 * W_SZ.y) : vec2(0.0, 0.5 * W_SZ.y)); }
+vec2 wElbow(vec2 A, vec2 T) { return vec2(T.x + sign(A.x - T.x) * abs(A.y - T.y), T.y); }
+float wCable(vec2 c, vec2 A, vec2 T, float w) {
+  vec2 E = wElbow(A, T);
+  return max(scLine(sdSeg(c, A, E), w), scLine(sdSeg(c, E, T), w));
+}
+vec2 wAlong(vec2 A, vec2 T, float t) {
+  vec2 E = wElbow(A, T);
+  float l1 = length(E - A);
+  float d = t * (l1 + length(T - E));
+  return d < l1 ? mix(A, E, d / max(l1, 1e-4)) : mix(E, T, (d - l1) / max(length(T - E), 1e-4));
+}
+
+void sceneWiring(vec2 q, vec2 S, vec4 clk, inout vec3 col) {
+  vec2 c = q / scU;
+  float A = S.x / S.y;
+  vec4 hit = stHit();
+  vec3 white = inkColor.rgb;
+  vec3 yel = accentColor.rgb;
+  vec3 cyan = tintA.rgb;
+  vec3 red = tintB.rgb;
+  float cut = floor(clk.x);
+  // plate: cyan / yellow duotone, scanline bands re-seeded on the cut, one slice thrown sideways on the beat
+  float sliceY = hash12(vec2(cut, 3.0));
+  float shift = step(abs(c.y - sliceY), 0.025) * hit.y * 0.05 * scU;
+  float l = clamp((luma(scPlate(q + vec2(shift, 0.0), vec2(0.0), S)) - 0.1) * 1.5, 0.0, 1.0);
+  vec3 d = mix(groundColor.rgb, cyan * 0.45, smoothstep(0.0, 0.4, l));
+  d = mix(d, cyan, smoothstep(0.35, 0.7, l));
+  d = mix(d, yel, smoothstep(0.66, 0.95, l));
+  float band = step(0.62, hash12(vec2(floor(c.y / 0.03), cut)));
+  d *= (1.0 - 0.22 * step(0.5, fract(c.y / 0.012))) * (1.0 - 0.5 * band);
+  d *= mix(0.45, 1.0, smoothstep(1.05, 0.3, length((c - vec2(0.5 * A, 0.5)) * vec2(0.8, 1.2))));
+  col = d;
+  // cables and anchors
+  int act = int(mod(clk.z, 5.0));
+  float age = float(FRAMEINDEX) - clk.w;
+  for (int i = 0; i < 5; i++) {
+    vec2 T = wTail(i);
+    bool on = i == act && clk.z > 0.5;
+    float flash = on ? step(0.3, hit.x) : 0.0;
+    col = mix(col, vec3(0.0), wCable(c, W_A[i], T, 4.0) * 0.85);
+    col = mix(col, mix(yel, white, flash), wCable(c, W_A[i], T, on ? 2.0 : 1.2));
+    float ring = scLine(length(c - W_A[i]) - 0.014, 1.2);
+    col = mix(col, vec3(0.0), scAA(length(c - W_A[i]) - 0.018) * 0.5);
+    col = mix(col, yel, max(ring, scAA(sdBox(c, W_A[i] - 0.004, W_A[i] + 0.004))));
+    if (on && age < 9.0) {
+      vec2 pp = wAlong(W_A[i], T, (age + 1.0) / 9.0);
+      col = mix(col, white, scAA(sdBox(c, pp - 0.007, pp + 0.007)));
+    }
+    // box: black plate, yellow outline, a live readout in the pixel font and a segmented level bar
+    float bf = scAA(sdBox(c, W_B[i], W_B[i] + W_SZ));
+    col = mix(col, mix(vec3(0.0), yel, flash), bf * 0.9);
+    col = mix(col, yel, scLine(sdBox(c, W_B[i], W_B[i] + W_SZ), 1.0));
+    float lev = bandAt(0.06 + 0.2 * float(i));
+    float cell = cellPx(0.0062 * scU);
+    vec2 np = q - (W_B[i] + vec2(0.014, 0.058)) * scU;
+    float num = numTxt(np, vec2(0.0), cell, floor(lev * 999.0), 3);
+    vec2 bp = (c - (W_B[i] + vec2(0.115, 0.064))) / vec2(0.17, 0.02);
+    float seg = step(0.0, bp.x) * step(bp.x, 1.0) * step(0.0, bp.y) * step(bp.y, 1.0) * step(mod(bp.x * 14.0, 1.0), 0.62);
+    float litSeg = step(bp.x, lev);
+    col = mix(col, mix(flash > 0.5 ? vec3(0.0) : yel, cyan, 1.0 - litSeg), seg * mix(0.35, 1.0, litSeg));
+    col = mix(col, flash > 0.5 ? vec3(0.0) : yel, min(num, 1.0));
+  }
+  // pixel arcs and a dot grid, bottom-left
+  float px = scPx();
+  vec2 pc = (floor(q / px) + 0.5) * px - vec2(0.0, S.y);
+  float r = length(pc) / scU;
+  float ring = floor((r - 0.05) / 0.036);
+  float ang = atan(-pc.y, pc.x) / 1.5708;
+  float seg = floor(ang * (5.0 + ring));
+  float arc = step(0.0, ring) * step(ring, 5.0) * step(fract((r - 0.05) / 0.036), 0.55) * step(0.0, ang) * step(ang, 1.0) * step(mod(seg + cut * (ring + 1.0), 3.0), 1.5);
+  col = mix(col, yel, arc);
+  vec2 dg = (c - vec2(0.27, 0.935)) / 0.026;
+  float dots = scAA(length(fract(dg) - 0.5) * 0.026 - 0.004) * step(0.0, dg.x) * step(dg.x, 12.0) * step(0.0, dg.y) * step(dg.y, 2.0);
+  col = mix(col, cyan, dots);
+  // the crimson pixel glyph: dim, full for 5 frames after every onset
+  vec2 gp = floor((c - vec2(0.405, 0.052)) / 0.0118);
+  float gl = 0.0;
+  if (gp.x >= 0.0 && gp.x < 7.0 && gp.y >= 0.0 && gp.y < 7.0) { gl = float((W_GLYPH[int(gp.y)] >> (6 - int(gp.x))) & 1); }
+  col = mix(col, red * (age < 5.0 && clk.z > 0.5 ? 1.0 : 0.3), gl);
+  // letterbox, corner brackets, label caps (Monument Extended)
+  col = mix(col, vec3(0.0), scAA(sdBox(c, vec2(-1.0), vec2(A + 1.0, 0.045))) + scAA(sdBox(c, vec2(-1.0, 0.955), vec2(A + 1.0, 2.0))));
+  vec2 a = min(c - 0.012, vec2(A, 1.0) - c - 0.012);
+  col = mix(col, white, max(scLine(a.y, 1.0) * step(a.x, 0.03), scLine(a.x, 1.0) * step(a.y, 0.03)) * step(0.0, min(a.x, a.y) + 0.001));
+  col = mix(col, white, scSheet(q, 0) * 0.9);
+}