@3driseai/3drise-viewer 0.1.1

package/dist/components/cursor/SparklesCursor.js

@@ -0,0 +1,151 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useMemo, useRef } from 'react';
+import { useFrame } from '@react-three/fiber';
+import * as THREE from 'three';
+const MAX_PARTICLES = 1200;
+const vertexShader = /* glsl */ `
+  attribute float aAge;
+  uniform float uSize;
+  uniform float uLifetime;
+  varying float vAge;
+  void main() {
+    vAge = clamp(aAge / max(uLifetime, 1.0), 0.0, 1.0);
+    vec4 mv = modelViewMatrix * vec4(position, 1.0);
+    gl_PointSize = uSize * (1.0 - vAge * 0.7) * (300.0 / -mv.z);
+    gl_Position = projectionMatrix * mv;
+  }
+`;
+const fragmentShader = /* glsl */ `
+  uniform vec3 uColor;
+  uniform float uOpacity;
+  uniform float uIntensity;
+  varying float vAge;
+  void main() {
+    vec2 c = gl_PointCoord * 2.0 - 1.0;
+    float dist = length(c);
+    if (dist > 1.0) discard;
+    // soft sparkle: bright center + cross flare
+    float core = 1.0 - smoothstep(0.0, 0.6, dist);
+    float flare = pow(1.0 - dist, 4.0);
+    float fade = (1.0 - vAge);
+    float alpha = (core * 0.6 + flare * 0.5) * fade * uOpacity;
+    if (alpha < 0.003) discard;
+    vec3 col = uColor * (1.0 + uIntensity * 0.6);
+    gl_FragColor = vec4(col, alpha);
+  }
+`;
+const SparklesCursor = ({ config, worldPosRef, velocityRef, hoverRef, idleMsRef, }) => {
+    const positions = useMemo(() => new Float32Array(MAX_PARTICLES * 3), []);
+    const velocities = useMemo(() => new Float32Array(MAX_PARTICLES * 3), []);
+    const ages = useMemo(() => new Float32Array(MAX_PARTICLES), []);
+    const alive = useMemo(() => new Uint8Array(MAX_PARTICLES), []);
+    const geometry = useMemo(() => {
+        const g = new THREE.BufferGeometry();
+        g.setAttribute('position', new THREE.BufferAttribute(positions, 3));
+        g.setAttribute('aAge', new THREE.BufferAttribute(ages, 1));
+        // Pre-park all particles off-screen
+        for (let i = 0; i < MAX_PARTICLES; i++)
+            positions[i * 3 + 1] = -1e6;
+        return g;
+    }, [positions, ages]);
+    const material = useMemo(() => new THREE.ShaderMaterial({
+        uniforms: {
+            uColor: { value: new THREE.Color(config.color) },
+            uSize: { value: config.scale * 0.35 },
+            uLifetime: { value: config.lifetimeMs },
+            uOpacity: { value: config.opacity },
+            uIntensity: { value: config.intensity },
+        },
+        vertexShader,
+        fragmentShader,
+        transparent: true,
+        depthWrite: false,
+        blending: THREE.AdditiveBlending,
+    }), []);
+    useEffect(() => {
+        material.uniforms.uColor.value.set(config.color);
+        material.uniforms.uSize.value = config.scale * 0.35;
+        material.uniforms.uLifetime.value = config.lifetimeMs;
+        material.uniforms.uOpacity.value = config.opacity;
+        material.uniforms.uIntensity.value = config.intensity;
+    }, [config.color, config.scale, config.lifetimeMs, config.opacity, config.intensity, material]);
+    useEffect(() => {
+        return () => {
+            geometry.dispose();
+            material.dispose();
+        };
+    }, [geometry, material]);
+    const lastSpawnPos = useRef(new THREE.Vector3());
+    const spawnAccum = useRef(0);
+    const firstFrame = useRef(true);
+    useFrame((_, delta) => {
+        const wp = worldPosRef.current;
+        if (firstFrame.current) {
+            lastSpawnPos.current.copy(wp);
+            firstFrame.current = false;
+        }
+        const dtMs = delta * 1000;
+        const idleFactor = Math.max(0, 1 - idleMsRef.current / Math.max(config.idleFadeMs, 1));
+        const hover = hoverRef.current;
+        const hoverBoost = hover ? 2.0 : 1.0;
+        const lifetimeS = Math.max(config.lifetimeMs / 1000, 0.05);
+        const steady = config.particleCount / lifetimeS;
+        spawnAccum.current += steady * delta * (0.4 + idleFactor * 0.6) * hoverBoost;
+        let toSpawn = Math.floor(spawnAccum.current);
+        spawnAccum.current -= toSpawn;
+        let scan = 0;
+        while (toSpawn > 0 && scan < MAX_PARTICLES) {
+            if (alive[scan] === 0) {
+                const base = scan * 3;
+                // When hovering, half of new sparkles spawn at the hovered surface point
+                // and pop outward along its normal — the rest spawn along the cursor path
+                // as usual.
+                if (hover && Math.random() < 0.5) {
+                    const hp = hover.point;
+                    const hn = hover.face?.normal ?? new THREE.Vector3(0, 1, 0);
+                    positions[base + 0] = hp.x + hn.x * 0.02;
+                    positions[base + 1] = hp.y + hn.y * 0.02;
+                    positions[base + 2] = hp.z + hn.z * 0.02;
+                    // Launch along normal + small lateral spread
+                    velocities[base + 0] = hn.x * (0.6 + Math.random() * 0.4) + (Math.random() - 0.5) * 0.3;
+                    velocities[base + 1] = hn.y * (0.6 + Math.random() * 0.4) + (Math.random() - 0.5) * 0.3;
+                    velocities[base + 2] = hn.z * (0.6 + Math.random() * 0.4) + (Math.random() - 0.5) * 0.3;
+                }
+                else {
+                    const t = Math.random();
+                    positions[base + 0] = THREE.MathUtils.lerp(lastSpawnPos.current.x, wp.x, t) + (Math.random() - 0.5) * 0.05 * config.scale;
+                    positions[base + 1] = THREE.MathUtils.lerp(lastSpawnPos.current.y, wp.y, t) + (Math.random() - 0.5) * 0.05 * config.scale;
+                    positions[base + 2] = THREE.MathUtils.lerp(lastSpawnPos.current.z, wp.z, t) + (Math.random() - 0.5) * 0.05 * config.scale;
+                    velocities[base + 0] = (Math.random() - 0.5) * 0.4 + velocityRef.current.x * 0.04;
+                    velocities[base + 1] = Math.random() * 0.3 + 0.1;
+                    velocities[base + 2] = (Math.random() - 0.5) * 0.4 + velocityRef.current.z * 0.04;
+                }
+                ages[scan] = 0;
+                alive[scan] = 1;
+                toSpawn--;
+            }
+            scan++;
+        }
+        lastSpawnPos.current.copy(wp);
+        const g = config.gravity * delta;
+        for (let j = 0; j < MAX_PARTICLES; j++) {
+            if (alive[j] === 0)
+                continue;
+            const base = j * 3;
+            ages[j] += dtMs;
+            if (ages[j] >= config.lifetimeMs) {
+                alive[j] = 0;
+                positions[base + 1] = -1e6;
+                continue;
+            }
+            velocities[base + 1] -= g;
+            positions[base + 0] += velocities[base + 0] * delta;
+            positions[base + 1] += velocities[base + 1] * delta;
+            positions[base + 2] += velocities[base + 2] * delta;
+        }
+        geometry.attributes.position.needsUpdate = true;
+        geometry.attributes.aAge.needsUpdate = true;
+    });
+    return _jsx("points", { geometry: geometry, material: material, frustumCulled: false });
+};
+export default SparklesCursor;

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"TeslaCursor.d.ts","sourceRoot":"","sources":["../../../src/components/cursor/TeslaCursor.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC/D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAwF1D,QAAA,MAAM,WAAW,EAAE,KAAK,CAAC,EAAE,CAAC,eAAe,CAAC,iBAAiB,CAAC,CAmI7D,CAAC;AACF,eAAe,WAAW,CAAC"}

package/dist/components/cursor/TeslaCursor.js

@@ -0,0 +1,223 @@
+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_HISTORY = 36;
+const TUBULAR_RES = 120;
+const RADIAL_RES = 6;
+// ── Source point shader ─────────────────────────────────────────────────────
+const sourceVertex = /* glsl */ `
+  uniform float uSize;
+  uniform float uShine;
+  void main() {
+    vec4 mv = modelViewMatrix * vec4(position, 1.0);
+    gl_PointSize = uSize * (1.0 + uShine * 0.7) * (300.0 / -mv.z);
+    gl_Position = projectionMatrix * mv;
+  }
+`;
+const sourceFragment = /* glsl */ `
+  uniform vec3  uColor;
+  uniform float uShine;
+  uniform float uTime;
+  void main() {
+    vec2 c = gl_PointCoord * 2.0 - 1.0;
+    float r = length(c);
+    if (r > 1.0) discard;
+    float core = pow(max(0.0, 1.0 - r), 6.0);
+    float halo = pow(max(0.0, 1.0 - r), 1.6) * 0.5;
+    float pulse = 0.5 + 0.5 * sin(uTime * 5.0);
+    float sparkle = core * (1.0 + uShine * (0.3 + pulse * 0.4));
+    vec3 col = mix(uColor, vec3(1.0), core);
+    col *= 1.0 + sparkle * 1.4;
+    float alpha = (sparkle + halo) * (0.85 + uShine * 0.2);
+    if (alpha < 0.005) discard;
+    gl_FragColor = vec4(col, alpha);
+  }
+`;
+// ── Tesla bolt shader ───────────────────────────────────────────────────────
+// vUv.x: 0 at tail, 1 at source (cursor). uv.y wraps the tube.
+// Energy packets travel from source (1) toward tail (0).
+const trailVertex = /* glsl */ `
+  varying vec2 vUv;
+  void main() {
+    vUv = uv;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+  }
+`;
+const trailFragment = /* glsl */ `
+  uniform vec3  uColor;
+  uniform float uOpacity;
+  uniform float uTime;
+  uniform float uShine;
+  uniform float uPulseCount;
+  uniform float uPulseSpeed;
+  varying vec2  vUv;
+
+  void main() {
+    // Soft tube cross-section glow
+    float core = 1.0 - abs(vUv.y * 2.0 - 1.0);
+    core = pow(core, 1.8);
+
+    // Discrete energy packets traveling source → tail.
+    // We shift the phase so packets appear to "leave" the source.
+    float phase = vUv.x * uPulseCount + uTime * uPulseSpeed;
+    float wave = 0.5 + 0.5 * sin(phase * 6.2831853);
+    float packets = pow(wave, 16.0);             // sharp dots
+    float trailSmear = pow(wave, 3.0) * 0.35;    // softer carrier
+
+    // Continuous baseline so the bolt is always visible as a thin line
+    float baseLine = core * 0.35;
+
+    // Brighter at the source end, fades into the tail
+    float sourceEmphasis = smoothstep(0.0, 0.95, vUv.x);
+    float tailFade = smoothstep(0.0, 0.05, vUv.x);
+
+    // Compose intensity: baseline + traveling pulses, gated by emphasis/fade
+    float pulseIntensity = (packets * 2.2 + trailSmear) * core;
+    float intensity = (baseLine + pulseIntensity) * sourceEmphasis * tailFade;
+
+    // Shine boost from velocity (smoothed in JS)
+    intensity *= 0.55 + uShine * 0.7;
+
+    // Color: white-hot inside the pulses, colored otherwise
+    vec3 col = mix(uColor, vec3(1.0), clamp(packets + core * 0.4, 0.0, 1.0));
+    col *= 1.0 + pulseIntensity * 1.4;
+
+    float alpha = intensity * uOpacity;
+    if (alpha < 0.005) discard;
+    gl_FragColor = vec4(col, alpha);
+  }
+`;
+const TeslaCursor = ({ config, worldPosRef, velocityRef, hoverRef, idleMsRef, }) => {
+    // ── Source point ─────────────────────────────────────────────────────────
+    const sourceGeom = useMemo(() => {
+        const g = new THREE.BufferGeometry();
+        g.setAttribute('position', new THREE.BufferAttribute(new Float32Array([0, 0, 0]), 3));
+        return g;
+    }, []);
+    const sourceMat = useMemo(() => new THREE.ShaderMaterial({
+        uniforms: {
+            uColor: { value: new THREE.Color(config.pointColor) },
+            uSize: { value: config.pointSize },
+            uShine: { value: 0 },
+            uTime: { value: 0 },
+        },
+        vertexShader: sourceVertex,
+        fragmentShader: sourceFragment,
+        transparent: true,
+        depthWrite: false,
+        blending: THREE.AdditiveBlending,
+    }), []);
+    // ── Trail tube ───────────────────────────────────────────────────────────
+    const trailMeshRef = useRef(null);
+    const trailGeomRef = useRef(null);
+    const trailMat = useMemo(() => new THREE.ShaderMaterial({
+        uniforms: {
+            uColor: { value: new THREE.Color(config.color) },
+            uOpacity: { value: 0 },
+            uTime: { value: 0 },
+            uShine: { value: 0 },
+            uPulseCount: { value: config.pulseCount },
+            uPulseSpeed: { value: config.pulseSpeed },
+        },
+        vertexShader: trailVertex,
+        fragmentShader: trailFragment,
+        transparent: true,
+        depthWrite: false,
+        blending: THREE.AdditiveBlending,
+        side: THREE.DoubleSide,
+    }), []);
+    useEffect(() => {
+        sourceMat.uniforms.uColor.value.set(config.pointColor);
+        sourceMat.uniforms.uSize.value = config.pointSize;
+        trailMat.uniforms.uColor.value.set(config.color);
+        trailMat.uniforms.uPulseCount.value = config.pulseCount;
+        trailMat.uniforms.uPulseSpeed.value = config.pulseSpeed;
+    }, [config.color, config.pointColor, config.pointSize, config.pulseCount, config.pulseSpeed, sourceMat, trailMat]);
+    useEffect(() => () => {
+        sourceGeom.dispose();
+        sourceMat.dispose();
+        trailMat.dispose();
+        trailGeomRef.current?.dispose();
+    }, [sourceGeom, sourceMat, trailMat]);
+    // ── History (sample-on-motion) ───────────────────────────────────────────
+    const history = useMemo(() => {
+        const arr = [];
+        for (let i = 0; i < MAX_HISTORY; i++)
+            arr.push(new THREE.Vector3());
+        return arr;
+    }, []);
+    const historyCount = useRef(0);
+    const lastSample = useMemo(() => new THREE.Vector3(), []);
+    const firstFrame = useRef(true);
+    // Smoothed shine
+    const shine = useRef(0);
+    useFrame((state, delta) => {
+        const wp = worldPosRef.current;
+        const time = state.clock.getElapsedTime();
+        sourceMat.uniforms.uTime.value = time;
+        trailMat.uniforms.uTime.value = time;
+        // Source position
+        sourceGeom.attributes.position.array[0] = wp.x;
+        sourceGeom.attributes.position.array[1] = wp.y;
+        sourceGeom.attributes.position.array[2] = wp.z;
+        sourceGeom.attributes.position.needsUpdate = true;
+        // Shine from velocity
+        const speed = velocityRef.current.length();
+        const targetShine = Math.min(1.5, speed * 0.35) + (hoverRef.current ? 0.3 : 0);
+        shine.current = THREE.MathUtils.damp(shine.current, targetShine, 8, delta);
+        sourceMat.uniforms.uShine.value = shine.current;
+        trailMat.uniforms.uShine.value = shine.current;
+        // Sample-on-motion history
+        if (firstFrame.current) {
+            for (let i = 0; i < MAX_HISTORY; i++)
+                history[i].copy(wp);
+            lastSample.copy(wp);
+            historyCount.current = 1;
+            firstFrame.current = false;
+        }
+        else {
+            const sampleDist = 0.06 * config.scale;
+            if (wp.distanceToSquared(lastSample) > sampleDist * sampleDist) {
+                for (let i = MAX_HISTORY - 1; i > 0; i--)
+                    history[i].copy(history[i - 1]);
+                history[0].copy(wp);
+                lastSample.copy(wp);
+                historyCount.current = Math.min(MAX_HISTORY, historyCount.current + 1);
+            }
+            else {
+                history[0].copy(wp);
+            }
+        }
+        // Opacity tied to idle factor + shine
+        const idleFactor = Math.max(0, 1 - idleMsRef.current / Math.max(config.idleFadeMs, 1));
+        trailMat.uniforms.uOpacity.value = idleFactor * (0.5 + shine.current * 0.45);
+        const visible = historyCount.current >= 3 && trailMat.uniforms.uOpacity.value > 0.02;
+        if (trailMeshRef.current)
+            trailMeshRef.current.visible = visible;
+        if (!visible)
+            return;
+        // ── Build the single clean curve through history ─────────────────────
+        // Points run tail (oldest) → head (cursor) so vUv.x goes 0 → 1 in that
+        // direction, matching the shader's source-bright convention.
+        const cap = Math.max(3, Math.min(MAX_HISTORY, Math.floor(config.trailLength)));
+        const n = Math.min(historyCount.current, cap);
+        const pts = [];
+        for (let i = n - 1; i >= 0; i--) {
+            pts.push(history[i].clone());
+        }
+        // Override the head so it sits exactly on the cursor (no sample lag)
+        pts[pts.length - 1].copy(wp);
+        // CatmullRom with tension 0.5 → smooth, gentle curve through history.
+        const curve = new THREE.CatmullRomCurve3(pts, false, 'catmullrom', 0.5);
+        const radius = Math.max(0.001, config.lineThickness);
+        const newGeo = new THREE.TubeGeometry(curve, TUBULAR_RES, radius, RADIAL_RES, false);
+        if (trailMeshRef.current)
+            trailMeshRef.current.geometry = newGeo;
+        if (trailGeomRef.current)
+            trailGeomRef.current.dispose();
+        trailGeomRef.current = newGeo;
+    });
+    return (_jsxs(_Fragment, { children: [_jsx("points", { geometry: sourceGeom, material: sourceMat, frustumCulled: false }), _jsx("mesh", { ref: trailMeshRef, material: trailMat, frustumCulled: false })] }));
+};
+export default TeslaCursor;

package/dist/components/cursor/clickActions/BoltFlashAction.d.ts

@@ -0,0 +1,11 @@
+import * as THREE from 'three';
+import React from "react";
+import type { ClickActionConfig } from "@3driseai/3drise-core";
+interface BoltFlashActionProps {
+    worldPos: THREE.Vector3;
+    config: ClickActionConfig;
+    onDone: () => void;
+}
+declare const BoltFlashAction: React.FC<BoltFlashActionProps>;
+export default BoltFlashAction;
+//# sourceMappingURL=BoltFlashAction.d.ts.map

package/dist/components/cursor/clickActions/BoltFlashAction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BoltFlashAction.d.ts","sourceRoot":"","sources":["../../../../src/components/cursor/clickActions/BoltFlashAction.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC/D,UAAU,oBAAoB;IAC1B,QAAQ,EAAE,KAAK,CAAC,OAAO,CAAC;IACxB,MAAM,EAAE,iBAAiB,CAAC;IAC1B,MAAM,EAAE,MAAM,IAAI,CAAC;CACtB;AA6BD,QAAA,MAAM,eAAe,EAAE,KAAK,CAAC,EAAE,CAAC,oBAAoB,CA8BnD,CAAC;AACF,eAAe,eAAe,CAAC"}

package/dist/components/cursor/clickActions/BoltFlashAction.js

@@ -0,0 +1,62 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useMemo, useRef } from 'react';
+import { useFrame } from '@react-three/fiber';
+import * as THREE from 'three';
+const fragmentShader = /* glsl */ `
+  uniform float uProgress;
+  uniform vec3  uColor;
+  void main() {
+    vec2 c = gl_PointCoord * 2.0 - 1.0;
+    float dist = length(c);
+    if (dist > 1.0) discard;
+    // Sharp flash: bright instantly, then exponential decay
+    float fade = exp(-uProgress * 8.0);
+    float core = pow(1.0 - dist, 1.5);
+    float alpha = core * fade;
+    if (alpha < 0.004) discard;
+    vec3 col = mix(vec3(1.0), uColor, smoothstep(0.0, 0.4, dist));
+    gl_FragColor = vec4(col * (1.0 + fade), alpha);
+  }
+`;
+const vertexShader = /* glsl */ `
+  uniform float uSize;
+  uniform float uProgress;
+  void main() {
+    vec4 mv = modelViewMatrix * vec4(position, 1.0);
+    float size = uSize * (1.0 + uProgress * 0.5);
+    gl_PointSize = size * (300.0 / -mv.z);
+    gl_Position = projectionMatrix * mv;
+  }
+`;
+const BoltFlashAction = ({ worldPos, config, onDone }) => {
+    const startRef = useRef(null);
+    const { geometry, material } = useMemo(() => {
+        const g = new THREE.BufferGeometry();
+        g.setAttribute('position', new THREE.BufferAttribute(new Float32Array([0, 0, 0]), 3));
+        const m = new THREE.ShaderMaterial({
+            uniforms: {
+                uProgress: { value: 0 },
+                uSize: { value: 220 * config.scale },
+                uColor: { value: new THREE.Color(config.color) },
+            },
+            vertexShader,
+            fragmentShader,
+            transparent: true,
+            depthWrite: false,
+            blending: THREE.AdditiveBlending,
+        });
+        return { geometry: g, material: m };
+    }, []);
+    useEffect(() => () => { geometry.dispose(); material.dispose(); }, [geometry, material]);
+    useFrame((state) => {
+        if (startRef.current === null)
+            startRef.current = state.clock.getElapsedTime();
+        const elapsedMs = (state.clock.getElapsedTime() - startRef.current) * 1000;
+        const p = Math.min(elapsedMs / config.durationMs, 1);
+        material.uniforms.uProgress.value = p;
+        if (p >= 1)
+            onDone();
+    });
+    return _jsx("points", { position: worldPos, geometry: geometry, material: material, frustumCulled: false });
+};
+export default BoltFlashAction;

package/dist/components/cursor/clickActions/GlyphInscriptionAction.d.ts

@@ -0,0 +1,11 @@
+import * as THREE from 'three';
+import React from "react";
+import type { GlyphInscriptionActionConfig } from "@3driseai/3drise-core";
+interface GlyphInscriptionActionProps {
+    worldPos: THREE.Vector3;
+    config: GlyphInscriptionActionConfig;
+    onDone: () => void;
+}
+declare const GlyphInscriptionAction: React.FC<GlyphInscriptionActionProps>;
+export default GlyphInscriptionAction;
+//# sourceMappingURL=GlyphInscriptionAction.d.ts.map

package/dist/components/cursor/clickActions/GlyphInscriptionAction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GlyphInscriptionAction.d.ts","sourceRoot":"","sources":["../../../../src/components/cursor/clickActions/GlyphInscriptionAction.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,uBAAuB,CAAC;AAC1E,UAAU,2BAA2B;IACjC,QAAQ,EAAE,KAAK,CAAC,OAAO,CAAC;IACxB,MAAM,EAAE,4BAA4B,CAAC;IACrC,MAAM,EAAE,MAAM,IAAI,CAAC;CACtB;AA6ED,QAAA,MAAM,sBAAsB,EAAE,KAAK,CAAC,EAAE,CAAC,2BAA2B,CAkCjE,CAAC;AACF,eAAe,sBAAsB,CAAC"}

package/dist/components/cursor/clickActions/GlyphInscriptionAction.js

@@ -0,0 +1,114 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useMemo, useRef } from 'react';
+import { useFrame, useThree } from '@react-three/fiber';
+import * as THREE from 'three';
+const vertexShader = /* glsl */ `
+  uniform float uProgress;
+  uniform float uMaxRadius;
+  varying vec2 vUv;
+  void main() {
+    vUv = uv;
+    // Slight pulse outward at the end
+    float burst = smoothstep(0.85, 1.0, uProgress) * 0.15;
+    vec3 pos = position * (uMaxRadius * (1.0 + burst));
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(pos, 1.0);
+  }
+`;
+const fragmentShader = /* glsl */ `
+  uniform float uProgress;
+  uniform float uTime;
+  uniform float uGlyphCount;
+  uniform vec3  uColor;
+  varying vec2 vUv;
+
+  // Cheap procedural glyph: per-slice pseudo-random rune mask using sine combos.
+  float glyph(vec2 p, float seed) {
+    // p is in [-1,1] within a single glyph cell
+    vec2 ap = abs(p);
+    float bar = step(ap.x, 0.18) * step(ap.y, 0.78);
+    float ring = step(abs(length(p) - 0.55), 0.07);
+    float diag = step(abs(p.x - p.y * sign(seed * 7.0)), 0.12);
+    float cross = step(ap.y, 0.10) * step(ap.x, 0.78);
+    // Combine based on seed
+    float s1 = fract(sin(seed * 12.9898) * 43758.5453);
+    float s2 = fract(sin(seed * 78.233)  * 12345.6789);
+    float s3 = fract(sin(seed * 4.821)   * 91812.234);
+    float g = max(max(bar * (s1 > 0.5 ? 1.0 : 0.0), ring * (s2 > 0.4 ? 1.0 : 0.0)),
+                  max(diag * (s3 > 0.5 ? 1.0 : 0.0), cross * (s1 < 0.4 ? 1.0 : 0.0)));
+    return g;
+  }
+
+  void main() {
+    // Polar coords centered on ring
+    vec2 p = vUv * 2.0 - 1.0;
+    float r = length(p);
+    float theta = atan(p.y, p.x); // -PI..PI
+    float a = theta / (2.0 * 3.141592653589793) + 0.5; // 0..1
+
+    // Restrict drawing to a thin ring band
+    float bandWidth = 0.18;
+    float ringMask = smoothstep(0.55 - bandWidth, 0.55, r) * (1.0 - smoothstep(0.55, 0.55 + bandWidth, r));
+    if (ringMask < 0.01) discard;
+
+    // Counter-clockwise draw progress (drawT is 1 where already drawn)
+    float draw = smoothstep(0.0, 0.85, uProgress);
+    float drawT = step(a, draw);
+
+    // Glyph cell index
+    float cell = floor(a * uGlyphCount);
+    float local = fract(a * uGlyphCount) * 2.0 - 1.0;
+    float radial = (r - 0.55) / bandWidth;
+    float g = glyph(vec2(local, radial * 0.8), cell + 1.0);
+
+    // Burst at the end: bright flash over the whole ring
+    float burst = smoothstep(0.85, 1.0, uProgress);
+    float burstFlash = burst * (1.0 - burst) * 4.0;
+
+    // Edge glow under the trailing draw line
+    float drawEdge = exp(-pow((a - draw) * 12.0, 2.0)) * 1.5;
+
+    float intensity = g * drawT + burstFlash + drawEdge * (1.0 - smoothstep(0.85, 1.0, uProgress));
+    float fade = 1.0 - smoothstep(0.9, 1.0, uProgress);
+    float alpha = ringMask * intensity * fade;
+    if (alpha < 0.005) discard;
+
+    vec3 col = uColor * (1.0 + intensity);
+    gl_FragColor = vec4(col, alpha);
+  }
+`;
+const GlyphInscriptionAction = ({ worldPos, config, onDone }) => {
+    const startRef = useRef(null);
+    const meshRef = useRef(null);
+    const { camera, clock } = useThree();
+    const geometry = useMemo(() => new THREE.PlaneGeometry(2, 2, 1, 1), []);
+    const material = useMemo(() => new THREE.ShaderMaterial({
+        uniforms: {
+            uProgress: { value: 0 },
+            uTime: { value: 0 },
+            uMaxRadius: { value: config.scale ?? 1 },
+            uGlyphCount: { value: Math.max(3, config.glyphCount ?? 8) },
+            uColor: { value: new THREE.Color(config.color) },
+        },
+        vertexShader,
+        fragmentShader,
+        transparent: true,
+        depthWrite: false,
+        side: THREE.DoubleSide,
+        blending: THREE.AdditiveBlending,
+    }), []);
+    useEffect(() => () => { geometry.dispose(); material.dispose(); }, [geometry, material]);
+    useFrame((state) => {
+        if (startRef.current === null)
+            startRef.current = state.clock.getElapsedTime();
+        const elapsedMs = (state.clock.getElapsedTime() - startRef.current) * 1000;
+        const p = Math.min(elapsedMs / config.durationMs, 1);
+        material.uniforms.uProgress.value = p;
+        material.uniforms.uTime.value = clock.getElapsedTime();
+        if (meshRef.current)
+            meshRef.current.lookAt(camera.position);
+        if (p >= 1)
+            onDone();
+    });
+    return (_jsx("mesh", { ref: meshRef, position: worldPos, geometry: geometry, material: material }));
+};
+export default GlyphInscriptionAction;

package/dist/components/cursor/clickActions/ImplosionAction.d.ts

@@ -0,0 +1,11 @@
+import * as THREE from 'three';
+import React from "react";
+import type { ImplosionActionConfig } from "@3driseai/3drise-core";
+interface ImplosionActionProps {
+    worldPos: THREE.Vector3;
+    config: ImplosionActionConfig;
+    onDone: () => void;
+}
+declare const ImplosionAction: React.FC<ImplosionActionProps>;
+export default ImplosionAction;
+//# sourceMappingURL=ImplosionAction.d.ts.map

package/dist/components/cursor/clickActions/ImplosionAction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ImplosionAction.d.ts","sourceRoot":"","sources":["../../../../src/components/cursor/clickActions/ImplosionAction.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AACnE,UAAU,oBAAoB;IAC1B,QAAQ,EAAE,KAAK,CAAC,OAAO,CAAC;IACxB,MAAM,EAAE,qBAAqB,CAAC;IAC9B,MAAM,EAAE,MAAM,IAAI,CAAC;CACtB;AA0DD,QAAA,MAAM,eAAe,EAAE,KAAK,CAAC,EAAE,CAAC,oBAAoB,CAgCnD,CAAC;AACF,eAAe,eAAe,CAAC"}