@ntalmagor/3drize-viewer 0.1.25 → 0.1.26

package/dist/components/SparklesBurst.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';
+import { SparklesBurstMaterial } from '@ntalmagor/3drize-core';
+const SparklesBurst = ({ settings }) => {
+    const config = settings.config;
+    const planeSize = useMemo(() => Math.max(0.05, config.scale ?? 2.5), [config.scale]);
+    const geometry = useMemo(() => new THREE.PlaneGeometry(planeSize, planeSize, 1, 1), [planeSize]);
+    const material = useMemo(() => {
+        const m = new SparklesBurstMaterial();
+        m.transparent = true;
+        m.depthWrite = false;
+        m.side = THREE.DoubleSide;
+        m.blending = THREE.AdditiveBlending;
+        return m;
+    }, []);
+    useEffect(() => {
+        const u = material.uniforms;
+        u.uCoreColor.value.set(config.coreColor ?? '#ffffff');
+        u.uBurstColor.value.set(config.burstColor ?? '#ffaa00');
+        u.uRayCount.value = Math.max(3, config.rayCount ?? 8);
+        u.uIntensity.value = config.intensity ?? 1.0;
+        u.uOpacity.value = config.opacity ?? 1.0;
+        u.uHoverColor.value.set(config.hoverColor ?? '#ffffff');
+        u.uHoverRadius.value = config.hoverRadius ?? 0.3;
+        u.uHoverIntensity.value = config.hoverIntensity ?? 0.0;
+    }, [
+        config.coreColor,
+        config.burstColor,
+        config.rayCount,
+        config.intensity,
+        config.opacity,
+        config.hoverColor,
+        config.hoverRadius,
+        config.hoverIntensity,
+        material,
+    ]);
+    useEffect(() => () => { geometry.dispose(); material.dispose(); }, [geometry, material]);
+    // Track elapsed time JS-side so loop on/off toggles cleanly without
+    // depending on the global clock for the progress phase.
+    const startRef = useRef(null);
+    // Reset start when loop toggles so behaviour is predictable.
+    useEffect(() => { startRef.current = null; }, [config.loop, config.durationMs]);
+    useFrame((state) => {
+        const now = state.clock.getElapsedTime();
+        if (startRef.current === null)
+            startRef.current = now;
+        const elapsedMs = (now - startRef.current) * 1000;
+        const duration = Math.max(1, config.durationMs ?? 1500);
+        const loop = config.loop ?? true;
+        const progress = loop
+            ? (elapsedMs % duration) / duration
+            : Math.min(elapsedMs / duration, 1);
+        material.uniforms.uProgress.value = progress;
+        material.uniforms.uTime.value = now;
+    });
+    if (!settings.meshSettings.visible)
+        return null;
+    return _jsx("mesh", { geometry: geometry, material: material, frustumCulled: false });
+};
+export default SparklesBurst;

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

@@ -0,0 +1,6 @@
+import React from 'react';
+import type { AuraCursorConfig } from '@ntalmagor/3drize-core';
+import type { CursorTypeProps } from './CursorController';
+declare const AuraCursor: React.FC<CursorTypeProps<AuraCursorConfig>>;
+export default AuraCursor;
+//# sourceMappingURL=AuraCursor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AuraCursor.d.ts","sourceRoot":"","sources":["../../../src/components/cursor/AuraCursor.tsx"],"names":[],"mappings":"AAAA,OAAO,KAA0B,MAAM,OAAO,CAAC;AAG/C,OAAO,KAAK,EAAc,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAG3E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAE1D,QAAA,MAAM,UAAU,EAAE,KAAK,CAAC,EAAE,CAAC,eAAe,CAAC,gBAAgB,CAAC,CAkC3D,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/components/cursor/AuraCursor.js

@@ -0,0 +1,30 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useMemo, useRef } from 'react';
+import { useFrame } from '@react-three/fiber';
+import AuraEffect from '../effects/AuraEffect.js';
+const AuraCursor = ({ config, worldPosRef, idleMsRef, }) => {
+    const groupRef = useRef(null);
+    const auraConfig = useMemo(() => ({
+        enabled: true,
+        intensity: config.intensity,
+        speed: 1,
+        color: config.color,
+        opacity: config.opacity,
+        layerCount: 2,
+        fresnelPower: config.falloff,
+        pulseSpeed: 1.5,
+        innerColor: config.color,
+        outerColor: config.color,
+        noiseAmount: 0.3,
+        sizeMultiplier: 2,
+    }), [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));
+        groupRef.current.scale.setScalar(config.scale * (0.75 + 0.25 * idleFactor));
+    });
+    return (_jsx("group", { ref: groupRef, children: _jsx(AuraEffect, { boundingRadius: 0.2, config: auraConfig }) }));
+};
+export default AuraCursor;

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

@@ -0,0 +1,6 @@
+import React from 'react';
+import type { AuroraCursorConfig } from '@ntalmagor/3drize-core';
+import type { CursorTypeProps } from './CursorController';
+declare const AuroraCursor: React.FC<CursorTypeProps<AuroraCursorConfig>>;
+export default AuroraCursor;
+//# sourceMappingURL=AuroraCursor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AuroraCursor.d.ts","sourceRoot":"","sources":["../../../src/components/cursor/AuroraCursor.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAqC,MAAM,OAAO,CAAC;AAG1D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAEjE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAyE1D,QAAA,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC,eAAe,CAAC,kBAAkB,CAAC,CAsJ/D,CAAC;AAEF,eAAe,YAAY,CAAC"}

package/dist/components/cursor/AuroraCursor.js

@@ -0,0 +1,207 @@
+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 MAX_TRAIL = 200;
+const vertexShader = /* glsl */ `
+  attribute float aT;
+  uniform float uTime;
+  varying float vT;
+  varying vec2 vUv;
+  void main() {
+    vT = aT;
+    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 float vT;
+  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 < 4; i++) {
+      v += a * noise(p);
+      p *= 2.03;
+      a *= 0.5;
+    }
+    return v;
+  }
+
+  void main() {
+    // vT is 0 at the trail tail, 1 at the cursor (head).
+    // vUv.y is 0..1 across ribbon width.
+    float t = uTime * uFlowSpeed;
+    float n = fbm(vec2(vT * 6.0 - t, vUv.y * 2.0));
+
+    // Vertical curtain falloff
+    float curtain = smoothstep(0.0, 0.2, vUv.y) * (1.0 - smoothstep(0.8, 1.0, vUv.y));
+
+    // Aurora multi-band color: green/cyan/magenta mix driven by noise + uColor
+    vec3 green   = vec3(0.1, 0.95, 0.6);
+    vec3 cyan    = vec3(0.2, 0.7, 1.0);
+    vec3 magenta = vec3(0.9, 0.3, 0.95);
+    vec3 aurora = mix(green, cyan, smoothstep(0.3, 0.7, n));
+    aurora = mix(aurora, magenta, smoothstep(0.7, 0.95, n));
+    aurora = mix(aurora, uColor, 0.35);
+
+    // Head glow
+    float head = smoothstep(0.7, 1.0, vT);
+    aurora += head * 0.4;
+
+    float tailFade = smoothstep(0.0, 0.15, vT);
+    float alpha = curtain * (0.35 + n * 0.6) * tailFade * uOpacity;
+    if (alpha < 0.005) discard;
+    gl_FragColor = vec4(aurora, alpha);
+  }
+`;
+const AuroraCursor = ({ config, worldPosRef, hoverRef, idleMsRef, }) => {
+    const N = Math.min(MAX_TRAIL, Math.max(4, config.trailLength));
+    const { camera } = useThree();
+    // History positions (newest at index 0, oldest at N-1)
+    const history = useMemo(() => {
+        const arr = new Float32Array(MAX_TRAIL * 3);
+        for (let i = 0; i < MAX_TRAIL; i++)
+            arr[i * 3 + 1] = -1e6;
+        return arr;
+    }, []);
+    // 2 verts per segment, 6 indices per quad
+    const positions = useMemo(() => new Float32Array(MAX_TRAIL * 2 * 3), []);
+    const uvs = useMemo(() => new Float32Array(MAX_TRAIL * 2 * 2), []);
+    const ts = useMemo(() => new Float32Array(MAX_TRAIL * 2), []);
+    const indices = useMemo(() => new Uint16Array((MAX_TRAIL - 1) * 6), []);
+    const geometry = useMemo(() => {
+        const g = new THREE.BufferGeometry();
+        g.setAttribute('position', new THREE.BufferAttribute(positions, 3));
+        g.setAttribute('uv', new THREE.BufferAttribute(uvs, 2));
+        g.setAttribute('aT', new THREE.BufferAttribute(ts, 1));
+        // Build index buffer
+        for (let i = 0; i < MAX_TRAIL - 1; i++) {
+            const a = i * 2, b = i * 2 + 1, c = (i + 1) * 2, d = (i + 1) * 2 + 1;
+            const base = i * 6;
+            indices[base + 0] = a;
+            indices[base + 1] = b;
+            indices[base + 2] = c;
+            indices[base + 3] = b;
+            indices[base + 4] = d;
+            indices[base + 5] = c;
+        }
+        g.setIndex(new THREE.BufferAttribute(indices, 1));
+        // UV per vert
+        for (let i = 0; i < MAX_TRAIL; i++) {
+            uvs[i * 2 * 2 + 0] = i / (MAX_TRAIL - 1);
+            uvs[i * 2 * 2 + 1] = 0;
+            uvs[i * 2 * 2 + 2] = i / (MAX_TRAIL - 1);
+            uvs[i * 2 * 2 + 3] = 1;
+        }
+        return g;
+    }, [positions, uvs, ts, indices]);
+    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(() => () => { geometry.dispose(); material.dispose(); }, [geometry, material]);
+    const firstFrame = useRef(true);
+    const tmpTangent = useMemo(() => new THREE.Vector3(), []);
+    const tmpToCam = useMemo(() => new THREE.Vector3(), []);
+    const tmpSide = useMemo(() => new THREE.Vector3(), []);
+    useFrame((state) => {
+        material.uniforms.uTime.value = state.clock.getElapsedTime();
+        const wp = worldPosRef.current;
+        if (firstFrame.current) {
+            for (let i = 0; i < N; i++) {
+                history[i * 3 + 0] = wp.x;
+                history[i * 3 + 1] = wp.y;
+                history[i * 3 + 2] = wp.z;
+            }
+            firstFrame.current = false;
+        }
+        // Shift history newest-first and write current
+        history.copyWithin(3, 0, (N - 1) * 3);
+        history[0] = wp.x;
+        history[1] = wp.y;
+        history[2] = wp.z;
+        // Width tapers and hover-driven boost
+        const idleFactor = Math.max(0, 1 - idleMsRef.current / Math.max(config.idleFadeMs, 1));
+        const hoverBoost = hoverRef.current ? 1.4 : 1.0;
+        const baseWidth = config.ribbonWidth * config.scale * (0.4 + idleFactor * 0.6) * hoverBoost;
+        // Camera position for facing the ribbon
+        const cam = camera.position;
+        for (let i = 0; i < N; i++) {
+            const idx = i * 3;
+            const px = history[idx + 0], py = history[idx + 1], pz = history[idx + 2];
+            // Tangent: difference between neighbors
+            const nextIdx = Math.max(0, i - 1) * 3;
+            const prevIdx = Math.min(N - 1, i + 1) * 3;
+            tmpTangent.set(history[nextIdx + 0] - history[prevIdx + 0], history[nextIdx + 1] - history[prevIdx + 1], history[nextIdx + 2] - history[prevIdx + 2]);
+            if (tmpTangent.lengthSq() < 1e-8)
+                tmpTangent.set(1, 0, 0);
+            tmpTangent.normalize();
+            // Side = tangent × (point-to-cam)
+            tmpToCam.set(cam.x - px, cam.y - py, cam.z - pz).normalize();
+            tmpSide.crossVectors(tmpTangent, tmpToCam);
+            if (tmpSide.lengthSq() < 1e-8)
+                tmpSide.set(0, 1, 0);
+            tmpSide.normalize();
+            // Width tapers: 1 at head, 0 at tail
+            const tNorm = 1 - i / Math.max(N - 1, 1);
+            const halfW = baseWidth * (0.2 + tNorm * 0.8);
+            const v0 = i * 2 * 3;
+            const v1 = v0 + 3;
+            positions[v0 + 0] = px + tmpSide.x * halfW;
+            positions[v0 + 1] = py + tmpSide.y * halfW;
+            positions[v0 + 2] = pz + tmpSide.z * halfW;
+            positions[v1 + 0] = px - tmpSide.x * halfW;
+            positions[v1 + 1] = py - tmpSide.y * halfW;
+            positions[v1 + 2] = pz - tmpSide.z * halfW;
+            ts[i * 2 + 0] = tNorm;
+            ts[i * 2 + 1] = tNorm;
+        }
+        // Zero out unused tail past N (in case trailLength shrinks)
+        for (let i = N; i < MAX_TRAIL; i++) {
+            const v0 = i * 2 * 3;
+            const v1 = v0 + 3;
+            positions[v0 + 0] = wp.x;
+            positions[v0 + 1] = -1e6;
+            positions[v0 + 2] = wp.z;
+            positions[v1 + 0] = wp.x;
+            positions[v1 + 1] = -1e6;
+            positions[v1 + 2] = wp.z;
+        }
+        geometry.attributes.position.needsUpdate = true;
+        geometry.attributes.aT.needsUpdate = true;
+        geometry.setDrawRange(0, (N - 1) * 6);
+    });
+    return _jsx("mesh", { geometry: geometry, material: material, frustumCulled: false });
+};
+export default AuroraCursor;

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

@@ -0,0 +1,6 @@
+import React from 'react';
+import type { BubblesCursorConfig } from '@ntalmagor/3drize-core';
+import type { CursorTypeProps } from './CursorController';
+declare const BubblesCursor: React.FC<CursorTypeProps<BubblesCursorConfig>>;
+export default BubblesCursor;
+//# sourceMappingURL=BubblesCursor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"BubblesCursor.d.ts","sourceRoot":"","sources":["../../../src/components/cursor/BubblesCursor.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAqC,MAAM,OAAO,CAAC;AAG1D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAElE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAgF1D,QAAA,MAAM,aAAa,EAAE,KAAK,CAAC,EAAE,CAAC,eAAe,CAAC,mBAAmB,CAAC,CAwHjE,CAAC;AAEF,eAAe,aAAa,CAAC"}

package/dist/components/cursor/BubblesCursor.js

@@ -0,0 +1,184 @@
+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_BUBBLES = 256;
+const pointsVertexShader = /* glsl */ `
+  attribute float aAge;
+  attribute float aLife;
+  attribute float aBaseSize;
+  attribute float aPhase;
+  uniform float uTime;
+  uniform float uScale;
+  uniform float uPopWindow; // fraction at end of life used for pop
+  varying float vAgeN;
+  varying float vPopN;
+  varying float vPhase;
+  void main() {
+    vAgeN = clamp(aAge / max(aLife, 1.0), 0.0, 1.0);
+    float popStart = 1.0 - uPopWindow;
+    vPopN = (vAgeN > popStart) ? (vAgeN - popStart) / uPopWindow : 0.0;
+    vPhase = aPhase;
+    vec4 mv = modelViewMatrix * vec4(position, 1.0);
+    float wobble = 1.0 + sin(uTime * 2.0 + aPhase) * 0.06;
+    // Scale-burst during pop
+    float popBurst = 1.0 + vPopN * 1.5;
+    float size = aBaseSize * wobble * popBurst * uScale;
+    gl_PointSize = size * (300.0 / -mv.z);
+    gl_Position = projectionMatrix * mv;
+  }
+`;
+const pointsFragmentShader = /* glsl */ `
+  uniform vec3  uColor;
+  uniform float uOpacity;
+  uniform float uIridescence;
+  uniform float uTime;
+  varying float vAgeN;
+  varying float vPopN;
+  varying float vPhase;
+
+  // Thin-film interference approximation: hue shifts with fresnel angle and
+  // a per-bubble phase that animates slowly to feel alive.
+  vec3 thinFilm(float fresnel, float phase) {
+    float t = fresnel + phase * 0.15 + uTime * 0.05;
+    return vec3(
+      0.5 + 0.5 * sin(6.2831 * (t + 0.0)),
+      0.5 + 0.5 * sin(6.2831 * (t + 0.33)),
+      0.5 + 0.5 * sin(6.2831 * (t + 0.66))
+    );
+  }
+
+  void main() {
+    vec2 c = gl_PointCoord * 2.0 - 1.0;
+    float r = length(c);
+    if (r > 1.0) discard;
+
+    // Fake sphere normal: approximate Z from disk distance
+    float z = sqrt(max(0.0, 1.0 - r * r));
+    vec3 n = vec3(c.x, c.y, z);
+    vec3 viewDir = vec3(0.0, 0.0, 1.0);
+    float fresnel = pow(1.0 - max(dot(n, viewDir), 0.0), 2.5);
+
+    // Iridescent rim + dimmer center (thin film, transparent middle)
+    vec3 film = thinFilm(fresnel, vPhase);
+    vec3 col = mix(uColor, film, uIridescence);
+
+    // Specular highlight at top-left
+    float spec = pow(max(dot(n, normalize(vec3(-0.4, 0.6, 0.7))), 0.0), 32.0);
+
+    // Pop flash brightens then fades hard
+    float popFlash = vPopN * (1.0 - vPopN) * 4.0;
+
+    float lifeFade = 1.0 - smoothstep(0.85, 1.0, vAgeN) * (vPopN > 0.0 ? 0.0 : 1.0);
+    float baseAlpha = (fresnel * 0.85 + spec * 0.5 + popFlash * 0.6);
+    float alpha = baseAlpha * uOpacity * lifeFade;
+    if (alpha < 0.004) discard;
+
+    gl_FragColor = vec4(col * (1.0 + spec + popFlash), alpha);
+  }
+`;
+const BubblesCursor = ({ config, worldPosRef, velocityRef, hoverRef, idleMsRef, }) => {
+    const positions = useMemo(() => new Float32Array(MAX_BUBBLES * 3), []);
+    const velocities = useMemo(() => new Float32Array(MAX_BUBBLES * 3), []);
+    const ages = useMemo(() => new Float32Array(MAX_BUBBLES), []);
+    const lives = useMemo(() => new Float32Array(MAX_BUBBLES), []);
+    const baseSizes = useMemo(() => new Float32Array(MAX_BUBBLES), []);
+    const phases = useMemo(() => new Float32Array(MAX_BUBBLES), []);
+    const alive = useMemo(() => new Uint8Array(MAX_BUBBLES), []);
+    const geometry = useMemo(() => {
+        const g = new THREE.BufferGeometry();
+        g.setAttribute('position', new THREE.BufferAttribute(positions, 3));
+        g.setAttribute('aAge', new THREE.BufferAttribute(ages, 1));
+        g.setAttribute('aLife', new THREE.BufferAttribute(lives, 1));
+        g.setAttribute('aBaseSize', new THREE.BufferAttribute(baseSizes, 1));
+        g.setAttribute('aPhase', new THREE.BufferAttribute(phases, 1));
+        for (let i = 0; i < MAX_BUBBLES; i++)
+            positions[i * 3 + 1] = -1e6;
+        return g;
+    }, [positions, ages, lives, baseSizes, phases]);
+    const material = useMemo(() => new THREE.ShaderMaterial({
+        uniforms: {
+            uTime: { value: 0 },
+            uScale: { value: config.scale / 10 },
+            uColor: { value: new THREE.Color(config.color) },
+            uOpacity: { value: config.opacity },
+            uIridescence: { value: config.iridescence },
+            uPopWindow: { value: 0.18 },
+        },
+        vertexShader: pointsVertexShader,
+        fragmentShader: pointsFragmentShader,
+        transparent: true,
+        depthWrite: false,
+        blending: THREE.NormalBlending,
+    }), []);
+    useEffect(() => {
+        material.uniforms.uColor.value.set(config.color);
+        material.uniforms.uScale.value = config.scale / 10;
+        material.uniforms.uOpacity.value = config.opacity;
+        material.uniforms.uIridescence.value = config.iridescence;
+    }, [config.color, config.scale, config.opacity, config.iridescence, material]);
+    useEffect(() => () => { geometry.dispose(); material.dispose(); }, [geometry, material]);
+    const spawnAccum = useRef(0);
+    const startTime = useRef(0);
+    useFrame((state, delta) => {
+        material.uniforms.uTime.value = state.clock.getElapsedTime();
+        if (startTime.current === 0)
+            startTime.current = state.clock.getElapsedTime();
+        const wp = worldPosRef.current;
+        const idleFactor = Math.max(0, 1 - idleMsRef.current / Math.max(config.idleFadeMs, 1));
+        const hover = hoverRef.current;
+        const hoverBoost = hover ? 1.6 : 1.0;
+        // Spawn rate (bubbles per second)
+        spawnAccum.current += config.spawnRate * delta * (0.5 + idleFactor * 0.5) * hoverBoost;
+        let toSpawn = Math.floor(spawnAccum.current);
+        spawnAccum.current -= toSpawn;
+        const dtMs = delta * 1000;
+        let scan = 0;
+        while (toSpawn > 0 && scan < MAX_BUBBLES) {
+            if (alive[scan] === 0) {
+                const base = scan * 3;
+                // Spawn near cursor with small lateral jitter
+                positions[base + 0] = wp.x + (Math.random() - 0.5) * 0.2 * config.scale;
+                positions[base + 1] = wp.y + (Math.random() - 0.5) * 0.1 * config.scale;
+                positions[base + 2] = wp.z + (Math.random() - 0.5) * 0.2 * config.scale;
+                // Drift + float up
+                velocities[base + 0] = (Math.random() - 0.5) * 0.4 + velocityRef.current.x * 0.05;
+                velocities[base + 1] = config.floatSpeed * (0.7 + Math.random() * 0.6);
+                velocities[base + 2] = (Math.random() - 0.5) * 0.4 + velocityRef.current.z * 0.05;
+                ages[scan] = 0;
+                lives[scan] = config.lifetimeMs * (0.7 + Math.random() * 0.6);
+                baseSizes[scan] = (16 + Math.random() * 28) * (config.scale / 10);
+                phases[scan] = Math.random() * 100;
+                alive[scan] = 1;
+                toSpawn--;
+            }
+            scan++;
+        }
+        for (let j = 0; j < MAX_BUBBLES; j++) {
+            if (alive[j] === 0)
+                continue;
+            const base = j * 3;
+            ages[j] += dtMs;
+            if (ages[j] >= lives[j]) {
+                alive[j] = 0;
+                positions[base + 1] = -1e6;
+                continue;
+            }
+            // Gentle horizontal drift damping; upward drift continues
+            velocities[base + 0] *= 0.99;
+            velocities[base + 2] *= 0.99;
+            // Wobble: tiny sinusoidal horizontal nudge based on phase
+            const wobble = Math.sin(state.clock.getElapsedTime() * 1.3 + phases[j]) * 0.05;
+            positions[base + 0] += velocities[base + 0] * delta + wobble * 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;
+        geometry.attributes.aLife.needsUpdate = true;
+        geometry.attributes.aBaseSize.needsUpdate = true;
+        geometry.attributes.aPhase.needsUpdate = true;
+    });
+    return _jsx("points", { geometry: geometry, material: material, frustumCulled: false });
+};
+export default BubblesCursor;

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

@@ -0,0 +1,6 @@
+import React from 'react';
+import type { CometCursorConfig } from '@ntalmagor/3drize-core';
+import type { CursorTypeProps } from './CursorController';
+declare const CometCursor: React.FC<CursorTypeProps<CometCursorConfig>>;
+export default CometCursor;
+//# sourceMappingURL=CometCursor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"CometCursor.d.ts","sourceRoot":"","sources":["../../../src/components/cursor/CometCursor.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAqC,MAAM,OAAO,CAAC;AAG1D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAEhE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAgE1D,QAAA,MAAM,WAAW,EAAE,KAAK,CAAC,EAAE,CAAC,eAAe,CAAC,iBAAiB,CAAC,CA0J7D,CAAC;AAEF,eAAe,WAAW,CAAC"}