@3driseai/3drise-viewer 0.1.1

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

@@ -0,0 +1,149 @@
+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';
+// Pseudo-Voronoi by sampling random seed points in a disk and approximating
+// each cell as the seed + its 2 nearest neighbors as a small triangle. Cheap,
+// stable, no full Voronoi diagram needed.
+function buildShards(count, radius) {
+    const seeds = [];
+    for (let i = 0; i < count; i++) {
+        const a = Math.random() * Math.PI * 2;
+        const r = Math.sqrt(Math.random()) * radius;
+        seeds.push({ x: Math.cos(a) * r, z: Math.sin(a) * r });
+    }
+    const shards = [];
+    for (let i = 0; i < count; i++) {
+        const s = seeds[i];
+        // Find 2 nearest other seeds
+        let n1 = -1, n2 = -1, d1 = Infinity, d2 = Infinity;
+        for (let j = 0; j < count; j++) {
+            if (j === i)
+                continue;
+            const dx = seeds[j].x - s.x;
+            const dz = seeds[j].z - s.z;
+            const d = dx * dx + dz * dz;
+            if (d < d1) {
+                d2 = d1;
+                n2 = n1;
+                d1 = d;
+                n1 = j;
+            }
+            else if (d < d2) {
+                d2 = d;
+                n2 = j;
+            }
+        }
+        if (n1 < 0 || n2 < 0)
+            continue;
+        // Midpoints toward neighbors form the shard triangle
+        const m1x = (s.x + seeds[n1].x) * 0.5;
+        const m1z = (s.z + seeds[n1].z) * 0.5;
+        const m2x = (s.x + seeds[n2].x) * 0.5;
+        const m2z = (s.z + seeds[n2].z) * 0.5;
+        const cx = (s.x + m1x + m2x) / 3;
+        const cz = (s.z + m1z + m2z) / 3;
+        // Scatter velocity radially outward + slight upward
+        const len = Math.max(Math.hypot(cx, cz), 0.001);
+        const outX = cx / len, outZ = cz / len;
+        shards.push({
+            vertices: [s.x, s.z, m1x, m1z, m2x, m2z],
+            centerX: cx,
+            centerZ: cz,
+            velocity: new THREE.Vector3(outX * (1 + Math.random()), 0.5 + Math.random() * 1.2, outZ * (1 + Math.random())),
+            angularVelocity: new THREE.Vector3((Math.random() - 0.5) * 8, (Math.random() - 0.5) * 8, (Math.random() - 0.5) * 8),
+        });
+    }
+    return shards;
+}
+const fragmentShader = /* glsl */ `
+  uniform float uProgress;
+  uniform vec3  uColor;
+  void main() {
+    float fade = 1.0 - smoothstep(0.6, 1.0, uProgress);
+    if (fade < 0.005) discard;
+    gl_FragColor = vec4(uColor * (1.0 + (1.0 - uProgress) * 0.5), fade);
+  }
+`;
+const vertexShader = /* glsl */ `
+  void main() {
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+  }
+`;
+const VoronoiFractureAction = ({ worldPos, config, onDone }) => {
+    const startRef = useRef(null);
+    const groupRef = useRef(null);
+    const COUNT = Math.max(6, Math.floor(config.shardCount ?? 24));
+    const RADIUS = config.scale ?? 1.2;
+    const { shards, geometry, material } = useMemo(() => {
+        const s = buildShards(COUNT, RADIUS);
+        // One BufferGeometry per shard would balloon draw calls. Instead, build one
+        // merged geometry with all triangles, and translate each triangle into its
+        // own group via per-vertex offset attribute updated each frame.
+        const positions = new Float32Array(s.length * 9);
+        const offsets = new Float32Array(s.length * 9);
+        for (let i = 0; i < s.length; i++) {
+            const v = s[i].vertices;
+            const base = i * 9;
+            positions[base + 0] = v[0];
+            positions[base + 1] = 0;
+            positions[base + 2] = v[1];
+            positions[base + 3] = v[2];
+            positions[base + 4] = 0;
+            positions[base + 5] = v[3];
+            positions[base + 6] = v[4];
+            positions[base + 7] = 0;
+            positions[base + 8] = v[5];
+        }
+        const g = new THREE.BufferGeometry();
+        g.setAttribute('position', new THREE.BufferAttribute(positions, 3));
+        g.setAttribute('aOffset', new THREE.BufferAttribute(offsets, 3));
+        const m = new THREE.ShaderMaterial({
+            uniforms: {
+                uProgress: { value: 0 },
+                uColor: { value: new THREE.Color(config.color) },
+            },
+            vertexShader: /* glsl */ `
+        attribute vec3 aOffset;
+        void main() {
+          gl_Position = projectionMatrix * modelViewMatrix * vec4(position + aOffset, 1.0);
+        }
+      `,
+            fragmentShader,
+            transparent: true,
+            depthWrite: false,
+            side: THREE.DoubleSide,
+        });
+        return { shards: s, geometry: g, material: m };
+    }, []);
+    useEffect(() => () => { geometry.dispose(); material.dispose(); }, [geometry, material]);
+    useFrame((state, delta) => {
+        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;
+        const offsets = geometry.attributes.aOffset;
+        for (let i = 0; i < shards.length; i++) {
+            const sh = shards[i];
+            // Integrate velocity (with gravity)
+            sh.velocity.y -= 3 * delta;
+            const dx = sh.velocity.x * delta;
+            const dy = sh.velocity.y * delta;
+            const dz = sh.velocity.z * delta;
+            const base = i * 9;
+            // Update offset for all 3 verts uniformly
+            for (let k = 0; k < 3; k++) {
+                const idx = base + k * 3;
+                offsets.array[idx + 0] += dx;
+                offsets.array[idx + 1] += dy;
+                offsets.array[idx + 2] += dz;
+            }
+        }
+        offsets.needsUpdate = true;
+        if (p >= 1)
+            onDone();
+    });
+    return _jsx("mesh", { ref: groupRef, position: worldPos, geometry: geometry, material: material, frustumCulled: false });
+};
+export default VoronoiFractureAction;

package/dist/components/effects/AuraEffect.d.ts

@@ -0,0 +1,10 @@
+import React from "react";
+import type { AuraConfig, AnimationOptions } from "@3driseai/3drise-core";
+interface AuraEffectProps {
+    boundingRadius: number;
+    config: AuraConfig;
+    animations?: AnimationOptions[];
+}
+declare const AuraEffect: React.FC<AuraEffectProps>;
+export default AuraEffect;
+//# sourceMappingURL=AuraEffect.d.ts.map

package/dist/components/effects/AuraEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AuraEffect.d.ts","sourceRoot":"","sources":["../../../src/components/effects/AuraEffect.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,KAAK,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAC1E,UAAU,eAAe;IACrB,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,UAAU,CAAC;IACnB,UAAU,CAAC,EAAE,gBAAgB,EAAE,CAAC;CACnC;AAgFD,QAAA,MAAM,UAAU,EAAE,KAAK,CAAC,EAAE,CAAC,eAAe,CA2CzC,CAAC;AACF,eAAe,UAAU,CAAC"}

package/dist/components/effects/AuraEffect.js

@@ -0,0 +1,127 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useRef, useMemo } from 'react';
+import { useFrame } from '@react-three/fiber';
+import * as THREE from 'three';
+import { applyGenerativeAnimations } from '../../utils/handleGenerativeEffectsAnimations.js';
+const vertexShader = /* glsl */ `
+  varying vec3 vNormal;
+  varying vec3 vViewDir;
+  varying vec3 vWorldNormal;
+
+  void main() {
+    vNormal       = normalize(normalMatrix * normal);
+    vWorldNormal  = normalize((modelMatrix * vec4(normal, 0.0)).xyz);
+    vec4 mv       = modelViewMatrix * vec4(position, 1.0);
+    vViewDir      = normalize(-mv.xyz);
+    gl_Position   = projectionMatrix * mv;
+  }
+`;
+const fragmentShader = /* glsl */ `
+  uniform float u_time;
+  uniform float uFresnelPower;
+  uniform float uPulseSpeed;
+  uniform float uNoiseAmount;
+  uniform float uOpacity;
+  uniform float uLayerIndex;  // 0..1
+  uniform float uBaseHue;
+  uniform float uIntensity;
+
+  varying vec3 vNormal;
+  varying vec3 vViewDir;
+  varying vec3 vWorldNormal;
+
+  // ── HSV helper ────────────────────────────────────────────────────────────
+  vec3 hsv2rgb(float h, float s, float v) {
+    vec3 rgb = clamp(abs(mod(h*6.0+vec3(0.,4.,2.),6.)-3.)-1.,0.,1.);
+    return v * mix(vec3(1.0), rgb, s);
+  }
+
+  // ── 3D value noise + 4-octave FBM ─────────────────────────────────────────
+  float hash(vec3 p){ return fract(sin(dot(p,vec3(127.1,311.7,74.7)))*43758.5453); }
+  float noise(vec3 p){
+    vec3 i=floor(p); vec3 f=fract(p); f=f*f*(3.-2.*f);
+    return mix(mix(mix(hash(i),         hash(i+vec3(1,0,0)),f.x),
+                   mix(hash(i+vec3(0,1,0)),hash(i+vec3(1,1,0)),f.x),f.y),
+               mix(mix(hash(i+vec3(0,0,1)),hash(i+vec3(1,0,1)),f.x),
+                   mix(hash(i+vec3(0,1,1)),hash(i+vec3(1,1,1)),f.x),f.y),f.z);
+  }
+  float fbm(vec3 p){
+    float v=0., a=0.5;
+    for(int i=0;i<4;i++){ v+=a*noise(p); p=p*2.17+vec3(1.7,9.2,3.7); a*=0.5; }
+    return v;
+  }
+
+  void main() {
+    vec3 viewDir = normalize(vViewDir);
+
+    // ── Fresnel ────────────────────────────────────────────────────────────
+    float ndv     = abs(dot(vNormal, viewDir));
+    float fresnel = pow(1.0 - ndv, uFresnelPower);
+
+    // ── 4-octave FBM noise ─────────────────────────────────────────────────
+    float f = fbm(vWorldNormal * 3.5 + u_time * 0.18);
+
+    // ── Iridescence: hue shifts with view angle AND time ───────────────────
+    float hue     = mod(uBaseHue + ndv * 0.45 - uLayerIndex * 0.15 + u_time * 0.04, 1.0);
+    vec3  iriCol  = hsv2rgb(hue, 0.85, 1.0);
+
+    // ── Electric tendrils: sharp bright streaks where FBM exceeds threshold ─
+    float tendrils = smoothstep(0.60, 0.75, f + uLayerIndex * 0.05);
+
+    // ── Pulse per layer (staggered phase) ──────────────────────────────────
+    float pulse = 0.65 + 0.35 * sin(u_time * uPulseSpeed + uLayerIndex * 2.1);
+
+    // ── Combine ────────────────────────────────────────────────────────────
+    float noiseBlend = (1.0 - uNoiseAmount) + uNoiseAmount * f;
+    float alpha = fresnel * noiseBlend * uOpacity * pulse * (1.0 - uLayerIndex * 0.22) * uIntensity;
+    if (alpha < 0.004) discard;
+
+    vec3 col = iriCol + iriCol * tendrils * 1.8;
+    gl_FragColor = vec4(col, alpha);
+  }
+`;
+const AuraEffect = ({ boundingRadius, config, animations }) => {
+    const { layerCount, fresnelPower, pulseSpeed, innerColor, outerColor, noiseAmount, sizeMultiplier, opacity, speed, intensity } = config;
+    const startValuesCacheRef = useRef({});
+    // Derive a single base hue from the innerColor
+    const baseHue = useMemo(() => {
+        const c = new THREE.Color(innerColor);
+        const h = { h: 0, s: 0, l: 0 };
+        c.getHSL(h);
+        return h.h;
+    }, [innerColor]);
+    const materials = useMemo(() => Array.from({ length: layerCount }, (_, i) => new THREE.ShaderMaterial({
+        vertexShader,
+        fragmentShader,
+        uniforms: {
+            u_time: { value: 0 },
+            uFresnelPower: { value: fresnelPower },
+            uPulseSpeed: { value: pulseSpeed * speed },
+            uNoiseAmount: { value: noiseAmount },
+            uOpacity: { value: opacity },
+            uLayerIndex: { value: layerCount > 1 ? i / (layerCount - 1) : 0 },
+            uBaseHue: { value: baseHue },
+            uIntensity: { value: intensity },
+        },
+        transparent: true,
+        depthWrite: false,
+        blending: THREE.AdditiveBlending,
+        side: THREE.BackSide,
+    })), [layerCount, fresnelPower, pulseSpeed, speed, noiseAmount, opacity, baseHue, intensity]);
+    useFrame((state) => {
+        const t = state.clock.getElapsedTime();
+        for (const mat of materials)
+            mat.uniforms.u_time.value = t;
+        if (animations?.length) {
+            applyGenerativeAnimations(materials, animations, startValuesCacheRef.current, Date.now(), false);
+        }
+    });
+    const baseR = boundingRadius * sizeMultiplier;
+    return (_jsx("group", { children: Array.from({ length: layerCount }, (_, i) => {
+            // Non-linear layer spacing: outer layers spread wider
+            const layerT = layerCount > 1 ? i / (layerCount - 1) : 0;
+            const r = baseR * (1 + layerT * layerT * 0.5);
+            return (_jsx("mesh", { material: materials[i], children: _jsx("sphereGeometry", { args: [r, 40, 40] }) }, i));
+        }) }));
+};
+export default AuraEffect;

package/dist/components/effects/AuroraEffect.d.ts

@@ -0,0 +1,10 @@
+import React from "react";
+import type { AuroraConfig, AnimationOptions } from "@3driseai/3drise-core";
+interface AuroraEffectProps {
+    boundingRadius: number;
+    config: AuroraConfig;
+    animations?: AnimationOptions[];
+}
+declare const AuroraEffect: React.FC<AuroraEffectProps>;
+export default AuroraEffect;
+//# sourceMappingURL=AuroraEffect.d.ts.map

package/dist/components/effects/AuroraEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AuroraEffect.d.ts","sourceRoot":"","sources":["../../../src/components/effects/AuroraEffect.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,KAAK,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAC5E,UAAU,iBAAiB;IACvB,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,YAAY,CAAC;IACrB,UAAU,CAAC,EAAE,gBAAgB,EAAE,CAAC;CACnC;AAqDD,QAAA,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC,iBAAiB,CAuD7C,CAAC;AACF,eAAe,YAAY,CAAC"}

package/dist/components/effects/AuroraEffect.js

@@ -0,0 +1,112 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useRef, useMemo } from 'react';
+import { useFrame } from '@react-three/fiber';
+import * as THREE from 'three';
+import { applyGenerativeAnimations } from '../../utils/handleGenerativeEffectsAnimations.js';
+const ribbonVert = /* glsl */ `
+  uniform float u_time;
+  uniform float uPhase;
+  uniform float u_speed;
+  uniform float uWaveAmp;
+  varying vec2  vUv;
+
+  void main() {
+    vec3 pos = position;
+    float w1 = sin(pos.y * 2.5 + u_time * u_speed + uPhase)         * uWaveAmp;
+    float w2 = sin(pos.y * 1.2 - u_time * u_speed * 0.7 + uPhase * 1.3) * uWaveAmp * 0.5;
+    float w3 = sin(pos.y * 4.1 + u_time * u_speed * 1.3 + uPhase * 2.1) * uWaveAmp * 0.18;
+    pos.x += w1 + w2 + w3;
+    pos.z += sin(pos.y * 3.0 + u_time * u_speed * 0.5 + uPhase * 0.7) * uWaveAmp * 0.3;
+    vUv = uv;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(pos, 1.0);
+  }
+`;
+const ribbonFrag = /* glsl */ `
+  uniform float u_time;
+  uniform float uHue;
+  uniform float uOpacity;
+  uniform float uIntensity;
+  varying vec2  vUv;
+
+  vec3 hsl2rgb(float h, float s, float l) {
+    vec3 rgb = clamp(abs(mod(h * 6.0 + vec3(0.0, 4.0, 2.0), 6.0) - 3.0) - 1.0, 0.0, 1.0);
+    return l + s * (rgb - 0.5) * (1.0 - abs(2.0 * l - 1.0));
+  }
+
+  void main() {
+    // Soft fade top and bottom
+    float fade = sin(vUv.y * 3.14159);
+    fade = pow(fade, 0.6); // bias toward middle
+
+    // Vertical shimmer bands (curtain rays)
+    float shimmer = 0.55 + 0.45 * sin(vUv.y * 22.0 + u_time * 2.4 + uHue * 9.0);
+
+    // Horizontal soft edge fade
+    float hEdge = smoothstep(0.0, 0.18, vUv.x) * smoothstep(1.0, 0.82, vUv.x);
+
+    // Color: hue drifts upward and over time
+    float hue = mod(uHue + vUv.y * 0.14 + u_time * 0.022, 1.0);
+    vec3  col = hsl2rgb(hue, 0.92, 0.58 + shimmer * 0.12);
+
+    float alpha = fade * shimmer * hEdge * uOpacity * uIntensity;
+    if (alpha < 0.005) discard;
+    gl_FragColor = vec4(col, alpha);
+  }
+`;
+const AuroraEffect = ({ boundingRadius, config, animations }) => {
+    const { ribbonCount, waveAmplitude, colorShift, arcWidth, opacity, speed, intensity } = config;
+    const groupRef = useRef(null);
+    const ribbons = useMemo(() => {
+        const N = Math.max(3, Math.min(ribbonCount, 10));
+        const r = boundingRadius;
+        const w = r * 0.9;
+        const h = r * 2.2;
+        const rad = r * 1.35;
+        // Aurora spectrum: green → teal → cyan → violet
+        const hues = [0.33, 0.38, 0.45, 0.50, 0.57, 0.65, 0.72, 0.78, 0.82, 0.87];
+        return Array.from({ length: N }, (_, i) => {
+            const t = N === 1 ? 0.5 : i / (N - 1);
+            const angle = (t - 0.5) * arcWidth * Math.PI; // spread across arc
+            const hue = (colorShift + hues[i % hues.length]) % 1;
+            const geo = new THREE.PlaneGeometry(w, h, 1, 24);
+            const mat = new THREE.ShaderMaterial({
+                vertexShader: ribbonVert,
+                fragmentShader: ribbonFrag,
+                uniforms: {
+                    u_time: { value: 0 },
+                    uPhase: { value: i * 1.13 + t * Math.PI * 2 },
+                    u_speed: { value: 0.55 + Math.random() * 0.3 },
+                    uWaveAmp: { value: waveAmplitude * r * 0.55 },
+                    uHue: { value: hue },
+                    uOpacity: { value: opacity },
+                    uIntensity: { value: intensity },
+                },
+                transparent: true,
+                depthWrite: false,
+                blending: THREE.AdditiveBlending,
+                side: THREE.DoubleSide,
+            });
+            // Position ribbon in arc — tilted slightly inward to wrap over the object
+            const mesh = new THREE.Mesh(geo, mat);
+            mesh.position.set(Math.sin(angle) * rad, r * 0.55, // float above object
+            -Math.cos(angle) * rad);
+            mesh.rotation.y = angle; // face inward
+            mesh.rotation.x = 0.08; // slight forward tilt
+            return { mesh, mat };
+        });
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [ribbonCount, waveAmplitude, colorShift, arcWidth, opacity, intensity, boundingRadius]);
+    const startValuesCacheRef = useRef({});
+    useFrame((state, delta) => {
+        if (!groupRef.current)
+            return;
+        const t = state.clock.getElapsedTime();
+        ribbons.forEach(({ mat }) => { mat.uniforms.u_time.value = t; });
+        groupRef.current.rotation.y += delta * speed * 0.06;
+        if (animations?.length) {
+            applyGenerativeAnimations(ribbons.map(({ mat }) => mat), animations, startValuesCacheRef.current, Date.now(), false);
+        }
+    });
+    return (_jsx("group", { ref: groupRef, children: ribbons.map(({ mesh }, i) => (_jsx("primitive", { object: mesh }, i))) }));
+};
+export default AuroraEffect;

package/dist/components/effects/BlackHoleEffect.d.ts

@@ -0,0 +1,10 @@
+import React from "react";
+import type { BlackHoleConfig, AnimationOptions } from "@3driseai/3drise-core";
+interface BlackHoleEffectProps {
+    boundingRadius: number;
+    config: BlackHoleConfig;
+    animations?: AnimationOptions[];
+}
+declare const BlackHoleEffect: React.FC<BlackHoleEffectProps>;
+export default BlackHoleEffect;
+//# sourceMappingURL=BlackHoleEffect.d.ts.map

package/dist/components/effects/BlackHoleEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlackHoleEffect.d.ts","sourceRoot":"","sources":["../../../src/components/effects/BlackHoleEffect.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAC/E,UAAU,oBAAoB;IAC1B,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,eAAe,CAAC;IACxB,UAAU,CAAC,EAAE,gBAAgB,EAAE,CAAC;CACnC;AAsHD,QAAA,MAAM,eAAe,EAAE,KAAK,CAAC,EAAE,CAAC,oBAAoB,CAuEnD,CAAC;AACF,eAAe,eAAe,CAAC"}

package/dist/components/effects/BlackHoleEffect.js

@@ -0,0 +1,193 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { useRef, useMemo } from 'react';
+import { useFrame } from '@react-three/fiber';
+import * as THREE from 'three';
+import { applyGenerativeAnimations } from '../../utils/handleGenerativeEffectsAnimations.js';
+// ── Accretion disk shader ─────────────────────────────────────────────────────
+const diskVert = /* glsl */ `
+  varying vec2 vUv;
+  void main() { vUv = uv; gl_Position = projectionMatrix * modelViewMatrix * vec4(position,1.0); }
+`;
+const diskFrag = /* glsl */ `
+  uniform float u_time;
+  uniform float uRotSpeed;
+  uniform vec3  uDiskColor;
+  uniform float uOpacity;
+  uniform float uIntensity;
+
+  varying vec2 vUv;
+
+  vec3 tempColor(float t) {
+    // t=0 outer edge (cool red), t=1 inner edge (blue-white hot)
+    vec3 outer = uDiskColor * 0.4;
+    vec3 mid   = uDiskColor;
+    vec3 inner = vec3(0.85, 0.95, 1.0) * 2.5;
+    if (t < 0.5) return mix(outer, mid,   t * 2.0);
+    else          return mix(mid,  inner, (t - 0.5) * 2.0);
+  }
+
+  float hash(float n) { return fract(sin(n) * 43758.5453); }
+
+  void main() {
+    // Polar coordinates from ring UV
+    vec2  centered = vUv * 2.0 - 1.0;
+    float dist     = length(centered);
+    if (dist > 1.0 || dist < 0.001) discard;
+
+    float angle = atan(centered.y, centered.x);
+
+    // Normalized radial position (0=inner, 1=outer)
+    float t = 1.0 - dist;
+
+    // Spiral motion bands
+    float spiral = fract(dist * 6.0 - u_time * uRotSpeed + angle / 6.28318);
+    float bands  = pow(spiral, 2.2) * 0.6 + 0.4;
+
+    // Brightness: peaks near inner edge, falls off to rim
+    float bright = pow(t, 0.7) * bands;
+
+    // Fine-grained turbulence
+    float noise = 0.85 + 0.15 * sin(angle * 7.0 + dist * 18.0 - u_time * 2.5);
+
+    vec3  col   = tempColor(t) * bright * noise;
+    float alpha = bright * noise * uOpacity * uIntensity * smoothstep(0.0, 0.08, dist);
+    if (alpha < 0.005) discard;
+    gl_FragColor = vec4(col, alpha);
+  }
+`;
+// ── Photon sphere (lensing rim) ───────────────────────────────────────────────
+const lensFrag = /* glsl */ `
+  uniform float u_time;
+  uniform vec3  uDiskColor;
+  uniform float uOpacity;
+  uniform float uIntensity;
+  varying vec3  vNormal;
+
+  void main() {
+    vec3  viewDir = normalize(cameraPosition - vNormal * 100.0);
+    float ndv     = abs(dot(normalize(vNormal), viewDir));
+    float fresnel = pow(1.0 - ndv, 2.2);
+    // Only show a bright equatorial band
+    float equator = exp(-ndv * ndv * 6.0) * 2.5;
+    float alpha   = (fresnel * 0.4 + equator * 0.6) * uOpacity * uIntensity;
+    if (alpha < 0.005) discard;
+    vec3 col = mix(uDiskColor, vec3(1.0, 0.92, 0.8), fresnel * 0.5);
+    gl_FragColor = vec4(col, alpha);
+  }
+`;
+const lensVert = /* glsl */ `
+  varying vec3 vNormal;
+  void main() {
+    vNormal = (modelMatrix * vec4(normal, 0.0)).xyz;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+  }
+`;
+// ── Jet particle shader ───────────────────────────────────────────────────────
+const jetVert = /* glsl */ `
+  attribute float aT;
+  attribute float aPhase;
+  uniform float   u_time;
+  uniform float   u_speed;
+  uniform float   uLength;
+  uniform float   uDir;    // +1 or -1
+  uniform float   uRadius;
+  varying float   vT;
+  void main() {
+    float t  = fract(aT + u_time * u_speed);
+    vT = t;
+    float r  = uRadius * (1.0 - t * 0.85);
+    float a  = aPhase + t * 4.0;
+    float x  = cos(a) * r;
+    float z  = sin(a) * r;
+    float y  = uDir * t * uLength;
+    vec4  mv = modelViewMatrix * vec4(x, y, z, 1.0);
+    gl_PointSize = (1.0 - t) * 6.0 * (200.0 / -mv.z);
+    gl_Position  = projectionMatrix * mv;
+  }
+`;
+const jetFrag = /* glsl */ `
+  uniform vec3  uJetColor;
+  uniform float uOpacity;
+  varying float vT;
+  void main() {
+    vec2  c = gl_PointCoord - 0.5;
+    if (length(c) > 0.5) discard;
+    float g = exp(-dot(c,c) * 6.0);
+    float a = g * uOpacity * (1.0 - vT) * smoothstep(0.0, 0.1, vT);
+    if (a < 0.01) discard;
+    gl_FragColor = vec4(uJetColor, a);
+  }
+`;
+const BlackHoleEffect = ({ boundingRadius, config, animations }) => {
+    const { diskColor, jetEnabled, jetColor, rotationSpeed, tilt, opacity, speed, intensity } = config;
+    const startValuesCacheRef = useRef({});
+    const groupRef = useRef(null);
+    const r = boundingRadius;
+    const { diskMat, lensMat, jetMat1, jetMat2, jetGeo } = useMemo(() => {
+        const dc = new THREE.Color(diskColor);
+        const dcv = new THREE.Vector3(dc.r, dc.g, dc.b);
+        const dMat = new THREE.ShaderMaterial({
+            vertexShader: diskVert, fragmentShader: diskFrag,
+            uniforms: {
+                u_time: { value: 0 },
+                uRotSpeed: { value: rotationSpeed },
+                uDiskColor: { value: dcv },
+                uOpacity: { value: opacity },
+                uIntensity: { value: intensity },
+            },
+            transparent: true, depthWrite: false, blending: THREE.AdditiveBlending, side: THREE.DoubleSide,
+        });
+        const lMat = new THREE.ShaderMaterial({
+            vertexShader: lensVert, fragmentShader: lensFrag,
+            uniforms: {
+                u_time: { value: 0 },
+                uDiskColor: { value: dcv },
+                uOpacity: { value: opacity },
+                uIntensity: { value: intensity },
+            },
+            transparent: true, depthWrite: false, blending: THREE.AdditiveBlending, side: THREE.BackSide,
+        });
+        // Jet geometry (shared, mirrored with uDir ±1)
+        const JN = 80;
+        const jT = new Float32Array(JN);
+        const jPhase = new Float32Array(JN);
+        for (let i = 0; i < JN; i++) {
+            jT[i] = i / JN;
+            jPhase[i] = Math.random() * Math.PI * 2;
+        }
+        const jGeo = new THREE.BufferGeometry();
+        jGeo.setAttribute('position', new THREE.BufferAttribute(new Float32Array(JN * 3), 3));
+        jGeo.setAttribute('aT', new THREE.BufferAttribute(jT, 1));
+        jGeo.setAttribute('aPhase', new THREE.BufferAttribute(jPhase, 1));
+        jGeo.frustumCulled = false;
+        const jc = new THREE.Color(jetColor);
+        const makeJetMat = (dir) => new THREE.ShaderMaterial({
+            vertexShader: jetVert, fragmentShader: jetFrag,
+            uniforms: {
+                u_time: { value: 0 },
+                u_speed: { value: speed },
+                uLength: { value: r * 2.2 },
+                uDir: { value: dir },
+                uRadius: { value: r * 0.12 },
+                uJetColor: { value: new THREE.Vector3(jc.r, jc.g, jc.b) },
+                uOpacity: { value: opacity * 0.8 },
+            },
+            transparent: true, depthWrite: false, blending: THREE.AdditiveBlending,
+        });
+        return { diskMat: dMat, lensMat: lMat, jetMat1: makeJetMat(1), jetMat2: makeJetMat(-1), jetGeo: jGeo };
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [diskColor, jetColor, rotationSpeed, opacity, intensity, speed, r]);
+    useFrame((state) => {
+        const t = state.clock.getElapsedTime();
+        diskMat.uniforms.u_time.value = t;
+        lensMat.uniforms.u_time.value = t;
+        jetMat1.uniforms.u_time.value = t;
+        jetMat2.uniforms.u_time.value = t;
+        if (animations?.length) {
+            applyGenerativeAnimations([diskMat, lensMat, jetMat1, jetMat2], animations, startValuesCacheRef.current, Date.now(), false);
+        }
+    });
+    const tiltRad = (tilt * Math.PI) / 180;
+    return (_jsxs("group", { ref: groupRef, rotation: [0, 0, tiltRad], children: [_jsx("mesh", { material: lensMat, children: _jsx("sphereGeometry", { args: [r * 0.55, 48, 48] }) }), _jsx("mesh", { material: diskMat, rotation: [Math.PI / 2, 0, 0], children: _jsx("ringGeometry", { args: [r * 0.38, r * 1.15, 72] }) }), jetEnabled && (_jsxs(_Fragment, { children: [_jsx("points", { geometry: jetGeo, material: jetMat1 }), _jsx("points", { geometry: jetGeo, material: jetMat2 })] }))] }));
+};
+export default BlackHoleEffect;

package/dist/components/effects/ConstellationEffect.d.ts

@@ -0,0 +1,10 @@
+import React from "react";
+import type { ConstellationConfig, AnimationOptions } from "@3driseai/3drise-core";
+interface ConstellationEffectProps {
+    boundingRadius: number;
+    config: ConstellationConfig;
+    animations?: AnimationOptions[];
+}
+declare const ConstellationEffect: React.FC<ConstellationEffectProps>;
+export default ConstellationEffect;
+//# sourceMappingURL=ConstellationEffect.d.ts.map

package/dist/components/effects/ConstellationEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConstellationEffect.d.ts","sourceRoot":"","sources":["../../../src/components/effects/ConstellationEffect.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,KAAK,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACnF,UAAU,wBAAwB;IAC9B,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,mBAAmB,CAAC;IAC5B,UAAU,CAAC,EAAE,gBAAgB,EAAE,CAAC;CACnC;AAiGD,QAAA,MAAM,mBAAmB,EAAE,KAAK,CAAC,EAAE,CAAC,wBAAwB,CAwF3D,CAAC;AACF,eAAe,mBAAmB,CAAC"}