@3driseai/3drise-viewer 0.1.1

package/dist/components/cursor/CometCursor.js

@@ -0,0 +1,191 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useMemo, useRef } from 'react';
+import { useFrame } from '@react-three/fiber';
+import * as THREE from 'three';
+const MAX_TRAIL = 1500;
+const vertexShader = /* glsl */ `
+  attribute float aIndex;
+  uniform float uSize;
+  uniform float uTrailLength;
+  varying float vFrac;
+  void main() {
+    vFrac = clamp(aIndex / max(uTrailLength, 1.0), 0.0, 1.0);
+    vec4 mv = modelViewMatrix * vec4(position, 1.0);
+    // Newest point (aIndex=0) is largest; oldest (aIndex≈trailLength) smallest
+    float size = uSize * (1.0 - vFrac * 0.85);
+    gl_PointSize = size * (300.0 / -mv.z);
+    gl_Position = projectionMatrix * mv;
+  }
+`;
+const fragmentShader = /* glsl */ `
+  uniform vec3 uHead;
+  uniform vec3 uTail;
+  uniform float uOpacity;
+  uniform float uIntensity;
+  varying float vFrac;
+  void main() {
+    vec2 c = gl_PointCoord * 2.0 - 1.0;
+    float dist = length(c);
+    if (dist > 1.0) discard;
+    float core = 1.0 - smoothstep(0.0, 1.0, dist);
+    vec3 col = mix(uHead, uTail, vFrac) * (1.0 + uIntensity * 0.8);
+    float fade = (1.0 - vFrac);
+    float alpha = core * fade * uOpacity;
+    if (alpha < 0.003) discard;
+    gl_FragColor = vec4(col, alpha);
+  }
+`;
+const impactFrag = /* glsl */ `
+  uniform vec3 uColor;
+  uniform float uOpacity;
+  varying vec2 vUv;
+  void main() {
+    vec2 c = vUv * 2.0 - 1.0;
+    float dist = length(c);
+    if (dist > 1.0) discard;
+    // Bright core + soft falloff
+    float core = pow(1.0 - dist, 2.0);
+    float ring = smoothstep(0.55, 0.75, dist) * smoothstep(1.0, 0.78, dist);
+    float alpha = (core * 0.9 + ring * 0.6) * uOpacity;
+    if (alpha < 0.003) discard;
+    vec3 col = uColor * (1.0 + core * 1.2);
+    gl_FragColor = vec4(col, alpha);
+  }
+`;
+const impactVert = /* glsl */ `
+  varying vec2 vUv;
+  void main() {
+    vUv = uv;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+  }
+`;
+const CometCursor = ({ config, worldPosRef, hoverRef, idleMsRef, }) => {
+    // Packed newest-first layout: slot 0 = newest, slot count-1 = oldest.
+    const positions = useMemo(() => new Float32Array(MAX_TRAIL * 3), []);
+    const indices = useMemo(() => {
+        const arr = new Float32Array(MAX_TRAIL);
+        for (let i = 0; i < MAX_TRAIL; i++)
+            arr[i] = i;
+        return arr;
+    }, []);
+    const geometry = useMemo(() => {
+        const g = new THREE.BufferGeometry();
+        g.setAttribute('position', new THREE.BufferAttribute(positions, 3));
+        g.setAttribute('aIndex', new THREE.BufferAttribute(indices, 1));
+        g.setDrawRange(0, 0);
+        return g;
+    }, [positions, indices]);
+    const material = useMemo(() => {
+        const head = new THREE.Color(config.color);
+        const tail = head.clone().multiplyScalar(0.3);
+        return new THREE.ShaderMaterial({
+            uniforms: {
+                uSize: { value: config.scale * 0.8 },
+                uTrailLength: { value: config.trailLength },
+                uHead: { value: new THREE.Vector3(head.r, head.g, head.b) },
+                uTail: { value: new THREE.Vector3(tail.r, tail.g, tail.b) },
+                uOpacity: { value: config.opacity },
+                uIntensity: { value: config.intensity },
+            },
+            vertexShader,
+            fragmentShader,
+            transparent: true,
+            depthWrite: false,
+            blending: THREE.AdditiveBlending,
+        });
+    }, []);
+    useEffect(() => {
+        const head = new THREE.Color(config.color);
+        const tail = head.clone().multiplyScalar(0.3);
+        material.uniforms.uHead.value.set(head.r, head.g, head.b);
+        material.uniforms.uTail.value.set(tail.r, tail.g, tail.b);
+        material.uniforms.uSize.value = config.scale * 0.8;
+        material.uniforms.uTrailLength.value = config.trailLength;
+        material.uniforms.uOpacity.value = config.opacity;
+        material.uniforms.uIntensity.value = config.intensity;
+    }, [config.color, config.scale, config.trailLength, config.opacity, config.intensity, material]);
+    // Impact glow at hovered surface — billboarded plane with additive shader
+    const impactRef = useRef(null);
+    const impactGeom = useMemo(() => new THREE.PlaneGeometry(1, 1), []);
+    const impactMat = useMemo(() => new THREE.ShaderMaterial({
+        uniforms: {
+            uColor: { value: new THREE.Color(config.color) },
+            uOpacity: { value: 0 },
+        },
+        vertexShader: impactVert,
+        fragmentShader: impactFrag,
+        transparent: true,
+        depthWrite: false,
+        blending: THREE.AdditiveBlending,
+    }), []);
+    useEffect(() => {
+        impactMat.uniforms.uColor.value.set(config.color);
+    }, [config.color, impactMat]);
+    useEffect(() => () => {
+        geometry.dispose();
+        material.dispose();
+        impactGeom.dispose();
+        impactMat.dispose();
+    }, [geometry, material, impactGeom, impactMat]);
+    const impactOpacity = useRef(0);
+    const countRef = useRef(0);
+    const lastPos = useRef(new THREE.Vector3());
+    const firstFrame = useRef(true);
+    useFrame((state, delta) => {
+        const wp = worldPosRef.current;
+        if (firstFrame.current) {
+            lastPos.current.copy(wp);
+            firstFrame.current = false;
+        }
+        const target = Math.min(config.trailLength, MAX_TRAIL, config.particleCount);
+        // Push new samples by interpolating between lastPos and current pos
+        const moved = wp.distanceTo(lastPos.current);
+        const steps = Math.max(1, Math.min(8, Math.ceil(moved / 0.05)));
+        for (let s = 1; s <= steps; s++) {
+            const t = s / steps;
+            const nx = THREE.MathUtils.lerp(lastPos.current.x, wp.x, t);
+            const ny = THREE.MathUtils.lerp(lastPos.current.y, wp.y, t);
+            const nz = THREE.MathUtils.lerp(lastPos.current.z, wp.z, t);
+            // Shift the packed buffer down by one slot (3 floats)
+            // copyWithin(targetStart, srcStart, srcEnd) — exclusive end
+            const live = Math.min(countRef.current, target - 1);
+            if (live > 0) {
+                positions.copyWithin(3, 0, live * 3);
+            }
+            positions[0] = nx;
+            positions[1] = ny;
+            positions[2] = nz;
+            countRef.current = Math.min(countRef.current + 1, target);
+        }
+        lastPos.current.copy(wp);
+        geometry.setDrawRange(0, countRef.current);
+        geometry.attributes.position.needsUpdate = true;
+        const idleFactor = Math.max(0, 1 - idleMsRef.current / Math.max(config.idleFadeMs, 1));
+        const hover = hoverRef.current;
+        // Boost head intensity when hovering an object.
+        material.uniforms.uIntensity.value = config.intensity * (hover ? 1.6 : 1.0);
+        material.uniforms.uOpacity.value = config.opacity * (0.5 + 0.5 * idleFactor);
+        // Impact glow follows hover hit point; smooth fade-in/out.
+        const impact = impactRef.current;
+        if (impact) {
+            const targetOpacity = hover ? config.opacity : 0;
+            impactOpacity.current = THREE.MathUtils.damp(impactOpacity.current, targetOpacity, 12, delta);
+            impactMat.uniforms.uOpacity.value = impactOpacity.current;
+            if (hover) {
+                impact.position.copy(hover.point);
+                // Offset slightly along the surface normal so it doesn't z-fight.
+                const n = hover.face?.normal;
+                if (n)
+                    impact.position.addScaledVector(n, 0.01);
+            }
+            // Always billboard to camera + scale with config + soft pulse.
+            impact.quaternion.copy(state.camera.quaternion);
+            const pulse = 1 + Math.sin(state.clock.getElapsedTime() * 6) * 0.08;
+            const s = config.scale * 0.6 * pulse;
+            impact.scale.setScalar(s);
+            impact.visible = impactOpacity.current > 0.005;
+        }
+    });
+    return (_jsxs(_Fragment, { children: [_jsx("points", { geometry: geometry, material: material, frustumCulled: false }), _jsx("mesh", { ref: impactRef, geometry: impactGeom, material: impactMat, visible: false })] }));
+};
+export default CometCursor;

package/dist/components/cursor/CrosshairCursor.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+import type { CrosshairCursorConfig } from "@3driseai/3drise-core";
+import type { CursorTypeProps } from "./CursorController";
+declare const CrosshairCursor: React.FC<CursorTypeProps<CrosshairCursorConfig>>;
+export default CrosshairCursor;
+//# sourceMappingURL=CrosshairCursor.d.ts.map

package/dist/components/cursor/CrosshairCursor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CrosshairCursor.d.ts","sourceRoot":"","sources":["../../../src/components/cursor/CrosshairCursor.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AACnE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAe1D,QAAA,MAAM,eAAe,EAAE,KAAK,CAAC,EAAE,CAAC,eAAe,CAAC,qBAAqB,CAAC,CA2HrE,CAAC;AACF,eAAe,eAAe,CAAC"}

package/dist/components/cursor/CrosshairCursor.js

@@ -0,0 +1,142 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useEffect, useMemo, useRef } from 'react';
+import { useFrame } from '@react-three/fiber';
+import * as THREE from 'three';
+function hasValidPositions(geo) {
+    const pos = geo.getAttribute('position');
+    if (!pos || pos.count === 0)
+        return false;
+    const arr = pos.array;
+    // Sample a few values — full scan would be wasteful for big meshes.
+    const samples = Math.min(arr.length, 30);
+    for (let i = 0; i < samples; i++) {
+        if (!Number.isFinite(arr[i]))
+            return false;
+    }
+    return true;
+}
+const CrosshairCursor = ({ config, worldPosRef, hoverRef, idleMsRef, }) => {
+    // Billboarded reticle group (ring + ticks)
+    const reticleRef = useRef(null);
+    const ringRef = useRef(null);
+    // World-space outline group (NOT billboarded) for the hovered object outline
+    const outlineGroupRef = useRef(null);
+    const outlineRef = useRef(null);
+    const ringGeom = useMemo(() => new THREE.RingGeometry(0.35, 0.42, 32), []);
+    const ringMat = useMemo(() => new THREE.MeshBasicMaterial({
+        color: config.color,
+        transparent: true,
+        opacity: config.opacity,
+        side: THREE.DoubleSide,
+        depthWrite: false,
+    }), [config.color, config.opacity]);
+    const tickGeom = useMemo(() => {
+        const g = new THREE.BufferGeometry();
+        const r1 = 0.5, r2 = 0.7;
+        const verts = new Float32Array([
+            r1, 0, 0, r2, 0, 0,
+            -r1, 0, 0, -r2, 0, 0,
+            0, r1, 0, 0, r2, 0,
+            0, -r1, 0, 0, -r2, 0,
+        ]);
+        g.setAttribute('position', new THREE.BufferAttribute(verts, 3));
+        return g;
+    }, []);
+    const tickMat = useMemo(() => new THREE.LineBasicMaterial({
+        color: config.color,
+        transparent: true,
+        opacity: config.opacity,
+        depthWrite: false,
+    }), [config.color, config.opacity]);
+    const outlineMat = useMemo(() => new THREE.LineBasicMaterial({
+        color: config.outlineColor,
+        transparent: true,
+        opacity: 0.85,
+        depthTest: false,
+    }), [config.outlineColor]);
+    const outlineGeomRef = useRef(null);
+    const lastHoveredRef = useRef(null);
+    useEffect(() => () => {
+        ringGeom.dispose();
+        ringMat.dispose();
+        tickGeom.dispose();
+        tickMat.dispose();
+        outlineMat.dispose();
+        outlineGeomRef.current?.dispose();
+    }, [ringGeom, ringMat, tickGeom, tickMat, outlineMat]);
+    useFrame((state) => {
+        const reticle = reticleRef.current;
+        const outlineGroup = outlineGroupRef.current;
+        if (!reticle || !outlineGroup)
+            return;
+        const hover = hoverRef.current;
+        // Only treat actual meshes with valid geometry as hover targets for outline.
+        const validMesh = hover && hover.object instanceof THREE.Mesh && hover.object.geometry
+            ? hover.object
+            : null;
+        // Reticle position: snap to the bounding-box center of the hovered MESH
+        // (so we don't snap to a parent Group origin), otherwise follow the cursor.
+        let targetPos;
+        if (validMesh) {
+            const box = new THREE.Box3().setFromObject(validMesh);
+            targetPos = box.isEmpty() ? worldPosRef.current : box.getCenter(new THREE.Vector3());
+        }
+        else {
+            targetPos = worldPosRef.current;
+        }
+        reticle.position.lerp(targetPos, 0.35);
+        reticle.scale.setScalar(config.scale);
+        // Billboard reticle to camera
+        reticle.quaternion.copy(state.camera.quaternion);
+        // Spin ring
+        const t = state.clock.getElapsedTime();
+        if (ringRef.current)
+            ringRef.current.rotation.z = t * 1.2;
+        // Outline: separate world-space group, NOT billboarded.
+        // Rebuild only when the hovered object identity changes.
+        if (validMesh !== lastHoveredRef.current) {
+            lastHoveredRef.current = validMesh;
+            // Dispose previous outline geometry; the LineSegments object stays.
+            outlineGeomRef.current?.dispose();
+            outlineGeomRef.current = null;
+            if (validMesh && outlineRef.current) {
+                const srcGeo = validMesh.geometry;
+                if (hasValidPositions(srcGeo)) {
+                    try {
+                        const edges = new THREE.EdgesGeometry(srcGeo, 30);
+                        // Defensive: verify the resulting edges geometry isn't degenerate.
+                        if (hasValidPositions(edges)) {
+                            outlineGeomRef.current = edges;
+                            outlineRef.current.geometry = edges;
+                        }
+                        else {
+                            edges.dispose();
+                        }
+                    }
+                    catch {
+                        // Some geometries (skinned, instanced without positions, etc.) can throw.
+                        // Silently skip the outline.
+                    }
+                }
+            }
+        }
+        // Each frame, copy the hovered mesh's world transform onto the outline group
+        // so the outline stays attached even if the object moves.
+        if (validMesh && outlineGeomRef.current && outlineRef.current) {
+            validMesh.updateWorldMatrix(true, false);
+            outlineGroup.position.setFromMatrixPosition(validMesh.matrixWorld);
+            outlineGroup.quaternion.setFromRotationMatrix(validMesh.matrixWorld);
+            outlineGroup.scale.setFromMatrixScale(validMesh.matrixWorld);
+            outlineRef.current.visible = true;
+        }
+        else if (outlineRef.current) {
+            outlineRef.current.visible = false;
+        }
+        // Idle fade on the reticle (not the outline — outline reads object presence, not idle).
+        const idleFactor = Math.max(0, 1 - idleMsRef.current / Math.max(config.idleFadeMs, 1));
+        ringMat.opacity = config.opacity * (0.4 + 0.6 * idleFactor);
+        tickMat.opacity = config.opacity * (0.4 + 0.6 * idleFactor);
+    });
+    return (_jsxs(_Fragment, { children: [_jsxs("group", { ref: reticleRef, children: [_jsx("mesh", { ref: ringRef, geometry: ringGeom, material: ringMat }), _jsx("lineSegments", { geometry: tickGeom, material: tickMat })] }), _jsx("group", { ref: outlineGroupRef, children: _jsx("lineSegments", { ref: outlineRef, material: outlineMat, visible: false }) })] }));
+};
+export default CrosshairCursor;

package/dist/components/cursor/CursorActions.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import type { ClickActionConfig } from "@3driseai/3drise-core";
+export interface CursorActionsProps {
+    clickActions?: ClickActionConfig[];
+}
+declare const CursorActions: React.FC<CursorActionsProps>;
+export default CursorActions;
+//# sourceMappingURL=CursorActions.d.ts.map

package/dist/components/cursor/CursorActions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CursorActions.d.ts","sourceRoot":"","sources":["../../../src/components/cursor/CursorActions.tsx"],"names":[],"mappings":"AAAA,OAAO,KAA4B,MAAM,OAAO,CAAC;AAYjD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC/D,MAAM,WAAW,kBAAkB;IAC/B,YAAY,CAAC,EAAE,iBAAiB,EAAE,CAAC;CACtC;AAWD,QAAA,MAAM,aAAa,EAAE,KAAK,CAAC,EAAE,CAAC,kBAAkB,CAqG/C,CAAC;AACF,eAAe,aAAa,CAAC"}

package/dist/components/cursor/CursorActions.js

@@ -0,0 +1,124 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import React, { useEffect, useRef } from 'react';
+import { useFrame, useThree } from '@react-three/fiber';
+import * as THREE from 'three';
+import ShockwaveAction from './clickActions/ShockwaveAction.js';
+import SparklesBurstAction from './clickActions/SparklesBurstAction.js';
+import BoltFlashAction from './clickActions/BoltFlashAction.js';
+import PlasmaBombAction from './clickActions/PlasmaBombAction.js';
+import RealityTearAction from './clickActions/RealityTearAction.js';
+import ImplosionAction from './clickActions/ImplosionAction.js';
+import VoronoiFractureAction from './clickActions/VoronoiFractureAction.js';
+import PhaseShiftAction from './clickActions/PhaseShiftAction.js';
+import GlyphInscriptionAction from './clickActions/GlyphInscriptionAction.js';
+// Fixed distance in front of the camera at which clicks are spawned, in world
+// units. The action's `config.scale` is the world-size at this distance, so
+// apparent screen size is stable. Tune here if needed.
+const CLICK_PLANE_DISTANCE = 8;
+// Half-height (world units) at CLICK_PLANE_DISTANCE — used when the camera is
+// orthographic (no fov) as a sensible fallback.
+const ORTHO_FALLBACK_HALF_HEIGHT = CLICK_PLANE_DISTANCE * 0.5;
+let clickIdCounter = 0;
+const CursorActions = ({ clickActions = [] }) => {
+    const { camera, gl } = useThree();
+    // Group that mirrors the camera each frame so any child rendered inside it
+    // appears at a fixed offset from the camera in world space — i.e., as if it
+    // were a 2D HUD overlay anchored to the screen.
+    const followGroupRef = useRef(null);
+    // Pending one-shot click action instances. Each entry maps to one rendered
+    // child that self-disposes via onDone.
+    const [pendingClicks, setPendingClicks] = React.useState([]);
+    // Mirror `clickActions` into a ref so the pointerdown listener stays
+    // attached even when Redux hands us a new array reference on each tick.
+    const clickActionsRef = useRef(clickActions);
+    useEffect(() => { clickActionsRef.current = clickActions; }, [clickActions]);
+    // Click listener — independent of cursor-effect state.
+    const hasFiringActions = clickActions.some(c => c.type !== 'none');
+    useEffect(() => {
+        if (!hasFiringActions)
+            return;
+        const el = gl.domElement;
+        const onDown = (e) => {
+            const rect = el.getBoundingClientRect();
+            // NDC: -1..1 across the canvas
+            const ndcX = ((e.clientX - rect.left) / rect.width) * 2 - 1;
+            const ndcY = -((e.clientY - rect.top) / rect.height) * 2 + 1;
+            // Project the NDC click onto a plane at CLICK_PLANE_DISTANCE in front of
+            // the camera, in camera-local space. Visible half-height at that
+            // distance is `d * tan(fov/2)` for a perspective camera.
+            let halfHeight;
+            let halfWidth;
+            const persp = camera;
+            if (persp.isPerspectiveCamera) {
+                const fovRad = (persp.fov * Math.PI) / 180;
+                halfHeight = CLICK_PLANE_DISTANCE * Math.tan(fovRad / 2);
+                halfWidth = halfHeight * persp.aspect;
+            }
+            else {
+                // Orthographic or unknown: use a sensible fallback derived from the
+                // canvas aspect ratio.
+                halfHeight = ORTHO_FALLBACK_HALF_HEIGHT;
+                halfWidth = halfHeight * (rect.width / Math.max(rect.height, 1));
+            }
+            const localPos = new THREE.Vector3(ndcX * halfWidth, ndcY * halfHeight, -CLICK_PLANE_DISTANCE);
+            const currentActions = clickActionsRef.current;
+            const toAdd = [];
+            for (let i = 0; i < currentActions.length; i++) {
+                if (currentActions[i].type === 'none')
+                    continue;
+                toAdd.push({ id: ++clickIdCounter, actionIndex: i, localPos });
+            }
+            if (toAdd.length)
+                setPendingClicks(prev => prev.concat(toAdd));
+        };
+        el.addEventListener('pointerdown', onDown);
+        return () => el.removeEventListener('pointerdown', onDown);
+    }, [hasFiringActions, camera, gl.domElement]);
+    const removeClick = (id) => {
+        setPendingClicks(prev => prev.filter(c => c.id !== id));
+    };
+    // Each frame, mirror the camera's world transform onto the follow group.
+    // Force-update its matrixWorld so child actions' `lookAt(camera.position)`
+    // calls compute against the current parent transform within the same tick.
+    // Negative `useFrame` priority makes this run before action components'
+    // own `useFrame` callbacks.
+    useFrame(() => {
+        const g = followGroupRef.current;
+        if (!g)
+            return;
+        g.position.copy(camera.position);
+        g.quaternion.copy(camera.quaternion);
+        g.updateMatrixWorld(true);
+    }, -1);
+    return (_jsx("group", { ref: followGroupRef, children: pendingClicks.map(pc => {
+            const ca = clickActions[pc.actionIndex];
+            if (!ca)
+                return null;
+            // Each action accepts `worldPos` — but because it's rendered inside
+            // the camera-follow group, the prop is effectively the action's
+            // position in screen-anchored space.
+            switch (ca.type) {
+                case 'shockwave':
+                    return _jsx(ShockwaveAction, { worldPos: pc.localPos, config: ca, onDone: () => removeClick(pc.id) }, pc.id);
+                case 'sparklesBurst':
+                    return _jsx(SparklesBurstAction, { worldPos: pc.localPos, config: ca, onDone: () => removeClick(pc.id) }, pc.id);
+                case 'boltFlash':
+                    return _jsx(BoltFlashAction, { worldPos: pc.localPos, config: ca, onDone: () => removeClick(pc.id) }, pc.id);
+                case 'plasmaBomb':
+                    return _jsx(PlasmaBombAction, { worldPos: pc.localPos, config: ca, onDone: () => removeClick(pc.id) }, pc.id);
+                case 'realityTear':
+                    return _jsx(RealityTearAction, { worldPos: pc.localPos, config: ca, onDone: () => removeClick(pc.id) }, pc.id);
+                case 'implosion':
+                    return _jsx(ImplosionAction, { worldPos: pc.localPos, config: ca, onDone: () => removeClick(pc.id) }, pc.id);
+                case 'voronoiFracture':
+                    return _jsx(VoronoiFractureAction, { worldPos: pc.localPos, config: ca, onDone: () => removeClick(pc.id) }, pc.id);
+                case 'phaseShift':
+                    return _jsx(PhaseShiftAction, { worldPos: pc.localPos, config: ca, onDone: () => removeClick(pc.id) }, pc.id);
+                case 'glyphInscription':
+                    return _jsx(GlyphInscriptionAction, { worldPos: pc.localPos, config: ca, onDone: () => removeClick(pc.id) }, pc.id);
+                default:
+                    return null;
+            }
+        }) }));
+};
+export default CursorActions;

package/dist/components/cursor/CursorController.d.ts

@@ -0,0 +1,10 @@
+import React from "react";
+import type { CursorConfig, ClickActionConfig } from "@3driseai/3drise-core";
+export type { CursorTypeProps } from './CursorEffects';
+export interface CursorControllerProps {
+    effects?: CursorConfig[];
+    clickActions?: ClickActionConfig[];
+}
+declare const CursorController: React.FC<CursorControllerProps>;
+export default CursorController;
+//# sourceMappingURL=CursorController.d.ts.map

package/dist/components/cursor/CursorController.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CursorController.d.ts","sourceRoot":"","sources":["../../../src/components/cursor/CursorController.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,KAAK,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC7E,YAAY,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAEvD,MAAM,WAAW,qBAAqB;IAClC,OAAO,CAAC,EAAE,YAAY,EAAE,CAAC;IACzB,YAAY,CAAC,EAAE,iBAAiB,EAAE,CAAC;CACtC;AAGD,QAAA,MAAM,gBAAgB,EAAE,KAAK,CAAC,EAAE,CAAC,qBAAqB,CAAqI,CAAC;AAC5L,eAAe,gBAAgB,CAAC"}

package/dist/components/cursor/CursorController.js

@@ -0,0 +1,5 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import CursorEffects from './CursorEffects.js';
+import CursorActions from './CursorActions.js';
+const CursorController = ({ effects = [], clickActions = [], }) => (_jsxs(_Fragment, { children: [_jsx(CursorEffects, { effects: effects }), _jsx(CursorActions, { clickActions: clickActions })] }));
+export default CursorController;

package/dist/components/cursor/CursorEffects.d.ts

@@ -0,0 +1,16 @@
+import * as THREE from 'three';
+import React from "react";
+import type { CursorConfig } from "@3driseai/3drise-core";
+export interface CursorTypeProps<C extends CursorConfig = CursorConfig> {
+    config: C;
+    worldPosRef: React.RefObject<THREE.Vector3>;
+    velocityRef: React.RefObject<THREE.Vector3>;
+    hoverRef: React.RefObject<THREE.Intersection | null>;
+    idleMsRef: React.RefObject<number>;
+}
+export interface CursorEffectsProps {
+    effects?: CursorConfig[];
+}
+declare const CursorEffects: React.FC<CursorEffectsProps>;
+export default CursorEffects;
+//# sourceMappingURL=CursorEffects.d.ts.map

package/dist/components/cursor/CursorEffects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CursorEffects.d.ts","sourceRoot":"","sources":["../../../src/components/cursor/CursorEffects.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAe/B,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAC1D,MAAM,WAAW,eAAe,CAAC,CAAC,SAAS,YAAY,GAAG,YAAY;IAClE,MAAM,EAAE,CAAC,CAAC;IACV,WAAW,EAAE,KAAK,CAAC,SAAS,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IAC5C,WAAW,EAAE,KAAK,CAAC,SAAS,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IAC5C,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC,KAAK,CAAC,YAAY,GAAG,IAAI,CAAC,CAAC;IACrD,SAAS,EAAE,KAAK,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;CACtC;AAED,MAAM,WAAW,kBAAkB;IAC/B,OAAO,CAAC,EAAE,YAAY,EAAE,CAAC;CAC5B;AAWD,QAAA,MAAM,aAAa,EAAE,KAAK,CAAC,EAAE,CAAC,kBAAkB,CAkF/C,CAAC;AACF,eAAe,aAAa,CAAC"}

package/dist/components/cursor/CursorEffects.js

@@ -0,0 +1,110 @@
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { useEffect, useMemo, useRef } from 'react';
+import { useFrame, useThree } from '@react-three/fiber';
+import * as THREE from 'three';
+import { pickCursorWorldPos } from '../../utils/cursorPicking.js';
+import SparklesCursor from './SparklesCursor.js';
+import OrbCursor from './OrbCursor.js';
+import AuraCursor from './AuraCursor.js';
+import CrosshairCursor from './CrosshairCursor.js';
+import LiquidMetalCursor from './LiquidMetalCursor.js';
+import LightningCursor from './LightningCursor.js';
+import CometCursor from './CometCursor.js';
+import AuroraCursor from './AuroraCursor.js';
+import BubblesCursor from './BubblesCursor.js';
+import TeslaCursor from './TeslaCursor.js';
+import PlasmaWhipCursor from './PlasmaWhipCursor.js';
+import GlyphRingCursor from './GlyphRingCursor.js';
+import FerrofluidCursor from './FerrofluidCursor.js';
+const createTickState = () => ({
+    worldPosRef: { current: new THREE.Vector3() },
+    lastPosRef: { current: new THREE.Vector3() },
+    velocityRef: { current: new THREE.Vector3() },
+    hoverRef: { current: null },
+    idleMsRef: { current: 0 },
+    firstFrameRef: { current: true },
+});
+const CursorEffects = ({ effects = [] }) => {
+    const { camera, gl, scene, raycaster, pointer } = useThree();
+    // Per-effect ref bundles. Indexed by effect position. Grows/shrinks as the
+    // effects array length changes, but individual entries are stable so the
+    // child components don't lose their refs across renders.
+    const tickStatesRef = useRef([]);
+    while (tickStatesRef.current.length < effects.length) {
+        tickStatesRef.current.push(createTickState());
+    }
+    if (tickStatesRef.current.length > effects.length) {
+        tickStatesRef.current.length = effects.length;
+    }
+    // Private scratch vector — not shared with click action code.
+    const tmpPos = useMemo(() => new THREE.Vector3(), []);
+    const anyEnabled = effects.some(e => e.enabled);
+    // Hide OS cursor over the canvas when any effect is active.
+    useEffect(() => {
+        if (!anyEnabled)
+            return;
+        const el = gl.domElement;
+        const prev = el.style.cursor;
+        el.style.cursor = 'none';
+        return () => { el.style.cursor = prev; };
+    }, [anyEnabled, gl.domElement]);
+    // Per-frame position/velocity/hover update for each enabled effect.
+    useFrame((_, delta) => {
+        for (let i = 0; i < effects.length; i++) {
+            const eff = effects[i];
+            if (!eff.enabled)
+                continue;
+            const s = tickStatesRef.current[i];
+            const result = pickCursorWorldPos(eff.pickMode, raycaster, scene, camera, pointer, eff.planeDistance, tmpPos);
+            if (s.firstFrameRef.current) {
+                s.lastPosRef.current.copy(result.worldPos);
+                s.firstFrameRef.current = false;
+            }
+            const moved = result.worldPos.distanceToSquared(s.lastPosRef.current) > 1e-8;
+            if (moved) {
+                s.idleMsRef.current = 0;
+            }
+            else {
+                s.idleMsRef.current += delta * 1000;
+            }
+            const dt = Math.max(delta, 1 / 120);
+            s.velocityRef.current
+                .subVectors(result.worldPos, s.lastPosRef.current)
+                .divideScalar(dt);
+            s.lastPosRef.current.copy(result.worldPos);
+            s.worldPosRef.current.copy(result.worldPos);
+            s.hoverRef.current = result.hover;
+        }
+    });
+    const renderEffect = (eff, idx) => {
+        if (!eff.enabled)
+            return null;
+        const s = tickStatesRef.current[idx];
+        if (!s)
+            return null;
+        const shared = {
+            worldPosRef: s.worldPosRef,
+            velocityRef: s.velocityRef,
+            hoverRef: s.hoverRef,
+            idleMsRef: s.idleMsRef,
+        };
+        const key = `${idx}-${eff.type}`;
+        switch (eff.type) {
+            case 'sparkles': return _jsx(SparklesCursor, { config: eff, ...shared }, key);
+            case 'orb': return _jsx(OrbCursor, { config: eff, ...shared }, key);
+            case 'aura': return _jsx(AuraCursor, { config: eff, ...shared }, key);
+            case 'crosshair': return _jsx(CrosshairCursor, { config: eff, ...shared }, key);
+            case 'liquidMetal': return _jsx(LiquidMetalCursor, { config: eff, ...shared }, key);
+            case 'lightning': return _jsx(LightningCursor, { config: eff, ...shared }, key);
+            case 'comet': return _jsx(CometCursor, { config: eff, ...shared }, key);
+            case 'aurora': return _jsx(AuroraCursor, { config: eff, ...shared }, key);
+            case 'bubbles': return _jsx(BubblesCursor, { config: eff, ...shared }, key);
+            case 'tesla': return _jsx(TeslaCursor, { config: eff, ...shared }, key);
+            case 'plasmaWhip': return _jsx(PlasmaWhipCursor, { config: eff, ...shared }, key);
+            case 'glyphs': return _jsx(GlyphRingCursor, { config: eff, ...shared }, key);
+            case 'ferrofluid': return _jsx(FerrofluidCursor, { config: eff, ...shared }, key);
+        }
+    };
+    return _jsx(_Fragment, { children: effects.map(renderEffect) });
+};
+export default CursorEffects;

package/dist/components/cursor/FerrofluidCursor.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+import type { FerrofluidCursorConfig } from "@3driseai/3drise-core";
+import type { CursorTypeProps } from "./CursorController";
+declare const FerrofluidCursor: React.FC<CursorTypeProps<FerrofluidCursorConfig>>;
+export default FerrofluidCursor;
+//# sourceMappingURL=FerrofluidCursor.d.ts.map

package/dist/components/cursor/FerrofluidCursor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FerrofluidCursor.d.ts","sourceRoot":"","sources":["../../../src/components/cursor/FerrofluidCursor.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AACpE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAE1D,QAAA,MAAM,gBAAgB,EAAE,KAAK,CAAC,EAAE,CAAC,eAAe,CAAC,sBAAsB,CAAC,CAgGvE,CAAC;AACF,eAAe,gBAAgB,CAAC"}