@pixerate/flair 0.21.0 → 0.22.0

package/dist/{chunk-KD7E3RWF.js → chunk-3RKDS64M.js}

@@ -456,17 +456,16 @@ var imageDuotone = {
   kind: "shader",
   id: "image-duotone",
   name: "Duotone",
-  description: "An image mapped onto two colours, with a slow light sweep.",
+  description: "An image mapped onto two colours, from its shadows to its highlights. For a passing glare, lay `shine-sweep` over it.",
   category: "image",
   video: "filter",
   tags: ["image", "brand", "editorial", "colour"],
   source: glsl(
-    `// Duotone: an image mapped onto two colours, with a light sweep.
+    `// Duotone: an image mapped onto two colours by its brightness.
 uniform sampler2D uImage;  // @control filter=linear wrap=clamp default=${SAMPLE_IMAGES.landscape} label="Image"
 uniform vec3 uShadow;      // @control color default=#1E1B4B label="Shadows"
 uniform vec3 uHighlight;   // @control color default=#FB7185 label="Highlights"
 uniform float uContrast;   // @control min=0.5 max=3 default=1.2 label="Contrast"
-uniform float uSweep;      // @control min=0 max=1 default=0.3 label="Light sweep"
 ${BACKDROP_CONTROLS}`,
     PICTURE,
     `void mainImage(out vec4 fragColor, in vec2 fragCoord) {
@@ -474,9 +473,7 @@ ${BACKDROP_CONTROLS}`,
   vec4 src = pictureRGBA(uImage, uv);
   float l = dot(src.rgb, vec3(0.2126, 0.7152, 0.0722));
   l = clamp((l - 0.5) * uContrast + 0.5, 0.0, 1.0);
-  float sweep = exp(-pow((uv.x + uv.y * 0.4 - fract(iTime * 0.15) * 2.0 + 0.4) * 6.0, 2.0));
-  vec3 col = mix(uShadow, uHighlight, l) + sweep * uSweep;
-  fragColor = vec4(col, src.a);
+  fragColor = vec4(mix(uShadow, uHighlight, l), src.a);
 }`
   ),
   presets: [
@@ -6992,16 +6989,25 @@ void mainImage(out vec4 fragColor, in vec2 fragCoord) {
   float px = 1.0 / iResolution.y;
   vec2 p = fragCoord * px;
   vec4 acc = vec4(0.0);
+  // The clicks are the same for every bubble, so look them up once.
+  vec4 clicks[8];
+  for (int j = 0; j < 8; j++) clicks[j] = clickAt(j, uDemo);
+  // Nothing of a bubble reaches further than this from where it is now: its pop (up to 0.7 s
+  // ago, so it has drifted at most this far since) throws droplets out to 3.6 radii + 0.1.
+  float drift = 0.7 * (uRise + 0.085 * uWobble + 0.04);
+  float far = max(uSize * 0.12, 0.01) * 3.6 + 0.1 + drift + 2.0 * px;
   for (int i = 0; i < 16; i++) {
     if (i >= uCount) break;
     float age;
     float life;
     vec4 b = bubbleAt(i, iTime, age, life);
+    vec2 d0 = p - b.xy;
+    if (dot(d0, d0) > far * far) continue;
     float birth = iTime - age;
     // It pops when its life is up, or at the first click that lands on it.
     float popAt = birth + life;
     for (int j = 0; j < 8; j++) {
-      vec4 c = clickAt(j, uDemo);
+      vec4 c = clicks[j];
       if (c.w < 0.5 || c.z < birth || c.z > iTime || c.z >= popAt) continue;
       float a2;
       float l2;
@@ -8240,10 +8246,36 @@ uniform float uClump;    // @control min=0 max=1 default=0.5 label="Clumping"
 uniform float uPart;     // @control min=0 max=1 default=0.8 label="Parting"`,
     HASH,
     NOISE,
-    `vec2 strandDir(vec2 root, vec2 ptr, float hov) {
-  float a = radians(uLie) + (vnoise(root * 0.07) - 0.5) * 1.6 * uClump;
-  a += uSway * 0.7 * sin(iTime * 1.3 + root.x * 0.05 + root.y * 0.03 + 2.0 * vnoise(root * 0.02 + iTime * 0.15));
+    `// The two slow noise fields that turn the strands, hashed once per pixel on a
+// 3 x 3 lattice that covers every root the pixel looks at.
+mat3 clumpGrid;
+vec2 clumpBase;
+mat3 swayGrid;
+vec2 swayBase;
+
+mat3 noiseGrid(vec2 base) {
+  mat3 g;
+  for (int x = 0; x < 3; x++) {
+    for (int y = 0; y < 3; y++) g[x][y] = hash12(base + vec2(float(x), float(y)));
+  }
+  return g;
+}
+
+// vnoise(q), with its corners read from a lattice hashed at base.
+float gridNoise(vec2 q, vec2 base, mat3 g) {
+  vec2 f = fract(q);
+  vec2 u = f * f * (3.0 - 2.0 * f);
+  ivec2 k = clamp(ivec2(floor(q) - base), 0, 1);
+  vec3 c0 = g[k.x];
+  vec3 c1 = g[k.x + 1];
+  return mix(mix(c0[k.y], c1[k.y], u.x), mix(c0[k.y + 1], c1[k.y + 1], u.x), u.y);
+}
+
+vec2 strandDir(vec2 root, vec2 ptr, float hov) {
+  float a = radians(uLie) + (gridNoise(root * 0.07, clumpBase, clumpGrid) - 0.5) * 1.6 * uClump;
+  a += uSway * 0.7 * sin(iTime * 1.3 + root.x * 0.05 + root.y * 0.03 + 2.0 * gridNoise(root * 0.02 + iTime * 0.15, swayBase, swayGrid));
   vec2 dir = vec2(cos(a), sin(a));
+  if (uPart * hov <= 0.0) return dir;
   vec2 away = root - ptr;
   float reach = 0.16 * uDensity;
   float f = uPart * hov * exp(-dot(away, away) / (reach * reach));
@@ -8254,23 +8286,93 @@ void mainImage(out vec4 fragColor, in vec2 fragCoord) {
   vec2 p = fragCoord / iResolution.y * uDensity;
   vec2 ptr = iPointer.xy / iResolution.y * uDensity;
   float hov = clamp(iPointer.z, 0.0, 1.0);
+  // Every root looked at below lies within 7 cells of p.
+  clumpBase = floor((p - 7.0) * 0.07);
+  clumpGrid = noiseGrid(clumpBase);
+  swayBase = floor((p - 7.0) * 0.02 + iTime * 0.15);
+  swayGrid = noiseGrid(swayBase);
   vec2 here = strandDir(p, ptr, hov);
   float top = -1.0;
   float across = 0.0;
   float tint = 0.0;
   vec2 topDir = here;
+  // Clumping and breeze turn a strand by at most 0.8 * uClump and 0.7 * uSway, and
+  // both fields are smooth, so strands rooted within reach of this pixel point
+  // inside a cone around its own direction. Roots whose strands can't reach the
+  // pixel, or can't rise above the strand already found, are skipped before their
+  // directions are worked out. Roots are visited upstream first, so the topmost
+  // strand tends to be found early and the rest skipped. (Hovering parts the fur
+  // near the pointer in any direction, so the cone isn't used there.)
+  float lie = radians(uLie);
+  float R = 1.25 * uLength + uWidth;
+  float cp = (gridNoise(p * 0.07, clumpBase, clumpGrid) - 0.5) * 1.6 * uClump;
+  float sp = uSway * 0.7 * sin(iTime * 1.3 + p.x * 0.05 + p.y * 0.03 + 2.0 * gridNoise(p * 0.02 + iTime * 0.15, swayBase, swayGrid));
+  // Bounds on each field's slope: 0.2376 * uClump and 0.10024 * uSway per cell.
+  float dc = 0.2376 * uClump * R;
+  float ds = 0.10024 * uSway * R;
+  vec2 lo = vec2(max(-0.8 * uClump, cp - dc), max(-0.7 * uSway, sp - ds));
+  vec2 hi = vec2(min(0.8 * uClump, cp + dc), min(0.7 * uSway, sp + ds));
+  float mid = lie + 0.5 * (lo.x + hi.x + lo.y + hi.y);
+  // At most 1.54, under a quarter turn.
+  float cone = 0.5 * (hi.x - lo.x + hi.y - lo.y) + 0.04;
+  vec2 axis = vec2(cos(mid), sin(mid));
+  float cosCone = cos(cone);
+  float sinCone = sin(cone);
+  float reach = 0.16 * uDensity;
+  bool parting = uPart * hov > 0.0;
+  // The box roots that reach this pixel lie in, relative to it: behind it within
+  // the cone (anywhere within reach where the pointer may be parting the fur).
+  float back = 1.25 * uLength;
+  vec2 e1 = -back * vec2(cos(mid + cone), sin(mid + cone));
+  vec2 e2 = -back * vec2(cos(mid - cone), sin(mid - cone));
+  vec2 boxLo = min(vec2(0.0), min(e1, e2));
+  vec2 boxHi = max(vec2(0.0), max(e1, e2));
+  if (-axis.x >= cosCone) boxHi.x = back;
+  if (axis.x >= cosCone) boxLo.x = -back;
+  if (-axis.y >= cosCone) boxHi.y = back;
+  if (axis.y >= cosCone) boxLo.y = -back;
+  float ptrGap = max(length(p - ptr) - R, 0.0);
+  if (uPart * hov * exp(-ptrGap * ptrGap / (reach * reach)) * 1.4 > 0.02) {
+    boxLo = vec2(-back);
+    boxHi = vec2(back);
+  }
+  boxLo += p - uWidth;
+  boxHi += p + uWidth;
+  bvec2 up = lessThan(here, vec2(0.0));
   for (int layer = 0; layer < 3; layer++) {
     float fl = float(layer);
     vec2 off = vec2(0.37, 0.71) * fl;
+    // Each layer's 5 x 5 cells around the middle of the strands through here,
+    // cut to those whose roots (in [id + off, id + off + 1)) can lie in the box.
     vec2 base = floor(p - here * uLength * 0.5 - off);
-    for (int j = -2; j <= 2; j++) {
-      for (int i = -2; i <= 2; i++) {
+    ivec2 first = ivec2(max(ceil(boxLo - off - 1.0), base - 2.0) - base);
+    ivec2 last = ivec2(min(floor(boxHi - off), base + 2.0) - base);
+    for (int row = 0; row < 5; row++) {
+      if (row > last.y - first.y) break;
+      int j = up.y ? last.y - row : first.y + row;
+      for (int column = 0; column < 5; column++) {
+        if (column > last.x - first.x) break;
+        int i = up.x ? last.x - column : first.x + column;
         vec2 id = base + vec2(float(i), float(j));
         vec2 h = hash22(id + fl * 31.7);
         vec2 root = id + off + h;
-        vec2 dir = strandDir(root, ptr, hov);
         float len = uLength * (0.75 + 0.5 * h.y);
         vec2 rp = p - root;
+        float r2 = dot(rp, rp);
+        // Too far away, or can't rise above the strand already found (along <= r / len).
+        float reachLen = len + uWidth;
+        if (r2 >= reachLen * reachLen || top >= 1.0 || (top >= 0.0 && r2 <= top * top * len * len)) continue;
+        bool parted = false;
+        if (parting) {
+          vec2 away = root - ptr;
+          parted = uPart * hov * exp(-dot(away, away) / (reach * reach)) * 1.4 > 0.02;
+        }
+        if (r2 > uWidth * uWidth && !parted) {
+          // Off the cone widened by the strand's width: it can't cover this pixel.
+          float da = dot(rp, axis);
+          if (da < cosCone * sqrt(r2 - uWidth * uWidth) - sinCone * uWidth) continue;
+        }
+        vec2 dir = strandDir(root, ptr, hov);
         float along = clamp(dot(rp, dir) / len, 0.0, 1.0);
         float w = uWidth * (1.0 - 0.75 * along);
         float dist = length(rp - dir * along * len);
@@ -9465,29 +9567,61 @@ float poolY(float x, float m) {
   return m * (0.1 + 0.012 * sin(x * 9.0 + iTime * 0.7854) + 0.025 * vnoise(vec2(x * 6.0, 2.0))) - 0.006;
 }
 
-// Distance to the liquid (negative inside): a lip along the slumped edge, drips hanging from it, the puddle.
-float liquid(vec2 uv, float m) {
+vec4 smin4(vec4 a, vec4 b, float k) {
+  k = max(k, 1e-4);
+  vec4 h = clamp(0.5 + 0.5 * (b - a) / k, 0.0, 1.0);
+  return mix(b, a, h) - k * h * (1.0 - h);
+}
+
+// Distances to the liquid (negative inside) at four nearby points (xs, ys) at
+// once: a lip along the slumped edge, drips hanging from it, the puddle. Each
+// point sees the drips of the five columns around its own; those columns'
+// drips are worked out once for all four. edge and pool are edgeY and poolY
+// at the points; a point's distance only matters below its entry in matter.
+vec4 liquid(vec4 xs, vec4 ys, vec4 edge, vec4 pool, float m, vec4 matter) {
   float n = float(uDrips);
   float grow = smoothstep(0.0, 0.2, m);
-  float e = edgeY(uv.x, m) + 0.01 * (1.0 - grow);
+  vec4 e = edge + 0.01 * (1.0 - grow);
   float lip = 0.022 * grow;
-  float d = max(uv.y - e, e - lip - uv.y);
-  float c = floor(uv.x * n);
-  for (int k = -2; k <= 2; k++) {
+  vec4 d = max(ys - e, e - lip - ys);
+  vec4 cs = floor(xs * n);
+  float c = cs.y;
+  // Where any drip's top and head can be, from the bounds of edgeY and poolY.
+  float topMin = 1.0 - m * 0.34 - lip * 0.5;
+  float topMax = 1.0 - m * 0.04 - lip * 0.5;
+  float poolMin = m * 0.088 - 0.006;
+  // A drip farther than this beyond where a distance matters can't change it
+  // there: the blends that follow can pull a distance down by at most this much.
+  vec4 reach = matter + 0.16;
+  for (int k = -3; k <= 3; k++) {
     float ci = c + float(k);
+    bvec4 near = lessThanEqual(abs(cs - ci), vec4(2.0));
+    if (!any(near)) continue;
     vec2 h = hash22(vec2(ci, 3.1));
     float xi = (ci + 0.2 + 0.6 * h.x) / n;
     float w = min(uViscosity * (0.7 + 0.6 * hash12(vec2(ci, 7.7))), 0.6 * aspect / n) * grow;
+    // The nearest this drip can be to each point, before working out its shape:
+    // skip it if it can't change any of them.
+    float f = pow(m, 1.4) * min(0.2 + 0.95 * h.y, 1.0);
+    float headMin = min(topMin, topMin * (1.0 - f) + f * poolMin);
+    vec4 gap = vec4(abs(xs - xi) * aspect);
+    vec4 rise = max(max(headMin - ys, ys - topMax), 0.0);
+    vec4 nearest = sqrt(gap * gap + rise * rise) - 1.3 * w;
+    bvec4 counts = bvec4(vec4(near) * step(nearest, d + 0.012 * grow) * step(nearest, reach));
+    if (!any(counts)) continue;
     float top = edgeY(xi, m) - lip * 0.5;
-    float len = pow(m, 1.4) * min(0.2 + 0.95 * h.y, 1.0) * max(top - poolY(xi, m), 0.0);
+    float len = f * max(top - poolY(xi, m), 0.0);
     float head = top - len;
-    float along = clamp(uv.y, head, top);
+    vec4 along = clamp(ys, head, top);
     // A stem thinning as it runs, then a round, heavier head.
-    float r = w * mix(0.85, 0.6, smoothstep(top, top - 0.3, uv.y));
-    r = mix(r, w * 1.3, smoothstep(head + 3.0 * w, head, uv.y));
-    d = smin(d, length(vec2((uv.x - xi) * aspect, uv.y - along)) - r, 0.012 * grow);
+    vec4 r = w * mix(vec4(0.85), vec4(0.6), smoothstep(top, top - 0.3, ys));
+    r = mix(r, vec4(w * 1.3), smoothstep(head + 3.0 * w, head, ys));
+    vec4 dx = (xs - xi) * aspect;
+    vec4 dy = ys - along;
+    vec4 dd = smin4(d, sqrt(dx * dx + dy * dy) - r, 0.012 * grow);
+    d = mix(d, dd, near);
   }
-  return smin(d, uv.y - poolY(uv.x, m), 0.03 * grow);
+  return smin4(d, ys - pool, 0.03 * grow);
 }
 
 void mainImage(out vec4 fragColor, in vec2 fragCoord) {
@@ -9496,23 +9630,32 @@ void mainImage(out vec4 fragColor, in vec2 fragCoord) {
   float px = 1.0 / iResolution.y;
   float m = uAnimate ? meltCycle(uSpeed) : uProgress;
 
+  // The liquid is sampled at four points: under the shadow, here, and a step
+  // right and up for its normal. They share three columns of x.
+  float eps = 0.0015;
+  vec4 xs = uv.x + vec4(-0.004, 0.0, eps / aspect, 0.0);
+  vec4 ys = uv.y + vec4(0.009, 0.0, 0.0, eps);
+  vec3 edge3 = vec3(edgeY(xs.x, m), edgeY(xs.y, m), edgeY(xs.z, m));
+  vec3 pool3 = vec3(poolY(xs.x, m), poolY(xs.y, m), poolY(xs.z, m));
+  // The shadow shows below 0.012, the liquid below 4 px (its neighbours a little farther).
+  vec4 liq = liquid(xs, ys, edge3.xyzy, pool3.xyzy, m, vec4(0.012, 4.0 * px, vec2(4.0 * px + 0.005)));
+
   // The picture slumped under its edge: squashed towards the bottom, stretched thin at the top.
-  float e = edgeY(uv.x, m);
+  float e = edge3.y;
   float h = clamp(uv.y / e, 0.0, 1.0);
-  float ys = 1.0 - pow(1.0 - h, 1.0 + m * 1.3);
-  float xs = uv.x + m * 0.006 * sin(uv.y * 40.0 + uv.x * 13.0);
-  vec4 col = pictureRGBA(uImage, vec2(xs, ys));
+  float ys0 = 1.0 - pow(1.0 - h, 1.0 + m * 1.3);
+  float xs0 = uv.x + m * 0.006 * sin(uv.y * 40.0 + uv.x * 13.0);
+  vec4 col = pictureRGBA(uImage, vec2(xs0, ys0));
   vec4 behind = vec4(uBackground * (0.75 + 0.5 * uv.y), uBackdropAlpha);
   col = mix(col, behind, smoothstep(e - px, e + px, uv.y));
 
   // The liquid's shadow, down and to the right.
-  float shadow = liquid(uv + vec2(-0.004, 0.009), m);
+  float shadow = liq.x;
   col.rgb *= 1.0 - 0.4 * smoothstep(0.012, -0.004, shadow) * smoothstep(0.0, 0.1, m);
 
-  float d = liquid(uv, m);
+  float d = liq.y;
   if (d < 4.0 * px) {
-    float eps = 0.0015;
-    vec2 g = vec2(liquid(uv + vec2(eps / aspect, 0.0), m) - d, liquid(uv + vec2(0.0, eps), m) - d);
+    vec2 g = vec2(liq.z - d, liq.w - d);
     g /= max(length(g), 1e-5);
     float thick = sqrt(clamp(-d / 0.018, 0.0, 1.0));
     vec3 nrm = normalize(vec3(g * (1.0 - thick) * 1.6, 0.4 + thick));
@@ -9520,7 +9663,7 @@ void mainImage(out vec4 fragColor, in vec2 fragCoord) {
     vec4 top = pictureRGBA(uImage, vec2(uv.x + 0.01 * sin(uv.y * 25.0), 0.965));
     float sx = uv.x + 0.04 * sin(uv.x * 11.0 + uv.y * 30.0);
     vec4 pool = (pictureRGBA(uImage, vec2(sx - 0.06, 0.25)) + pictureRGBA(uImage, vec2(sx + 0.06, 0.4)) + pictureRGBA(uImage, vec2(sx, 0.9))) / 3.0;
-    float inPool = smoothstep(poolY(uv.x, m) + 0.04, poolY(uv.x, m) - 0.01, uv.y);
+    float inPool = smoothstep(pool3.y + 0.04, pool3.y - 0.01, uv.y);
     vec4 base = mix(top, pool, inPool);
     base.rgb *= 0.9 + 0.12 * vnoise(vec2(uv.x * 90.0, uv.y * 3.0));
     vec3 wet = liquidShade(base.rgb * 1.05, nrm, uGloss);
@@ -10449,7 +10592,18 @@ uniform float uIntensity; // @control min=0.2 max=3 default=1 label="Intensity"`
   float w = max(0.0022, px);
   float k = 1.4;
   float g = 1.5;
+  // Past this distance a streak's glow is far below one level, so sparks farther
+  // away are skipped, and so is the whole loop outside the fountain's reach.
+  float margin = 30.0 * w;
+  float vmax = 1.35 * uHeight * 1.25;
+  float xmax = vmax * sin(min(uSpread * 1.2, 1.5708)) * (1.0 - exp(-k * 1.8)) / k;
+  float apex = log(1.0 + vmax * k / g) / k;
+  float ea = (1.0 - exp(-k * apex)) / k;
+  float ymax = vmax * ea - g / k * (apex - ea);
+  vec2 rel = p - base;
+  bool inReach = abs(rel.x) < xmax + margin && rel.y > -0.01 - margin && rel.y < ymax + margin;
   for (int j = 0; j < 112; j++) {
+    if (!inReach) break;
     float fj = float(j);
     vec2 h = hash22(vec2(fj, 2.31));
     float life = 1.0 + 0.8 * h.y;
@@ -10459,11 +10613,14 @@ uniform float uIntensity; // @control min=0.2 max=3 default=1 label="Intensity"`
     vec3 s = vec3(hash22(vec2(fj * 1.7, n)), hash12(vec2(n, fj + 0.37)));
     if (s.z > uDensity) continue;
     float a = (s.x - 0.5) * 2.0 * uSpread * 1.2;
+    // A spark only ever moves to its own side of the base.
+    if (a * rel.x < 0.0 && abs(rel.x) > margin) continue;
     vec2 v = vec2(sin(a), cos(a)) * mix(0.9, 1.35, s.y) * uHeight * 1.25;
     vec2 head = base + ballistic(v, k, g, age);
     vec2 tail = base + ballistic(v, k, g, max(age - 0.07, 0.0));
     // Sparks that fall back past the base are gone.
     if (head.y < base.y - 0.01) continue;
+    if (any(lessThan(p, min(head, tail) - margin)) || any(greaterThan(p, max(head, tail) + margin))) continue;
     float fade = 1.0 - smoothstep(0.5, 1.0, age / life);
     float twinkle = 0.6 + 0.4 * hash12(vec2(fj, floor(iTime * 24.0)));
     vec3 tint = mix(vec3(1.0, 0.96, 0.85), uColor, smoothstep(0.0, 0.5, age));
@@ -11708,15 +11865,15 @@ ${BACKDROP_CONTROLS}`,
     ROTATE,
     PICTURE,
     COMMON,
-    `const vec2 RING[4] = vec2[4](vec2(0.0, 0.0), vec2(1.0, 0.0), vec2(1.0, 1.0), vec2(0.0, 1.0));
-
-// Where cell c's particle lands: cells trade places around each 2 \xD7 2 block, turned 1\u20133 steps.
+    `// Where cell c's particle lands: cells trade places around each 2 \xD7 2 block, turned 1\u20133 steps.
+// Round the block the corners go (0, 0), (1, 0), (1, 1), (0, 1); worked out rather than looked up in an array.
 vec2 landing(vec2 c) {
   vec2 block = floor(c * 0.5);
   vec2 local = c - block * 2.0;
-  int i = local.y < 0.5 ? int(local.x) : 3 - int(local.x);
-  int turn = 1 + int(hash12(block + 7.3) * 2.999);
-  return block * 2.0 + RING[(i + turn) % 4];
+  float i = local.y < 0.5 ? local.x : 3.0 - local.x;
+  float turn = 1.0 + floor(hash12(block + 7.3) * 2.999);
+  float r = mod(i + turn, 4.0);
+  return block * 2.0 + vec2(r > 0.5 && r < 2.5 ? 1.0 : 0.0, r > 1.5 ? 1.0 : 0.0);
 }
 
 void mainImage(out vec4 fragColor, in vec2 fragCoord) {
@@ -11730,26 +11887,43 @@ void mainImage(out vec4 fragColor, in vec2 fragCoord) {
   vec2 hitTo = vec2(0.0);
   float hitT = 0.0;
   float hitCover = 0.0;
-  // Particles travel at most about 1.5 cells, so the 5 \xD7 5 cells around are every candidate.
-  for (int j = -2; j <= 2; j++) {
-    for (int i = -2; i <= 2; i++) {
-      vec2 c = base + vec2(float(i), float(j));
+  // How far a particle's corners stray from the straight line between its two places: the curl, then its turned corners.
+  float reach = max(0.7072, 0.6 * abs(uScatter + uSpin * 0.3) + 0.4951) + 0.01;
+  // Particles travel at most about 1.5 cells, so the 5 \xD7 5 cells around are every candidate;
+  // of those, only the cells within reach (one cell either side of the block) need looking at.
+  vec2 lo = max(base - 2.0, ceil(p - 1.5 - reach));
+  vec2 hi = min(base + 2.0, floor(p + 0.5 + reach));
+  for (int j = 0; j < 5; j++) {
+    if (lo.y + float(j) > hi.y) break;
+    for (int i = 0; i < 5; i++) {
+      if (lo.x + float(i) > hi.x) break;
+      vec2 c = lo + vec2(float(i), float(j));
+      // It stays in its 2 \xD7 2 block, so skip it if this pixel is out of its reach from there.
+      vec2 corner = c - 2.0 * floor(c * 0.5);
+      if (any(lessThan(p, c + 0.5 - corner - reach)) || any(greaterThan(p, c + 1.5 - corner + reach))) continue;
       vec2 h = hash22(c);
       // Staggered: a sweep from the left plus some randomness.
       float delay = 0.5 * (0.55 * clamp(c.x / grid.x, 0.0, 1.0) + 0.45 * h.x);
       float k = smoothstep(0.0, 1.0, clamp((t - delay) / 0.5, 0.0, 1.0));
       float lift = sin(3.14159 * k);
+      float z = h.y + lift;
+      // Behind what is already here, or (now its lift is known) out of reach: skip it before working out where it is.
+      if (z <= top) continue;
+      float near = 0.6 * abs(uScatter + uSpin * 0.3) * lift + 0.7072 * (1.0 - 0.3 * lift) + 0.01;
+      if (any(lessThan(p, c + 0.5 - corner - near)) || any(greaterThan(p, c + 1.5 - corner + near))) continue;
       vec2 from = c + 0.5;
       vec2 to = landing(c) + 0.5;
       vec2 path = to - from;
       vec2 side = normalize(vec2(-path.y, path.x) + (h - 0.5) * 0.8);
       vec2 pos = mix(from, to, k) + side * lift * (uScatter + uSpin * 0.3) * (h.y > 0.5 ? 0.6 : -0.6);
       float size = 1.0 - 0.3 * lift;
+      // Out of reach of its corners, however it is turned.
+      vec2 rel = p - pos;
+      if (dot(rel, rel) > 0.501 * size * size) continue;
       float angle = (h.y - 0.5) * 6.28318 * uSpin * lift;
-      vec2 l = rot(-angle) * (p - pos) / size;
+      vec2 l = rot(-angle) * rel / size;
       float m = max(abs(l.x), abs(l.y));
-      float z = h.y + lift;
-      if (m <= 0.5 && z > top) {
+      if (m <= 0.5) {
         top = z;
         hitFrom = from + l;
         hitTo = to + l;
@@ -12688,6 +12862,24 @@ ${BACKDROP_CONTROLS}`,
   return cell + 0.15 + 0.7 * hash22(cell);
 }
 
+// No point is further than this from its own shard's site (sites sit in the middle 70% of each cell).
+const float SHARD_REACH = 1.25;
+
+// Whether grid point q lies on shard c: c's site is the nearest of those in the 3 \xD7 3 cells around q.
+bool onShard(vec2 q, vec2 c) {
+  vec2 base = floor(q);
+  vec2 off = c - base;
+  if (abs(off.x) > 1.0 || abs(off.y) > 1.0) return false;
+  float own = distance(q, shardSite(c));
+  for (int j = -1; j <= 1; j++) {
+    for (int i = -1; i <= 1; i++) {
+      vec2 n = base + vec2(float(i), float(j));
+      if (n != c && distance(q, shardSite(n)) < own) return false;
+    }
+  }
+  return true;
+}
+
 // The shard (cell) under grid point q, and how far q is from its edge (xy: cell, z: edge gap).
 vec3 shardAt(vec2 q) {
   vec2 base = floor(q);
@@ -12716,28 +12908,42 @@ void mainImage(out vec4 fragColor, in vec2 fragCoord) {
   // Shard centres move out from the middle; shards keep their size, so gaps open between them.
   float grow = 1.0 + uSpread * k;
   vec2 base = floor(p / grow);
-  vec4 col = vec4(uBackground, uBackdropAlpha);
   float top = -1.0;
-  for (int j = -2; j <= 2; j++) {
-    for (int i = -2; i <= 2; i++) {
-      vec2 c = base + vec2(float(i), float(j));
-      vec2 site = shardSite(c);
+  vec2 hitQ = vec2(0.0);
+  float hitA = 0.0;
+  // Every shard that could reach this pixel (of the 5 \xD7 5 cells around, those whose site, wherever it sits
+  // in its cell and however far it is thrown, lands close enough); the one on top (highest h.y) wins.
+  float slack = 0.6 * k + SHARD_REACH;
+  vec2 lo = max(base - 2.0, ceil((p - slack) / grow - 0.85));
+  vec2 hi = min(base + 2.0, floor((p + slack) / grow - 0.15));
+  for (int j = 0; j < 5; j++) {
+    if (lo.y + float(j) > hi.y) break;
+    for (int i = 0; i < 5; i++) {
+      if (lo.x + float(i) > hi.x) break;
+      vec2 c = lo + vec2(float(i), float(j));
       vec2 h = hash22(c + 41.7);
+      if (h.y <= top) continue;
+      vec2 site = shardSite(c);
       vec2 centre = site * grow + (h - 0.5) * 1.2 * k;
+      vec2 rel = p - centre;
+      if (dot(rel, rel) > SHARD_REACH * SHARD_REACH) continue;
       float a = (h.x - 0.5) * 2.0 * uSpin * k;
       // Back to where this pixel would sit in the unbroken image, if it is on this shard.
-      vec2 q = rot(-a) * (p - centre) + site;
-      vec3 s = shardAt(q);
-      if (s.x == c.x && s.y == c.y && h.y > top) {
+      vec2 q = rot(-a) * rel + site;
+      if (onShard(q, c)) {
         top = h.y;
-        vec2 uv = q / uCount * iResolution.y / iResolution.xy + 0.5;
-        vec4 shard = pictureRGBA(uImage, uv);
-        shard.rgb *= 1.0 - 0.35 * k * abs(sin(a));
-        shard.rgb += k * 0.35 * smoothstep(0.06, 0.0, s.z);
-        col = shard;
+        hitQ = q;
+        hitA = a;
       }
     }
   }
+  vec4 col = vec4(uBackground, uBackdropAlpha);
+  if (top > -1.0) {
+    vec2 uv = hitQ / uCount * iResolution.y / iResolution.xy + 0.5;
+    col = pictureRGBA(uImage, uv);
+    col.rgb *= 1.0 - 0.35 * k * abs(sin(hitA));
+    col.rgb += k * 0.35 * smoothstep(0.06, 0.0, shardAt(hitQ).z);
+  }
   fragColor = col;
 }`
   ),
@@ -13182,31 +13388,48 @@ uniform float uSharpness;  // @control min=0.5 max=8 default=4 label="Sharpness"
 uniform float uSaturation; // @control min=0 max=2 default=1.15 label="Saturation"
 ${BACKDROP_CONTROLS}`,
     PICTURE,
-    `void mainImage(out vec4 fragColor, in vec2 fragCoord) {
+    `// Sums of colour and colour\xB2 over four overlapping squares (down-left, down-right, up-left, up-right),
+// each pixel read once: the shared middle row and column count towards both squares they border.
+// A macro so the image and the test card each get their own loop, rather than every read paying for both.
+#define GATHER(TAP) { \\
+  vec3 c = TAP(uv); \\
+  vec3 cc = c * c; \\
+  m0 = c; m1 = c; m2 = c; m3 = c; \\
+  s0 = cc; s1 = cc; s2 = cc; s3 = cc; \\
+  for (int i = 1; i <= 8; i++) { \\
+    if (i > uRadius) break; \\
+    float o = float(i); \\
+    c = TAP(uv - vec2(o * px.x, 0.0)); cc = c * c; m0 += c; s0 += cc; m2 += c; s2 += cc; \\
+    c = TAP(uv + vec2(o * px.x, 0.0)); cc = c * c; m1 += c; s1 += cc; m3 += c; s3 += cc; \\
+    c = TAP(uv - vec2(0.0, o * px.y)); cc = c * c; m0 += c; s0 += cc; m1 += c; s1 += cc; \\
+    c = TAP(uv + vec2(0.0, o * px.y)); cc = c * c; m2 += c; s2 += cc; m3 += c; s3 += cc; \\
+  } \\
+  for (int j = 1; j <= 8; j++) { \\
+    if (j > uRadius) break; \\
+    for (int i = 1; i <= 8; i++) { \\
+      if (i > uRadius) break; \\
+      vec2 o = vec2(float(i), float(j)) * px; \\
+      c = TAP(uv - o); m0 += c; s0 += c * c; \\
+      c = TAP(uv + vec2(o.x, -o.y)); m1 += c; s1 += c * c; \\
+      c = TAP(uv + vec2(-o.x, o.y)); m2 += c; s2 += c * c; \\
+      c = TAP(uv + o); m3 += c; s3 += c * c; \\
+    } \\
+  } \\
+}
+
+vec3 imageTap(vec2 uv) {
+  return overBackdrop(texture(uImage, uv)).rgb;
+}
+
+vec3 cardTap(vec2 uv) {
+  return testCard(fract(uv));
+}
+
+void mainImage(out vec4 fragColor, in vec2 fragCoord) {
   vec2 uv = fragCoord / iResolution.xy;
   vec2 px = 1.0 / iResolution.xy;
-  // Sums of colour and colour\xB2 over four overlapping squares: down-left, down-right, up-left, up-right.
-  vec3 m0 = vec3(0.0), m1 = vec3(0.0), m2 = vec3(0.0), m3 = vec3(0.0);
-  vec3 s0 = vec3(0.0), s1 = vec3(0.0), s2 = vec3(0.0), s3 = vec3(0.0);
-  for (int j = 0; j <= 8; j++) {
-    if (j > uRadius) break;
-    for (int i = 0; i <= 8; i++) {
-      if (i > uRadius) break;
-      vec2 o = vec2(float(i), float(j)) * px;
-      vec3 c = picture(uImage, uv + vec2(-o.x, -o.y));
-      m0 += c;
-      s0 += c * c;
-      c = picture(uImage, uv + vec2(o.x, -o.y));
-      m1 += c;
-      s1 += c * c;
-      c = picture(uImage, uv + vec2(-o.x, o.y));
-      m2 += c;
-      s2 += c * c;
-      c = picture(uImage, uv + o);
-      m3 += c;
-      s3 += c * c;
-    }
-  }
+  vec3 m0, m1, m2, m3, s0, s1, s2, s3;
+  if (textureSize(uImage, 0).x > 1) GATHER(imageTap) else GATHER(cardTap)
   float n = float((uRadius + 1) * (uRadius + 1));
   m0 /= n; m1 /= n; m2 /= n; m3 /= n;
   // Weight each square by how calm (low-variance) it is; sharpness sets how strongly the calmest wins.
@@ -13244,7 +13467,7 @@ var imageTreatments = [
 ];
 
 // src/catalog/shaders/trail.ts
-function trailHelper(dt, speed) {
+function trailHelper(dt, speed, walk = false) {
   return `
 const int TRAIL_POINTS = 32;
 vec2 demoPath(float t) {
@@ -13261,6 +13484,52 @@ vec4 trailPoint(int i, bool demo) {
   const float dt = ${dt.toFixed(5)};
   float t = i == 0 ? iTime : (floor(iTime / dt) + 1.0 - float(i)) * dt;
   return vec4(demoPath(t), t, 1.0);
+}${walk ? `
+${trailWalk(dt, speed)}` : ""}`.trim();
+}
+function trailWalk(dt, speed) {
+  const rates = [1, 2.3, 2, 3.1];
+  const turn = rates.map((r) => r * dt * speed);
+  const vec = (f) => `vec4(${turn.map((x) => f(x).toFixed(8)).join(", ")})`;
+  return `
+bool trailLive(bool demo) {
+  return !demo || (iTrail[0].w > 0.5 && iPointer.z > 0.0);
+}
+vec4 trailAt(int i, bool live) {
+  if (live) return iTrail[i];
+  const float dt = ${dt.toFixed(5)};
+  float t = i == 0 ? iTime : (floor(iTime / dt) + 1.0 - float(i)) * dt;
+  return vec4(demoPath(t), t, 1.0);
+}
+int gWalkI;
+float gWalkBase;
+vec4 gWalkCos;
+vec4 gWalkSin;
+// Starts a walk at point i (1 or more).
+void trailFrom(int i, bool live) {
+  gWalkI = i;
+  if (live) return;
+  const float dt = ${dt.toFixed(5)};
+  gWalkBase = floor(iTime / dt) + 1.0;
+  float s = (gWalkBase - float(i)) * dt * ${speed.toFixed(3)};
+  vec4 phase = vec4(s, s * 2.3 + 1.0, s * 2.0 + 0.4, s * 3.1);
+  gWalkCos = cos(phase);
+  gWalkSin = sin(phase);
+}
+// The walk's next point: as trailAt(i, live) for i = the start, then one more each call.
+vec4 trailNext(bool live) {
+  int i = gWalkI;
+  gWalkI++;
+  if (live) return iTrail[min(i, TRAIL_POINTS - 1)];
+  const float dt = ${dt.toFixed(5)};
+  vec2 q = vec2(0.34 * gWalkSin.x + 0.05 * gWalkSin.y, 0.27 * gWalkSin.z + 0.04 * gWalkCos.w);
+  vec4 point = vec4(iResolution.xy * (0.5 + q), (gWalkBase - float(i)) * dt, 1.0);
+  const vec4 turnCos = ${vec(Math.cos)};
+  const vec4 turnSin = ${vec(Math.sin)};
+  vec4 c = gWalkCos * turnCos + gWalkSin * turnSin;
+  gWalkSin = gWalkSin * turnCos - gWalkCos * turnSin;
+  gWalkCos = c;
+  return point;
 }`.trim();
 }
 var SEGMENT3 = `
@@ -13275,6 +13544,14 @@ vec2 catmull(vec2 p0, vec2 p1, vec2 p2, vec2 p3, float t) {
   float t3 = t2 * t;
   return 0.5 * (2.0 * p1 + (p2 - p0) * t + (2.0 * p0 - 5.0 * p1 + 4.0 * p2 - p3) * t2 + (3.0 * p1 - p0 - 3.0 * p2 + p3) * t3);
 }`.trim();
+var CATMULL_BOX = `
+float trailBoxDist(vec2 p, vec2 p0, vec2 p1, vec2 p2, vec2 p3, float scale) {
+  vec2 c1 = p1 + (p2 - p0) / 6.0;
+  vec2 c2 = p2 - (p3 - p1) / 6.0;
+  vec2 lo = min(min(p1, p2), min(c1, c2)) * scale;
+  vec2 hi = max(max(p1, p2), max(c1, c2)) * scale;
+  return length(max(max(lo - p, p - hi), 0.0));
+}`.trim();
 var GLOW5 = `
 vec4 glow(vec3 c) {
   c = 1.0 - exp(-max(c, 0.0));
@@ -13371,14 +13648,16 @@ uniform float uSpin;      // @control min=0 max=10 default=2 label="Spin"
 uniform float uShine;     // @control min=0 max=1 default=0.7 label="Shine"
 uniform float uLife;      // @control min=0.1 max=3 default=1.1 label="Fade time"
 uniform bool uDemo;       // @control default=true label="Demo when idle"`,
-    trailHelper(1 / 30, 1.5),
+    trailHelper(1 / 30, 1.5, true),
     SEGMENT3,
     CATMULL,
+    CATMULL_BOX,
     `void mainImage(out vec4 fragColor, in vec2 fragCoord) {
   float px = 1.0 / iResolution.y;
   vec2 p = fragCoord * px;
-  vec4 a = trailPoint(0, uDemo);
-  vec4 b = trailPoint(1, uDemo);
+  bool live = trailLive(uDemo);
+  vec4 a = trailAt(0, live);
+  vec4 b = trailAt(1, live);
   if (a.w < 0.5 || b.w < 0.5) {
     fragColor = vec4(0.0);
     return;
@@ -13389,14 +13668,16 @@ uniform bool uDemo;       // @control default=true label="Demo when idle"`,
   float bestFace = 1.0;
   float bestV = 0.0;
   float bestFade = 0.0;
+  trailFrom(2, live);
   for (int k = 0; k < TRAIL_POINTS - 1; k++) {
-    b = trailPoint(k + 1, uDemo);
     if (b.w < 0.5 || trailJump(a, b)) break;
-    vec4 c = k + 2 < TRAIL_POINTS ? trailPoint(min(k + 2, TRAIL_POINTS - 1), uDemo) : vec4(0.0);
+    // The point after b: read once, it is the next segment's b.
+    vec4 c = k + 2 < TRAIL_POINTS ? trailNext(live) : vec4(0.0);
     vec2 next = c.w > 0.5 && !trailJump(b, c) ? c.xy : 2.0 * b.xy - a.xy;
     vec2 lo = min(min(prev, a.xy), min(b.xy, next)) * px - uWidth - 2.0 * px;
     vec2 hi = max(max(prev, a.xy), max(b.xy, next)) * px + uWidth + 2.0 * px;
-    if (all(greaterThan(p, lo)) && all(lessThan(p, hi))) {
+    // The ribbon is at most half its width either side of the spline: further off than that, a segment cannot be nearer.
+    if (all(greaterThan(p, lo)) && all(lessThan(p, hi)) && trailBoxDist(p, prev, a.xy, b.xy, next, px) - uWidth * 0.5 < best) {
       vec2 q0 = a.xy * px;
       for (int j = 1; j <= 4; j++) {
         float t1 = float(j) / 4.0;
@@ -13422,6 +13703,7 @@ uniform bool uDemo;       // @control default=true label="Demo when idle"`,
     }
     prev = a.xy;
     a = b;
+    b = c;
   }
   float cover = (1.0 - smoothstep(-px, px, best)) * smoothstep(0.0, 0.15, bestFade);
   if (cover <= 0.0) {
@@ -13466,21 +13748,31 @@ uniform float uTwinkle;   // @control min=0 max=1 default=0.7 label="Twinkle"
 uniform float uIntensity; // @control min=0.2 max=3 default=1.2 label="Intensity"
 uniform bool uDemo;       // @control default=true label="Demo when idle"`,
     HASH,
-    trailHelper(1 / 40, 1.4),
+    trailHelper(1 / 40, 1.4, true),
     GLOW5,
     `void mainImage(out vec4 fragColor, in vec2 fragCoord) {
   float px = 1.0 / iResolution.y;
   vec2 p = fragCoord * px;
   vec3 col = vec3(0.0);
+  bool live = trailLive(uDemo);
+  // How far a sparkle's light reaches from where it is (twice its largest size), and its sideways sway.
+  float reach = 2.5 * uSize + px;
+  float side = uSpread + 0.012 + reach;
   // Point 0 is still moving with the pointer, so sparkles come from the settled points after it.
+  trailFrom(1, live);
   for (int k = 1; k < TRAIL_POINTS; k++) {
-    vec4 q = trailPoint(k, uDemo);
+    vec4 q = trailNext(live);
     if (q.w < 0.5) break;
     float age = iTime - q.z;
     if (age < 0.0 || age > uLife) continue;
+    // Skip points none of whose sparkles (spread, swaying and drifting down) can reach this pixel.
+    vec2 rel = p - q.xy * px;
+    float fall = uFall * age * (0.4 + 0.6 * age);
+    if (abs(rel.x) > side || rel.y > uSpread + reach || rel.y < -uSpread - fall - reach) continue;
     float life = age / uLife;
     // Points drop off the end of the trail: fade those about to go.
     float keep = 1.0 - smoothstep(float(TRAIL_POINTS) - 6.0, float(TRAIL_POINTS) - 1.0, float(k));
+    float env = smoothstep(0.0, 0.08, life) * (1.0 - life) * (1.0 - life) * keep;
     for (int j = 0; j < 4; j++) {
       if (j >= uCount) break;
       vec2 h = hash22(vec2(q.z * 61.37 + float(j) * 7.13, float(j) + 0.5));
@@ -13493,13 +13785,12 @@ uniform bool uDemo;       // @control default=true label="Demo when idle"`,
       // Turn some of them a little.
       float an = (h.y - 0.5) * 0.9;
       d = mat2(cos(an), sin(an), -sin(an), cos(an)) * d;
-      float env = smoothstep(0.0, 0.08, life) * (1.0 - life) * (1.0 - life);
       float tw = mix(1.0, 0.35 + 0.65 * (0.5 + 0.5 * sin(age * (12.0 + 12.0 * h.y) + h.x * 6.28318)), uTwinkle);
       float rays = exp(-abs(d.x) / (s * 0.05)) * exp(-abs(d.y) / (s * 0.45));
       rays += exp(-abs(d.y) / (s * 0.05)) * exp(-abs(d.x) / (s * 0.45));
       float core = exp(-dot(d, d) / (s * s * 0.02));
       vec3 tint = h3 < 0.5 ? uColorA : uColorB;
-      col += (tint * (rays * 0.9 + core * 0.6) + vec3(1.0) * core) * env * tw * keep;
+      col += (tint * (rays * 0.9 + core * 0.6) + vec3(1.0) * core) * env * tw;
     }
   }
   fragColor = glow(col * uIntensity);
@@ -13532,7 +13823,7 @@ uniform bool uDemo;       // @control default=true label="Demo when idle"`,
     HASH,
     NOISE,
     FBM,
-    trailHelper(1 / 30, 1.3),
+    trailHelper(1 / 30, 1.3, true),
     SEGMENT3,
     `// The stroke's width at a point from how fast the segment from a to b was drawn: faster, thinner.
 float pressWidth(vec4 a, vec4 b, float px) {
@@ -13543,47 +13834,61 @@ float pressWidth(vec4 a, vec4 b, float px) {
 void mainImage(out vec4 fragColor, in vec2 fragCoord) {
   float px = 1.0 / iResolution.y;
   vec2 p = fragCoord * px;
-  vec4 a = trailPoint(0, uDemo);
-  vec4 b = trailPoint(1, uDemo);
+  bool live = trailLive(uDemo);
+  vec4 a = trailAt(0, live);
+  vec4 b = trailAt(1, live);
   float best = 1e9;
   float bestU = 1.0;
   float bestV = 0.0;
   float bestFade = 0.0;
+  // Ragged edges: the same noise for every segment, so read it once.
+  float rag = 0.9 + 0.2 * vnoise(p * 180.0);
   if (a.w > 0.5 && b.w > 0.5) {
-    float wa = pressWidth(a, b, px);
+    // Faster strokes are thinner, never wider than uWidth: ragged, at most 1.1 \xD7 that from the line.
+    float reach = 1.1 * uWidth;
+    trailFrom(2, live);
     for (int k = 0; k < TRAIL_POINTS - 1; k++) {
-      b = trailPoint(k + 1, uDemo);
       if (b.w < 0.5 || trailJump(a, b)) break;
-      vec4 c = k + 2 < TRAIL_POINTS ? trailPoint(min(k + 2, TRAIL_POINTS - 1), uDemo) : vec4(0.0);
-      if (trailJump(b, c)) c = vec4(0.0);
-      float wb = c.w > 0.5 ? pressWidth(b, c, px) : wa;
-      vec2 s = segment(p, a.xy * px, b.xy * px);
-      float u = (float(k) + s.y) / float(TRAIL_POINTS - 1);
-      float fade = clamp(1.0 - (iTime - mix(a.z, b.z, s.y)) / uLife, 0.0, 1.0);
-      // A rounded start and a tail that thins out.
-      float w = mix(wa, wb, s.y) * (1.0 - 0.6 * smoothstep(0.55, 1.0, u)) * smoothstep(0.0, 0.04, u + 0.01);
-      w *= 0.4 + 0.6 * fade;
-      // Ragged edges.
-      float sd = s.x - w * (0.9 + 0.2 * vnoise(p * 180.0));
-      if (sd < best) {
-        vec2 dir = b.xy - a.xy;
-        float side = dir.x * (p.y - a.y * px) - dir.y * (p.x - a.x * px);
-        best = sd;
-        bestU = u;
-        bestV = clamp(s.x / max(w, 1e-5), 0.0, 1.0) * (side < 0.0 ? -1.0 : 1.0);
-        bestFade = fade;
+      // The point after b: read once, it is the next segment's b.
+      vec4 next = k + 2 < TRAIL_POINTS ? trailNext(live) : vec4(0.0);
+      // A segment whose box is further off than the stroke reaches cannot be nearer than the best so far.
+      vec2 off = max(max(min(a.xy, b.xy) * px - p, p - max(a.xy, b.xy) * px), 0.0);
+      float r = best + reach;
+      if (r > 0.0 && dot(off, off) < r * r) {
+        // The width where the segment starts is from it, where it ends from the next (or the same at the end).
+        float wa = pressWidth(a, b, px);
+        float wb = next.w > 0.5 && !trailJump(b, next) ? pressWidth(b, next, px) : wa;
+        vec2 s = segment(p, a.xy * px, b.xy * px);
+        float u = (float(k) + s.y) / float(TRAIL_POINTS - 1);
+        float fade = clamp(1.0 - (iTime - mix(a.z, b.z, s.y)) / uLife, 0.0, 1.0);
+        // A rounded start and a tail that thins out.
+        float w = mix(wa, wb, s.y) * (1.0 - 0.6 * smoothstep(0.55, 1.0, u)) * smoothstep(0.0, 0.04, u + 0.01);
+        w *= 0.4 + 0.6 * fade;
+        float sd = s.x - w * rag;
+        if (sd < best) {
+          vec2 dir = b.xy - a.xy;
+          float side = dir.x * (p.y - a.y * px) - dir.y * (p.x - a.x * px);
+          best = sd;
+          bestU = u;
+          bestV = clamp(s.x / max(w, 1e-5), 0.0, 1.0) * (side < 0.0 ? -1.0 : 1.0);
+          bestFade = fade;
+        }
       }
       a = b;
-      wa = wb;
+      b = next;
     }
   }
   // Bristles streak along the stroke (they vary across it); the paper's tooth breaks them up.
-  float bristle = 0.6 * vnoise(vec2(bestV * uBristles, 3.7)) + 0.4 * fbm(p * vec2(55.0, 55.0), 3);
-  float dry = uDry * smoothstep(0.15, 1.0, bestU) + 0.35 * uDry * smoothstep(0.6, 1.0, abs(bestV)) + 0.7 * (1.0 - bestFade);
-  float ink = smoothstep(dry - 0.06, dry + 0.06, bristle * 1.1);
-  float cover = (1.0 - smoothstep(-px, px, best)) * ink * smoothstep(0.0, 0.1, bestFade);
-  // Ink pools darker at the edges and thins where a bristle runs dry.
-  vec3 col = uInk * (1.0 + 0.6 * (1.0 - bristle) * (1.0 - abs(bestV))) + 0.04 * (1.0 - bristle);
+  // Away from the stroke nothing shows, so the bristles are not worked out there.
+  float cover = (1.0 - smoothstep(-px, px, best)) * smoothstep(0.0, 0.1, bestFade);
+  vec3 col = uInk;
+  if (cover > 0.0) {
+    float bristle = 0.6 * vnoise(vec2(bestV * uBristles, 3.7)) + 0.4 * fbm(p * vec2(55.0, 55.0), 3);
+    float dry = uDry * smoothstep(0.15, 1.0, bestU) + 0.35 * uDry * smoothstep(0.6, 1.0, abs(bestV)) + 0.7 * (1.0 - bestFade);
+    cover *= smoothstep(dry - 0.06, dry + 0.06, bristle * 1.1);
+    // Ink pools darker at the edges and thins where a bristle runs dry.
+    col = uInk * (1.0 + 0.6 * (1.0 - bristle) * (1.0 - abs(bestV))) + 0.04 * (1.0 - bristle);
+  }
   if (uPaper) {
     vec3 paper = uPaperColor * (0.95 + 0.07 * fbm(p * 9.0, 4)) - 0.03 * smoothstep(0.55, 0.9, vnoise(p * vec2(400.0, 30.0)));
     fragColor = vec4(mix(paper, col, cover * 0.95), 1.0);
@@ -13701,9 +14006,10 @@ uniform float uLife;      // @control min=0.5 max=10 default=4 label="Fade time"
 uniform float uFlicker;   // @control min=0 max=1 default=0.25 label="Flicker"
 uniform bool uDemo;       // @control default=true label="Demo when idle"`,
     HASH,
-    trailHelper(0.05, 1.1),
+    trailHelper(0.05, 1.1, true),
     SEGMENT3,
     CATMULL,
+    CATMULL_BOX,
     `vec3 spectrum(float h) {
   return 0.5 + 0.5 * cos(6.28318 * (h + vec3(0.0, 0.33, 0.67)));
 }
@@ -13716,8 +14022,9 @@ void mainImage(out vec4 fragColor, in vec2 fragCoord) {
   vec3 col = uBackground * (1.0 - 0.45 * dot(uv - 0.5, uv - 0.5) * 2.0);
   col += (hash12(fragCoord + fract(iTime) * 113.0) - 0.5) * 0.012;
 
-  vec4 a = trailPoint(0, uDemo);
-  vec4 b = trailPoint(1, uDemo);
+  bool live = trailLive(uDemo);
+  vec4 a = trailAt(0, live);
+  vec4 b = trailAt(1, live);
   if (a.w > 0.5 && b.w > 0.5) {
     float glowR = uWidth * 4.0 * max(uGlow, 0.05);
     float margin = uWidth * 3.0 + glowR * 6.0 + 2.0 * px;
@@ -13726,35 +14033,44 @@ void mainImage(out vec4 fragColor, in vec2 fragCoord) {
     float halo = 0.0;
     float best = 1e9;
     float bestWhen = a.z;
+    trailFrom(2, live);
     for (int k = 0; k < TRAIL_POINTS - 1; k++) {
-      b = trailPoint(k + 1, uDemo);
       if (b.w < 0.5) break;
       // Earlier strokes stay lit, but the jump between strokes is not drawn.
       bool jump = trailJump(a, b);
-      vec4 c = k + 2 < TRAIL_POINTS ? trailPoint(min(k + 2, TRAIL_POINTS - 1), uDemo) : vec4(0.0);
+      // The point after b: read once, it is the next segment's b.
+      vec4 c = k + 2 < TRAIL_POINTS ? trailNext(live) : vec4(0.0);
       vec2 next = c.w > 0.5 && !trailJump(b, c) ? c.xy : 2.0 * b.xy - a.xy;
       vec2 lo = min(min(prev, a.xy), min(b.xy, next)) * px - margin;
       vec2 hi = max(max(prev, a.xy), max(b.xy, next)) * px + margin;
       if (!jump && all(greaterThan(p, lo)) && all(lessThan(p, hi))) {
-        vec2 q0 = a.xy * px;
-        for (int j = 1; j <= 4; j++) {
-          vec2 q1 = catmull(prev, a.xy, b.xy, next, float(j) / 4.0) * px;
-          vec2 s = segment(p, q0, q1);
-          float when = mix(a.z, b.z, (float(j - 1) + s.y) / 4.0);
-          float fade = clamp(1.0 - (iTime - when) / uLife, 0.0, 1.0);
-          fade *= fade;
-          float d = s.x;
-          core = max(core, exp(-d * d / (uWidth * uWidth)) * fade);
-          halo = max(halo, exp(-d / glowR) * fade);
-          if (d < best) {
-            best = d;
-            bestWhen = when;
+        // Nothing on the segment is brighter than its newer end: skip it when it can be neither nearer
+        // nor brighter than what is found.
+        float dmin = trailBoxDist(p, prev, a.xy, b.xy, next, px);
+        float top = clamp(1.0 - (iTime - max(a.z, b.z)) / uLife, 0.0, 1.0);
+        top *= top;
+        if (dmin < best || exp(-dmin / glowR) * top > halo || exp(-dmin * dmin / (uWidth * uWidth)) * top > core) {
+          vec2 q0 = a.xy * px;
+          for (int j = 1; j <= 4; j++) {
+            vec2 q1 = catmull(prev, a.xy, b.xy, next, float(j) / 4.0) * px;
+            vec2 s = segment(p, q0, q1);
+            float when = mix(a.z, b.z, (float(j - 1) + s.y) / 4.0);
+            float fade = clamp(1.0 - (iTime - when) / uLife, 0.0, 1.0);
+            fade *= fade;
+            float d = s.x;
+            core = max(core, exp(-d * d / (uWidth * uWidth)) * fade);
+            halo = max(halo, exp(-d / glowR) * fade);
+            if (d < best) {
+              best = d;
+              bestWhen = when;
+            }
+            q0 = q1;
           }
-          q0 = q1;
         }
       }
       prev = jump ? 2.0 * b.xy - next : a.xy;
       a = b;
+      b = c;
     }
     // Colour from when the light passed, so each part keeps its colour as it fades.
     vec3 tint = spectrum(uHue + bestWhen * uCycle);
@@ -13803,6 +14119,16 @@ vec4 clickAt(int i, bool demo, float period) {
   vec2 h = hash22(vec2(k * 1.37 + 0.5, 3.7));
   return vec4((0.2 + 0.6 * h) * iResolution.xy, k * period, 1.0);
 }`.trim();
+var CORNER_HASHES = `
+vec4 cornerHashes(vec2 i) {
+  vec2 x = fract(vec2(i.x, i.x + 1.0) * 0.1031);
+  vec2 y = fract(vec2(i.y, i.y + 1.0) * 0.1031);
+  vec4 X = x.xyxy;
+  vec4 Y = y.xxyy;
+  vec4 d = X * (Y + 33.33) + Y * (X + 33.33) + X * (X + 33.33);
+  vec4 px = X + d;
+  return fract((px + (Y + d)) * px);
+}`.trim();
 var flowParticles = {
   kind: "shader",
   id: "flow-particles",
@@ -13825,19 +14151,25 @@ uniform vec3 uFast;         // @control color default=#7CFFE0 label="Fast colour
 uniform vec3 uBackground;   // @control color default=#04060E label="Background"
 uniform bool uTransparent;  // @control default=false label="Transparent"`,
     HASH,
-    NOISE,
+    CORNER_HASHES,
     GLOW6,
-    `float potential(vec2 p, float t) {
-  return vnoise(p + vec2(t, -0.6 * t)) + uTurbulence * 0.5 * vnoise(p * 2.3 - vec2(0.7 * t, t) + 9.1);
+    `// The gradient of vnoise, worked out exactly (its value is not needed here).
+vec2 vnoiseGrad(vec2 p) {
+  vec2 i = floor(p);
+  vec2 f = fract(p);
+  vec2 u = f * f * (3.0 - 2.0 * f);
+  vec2 du = 6.0 * f * (1.0 - f);
+  vec4 h = cornerHashes(i);
+  float k = h.x - h.y - h.z + h.w;
+  return du * vec2(h.y - h.x + k * u.y, h.z - h.x + k * u.x);
 }
 
-// The curl of the potential (divergence free, so streams swirl rather than pool), plus a gentle drift.
+// The curl of the potential vnoise(p + vec2(t, -0.6 t)) + turbulence * 0.5 * vnoise(p * 2.3 - vec2(0.7 t, t) + 9.1)
+// (divergence free, so streams swirl rather than pool), plus a gentle drift.
 vec2 flow(vec2 p, float t) {
-  const float e = 0.01;
-  float c = potential(p, t);
-  float dx = potential(p + vec2(e, 0.0), t) - c;
-  float dy = potential(p + vec2(0.0, e), t) - c;
-  return vec2(dy, -dx) / e + vec2(0.35, 0.08);
+  vec2 g = vnoiseGrad(p + vec2(t, -0.6 * t));
+  if (uTurbulence > 0.0) g += uTurbulence * 1.15 * vnoiseGrad(p * 2.3 - vec2(0.7 * t, t) + 9.1);
+  return vec2(g.y, -g.x) + vec2(0.35, 0.08);
 }
 
 void mainImage(out vec4 fragColor, in vec2 fragCoord) {
@@ -13847,22 +14179,38 @@ void mainImage(out vec4 fragColor, in vec2 fragCoord) {
   float ft = iTime * uSpeed * 0.04;
   float tail = max(uTail * float(STEPS), 1.0);
   vec3 col = vec3(0.0);
+  // The walk stays a few steps in each cell, so its particle is worked out once per cell.
+  vec2 cellAt = vec2(-1e9);
+  bool alive = false;
+  float life = 0.0;
+  vec2 at = vec2(0.0);
+  vec2 v = vec2(0.0);
+  float sp = 0.0;
   for (int k = 0; k < STEPS; k++) {
-    vec2 v = flow(q * uScale, ft);
-    float sp = length(v);
+    // The field barely turns over a step, so it is looked up every other step.
+    if ((k & 1) == 0) {
+      v = flow(q * uScale, ft);
+      sp = length(v);
+    }
     // One particle per cell at most; each life starts somewhere new in the cell.
     vec2 c = floor(q * uDensity);
-    float h0 = hash12(c + 0.31);
-    float phase = iTime * uSpeed * (0.3 + 0.3 * h0) + hash12(c + 7.7);
-    float life = fract(phase);
-    float cyc = floor(phase);
-    if (hash12(c * 1.7 + cyc * 3.1) < uAmount) {
-      vec2 hd = hash22(c + cyc * 17.13);
-      float d = length(q - (c + 0.25 + 0.5 * hd) * cell) / cell;
-      float spot = exp(-d * d * 14.0);
-      // This pixel lies k steps downstream of the particle's start; its head is "head" steps along.
-      float behind = life * float(STEPS) - float(k);
-      if (spot > 0.01 && behind >= 0.0 && behind < tail) {
+    if (c != cellAt) {
+      cellAt = c;
+      float h0 = hash12(c + 0.31);
+      float phase = iTime * uSpeed * (0.3 + 0.3 * h0) + hash12(c + 7.7);
+      life = fract(phase);
+      float cyc = floor(phase);
+      alive = hash12(c * 1.7 + cyc * 3.1) < uAmount;
+      if (alive) at = (c + 0.25 + 0.5 * hash22(c + cyc * 17.13)) * cell;
+    }
+    // This pixel lies k steps downstream of the particle's start; its head is "head" steps along.
+    float behind = life * float(STEPS) - float(k);
+    if (alive && behind >= 0.0 && behind < tail) {
+      vec2 dq = (q - at) / cell;
+      float d2 = dot(dq, dq);
+      // exp(-14 d^2) > 0.01
+      if (d2 < 0.329) {
+        float spot = exp(-d2 * 14.0);
         float w = 1.0 - behind / tail;
         float fade = smoothstep(0.0, 0.08, life) * (1.0 - smoothstep(0.75, 1.0, life));
         vec3 hue = mix(uSlow, uFast, smoothstep(0.3, 2.2, sp));
@@ -14130,12 +14478,40 @@ void mainImage(out vec4 fragColor, in vec2 fragCoord) {
   float t = iTime * uSpeed * 0.5;
   float len = 0.018 * uSize;
   float cover = 0.0;
+  // A bird is within its formation offset, jitter and size of the line between the two flocks
+  // it is moving between, so first find which pairs of flocks pass near this pixel (bit a * 4 + b).
+  float groups = float(uGroups);
+  vec2 flocks[4];
+  for (int g = 0; g < 4; g++) flocks[g] = flockAt(float(g), t, aspect);
+  float margin = 1.89 * uSpread + 0.036 * uJitter + 2.04 * len + 2.0 * px;
+  int near = 0;
+  for (int a = 0; a < 4; a++) {
+    if (a >= uGroups) break;
+    for (int b = 0; b < 4; b++) {
+      if (b >= uGroups) break;
+      vec2 pa = p - flocks[a];
+      vec2 ba = flocks[b] - flocks[a];
+      vec2 off = pa - ba * clamp(dot(pa, ba) / max(dot(ba, ba), 1e-8), 0.0, 1.0);
+      if (dot(off, off) < margin * margin) near |= 1 << (a * 4 + b);
+    }
+  }
   for (int i = 0; i < 120; i++) {
-    if (i >= uCount) break;
+    if (near == 0 || i >= uCount) break;
     float fi = float(i);
+    // birdAt, with the flock centres looked up and far birds dropped before the rest of the work.
+    vec2 h = hash22(vec2(fi, 3.1));
+    float sw = t * 0.06 * (0.6 + 0.8 * h.y) + h.x * 10.0;
+    float k = floor(sw);
+    int ga = int(floor(hash12(vec2(fi, k)) * groups));
+    float glide = smoothstep(0.6, 1.0, fract(sw));
+    int gb = glide > 0.0 ? int(floor(hash12(vec2(fi, k + 1.0)) * groups)) : ga;
+    if ((near & (1 << (ga * 4 + gb))) == 0) continue;
+    vec2 o = (hash22(vec2(fi, 8.3)) - 0.5) * 2.0 * uSpread;
+    o.x *= 1.6;
+    vec2 jitter = uJitter * 0.025 * vec2(sin(t * (1.1 + h.x) + fi), cos(t * (1.3 + h.y) + fi * 1.7));
+    vec2 pos = mix(flocks[ga], flocks[gb], glide) + o + jitter;
     float scale = 0.7 + 0.5 * hash12(vec2(fi, 6.6));
     float l = len * scale;
-    vec2 pos = birdAt(fi, t, aspect);
     vec2 dp = p - pos;
     if (abs(dp.x) > l * 1.2 || abs(dp.y) > l * 1.2) continue;
     vec2 v = pos - birdAt(fi, t - 0.03, aspect);
@@ -14194,7 +14570,7 @@ uniform float uDensity;      // @control min=40 max=240 default=120 step=1 label
 uniform float uScatter;      // @control min=0.1 max=1.5 default=0.4 label="Scatter distance"
 uniform float uDirection;    // @control min=-180 max=180 default=20 label="Drift direction"`,
     HASH,
-    NOISE,
+    CORNER_HASHES,
     `// The text image's alpha at frame point p (height 1, centred), the image contained in uSize of the frame.
 float letters(vec2 p) {
   vec2 size = vec2(textureSize(uText, 0));
@@ -14206,6 +14582,15 @@ float letters(vec2 p) {
   return texture(uText, uv).a;
 }
 
+// Half the size of the text's box in the frame (letters is 0 outside it).
+vec2 lettersHalf() {
+  vec2 size = vec2(textureSize(uText, 0));
+  float aspect = size.x / max(size.y, 1.0);
+  float frame = iResolution.x / iResolution.y;
+  float h = min(uSize, frame * uSize / aspect);
+  return 0.5 * vec2(h * aspect, h);
+}
+
 // How far through dissolving the particle at home is (0 in place, 1 gone): left to right, then back together.
 float scattered(vec2 home, float phase) {
   float frame = iResolution.x / iResolution.y;
@@ -14216,16 +14601,40 @@ float scattered(vec2 home, float phase) {
   return a * a * (3.0 - 2.0 * a);
 }
 
+// vnoise, keeping the corner hashes of the lattice cell it last looked in: the wind is smooth and
+// its lattice coarse, so most lookups land in the same cell as the one before.
+vec2 eddyCellA = vec2(-1e9);
+vec2 eddyCellB = vec2(-1e9);
+vec4 eddyHashA = vec4(0.0);
+vec4 eddyHashB = vec4(0.0);
+
+float eddy(vec2 p, inout vec2 cellAt, inout vec4 h) {
+  vec2 i = floor(p);
+  if (i != cellAt) {
+    cellAt = i;
+    h = cornerHashes(i);
+  }
+  vec2 f = fract(p);
+  vec2 u = f * f * (3.0 - 2.0 * f);
+  return mix(mix(h.x, h.y, u.x), mix(h.z, h.w, u.x), u.y);
+}
+
+// Group g's gust: its wind (xy) and how much it lifts what it carries (z).
+vec3 gustOf(float g) {
+  float ang = radians(uDirection) + (fract(g * 0.618) - 0.5) * 1.2;
+  return vec3(vec2(cos(ang), sin(ang)) * (0.3 + 0.18 * g), 0.3 * (0.5 + 0.2 * g));
+}
+
 // Where the wind has carried a particle of group g from home: smooth in home, so it can be inverted.
 // Each of the six groups rides its own gust (speed, heading and eddies), so they spread apart.
-vec2 carried(vec2 home, float phase, float g) {
+vec2 carried(vec2 home, float phase, float g, vec3 gust) {
   float a = scattered(home, phase);
-  float ang = radians(uDirection) + (fract(g * 0.618) - 0.5) * 1.2;
-  vec2 wind = vec2(cos(ang), sin(ang)) * (0.3 + 0.18 * g);
+  // Still at home (most of the frame, most of the time): no need for the eddies.
+  if (a <= 0.0) return vec2(0.0);
   float t = phase * 3.0;
   vec2 q = home * 3.0 + g * 5.3;
-  vec2 swirl = vec2(vnoise(q + vec2(t, 0.0)), vnoise(q + vec2(4.7, t))) - 0.5;
-  return a * uScatter * (wind + swirl * 0.8 + vec2(0.0, 0.3 * a * (0.5 + 0.2 * g)));
+  vec2 swirl = vec2(eddy(q + vec2(t, 0.0), eddyCellA, eddyHashA), eddy(q + vec2(4.7, t), eddyCellB, eddyHashB)) - 0.5;
+  return a * uScatter * (gust.xy + swirl * 0.8 + vec2(0.0, gust.z * a));
 }
 
 void mainImage(out vec4 fragColor, in vec2 fragCoord) {
@@ -14239,22 +14648,28 @@ void mainImage(out vec4 fragColor, in vec2 fragCoord) {
   vec3 col = uColor;
   float cover = solid;
 
+  // Every particle is home outside this part of the loop.
+  bool moving = phase > 0.12 && phase < 0.94;
+  vec2 box = lettersHalf() + 2.0 * cell;
   for (int gi = 0; gi < 6; gi++) {
+    if (!moving) break;
     float g = float(gi);
+    vec3 gust = gustOf(g);
     // Trace back to the home a particle of this group here would have come from, then search the cells round it.
     vec2 home = p;
-    for (int i = 0; i < 4; i++) home = p - carried(home, phase, g);
+    for (int i = 0; i < 4; i++) home = p - carried(home, phase, g, gust);
+    // The cells searched are all off the text.
+    if (any(greaterThan(abs(home), box))) continue;
     vec2 base = floor(home / cell);
     for (int y = -1; y <= 1; y++) {
       for (int x = -1; x <= 1; x++) {
         vec2 c = base + vec2(float(x), float(y));
         if (floor(hash12(c + 0.73) * 6.0) != g) continue;
         vec2 hc = (c + 0.5) * cell;
-        if (letters(hc) < 0.5) continue;
         float a = scattered(hc, phase);
-        if (a < 0.002) continue;
+        if (a < 0.002 || letters(hc) < 0.5) continue;
         vec2 j = hash22(c);
-        vec2 pos = hc + carried(hc, phase, g) + (j - 0.5) * cell * 1.1 * a;
+        vec2 pos = hc + carried(hc, phase, g, gust) + (j - 0.5) * cell * 1.1 * a;
         float r = cell * (0.5 - 0.1 * a) * (0.75 + 0.5 * j.x);
         float d = length(p - pos);
         float disc = (1.0 - smoothstep(r - px, r + px * 0.5, d)) * (1.0 - smoothstep(0.6, 1.0, a) * 0.6 * j.y);
@@ -14312,14 +14727,32 @@ vec4 blast(vec4 acc, vec2 p, vec2 origin, float angle, float spread, float speed
   float e = (1.0 - exp(-k * age)) / k;
   float fade = 1.0 - smoothstep(LIFE - 1.0, LIFE, age);
   float reach = 0.03 * uSize;
+  // Every piece is within its sway and the spread of fall speeds of the fan its launch sweeps out
+  // (speeds 0.5 to 1 times speed, within spread of angle, all dropped by the middle fall speed),
+  // so skip the blast where this pixel is clear of that.
+  float drop = 0.16 * uFall * (age - e);
+  vec2 rel = p - origin + vec2(0.0, drop);
+  float slack = reach * 1.42 + 0.035 + 0.3 * drop + px;
+  float r = length(rel);
+  float far = speed * e;
+  if (r > far + slack || r < 0.5 * far - slack) return acc;
+  if (spread < 6.2 && r > slack) {
+    float off = abs(mod(atan(rel.y, rel.x) - angle + 3.14159265, 6.28318531) - 3.14159265);
+    if (off > spread * 0.5 + asin(slack / r) + 0.01) return acc;
+  }
   for (int j = 0; j < 80; j++) {
     if (j >= count) break;
     float fj = float(j);
     vec2 h = hash22(vec2(fj * 7.13 + 1.0, seed));
+    float launch = speed * (0.5 + 0.5 * h.y);
+    // The same tests for this piece before working out the rest of it: how far out, then where.
+    if (abs(r - launch * e) > slack) continue;
+    float a = angle + (h.x - 0.5) * spread;
+    vec2 v0 = vec2(cos(a), sin(a)) * launch;
+    vec2 dv = rel - v0 * e;
+    if (abs(dv.x) > reach + 0.035 || abs(dv.y) > reach + 0.3 * drop) continue;
     vec2 h2 = hash22(h * 53.1 + seed);
     float h3 = hash12(h2 * 17.7 + fj);
-    float a = angle + (h.x - 0.5) * spread;
-    vec2 v0 = vec2(cos(a), sin(a)) * speed * (0.5 + 0.5 * h.y);
     float fall = 0.16 * uFall * (0.7 + 0.6 * h2.x);
     vec2 pos = origin + v0 * e - vec2(0.0, fall * (age - e));
     pos.x += 0.035 * sin(age * (2.0 + 2.0 * h2.y) + h.x * 6.28) * smoothstep(0.3, 1.2, age);
@@ -14732,18 +15165,6 @@ vec3 shardOf(vec2 q) {
   return vec3(sid, ring, edge);
 }
 
-// A shard's middle, which it turns about, and how far it reaches from there.
-vec3 shardCentre(float sid, float ring) {
-  float a0 = spoke(sid);
-  float a1 = spoke(sid + 1.0);
-  float mid = 0.5 * (a0 + a1);
-  float inner = ring > 0.0 ? ringAt(sid, ring) : 0.0;
-  float outer = ring + 1.0 < float(RINGS) ? ringAt(sid, ring + 1.0) : inner * uGrowth;
-  float rc = ring > 0.0 ? 0.5 * (inner + outer) : 0.66 * outer;
-  float reach = length(vec2(max(outer - rc, rc - inner), outer * tan(0.5 * (a1 - a0))));
-  return vec3(vec2(cos(mid), sin(mid)) * rc, reach + 0.01);
-}
-
 // When a shard lets go: the middle first, the outer pane last.
 float release(float sid, float ring) {
   return 0.3 + 0.16 * ring + 0.25 * hash12(vec2(sid, ring + 9.0));
@@ -14765,33 +15186,109 @@ void mainImage(out vec4 fragColor, in vec2 fragCoord) {
   vec4 col = vec4(uBackground, 1.0);
 
   // Shards that have let go, falling and spinning: the first to fall is in front.
+  // A ring at a time: the rings all of whose shards are too far from this pixel, wherever they are
+  // in their fall, are passed over whole; later rings let go later, so once one is not yet falling
+  // (or would be behind what is already here) neither are the rest.
   float best = 1e3;
   vec4 hit = vec4(0.0);
   vec2 hitCentre = vec2(0.0);
-  for (int s = 0; s < 16; s++) {
-    if (s >= uSpokes) break;
-    for (int j = 0; j < RINGS; j++) {
-      float sid = float(s);
-      float ring = float(j);
+  float n = float(uSpokes);
+  float spreadMax = tan(min(0.8 * TAU / n, 1.5));
+  for (int j = 0; j < RINGS; j++) {
+    float ring = float(j);
+    float firstGo = 0.3 + 0.16 * ring;
+    float dtHi = age - firstGo;
+    if (dtHi <= 0.0 || firstGo >= best) break;
+    float dtLo = max(dtHi - 0.25, 0.0);
+    // Bounds on this ring's shards: how far out their middles are, how far they reach, how far they have drifted and dropped.
+    float span = uScale * pow(uGrowth, ring);
+    float lo = j > 0 ? span / uGrowth : 0.0;
+    float rcLo = j > 0 ? 0.425 * (lo + span) : 0.561 * span;
+    float rcHi = j > 0 ? 0.575 * (lo + span) : 0.759 * span;
+    float radial = j > 0 ? 0.5 * max(1.15 * span - 0.85 * lo, 1.15 * lo - 0.85 * span) : rcHi;
+    float reachMax = length(vec2(radial, 1.15 * span * spreadMax)) + 0.02;
+    float rMin = rcLo + 0.05 * (1.0 - exp(-0.6 * dtLo)) / 0.6 / (1.0 + ring) - reachMax - 0.01;
+    float rMax = rcHi + 0.2 * (1.0 - exp(-0.6 * dtHi)) / 0.6 / (1.0 + ring) + reachMax + 0.01;
+    float yA = ballistic(vec2(0.0, 0.08), 0.6, uGravity, dtLo).y;
+    float yB = ballistic(vec2(0.0, 0.08), 0.6, uGravity, dtHi).y;
+    float yLo = min(yA, yB) - 0.02;
+    float yHi = max(yA, yB) + 0.02;
+    float dNear = length(vec2(q.x, q.y - clamp(q.y, yLo, yHi)));
+    float dFar = max(length(q - vec2(0.0, yLo)), length(q - vec2(0.0, yHi)));
+    if (dFar < rMin || dNear > rMax) continue;
+    // And of its shards, only those whose sector points (near enough) at this pixel from where the impact point has dropped to:
+    // each sector's middle lies 0.2\u20130.8 of the way round its share of the circle.
+    float first = 0.0;
+    float count = n;
+    float slack = reachMax + 0.01;
+    if (dNear > slack) {
+      vec2 na = normalize(q - vec2(0.0, yLo));
+      vec2 nb = normalize(q - vec2(0.0, yHi));
+      float w = 0.5 * acos(clamp(dot(na, nb), -1.0, 1.0)) + asin(slack / dNear);
+      vec2 bisect = na + nb;
+      float toward = atan(bisect.y, bisect.x) / (TAU / n);
+      w /= TAU / n;
+      first = ceil(toward - w - 0.8);
+      count = min(floor(toward + w - 0.2) - first + 1.0, n);
+    }
+    for (int k = 0; k < 16; k++) {
+      if (float(k) >= count) break;
+      float sid = mod(first + float(k), n);
       float tr = release(sid, ring);
       float dt = age - tr;
       if (dt <= 0.0 || tr >= best) continue;
+      // How far it has drifted (along e) and dropped since it let go: ballistic(), split so the drop can be used first.
+      float e = (1.0 - exp(-0.6 * dt)) / 0.6;
+      // Seen from where the impact point has dropped to by now, too near or far, or not in this sector's direction.
+      vec2 dropped = q - vec2(0.0, 0.08 * e - uGravity / 0.6 * (dt - e));
+      float far = length(dropped);
+      if (far < rMin || far > rMax) continue;
+      // Its two cracks, the direction halfway between them and tan of half the angle they make.
+      float a0 = spoke(sid);
+      float a1 = spoke(sid + 1.0);
+      vec2 d0 = vec2(cos(a0), sin(a0));
+      vec2 d1 = vec2(cos(a1), sin(a1));
+      vec2 dir = normalize(d0 + d1);
+      float spread = (d0.x * d1.y - d0.y * d1.x) / (1.0 + dot(d0, d1));
+      // Not pointing (near enough) this way: further off its middle than any of its corners could be.
+      float near = length(vec2(radial, 1.15 * span * spread)) + 0.03;
+      if (far > near && dot(dropped, dir) < sqrt(far * far - near * near)) continue;
+      // Its middle, which it turns about, and how far it reaches from there (ringAt, with the ring's scale worked out above).
+      float inner = j > 0 ? lo * (0.85 + 0.3 * hash12(vec2(sid, ring + 0.5))) : 0.0;
+      float outer = j + 1 < RINGS ? span * (0.85 + 0.3 * hash12(vec2(sid, ring + 1.5))) : inner * uGrowth;
+      float rc = j > 0 ? 0.5 * (inner + outer) : 0.66 * outer;
+      float reach = length(vec2(max(outer - rc, rc - inner), outer * spread)) + 0.01;
+      vec2 cen = dir * rc;
       vec2 h = hash22(vec2(sid, ring) + 17.3);
-      vec3 cen = shardCentre(sid, ring);
-      vec2 v0 = normalize(cen.xy + 1e-4) * (0.05 + 0.15 * h.x) / (1.0 + ring) + vec2(0.0, 0.08);
-      vec2 rel = q - cen.xy - ballistic(v0, 0.6, uGravity, dt);
-      if (length(rel) > cen.z) continue;
+      vec2 rel = dropped - cen - normalize(cen + 1e-4) * (0.05 + 0.15 * h.x) / (1.0 + ring) * e;
+      if (dot(rel, rel) > reach * reach) continue;
       float ang = (h.y - 0.5) * 2.0 * uSpin * dt;
       // It also turns about its own axis, narrowing and catching the light.
       float tilt = cos(dt * (0.6 + 1.2 * h.x) * uSpin);
       vec2 local = rot(-ang) * rel;
       local.x /= sign(tilt) * max(abs(tilt), 0.05);
-      vec2 orig = cen.xy + local;
-      vec3 sh = shardOf(orig);
-      if (sh.x != sid || sh.y != ring) continue;
+      vec2 orig = cen + local;
+      // Back on the pane, is that point inside this shard: between its two cracks and its two rings?
+      float side0 = d0.x * orig.y - d0.y * orig.x;
+      float side1 = d1.x * orig.y - d1.y * orig.x;
+      float d = dot(orig, dir);
+      float rim = j + 1 < RINGS ? outer : 1e3;
+      if (side0 < 0.0 || side1 >= 0.0 || d >= rim) continue;
+      // Past every ring inside it (they are a little ragged, so not only the nearest).
+      bool past = true;
+      for (int i = 1; i < RINGS; i++) {
+        if (i > j) break;
+        if (d < ringAt(sid, float(i))) {
+          past = false;
+          break;
+        }
+      }
+      if (!past) continue;
+      float edge = min(rim - d, min(abs(side0), abs(side1)));
+      if (j > 0) edge = min(edge, d - inner);
       best = tr;
-      hit = vec4(orig, tilt, sh.z);
-      hitCentre = cen.xy;
+      hit = vec4(orig, tilt, edge);
+      hitCentre = cen;
     }
   }
 
@@ -15273,6 +15770,14 @@ void mainImage(out vec4 fragColor, in vec2 fragCoord) {
       float b = now - float(k);
       float a = e - b * BATCH;
       if (a < 0.0 || a > LIFE) continue;
+      // Where its grains came from, give or take the turbulence: skip the batch unless that is in
+      // the shape and in the slab of it this batch was taken from (see batchOf).
+      vec2 from = (p - vec2(dirX * uWind * (0.15 * a + 0.55 * a * a), 0.05 * a + 0.03 * a * a) - origin) / vec2(shapeW, shapeH);
+      vec2 sway = uTurbulence * a * vec2(0.04, 0.11) / vec2(shapeW, shapeH) + 1e-3;
+      if (uFromRight) from.x = 1.0 - from.x;
+      float slabLo = max((b * BATCH - 0.775) / 1.5, 0.0);
+      float slabHi = min(((b + 1.0) * BATCH - 0.125) / 1.5, 1.0);
+      if (from.x + sway.x < slabLo || from.x - sway.x > slabHi || from.y + sway.y < 0.0 || from.y - sway.y > 1.0) continue;
       // Back from where a grain is to where it came from.
       vec2 s = p - blown(a, p);
       s = p - blown(a, s);
@@ -16256,12 +16761,64 @@ uniform float uSpeed;       // @control min=0 max=3 default=0.6 label="Drift spe
     `const float BOTTOM = 1.5;
 const float TOP = 3.2;
 
-float cloudDensity(vec3 p, int octaves) {
-  vec3 q = p * 0.42 + vec3(iTime * uSpeed * 0.12, 0.0, iTime * uSpeed * 0.05);
-  float n = fbm3(q, octaves);
+// The noise's lattice cell last used, and its eight corner hashes. Successive
+// samples along a ray (and toward the sun) mostly fall in the same cell of the
+// coarse octaves, so they reuse its hashes instead of hashing it again.
+struct Cell {
+  vec3 id;
+  vec4 lo;
+  vec4 hi;
+};
+
+Cell noCell() {
+  return Cell(vec3(1e9), vec4(0.0), vec4(0.0));
+}
+
+// vnoise3(p), with its corners taken from the cell when p is still in it.
+float cellNoise(vec3 p, inout Cell c) {
+  vec3 i = floor(p);
+  if (i != c.id) {
+    c.id = i;
+    c.lo = vec4(hash13(i), hash13(i + vec3(1.0, 0.0, 0.0)), hash13(i + vec3(0.0, 1.0, 0.0)), hash13(i + vec3(1.0, 1.0, 0.0)));
+    c.hi = vec4(hash13(i + vec3(0.0, 0.0, 1.0)), hash13(i + vec3(1.0, 0.0, 1.0)), hash13(i + vec3(0.0, 1.0, 1.0)), hash13(i + vec3(1.0, 1.0, 1.0)));
+  }
+  vec3 f = fract(p);
+  vec3 u = f * f * (3.0 - 2.0 * f);
+  float a = mix(c.lo.x, c.lo.y, u.x);
+  float b = mix(c.lo.z, c.lo.w, u.x);
+  float cc = mix(c.hi.x, c.hi.y, u.x);
+  float d = mix(c.hi.z, c.hi.w, u.x);
+  return mix(mix(a, b, u.y), mix(cc, d, u.y), u.z);
+}
+
+// fbm3(p, octaves) for three octaves or more, the first three through cells c0, c1 and c2.
+float cloudNoise(vec3 p, int octaves, inout Cell c0, inout Cell c1, inout Cell c2) {
+  float sum = 0.5 * cellNoise(p, c0);
+  p = p * 2.03 + vec3(11.7, 3.1, 7.9);
+  sum += 0.25 * cellNoise(p, c1);
+  p = p * 2.03 + vec3(11.7, 3.1, 7.9);
+  sum += 0.125 * cellNoise(p, c2);
+  p = p * 2.03 + vec3(11.7, 3.1, 7.9);
+  float amp = 0.0625;
+  for (int i = 3; i < 6; i++) {
+    if (i >= octaves) break;
+    sum += amp * vnoise3(p);
+    p = p * 2.03 + vec3(11.7, 3.1, 7.9);
+    amp *= 0.5;
+  }
+  return sum;
+}
+
+// The cloud's density at p from its noise to the given octaves; rest stands in
+// for the octaves left out (their average), so the cloud keeps its mass.
+float cloudDensity(vec3 p, int octaves, float rest, inout Cell c0, inout Cell c1, inout Cell c2) {
   float h = clamp((p.y - BOTTOM) / (TOP - BOTTOM), 0.0, 1.0);
   // Rounded tops and flat-ish bases.
   float shape = smoothstep(0.0, 0.15, h) * (1.0 - smoothstep(0.45, 1.0, h));
+  // Outside the slab there's no cloud, whatever the noise.
+  if (shape <= 0.0) return 0.0;
+  vec3 q = p * 0.42 + vec3(iTime * uSpeed * 0.12, 0.0, iTime * uSpeed * 0.05);
+  float n = cloudNoise(q, octaves, c0, c1, c2) + rest;
   return clamp((n - (1.0 - uCoverage) * 0.75) * 3.0 * shape, 0.0, 1.0) * uDensity;
 }
 
@@ -16280,21 +16837,35 @@ void mainImage(out vec4 fragColor, in vec2 fragCoord) {
   if (rd.y > 0.02) {
     float t0 = BOTTOM / rd.y;
     float t1 = min(TOP / rd.y, t0 + 14.0);
-    float dt = (t1 - t0) / 40.0;
+    // Steps of about 0.35 (as long as a ray toward the horizon takes in 40), so
+    // short, steep rays take fewer: between 28 and 40 (fewer shows the jitter as grain).
+    float steps = clamp(ceil((t1 - t0) / 0.35), 28.0, 40.0);
+    float dt = (t1 - t0) / steps;
     float t = t0 + dt * fract(sin(dot(fragCoord, vec2(12.9898, 78.233))) * 43758.5453);
     // Henyey-Greenstein: a forward lobe for the silver lining plus a soft back lobe.
     float g = 0.65;
     float hg = (1.0 - g * g) / pow(1.0 + g * g - 2.0 * g * mu, 1.5) / 12.566;
     float phase = mix(0.08, hg * 4.0, 0.7);
+    // Noise cells along the ray (m) and toward the sun (l).
+    Cell m0 = noCell();
+    Cell m1 = noCell();
+    Cell m2 = noCell();
+    Cell l0 = noCell();
+    Cell l1 = noCell();
+    Cell l2 = noCell();
     for (int i = 0; i < 40; i++) {
-      if (trans < 0.02 || t > 60.0) break;
+      if (trans < 0.02 || t > 60.0 || float(i) >= steps) break;
       vec3 pos = rd * t;
-      int oct = t < 18.0 ? 5 : 3;
-      float d = cloudDensity(pos, oct);
+      // Fine detail where it shows: five octaves near and in front, fewer once
+      // the cloud in front hides most of this sample, three far away.
+      int oct = t < 18.0 ? (trans > 0.5 ? 5 : trans > 0.15 ? 4 : 3) : 3;
+      float rest = t < 18.0 ? 0.5 * (exp2(-float(oct)) - exp2(-5.0)) : 0.0;
+      float d = cloudDensity(pos, oct, rest, m0, m1, m2);
       if (d > 0.01) {
-        // Light march toward the sun for self-shadowing.
+        // Light march toward the sun for self-shadowing: the cloud between 0.11 and
+        // 0.99 toward it, sampled at the middles of its two halves.
         float shade = 0.0;
-        for (int j = 1; j <= 4; j++) shade += cloudDensity(pos + sun * 0.22 * float(j), 3);
+        for (int j = 0; j < 2; j++) shade += 2.0 * cloudDensity(pos + sun * (0.33 + 0.44 * float(j)), 3, 0.0, l0, l1, l2);
         float light = exp(-shade * 1.4);
         float powder = 1.0 - exp(-d * 4.0);
         vec3 lit = mix(uShadowColor, uCloudColor, light) + uSunColor * light * powder * phase * 2.5;
@@ -16769,6 +17340,75 @@ float coverage(vec2 p, float radius) {
   }
   return sum / 16.0;
 }`.trim();
+function goldenTaps(n11) {
+  const taps = Array.from({ length: n11 }, (_, i) => {
+    const r = Math.sqrt((i + 0.5) / n11);
+    const a = i * 2.39996;
+    return `vec2(${(r * Math.cos(a)).toFixed(5)}, ${(r * Math.sin(a)).toFixed(5)})`;
+  });
+  return `const vec2 GOLDEN${n11}[${n11}] = vec2[${n11}](${taps.join(", ")});`;
+}
+function coverageTaps(name, n11, blur) {
+  return `
+${goldenTaps(n11)}
+float ${name}(vec2 p, float radius) {
+  float sum = 0.0;
+  if (gMaskPlace.w < 0.5) {
+    for (int i = 0; i < ${n11}; i++) sum += shapeAt(p + radius * GOLDEN${n11}[i], radius * ${blur.toFixed(2)});
+  } else {
+    float lod = log2(max(radius * ${blur.toFixed(2)} * gMaskPlace.z, 1.0));
+    for (int i = 0; i < ${n11}; i++) sum += shapeLod(p + radius * GOLDEN${n11}[i], lod);
+  }
+  return sum / ${n11}.0;
+}`.trim();
+}
+var LITE_TAPS = 10;
+var MASK_FAST = `
+vec3 gKeyColour;
+float gKeyTolerance;
+// Picture units per frame unit (xy), texels per frame unit (z), 1 with a picture (w).
+vec4 gMaskPlace;
+
+// The colour in the picture's top-left corner: the ground to key out; and where the picture sits.
+void setKey(float tolerance) {
+  gKeyTolerance = tolerance;
+  vec4 c = textureLod(uMask, vec2(0.01, 0.99), 0.0);
+  gKeyColour = c.rgb / max(c.a, 1e-3);
+  vec2 size = vec2(textureSize(uMask, 0));
+  float aspect = size.x / size.y;
+  float h = min(uSize, iResolution.x / iResolution.y * uSize / aspect);
+  gMaskPlace = vec4(1.0 / (h * aspect), 1.0 / h, size.y / h, size.x > 1.0 ? 1.0 : 0.0);
+}
+
+// Where frame point p falls in the picture (xy) and texels per frame unit (z).
+vec3 maskPlace(vec2 p) {
+  return vec3(p * gMaskPlace.xy + 0.5, gMaskPlace.z);
+}
+
+// The picture's coverage at p read at mip level lod (needs a picture).
+float shapeLod(vec2 p, float lod) {
+  vec2 uv = p * gMaskPlace.xy + 0.5;
+  if (uv.x < 0.0 || uv.x > 1.0 || uv.y < 0.0 || uv.y > 1.0) return 0.0;
+  vec4 c = textureLod(uMask, uv, lod);
+  float a = c.a;
+  if (gKeyTolerance > 0.0) {
+    float away = distance(c.rgb / max(c.a, 1e-3), gKeyColour);
+    a *= smoothstep(gKeyTolerance, gKeyTolerance + 0.12, away);
+  }
+  return a;
+}
+
+float shapeAt(vec2 p, float blur) {
+  if (gMaskPlace.w < 0.5) {
+    float d = length(p) - 0.3 * uSize;
+    return clamp(0.5 - d / max(blur, 0.004), 0.0, 1.0);
+  }
+  return shapeLod(p, log2(max(blur * gMaskPlace.z, 1.0)));
+}
+
+${coverageTaps("coverage", 16, 0.4)}
+
+${coverageTaps("coverageLite", LITE_TAPS, 0.5)}`.trim();
 var aura = {
   kind: "shader",
   id: "aura",
@@ -16793,7 +17433,7 @@ uniform float uIntensity;    // @control min=0 max=3 default=1.1 label="Intensit
     HASH,
     NOISE,
     FBM,
-    MASK,
+    MASK_FAST,
     `void mainImage(out vec4 fragColor, in vec2 fragCoord) {
   setKey(uKey);
   vec2 p = (fragCoord - 0.5 * iResolution.xy) / iResolution.y;
@@ -16805,10 +17445,11 @@ uniform float uIntensity;    // @control min=0 max=3 default=1.1 label="Intensit
   float n2 = fbm(vec2(q.x * 1.7 + 4.1, q.y * 0.9 - t * 2.9), 4);
   float pulse = 1.0 + uPulse * (0.3 * sin(t * 3.0) + 0.12 * sin(t * 7.3 + 1.0));
   // The silhouette blurred at three widths, swayed and stretched upward by the noise, so light gathers above it.
+  // The two wide blurs, torn by the noise anyway, take fewer taps.
   vec2 warp = vec2((n2 - 0.5) * uSpread * 1.5, -(n - 0.3) * uHeight);
   float inner = coverage(p + warp * 0.3, uSpread * 0.5);
-  float outer = coverage(p + warp, uSpread * 1.4);
-  float tall = coverage(p + warp * 1.5 - vec2(0.0, uHeight), uSpread * 2.2);
+  float outer = coverageLite(p + warp, uSpread * 1.4);
+  float tall = coverageLite(p + warp * 1.5 - vec2(0.0, uHeight), uSpread * 2.2);
   float field = (inner * 0.9 + outer * 0.8 + tall * 0.6) * pulse;
   // Torn into tongues: the noise breaks the thin outer field into licks, the thick inner field holds.
   float tongues = smoothstep(0.12, 0.95, field * (0.45 + 1.1 * n));
@@ -16818,7 +17459,7 @@ uniform float uIntensity;    // @control min=0 max=3 default=1.1 label="Intensit
   light *= uIntensity;
   vec3 col = uBackground + (1.0 - exp(-light));
   // The figure in front, its own colours, rim-lit by the aura.
-  if (textureSize(uMask, 0).x > 1 && body > 0.0) {
+  if (gMaskPlace.w > 0.5 && body > 0.0) {
     vec3 m = maskPlace(p);
     vec4 c = texture(uMask, m.xy);
     vec3 own = c.rgb / max(c.a, 1e-3);
@@ -17059,7 +17700,7 @@ uniform float uSpeed;        // @control min=0 max=2 default=0.4 label="Ray drif
 uniform float uIntensity;    // @control min=0 max=3 default=1.3 label="Intensity"`,
     HASH,
     NOISE,
-    MASK,
+    MASK_FAST,
     `void mainImage(out vec4 fragColor, in vec2 fragCoord) {
   setKey(uKey);
   float px = 1.0 / iResolution.y;
@@ -17068,17 +17709,21 @@ uniform float uIntensity;    // @control min=0 max=3 default=1.3 label="Intensit
   vec2 toL = L - p;
   float dl = length(toL);
   // Light reaching here: march toward the light, the shape shadowing what is behind it.
+  // 24 jittered steps (decay and sum scaled to match 0.965 per 1/40 of the way); steps three light
+  // sizes or more from it add almost nothing, so they skip reading the shape.
   float shafts = 0.0;
   float decay = 1.0;
   float jitter = hash12(fragCoord);
-  for (int i = 0; i < 40; i++) {
-    float s = (float(i) + jitter) / 40.0;
-    vec2 q = p + toL * s;
-    float open = 1.0 - shapeAt(q, 2.0 * px + 0.01 * s);
-    shafts += open * exp(-pow(length(q - L) / uGlowSize, 2.0)) * decay;
-    decay *= 0.965;
-  }
-  shafts /= 20.0;
+  float far = 3.0 * uGlowSize;
+  for (int i = 0; i < 24; i++) {
+    float s = (float(i) + jitter) / 24.0;
+    float r = dl * (1.0 - s);
+    float open = r < far ? 1.0 - shapeAt(p + toL * s, 2.0 * px + 0.01 * s) : 1.0;
+    float g = r / uGlowSize;
+    shafts += open * exp(-g * g) * decay;
+    decay *= 0.94236;
+  }
+  shafts /= 12.0;
   // Streaks round the light, drifting slowly.
   vec2 dir = -toL / max(dl, 1e-4);
   float a = iTime * uSpeed * 0.2;
@@ -17086,7 +17731,7 @@ uniform float uIntensity;    // @control min=0 max=3 default=1.3 label="Intensit
   float rays = shafts * mix(1.0, 0.25 + 1.5 * streak * streak, uRays);
   // Spill: light wrapping just round the edges.
   float body = shapeAt(p, 1.2 * px);
-  float spill = coverage(p, 0.03) * 0.8 + coverage(p, 0.08) * 0.5;
+  float spill = coverage(p, 0.03) * 0.8 + coverageLite(p, 0.08) * 0.5;
   float glowAt = exp(-pow(dl / (uGlowSize * 1.6), 2.0));
   vec3 light = uLight * (rays * 1.4 + spill * (1.0 - body) * glowAt * 1.2) * uIntensity;
   vec3 col = uBackground + (1.0 - exp(-light));
@@ -19534,4 +20179,4 @@ export {
   effectControls,
   effectDefaults
 };
-//# sourceMappingURL=chunk-KD7E3RWF.js.map
+//# sourceMappingURL=chunk-3RKDS64M.js.map