react-native-webrtc-kaleidoscope 2.3.0 → 2.4.0

package/catalog/shaders/halftone-waves/halftone-waves.frag

@@ -0,0 +1,84 @@
+// Halftone waves: a dot lattice whose dot size is modulated by slow traveling
+// interference waves; the late-2000s "mathematical" tech texture as an opaque
+// BACKGROUND layer (issue #61). The cheapest of the corporate-abstract set:
+// per pixel, one hash-free cell lookup, two sines evaluated at the CELL CENTER
+// (so every pixel of a dot agrees), and one blended distance metric. No noise,
+// no pow, no loops.
+//
+// Overdrive surface: the two-tone palette inverts the whole mood (ink on
+// paper vs paper on ink), uPitch sets the texture scale, uShape morphs the
+// dots diamond -> circle -> square, uWaveAmp and uSpeed set how alive it is.
+// uCalm eases the wave modulation near frame center, where the masked
+// subject's face sits.
+//
+// UV convention: matches passthrough.vert. vUv = (0, 0) at bottom-left,
+// (1, 1) at top-right. fragCoord is reconstructed as vUv * uResolution; no
+// gl_FragCoord. Fully procedural: no input texture, zero net texture flips on
+// every runtime.
+//
+// Precision: highp float, matching the other procedural shaders; the cell
+// math is plain fract/floor and would survive mediump, but consistency wins.
+
+#version 300 es
+precision highp float;
+
+uniform float uTime;       // seconds, monotonically increasing; range [0, inf)
+uniform vec2 uResolution;  // framebuffer size in pixels; both components > 0
+uniform vec3 uPaper;       // field color (behind the dots)
+uniform vec3 uInk;         // dot color
+uniform float uPitch;      // dot-grid cells across frame height
+uniform float uDotSize;    // base dot radius in cell units, 0..0.5
+uniform float uWaveAmp;    // radius modulation depth, 0..1
+uniform float uSpeed;      // wave travel rate; 0 freezes
+uniform float uShape;      // dot shape: 0 diamond, 1 circle, 2 square
+uniform float uAngle;      // wave direction, radians
+uniform float uCalm;       // 0..1 eases the waves at frame center (face zone)
+
+in highp vec2 vUv;
+out vec4 oColor;
+
+// Antialias half-width in cell units; ~1px at the default pitch.
+const float AA = 0.06;
+
+void main() {
+  // Aspect-correct, screen-centered coordinates (matches plasma/nebula).
+  vec2 fragCoord = vUv * uResolution;
+  vec2 uv = (fragCoord - 0.5 * uResolution) / uResolution.y;
+  float centerDist = length(uv);
+
+  vec2 luv = uv * uPitch;
+  vec2 id = floor(luv);
+  vec2 gv = fract(luv) - 0.5;
+  // Wave phase is sampled at the CELL CENTER so a dot's radius is uniform
+  // across its own pixels (true halftone, not a warped field).
+  vec2 c = (id + 0.5) / uPitch;
+
+  float t = uTime * uSpeed;
+  vec2 dir1 = vec2(cos(uAngle), sin(uAngle));
+  vec2 dir2 = vec2(cos(uAngle + 2.2), sin(uAngle + 2.2));
+  // Two traveling waves at incommensurate frequencies: interference patterns
+  // that drift forever without visibly repeating.
+  float w = 0.5 + 0.25 * sin(dot(c, dir1) * 3.1 + t) + 0.25 * sin(dot(c, dir2) * 4.7 - t * 0.77);
+
+  // uCalm: flatten the modulation toward its midpoint near frame center.
+  float calm = uCalm * (1.0 - smoothstep(0.15, 0.62, centerDist));
+  w = mix(w, 0.5, calm);
+
+  float radius = uDotSize * mix(1.0 - uWaveAmp, 1.0 + uWaveAmp, w);
+
+  // Blended distance metric, pow-free (variable-exponent pow lowers to
+  // exp2+log2 on mobile): diamond (L1) -> circle (L2) -> square (Linf).
+  vec2 q = abs(gv);
+  float dDiamond = (q.x + q.y) * 0.7071;
+  float dCircle = length(q);
+  float dSquare = max(q.x, q.y);
+  float d = (uShape < 1.0)
+      ? mix(dDiamond, dCircle, clamp(uShape, 0.0, 1.0))
+      : mix(dCircle, dSquare, clamp(uShape - 1.0, 0.0, 1.0));
+
+  float m = smoothstep(radius + AA, radius - AA, d);
+  vec3 color = mix(uPaper, uInk, m);
+
+  // Opaque procedural background; the person is composited over it downstream.
+  oColor = vec4(color, 1.0);
+}

package/catalog/shaders/halftone-waves/halftone-waves.ts

@@ -0,0 +1,100 @@
+// Halftone-waves layer-shader interface: typed uniforms + control descriptor.
+// A dot lattice with traveling-wave size modulation (the late-2000s
+// "mathematical" tech texture), an opaque BACKGROUND layer (issue #61). One
+// halftone-waves.frag fans out into the book presets (boardroom, press,
+// ripple) by varying these uniforms; the two-tone palette is the big lever.
+// Shader source is shaders/halftone-waves.frag.
+
+import type { RGB } from '../../../src/lib/primitives.types';
+import type { UniformControl } from '../_shared/types';
+
+/** Typed uniforms for the `halftone-waves` layer shader. */
+export type HalftoneWavesUniforms = {
+  /** Field color behind the dots. */
+  readonly uPaper: RGB;
+  /** Dot color. */
+  readonly uInk: RGB;
+  /** Dot-grid cells across frame height; higher = finer texture. */
+  readonly uPitch: number;
+  /** Base dot radius in cell units. */
+  readonly uDotSize: number;
+  /** Wave modulation depth; 0 = static even dots. */
+  readonly uWaveAmp: number;
+  /** Wave travel rate; 0 freezes. */
+  readonly uSpeed: number;
+  /** Dot shape: 0 diamond, 1 circle, 2 square. */
+  readonly uShape: number;
+  /** Wave direction in radians. */
+  readonly uAngle: number;
+  /** Eases the waves at frame center (the face zone); 0 = off. */
+  readonly uCalm: number;
+};
+
+/** The `halftone-waves` shader's tunables; defaults are the "boardroom" look. */
+export const HALFTONE_WAVES_CONTROLS: readonly UniformControl[] = [
+  { name: 'uPaper', kind: 'color', default: [0.95, 0.95, 0.94], doc: 'Field color.' },
+  { name: 'uInk', kind: 'color', default: [0.62, 0.66, 0.7], doc: 'Dot color.' },
+  {
+    name: 'uPitch',
+    kind: 'float',
+    default: 26,
+    min: 8,
+    max: 60,
+    step: 1,
+    doc: 'Dot-grid cells across frame height.',
+  },
+  {
+    name: 'uDotSize',
+    kind: 'float',
+    default: 0.26,
+    min: 0.05,
+    max: 0.5,
+    step: 0.01,
+    doc: 'Base dot radius in cell units.',
+  },
+  {
+    name: 'uWaveAmp',
+    kind: 'float',
+    default: 0.55,
+    min: 0,
+    max: 1,
+    step: 0.01,
+    doc: 'Wave modulation depth.',
+  },
+  {
+    name: 'uSpeed',
+    kind: 'float',
+    default: 0.5,
+    min: 0,
+    max: 2,
+    step: 0.01,
+    doc: 'Wave travel rate; 0 freezes.',
+  },
+  {
+    name: 'uShape',
+    kind: 'float',
+    default: 1,
+    min: 0,
+    max: 2,
+    step: 0.05,
+    doc: 'Dot shape: 0 diamond, 1 circle, 2 square.',
+  },
+  {
+    name: 'uAngle',
+    kind: 'float',
+    default: 0.6,
+    min: 0,
+    max: 6.28,
+    step: 0.01,
+    doc: 'Wave direction, radians.',
+  },
+  {
+    name: 'uCalm',
+    kind: 'float',
+    default: 0,
+    min: 0,
+    max: 1,
+    step: 0.01,
+    doc: 'Eases the waves at frame center (face zone).',
+  },
+];

package/catalog/shaders/index.ts

@@ -4,19 +4,25 @@
 // re-exported individually; a consumer imports the one its preset's layer needs.
 
 import type { AnamorphicLensFlareUniforms } from './anamorphic-lensflare/anamorphic-lensflare';
+import type { AuroraSilkUniforms } from './aurora-silk/aurora-silk';
 import type { BlurUniforms } from './blur/blur';
 import type { CloudsUniforms } from './clouds/clouds';
 import type { CorporateBlobsUniforms } from './corporate-blobs/corporate-blobs';
 import type { FirefliesUniforms } from './fireflies/fireflies';
 import type { GodraysUniforms } from './godrays/godrays';
+import type { HalftoneWavesUniforms } from './halftone-waves/halftone-waves';
+import type { KaleidoscopeShaderUniforms } from './kaleidoscope/kaleidoscope';
 import type { LightBeamsAndMotesUniforms } from './light-beams-and-motes/light-beams-and-motes';
 import type { NebulaUniforms } from './nebula/nebula';
+import type { NeoMemphisUniforms } from './neo-memphis/neo-memphis';
 import type { PlasmaUniforms } from './plasma/plasma';
 import type { SimianlightsUniforms } from './simianlights/simianlights';
 
 export { defaultUniforms, type UniformControl } from './_shared/types';
 export type { AnamorphicLensFlareUniforms } from './anamorphic-lensflare/anamorphic-lensflare';
 export { ANAMORPHIC_LENSFLARE_CONTROLS } from './anamorphic-lensflare/anamorphic-lensflare';
+export type { AuroraSilkUniforms } from './aurora-silk/aurora-silk';
+export { AURORA_SILK_CONTROLS } from './aurora-silk/aurora-silk';
 export type { BlurUniforms } from './blur/blur';
 export { BLUR_CONTROLS } from './blur/blur';
 export type { CloudsUniforms } from './clouds/clouds';
@@ -27,10 +33,16 @@ export type { FirefliesUniforms } from './fireflies/fireflies';
 export { FIREFLIES_CONTROLS } from './fireflies/fireflies';
 export type { GodraysUniforms } from './godrays/godrays';
 export { GODRAYS_CONTROLS } from './godrays/godrays';
+export type { HalftoneWavesUniforms } from './halftone-waves/halftone-waves';
+export { HALFTONE_WAVES_CONTROLS } from './halftone-waves/halftone-waves';
+export type { KaleidoscopeShaderUniforms } from './kaleidoscope/kaleidoscope';
+export { KALEIDOSCOPE_CONTROLS } from './kaleidoscope/kaleidoscope';
 export type { LightBeamsAndMotesUniforms } from './light-beams-and-motes/light-beams-and-motes';
 export { LIGHT_BEAMS_AND_MOTES_CONTROLS } from './light-beams-and-motes/light-beams-and-motes';
 export type { NebulaUniforms } from './nebula/nebula';
 export { NEBULA_CONTROLS } from './nebula/nebula';
+export type { NeoMemphisUniforms } from './neo-memphis/neo-memphis';
+export { NEO_MEMPHIS_CONTROLS } from './neo-memphis/neo-memphis';
 export type { PlasmaUniforms } from './plasma/plasma';
 export { PLASMA_CONTROLS } from './plasma/plasma';
 export type { SimianlightsUniforms } from './simianlights/simianlights';
@@ -47,10 +59,14 @@ export type ShaderUniformsMap = {
   readonly clouds: CloudsUniforms;
   readonly godrays: GodraysUniforms;
   readonly fireflies: FirefliesUniforms;
+  readonly kaleidoscope: KaleidoscopeShaderUniforms;
+  readonly 'halftone-waves': HalftoneWavesUniforms;
   readonly plasma: PlasmaUniforms;
   readonly nebula: NebulaUniforms;
+  readonly 'neo-memphis': NeoMemphisUniforms;
   readonly simianlights: SimianlightsUniforms;
   readonly 'anamorphic-lensflare': AnamorphicLensFlareUniforms;
+  readonly 'aurora-silk': AuroraSilkUniforms;
   readonly 'light-beams-and-motes': LightBeamsAndMotesUniforms;
   readonly 'corporate-blobs': CorporateBlobsUniforms;
 };

package/catalog/shaders/kaleidoscope/kaleidoscope.form.tsx

@@ -0,0 +1,35 @@
+// Kaleidoscope's editor form: the shader OWNS its control layout (the plasma
+// pattern). One <Control uniform="…"/> per uniform in declared order; layout
+// or grouping changes are a local edit here. Conventional layer id:
+// "kaleidoscope".
+
+import {
+  Control,
+  ControlForm,
+  ControlSection,
+  type KaleidoscopeControls,
+} from '../../../src/components/preset-control-panel';
+import { KALEIDOSCOPE_CONTROLS } from './kaleidoscope';
+
+export function KaleidoscopeForm({ uniforms, onPatch, disabled }: KaleidoscopeControls) {
+  return (
+    <ControlForm
+      id="kaleidoscope"
+      uniforms={uniforms.kaleidoscope ?? {}}
+      onPatch={onPatch}
+      disabled={disabled}
+      controls={KALEIDOSCOPE_CONTROLS}
+    >
+      <ControlSection title="kaleidoscope">
+        <Control uniform="uColorA" />
+        <Control uniform="uColorB" />
+        <Control uniform="uColorC" />
+        <Control uniform="uSegments" />
+        <Control uniform="uSpeed" />
+        <Control uniform="uRotate" />
+        <Control uniform="uZoom" />
+        <Control uniform="uCalm" />
+      </ControlSection>
+    </ControlForm>
+  );
+}

package/catalog/shaders/kaleidoscope/kaleidoscope.frag

@@ -0,0 +1,93 @@
+// Kaleidoscope: the library's namesake. A mirrored polar fold (angle modulo
+// 2pi/N) over a cheap drifting sine field; the fold makes any source field
+// read as ornamental cut glass. An opaque BACKGROUND layer (issue #61).
+//
+// Overdrive surface: uSegments changes the whole character (6 = bold facets,
+// 12 = lace), the three palette colors re-skin it completely, uRotate/uSpeed
+// set the energy. uCalm eases contrast toward frame center, where the masked
+// subject's face sits, so the pattern stays lively at the edges without
+// flickering behind a speaker.
+//
+// UV convention: matches passthrough.vert. vUv = (0, 0) at bottom-left,
+// (1, 1) at top-right. fragCoord is reconstructed as vUv * uResolution so this
+// stays on the vUv convention and never reads gl_FragCoord (whose Y
+// orientation flips between OpenGL and Metal). Fully procedural: no input
+// texture, so there is no texture-origin handoff to flip. Net texture flips:
+// zero on every runtime. The polar fold is rotation-symmetric, so even a
+// hypothetical flip would be invisible here; the convention is kept anyway.
+//
+// Precision: highp float, matching the other procedural shaders (bounded
+// sine sums, but vUv is highp by the passthrough.vert contract and the fold's
+// atan/mod chain benefits from full mantissa at high segment counts).
+//
+// Cost class: plasma plus one atan and a mod; no loops, no noise, no hashing.
+
+#version 300 es
+precision highp float;
+
+uniform float uTime;       // seconds, monotonically increasing; range [0, inf)
+uniform vec2 uResolution;  // framebuffer size in pixels; both components > 0
+uniform vec3 uColorA;      // base palette color (also the calm midpoint pole)
+uniform vec3 uColorB;      // second palette color
+uniform vec3 uColorC;      // accent color, layered over the A/B field
+uniform float uSegments;   // mirror segment count; floor()ed, clamped >= 3
+uniform float uSpeed;      // source-field drift rate; 0 freezes the pattern
+uniform float uRotate;     // whole-field rotation rate; sign sets direction
+uniform float uZoom;       // pattern scale; higher = more rings of detail
+uniform float uCalm;       // 0..1 eases contrast at frame center (face zone)
+
+in highp vec2 vUv;
+out vec4 oColor;
+
+const float TAU = 6.28318530718;
+
+void main() {
+  // Aspect-correct, screen-centered coordinates (matches plasma/nebula).
+  vec2 fragCoord = vUv * uResolution;
+  vec2 uv = (fragCoord - 0.5 * uResolution) / uResolution.y;
+  float centerDist = length(uv);
+
+  // Whole-field rotation: the slow "turning the scope" motion.
+  float ra = uTime * uRotate;
+  float cs = cos(ra);
+  float sn = sin(ra);
+  uv = mat2(cs, -sn, sn, cs) * uv;
+
+  // Mirrored polar fold. The 1e-5 nudge keeps atan() off the undefined (0,0)
+  // input under Metal; it is far below one pixel at any resolution.
+  float r = centerDist * uZoom * (1.0 + 0.06 * sin(uTime * 0.23));
+  float seg = TAU / max(3.0, floor(uSegments));
+  float a = atan(uv.y, uv.x + 1e-5);
+  a = mod(a, seg);
+  a = abs(a - seg * 0.5);
+  vec2 p = r * vec2(cos(a), sin(a));
+
+  float t = uTime * uSpeed;
+
+  // Drifting source field, plasma-class: a few sines of folded position and
+  // time. The off-axis moving center in the length() term keeps the pattern
+  // evolving (non-repeating) rather than pulsing in place.
+  float f1 = sin(p.x * 6.0 + t)
+      + sin((p.x + p.y) * 4.2 - t * 0.7)
+      + sin(length(p - vec2(0.9 + 0.25 * sin(t * 0.31), 0.0)) * 7.0 + t * 1.1);
+  float f2 = sin(p.y * 5.0 - t * 0.9 + sin(p.x * 3.1 + t * 0.4));
+  float m1 = 0.5 + 0.5 * sin(f1);
+  float m2 = smoothstep(0.25, 0.9, 0.5 + 0.5 * sin(f2 + f1 * 0.5));
+
+  vec3 color = mix(uColorA, uColorB, m1);
+  color = mix(color, uColorC, m2 * 0.65);
+
+  // Thin darkening along both mirror lines sells the cut-glass facets.
+  float seam = smoothstep(0.035, 0.0, abs(a - seg * 0.5)) + smoothstep(0.035, 0.0, a);
+  color *= 1.0 - 0.18 * seam;
+
+  // uCalm: ease toward the palette midpoint near frame center. Spatial-only
+  // (never scales time per pixel, which would shear the field across the
+  // falloff ring).
+  vec3 mid = 0.5 * (uColorA + uColorB);
+  float calm = uCalm * (1.0 - smoothstep(0.15, 0.62, centerDist));
+  color = mix(color, mid, calm * 0.6);
+
+  // Opaque procedural background; the person is composited over it downstream.
+  oColor = vec4(color, 1.0);
+}

package/catalog/shaders/kaleidoscope/kaleidoscope.ts

@@ -0,0 +1,81 @@
+// Kaleidoscope layer-shader interface: typed uniforms + control descriptor.
+// The library's namesake: a mirrored polar fold over a drifting sine field, an
+// opaque BACKGROUND layer (issue #61). One kaleidoscope.frag fans out into the
+// book presets (stained-glass, mandala, prism) by varying these uniforms; the
+// segment count and palette are the big levers. Shader source is
+// shaders/kaleidoscope.frag.
+
+import type { RGB } from '../../../src/lib/primitives.types';
+import type { UniformControl } from '../_shared/types';
+
+/** Typed uniforms for the `kaleidoscope` layer shader. */
+export type KaleidoscopeShaderUniforms = {
+  /** Base palette color; also the pole uCalm eases toward. */
+  readonly uColorA: RGB;
+  /** Second palette color. */
+  readonly uColorB: RGB;
+  /** Accent color layered over the A/B field. */
+  readonly uColorC: RGB;
+  /** Mirror segment count; 6 = bold facets, 12 = lace. */
+  readonly uSegments: number;
+  /** Source-field drift rate; 0 freezes the pattern. */
+  readonly uSpeed: number;
+  /** Whole-field rotation rate; sign sets direction. */
+  readonly uRotate: number;
+  /** Pattern scale; higher = more rings of detail. */
+  readonly uZoom: number;
+  /** Eases contrast at frame center (the face zone); 0 = off. */
+  readonly uCalm: number;
+};
+
+/** The `kaleidoscope` shader's tunables; defaults are the "stained glass" look. */
+export const KALEIDOSCOPE_CONTROLS: readonly UniformControl[] = [
+  { name: 'uColorA', kind: 'color', default: [0.07, 0.15, 0.36], doc: 'Base palette color.' },
+  { name: 'uColorB', kind: 'color', default: [0.1, 0.55, 0.62], doc: 'Second palette color.' },
+  { name: 'uColorC', kind: 'color', default: [0.93, 0.69, 0.21], doc: 'Accent color.' },
+  {
+    name: 'uSegments',
+    kind: 'float',
+    default: 8,
+    min: 3,
+    max: 16,
+    step: 1,
+    doc: 'Mirror segment count; 6 = bold facets, 12 = lace.',
+  },
+  {
+    name: 'uSpeed',
+    kind: 'float',
+    default: 0.35,
+    min: 0,
+    max: 2,
+    step: 0.01,
+    doc: 'Drift rate; 0 freezes.',
+  },
+  {
+    name: 'uRotate',
+    kind: 'float',
+    default: 0.04,
+    min: -0.5,
+    max: 0.5,
+    step: 0.005,
+    doc: 'Whole-field rotation rate; sign sets direction.',
+  },
+  {
+    name: 'uZoom',
+    kind: 'float',
+    default: 1.6,
+    min: 0.5,
+    max: 4,
+    step: 0.05,
+    doc: 'Pattern scale; higher = more rings of detail.',
+  },
+  {
+    name: 'uCalm',
+    kind: 'float',
+    default: 0,
+    min: 0,
+    max: 1,
+    step: 0.01,
+    doc: 'Eases contrast at frame center (face zone).',
+  },
+];

package/catalog/shaders/neo-memphis/neo-memphis.form.tsx

@@ -0,0 +1,35 @@
+// Neo-Memphis's editor form: the shader OWNS its control layout (the plasma
+// pattern). One <Control uniform="…"/> per uniform in declared order.
+// Conventional layer id: "neo-memphis".
+
+import {
+  Control,
+  ControlForm,
+  ControlSection,
+  type KaleidoscopeControls,
+} from '../../../src/components/preset-control-panel';
+import { NEO_MEMPHIS_CONTROLS } from './neo-memphis';
+
+export function NeoMemphisForm({ uniforms, onPatch, disabled }: KaleidoscopeControls) {
+  return (
+    <ControlForm
+      id="neo-memphis"
+      uniforms={uniforms['neo-memphis'] ?? {}}
+      onPatch={onPatch}
+      disabled={disabled}
+      controls={NEO_MEMPHIS_CONTROLS}
+    >
+      <ControlSection title="neo-memphis">
+        <Control uniform="uBgColor" />
+        <Control uniform="uColorA" />
+        <Control uniform="uColorB" />
+        <Control uniform="uColorC" />
+        <Control uniform="uScale" />
+        <Control uniform="uDensity" />
+        <Control uniform="uOutline" />
+        <Control uniform="uDrift" />
+        <Control uniform="uCalm" />
+      </ControlSection>
+    </ControlForm>
+  );
+}

package/catalog/shaders/neo-memphis/neo-memphis.frag

@@ -0,0 +1,152 @@
+// Neo-Memphis: scattered flat-color geometric primitives (discs, rings,
+// triangles, crosses, boxes, squiggles) drifting on a quiet field; the 90s
+// Memphis-design / "Jazz cup" pattern family as an opaque BACKGROUND layer
+// (issue #61). Two parallax cell layers: hero shapes plus a smaller, dimmer
+// backfill texture.
+//
+// Overdrive surface: the four palette colors re-skin it completely (pastel
+// studio / bold primary / duotone), uDensity and uScale set busy-ness,
+// uOutline trades filled shapes for outlined ones, uDrift sets the energy.
+// uCalm fades shapes out near frame center, where the masked subject's face
+// sits.
+//
+// Cost: per pixel, two cell layers each evaluate ONE hash and at most one
+// shape SDF in the HOME cell only; shape extent (size + bob) stays below the
+// half-cell bound, so there is no 3x3 neighbor sweep (contrast nebula's
+// Star). No noise, no pow; one sin per squiggle cell.
+//
+// UV convention: matches passthrough.vert. vUv = (0, 0) at bottom-left,
+// (1, 1) at top-right. fragCoord is reconstructed as vUv * uResolution; no
+// gl_FragCoord. Fully procedural: no input texture, zero net texture flips on
+// every runtime.
+//
+// Precision: highp float. The hash uses large multipliers (fract-of-product
+// tricks); mediump collapses them to banding, same reasoning as nebula.
+
+#version 300 es
+precision highp float;
+
+uniform float uTime;       // seconds, monotonically increasing; range [0, inf)
+uniform vec2 uResolution;  // framebuffer size in pixels; both components > 0
+uniform vec3 uBgColor;     // field color behind the shapes
+uniform vec3 uColorA;      // shape palette color 1
+uniform vec3 uColorB;      // shape palette color 2
+uniform vec3 uColorC;      // shape palette color 3
+uniform float uScale;      // hero-grid cells across frame height
+uniform float uDensity;    // probability a cell draws its shape, 0..1
+uniform float uOutline;    // probability a shape renders outlined, 0..1
+uniform float uDrift;      // scroll + rotation rate; 0 freezes
+uniform float uCalm;       // 0..1 fades shapes near frame center (face zone)
+
+in highp vec2 vUv;
+out vec4 oColor;
+
+const float TAU = 6.28318530718;
+// Antialias half-width in cell units; ~1px at the default pitch.
+const float AA = 0.012;
+
+float hash21(vec2 p) {
+  p = fract(p * vec2(234.34, 435.345));
+  p += dot(p, p + 34.23);
+  return fract(p.x * p.y);
+}
+
+float sdBox(vec2 p, vec2 b) {
+  vec2 d = abs(p) - b;
+  return length(max(d, vec2(0.0))) + min(max(d.x, d.y), 0.0);
+}
+
+// iq's equilateral triangle, point up, circumradius r.
+float sdTriangle(vec2 p, float r) {
+  const float k = 1.7320508;
+  p.x = abs(p.x) - r;
+  p.y = p.y + r / k;
+  if (p.x + k * p.y > 0.0) {
+    p = vec2(p.x - k * p.y, -k * p.x - p.y) * 0.5;
+  }
+  p.x -= clamp(p.x, -2.0 * r, 0.0);
+  return -length(p) * sign(p.y);
+}
+
+// One cell layer: returns the shape coverage and writes its color.
+// luv is the layer's scrolled cell-space coordinate; backfill restricts the
+// shape menu to dots and crosses and draws smaller.
+float memphisCell(vec2 luv, float seed, float backfill, float t, out vec3 shapeColor) {
+  vec2 id = floor(luv);
+  vec2 gv = fract(luv) - 0.5;
+  float h = hash21(id + seed);
+  shapeColor = uBgColor;
+  // Density gate: empty cells cost one hash.
+  if (h > uDensity) return 0.0;
+
+  float h2 = fract(h * 57.31);
+  float h3 = fract(h * 113.77);
+  float h4 = fract(h * 431.13);
+  float h5 = fract(h * 891.71);
+
+  // Per-cell slow spin and a small bob; both bounded so the shape stays
+  // inside its cell (max extent 0.34 + 0.04 < 0.5).
+  float ang = h2 * TAU + t * (h3 - 0.5) * 0.8;
+  float cs = cos(ang);
+  float sn = sin(ang);
+  gv -= 0.04 * vec2(sin(t * 0.6 + h * TAU), cos(t * 0.8 + h * TAU));
+  gv = mat2(cs, -sn, sn, cs) * gv;
+
+  float r = mix(0.14, 0.30, h3) * mix(1.0, 0.6, backfill);
+  float pick = h4 * 6.0;
+  float d;
+  if (backfill > 0.5) {
+    // Backfill texture: dots and crosses only.
+    d = (pick < 3.0)
+        ? length(gv) - r * 0.45
+        : min(sdBox(gv, vec2(r, r * 0.22)), sdBox(gv, vec2(r * 0.22, r)));
+  } else if (pick < 1.0) {
+    d = length(gv) - r;                                   // disc
+  } else if (pick < 2.0) {
+    d = abs(length(gv) - r * 0.8) - r * 0.18;             // ring
+  } else if (pick < 3.0) {
+    d = sdTriangle(gv, r);                                // triangle
+  } else if (pick < 4.0) {
+    d = min(sdBox(gv, vec2(r, r * 0.24)), sdBox(gv, vec2(r * 0.24, r))); // cross
+  } else if (pick < 5.0) {
+    d = sdBox(gv, vec2(r * 0.78, r * 0.78));              // box
+  } else {
+    // Squiggle: a sine-displaced band, clipped to its run length.
+    d = max(abs(gv.y - 0.4 * r * sin(gv.x / r * 6.5)) - r * 0.17, abs(gv.x) - r);
+  }
+
+  float fill = smoothstep(AA, -AA, d);
+  float ring = smoothstep(AA, -AA, abs(d + r * 0.06) - r * 0.09);
+  float m = (h5 < uOutline) ? ring : fill;
+
+  float colorPick = fract(h * 769.23) * 3.0;
+  shapeColor = (colorPick < 1.0) ? uColorA : (colorPick < 2.0) ? uColorB : uColorC;
+  return m;
+}
+
+void main() {
+  // Aspect-correct, screen-centered coordinates (matches plasma/nebula).
+  vec2 fragCoord = vUv * uResolution;
+  vec2 uv = (fragCoord - 0.5 * uResolution) / uResolution.y;
+  float centerDist = length(uv);
+
+  float t = uTime * uDrift;
+  vec3 color = uBgColor;
+  vec3 shapeColor;
+
+  // Backfill layer first (under the hero shapes): smaller, denser, dimmer.
+  vec2 luv1 = uv * uScale * 2.3 + vec2(t * 0.045, t * -0.03) + 51.7;
+  float m1 = memphisCell(luv1, 7.0, 1.0, t, shapeColor);
+  color = mix(color, mix(uBgColor, shapeColor, 0.55), m1);
+
+  // Hero layer: the big shapes, scrolling the other way.
+  vec2 luv0 = uv * uScale + vec2(t * -0.06, t * 0.04);
+  float m0 = memphisCell(luv0, 0.0, 0.0, t, shapeColor);
+
+  // uCalm: fade shapes (not the field) near frame center.
+  float calm = 1.0 - uCalm * (1.0 - smoothstep(0.15, 0.62, centerDist));
+  color = mix(color, shapeColor, m0 * calm);
+
+  // Opaque procedural background; the person is composited over it downstream.
+  oColor = vec4(color, 1.0);
+}