@3driseai/3drise-viewer 0.1.17 → 0.1.18

package/dist/components/particles/BrownianDustParticles.js

@@ -0,0 +1,757 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useLayoutEffect, useMemo, useRef } from 'react';
+import * as THREE from 'three';
+import { useFrame } from '@react-three/fiber';
+import { applyGenerativeAnimations } from '../../utils/handleGenerativeEffectsAnimations.js';
+import { createPointerUniforms, stepPointerField, usePointerField } from '../../utils/pointerField.js';
+import { createTrailUniforms, applyTrailConfig, createCpuTrail } from '../../utils/particleTrails.js';
+import { useObjectReady } from '../../hooks/useObjectReady.js';
+/**
+ * Sunbeam Dust — Dust drifting in window light: Langevin motion in Kolmogorov turbulence, mullion shadows, forward scattering, glints and bokeh; the cursor is a hand, a torch or a charged rod. Use for interiors and cinematic scenes.
+ */
+// Sunbeam Dust — dust drifting through sunlight that falls through a mullioned window.
+// Movement: Langevin dynamics per mote: exact Ornstein–Uhlenbeck relaxation toward the local air
+//           velocity (Stokes drag) + thermal kicks with sigma = sqrt(2 gamma kT) + gravity settling.
+//           The air is Kraichnan synthetic turbulence — divergence-free random Fourier modes with a
+//           Kolmogorov k^-5/3 spectrum — plus a warm updraft inside the beam.
+// Colour:   single scattering. Brightness = window footprint (mullion shadows with a penumbra that
+//           widens with distance, from the sun's 0.53 deg disc) x Henyey–Greenstein phase of the
+//           scattering angle. Tumbling flakes add specular glints when their normal bisects sun and
+//           eye. The shaft itself is a single-scattering raymarch through the room. A thin-lens camera model turns out-of-focus motes into bokeh discs (circle of
+//           confusion ~ aperture |d - focus| / d, energy conserved).
+// Mouse (pointerMode):
+//   hand   — a hand moving through the air: moving-sphere potential-flow dipole, a wake, vortex
+//            rings shed along fast strokes (Kelvin's self-propulsion speed) that decay; the hand
+//            also blocks the sun, so a soft shadow shaft runs down the beam behind it.
+//   torch  — a small lamp: inverse-square point light scattered by motes and by the haze
+//            (Henyey–Greenstein, raymarched halo), and a buoyant thermal plume rising from it.
+//   charge — a charged rod: induced-dipole attraction pulls dust in; motes that touch it pick up
+//            charge and are Coulomb-repelled, then discharge and fall back — a breathing corona
+//            that glows faintly where motes carry charge.
+// Trails (trailMode): streak = shutter-drag motion blur, comet = swirl threads, echo = afterglow.
+//           Every trail sample is lit by the same beam, shadow and torch as the motes.
+//
+// Generated from the approved lab module (particle lab, round 3). Sim units = object-local / size.
+/** mulberry32 — seeded PRNG, returns a function giving floats in [0,1). */
+function mulberry32(seed) {
+    let a = seed >>> 0;
+    return function () {
+        a = (a + 0x6d2b79f5) >>> 0;
+        let t = a;
+        t = Math.imul(t ^ (t >>> 15), t | 1);
+        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}
+/** Viewport-height hook so point sizes are pixel-correct at any canvas size. */
+function attachViewH(obj, u) {
+    const scratch = new THREE.Vector2();
+    obj.onBeforeRender = (renderer) => {
+        renderer.getDrawingBufferSize(scratch);
+        u.uViewH.value = scratch.y;
+    };
+}
+function colorUniform(hex) {
+    return { value: new THREE.Color(hex) };
+}
+const POINTER_MODES = ['hand', 'torch', 'charge'];
+const BX = 1, BY0 = 0.02, BY1 = 1.6, BZ = 1; // room box (sim units)
+const GAMMA = 2.5; // Stokes drag rate (1/s)
+const KT = 4e-4; // kT at temperature 1 (velocity variance)
+const H_MAX = 1 / 30;
+const BEAM_AZ = Math.atan2(0.8, 0.6); // sun from the back-left, shining toward +x/+z
+const BEAM_ORIGIN = [0, 0.8, 0];
+const WINDOW_ALONG = -1.0; // window plane, measured along the beam from BEAM_ORIGIN
+const N_MODES = 6; // Kraichnan modes
+const MAX_RINGS = 10;
+const HAND = 0.12; // hand radius at pointerRadius 1
+function createUniforms() {
+    return {
+        uTime: { value: 0 },
+        uSize: { value: 1 },
+        uViewH: { value: 800 },
+        uIntensity: { value: 1 },
+        uSpeed: { value: 1 },
+        uOpacity: { value: 0.9 },
+        uColor: colorUniform('#ffffff'),
+        uParticleCount: { value: 0 },
+        uTemperature: { value: 1 },
+        uTurbulence: { value: 1 },
+        uBeamAngle: { value: 38 },
+        uBeamWidth: { value: 0.32 },
+        uWindowPanes: { value: 3 },
+        uAnisotropy: { value: 0.7 },
+        uHazeDensity: { value: 1 },
+        uAperture: { value: 0.6 },
+        uAmbientColor: colorUniform('#ffffff'),
+        uPointerMode: { value: 0 },
+        uPointerStrength: { value: 1 },
+        uPointerRadius: { value: 1 },
+        uPointerColor: colorUniform('#ffffff'),
+        uFocus: { value: 2.5 },
+        uCamLocal: { value: new THREE.Vector3(0, 0.8, 3) },
+        ...createPointerUniforms(),
+        ...createTrailUniforms(),
+    };
+}
+function applyConfig(u, c, size) {
+    u.uSize.value = size;
+    u.uIntensity.value = c.intensity;
+    u.uSpeed.value = c.speed;
+    u.uOpacity.value = c.opacity;
+    u.uColor.value.set(c.color);
+    u.uParticleCount.value = c.particleCount;
+    u.uTemperature.value = c.temperature;
+    u.uTurbulence.value = c.turbulence;
+    u.uBeamAngle.value = c.beamAngle;
+    u.uBeamWidth.value = c.beamWidth;
+    u.uWindowPanes.value = c.windowPanes;
+    u.uAnisotropy.value = c.anisotropy;
+    u.uHazeDensity.value = c.hazeDensity;
+    u.uAperture.value = c.aperture;
+    u.uAmbientColor.value.set(c.ambientColor);
+    u.uPointerMode.value = POINTER_MODES.indexOf(c.pointerMode); // -1 = 'none' (off)
+    u.uPointerStrength.value = c.pointerStrength;
+    u.uPointerRadius.value = c.pointerRadius;
+    u.uPointerColor.value.set(c.pointerColor);
+    applyTrailConfig(u, c);
+}
+// Shared GLSL: beam geometry, window mask with penumbra, HG phase, hand shadow, bokeh size.
+const BASE_U = 'uniform float uSize, uViewH, uIntensity, uOpacity;';
+const BEAM_GLSL = /* glsl */ `
+uniform float uTime;
+uniform float uBeamAngle, uBeamWidth, uWindowPanes, uAnisotropy, uAperture, uFocus;
+uniform vec3 uColor, uAmbientColor;
+uniform vec3 uPointer, uPointerColor;
+uniform float uPointerActive, uPointerStrength, uPointerRadius, uPointerMode;
+const vec3 BEAM_O = vec3(${BEAM_ORIGIN.map((v) => v.toFixed(3)).join(', ')});
+vec3 beamDir() {
+  float el = radians(uBeamAngle);
+  return normalize(vec3(cos(el) * ${Math.cos(BEAM_AZ).toFixed(5)}, -sin(el), cos(el) * ${Math.sin(BEAM_AZ).toFixed(5)}));
+}
+void beamBasis(vec3 L, out vec3 b1, out vec3 b2) {
+  b1 = normalize(cross(L, vec3(0.0, 1.0, 0.0)));
+  b2 = cross(b1, L);
+}
+// Window footprint with mullions; penumbra = tan(0.53 deg / 2) * 2 * distance from the window.
+float windowMask(vec3 p, vec3 L) {
+  vec3 b1, b2; beamBasis(L, b1, b2);
+  vec3 d = p - BEAM_O;
+  float along = dot(d, L) - (${WINDOW_ALONG.toFixed(2)});
+  float pen = 0.01 + 0.0093 * max(along, 0.0);
+  float a = dot(d, b1), b = dot(d, b2);
+  float w = uBeamWidth, h = w * 1.4;
+  float m = (1.0 - smoothstep(w - pen, w + pen, abs(a))) * (1.0 - smoothstep(h - pen, h + pen, abs(b)));
+  float bar = 0.08 * w;
+  if (uWindowPanes > 1.5) {
+    float cw = 2.0 * w / uWindowPanes;
+    float fa = mod(a + w, cw);
+    float da = min(fa, cw - fa);
+    m *= smoothstep(bar - pen, bar + pen, da);
+    m *= smoothstep(bar - pen, bar + pen, abs(b - 0.3 * h));   // transom
+  }
+  return m;
+}
+float hg(float cosT, float g) {
+  float g2 = g * g;
+  float p = (1.0 - g2) / pow(max(1.0 + g2 - 2.0 * g * cosT, 1e-4), 1.5);
+  float p90 = (1.0 - g2) / pow(1.0 + g2, 1.5);
+  return p / p90;
+}
+// The hand (a sphere at the pointer) shades everything down-beam of it.
+float handShadow(vec3 p, vec3 L) {
+  float s = uPointerActive * step(0.001, uPointerStrength) * (1.0 - step(0.5, uPointerMode));
+  if (s < 0.001) return 1.0;
+  vec3 d = p - uPointer;
+  float along = dot(d, L);
+  if (along < 0.0) return 1.0;
+  float R = ${HAND.toFixed(3)} * uPointerRadius;
+  float perp = length(d - along * L);
+  float pen = 0.01 + 0.0093 * along;
+  float sh = smoothstep(R * 0.85 - pen, R + pen, perp);
+  return mix(1.0, sh, s);
+}
+// Torch: an inverse-square point light at the cursor (radiant intensity ~ strength),
+// returned as the in-scattered light toward the eye for a scatterer at p.
+vec3 torchLight(vec3 p, vec3 toEye, float g) {
+  if (uPointerMode < 0.5 || uPointerMode > 1.5) return vec3(0.0);
+  vec3 d = p - uPointer;
+  float r2 = dot(d, d);
+  float reach = 0.5 * uPointerRadius;
+  float I = uPointerStrength * uPointerActive * 0.02 / (r2 + 0.004) * exp(-r2 / (reach * reach));
+  return uPointerColor * I * hg(dot(normalize(d + 1e-5), toEye), g);
+}
+float boxFade(vec3 p) {
+  float fx = ${BX.toFixed(2)} - abs(p.x);
+  float fz = ${BZ.toFixed(2)} - abs(p.z);
+  float fy = min(p.y - ${BY0.toFixed(2)}, ${BY1.toFixed(2)} - p.y);
+  return smoothstep(0.0, 0.12, min(min(fx, fz), fy));
+}
+`;
+const moteVertex = /* glsl */ `
+${BASE_U}
+${BEAM_GLSL}
+attribute float aCharge; // 0..1 contact charge (charged-rod mode)
+attribute vec4 aSeed; // size seed, flake flag, tumble rate, phase
+attribute vec3 aAxis; // tumble axis
+varying vec3 vCol;
+varying float vA;
+varying float vBokeh;
+vec3 rotateAxis(vec3 v, vec3 k, float a) {
+  return v * cos(a) + cross(k, v) * sin(a) + k * dot(k, v) * (1.0 - cos(a));
+}
+void main() {
+  vec3 L = beamDir();
+  vec4 wp = modelMatrix * vec4(position * uSize, 1.0);
+  vec3 toCam = normalize(cameraPosition - wp.xyz);
+  vec3 Lw = normalize(mat3(modelMatrix) * L);
+  float lit = windowMask(position, L) * handShadow(position, L);
+  float g = uAnisotropy * (0.75 + 0.25 * aSeed.x);
+  float phase = hg(dot(Lw, toCam), g);
+  // tumbling flake: glint when its normal bisects the sun direction and the eye
+  float glint = 0.0;
+  if (aSeed.y > 0.5) {
+    vec3 n0 = normalize(aAxis.yzx * vec3(1.0, -1.0, 1.0) + vec3(0.01));
+    vec3 n = rotateAxis(n0, normalize(aAxis), aSeed.z * uTime + aSeed.w);
+    float c = abs(dot(n, normalize(-Lw + toCam)));
+    glint = pow(c, 90.0) * 9.0;
+  }
+  float big = pow(aSeed.x, 5.0);               // power-law size distribution
+  vec3 toCamL = normalize(transpose(mat3(modelMatrix)) * toCam);
+  vec3 torch = torchLight(position, toCamL, g);
+  float chg = aCharge * step(1.5, uPointerMode);
+  vec3 corona = uPointerColor * chg * 1.6;
+  vec3 col = uColor * lit * (phase * 0.6 + glint) + uAmbientColor * 0.06 + torch + corona;
+  float extra = dot(torch + corona, vec3(0.33));
+  float baseA = uOpacity * boxFade(position) * clamp(0.05 + 0.7 * lit * (phase + glint) + extra, 0.0, 4.0);
+  // thin lens: circle of confusion in pixels, energy spread over the disc
+  vec4 mv = viewMatrix * wp;
+  float dist = -mv.z;
+  float basePx = uSize * uViewH * 0.0055 * (0.6 + 2.2 * big) * (1.0 + 1.2 * chg) / dist;
+  float coc = uAperture * uViewH * 0.06 * abs(dist - uFocus) / max(dist, 0.05);
+  float px = sqrt(basePx * basePx + coc * coc);
+  float spread = clamp((basePx * basePx) / (px * px), 0.03, 1.0);
+  vBokeh = smoothstep(5.0, 16.0, coc);
+  vCol = col * uIntensity;
+  vA = baseA * mix(1.0, spread * 3.0, vBokeh);
+  gl_PointSize = clamp(px, 1.0, 96.0);
+  gl_Position = projectionMatrix * mv;
+}
+`;
+// Light shaft: single-scattering raymarch through the room box (the medium the motes live in).
+// Every sample is window mask x hand shadow x HG phase x a slowly drifting density, so mullion
+// and hand shadows are crisp and the shaft is smooth. Additive, alpha = added light only, so it
+// composites correctly on a transparent canvas.
+const volVertex = /* glsl */ `
+uniform float uSize;
+varying vec3 vLocal;
+void main() {
+  vLocal = position;
+  gl_Position = projectionMatrix * modelViewMatrix * vec4(position * uSize, 1.0);
+}
+`;
+const volFragment = /* glsl */ `
+${BASE_U}
+${BEAM_GLSL}
+uniform float uHazeDensity;
+uniform vec3 uCamLocal;
+varying vec3 vLocal;
+float hash13(vec3 p) { p = fract(p * 0.1031); p += dot(p, p.zyx + 31.32); return fract((p.x + p.y) * p.z); }
+float vnoise(vec3 p) {
+  vec3 i = floor(p), f = fract(p);
+  f = f * f * (3.0 - 2.0 * f);
+  return mix(mix(mix(hash13(i), hash13(i + vec3(1, 0, 0)), f.x), mix(hash13(i + vec3(0, 1, 0)), hash13(i + vec3(1, 1, 0)), f.x), f.y),
+             mix(mix(hash13(i + vec3(0, 0, 1)), hash13(i + vec3(1, 0, 1)), f.x), mix(hash13(i + vec3(0, 1, 1)), hash13(i + vec3(1, 1, 1)), f.x), f.y), f.z);
+}
+void main() {
+  vec3 ro = uCamLocal;
+  vec3 rd = normalize(vLocal - ro);
+  vec3 bmin = vec3(${(-BX).toFixed(2)}, ${BY0.toFixed(2)}, ${(-BZ).toFixed(2)});
+  vec3 bmax = vec3(${BX.toFixed(2)}, ${BY1.toFixed(2)}, ${BZ.toFixed(2)});
+  vec3 t0 = (bmin - ro) / rd, t1 = (bmax - ro) / rd;
+  vec3 tn3 = min(t0, t1), tf3 = max(t0, t1);
+  float tn = max(max(max(tn3.x, tn3.y), tn3.z), 0.0);
+  float tf = min(min(tf3.x, tf3.y), tf3.z);
+  if (tf <= tn) discard;
+  vec3 L = beamDir();
+  const int N = 44;
+  float dt = (tf - tn) / float(N);
+  // interleaved gradient noise: per-pixel start offset, stable over time (no flicker)
+  float jit = fract(52.9829189 * fract(dot(gl_FragCoord.xy, vec2(0.06711056, 0.00583715))));
+  float acc = 0.0;
+  vec3 tacc = vec3(0.0);
+  bool torchOn = uPointerMode > 0.5 && uPointerMode < 1.5 && uPointerActive > 0.001;
+  for (int i = 0; i < N; i++) {
+    vec3 p = ro + rd * (tn + (float(i) + jit) * dt);
+    float m = windowMask(p, L);
+    if (m < 0.001 && !torchOn) continue;
+    float dens = (0.75 + 0.5 * vnoise(p * 3.2 + vec3(0.0, -uTime * 0.04, uTime * 0.02))) * boxFade(p);
+    acc += m * handShadow(p, L) * dens;
+    if (torchOn) tacc += torchLight(p, -rd, uAnisotropy * 0.5) * dens;
+  }
+  float k = dt * uHazeDensity * uOpacity * uIntensity;
+  vec3 rgb = uColor * (acc * hg(dot(L, -rd), uAnisotropy * 0.6) * 0.22 * k) + tacc * k * 0.35;
+  float I = max(max(rgb.r, rgb.g), rgb.b);
+  if (I < 0.0005) discard;
+  I = min(I, 1.0);
+  // colour * alpha = added light; alpha carries only the light (correct on a transparent canvas)
+  gl_FragColor = vec4(rgb / max(max(max(rgb.r, rgb.g), rgb.b), 1e-4), I);
+}
+`;
+const fragment = /* glsl */ `
+varying vec3 vCol;
+varying float vA;
+varying float vBokeh;
+void main() {
+  vec2 d = gl_PointCoord * 2.0 - 1.0;
+  float r2 = dot(d, d);
+  if (r2 > 1.0) discard;
+  float spriteA = (exp(-r2 * 9.0) + 0.35 * exp(-r2 * 3.2)) * (1.0 - r2);
+  // bokeh: flat disc with a slightly brighter rim (spherical aberration), soft edge
+  float r = sqrt(r2);
+  float disc = (1.0 - smoothstep(0.82, 1.0, r)) * (0.7 + 0.3 * smoothstep(0.55, 0.92, r));
+  float a = mix(spriteA, disc * 0.5, vBokeh) * vA;
+  if (a < 0.002) discard;
+  gl_FragColor = vec4(vCol, a);
+}
+`;
+// The cursor made visible: nothing for the hand (its shadow is the tell), a lamp bulb with a soft
+// bloom for the torch, a bright tip with a corona for the charged rod.
+const glyphVertex = /* glsl */ `
+uniform float uSize, uViewH;
+uniform vec3 uPointer;
+uniform float uPointerMode, uPointerActive, uPointerStrength, uPointerRadius;
+varying float vMode;
+void main() {
+  vec4 mv = modelViewMatrix * vec4(uPointer * uSize, 1.0);
+  float on = uPointerActive * step(0.001, uPointerStrength) * step(0.5, uPointerMode);
+  gl_PointSize = clamp(uSize * uViewH * 0.16 * uPointerRadius / -mv.z, 0.0, 400.0) * step(0.02, on);
+  vMode = uPointerMode;
+  gl_Position = projectionMatrix * mv;
+}
+`;
+const glyphFragment = /* glsl */ `
+uniform vec3 uPointerColor;
+uniform float uPointerActive, uPointerStrength, uOpacity;
+varying float vMode;
+void main() {
+  vec2 d = gl_PointCoord * 2.0 - 1.0;
+  float r2 = dot(d, d);
+  if (r2 > 1.0) discard;
+  float a;
+  if (vMode < 1.5) a = exp(-r2 * 60.0) * 1.2 + exp(-r2 * 9.0) * 0.25;        // bulb + bloom
+  else a = exp(-r2 * 90.0) + 0.18 * exp(-pow((sqrt(r2) - 0.35) / 0.12, 2.0)); // tip + corona
+  a *= (1.0 - r2) * uPointerActive * min(uPointerStrength, 1.5) * uOpacity;
+  if (a < 0.003) discard;
+  gl_FragColor = vec4(mix(uPointerColor, vec3(1.0), 0.35 * exp(-r2 * 60.0)), a);
+}
+`;
+// CPU copy of the beam direction (for the updraft).
+function beamDirCPU(deg) {
+    const el = (deg * Math.PI) / 180;
+    return [Math.cos(el) * Math.cos(BEAM_AZ), -Math.sin(el), Math.cos(el) * Math.sin(BEAM_AZ)];
+}
+function build(u, c, size) {
+    const n = Math.max(1, Math.round(c.particleCount));
+    const rng = mulberry32(0xd057);
+    const pos = new Float32Array(n * 3);
+    const vel = new Float32Array(n * 3);
+    const seed = new Float32Array(n * 4);
+    const axis = new Float32Array(n * 3);
+    for (let i = 0; i < n; i++) {
+        pos[i * 3] = (rng() * 2 - 1) * BX;
+        pos[i * 3 + 1] = BY0 + rng() * (BY1 - BY0);
+        pos[i * 3 + 2] = (rng() * 2 - 1) * BZ;
+        seed[i * 4] = rng();
+        seed[i * 4 + 1] = rng() < 0.3 ? 1 : 0; // 30% are flat, glinting flakes
+        seed[i * 4 + 2] = 0.35 + rng() * 0.8; // tumble rate (rad/s)
+        seed[i * 4 + 3] = rng() * 6.2831853;
+        const ax = rng() * 2 - 1, ay = rng() * 2 - 1, az = rng() * 2 - 1, l = Math.hypot(ax, ay, az) || 1;
+        axis[i * 3] = ax / l;
+        axis[i * 3 + 1] = ay / l;
+        axis[i * 3 + 2] = az / l;
+    }
+    // ---- Kraichnan modes: k in [2.5, 10], energy ~ k^-5/3, sigma perpendicular to k ----
+    const mrng = mulberry32(0x7ab1);
+    const MK = new Float64Array(N_MODES * 3), MS = new Float64Array(N_MODES * 3), MW = new Float64Array(N_MODES * 2);
+    for (let m = 0; m < N_MODES; m++) {
+        const kmag = 2.5 * Math.pow(4, m / (N_MODES - 1));
+        let kx = mrng() * 2 - 1, ky = mrng() * 2 - 1, kz = mrng() * 2 - 1;
+        const kl = Math.hypot(kx, ky, kz) || 1;
+        kx /= kl;
+        ky /= kl;
+        kz /= kl;
+        let rx = mrng() * 2 - 1, ry = mrng() * 2 - 1, rz = mrng() * 2 - 1;
+        // sigma = normalize(r x k) is transverse -> each mode is divergence-free
+        let sx = ry * kz - rz * ky, sy = rz * kx - rx * kz, sz = rx * ky - ry * kx;
+        const sl = Math.hypot(sx, sy, sz) || 1;
+        const amp = Math.sqrt(Math.pow(kmag, -5 / 3) * kmag * 0.5); // sqrt(E(k) dk), log-spaced shells
+        MK[m * 3] = kx * kmag;
+        MK[m * 3 + 1] = ky * kmag;
+        MK[m * 3 + 2] = kz * kmag;
+        MS[m * 3] = (sx / sl) * amp;
+        MS[m * 3 + 1] = (sy / sl) * amp;
+        MS[m * 3 + 2] = (sz / sl) * amp;
+        MW[m * 2] = 0.12 * Math.sqrt(kmag) * (0.6 + 0.8 * mrng()); // eddy turnover ~ k^(2/3) (softened)
+        MW[m * 2 + 1] = mrng() * 6.2831853;
+    }
+    // ---- vortex rings shed by the hand ----
+    const RC_ = new Float64Array(MAX_RINGS * 3), RN = new Float64Array(MAX_RINGS * 3);
+    const RG = new Float64Array(MAX_RINGS), RR = new Float64Array(MAX_RINGS), RA = new Float64Array(MAX_RINGS);
+    let ringHead = 0, shedClock = 0;
+    const live = new Int32Array(MAX_RINGS);
+    const noise = mulberry32(0xb10e);
+    const r2n = () => noise() + noise() - 1; // triangular, variance 1/6 (scaled by sqrt 6 below)
+    let time = 0;
+    const hp = new THREE.Vector3(), hv = new THREE.Vector3();
+    const charge = new Float32Array(n); // contact charge per mote (charged-rod mode)
+    function step(h) {
+        time += h;
+        const T = KT * Math.max(u.uTemperature.value, 0);
+        const sig = Math.sqrt(2 * GAMMA * T * h) * 2.449;
+        const turb = 0.035 * u.uTurbulence.value;
+        const L = beamDirCPU(u.uBeamAngle.value);
+        const w = u.uBeamWidth.value;
+        let b1x = -L[2], b1z = L[0];
+        const bl = Math.hypot(b1x, b1z) || 1;
+        b1x /= bl;
+        b1z /= bl;
+        const decay = Math.exp(-GAMMA * h);
+        // hand
+        const S = u.uPointerStrength.value * u.uPointerActive.value;
+        const R = HAND * u.uPointerRadius.value;
+        hp.copy(u.uPointer.value);
+        hv.copy(u.uPointerVel.value);
+        const speed = hv.length();
+        const mode = u.uPointerMode.value;
+        const useHand = S > 0.01 && mode === 0;
+        const useTorch = S > 0.01 && mode === 1;
+        const useCharge = S > 0.01 && mode === 2;
+        // torch plume: buoyant column above the lamp, widening with height (sigma grows linearly,
+        // centreline speed falls as the plume spreads — momentum-conserving plume scaling)
+        const pr = 0.05 * u.uPointerRadius.value;
+        // charged rod: induced-dipole attraction ~ 1/r^3, Coulomb repulsion of charged motes ~ 1/r^2
+        const reach = 0.6 * u.uPointerRadius.value;
+        const KA = 0.012 * S * u.uPointerRadius.value, KR = 0.0045 * S, EPS = 0.03, RCON = 0.035 * u.uPointerRadius.value;
+        const dis = Math.exp(-h / 1.4);
+        // shed a ring every ~0.12 s of fast motion
+        shedClock += h;
+        if (useHand && speed > 0.3 && shedClock > 0.12) {
+            shedClock = 0;
+            const k = ringHead % MAX_RINGS;
+            ringHead++;
+            RC_[k * 3] = hp.x;
+            RC_[k * 3 + 1] = hp.y;
+            RC_[k * 3 + 2] = hp.z;
+            RN[k * 3] = hv.x / speed;
+            RN[k * 3 + 1] = hv.y / speed;
+            RN[k * 3 + 2] = hv.z / speed;
+            RG[k] = 1.1 * Math.min(speed, 4) * R * S;
+            RR[k] = R * 0.9;
+            RA[k] = 0;
+        }
+        // rings: self-propulsion (Kelvin: U = G / (4 pi a) (ln(8a/core) - 1/4)), growth, decay
+        for (let k = 0; k < MAX_RINGS; k++) {
+            if (RG[k] === 0)
+                continue;
+            RA[k] += h;
+            RG[k] *= Math.exp(-h / 2.2);
+            RR[k] *= 1 + 0.08 * h;
+            const core = 0.3 * RR[k];
+            const U = (RG[k] / (4 * Math.PI * RR[k])) * (Math.log(8 / 0.3) - 0.25);
+            RC_[k * 3] += RN[k * 3] * U * h;
+            RC_[k * 3 + 1] += RN[k * 3 + 1] * U * h;
+            RC_[k * 3 + 2] += RN[k * 3 + 2] * U * h;
+            if (RA[k] > 5 || RG[k] < 1e-4 || core <= 0)
+                RG[k] = 0;
+        }
+        const vn = speed > 1e-4 ? 1 / speed : 0;
+        // compact the live rings so empty slots cost nothing per mote
+        let nr = 0;
+        for (let k = 0; k < MAX_RINGS; k++)
+            if (RG[k] !== 0)
+                live[nr++] = k;
+        for (let i = 0, j = 0; i < n; i++, j += 3) {
+            const x = pos[j], y = pos[j + 1], z = pos[j + 2];
+            // Kraichnan turbulence
+            let ax = 0, ay = 0, az = 0;
+            for (let m = 0; m < N_MODES; m++) {
+                const cph = Math.cos(MK[m * 3] * x + MK[m * 3 + 1] * y + MK[m * 3 + 2] * z + MW[m * 2] * time + MW[m * 2 + 1]);
+                ax += MS[m * 3] * cph;
+                ay += MS[m * 3 + 1] * cph;
+                az += MS[m * 3 + 2] * cph;
+            }
+            ax *= turb;
+            ay *= turb;
+            az *= turb;
+            // warm updraft inside the beam
+            const dx0 = x - BEAM_ORIGIN[0], dz0 = z - BEAM_ORIGIN[2];
+            const across = Math.abs(dx0 * b1x + dz0 * b1z);
+            if (across < w)
+                ay += turb * 0.5 * (1 - across / w);
+            if (useHand) {
+                // moving sphere: potential-flow dipole outside, carried inside, plus a trailing wake
+                const qx = x - hp.x, qy = y - hp.y, qz = z - hp.z;
+                const r2 = qx * qx + qy * qy + qz * qz;
+                if (r2 < 36 * R * R) {
+                    const r = Math.sqrt(r2) + 1e-6;
+                    if (r > R) {
+                        const k3 = (R * R * R) / (2 * r2 * r);
+                        const vr = (hv.x * qx + hv.y * qy + hv.z * qz) / r;
+                        ax += S * k3 * (3 * vr * qx / r - hv.x);
+                        ay += S * k3 * (3 * vr * qy / r - hv.y);
+                        az += S * k3 * (3 * vr * qz / r - hv.z);
+                    }
+                    else {
+                        ax += S * hv.x;
+                        ay += S * hv.y;
+                        az += S * hv.z;
+                    }
+                    const behind = -(qx * hv.x + qy * hv.y + qz * hv.z) * vn;
+                    if (behind > 0) {
+                        const perp2 = r2 - behind * behind;
+                        const wk = 0.6 * S * Math.exp(-perp2 / (R * R) - behind / (3 * R));
+                        ax += hv.x * wk;
+                        ay += hv.y * wk;
+                        az += hv.z * wk;
+                    }
+                }
+            }
+            else if (useTorch) {
+                const above = y - hp.y;
+                if (above > -0.06 && above < 1.2) {
+                    const qx = x - hp.x, qz = z - hp.z;
+                    const sgm = pr + 0.22 * Math.max(above, 0);
+                    const rh2 = qx * qx + qz * qz;
+                    if (rh2 < 9 * sgm * sgm) {
+                        const wv = 0.16 * S * (pr / sgm) * Math.exp(-rh2 / (sgm * sgm)) * Math.min(1, (above + 0.06) / 0.06);
+                        ay += wv;
+                        ax -= qx * wv * 0.8;
+                        az -= qz * wv * 0.8; // entrainment: air drawn into the plume
+                    }
+                }
+            }
+            // vortex rings: circulation around the ring's core circle
+            for (let q = 0; q < nr; q++) {
+                const k = live[q];
+                const G = RG[k];
+                const a = RR[k];
+                const qx = x - RC_[k * 3], qy = y - RC_[k * 3 + 1], qz = z - RC_[k * 3 + 2];
+                if (qx * qx + qy * qy + qz * qz > 16 * a * a)
+                    continue; // outside the ring's reach
+                const nx = RN[k * 3], ny = RN[k * 3 + 1], nz = RN[k * 3 + 2];
+                const zz = qx * nx + qy * ny + qz * nz;
+                const px = qx - zz * nx, py = qy - zz * ny, pz = qz - zz * nz;
+                const rho = Math.sqrt(px * px + py * py + pz * pz) + 1e-6;
+                const dr = rho - a;
+                const s2 = dr * dr + zz * zz;
+                if (s2 > 9 * a * a)
+                    continue;
+                const core = 0.3 * a;
+                const f = (G / (6.2831853 * (s2 + core * core))) * Math.exp(-s2 / (2.25 * a * a));
+                // t = z * rho_hat - (rho - a) * n  (flow runs through the ring along +n)
+                ax += f * (zz * px / rho - dr * nx);
+                ay += f * (zz * py / rho - dr * ny);
+                az += f * (zz * pz / rho - dr * nz);
+            }
+            const settle = -0.004 * (0.4 + seed[i * 4]);
+            // exact OU relaxation toward the air velocity + thermal kick
+            vel[j] = ax + (vel[j] - ax) * decay + sig * r2n();
+            vel[j + 1] = ay + settle + (vel[j + 1] - ay - settle) * decay + sig * r2n();
+            vel[j + 2] = az + (vel[j + 2] - az) * decay + sig * r2n();
+            charge[i] *= dis;
+            if (useCharge) {
+                const qx = x - hp.x, qy = y - hp.y, qz = z - hp.z;
+                const r2 = qx * qx + qy * qy + qz * qz;
+                if (r2 < reach * reach) {
+                    const r = Math.sqrt(r2) + 1e-6;
+                    if (r < RCON)
+                        charge[i] = 1; // contact: the mote takes the rod's charge
+                    const c = charge[i];
+                    const f = (-KA * (1 - c)) / (r2 * r + EPS * EPS * EPS) + (KR * c) / (r2 + EPS * EPS);
+                    const fr = Math.max(Math.min(f, 3), -3) / r;
+                    vel[j] += qx * fr * h;
+                    vel[j + 1] += qy * fr * h;
+                    vel[j + 2] += qz * fr * h;
+                }
+            }
+            let nx = x + vel[j] * h, ny = y + vel[j + 1] * h, nz = z + vel[j + 2] * h;
+            // periodic room (the shader fades motes at the walls, so wrapping never pops)
+            if (nx > BX)
+                nx -= 2 * BX;
+            else if (nx < -BX)
+                nx += 2 * BX;
+            if (nz > BZ)
+                nz -= 2 * BZ;
+            else if (nz < -BZ)
+                nz += 2 * BZ;
+            if (ny > BY1)
+                ny -= BY1 - BY0;
+            else if (ny < BY0)
+                ny += BY1 - BY0;
+            pos[j] = nx;
+            pos[j + 1] = ny;
+            pos[j + 2] = nz;
+        }
+    }
+    for (let s = 0; s < 60; s++)
+        step(H_MAX); // velocities into equilibrium with the air
+    const geo = new THREE.BufferGeometry();
+    const posAttr = new THREE.BufferAttribute(pos, 3).setUsage(THREE.DynamicDrawUsage);
+    geo.setAttribute('position', posAttr);
+    geo.setAttribute('aSeed', new THREE.BufferAttribute(seed, 4));
+    geo.setAttribute('aAxis', new THREE.BufferAttribute(axis, 3));
+    const chargeAttr = new THREE.BufferAttribute(charge, 1).setUsage(THREE.DynamicDrawUsage);
+    geo.setAttribute('aCharge', chargeAttr);
+    const mat = new THREE.ShaderMaterial({
+        uniforms: u, vertexShader: moteVertex, fragmentShader: fragment,
+        transparent: true, depthWrite: false, blending: THREE.AdditiveBlending,
+    });
+    const motes = new THREE.Points(geo, mat);
+    motes.frustumCulled = false;
+    attachViewH(motes, u);
+    // the light shaft volume: the room box, drawn from its back faces so it works from inside too
+    const volGeo = new THREE.BoxGeometry(2 * BX, BY1 - BY0, 2 * BZ);
+    volGeo.translate(0, (BY0 + BY1) / 2, 0);
+    const volMat = new THREE.ShaderMaterial({
+        uniforms: u, vertexShader: volVertex, fragmentShader: volFragment,
+        transparent: true, depthWrite: false, depthTest: false, side: THREE.BackSide, blending: THREE.AdditiveBlending,
+    });
+    const haze = new THREE.Mesh(volGeo, volMat);
+    haze.frustumCulled = false;
+    const ggeo = new THREE.BufferGeometry();
+    ggeo.setAttribute('position', new THREE.BufferAttribute(new Float32Array(3), 3));
+    const gmat = new THREE.ShaderMaterial({
+        uniforms: u, vertexShader: glyphVertex, fragmentShader: glyphFragment,
+        transparent: true, depthWrite: false, blending: THREE.AdditiveBlending,
+    });
+    const glyph = new THREE.Points(ggeo, gmat);
+    glyph.frustumCulled = false;
+    const object = new THREE.Group();
+    object.add(haze, motes, glyph);
+    const anchor = new THREE.Vector3(...BEAM_ORIGIN);
+    const focusPt = new THREE.Vector3();
+    // ---- trails: every sample lit by the same beam, hand shadow and torch as the motes ----
+    const trailGLSL = /* glsl */ `
+${BEAM_GLSL}
+uniform vec3 uCamLocal;
+vec3 trailShade(vec3 p, float f) {
+  vec3 L = beamDir();
+  vec3 toEye = normalize(uCamLocal - p);
+  float lit = windowMask(p, L) * handShadow(p, L) * boxFade(p);
+  return uColor * lit * hg(dot(L, toEye), uAnisotropy) * 1.1 + torchLight(p, toEye, uAnisotropy) + uAmbientColor * 0.04;
+}
+vec3 trailView(vec3 mv, out float mag) { mag = 1.0; return mv; }
+`;
+    const materials = [mat, volMat, gmat];
+    let trail = null, trailKey = '';
+    function buildTrails(mode, share) {
+        const key = mode + ':' + share;
+        if (key === trailKey)
+            return;
+        trailKey = key;
+        if (trail) {
+            object.remove(trail.object);
+            trail.dispose();
+            trail = null;
+        }
+        materials.length = 3;
+        trail = createCpuTrail(mode, { u, n, pos, vel, glsl: trailGLSL, sizePx: 0.007, spacing: 0.003 });
+        if (!trail)
+            return;
+        object.add(trail.object);
+        materials.push(...trail.materials);
+    }
+    buildTrails(c.trailMode, c.trailShare);
+    return {
+        object,
+        materials,
+        apply(cfg) { if (cfg)
+            buildTrails(cfg.trailMode, cfg.trailShare); },
+        update(dt, camera, pointer) {
+            const rdt = Math.min(Math.max(dt, 0), 1 / 20);
+            const d = rdt * u.uSpeed.value;
+            u.uTime.value += d;
+            if (camera) {
+                // autofocus on the middle of the beam
+                object.localToWorld(focusPt.copy(anchor).multiplyScalar(u.uSize.value));
+                u.uFocus.value = camera.position.distanceTo(focusPt);
+                object.worldToLocal(u.uCamLocal.value.copy(camera.position)).divideScalar(u.uSize.value);
+                if (pointer)
+                    stepPointerField(u, pointer, camera, object, u.uSize.value, rdt, anchor);
+            }
+            u.uVelScale.value = u.uSpeed.value;
+            if (d > 0) {
+                const steps = Math.ceil(d / H_MAX);
+                for (let s = 0; s < steps; s++)
+                    step(d / steps);
+            }
+            posAttr.needsUpdate = true;
+            chargeAttr.needsUpdate = true;
+            if (trail)
+                trail.update(d);
+        },
+        dispose() {
+            geo.dispose();
+            mat.dispose();
+            volGeo.dispose();
+            volMat.dispose();
+            ggeo.dispose();
+            gmat.dispose();
+            if (trail)
+                trail.dispose();
+        },
+        _state: { pos, vel, RG, charge },
+    };
+}
+/** Defaults for every knob, so an older saved config still renders (identical to the catalog entry). */
+const DEFAULTS = {
+    intensity: 1,
+    speed: 1,
+    opacity: 0.9,
+    size: 1,
+    color: '#ffd7a1',
+    particleCount: 5000,
+    temperature: 1,
+    turbulence: 1,
+    beamAngle: 38,
+    beamWidth: 0.32,
+    windowPanes: 3,
+    anisotropy: 0.7,
+    hazeDensity: 1,
+    aperture: 0.6,
+    ambientColor: '#7892b8',
+    pointerMode: 'hand',
+    pointerStrength: 1,
+    pointerRadius: 1,
+    pointerColor: '#ffe7c2',
+    trailMode: 'comet',
+    trailLength: 2.5,
+    trailOpacity: 0.5,
+    trailColor: '#ffb870',
+    trailShare: 0.3,
+};
+const BrownianDustParticles = ({ size, config, animations, onObjectReady, onObjectDispose }) => {
+    const rootRef = useRef(null);
+    const animCache = useRef({});
+    useObjectReady(rootRef, config, onObjectReady, onObjectDispose);
+    const s = size > 0 ? size : 1;
+    const cfg = useMemo(() => ({ ...DEFAULTS, ...config }), [config]);
+    // uniforms outlive the objects, so keyframe animations survive a rebuild
+    const uniforms = useMemo(() => createUniforms(), []);
+    // rebuilt only when a structural knob changes (trails rebuild inside apply())
+    const instance = useMemo(() => build(uniforms, cfg, s), [uniforms, cfg.particleCount]);
+    useEffect(() => () => instance.dispose(), [instance]);
+    useLayoutEffect(() => {
+        applyConfig(uniforms, cfg, s);
+        instance.apply(cfg);
+    }, [instance, uniforms, cfg, s]);
+    const pointer = usePointerField();
+    useFrame((state, delta) => {
+        instance.update(Math.min(delta, 0.1), state.camera, pointer);
+        if (animations?.length)
+            applyGenerativeAnimations(instance.materials, animations, animCache.current, Date.now(), false);
+    });
+    return (_jsx("group", { ref: rootRef, children: _jsx("primitive", { object: instance.object }) }));
+};
+export default BrownianDustParticles;