@3driseai/3drise-viewer 0.1.16 → 0.1.18

package/dist/utils/particleTrails.js

@@ -0,0 +1,369 @@
+// Particle trails — the shared trail contract for CPU-simulated particle objects.
+// Three trail types, each an instanced chain of soft sprites (no 1-px GL lines):
+//   streak — motion blur: a straight tail along the current velocity (exposure = trailLength);
+//            only moving particles streak.
+//   comet  — history tails: 10 past positions per particle, kept in 10 instanced attribute slots
+//            (one slot uploaded per sample), joined by Catmull–Rom splines that slide smoothly.
+//   echo   — afterglow: particles shed ghost sprites that keep some of their velocity, spread,
+//            swell and fade (a ring-buffer pool with partial uploads).
+// Every sample's alpha is proportional to its step length along the trail, so slow or still
+// particles never stack sprites into hot spots and brightness per unit length stays even.
+// The component supplies GLSL that defines
+//   vec3 trailShade(vec3 pSim, float f);     // light at a trail sample (f: 0 head .. 1 tail)
+//   vec3 trailView(vec3 mv, out float mag);  // optional view-space warp (e.g. a lens), else identity
+// and shares its uniform object, which must include createTrailUniforms().
+// Every trail has reset(i): call it when particle i teleports (respawn, wrap) so comet history
+// does not draw a line from its old place.
+// Optional opts.k (Float32Array n): a per-particle scalar (heat, emission, alive flag) the GLSL reads
+// as TRAIL_K (1.0 when not given). Echo ghosts keep the value they had when they were shed.
+import * as THREE from 'three';
+/** 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;
+    };
+}
+export const TRAIL_MODES = ['none', 'streak', 'comet', 'echo'];
+const SLOTS = 10;
+const SUB = 4; // default spline samples per comet segment (opts.sub overrides)
+const CAPS = { streak: 40000, comet: 5000, echo: 8000 };
+export function createTrailUniforms() {
+    return {
+        uTrailLength: { value: 1.5 },
+        uTrailOpacity: { value: 0.6 },
+        uTrailColor: { value: new THREE.Color('#ffffff') },
+        uTrailShare: { value: 0.3 },
+        uTrailHead: { value: 0 },
+        uTrailAcc: { value: 0 },
+        uTrailTime: { value: 0 },
+        uVelScale: { value: 1 },
+    };
+}
+export function applyTrailConfig(u, c) {
+    u.uTrailLength.value = c.trailLength;
+    u.uTrailOpacity.value = c.trailOpacity;
+    u.uTrailColor.value.set(c.trailColor);
+    u.uTrailShare.value = c.trailShare;
+}
+/** GUI spec for the trail knobs; `labels` names the three types for this object. */
+export function trailSpec(labels) {
+    return {
+        trailMode: { options: { Off: 'none', [labels.streak]: 'streak', [labels.comet]: 'comet', [labels.echo]: 'echo' } },
+        trailLength: { min: 0.2, max: 6, step: 0.05 },
+        trailOpacity: { min: 0, max: 1, step: 0.01 },
+        trailColor: 'color',
+        trailShare: { min: 0.02, max: 1, step: 0.01 },
+    };
+}
+const HEAD = /* glsl */ `
+uniform float uSize, uViewH, uIntensity, uOpacity;
+uniform float uTrailLength, uTrailOpacity, uTrailAcc, uTrailTime, uVelScale;
+uniform int uTrailHead;
+uniform vec3 uTrailColor;
+varying vec3 vCol;
+varying float vA;
+`;
+const FRAG = /* 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 * 4.0) + 0.25 * exp(-r2 * 1.5)) * (1.0 - r2) * vA;
+  if (a < 0.002) discard;
+  gl_FragColor = vec4(vCol, a);
+}
+`;
+// shared tail of every trail vertex shader: shade, tint toward trailColor, size, project
+function finish(sizePx) {
+    return /* glsl */ `
+  vec3 light = trailShade(p, f);
+  vCol = light * mix(vec3(1.0), uTrailColor * 1.25, smoothstep(0.0, 0.8, f)) * uIntensity;
+  vec4 mvp = modelViewMatrix * vec4(p * uSize, 1.0);
+  float mag;
+  vec3 mv = trailView(mvp.xyz, mag);
+  vCol *= mag;
+  vA = clamp(vA, 0.0, 1.0) * uOpacity * uTrailOpacity;
+  gl_PointSize = clamp(uSize * uViewH * ${sizePx.toFixed(4)} * (1.0 - 0.5 * f) * sqrt(mag) / -mv.z, 1.0, 40.0);
+  gl_Position = projectionMatrix * vec4(mv, 1.0);
+`;
+}
+const K_ON = '#define TRAIL_K aK\nattribute float aK;\n';
+const K_OFF = '#define TRAIL_K 1.0\n';
+function streakShader(glsl, sizePx, spacing, kdef) {
+    const S = 24;
+    return {
+        S,
+        vertex: /* glsl */ `
+${HEAD}
+attribute vec3 aP;
+attribute vec3 aV;
+${kdef}
+${glsl}
+void main() {
+  float f = position.x;                                // 0 head .. 1 tail
+  vec3 dv = aV * uVelScale * uTrailLength;
+  float len = length(dv);
+  vec3 p = aP - dv * f;
+  float stepLen = len / ${(S - 1).toFixed(1)};
+  vA = 1.2 * pow(1.0 - f, 1.4) * clamp(stepLen / ${spacing.toFixed(4)}, 0.0, 1.0) * step(0.001, f);
+  ${finish(sizePx)}
+}
+`,
+    };
+}
+function cometShader(glsl, sizePx, spacing, kdef, SUB) {
+    const slots = Array.from({ length: SLOTS }, (_, i) => `attribute vec3 h${i};`).join('\n');
+    const pick = Array.from({ length: SLOTS }, (_, i) => `  ${i === 0 ? 'if' : 'else if'} (i == ${i}) return h${i};`).join('\n');
+    return /* glsl */ `
+${HEAD}
+attribute vec3 aP;
+${slots}
+${kdef}
+${glsl}
+vec3 slot(int i) {
+${pick}
+  return h${SLOTS - 1};
+}
+// L(0) = live position, L(k) = k-th most recent stored sample
+vec3 L(int k) {
+  if (k <= 0) return aP;
+  int kk = min(k, ${SLOTS});
+  return slot(int(mod(float(uTrailHead - (kk - 1) + ${SLOTS * 2}), ${SLOTS.toFixed(1)})));
+}
+vec3 catmull(vec3 a, vec3 b, vec3 c, vec3 d, float t) {
+  float t2 = t * t, t3 = t2 * t;
+  return 0.5 * ((2.0 * b) + (-a + c) * t + (2.0 * a - 5.0 * b + 4.0 * c - d) * t2 + (-a + 3.0 * b - 3.0 * c + d) * t3);
+}
+void main() {
+  float s = position.x;                                // 0 .. ${SLOTS} along the chain
+  int k = int(floor(s));
+  float t = s - float(k);
+  vec3 p0 = L(k - 1), p1 = L(k), p2 = L(k + 1), p3 = L(k + 2);
+  vec3 p = catmull(p0, p1, p2, p3, t);
+  float dt = uTrailLength / ${(SLOTS - 1).toFixed(1)};
+  float age = s < 1.0 ? s * uTrailAcc : uTrailAcc + (s - 1.0) * dt;
+  float f = clamp(age / uTrailLength, 0.0, 1.0);
+  float stepLen = length(p2 - p1) / ${SUB.toFixed(1)};
+  vA = pow(1.0 - f, 1.3) * clamp(stepLen / ${spacing.toFixed(4)}, 0.0, 1.0) * step(0.0001, s);
+  ${finish(sizePx)}
+}
+`;
+}
+function echoShader(glsl, sizePx, kdef) {
+    return /* glsl */ `
+${HEAD}
+attribute vec4 aE0; // emitted position xyz, birth time
+attribute vec4 aE1; // emitter velocity xyz, seed
+${kdef}
+${glsl}
+void main() {
+  float age = uTrailTime - aE0.w;
+  float f = age / max(uTrailLength, 1e-3);
+  vec3 dir = normalize(vec3(fract(aE1.w * 13.7), fract(aE1.w * 71.3), fract(aE1.w * 37.9)) - 0.5 + 1e-3);
+  // ghosts keep a decaying share of the emitter's velocity and diffuse (spread ~ sqrt(age))
+  float carry = (1.0 - exp(-age * 1.5)) / 1.5;
+  vec3 p = aE0.xyz + aE1.xyz * uVelScale * carry * 0.6 + dir * 0.03 * sqrt(max(age, 0.0)) * uTrailLength;
+  vA = (f < 0.0 || f > 1.0) ? 0.0 : smoothstep(0.0, 0.08, f) * pow(1.0 - f, 2.0) * 0.55;
+  f = clamp(f, 0.0, 1.0);
+  ${finish(sizePx * 1.4).replace('(1.0 - 0.5 * f)', '(1.0 + 1.2 * f)')}
+}
+`;
+}
+/**
+ * Build a trail for a CPU particle set.
+ * opts: { u, n, pos (Float32Array n*3, sim units), vel (Float32Array n*3), glsl, sizePx, spacing }
+ * `vel` is in sim units per sim-time unit; the component keeps u.uVelScale = sim-time per real second.
+ */
+export function createCpuTrail(mode, opts) {
+    if (!mode || mode === 'none')
+        return null;
+    const { u, n, pos, vel, glsl } = opts;
+    const kArr = opts.k || null;
+    const kdef = kArr ? K_ON : K_OFF;
+    const sizePx = opts.sizePx ?? 0.006;
+    const spacing = opts.spacing ?? 0.004;
+    const nSub = Math.max(1, Math.min(CAPS[mode], Math.round(n * Math.min(Math.max(u.uTrailShare.value, 0), 1))));
+    const object = new THREE.Group();
+    const materials = [];
+    const geos = [];
+    const mk = (vertexShader) => {
+        const m = new THREE.ShaderMaterial({
+            uniforms: u, vertexShader, fragmentShader: FRAG,
+            transparent: true, depthWrite: false, blending: THREE.AdditiveBlending,
+        });
+        materials.push(m);
+        return m;
+    };
+    if (mode === 'streak') {
+        const sh = streakShader(glsl, sizePx, spacing, kdef);
+        const g = new THREE.InstancedBufferGeometry();
+        const tpl = new Float32Array(sh.S * 3);
+        for (let i = 0; i < sh.S; i++)
+            tpl[i * 3] = i / (sh.S - 1);
+        g.setAttribute('position', new THREE.BufferAttribute(tpl, 3));
+        const aP = new THREE.InstancedBufferAttribute(pos, 3).setUsage(THREE.DynamicDrawUsage);
+        const aV = new THREE.InstancedBufferAttribute(vel, 3).setUsage(THREE.DynamicDrawUsage);
+        g.setAttribute('aP', aP);
+        g.setAttribute('aV', aV);
+        const aK = kArr ? new THREE.InstancedBufferAttribute(kArr, 1).setUsage(THREE.DynamicDrawUsage) : null;
+        if (aK)
+            g.setAttribute('aK', aK);
+        g.instanceCount = nSub;
+        geos.push(g);
+        const pts = new THREE.Points(g, mk(sh.vertex));
+        pts.frustumCulled = false;
+        object.add(pts);
+        return {
+            object, materials, nSub,
+            reset() { },
+            update() { aP.needsUpdate = true; aV.needsUpdate = true; if (aK)
+                aK.needsUpdate = true; },
+            dispose() { geos.forEach((x) => x.dispose()); materials.forEach((x) => x.dispose()); },
+        };
+    }
+    if (mode === 'comet') {
+        const g = new THREE.InstancedBufferGeometry();
+        const SUBn = opts.sub || SUB; // spline samples per history segment (fast particles need more)
+        const M = SLOTS * SUBn + 1;
+        const tpl = new Float32Array(M * 3);
+        for (let i = 0; i < M; i++)
+            tpl[i * 3] = i / SUBn;
+        g.setAttribute('position', new THREE.BufferAttribute(tpl, 3));
+        const aP = new THREE.InstancedBufferAttribute(pos, 3).setUsage(THREE.DynamicDrawUsage);
+        g.setAttribute('aP', aP);
+        const aK = kArr ? new THREE.InstancedBufferAttribute(kArr, 1).setUsage(THREE.DynamicDrawUsage) : null;
+        if (aK)
+            g.setAttribute('aK', aK);
+        const slots = [];
+        for (let s = 0; s < SLOTS; s++) {
+            const arr = new Float32Array(nSub * 3);
+            arr.set(pos.subarray(0, nSub * 3));
+            const at = new THREE.InstancedBufferAttribute(arr, 3).setUsage(THREE.DynamicDrawUsage);
+            g.setAttribute('h' + s, at);
+            slots.push(at);
+        }
+        g.instanceCount = nSub;
+        geos.push(g);
+        const pts = new THREE.Points(g, mk(cometShader(glsl, sizePx, spacing, kdef, SUBn)));
+        pts.frustumCulled = false;
+        object.add(pts);
+        let head = 0, acc = 0, dirtyReset = false;
+        return {
+            object, materials, nSub,
+            // a particle that was recycled (respawned elsewhere) starts a fresh history
+            reset(i) {
+                if (i >= nSub)
+                    return;
+                const x = pos[i * 3], y = pos[i * 3 + 1], z = pos[i * 3 + 2];
+                for (let s = 0; s < SLOTS; s++) {
+                    const a = slots[s].array;
+                    a[i * 3] = x;
+                    a[i * 3 + 1] = y;
+                    a[i * 3 + 2] = z;
+                }
+                dirtyReset = true;
+            },
+            update(dt) {
+                aP.needsUpdate = true;
+                if (aK)
+                    aK.needsUpdate = true;
+                if (dirtyReset) {
+                    for (let s = 0; s < SLOTS; s++)
+                        slots[s].needsUpdate = true;
+                    dirtyReset = false;
+                }
+                const interval = Math.max(u.uTrailLength.value, 0.05) / (SLOTS - 1);
+                acc += dt;
+                if (acc >= interval) {
+                    acc = Math.min(acc - interval, interval);
+                    head = (head + 1) % SLOTS;
+                    slots[head].array.set(pos.subarray(0, nSub * 3));
+                    slots[head].needsUpdate = true;
+                }
+                u.uTrailHead.value = head;
+                u.uTrailAcc.value = acc;
+            },
+            dispose() { geos.forEach((x) => x.dispose()); materials.forEach((x) => x.dispose()); },
+        };
+    }
+    // echo
+    const P = nSub * 6;
+    const e0 = new Float32Array(P * 4);
+    const e1 = new Float32Array(P * 4);
+    const rng = mulberry32(0xec40);
+    for (let i = 0; i < P; i++) {
+        e0[i * 4 + 3] = -1e9;
+        e1[i * 4 + 3] = rng();
+    }
+    const g = new THREE.BufferGeometry();
+    g.setAttribute('position', new THREE.BufferAttribute(new Float32Array(P * 3), 3));
+    const a0 = new THREE.BufferAttribute(e0, 4).setUsage(THREE.DynamicDrawUsage);
+    const a1 = new THREE.BufferAttribute(e1, 4).setUsage(THREE.DynamicDrawUsage);
+    g.setAttribute('aE0', a0);
+    g.setAttribute('aE1', a1);
+    const eK = kArr ? new Float32Array(P) : null;
+    const a2 = eK ? new THREE.BufferAttribute(eK, 1).setUsage(THREE.DynamicDrawUsage) : null;
+    if (a2)
+        g.setAttribute('aK', a2);
+    geos.push(g);
+    const pts = new THREE.Points(g, mk(echoShader(glsl, sizePx, kdef)));
+    pts.frustumCulled = false;
+    object.add(pts);
+    let write = 0, src = 0, emitAcc = 0;
+    return {
+        object, materials, nSub,
+        reset() { },
+        update(dt) {
+            u.uTrailTime.value += dt;
+            const t = u.uTrailTime.value;
+            // each tracked particle sheds a ghost every trailLength / 6
+            emitAcc += (dt * nSub * 6) / Math.max(u.uTrailLength.value, 0.05);
+            let k = Math.min(Math.floor(emitAcc), P);
+            emitAcc -= k;
+            if (k <= 0)
+                return;
+            const start = write;
+            for (let q = 0; q < k; q++) {
+                const w = write * 4, s = src * 3;
+                e0[w] = pos[s];
+                e0[w + 1] = pos[s + 1];
+                e0[w + 2] = pos[s + 2];
+                e0[w + 3] = t;
+                e1[w] = vel[s];
+                e1[w + 1] = vel[s + 1];
+                e1[w + 2] = vel[s + 2];
+                if (eK)
+                    eK[write] = kArr[src];
+                write = (write + 1) % P;
+                src = (src + 1) % nSub;
+            }
+            // partial uploads (two ranges when the ring wraps)
+            const first = Math.min(k, P - start);
+            a0.clearUpdateRanges();
+            a1.clearUpdateRanges();
+            a0.addUpdateRange(start * 4, first * 4);
+            a1.addUpdateRange(start * 4, first * 4);
+            if (k > first) {
+                a0.addUpdateRange(0, (k - first) * 4);
+                a1.addUpdateRange(0, (k - first) * 4);
+            }
+            a0.needsUpdate = true;
+            a1.needsUpdate = true;
+            if (a2) {
+                a2.clearUpdateRanges();
+                a2.addUpdateRange(start, first);
+                if (k > first)
+                    a2.addUpdateRange(0, k - first);
+                a2.needsUpdate = true;
+            }
+        },
+        dispose() { geos.forEach((x) => x.dispose()); materials.forEach((x) => x.dispose()); },
+    };
+}

package/dist/utils/pointerField.d.ts

@@ -0,0 +1,28 @@
+import * as THREE from 'three';
+export declare const POINTER_IDLE = 1.4;
+export interface PointerUniforms {
+    uPointer: THREE.IUniform<THREE.Vector3>;
+    uPointerVel: THREE.IUniform<THREE.Vector3>;
+    uPointerActive: THREE.IUniform<number>;
+    /** Optional: the component's mode index; -1 means off. */
+    uPointerMode?: THREE.IUniform<number>;
+}
+export declare function createPointerUniforms(): PointerUniforms;
+export interface PointerState {
+    ndc: THREE.Vector2;
+    inside: boolean;
+    lastMove: number;
+    clock: number;
+    fresh: boolean;
+    raw: THREE.Vector3;
+    prevRaw: THREE.Vector3;
+}
+export declare function createPointerState(): PointerState;
+/** Wire DOM pointer events into a pointer state. Read-only: never prevents or stops anything. */
+export declare function bindPointer(el: HTMLElement, s: PointerState): () => void;
+/** One pointer state per component, bound to the R3F event source (falls back to the canvas). */
+export declare function usePointerField(): PointerState;
+/** Advance the pointer uniforms by dt. `anchor` (sim units) is where the interaction plane passes;
+ *  `normal` (object-local) pins the plane's orientation (e.g. a water surface) instead of facing the camera. */
+export declare function stepPointerField(u: PointerUniforms, s: PointerState, camera: THREE.Camera, object: THREE.Object3D, size: number, dt: number, anchor?: THREE.Vector3, normal?: THREE.Vector3): void;
+//# sourceMappingURL=pointerField.d.ts.map

package/dist/utils/pointerField.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pointerField.d.ts","sourceRoot":"","sources":["../../src/utils/pointerField.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,eAAO,MAAM,YAAY,MAAM,CAAC;AAEhC,MAAM,WAAW,eAAe;IAC5B,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IACxC,WAAW,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IAC3C,cAAc,EAAE,KAAK,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;IACvC,0DAA0D;IAC1D,YAAY,CAAC,EAAE,KAAK,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;CACzC;AAED,wBAAgB,qBAAqB,IAAI,eAAe,CAMvD;AAED,MAAM,WAAW,YAAY;IACzB,GAAG,EAAE,KAAK,CAAC,OAAO,CAAC;IACnB,MAAM,EAAE,OAAO,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,OAAO,CAAC;IACf,GAAG,EAAE,KAAK,CAAC,OAAO,CAAC;IACnB,OAAO,EAAE,KAAK,CAAC,OAAO,CAAC;CAC1B;AAED,wBAAgB,kBAAkB,IAAI,YAAY,CAEjD;AAED,iGAAiG;AACjG,wBAAgB,WAAW,CAAC,EAAE,EAAE,WAAW,EAAE,CAAC,EAAE,YAAY,GAAG,MAAM,IAAI,CAmBxE;AAED,iGAAiG;AACjG,wBAAgB,eAAe,IAAI,YAAY,CAM9C;AASD;gHACgH;AAChH,wBAAgB,gBAAgB,CAC5B,CAAC,EAAE,eAAe,EAAE,CAAC,EAAE,YAAY,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,QAAQ,EACjF,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,KAAK,CAAC,OAAO,EAAE,MAAM,CAAC,EAAE,KAAK,CAAC,OAAO,GACzE,IAAI,CA8BN"}

package/dist/utils/pointerField.js

@@ -0,0 +1,103 @@
+// Pointer field — the shared mouse contract every generative particle object uses.
+// The pointer is projected onto the plane through an anchor of the object that faces the camera
+// and expressed in the component's sim units (object-local / size). Components read
+//   uPointer (vec3, sim units), uPointerVel (vec3, sim units per second, smoothed),
+//   uPointerActive (0..1, eases in on movement, fades after POINTER_IDLE s of stillness or on leave)
+// and decide themselves what the cursor is physically. pointerMode 'none' maps to uPointerMode = -1:
+// the cursor then does nothing and costs nothing. See the 3drise-particles skill.
+import { useEffect, useMemo } from 'react';
+import { useThree } from '@react-three/fiber';
+import * as THREE from 'three';
+export const POINTER_IDLE = 1.4;
+export function createPointerUniforms() {
+    return {
+        uPointer: { value: new THREE.Vector3() },
+        uPointerVel: { value: new THREE.Vector3() },
+        uPointerActive: { value: 0 },
+    };
+}
+export function createPointerState() {
+    return { ndc: new THREE.Vector2(), inside: false, lastMove: -1e9, clock: 0, fresh: true, raw: new THREE.Vector3(), prevRaw: new THREE.Vector3() };
+}
+/** Wire DOM pointer events into a pointer state. Read-only: never prevents or stops anything. */
+export function bindPointer(el, s) {
+    const move = (e) => {
+        const r = el.getBoundingClientRect();
+        s.ndc.set(((e.clientX - r.left) / r.width) * 2 - 1, -((e.clientY - r.top) / r.height) * 2 + 1);
+        if (!s.inside)
+            s.fresh = true;
+        s.inside = true;
+        s.lastMove = s.clock;
+    };
+    const leave = () => { s.inside = false; };
+    el.addEventListener('pointermove', move, { passive: true });
+    el.addEventListener('pointerdown', move, { passive: true });
+    el.addEventListener('pointerleave', leave);
+    el.addEventListener('pointercancel', leave);
+    return () => {
+        el.removeEventListener('pointermove', move);
+        el.removeEventListener('pointerdown', move);
+        el.removeEventListener('pointerleave', leave);
+        el.removeEventListener('pointercancel', leave);
+    };
+}
+/** One pointer state per component, bound to the R3F event source (falls back to the canvas). */
+export function usePointerField() {
+    const gl = useThree((st) => st.gl);
+    const connected = useThree((st) => st.events.connected);
+    const state = useMemo(createPointerState, []);
+    useEffect(() => bindPointer(connected ?? gl.domElement, state), [gl, connected, state]);
+    return state;
+}
+const _ray = new THREE.Raycaster();
+const _plane = new THREE.Plane();
+const _n = new THREE.Vector3();
+const _c = new THREE.Vector3();
+const _hit = new THREE.Vector3();
+const _v = new THREE.Vector3();
+/** Advance the pointer uniforms by dt. `anchor` (sim units) is where the interaction plane passes;
+ *  `normal` (object-local) pins the plane's orientation (e.g. a water surface) instead of facing the camera. */
+export function stepPointerField(u, s, camera, object, size, dt, anchor, normal) {
+    s.clock += dt;
+    if (u.uPointerMode && u.uPointerMode.value < 0) {
+        u.uPointerActive.value = 0;
+        u.uPointerVel.value.set(0, 0, 0);
+        return;
+    }
+    const active = s.inside && s.clock - s.lastMove < POINTER_IDLE ? 1 : 0;
+    const rate = active > u.uPointerActive.value ? 6 : 1.5;
+    u.uPointerActive.value += (active - u.uPointerActive.value) * Math.min(1, dt * rate);
+    if (!s.inside) {
+        u.uPointerVel.value.multiplyScalar(Math.max(0, 1 - dt * 4));
+        return;
+    }
+    object.updateWorldMatrix(true, false);
+    if (anchor)
+        object.localToWorld(_c.copy(anchor).multiplyScalar(size));
+    else
+        object.getWorldPosition(_c);
+    if (normal)
+        _n.copy(normal).transformDirection(object.matrixWorld);
+    else
+        camera.getWorldDirection(_n);
+    _plane.setFromNormalAndCoplanarPoint(_n, _c);
+    _ray.setFromCamera(s.ndc, camera);
+    if (!_ray.ray.intersectPlane(_plane, _hit))
+        return;
+    object.worldToLocal(_hit);
+    _hit.divideScalar(Math.max(size, 1e-4));
+    if (s.fresh) {
+        s.prevRaw.copy(_hit);
+        u.uPointer.value.copy(_hit);
+        s.fresh = false;
+    }
+    s.raw.copy(_hit);
+    if (dt > 0) {
+        _v.copy(s.raw).sub(s.prevRaw).divideScalar(dt);
+        if (_v.length() > 8)
+            _v.setLength(8);
+        u.uPointerVel.value.lerp(_v, Math.min(1, dt / 0.08));
+    }
+    s.prevRaw.copy(s.raw);
+    u.uPointer.value.lerp(s.raw, Math.min(1, dt / 0.05));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@3driseai/3drise-viewer",
-  "version": "0.1.16",
+  "version": "0.1.18",
   "private": false,
   "type": "module",
   "main": "./dist/index.js",
@@ -39,6 +39,6 @@
   },
   "dependencies": {
     "@3driseai/3drise-common": "^1.0.1",
-    "@3driseai/3drise-core": "^1.0.10"
+    "@3driseai/3drise-core": "^1.0.12"
   }
 }