@3driseai/3drise-viewer 0.1.16 → 0.1.18

package/dist/components/particles/GrinderSparksParticles.js

@@ -0,0 +1,744 @@
+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';
+/**
+ * Grinder Sparks — Slow-motion grinder sparks: drag-limited ballistics, radiative cooling on the blackbody scale, carbon bursts, floor bounces and reflections; the cursor moves the grinder, aims the spray or sweeps the air. Use for industrial and cinematic scenes.
+ */
+// Grinder Sparks — an angle grinder biting steel, filmed in slow motion.
+// Movement: each spark is a burning steel grain thrown tangentially off the wheel rim. Quadratic
+//           air drag a = -k |v| v with k = 3 rho_air C_d / (4 rho_steel d) (small grains stop sooner),
+//           gravity, and floor bounces with restitution and skid friction. Carbon in the steel burns
+//           to CO inside the grain and bursts it: the spark forks into a star of short, brighter
+//           sparklets that can fork again — the "spark test" that tells steels apart (`carbon`).
+// Colour:   temperature on the Planck locus. While a grain burns, oxidation holds it near its
+//           launch temperature; after burn-out it cools by radiation (eps sigma T^4) and convection
+//           (Nu = 2), sliding from white-yellow to orange to cherry red; visible radiance
+//           ~ exp(-c2 / (lambda T)) sets brightness, so it fades out around 1000 K. The floor is lit
+//           by the contact point (cos / d^2) and mirrors the sparks; the cut glows and cools behind
+//           the wheel.
+// Mouse (pointerMode) — the cursor moves the grinder or the sparks; nothing is drawn at the cursor:
+//   wheel  — the grinder follows the cursor: the contact point moves along a camera-facing plane,
+//            the spark rate follows Preston's law (removal ~ pressure x speed), and the cut behind
+//            it glows and cools.
+//   aim    — the grinder stays put and turns: the spray fan swings toward the cursor, and pushing
+//            harder (a faster swing) throws more sparks.
+//   sweep  — the cursor's motion stirs the air: a moving-body potential flow plus a trailing wake
+//            (in the slowed-down physics time) drags the sparks into swirls, and burning grains in the
+//            wake get extra oxygen and flare hotter.
+// Trails (trailMode): streak = long exposure (the classic grinder photo), comet = tracer arcs,
+//           echo = smoulder. Trails take the spark's temperature (TRAIL_K) so they cool with it.
+//
+// Generated from the approved lab module (particle lab, batch 2). 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;
+    };
+}
+/** Standard normal from a uniform PRNG (Box–Muller, one value per call). */
+function gauss(rng) {
+    const u = Math.max(rng(), 1e-9);
+    const v = rng();
+    return Math.sqrt(-2 * Math.log(u)) * Math.cos(6.283185307 * v);
+}
+/** 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) };
+}
+/** Tanner Helland blackbody fit, t in kelvin -> linear-ish RGB. */
+const BLACKBODY_GLSL = /* glsl */ `
+vec3 blackbody(float tK) {
+  float t = clamp(tK, 1000.0, 40000.0) / 100.0;
+  float r = t <= 66.0 ? 1.0 : clamp(1.29293618606 * pow(t - 60.0, -0.1332047592), 0.0, 1.0);
+  float g = t <= 66.0 ? clamp(0.39008157876 * log(t) - 0.63184144378, 0.0, 1.0)
+                      : clamp(1.12989086089 * pow(t - 60.0, -0.0755148492), 0.0, 1.0);
+  float b = t >= 66.0 ? 1.0 : (t <= 19.0 ? 0.0 : clamp(0.54320678911 * log(t - 10.0) - 1.19625408914, 0.0, 1.0));
+  return pow(vec3(r, g, b), vec3(2.2));
+}
+`;
+/** Quality levels scale counts, raymarch samples and trail caps. Structural. */
+const QUALITY_SCALE = { low: 0.5, medium: 1, high: 1.6 };
+function qualityScale(q) { return QUALITY_SCALE[q] || 1; }
+/** Mix the object's own base seed with the `seed` knob into a mulberry32 seed. */
+function seedMix(base, seed) {
+    let h = (base ^ Math.imul((Math.round(seed) | 0) + 0x9e37, 0x85ebca6b)) >>> 0;
+    h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35) >>> 0;
+    return (h ^ (h >>> 16)) >>> 0;
+}
+/** Fixed-step clock: the same motion at 30, 60 or 144 Hz. `run(d, step)` advances d sim-seconds
+ *  in steps of exactly H (at most maxSteps per call; a longer backlog is dropped, not caught up). */
+function createFixedStep(H, maxSteps) {
+    let acc = 0;
+    return {
+        H,
+        run(d, step) {
+            acc += Math.max(d, 0);
+            let k = 0;
+            while (acc >= H && k < maxSteps) {
+                step(H);
+                acc -= H;
+                k++;
+            }
+            if (k === maxSteps)
+                acc = Math.min(acc, H);
+            return acc / H; // leftover fraction, for render interpolation
+        },
+        reset() { acc = 0; },
+    };
+}
+/** Selection bounds: an invisible sphere the editor can pick, frame and size (never rendered,
+ *  still raycastable and counted by Box3.setFromObject). */
+function createPickProxy(center, radius) {
+    const geo = new THREE.SphereGeometry(1, 16, 10);
+    const mat = new THREE.MeshBasicMaterial({ visible: false });
+    const mesh = new THREE.Mesh(geo, mat);
+    mesh.name = 'pickProxy';
+    mesh.position.set(center[0], center[1], center[2]);
+    mesh.scale.setScalar(radius);
+    return { mesh, dispose() { geo.dispose(); mat.dispose(); } };
+}
+const _frustum = new THREE.Frustum();
+const _pm = new THREE.Matrix4();
+const _sphere = new THREE.Sphere();
+/** Off-screen test: false when the object's bounding sphere is outside the camera frustum. */
+function inView(object, camera, center, radius, size) {
+    if (!camera || !camera.projectionMatrix)
+        return true;
+    object.updateWorldMatrix(true, false);
+    _sphere.center.set(center[0], center[1], center[2]).multiplyScalar(size).applyMatrix4(object.matrixWorld);
+    _sphere.radius = radius * size * object.matrixWorld.getMaxScaleOnAxis();
+    _pm.multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse);
+    _frustum.setFromProjectionMatrix(_pm);
+    return _frustum.intersectsSphere(_sphere);
+}
+const POINTER_MODES = ['wheel', 'aim', 'sweep'];
+const SLOWMO = 0.2; // physics seconds per shown second (a high-speed camera)
+const H_STEP = 1 / 120; // shown-time step (physics step = H_STEP * SLOWMO)
+const TR = 0.006; // physics seconds per trail unit (the shutter) for streaks
+const TR_MODE = { streak: TR, comet: 0.03, echo: 0.04 }; // arcs and smoulder look back further
+const C0 = [-0.8, 0.95, 0]; // contact point at rest (m)
+const SPRAY_MID = [0.1, 0.6, 0];
+const BOUNDS = { center: [0.2, 0.7, 0], radius: 2.3 };
+const RHO_C = 7800 * 600; // steel density x heat capacity
+const SIGMA = 5.67e-8, EPS = 0.8, T_AIR = 300;
+const EL0 = -0.26; // rest elevation of the fan (rad)
+const COOL = 0.22; // effective cooling scale (grains keep oxide shells hot)
+const NK = 96; // cut heat-trail points
+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 },
+        uSparkRate: { value: 1 },
+        uWheelSpeed: { value: 45 },
+        uSprayAngle: { value: 14 },
+        uCarbon: { value: 0.5 },
+        uTemperature: { value: 2000 },
+        uExposure: { value: 1 },
+        uFloorReflect: { value: 0.35 },
+        uEmberColor: colorUniform('#ffffff'),
+        uPointerMode: { value: 0 },
+        uPointerStrength: { value: 1 },
+        uPointerRadius: { value: 1 },
+        uPointerColor: colorUniform('#ffffff'),
+        uContact: { value: new THREE.Vector4(C0[0], C0[1], C0[2], 0) }, // xyz, glow
+        ...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.uSparkRate.value = c.sparkRate;
+    u.uWheelSpeed.value = c.wheelSpeed;
+    u.uSprayAngle.value = c.sprayAngle;
+    u.uCarbon.value = c.carbon;
+    u.uTemperature.value = c.temperature;
+    u.uExposure.value = c.exposure;
+    u.uFloorReflect.value = c.floorReflect;
+    u.uEmberColor.value.set(c.emberColor);
+    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);
+}
+const BASE_U = 'uniform float uSize, uViewH, uIntensity, uOpacity;';
+// Spark light: blackbody colour, visible-band radiance ~ exp(-c / T) normalised at 2000 K.
+const HEAT_GLSL = /* glsl */ `
+${BLACKBODY_GLSL}
+uniform vec3 uColor, uEmberColor;
+uniform float uExposure;
+vec3 heatLight(float T) {
+  if (T < 600.0) return vec3(0.0);
+  float b = exp(-5500.0 / uExposure * (1.0 / T - 1.0 / 2000.0));
+  vec3 c = blackbody(T);
+  c /= max(max(c.r, c.g), max(c.b, 1e-3));
+  c = mix(c, c * uColor, smoothstep(1700.0, 2300.0, T));      // hottest sparks take the tint
+  c = mix(c, uEmberColor, 0.55 * smoothstep(1350.0, 950.0, T)); // dull red embers take the ember tint
+  // film response: bright sparks saturate toward white like an overexposed photo
+  vec3 E = c * b * 2.4;
+  return (vec3(1.0) - exp(-E)) * (1.0 + 0.6 * smoothstep(1.2, 3.0, b));
+}
+`;
+function sparkVertex(mirror) {
+    return /* glsl */ `
+${BASE_U}
+${HEAT_GLSL}
+uniform float uFloorReflect;
+attribute float aT;
+attribute float aD;
+varying vec3 vCol;
+varying float vA;
+void main() {
+  vec3 p = position;
+  ${mirror ? 'p.y = -p.y;' : ''}
+  vec3 L = heatLight(aT);
+  vec4 mv = modelViewMatrix * vec4(p * uSize, 1.0);
+  float lum = dot(L, vec3(0.3, 0.5, 0.2));
+  float px = uSize * uViewH * (0.0045 + 0.004 * aD) * (1.0 + 0.8 * min(lum, 2.0)) / -mv.z;
+  ${mirror ? 'px *= 1.6; float fade = uFloorReflect * 0.45 * exp(-position.y * 1.2) * smoothstep(3.0, 1.5, length(position.xz - vec2(0.4, 0.0)));' : 'float fade = 1.0;'}
+  vCol = L * uIntensity;
+  vA = uOpacity * fade * step(600.0, aT);
+  gl_PointSize = clamp(px, 1.0, 40.0) * step(0.001, vA);
+  gl_Position = projectionMatrix * mv;
+}
+`;
+}
+const sparkFragment = /* glsl */ `
+varying vec3 vCol;
+varying float vA;
+void main() {
+  vec2 d = gl_PointCoord * 2.0 - 1.0;
+  float r2 = dot(d, d);
+  if (r2 > 1.0) discard;
+  float a = (exp(-r2 * 8.0) + 0.3 * exp(-r2 * 2.2)) * (1.0 - r2) * vA;
+  if (a < 0.002) discard;
+  gl_FragColor = vec4(vCol, a);
+}
+`;
+// Floor: light from the contact point (Lambert, cos / d^2) — the pool the sparks rain into.
+const floorVertex = /* glsl */ `
+uniform float uSize;
+varying vec3 vP;
+void main() {
+  vP = position;
+  gl_Position = projectionMatrix * modelViewMatrix * vec4(position * uSize, 1.0);
+}
+`;
+const floorFragment = /* glsl */ `
+${BASE_U}
+${BLACKBODY_GLSL}
+uniform vec4 uContact;
+uniform vec3 uColor;
+varying vec3 vP;
+void main() {
+  vec3 d = uContact.xyz - vP;
+  float r2 = dot(d, d);
+  float E = uContact.w * max(d.y, 0.0) / pow(r2 + 0.02, 1.5);
+  vec3 c = blackbody(2100.0); c /= max(max(c.r, c.g), c.b);
+  float edge = smoothstep(2.8, 1.8, length(vP.xz - vec2(0.3, 0.0)));
+  vec3 rgb = c * uColor * E * 0.14 * uIntensity * edge;
+  float I = max(max(rgb.r, rgb.g), rgb.b);
+  if (I < 0.001) discard;
+  I = min(I, 1.0);
+  gl_FragColor = vec4(rgb / max(I, 1e-4), I * uOpacity);
+}
+`;
+// Glyphs: the contact glow and the cooling cut behind the wheel (nothing is drawn at the cursor).
+const glyphVertex = /* glsl */ `
+${BASE_U}
+${HEAT_GLSL}
+attribute vec3 aG; // kind, temperature, strength
+varying vec3 vCol;
+varying float vA;
+varying float vKind;
+void main() {
+  vec4 mv = modelViewMatrix * vec4(position * uSize, 1.0);
+  float kind = aG.x;
+  float s;
+  if (kind < 0.5) { s = 0.05 + 0.05 * aG.z; vCol = heatLight(2300.0); }   // contact glow
+  else { s = 0.018; vCol = heatLight(aG.y); }                               // the cooling cut
+  vA = aG.z * uOpacity;
+  vKind = kind;
+  vCol *= uIntensity;
+  gl_PointSize = clamp(uSize * uViewH * s / -mv.z, 0.0, 200.0) * step(0.001, vA);
+  gl_Position = projectionMatrix * mv;
+}
+`;
+const glyphFragment = /* glsl */ `
+varying vec3 vCol;
+varying float vA;
+varying float vKind;
+void main() {
+  vec2 d = gl_PointCoord * 2.0 - 1.0;
+  float r2 = dot(d, d);
+  if (r2 > 1.0) discard;
+  float a = vKind < 0.5 ? exp(-r2 * 40.0) * 1.5 + exp(-r2 * 5.0) * 0.25 : exp(-r2 * 6.0) * 0.9;
+  a *= (1.0 - r2) * vA;
+  if (a < 0.003) discard;
+  gl_FragColor = vec4(vCol, a);
+}
+`;
+function build(u, c, size) {
+    const q = qualityScale(c.quality);
+    const n = Math.max(64, Math.round(c.particleCount * q));
+    const rng = mulberry32(seedMix(0x5a4c, c.seed));
+    const pos = new Float32Array(n * 3), vel = new Float32Array(n * 3);
+    let trail = null, trailKey = '', trailTR = TR;
+    const T = new Float32Array(n); // temperature (K); 0 = not glowing
+    const Dm = new Float32Array(n); // grain diameter (m)
+    const aD = new Float32Array(n); // size seed for rendering
+    const burn = new Float32Array(n); // remaining burn time (physics s)
+    const burst = new Float32Array(n); // physics age of the carbon burst (1e9 = none)
+    const age = new Float32Array(n);
+    const gen = new Uint8Array(n);
+    const st = new Uint8Array(n); // 0 free, 1 flying, 2 holding (dead)
+    const hold = new Float32Array(n);
+    const free = new Int32Array(n);
+    let nFree = n;
+    for (let i = 0; i < n; i++)
+        free[i] = n - 1 - i;
+    // contact point (moves in wheel mode), cut heat trail
+    const cp = new THREE.Vector3(...C0);
+    const KP = new Float32Array(NK * 3), KB = new Float32Array(NK);
+    for (let k = 0; k < NK; k++)
+        KB[k] = -1e9;
+    let kHead = 0, kClock = 0;
+    const kLast = new THREE.Vector3(...C0);
+    let emitAcc = 0, glow = 1, physT = 0, strokeRate = 0;
+    const hp = new THREE.Vector3(), hv = new THREE.Vector3();
+    let aimAz = 0, aimEl = EL0;
+    function spawn(i, x, y, z, vx, vy, vz, T0, d, g) {
+        st[i] = 1;
+        age[i] = 0;
+        gen[i] = g;
+        pos[i * 3] = x;
+        pos[i * 3 + 1] = y;
+        pos[i * 3 + 2] = z;
+        vel[i * 3] = vx;
+        vel[i * 3 + 1] = vy;
+        vel[i * 3 + 2] = vz;
+        T[i] = T0;
+        Dm[i] = d;
+        // burn time grows with grain size (diffusion-limited oxidation)
+        burn[i] = g === 0 ? 0.22 * Math.pow(d / 1.2e-4, 1.5) * (0.7 + 0.6 * rng()) : 0.012 + 0.03 * rng();
+        const pBurst = g === 0 ? 0.85 * u.uCarbon.value : g === 1 ? 0.35 * u.uCarbon.value : 0;
+        burst[i] = rng() < pBurst ? burn[i] * (0.35 + 0.5 * rng()) : 1e9;
+        aD[i] = Math.min(d / 2.5e-4, 1.5);
+        if (trail)
+            trail.reset(i);
+    }
+    function step(hShown) {
+        const h = hShown * SLOWMO; // physics seconds
+        physT += h;
+        const mode = u.uPointerMode.value;
+        const S = u.uPointerStrength.value, act = u.uPointerActive.value, Rr = u.uPointerRadius.value;
+        hp.copy(u.uPointer.value);
+        hv.copy(u.uPointerVel.value);
+        const useWheel = mode === 0 && S > 0.01;
+        const useAim = mode === 1 && S > 0.01;
+        const useSweep = mode === 2 && S > 0.01 && act > 0.01;
+        // ---- contact point and spark rate (Preston: removal ~ pressure x relative speed) ----
+        let target = C0;
+        if (useWheel && act > 0.05)
+            target = [hp.x, Math.min(Math.max(hp.y, 0.25), 1.6), hp.z];
+        const lagK = Math.min(1, hShown * 10);
+        cp.x += (target[0] - cp.x) * lagK;
+        cp.y += (target[1] - cp.y) * lagK;
+        cp.z += (target[2] - cp.z) * lagK;
+        const stroke = useWheel || useAim ? hv.length() * act : 0;
+        strokeRate += (stroke - strokeRate) * Math.min(1, hShown * 4);
+        const pressure = useWheel || useAim ? 0.6 + 0.5 * S : 0.8;
+        // aim: the fan direction swings toward the cursor (azimuth about y, elevation), back to rest when idle
+        let tEl = EL0, tAz = 0;
+        if (useAim && act > 0.05) {
+            const dx = hp.x - cp.x, dy = hp.y - cp.y, dz = hp.z - cp.z;
+            const dl = Math.hypot(dx, dy, dz);
+            if (dl > 0.05) {
+                tEl = Math.max(-1.2, Math.min(0.9, Math.asin(dy / dl)));
+                tAz = Math.atan2(dz, dx);
+            }
+        }
+        let dAz = tAz - aimAz;
+        while (dAz > Math.PI)
+            dAz -= 2 * Math.PI;
+        while (dAz < -Math.PI)
+            dAz += 2 * Math.PI;
+        const aimK = Math.min(1, hShown * 5);
+        aimAz += dAz * aimK;
+        aimEl += (tEl - aimEl) * aimK;
+        const rate = 5000 * u.uSparkRate.value * pressure * (1 + 1.2 * strokeRate / (strokeRate + 0.6));
+        glow += (rate / 5000 - glow) * Math.min(1, hShown * 6);
+        u.uContact.value.set(cp.x, cp.y, cp.z, glow);
+        // cut heat trail: a point every ~1 cm of contact travel
+        kClock += hShown;
+        if (cp.distanceTo(kLast) > 0.012 || kClock > 0.5) {
+            KP[kHead * 3] = cp.x;
+            KP[kHead * 3 + 1] = cp.y;
+            KP[kHead * 3 + 2] = cp.z;
+            KB[kHead] = physT;
+            kHead = (kHead + 1) % NK;
+            kLast.copy(cp);
+            kClock = 0;
+        }
+        // ---- emission: tangential fan off the rim (the wheel turns in the x-y plane) ----
+        emitAcc += rate * h;
+        const vRim = u.uWheelSpeed.value;
+        const spread = (u.uSprayAngle.value * Math.PI) / 180;
+        const T0 = u.uTemperature.value;
+        while (emitAcc >= 1 && nFree > 0) {
+            emitAcc -= 1;
+            const i = free[--nFree];
+            const ang = aimEl + spread * gauss(rng) * 0.6; // the fan spreads in the wheel plane
+            const yaw = aimAz + 0.05 * gauss(rng); // thin across it
+            const sp = vRim * (0.55 + 0.45 * rng());
+            const d = 1.2e-4 * Math.exp(0.45 * gauss(rng));
+            const ca = Math.cos(ang), sa = Math.sin(ang);
+            spawn(i, cp.x + 0.004 * gauss(rng), cp.y + 0.004 * gauss(rng), cp.z + 0.004 * gauss(rng), sp * ca * Math.cos(yaw), sp * sa, sp * ca * Math.sin(yaw), T0 * (0.96 + 0.08 * rng()), d, 0);
+        }
+        if (emitAcc > 1)
+            emitAcc = 1;
+        // ---- air sweep: the cursor is a moving body in the air (velocity in physics time) ----
+        const mx = hp.x, my = hp.y, mz = hp.z;
+        const RS = 0.2 * Rr;
+        const AIR = 2.2 * S * act / SLOWMO; // a fast sweep (a hand or a board fanning the air)
+        const bvx = hv.x * AIR, bvy = hv.y * AIR, bvz = hv.z * AIR;
+        const bsp = Math.hypot(bvx, bvy, bvz), bn = bsp > 1e-4 ? 1 / bsp : 0;
+        const sweepOn = useSweep && bsp > 0.05;
+        for (let i = 0; i < n; i++) {
+            const s = st[i];
+            if (s === 0)
+                continue;
+            if (s === 2) { // dead: park until the trails forget it
+                hold[i] -= h;
+                if (hold[i] <= 0) {
+                    st[i] = 0;
+                    free[nFree++] = i;
+                }
+                continue;
+            }
+            const j = i * 3;
+            const d = Dm[i];
+            let t = T[i];
+            age[i] += h;
+            let x = pos[j], y = pos[j + 1], z = pos[j + 2];
+            let vx = vel[j], vy = vel[j + 1], vz = vel[j + 2];
+            // air: still, unless the sweep stirs it (moving-sphere dipole outside, carried inside, plus a wake)
+            let ax = 0, ay = 0, az = 0, flare = 0;
+            if (sweepOn) {
+                const qx = x - mx, qy = y - my, qz = z - mz;
+                const r2 = qx * qx + qy * qy + qz * qz;
+                if (r2 < 64 * RS * RS) {
+                    const r = Math.sqrt(r2) + 1e-6;
+                    if (r > RS) {
+                        const k3 = (RS * RS * RS) / (2 * r2 * r);
+                        const vr = (bvx * qx + bvy * qy + bvz * qz) / r;
+                        ax = k3 * (3 * vr * qx / r - bvx);
+                        ay = k3 * (3 * vr * qy / r - bvy);
+                        az = k3 * (3 * vr * qz / r - bvz);
+                    }
+                    else {
+                        ax = bvx;
+                        ay = bvy;
+                        az = bvz;
+                    }
+                    const behind = -(qx * bvx + qy * bvy + qz * bvz) * bn;
+                    if (behind > 0) {
+                        const perp2 = r2 - behind * behind;
+                        const wk = Math.exp(-perp2 / (RS * RS * 1.5) - behind / (8 * RS));
+                        ax += bvx * wk * 0.7;
+                        ay += bvy * wk * 0.7;
+                        az += bvz * wk * 0.7;
+                        flare = wk; // fresh air feeds the burning grains
+                    }
+                }
+            }
+            // quadratic drag relative to the air, semi-implicit
+            const k = 1.8 / (31200 * d);
+            const rx = vx - ax, ry = vy - ay, rz = vz - az;
+            const rv = Math.sqrt(rx * rx + ry * ry + rz * rz);
+            const damp = 1 / (1 + k * rv * h);
+            vx = ax + rx * damp;
+            vy = ay + ry * damp - 9.81 * h;
+            vz = az + rz * damp;
+            x += vx * h;
+            y += vy * h;
+            z += vz * h;
+            // floor: bounce with restitution, skid friction; conduction cools grains that touch it
+            let cool = 1;
+            if (y < 0) {
+                y = -y * 0.25;
+                vy = -vy * 0.25;
+                vx *= 0.5;
+                vz *= 0.5;
+                vz += (rng() - 0.5) * Math.abs(vx) * 0.4;
+                cool = 8;
+            }
+            else if (y < 0.01)
+                cool = 8; // lying on the floor: conduction drains it fast
+            // temperature: oxidation holds it hot while burning; then radiation + convection
+            if (burn[i] > 0) {
+                burn[i] -= h;
+                t += (T0 * 1.03 + 260 * flare - t) * Math.min(1, h / 0.02);
+                if (flare > 0.2)
+                    burn[i] += h * flare * 0.8; // oxygen keeps it burning longer
+            }
+            else {
+                const t2 = t * t;
+                t -= h * cool * COOL * (6 / (RHO_C * d)) * (EPS * SIGMA * (t2 * t2 - 8.1e9) + (0.052 / d) * (t - T_AIR));
+            }
+            // carbon burst: the grain forks into a star of sparklets
+            if (age[i] >= burst[i]) {
+                burst[i] = 1e9;
+                const kids = 3 + Math.floor(rng() * 4);
+                for (let q = 0; q < kids && nFree > 0; q++) {
+                    const cI = free[--nFree];
+                    let dx = gauss(rng), dy = gauss(rng), dz = gauss(rng);
+                    const dl = Math.hypot(dx, dy, dz) || 1;
+                    const sp = 2 + 4 * rng();
+                    dx = dx / dl * sp;
+                    dy = dy / dl * sp;
+                    dz = dz / dl * sp;
+                    spawn(cI, x, y, z, vx * 0.6 + dx, vy * 0.6 + dy, vz * 0.6 + dz, Math.max(t, T0) + 220, d * 0.45, gen[i] + 1);
+                }
+                Dm[i] = d * 0.75;
+                t += 120;
+            }
+            T[i] = t;
+            pos[j] = x;
+            pos[j + 1] = y;
+            pos[j + 2] = z;
+            vel[j] = vx;
+            vel[j + 1] = vy;
+            vel[j + 2] = vz;
+            if (t < 700 || age[i] > 6 || x > 3.5 || x < -2.5 || Math.abs(z) > 3 || y > 3.5) {
+                st[i] = 2;
+                hold[i] = 0.05;
+                T[i] = 0;
+                vel[j] = 0;
+                vel[j + 1] = 0;
+                vel[j + 2] = 0;
+            }
+        }
+    }
+    const stepper = createFixedStep(H_STEP, 6);
+    for (let s = 0; s < 240; s++)
+        step(H_STEP); // two shown seconds: the spray is established
+    // ---- geometry ----
+    const geo = new THREE.BufferGeometry();
+    const posAttr = new THREE.BufferAttribute(pos, 3).setUsage(THREE.DynamicDrawUsage);
+    const tAttr = new THREE.BufferAttribute(T, 1).setUsage(THREE.DynamicDrawUsage);
+    const dAttr = new THREE.BufferAttribute(aD, 1).setUsage(THREE.DynamicDrawUsage);
+    geo.setAttribute('position', posAttr);
+    geo.setAttribute('aT', tAttr);
+    geo.setAttribute('aD', dAttr);
+    const mkSpark = (mirror) => new THREE.ShaderMaterial({
+        uniforms: u, vertexShader: sparkVertex(mirror), fragmentShader: sparkFragment,
+        transparent: true, depthWrite: false, blending: THREE.AdditiveBlending,
+    });
+    const mat = mkSpark(false), rmat = mkSpark(true);
+    const sparks = new THREE.Points(geo, mat);
+    sparks.frustumCulled = false;
+    attachViewH(sparks, u);
+    const mirror = new THREE.Points(geo, rmat);
+    mirror.frustumCulled = false;
+    const fgeo = new THREE.CircleGeometry(2.8, 64);
+    fgeo.rotateX(-Math.PI / 2);
+    fgeo.translate(0.3, 0.002, 0);
+    const fmat = new THREE.ShaderMaterial({
+        uniforms: u, vertexShader: floorVertex, fragmentShader: floorFragment,
+        transparent: true, depthWrite: false, blending: THREE.AdditiveBlending,
+    });
+    const floor = new THREE.Mesh(fgeo, fmat);
+    floor.frustumCulled = false;
+    const NG = 1 + NK;
+    const gp = new Float32Array(NG * 3), ga = new Float32Array(NG * 3);
+    const gpAttr = new THREE.BufferAttribute(gp, 3).setUsage(THREE.DynamicDrawUsage);
+    const gaAttr = new THREE.BufferAttribute(ga, 3).setUsage(THREE.DynamicDrawUsage);
+    const ggeo = new THREE.BufferGeometry();
+    ggeo.setAttribute('position', gpAttr);
+    ggeo.setAttribute('aG', gaAttr);
+    const gmat = new THREE.ShaderMaterial({
+        uniforms: u, vertexShader: glyphVertex, fragmentShader: glyphFragment,
+        transparent: true, depthWrite: false, blending: THREE.AdditiveBlending,
+    });
+    const glyphs = new THREE.Points(ggeo, gmat);
+    glyphs.frustumCulled = false;
+    const object = new THREE.Group();
+    const proxy = createPickProxy(BOUNDS.center, BOUNDS.radius);
+    object.add(floor, mirror, sparks, glyphs, proxy.mesh);
+    const anchorWheel = new THREE.Vector3(...C0), anchorSpray = new THREE.Vector3(...SPRAY_MID);
+    function upload() {
+        posAttr.needsUpdate = true;
+        tAttr.needsUpdate = true;
+        dAttr.needsUpdate = true;
+        const mode = u.uPointerMode.value;
+        gp[0] = cp.x;
+        gp[1] = cp.y;
+        gp[2] = cp.z;
+        ga[0] = 0;
+        ga[1] = 2300;
+        ga[2] = Math.min(glow, 2.5);
+        for (let k = 0; k < NK; k++) {
+            const g = 1 + k;
+            gp[g * 3] = KP[k * 3];
+            gp[g * 3 + 1] = KP[k * 3 + 1];
+            gp[g * 3 + 2] = KP[k * 3 + 2];
+            const a = physT - KB[k];
+            const tk = T_AIR + (1350 - T_AIR) * Math.exp(-a / 0.35); // the cut cools behind the wheel
+            ga[g * 3] = 1;
+            ga[g * 3 + 1] = tk;
+            ga[g * 3 + 2] = a < 4 && mode === 0 ? 1 : 0;
+        }
+        gpAttr.needsUpdate = true;
+        gaAttr.needsUpdate = true;
+    }
+    // ---- trails: coloured by the spark's temperature ----
+    const trailGLSL = /* glsl */ `
+${HEAT_GLSL}
+vec3 trailShade(vec3 p, float f) { return heatLight(TRAIL_K) * 2.2; }
+vec3 trailView(vec3 mv, out float mag) { mag = 1.0; return mv; }
+`;
+    const materials = [mat, rmat, fmat, gmat];
+    trailKey = '';
+    trailTR = TR;
+    function buildTrails(mode, share) {
+        trailTR = TR_MODE[mode] || TR;
+        const key = mode + ':' + share;
+        if (key === trailKey)
+            return;
+        trailKey = key;
+        if (trail) {
+            object.remove(trail.object);
+            trail.dispose();
+            trail = null;
+        }
+        materials.length = 4;
+        trail = createCpuTrail(mode, { u, n, pos, vel, k: T, glsl: trailGLSL, sizePx: 0.0055, spacing: 0.004, sub: 12 });
+        if (!trail)
+            return;
+        object.add(trail.object);
+        materials.push(...trail.materials);
+    }
+    buildTrails(c.trailMode, c.trailShare);
+    upload();
+    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);
+            if (camera && !inView(object, camera, BOUNDS.center, BOUNDS.radius, u.uSize.value))
+                return;
+            const d = rdt * u.uSpeed.value;
+            u.uTime.value += d;
+            if (camera && pointer) {
+                const anchor = u.uPointerMode.value === 0 ? anchorWheel : anchorSpray;
+                stepPointerField(u, pointer, camera, object, u.uSize.value, rdt, anchor);
+            }
+            u.uVelScale.value = trailTR; // trails cover trailTR x trailLength physics seconds
+            let simD = 0;
+            stepper.run(d, (hh) => { step(hh); simD += hh; });
+            if (simD > 0) {
+                upload();
+                if (trail)
+                    trail.update((simD * SLOWMO) / trailTR);
+            }
+        },
+        seek(t) { for (let s = 0; s < Math.round(t / H_STEP); s++)
+            step(H_STEP); upload(); },
+        dispose() {
+            geo.dispose();
+            mat.dispose();
+            rmat.dispose();
+            fgeo.dispose();
+            fmat.dispose();
+            ggeo.dispose();
+            gmat.dispose();
+            proxy.dispose();
+            if (trail)
+                trail.dispose();
+        },
+        _state: { pos, vel, T },
+    };
+}
+/** 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: '#fff1d6',
+    particleCount: 12000,
+    sparkRate: 1,
+    wheelSpeed: 35,
+    sprayAngle: 14,
+    carbon: 0.5,
+    temperature: 2000,
+    exposure: 1,
+    floorReflect: 0.35,
+    emberColor: '#ff3a12',
+    seed: 1,
+    quality: 'medium',
+    pointerMode: 'wheel',
+    pointerStrength: 1,
+    pointerRadius: 1,
+    pointerColor: '#ffd9a0',
+    trailMode: 'comet',
+    trailLength: 0.9,
+    trailOpacity: 0.9,
+    trailColor: '#ff7a2e',
+    trailShare: 1,
+};
+const GrinderSparksParticles = ({ 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, cfg.seed, cfg.quality]);
+    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 GrinderSparksParticles;