react-native-webrtc-kaleidoscope 2.0.0 → 2.1.0

package/catalog/shaders/nebula/nebula.frag

@@ -0,0 +1,151 @@
+// SIMIANCRAFT Deadlights V2 "Deadlights nebula"
+// Procedural full-screen backdrop animation for https://simiancraft.com/
+// Jesse Harlin, 2020. MIT license.
+// Ported from a ShaderToy prototype (mainImage/iTime/iResolution) to this
+// repo's GLSL ES 3.00 multi-runtime convention. Tuned high: speed/glow
+// cranked relative to V1.
+//
+// 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). This is a fully procedural
+// background: no input texture, so there is no texture-origin handoff to
+// flip; the only orientation that matters is vUv, which the vertex shader
+// already pins. Net texture flips: zero on every runtime.
+//
+// Precision: highp float is REQUIRED, not mediump. The PseudoRandomizer
+// hash and the fract() size/color tricks use large multipliers (123.45,
+// 345.67, 1356.33, 2150.0, 3000.0, 3430.0). At mediump (10-bit mantissa on
+// mobile GPUs) fract() of those products collapses to banded garbage,
+// destroying the star distribution. Same reasoning composite-blur.frag gives
+// for keeping vUv highp, applied to the whole hash chain here.
+
+#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 uColor;          // overall tint / color grade; [1,1,1] = untinted
+uniform float uBrightness;    // final glow multiplier; 1.0 = stock
+uniform float uSpeed;         // drift + rotation rate; 1.0 = stock, 0 freezes
+uniform float uTwinkleSpeed;  // star color-cycle rate; 1.0 = stock
+uniform float uScale;         // starfield zoom / density; >1 = more, smaller stars
+uniform float uStarGlow;      // star-core size; 1.0 = stock
+
+in highp vec2 vUv;
+out vec4 oColor;
+
+const float PI = 3.14159265;
+const float MIN_DIVIDE = 64.0;
+const float MAX_DIVIDE = 0.01;
+// Number of stacked starfield layers. Compile-time constant so the layer
+// loop has a fixed integer bound (cross-compile-safe; no float loop counter).
+const int STARFIELD_LAYERS_COUNT = 12;
+
+mat2 Rotate(float angle) {
+  float s = sin(angle);
+  float c = cos(angle);
+  return mat2(c, -s, s, c);
+}
+
+float Star(vec2 uv, float flaresize, float rotAngle, float randomN) {
+  float d = length(uv);
+  // Star core. Guard the division: length(uv) can be exactly 0 at a cell
+  // center, which yields inf/NaN under Metal. max(d, 1e-4) caps the core
+  // brightness without visibly changing the look (the concentric
+  // smoothstep fade below already clamps it).
+  float starcore = 0.05 * uStarGlow / max(d, 1e-4);
+  uv *= Rotate(-2.0 * PI * rotAngle);
+  float flareMax = 1.0;
+
+  // flares
+  float starflares = max(0.0, flareMax - abs(uv.x * uv.y * 3000.0));
+  starcore += starflares * flaresize;
+  uv *= Rotate(PI * 0.25);
+  starflares = max(0.0, flareMax - abs(uv.x * uv.y * 3000.0));
+  starcore += starflares * 0.3 * flaresize;
+  // light can't go forever, fade it concentrically.
+  starcore *= smoothstep(1.0, 0.05, d);
+  return starcore;
+}
+
+float PseudoRandomizer(vec2 p) {
+  // not really random, but it looks random.
+  p = fract(p * vec2(123.45, 345.67));
+  p += dot(p, p + 45.32);
+  return fract(p.x * p.y);
+}
+
+vec3 StarFieldLayer(vec2 uv, float rotAngle) {
+  vec3 col = vec3(0.0);
+
+  vec2 gv = fract(uv) - 0.5;
+  vec2 id = floor(uv);
+
+  float deltaTimeTwinkle = uTime * 0.35 * uTwinkleSpeed;
+
+  // sweep the 8 neighbors plus the home cell so stars are not clipped at
+  // cell borders. Constant 3x3 bounds.
+  for (int y = -1; y <= 1; y++) {
+    for (int x = -1; x <= 1; x++) {
+      vec2 offset = vec2(float(x), float(y));
+
+      float randomN = PseudoRandomizer(id + offset); // 0..1
+      float randoX = randomN - 0.5;
+      float randoY = fract(randomN * 45.0) - 0.5;
+      vec2 randomPosition = gv - offset - vec2(randoX, randoY);
+      // fract trick: random sizes
+      float size = fract(randomN * 1356.33);
+      float flareSwitch = smoothstep(0.9, 1.0, size);
+      float star = Star(randomPosition, flareSwitch, rotAngle, randomN);
+
+      // fract trick: random colors
+      float randomStarColorSeed = fract(randomN * 2150.0) * (3.0 * PI) * deltaTimeTwinkle;
+      vec3 color = sin(vec3(0.7, 0.3, 0.9) * randomStarColorSeed);
+
+      // compress
+      color = color * (0.4 * sin(deltaTimeTwinkle)) + 0.6;
+      // filter
+      color = color * vec3(1.0, 0.1, 0.9 + size);
+      float dimByDensity = 15.0 / float(STARFIELD_LAYERS_COUNT);
+      col += star * size * color * dimByDensity;
+    }
+  }
+
+  return col;
+}
+
+void main() {
+  // ShaderToy fragCoord, reconstructed from vUv (see header).
+  vec2 fragCoord = vUv * uResolution;
+
+  // Normalized pixel coordinates centered at screen middle.
+  vec2 uv = (fragCoord - 0.5 * uResolution.xy) / uResolution.y;
+
+  float deltaTime = uTime * 0.01 * uSpeed;
+
+  vec3 col = vec3(0.0);
+
+  float rotAngle = deltaTime * 0.09;
+
+  // Layer accumulation. Integer-counted loop replacing the original
+  // `for (float i = 0.0; i < 1.0; i += 1.0/COUNT)`. With n in [0, COUNT),
+  // i = n/COUNT reproduces the exact same {0, 1/N, 2/N, ...} sequence and
+  // the same iteration count, so visual output is unchanged; only the loop
+  // form is cross-compile-safe.
+  for (int n = 0; n < STARFIELD_LAYERS_COUNT; n++) {
+    float i = float(n) / float(STARFIELD_LAYERS_COUNT);
+    float layerDepth = fract(i + deltaTime);
+    float layerScale = mix(MIN_DIVIDE, MAX_DIVIDE, layerDepth);
+    float layerFader = layerDepth * smoothstep(0.1, 1.1, layerDepth);
+    float layerOffset = i * (3430.0 + fract(i));
+    mat2 layerRot = Rotate(rotAngle * i * -10.0);
+    uv *= layerRot;
+    vec2 starfieldUv = uv * layerScale * uScale + layerOffset;
+    col += StarFieldLayer(starfieldUv, rotAngle) * layerFader;
+  }
+
+  // Glow + color grade, then opaque procedural background.
+  col *= uBrightness * uColor;
+  oColor = vec4(col, 1.0);
+}

package/catalog/shaders/nebula/nebula.ts

@@ -0,0 +1,74 @@
+// Nebula layer-shader interface: typed uniforms + control descriptor. A deep-
+// space starfield BACKGROUND layer (opaque), uniform-ized from the fixed
+// Deadlights V2 backdrop so a composite can color-grade and pace it (the nebula
+// composite runs it full-frame behind the masked subject). Shader source is
+// ./nebula.frag.
+
+import type { RGB } from '../../../src/lib/primitives.types';
+import type { UniformControl } from '../_shared/types';
+
+/** Typed uniforms for the `nebula` layer shader. */
+export type NebulaUniforms = {
+  /** Overall tint / color grade; [1,1,1] keeps the stock star colors. */
+  readonly uColor: RGB;
+  /** Final glow multiplier; 1 = stock, higher = brighter field. */
+  readonly uBrightness: number;
+  /** Drift + rotation rate; 1 = stock, 0 freezes the field. */
+  readonly uSpeed: number;
+  /** Star color-cycle (twinkle) rate; 1 = stock. */
+  readonly uTwinkleSpeed: number;
+  /** Starfield zoom / density; >1 = more, smaller stars. */
+  readonly uScale: number;
+  /** Star-core size; 1 = stock, higher = fatter cores. */
+  readonly uStarGlow: number;
+};
+
+/** The `nebula` shader's tunable uniforms; defaults reproduce the stock look. */
+export const NEBULA_CONTROLS: readonly UniformControl[] = [
+  { name: 'uColor', kind: 'color', default: [1, 1, 1], doc: 'Overall tint / color grade.' },
+  {
+    name: 'uBrightness',
+    kind: 'float',
+    default: 1,
+    min: 0,
+    max: 3,
+    step: 0.01,
+    doc: 'Final glow multiplier.',
+  },
+  {
+    name: 'uSpeed',
+    kind: 'float',
+    default: 1,
+    min: 0,
+    max: 3,
+    step: 0.01,
+    doc: 'Drift + rotation rate; 0 freezes.',
+  },
+  {
+    name: 'uTwinkleSpeed',
+    kind: 'float',
+    default: 1,
+    min: 0,
+    max: 3,
+    step: 0.01,
+    doc: 'Star twinkle rate.',
+  },
+  {
+    name: 'uScale',
+    kind: 'float',
+    default: 1,
+    min: 0.3,
+    max: 3,
+    step: 0.01,
+    doc: 'Zoom / density; >1 = more, smaller stars.',
+  },
+  {
+    name: 'uStarGlow',
+    kind: 'float',
+    default: 1,
+    min: 0.2,
+    max: 3,
+    step: 0.01,
+    doc: 'Star-core size.',
+  },
+];

package/catalog/shaders/plasma/plasma.form.tsx

@@ -0,0 +1,32 @@
+// Plasma's editor form: the shader OWNS its control layout. This pass just stacks
+// one <Control uniform="…"/> per uniform in declared order (the auto-form's shape);
+// the point is that this file exists per shader, so layout/grouping is a local edit
+// here, and a new primitive flows in through <Control> without touching it.
+// Conventional layer id: "plasma".
+
+import {
+  Control,
+  ControlForm,
+  ControlSection,
+  type KaleidoscopeControls,
+} from '../../../src/components/preset-control-panel';
+import { PLASMA_CONTROLS } from './plasma';
+
+export function PlasmaForm({ uniforms, onPatch, disabled }: KaleidoscopeControls) {
+  return (
+    <ControlForm
+      id="plasma"
+      uniforms={uniforms.plasma ?? {}}
+      onPatch={onPatch}
+      disabled={disabled}
+      controls={PLASMA_CONTROLS}
+    >
+      <ControlSection title="plasma">
+        <Control uniform="uColorA" />
+        <Control uniform="uColorB" />
+        <Control uniform="uSpeed" />
+        <Control uniform="uScale" />
+      </ControlSection>
+    </ControlForm>
+  );
+}

package/catalog/shaders/plasma/plasma.frag

@@ -0,0 +1,55 @@
+// Plasma: a two-color time-morphing procedural background.
+//
+// The specimen for the generic procedural-shader processor (issue #25/#26).
+// Deliberately the cheapest engine still worth shipping: a small sum of sines
+// of position and time, mapped between two palette colors. No loops, no noise,
+// no hashing, so it stays comfortably within the per-frame budget the shader-
+// authoring guide sets. One plasma.frag fans out into many named presets
+// (ocean, sunset, mint, and fast) by varying its uniforms.
+//
+// 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.
+//
+// Precision: highp float. The plasma value is a bounded sum of sines (range
+// well within mediump), but vUv is highp by the passthrough.vert contract and
+// the aspect-correct division below keeps the field stable at high resolution;
+// highp matches the other procedural shaders and avoids banding on mobile.
+
+#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;      // first palette color, linear-ish RGB in [0, 1]
+uniform vec3 uColorB;      // second palette color, linear-ish RGB in [0, 1]
+uniform float uSpeed;      // animation rate multiplier; 0 freezes the field
+uniform float uScale;      // spatial frequency; higher = more, tighter cells
+
+in highp vec2 vUv;
+out vec4 oColor;
+
+void main() {
+  // Aspect-correct, screen-centered coordinates (matches nebula.frag): divide
+  // by the height so uScale reads the same regardless of aspect ratio.
+  vec2 fragCoord = vUv * uResolution;
+  vec2 uv = (fragCoord - 0.5 * uResolution) / uResolution.y;
+
+  float t = uTime * uSpeed;
+
+  // Classic demoscene plasma: a few sines of position and time. The radial
+  // term (length(uv)) gives the field an organic, non-grid-aligned drift.
+  float v = sin(uv.x * uScale + t);
+  v += sin(uv.y * uScale + t * 0.8);
+  v += sin((uv.x + uv.y) * uScale * 0.7 + t * 1.3);
+  v += sin(length(uv) * uScale * 1.2 - t);
+
+  // v ranges roughly [-4, 4]; fold through sin to a smooth [0, 1] mix factor.
+  float mixT = 0.5 + 0.5 * sin(v);
+
+  // Opaque procedural background; the person is composited over it downstream.
+  oColor = vec4(mix(uColorA, uColorB, mixT), 1.0);
+}

package/catalog/shaders/plasma/plasma.ts

@@ -0,0 +1,44 @@
+// Plasma layer-shader interface: typed uniforms + control descriptor. A two-
+// color time-morphing field, an opaque BACKGROUND layer (the cheapest
+// procedural engine worth shipping). The same shader also backs the standalone
+// `plasma` book presets (ocean/sunset/mint/fast) via ShaderOptionsMap; this file
+// is the layer-side type + control surface. Shader source is shaders/plasma.frag.
+
+import type { RGB } from '../../../src/lib/primitives.types';
+import type { UniformControl } from '../_shared/types';
+
+/** Typed uniforms for the `plasma` layer shader. */
+export type PlasmaUniforms = {
+  /** First palette color, RGB each channel 0..1. */
+  readonly uColorA: RGB;
+  /** Second palette color, RGB each channel 0..1. */
+  readonly uColorB: RGB;
+  /** Animation rate; 0 freezes the field. */
+  readonly uSpeed: number;
+  /** Spatial frequency; higher = more, tighter cells. */
+  readonly uScale: number;
+};
+
+/** The `plasma` shader's tunable uniforms; defaults are the cool "ocean" look. */
+export const PLASMA_CONTROLS: readonly UniformControl[] = [
+  { name: 'uColorA', kind: 'color', default: [0.0, 0.3, 0.6], doc: 'First palette color.' },
+  { name: 'uColorB', kind: 'color', default: [0.0, 0.6, 0.6], doc: 'Second palette color.' },
+  {
+    name: 'uSpeed',
+    kind: 'float',
+    default: 0.3,
+    min: 0,
+    max: 2,
+    step: 0.01,
+    doc: 'Animation rate; 0 freezes.',
+  },
+  {
+    name: 'uScale',
+    kind: 'float',
+    default: 8,
+    min: 1,
+    max: 20,
+    step: 0.5,
+    doc: 'Spatial frequency; higher = tighter cells.',
+  },
+];

package/catalog/shaders/simianlights/simianlights.form.tsx

@@ -0,0 +1,34 @@
+// Simianlights' editor form: the shader OWNS its control layout. This pass just
+// stacks one <Control uniform="…"/> per uniform in declared order (the auto-form's
+// shape); the point is that this file exists per shader, so layout/grouping is a
+// local edit here, and a new primitive flows in through <Control> without touching
+// it. Conventional layer id: "field".
+
+import {
+  Control,
+  ControlForm,
+  ControlSection,
+  type KaleidoscopeControls,
+} from '../../../src/components/preset-control-panel';
+import { SIMIANLIGHTS_CONTROLS } from './simianlights';
+
+export function SimianlightsForm({ uniforms, onPatch, disabled }: KaleidoscopeControls) {
+  return (
+    <ControlForm
+      id="field"
+      uniforms={uniforms.field ?? {}}
+      onPatch={onPatch}
+      disabled={disabled}
+      controls={SIMIANLIGHTS_CONTROLS}
+    >
+      <ControlSection title="simianlights">
+        <Control uniform="uColor" />
+        <Control uniform="uBrightness" />
+        <Control uniform="uSpeed" />
+        <Control uniform="uTwinkleSpeed" />
+        <Control uniform="uScale" />
+        <Control uniform="uStarGlow" />
+      </ControlSection>
+    </ControlForm>
+  );
+}

package/catalog/shaders/simianlights/simianlights.frag

@@ -0,0 +1,151 @@
+// SIMIANCRAFT Simianlights
+// Procedural full-screen backdrop animation for https://simiancraft.com/
+// Jesse Harlin, 2020. MIT license.
+// Ported from a ShaderToy prototype (mainImage/iTime/iResolution) to this
+// repo's GLSL ES 3.00 multi-runtime convention. Calmer sibling of the
+// Deadlights nebula: fewer layers, larger near-field scale.
+//
+// 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). This is a fully procedural
+// background: no input texture, so there is no texture-origin handoff to
+// flip; the only orientation that matters is vUv, which the vertex shader
+// already pins. Net texture flips: zero on every runtime.
+//
+// Precision: highp float is REQUIRED, not mediump. The PseudoRandomizer
+// hash and the fract() size/color tricks use large multipliers (123.45,
+// 345.67, 1356.33, 2150.0, 3000.0, 3430.0). At mediump (10-bit mantissa on
+// mobile GPUs) fract() of those products collapses to banded garbage,
+// destroying the star distribution. Same reasoning composite-blur.frag gives
+// for keeping vUv highp, applied to the whole hash chain here.
+
+#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 uColor;          // overall tint / color grade; [1,1,1] = untinted
+uniform float uBrightness;    // final glow multiplier; 1.0 = stock
+uniform float uSpeed;         // drift + rotation rate; 1.0 = stock, 0 freezes
+uniform float uTwinkleSpeed;  // star color-cycle rate; 1.0 = stock
+uniform float uScale;         // starfield zoom / density; >1 = more, smaller stars
+uniform float uStarGlow;      // star-core size; 1.0 = stock
+
+in highp vec2 vUv;
+out vec4 oColor;
+
+const float PI = 3.14159265;
+const float MIN_DIVIDE = 3.0;
+const float MAX_DIVIDE = 0.01;
+// Number of stacked starfield layers. Compile-time constant so the layer
+// loop has a fixed integer bound (cross-compile-safe; no float loop counter).
+const int STARFIELD_LAYERS_COUNT = 4;
+
+mat2 Rotate(float angle) {
+  float s = sin(angle);
+  float c = cos(angle);
+  return mat2(c, -s, s, c);
+}
+
+float Star(vec2 uv, float flaresize, float rotAngle, float randomN) {
+  float d = length(uv);
+  // Star core. Guard the division: length(uv) can be exactly 0 at a cell
+  // center, which yields inf/NaN under Metal. max(d, 1e-4) caps the core
+  // brightness without visibly changing the look (the concentric
+  // smoothstep fade below already clamps it).
+  float starcore = 0.09 * uStarGlow / max(d, 1e-4);
+  uv *= Rotate(-2.0 * PI * rotAngle);
+  float flareMax = 1.0;
+
+  // flares
+  float starflares = max(0.0, flareMax - abs(uv.x * uv.y * 3000.0));
+  starcore += starflares * flaresize;
+  uv *= Rotate(PI * 0.25);
+  starflares = max(0.0, flareMax - abs(uv.x * uv.y * 3000.0));
+  starcore += starflares * 0.3 * flaresize;
+  // light can't go forever, fade it concentrically.
+  starcore *= smoothstep(1.0, 0.05, d);
+  return starcore;
+}
+
+float PseudoRandomizer(vec2 p) {
+  // not really random, but it looks random.
+  p = fract(p * vec2(123.45, 345.67));
+  p += dot(p, p + 45.32);
+  return fract(p.x * p.y);
+}
+
+vec3 StarFieldLayer(vec2 uv, float rotAngle) {
+  vec3 col = vec3(0.0);
+
+  vec2 gv = fract(uv) - 0.5;
+  vec2 id = floor(uv);
+
+  float deltaTimeTwinkle = uTime * 0.35 * uTwinkleSpeed;
+
+  // sweep the 8 neighbors plus the home cell so stars are not clipped at
+  // cell borders. Constant 3x3 bounds.
+  for (int y = -1; y <= 1; y++) {
+    for (int x = -1; x <= 1; x++) {
+      vec2 offset = vec2(float(x), float(y));
+
+      float randomN = PseudoRandomizer(id + offset); // 0..1
+      float randoX = randomN - 0.5;
+      float randoY = fract(randomN * 45.0) - 0.5;
+      vec2 randomPosition = gv - offset - vec2(randoX, randoY);
+      // fract trick: random sizes
+      float size = fract(randomN * 1356.33);
+      float flareSwitch = smoothstep(0.9, 1.0, size);
+      float star = Star(randomPosition, flareSwitch, rotAngle, randomN);
+
+      // fract trick: random colors
+      float randomStarColorSeed = fract(randomN * 2150.0) * (3.0 * PI) * deltaTimeTwinkle;
+      vec3 color = sin(vec3(0.7, 0.3, 0.9) * randomStarColorSeed);
+
+      // compress
+      color = color * (0.4 * sin(deltaTimeTwinkle)) + 0.6;
+      // filter
+      color = color * vec3(1.0, 0.1, 0.9 + size);
+      float dimByDensity = 15.0 / float(STARFIELD_LAYERS_COUNT);
+      col += star * size * color * dimByDensity;
+    }
+  }
+
+  return col;
+}
+
+void main() {
+  // ShaderToy fragCoord, reconstructed from vUv (see header).
+  vec2 fragCoord = vUv * uResolution;
+
+  // Normalized pixel coordinates centered at screen middle.
+  vec2 uv = (fragCoord - 0.5 * uResolution.xy) / uResolution.y;
+
+  float deltaTime = uTime * 0.01 * uSpeed;
+
+  vec3 col = vec3(0.0);
+
+  float rotAngle = deltaTime * 0.09;
+
+  // Layer accumulation. Integer-counted loop replacing the original
+  // `for (float i = 0.0; i < 1.0; i += 1.0/COUNT)`. With n in [0, COUNT),
+  // i = n/COUNT reproduces the exact same {0, 1/N, 2/N, ...} sequence and
+  // the same iteration count, so visual output is unchanged; only the loop
+  // form is cross-compile-safe.
+  for (int n = 0; n < STARFIELD_LAYERS_COUNT; n++) {
+    float i = float(n) / float(STARFIELD_LAYERS_COUNT);
+    float layerDepth = fract(i + deltaTime);
+    float layerScale = mix(MIN_DIVIDE, MAX_DIVIDE, layerDepth);
+    float layerFader = layerDepth * smoothstep(0.1, 1.1, layerDepth);
+    float layerOffset = i * (3430.0 + fract(i));
+    mat2 layerRot = Rotate(rotAngle * i * -10.0);
+    uv *= layerRot;
+    vec2 starfieldUv = uv * layerScale * uScale + layerOffset;
+    col += StarFieldLayer(starfieldUv, rotAngle) * layerFader;
+  }
+
+  // Glow + color grade, then opaque procedural background.
+  col *= uBrightness * uColor;
+  oColor = vec4(col, 1.0);
+}

package/catalog/shaders/simianlights/simianlights.ts

@@ -0,0 +1,73 @@
+// Simianlights layer-shader interface: typed uniforms + control descriptor. The
+// calmer sibling of the nebula (fewer starfield layers, larger near-field
+// scale), same opaque BACKGROUND-layer role and same uniform surface. Shader
+// source is ./simianlights.frag.
+
+import type { RGB } from '../../../src/lib/primitives.types';
+import type { UniformControl } from '../_shared/types';
+
+/** Typed uniforms for the `simianlights` layer shader. */
+export type SimianlightsUniforms = {
+  /** Overall tint / color grade; [1,1,1] keeps the stock star colors. */
+  readonly uColor: RGB;
+  /** Final glow multiplier; 1 = stock, higher = brighter field. */
+  readonly uBrightness: number;
+  /** Drift + rotation rate; 1 = stock, 0 freezes the field. */
+  readonly uSpeed: number;
+  /** Star color-cycle (twinkle) rate; 1 = stock. */
+  readonly uTwinkleSpeed: number;
+  /** Starfield zoom / density; >1 = more, smaller stars. */
+  readonly uScale: number;
+  /** Star-core size; 1 = stock, higher = fatter cores. */
+  readonly uStarGlow: number;
+};
+
+/** The `simianlights` shader's tunable uniforms; defaults reproduce the stock look. */
+export const SIMIANLIGHTS_CONTROLS: readonly UniformControl[] = [
+  { name: 'uColor', kind: 'color', default: [1, 1, 1], doc: 'Overall tint / color grade.' },
+  {
+    name: 'uBrightness',
+    kind: 'float',
+    default: 1,
+    min: 0,
+    max: 3,
+    step: 0.01,
+    doc: 'Final glow multiplier.',
+  },
+  {
+    name: 'uSpeed',
+    kind: 'float',
+    default: 1,
+    min: 0,
+    max: 3,
+    step: 0.01,
+    doc: 'Drift + rotation rate; 0 freezes.',
+  },
+  {
+    name: 'uTwinkleSpeed',
+    kind: 'float',
+    default: 1,
+    min: 0,
+    max: 3,
+    step: 0.01,
+    doc: 'Star twinkle rate.',
+  },
+  {
+    name: 'uScale',
+    kind: 'float',
+    default: 1,
+    min: 0.3,
+    max: 3,
+    step: 0.01,
+    doc: 'Zoom / density; >1 = more, smaller stars.',
+  },
+  {
+    name: 'uStarGlow',
+    kind: 'float',
+    default: 1,
+    min: 0.2,
+    max: 3,
+    step: 0.01,
+    doc: 'Star-core size.',
+  },
+];

package/dist/catalog/composites/clouds/clouds.controls.d.ts

@@ -0,0 +1,3 @@
+import { type KaleidoscopeControls } from '../../../src/components/preset-control-panel';
+export declare function CloudsControls({ uniforms, onPatch, disabled }: KaleidoscopeControls): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=clouds.controls.d.ts.map

package/dist/catalog/composites/clouds/clouds.controls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clouds.controls.d.ts","sourceRoot":"","sources":["../../../../catalog/composites/clouds/clouds.controls.tsx"],"names":[],"mappings":"AAEA,OAAO,EAIL,KAAK,oBAAoB,EAC1B,MAAM,8CAA8C,CAAC;AAGtD,wBAAgB,cAAc,CAAC,EAAE,QAAQ,EAAE,OAAO,EAAE,QAAQ,EAAE,EAAE,oBAAoB,2CAQnF","sourcesContent":["// Turnkey controls for the clouds composite (a single clouds `sky` layer).\n\nimport {\n  CompositeLayerControlPanel,\n  ControlForm,\n  ControlSection,\n  type KaleidoscopeControls,\n} from '../../../src/components/preset-control-panel';\nimport { CLOUDS_CONTROLS } from '../../shaders/clouds/clouds';\n\nexport function CloudsControls({ uniforms, onPatch, disabled }: KaleidoscopeControls) {\n  return (\n    <ControlForm id=\"sky\" uniforms={uniforms.sky ?? {}} onPatch={onPatch} disabled={disabled}>\n      <ControlSection title=\"sky\">\n        <CompositeLayerControlPanel controls={CLOUDS_CONTROLS} />\n      </ControlSection>\n    </ControlForm>\n  );\n}\n"]}

package/dist/catalog/composites/clouds/clouds.controls.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CloudsControls = CloudsControls;
+const jsx_runtime_1 = require("react/jsx-runtime");
+// Turnkey controls for the clouds composite (a single clouds `sky` layer).
+const preset_control_panel_1 = require("../../../src/components/preset-control-panel");
+const clouds_1 = require("../../shaders/clouds/clouds");
+function CloudsControls({ uniforms, onPatch, disabled }) {
+    return ((0, jsx_runtime_1.jsx)(preset_control_panel_1.ControlForm, { id: "sky", uniforms: uniforms.sky ?? {}, onPatch: onPatch, disabled: disabled, children: (0, jsx_runtime_1.jsx)(preset_control_panel_1.ControlSection, { title: "sky", children: (0, jsx_runtime_1.jsx)(preset_control_panel_1.CompositeLayerControlPanel, { controls: clouds_1.CLOUDS_CONTROLS }) }) }));
+}
+//# sourceMappingURL=clouds.controls.js.map

package/dist/catalog/composites/clouds/clouds.controls.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clouds.controls.js","sourceRoot":"","sources":["../../../../catalog/composites/clouds/clouds.controls.tsx"],"names":[],"mappings":";;;;AAAA,2EAA2E;AAE3E,uFAKsD;AACtD,wDAA8D;AAE9D,wBAA+B,EAAE,QAAQ,EAAE,OAAO,EAAE,QAAQ,EAAwB;IAClF,OAAO,CACL,uBAAC,kCAAW,IAAC,EAAE,EAAC,KAAK,EAAC,QAAQ,EAAE,QAAQ,CAAC,GAAG,IAAI,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,QAAQ,YACtF,uBAAC,qCAAc,IAAC,KAAK,EAAC,KAAK,YACzB,uBAAC,iDAA0B,IAAC,QAAQ,EAAE,wBAAe,GAAI,GAC1C,GACL,CACf,CAAC;AACJ,CAAC","sourcesContent":["// Turnkey controls for the clouds composite (a single clouds `sky` layer).\n\nimport {\n  CompositeLayerControlPanel,\n  ControlForm,\n  ControlSection,\n  type KaleidoscopeControls,\n} from '../../../src/components/preset-control-panel';\nimport { CLOUDS_CONTROLS } from '../../shaders/clouds/clouds';\n\nexport function CloudsControls({ uniforms, onPatch, disabled }: KaleidoscopeControls) {\n  return (\n    <ControlForm id=\"sky\" uniforms={uniforms.sky ?? {}} onPatch={onPatch} disabled={disabled}>\n      <ControlSection title=\"sky\">\n        <CompositeLayerControlPanel controls={CLOUDS_CONTROLS} />\n      </ControlSection>\n    </ControlForm>\n  );\n}\n"]}

package/dist/catalog/composites/clouds/clouds.d.ts

@@ -0,0 +1,26 @@
+export declare const clouds: {
+    readonly name: 'Daytime';
+    readonly taxonomy: readonly ["Shaders", "Sky"];
+    readonly layers: readonly [{
+        readonly id: 'sky';
+        readonly shader: 'clouds';
+        readonly uniforms: {
+            readonly uSkyLowColor: readonly [0.09, 0.63, 0.95];
+            readonly uSkyHighColor: readonly [0.04, 0.03, 0.86];
+            readonly uCloudLightColor: readonly [1, 0.91, 0.77];
+            readonly uCloudDarkColor: readonly [0.3, 0.3, 0.5];
+            readonly uExposure: 1.18;
+            readonly uStepSize: 0.16;
+            readonly uCloudSpeed: 0.16;
+            readonly uCloudScale: 1.08;
+            readonly uDensity: 0.235;
+            readonly uCoverage: 0.42;
+            readonly uSoftness: 0.39;
+        };
+    }, {
+        readonly id: 'you';
+        readonly shader: 'direct';
+        readonly target: 'subject';
+    }];
+};
+//# sourceMappingURL=clouds.d.ts.map