react-native-webrtc-kaleidoscope 2.3.0 → 2.5.0

package/catalog/shaders/aurora-silk/aurora-silk.ts

@@ -0,0 +1,92 @@
+// Aurora-silk layer-shader interface: typed uniforms + control descriptor.
+// Noise-warped ribbon bands over a two-stop gradient (OS-swoosh through SaaS
+// gradient), an opaque BACKGROUND layer (issue #61). One aurora-silk.frag
+// fans out into the book presets (corporate-silk, dusk, polar) by varying
+// these uniforms; the palette and uStyle are the big levers. Shader source is
+// shaders/aurora-silk.frag.
+
+import type { RGB } from '../../../src/lib/primitives.types';
+import type { UniformControl } from '../_shared/types';
+
+/** Typed uniforms for the `aurora-silk` layer shader. */
+export type AuroraSilkUniforms = {
+  /** Gradient color at the flow's low side. */
+  readonly uColorLow: RGB;
+  /** Gradient color at the flow's high side. */
+  readonly uColorHigh: RGB;
+  /** Ribbon tint; back-of-stack ribbons shade toward uColorHigh. */
+  readonly uRibbonColor: RGB;
+  /** Visible ribbon count, 1..5. */
+  readonly uRibbons: number;
+  /** Ribbon edge softness; 0 = paper-cut crisp, 1 = fully diffuse. */
+  readonly uSoftness: number;
+  /** Flow direction in radians. */
+  readonly uAngle: number;
+  /** Drift rate; 0 freezes. */
+  readonly uSpeed: number;
+  /** Aesthetic morph: 0 flat paper-cut, 1 glowing silk. */
+  readonly uStyle: number;
+  /** Eases ribbons at frame center (the face zone); 0 = off. */
+  readonly uCalm: number;
+};
+
+/** The `aurora-silk` shader's tunables; defaults are the "corporate silk" look. */
+export const AURORA_SILK_CONTROLS: readonly UniformControl[] = [
+  { name: 'uColorLow', kind: 'color', default: [0.08, 0.11, 0.22], doc: 'Gradient low color.' },
+  { name: 'uColorHigh', kind: 'color', default: [0.16, 0.29, 0.48], doc: 'Gradient high color.' },
+  { name: 'uRibbonColor', kind: 'color', default: [0.36, 0.62, 0.85], doc: 'Ribbon tint.' },
+  {
+    name: 'uRibbons',
+    kind: 'float',
+    default: 4,
+    min: 1,
+    max: 5,
+    step: 1,
+    doc: 'Visible ribbon count.',
+  },
+  {
+    name: 'uSoftness',
+    kind: 'float',
+    default: 0.7,
+    min: 0,
+    max: 1,
+    step: 0.01,
+    doc: 'Ribbon edge softness; 0 = paper-cut.',
+  },
+  {
+    name: 'uAngle',
+    kind: 'float',
+    default: 0.5,
+    min: 0,
+    max: 6.28,
+    step: 0.01,
+    doc: 'Flow direction, radians.',
+  },
+  {
+    name: 'uSpeed',
+    kind: 'float',
+    default: 0.6,
+    min: 0,
+    max: 2,
+    step: 0.01,
+    doc: 'Drift rate; 0 freezes.',
+  },
+  {
+    name: 'uStyle',
+    kind: 'float',
+    default: 0.8,
+    min: 0,
+    max: 1,
+    step: 0.01,
+    doc: '0 flat paper-cut, 1 glowing silk.',
+  },
+  {
+    name: 'uCalm',
+    kind: 'float',
+    default: 0,
+    min: 0,
+    max: 1,
+    step: 0.01,
+    doc: 'Eases ribbons at frame center (face zone).',
+  },
+];

package/catalog/shaders/halftone-waves/halftone-waves.form.tsx

@@ -0,0 +1,35 @@
+// Halftone-waves' editor form: the shader OWNS its control layout (the plasma
+// pattern). One <Control uniform="…"/> per uniform in declared order.
+// Conventional layer id: "halftone-waves".
+
+import {
+  Control,
+  ControlForm,
+  ControlSection,
+  type KaleidoscopeControls,
+} from '../../../src/components/preset-control-panel';
+import { HALFTONE_WAVES_CONTROLS } from './halftone-waves';
+
+export function HalftoneWavesForm({ uniforms, onPatch, disabled }: KaleidoscopeControls) {
+  return (
+    <ControlForm
+      id="halftone-waves"
+      uniforms={uniforms['halftone-waves'] ?? {}}
+      onPatch={onPatch}
+      disabled={disabled}
+      controls={HALFTONE_WAVES_CONTROLS}
+    >
+      <ControlSection title="halftone-waves">
+        <Control uniform="uPaper" />
+        <Control uniform="uInk" />
+        <Control uniform="uPitch" />
+        <Control uniform="uDotSize" />
+        <Control uniform="uWaveAmp" />
+        <Control uniform="uSpeed" />
+        <Control uniform="uShape" />
+        <Control uniform="uAngle" />
+        <Control uniform="uCalm" />
+      </ControlSection>
+    </ControlForm>
+  );
+}

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>
+  );
+}