@3driseai/3drise-viewer 0.1.1

package/dist/components/cursor/FerrofluidCursor.js

@@ -0,0 +1,102 @@
+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 FerrofluidCursor = ({ config, worldPosRef, velocityRef, hoverRef, idleMsRef, }) => {
+    const groupRef = useRef(null);
+    // Base sphere geometry (kept for original vertex positions)
+    const { geometry, basePositions } = useMemo(() => {
+        const baseRadius = 0.15 * config.scale;
+        const g = new THREE.IcosahedronGeometry(baseRadius, 3);
+        const base = new Float32Array(g.attributes.position.array.slice());
+        return { geometry: g, basePositions: base };
+    }, [config.scale]);
+    const material = useMemo(() => new THREE.MeshPhysicalMaterial({
+        color: new THREE.Color(config.color),
+        metalness: config.metalness,
+        roughness: 0.08,
+        clearcoat: 1,
+        clearcoatRoughness: 0.05,
+        envMapIntensity: 1.5,
+    }), []);
+    useEffect(() => {
+        material.color.set(config.color);
+        material.metalness = config.metalness;
+    }, [config.color, config.metalness, material]);
+    useEffect(() => () => { geometry.dispose(); material.dispose(); }, [geometry, material]);
+    // Pre-compute fixed per-vertex random offsets and pick `spikeCount` spike vertices
+    const { spikeIndices, vertNoise } = useMemo(() => {
+        const totalVerts = basePositions.length / 3;
+        const indices = [];
+        const used = new Set();
+        const spikes = Math.min(config.spikeCount, totalVerts);
+        while (indices.length < spikes) {
+            const i = Math.floor(Math.random() * totalVerts);
+            if (!used.has(i)) {
+                used.add(i);
+                indices.push(i);
+            }
+        }
+        const noise = new Float32Array(totalVerts);
+        for (let i = 0; i < totalVerts; i++)
+            noise[i] = Math.random() * 100;
+        return { spikeIndices: indices, vertNoise: noise };
+    }, [basePositions, config.spikeCount]);
+    const tmpVert = useMemo(() => new THREE.Vector3(), []);
+    const tmpDir = useMemo(() => new THREE.Vector3(), []);
+    const tmpTarget = useMemo(() => new THREE.Vector3(), []);
+    useFrame((state, delta) => {
+        if (groupRef.current)
+            groupRef.current.position.copy(worldPosRef.current);
+        const hover = hoverRef.current;
+        const idleFactor = Math.max(0.2, 1 - idleMsRef.current / Math.max(config.idleFadeMs * 2, 1));
+        const speed = velocityRef.current.length();
+        const wobbleAmp = Math.min(0.4, 0.05 + speed * 0.02);
+        // Target direction in local space (relative to cursor world pos)
+        if (hover) {
+            tmpTarget.copy(hover.point).sub(worldPosRef.current).normalize();
+        }
+        else {
+            // No target: spike along velocity direction (if any)
+            tmpTarget.copy(velocityRef.current).normalize();
+            if (!Number.isFinite(tmpTarget.x) || tmpTarget.lengthSq() < 1e-6)
+                tmpTarget.set(0, 1, 0);
+        }
+        const positions = geometry.attributes.position.array;
+        const t = state.clock.getElapsedTime();
+        const totalVerts = basePositions.length / 3;
+        const reach = config.reach * config.scale;
+        // Reset to base positions plus wobble
+        for (let i = 0; i < totalVerts; i++) {
+            const bx = basePositions[i * 3 + 0];
+            const by = basePositions[i * 3 + 1];
+            const bz = basePositions[i * 3 + 2];
+            const wob = 1 + Math.sin(t * 3 + vertNoise[i]) * wobbleAmp * 0.5;
+            positions[i * 3 + 0] = bx * wob;
+            positions[i * 3 + 1] = by * wob;
+            positions[i * 3 + 2] = bz * wob;
+        }
+        // Add spike displacement for each chosen spike vertex along the target dir
+        // weighted by alignment of that vertex's base direction with the target.
+        for (let k = 0; k < spikeIndices.length; k++) {
+            const i = spikeIndices[k];
+            tmpVert.set(basePositions[i * 3 + 0], basePositions[i * 3 + 1], basePositions[i * 3 + 2]);
+            const len = tmpVert.length();
+            if (len < 1e-6)
+                continue;
+            tmpDir.copy(tmpVert).divideScalar(len);
+            // Only spike vertices that face the target
+            const align = Math.max(0, tmpDir.dot(tmpTarget));
+            const spikeAmp = Math.pow(align, 4) * reach * idleFactor;
+            if (spikeAmp < 0.001)
+                continue;
+            positions[i * 3 + 0] += tmpDir.x * spikeAmp;
+            positions[i * 3 + 1] += tmpDir.y * spikeAmp;
+            positions[i * 3 + 2] += tmpDir.z * spikeAmp;
+        }
+        geometry.attributes.position.needsUpdate = true;
+        geometry.computeVertexNormals();
+    });
+    return (_jsx("group", { ref: groupRef, children: _jsx("mesh", { geometry: geometry, material: material }) }));
+};
+export default FerrofluidCursor;

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"GlyphRingCursor.d.ts","sourceRoot":"","sources":["../../../src/components/cursor/GlyphRingCursor.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;AAyE1D,QAAA,MAAM,eAAe,EAAE,KAAK,CAAC,EAAE,CAAC,eAAe,CAAC,qBAAqB,CAAC,CA8CrE,CAAC;AACF,eAAe,eAAe,CAAC"}

package/dist/components/cursor/GlyphRingCursor.js

@@ -0,0 +1,123 @@
+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 */ `
+  varying vec2 vUv;
+  void main() {
+    vUv = uv;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+  }
+`;
+const fragmentShader = /* glsl */ `
+  uniform float uTime;
+  uniform float uRotation;
+  uniform float uGlyphCount;
+  uniform float uHover;
+  uniform float uIntensity;
+  uniform float uOpacity;
+  uniform vec3  uColor;
+  varying vec2  vUv;
+
+  float glyph(vec2 p, float seed) {
+    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 - 1.0)), 0.12);
+    float cross  = step(ap.y, 0.10) * step(ap.x, 0.78);
+    float spoke  = step(abs(p.y), 0.10) + step(abs(p.x), 0.10);
+    spoke = clamp(spoke, 0.0, 1.0);
+    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 s4 = fract(sin(seed * 22.1)    * 5532.111);
+    float g = 0.0;
+    g = max(g, bar   * step(0.5, s1));
+    g = max(g, ring  * step(0.4, s2));
+    g = max(g, diag  * step(0.5, s3));
+    g = max(g, cross * step(0.6, s4));
+    g = max(g, spoke * step(0.7, s1 * s4));
+    return g;
+  }
+
+  void main() {
+    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 + uRotation;
+    a = fract(a);
+
+    float bandWidth = 0.16;
+    float ringR = 0.55;
+    float ringMask = smoothstep(ringR - bandWidth, ringR - 0.02, r) * (1.0 - smoothstep(ringR + 0.02, ringR + bandWidth, r));
+    if (ringMask < 0.01) discard;
+
+    float cell = floor(a * uGlyphCount);
+    float local = fract(a * uGlyphCount) * 2.0 - 1.0;
+    float radial = (r - ringR) / bandWidth;
+
+    // Morph: hover blends two seeds together so glyphs visibly shift on hover
+    float morphSeed = cell + 1.0 + uHover * (5.0 + cell * 0.31);
+    float g = glyph(vec2(local, radial * 0.8), morphSeed);
+
+    // Soft connecting ring beneath glyphs
+    float underline = smoothstep(ringR - 0.06, ringR - 0.02, r) * (1.0 - smoothstep(ringR + 0.02, ringR + 0.06, r));
+
+    float intensity = g + underline * 0.18;
+    float alpha = ringMask * intensity * uOpacity;
+    if (alpha < 0.005) discard;
+
+    vec3 col = uColor * (1.0 + intensity * uIntensity);
+    // Hover pulse: brighten on hover
+    col += uHover * 0.3;
+    gl_FragColor = vec4(col, alpha);
+  }
+`;
+const GlyphRingCursor = ({ config, worldPosRef, hoverRef, idleMsRef, }) => {
+    const meshRef = useRef(null);
+    const { camera } = useThree();
+    const hoverSmooth = useRef(0);
+    const radius = Math.max(0.3, config.ringRadius * config.scale);
+    const geometry = useMemo(() => new THREE.PlaneGeometry(2 * radius / 0.55, 2 * radius / 0.55, 1, 1), [radius]);
+    const material = useMemo(() => new THREE.ShaderMaterial({
+        uniforms: {
+            uTime: { value: 0 },
+            uRotation: { value: 0 },
+            uGlyphCount: { value: Math.max(3, config.glyphCount) },
+            uHover: { value: 0 },
+            uIntensity: { value: config.intensity },
+            uOpacity: { value: config.opacity },
+            uColor: { value: new THREE.Color(config.color) },
+        },
+        vertexShader,
+        fragmentShader,
+        transparent: true,
+        depthWrite: false,
+        side: THREE.DoubleSide,
+        blending: THREE.AdditiveBlending,
+    }), []);
+    useEffect(() => {
+        material.uniforms.uGlyphCount.value = Math.max(3, config.glyphCount);
+        material.uniforms.uIntensity.value = config.intensity;
+        material.uniforms.uOpacity.value = config.opacity;
+        material.uniforms.uColor.value.set(config.color);
+    }, [config.glyphCount, config.intensity, config.opacity, config.color, material]);
+    useEffect(() => () => { geometry.dispose(); material.dispose(); }, [geometry, material]);
+    useFrame((state, delta) => {
+        material.uniforms.uTime.value = state.clock.getElapsedTime();
+        material.uniforms.uRotation.value += delta * config.rotationSpeed * 0.15;
+        // Smooth hover transition
+        const target = hoverRef.current ? 1 : 0;
+        hoverSmooth.current = THREE.MathUtils.damp(hoverSmooth.current, target, 6, delta);
+        material.uniforms.uHover.value = hoverSmooth.current;
+        // Idle fade via opacity uniform
+        const idleFactor = Math.max(0.15, 1 - idleMsRef.current / Math.max(config.idleFadeMs * 2, 1));
+        material.uniforms.uOpacity.value = config.opacity * idleFactor;
+        if (meshRef.current) {
+            meshRef.current.position.copy(worldPosRef.current);
+            meshRef.current.lookAt(camera.position);
+        }
+    });
+    return _jsx("mesh", { ref: meshRef, geometry: geometry, material: material, frustumCulled: false });
+};
+export default GlyphRingCursor;

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"LightningCursor.d.ts","sourceRoot":"","sources":["../../../src/components/cursor/LightningCursor.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,CAsBrE,CAAC;AACF,eAAe,eAAe,CAAC"}

package/dist/components/cursor/LightningCursor.js

@@ -0,0 +1,28 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useMemo, useRef } from 'react';
+import { useFrame } from '@react-three/fiber';
+import LightningEffect from '../effects/LightningEffect.js';
+const LightningCursor = ({ config, worldPosRef, }) => {
+    const groupRef = useRef(null);
+    const lightningConfig = useMemo(() => ({
+        enabled: true,
+        intensity: config.intensity,
+        speed: 1,
+        color: config.color,
+        opacity: config.opacity,
+        boltCount: 3,
+        branchDepth: Math.max(2, Math.min(5, Math.floor(config.segmentCount / 2))),
+        branchProbability: config.jitter,
+        glowColor: config.color,
+        flickerRate: 14,
+        strikeRadius: config.arcRange,
+    }), [config]);
+    useFrame(() => {
+        if (!groupRef.current)
+            return;
+        groupRef.current.position.copy(worldPosRef.current);
+        groupRef.current.scale.setScalar(config.scale);
+    });
+    return (_jsx("group", { ref: groupRef, children: _jsx(LightningEffect, { boundingRadius: 0.25, config: lightningConfig }) }));
+};
+export default LightningCursor;

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

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

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

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

package/dist/components/cursor/LiquidMetalCursor.js

@@ -0,0 +1,61 @@
+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 LiquidMetalCursor = ({ config, worldPosRef, velocityRef, }) => {
+    const groupRef = useRef(null);
+    const meshRef = useRef(null);
+    const geometry = useMemo(() => new THREE.IcosahedronGeometry(0.18, 4), []);
+    const basePositions = useMemo(() => {
+        const arr = geometry.attributes.position.array;
+        return new Float32Array(arr);
+    }, [geometry]);
+    const material = useMemo(() => new THREE.MeshPhysicalMaterial({
+        color: config.color,
+        metalness: config.metalness,
+        roughness: config.roughness,
+        clearcoat: 1.0,
+        clearcoatRoughness: 0.1,
+        envMapIntensity: 1.5,
+        transparent: true,
+        opacity: config.opacity,
+    }), []);
+    useEffect(() => {
+        material.color.set(config.color);
+        material.metalness = config.metalness;
+        material.roughness = config.roughness;
+        material.opacity = config.opacity;
+    }, [config.color, config.metalness, config.roughness, config.opacity, material]);
+    useEffect(() => () => {
+        geometry.dispose();
+        material.dispose();
+    }, [geometry, material]);
+    useFrame((state) => {
+        if (!groupRef.current)
+            return;
+        groupRef.current.position.copy(worldPosRef.current);
+        const speed = velocityRef.current.length();
+        const wobble = Math.min(speed * 0.08, 0.4);
+        const t = state.clock.getElapsedTime() * config.morphSpeed;
+        // Vertex displacement for the morphing blob look
+        const posAttr = geometry.attributes.position;
+        const arr = posAttr.array;
+        for (let i = 0; i < arr.length; i += 3) {
+            const x = basePositions[i];
+            const y = basePositions[i + 1];
+            const z = basePositions[i + 2];
+            const n = Math.sin(x * 3 + t) * Math.cos(y * 3 + t * 1.3) * Math.sin(z * 3 + t * 0.7);
+            const k = 1 + (n * 0.15 + wobble * 0.2);
+            arr[i] = x * k;
+            arr[i + 1] = y * k;
+            arr[i + 2] = z * k;
+        }
+        posAttr.needsUpdate = true;
+        geometry.computeVertexNormals();
+        if (meshRef.current) {
+            meshRef.current.scale.setScalar(config.scale * (1 + wobble * 0.3));
+        }
+    });
+    return (_jsx("group", { ref: groupRef, children: _jsx("mesh", { ref: meshRef, geometry: geometry, material: material }) }));
+};
+export default LiquidMetalCursor;

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

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

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

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

package/dist/components/cursor/OrbCursor.js

@@ -0,0 +1,32 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useMemo, useRef } from 'react';
+import { useFrame } from '@react-three/fiber';
+import OrbEffect from '../effects/OrbEffect.js';
+const OrbCursor = ({ config, worldPosRef, idleMsRef, }) => {
+    const groupRef = useRef(null);
+    const orbConfig = useMemo(() => ({
+        enabled: true,
+        intensity: config.intensity,
+        speed: 1,
+        color: config.color,
+        opacity: config.opacity,
+        coreSize: 0.4,
+        glowLayers: 2,
+        innerColor: config.innerColor,
+        outerColor: config.outerColor,
+        coronaEnabled: false,
+        coronaColor: config.color,
+        noiseAmount: 0.5,
+        pulseSpeed: config.pulseSpeed,
+    }), [config]);
+    useFrame(() => {
+        if (!groupRef.current)
+            return;
+        groupRef.current.position.copy(worldPosRef.current);
+        const idleFactor = Math.max(0, 1 - idleMsRef.current / Math.max(config.idleFadeMs, 1));
+        const s = config.scale * (0.85 + 0.15 * idleFactor);
+        groupRef.current.scale.setScalar(s);
+    });
+    return (_jsx("group", { ref: groupRef, children: _jsx(OrbEffect, { boundingRadius: 0.15, config: orbConfig }) }));
+};
+export default OrbCursor;

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"PlasmaWhipCursor.d.ts","sourceRoot":"","sources":["../../../src/components/cursor/PlasmaWhipCursor.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;AAiE1D,QAAA,MAAM,gBAAgB,EAAE,KAAK,CAAC,EAAE,CAAC,eAAe,CAAC,sBAAsB,CAAC,CAiEvE,CAAC;AACF,eAAe,gBAAgB,CAAC"}

package/dist/components/cursor/PlasmaWhipCursor.js

@@ -0,0 +1,134 @@
+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_POINTS = 64;
+const vertexShader = /* glsl */ `
+  varying vec2 vUv;
+  void main() {
+    vUv = uv;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+  }
+`;
+const fragmentShader = /* glsl */ `
+  uniform vec3  uColor;
+  uniform float uOpacity;
+  uniform float uTime;
+  uniform float uFlowSpeed;
+  varying vec2  vUv;
+
+  float hash(vec2 p) { return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453); }
+  float noise(vec2 p) {
+    vec2 i = floor(p);
+    vec2 f = fract(p);
+    f = f * f * (3.0 - 2.0 * f);
+    return mix(
+      mix(hash(i + vec2(0,0)), hash(i + vec2(1,0)), f.x),
+      mix(hash(i + vec2(0,1)), hash(i + vec2(1,1)), f.x),
+      f.y);
+  }
+  float fbm(vec2 p) {
+    float v = 0.0;
+    float a = 0.5;
+    for (int i = 0; i < 5; i++) {
+      v += a * noise(p);
+      p *= 2.13;
+      a *= 0.5;
+    }
+    return v;
+  }
+
+  void main() {
+    // vUv.x runs along the tube; vUv.y wraps around.
+    float t = uTime * uFlowSpeed;
+    vec2 p = vec2(vUv.x * 8.0 - t * 1.2, vUv.y * 4.0 + t * 0.6);
+    float n = fbm(p);
+
+    // Hot core + cooler shell
+    vec3 hot   = vec3(1.0, 0.95, 0.7);
+    vec3 mid   = uColor;
+    vec3 cold  = uColor * 0.35 + vec3(0.0, 0.0, 0.05);
+    vec3 col = mix(cold, mid, smoothstep(0.2, 0.6, n));
+    col = mix(col, hot, smoothstep(0.7, 0.95, n));
+
+    // Head emphasis (uv.x near 1)
+    float head = smoothstep(0.85, 1.0, vUv.x);
+    col += head * 0.5;
+
+    // Tail fade
+    float tailFade = smoothstep(0.0, 0.15, vUv.x);
+
+    // Surface highlight via noise contrast
+    float rim = pow(n, 2.0);
+    float alpha = (0.45 + rim * 0.65) * uOpacity * tailFade;
+    if (alpha < 0.005) discard;
+    gl_FragColor = vec4(col, alpha);
+  }
+`;
+const PlasmaWhipCursor = ({ config, worldPosRef, hoverRef, idleMsRef, }) => {
+    const N = Math.min(MAX_POINTS, Math.max(4, config.pointCount));
+    const history = useMemo(() => {
+        const arr = [];
+        for (let i = 0; i < MAX_POINTS; i++)
+            arr.push(new THREE.Vector3());
+        return arr;
+    }, []);
+    const meshRef = useRef(null);
+    const geometryRef = useRef(null);
+    const firstFrame = useRef(true);
+    const material = useMemo(() => new THREE.ShaderMaterial({
+        uniforms: {
+            uColor: { value: new THREE.Color(config.color) },
+            uOpacity: { value: config.opacity },
+            uTime: { value: 0 },
+            uFlowSpeed: { value: config.flowSpeed },
+        },
+        vertexShader,
+        fragmentShader,
+        transparent: true,
+        depthWrite: false,
+        blending: THREE.AdditiveBlending,
+        side: THREE.DoubleSide,
+    }), []);
+    useEffect(() => {
+        material.uniforms.uColor.value.set(config.color);
+        material.uniforms.uOpacity.value = config.opacity;
+        material.uniforms.uFlowSpeed.value = config.flowSpeed;
+    }, [config.color, config.opacity, config.flowSpeed, material]);
+    useEffect(() => () => {
+        material.dispose();
+        geometryRef.current?.dispose();
+    }, [material]);
+    useFrame((state) => {
+        material.uniforms.uTime.value = state.clock.getElapsedTime();
+        const wp = worldPosRef.current;
+        if (firstFrame.current) {
+            for (let i = 0; i < MAX_POINTS; i++)
+                history[i].copy(wp);
+            firstFrame.current = false;
+        }
+        // Shift history (newest at index 0)
+        for (let i = MAX_POINTS - 1; i > 0; i--)
+            history[i].copy(history[i - 1]);
+        history[0].copy(wp);
+        // Build curve from first N history points (oldest to newest, reversed)
+        const pts = [];
+        for (let i = N - 1; i >= 0; i--)
+            pts.push(history[i]);
+        // Skip if all points are identical (e.g. first frame)
+        const curve = new THREE.CatmullRomCurve3(pts, false, 'catmullrom', 0.5);
+        const hoverBoost = hoverRef.current ? 1.4 : 1.0;
+        const idleFactor = Math.max(0, 1 - idleMsRef.current / Math.max(config.idleFadeMs, 1));
+        const radius = config.thickness * config.scale * (0.4 + idleFactor * 0.6) * hoverBoost;
+        const tubular = Math.max(8, N * 2);
+        const newGeo = new THREE.TubeGeometry(curve, tubular, radius, 8, false);
+        if (meshRef.current) {
+            meshRef.current.geometry = newGeo;
+        }
+        if (geometryRef.current)
+            geometryRef.current.dispose();
+        geometryRef.current = newGeo;
+    });
+    return _jsx("mesh", { ref: meshRef, material: material, frustumCulled: false });
+};
+export default PlasmaWhipCursor;

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

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

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

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