@3driseai/3drise-viewer 0.1.1

package/dist/components/effects/OrbEffect.js

@@ -0,0 +1,291 @@
+import { jsx as _jsx, 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';
+// ── Shared vert (normal + viewDir) ────────────────────────────────────────────
+const sharedVert = /* 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;
+  }
+`;
+// ── CORE: boiling solar surface ───────────────────────────────────────────────
+const coreFrag = /* glsl */ `
+  uniform float u_time;
+  uniform vec3  uInnerColor;
+  uniform vec3  uOuterColor;
+  uniform float uOpacity;
+  uniform float uNoiseAmount;
+  uniform float uIntensity;
+  uniform float uPulseSpeed;
+
+  varying vec3 vNormal;
+  varying vec3 vViewDir;
+  varying vec3 vWorldNormal;
+
+  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);
+  }
+  // 6-octave FBM for rich surface detail
+  float fbm(vec3 p){
+    float v=0., a=0.5;
+    for(int i=0;i<6;i++){ v+=a*noise(p); p=p*2.13+vec3(1.7,9.2,3.7); a*=0.5; }
+    return v;
+  }
+
+  void main() {
+    // Animated surface boiling — rotate noise field over time
+    vec3 nCoord = vWorldNormal * 5.5 + vec3(u_time * 0.35, u_time * 0.18, u_time * -0.22);
+    float f      = fbm(nCoord);
+
+    // Active regions: bright convective cells
+    float cells  = smoothstep(0.54, 0.72, f) * 4.0;
+    // Cool lanes between cells (slightly darker)
+    float cool   = (1.0 - smoothstep(0.38, 0.50, f)) * 0.3;
+    // Solar flares: ultra-sharp spikes where FBM peaks
+    float flares = smoothstep(0.70, 0.85, f) * 6.0;
+
+    float pulse  = 0.85 + 0.15 * sin(u_time * uPulseSpeed * 2.3);
+    float limb   = 1.0 - abs(dot(vNormal, vViewDir)) * 0.4; // limb darkening
+
+    // Color: white-hot core cells, outer-color cool lanes
+    vec3 col = mix(uOuterColor, uInnerColor, f * 1.8 + cells * 0.3);
+    col += uInnerColor * flares;
+    col -= uOuterColor * cool;
+    col *= pulse * limb * (1.0 + uNoiseAmount * cells);
+
+    float alpha = (0.85 + cells * 0.15) * uOpacity * uIntensity;
+    gl_FragColor = vec4(col, alpha);
+  }
+`;
+// ── PLASMA SHELL: iridescent + FBM tendrils ───────────────────────────────────
+const plasmaFrag = /* glsl */ `
+  uniform float u_time;
+  uniform float uLayerIndex;   // 0..1
+  uniform vec3  uInnerColor;
+  uniform vec3  uOuterColor;
+  uniform float uOpacity;
+  uniform float uNoiseAmount;
+  uniform float uPulseSpeed;
+  uniform float uIntensity;
+
+  varying vec3 vNormal;
+  varying vec3 vViewDir;
+  varying vec3 vWorldNormal;
+
+  vec3 hsv2rgb(float h, float s, float v){
+    vec3 rgb=clamp(abs(mod(h*6.+vec3(0.,4.,2.),6.)-3.)-1.,0.,1.);
+    return v*mix(vec3(1.),rgb,s);
+  }
+  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<5;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);
+    float ndv    = abs(dot(vNormal, viewDir));
+
+    // Fresnel edge glow
+    float fresnel = pow(1.0 - ndv, 2.5 - uLayerIndex);
+
+    // 5-octave FBM driven by world normal + time
+    float f = fbm(vWorldNormal * (3.0 + uLayerIndex * 2.0) + vec3(u_time * (0.15 + uLayerIndex * 0.08)));
+
+    // Iridescent hue: shifts with view angle, layer depth, and time
+    float innerHue = 0.0; // derive from innerColor
+    float hue      = mod(ndv * 0.5 - uLayerIndex * 0.2 + u_time * 0.05 + f * 0.15, 1.0);
+    vec3  iriCol   = hsv2rgb(hue, 0.9 - uLayerIndex * 0.2, 1.0);
+
+    // Electric tendrils: sharp bright streamers where FBM exceeds threshold
+    float tendril  = smoothstep(0.62 - uLayerIndex * 0.04, 0.78, f);
+    // Plasma cells: lower threshold dimmer glow
+    float plasma   = smoothstep(0.50, 0.65, f) * 0.5;
+
+    float pulse    = 0.6 + 0.4 * sin(u_time * uPulseSpeed + uLayerIndex * 2.4);
+
+    vec3 col = iriCol + iriCol * (tendril * 2.0 + plasma);
+    col      = mix(col, uInnerColor, tendril * 0.3); // brightest tendrils go white
+
+    float noiseBlend = (1.0 - uNoiseAmount) + uNoiseAmount * f;
+    float alpha = fresnel * noiseBlend * uOpacity * pulse
+                  * (1.0 - uLayerIndex * 0.28) * uIntensity;
+    if (alpha < 0.004) discard;
+
+    gl_FragColor = vec4(col, alpha);
+  }
+`;
+// ── OUTER DIFFUSE GLOW ────────────────────────────────────────────────────────
+const glowFrag = /* glsl */ `
+  uniform float u_time;
+  uniform vec3  uOuterColor;
+  uniform float uOpacity;
+  uniform float uPulseSpeed;
+
+  varying vec3 vNormal;
+  varying vec3 vViewDir;
+
+  void main() {
+    float ndv    = abs(dot(normalize(vNormal), normalize(vViewDir)));
+    float fresnel = pow(1.0 - ndv, 1.2);
+    float pulse   = 0.55 + 0.45 * sin(u_time * uPulseSpeed * 0.7 + 1.2);
+    float alpha   = fresnel * uOpacity * pulse * 0.5;
+    if (alpha < 0.003) discard;
+    // Slowly cycle hue of the outer glow
+    float hue  = mod(u_time * 0.04, 1.0);
+    vec3  tint = mix(uOuterColor, vec3(cos(hue*6.28)*0.5+0.5, cos((hue+0.33)*6.28)*0.5+0.5, cos((hue+0.67)*6.28)*0.5+0.5), 0.25);
+    gl_FragColor = vec4(tint, alpha);
+  }
+`;
+// ── CORONA RING ───────────────────────────────────────────────────────────────
+const coronaVert = /* glsl */ `
+  attribute float aAngle;
+  varying float vAngle;
+  void main() {
+    vAngle      = aAngle;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+  }
+`;
+const coronaFrag = /* glsl */ `
+  uniform float u_time;
+  uniform vec3  uCoronaColor;
+  uniform float uOpacity;
+  uniform float uIntensity;
+  varying float vAngle;
+
+  vec3 hsv2rgb(float h, float s, float v){
+    vec3 rgb=clamp(abs(mod(h*6.+vec3(0.,4.,2.),6.)-3.)-1.,0.,1.);
+    return v*mix(vec3(1.),rgb,s);
+  }
+
+  void main() {
+    // Color flows around the ring over time
+    float hue    = mod(vAngle / 6.28318 + u_time * 0.15, 1.0);
+    vec3  col    = mix(uCoronaColor, hsv2rgb(hue, 0.8, 1.0), 0.6);
+    // Pulse brightness
+    float pulse  = 0.6 + 0.4 * sin(u_time * 2.5 + vAngle * 3.0);
+    float alpha  = uOpacity * pulse * uIntensity;
+    gl_FragColor = vec4(col * (1.0 + pulse), alpha);
+  }
+`;
+const OrbEffect = ({ boundingRadius, config, animations }) => {
+    const { coreSize, glowLayers, innerColor, outerColor, coronaEnabled, coronaColor, noiseAmount, pulseSpeed, opacity, speed, intensity } = config;
+    const startValuesCacheRef = useRef({});
+    const innerColorVec = useMemo(() => { const c = new THREE.Color(innerColor); return new THREE.Vector3(c.r, c.g, c.b); }, [innerColor]);
+    const outerColorVec = useMemo(() => { const c = new THREE.Color(outerColor); return new THREE.Vector3(c.r, c.g, c.b); }, [outerColor]);
+    const coronaColorVec = useMemo(() => { const c = new THREE.Color(coronaColor); return new THREE.Vector3(c.r, c.g, c.b); }, [coronaColor]);
+    const coreR = boundingRadius * coreSize;
+    // Core material — boiling solar surface
+    const coreMat = useMemo(() => new THREE.ShaderMaterial({
+        vertexShader: sharedVert,
+        fragmentShader: coreFrag,
+        uniforms: {
+            u_time: { value: 0 },
+            uInnerColor: { value: innerColorVec },
+            uOuterColor: { value: outerColorVec },
+            uOpacity: { value: opacity },
+            uNoiseAmount: { value: noiseAmount },
+            uIntensity: { value: intensity },
+            uPulseSpeed: { value: pulseSpeed * speed },
+        },
+        transparent: true,
+        depthWrite: false,
+        blending: THREE.AdditiveBlending,
+    }), [innerColorVec, outerColorVec, opacity, noiseAmount, intensity, pulseSpeed, speed]);
+    // Plasma shell materials — one per layer
+    const shellMats = useMemo(() => Array.from({ length: glowLayers }, (_, i) => new THREE.ShaderMaterial({
+        vertexShader: sharedVert,
+        fragmentShader: plasmaFrag,
+        uniforms: {
+            u_time: { value: 0 },
+            uLayerIndex: { value: glowLayers > 1 ? i / (glowLayers - 1) : 0 },
+            uInnerColor: { value: innerColorVec },
+            uOuterColor: { value: outerColorVec },
+            uOpacity: { value: opacity },
+            uNoiseAmount: { value: noiseAmount },
+            uPulseSpeed: { value: pulseSpeed * speed },
+            uIntensity: { value: intensity },
+        },
+        transparent: true,
+        depthWrite: false,
+        blending: THREE.AdditiveBlending,
+        side: THREE.BackSide,
+    })), [glowLayers, innerColorVec, outerColorVec, opacity, noiseAmount, pulseSpeed, speed, intensity]);
+    // Outer diffuse glow
+    const glowMat = useMemo(() => new THREE.ShaderMaterial({
+        vertexShader: sharedVert,
+        fragmentShader: glowFrag,
+        uniforms: {
+            u_time: { value: 0 },
+            uOuterColor: { value: outerColorVec },
+            uOpacity: { value: opacity * 0.6 },
+            uPulseSpeed: { value: pulseSpeed * speed },
+        },
+        transparent: true,
+        depthWrite: false,
+        blending: THREE.AdditiveBlending,
+        side: THREE.BackSide,
+    }), [outerColorVec, opacity, pulseSpeed, speed]);
+    // Corona ring geometry — torus with per-vertex angle attribute for color flow
+    const { coronaGeo, coronaMat } = useMemo(() => {
+        const tubeSegs = 80;
+        const geo = new THREE.TorusGeometry(coreR * 2.8, coreR * 0.12, 8, tubeSegs);
+        const count = geo.attributes.position.count;
+        // Per-vertex angle around the ring (0 → 2π)
+        const angles = new Float32Array(count);
+        // TorusGeometry vertices go around the major circle; approximate angle from XZ
+        const pos = geo.attributes.position;
+        for (let i = 0; i < count; i++) {
+            angles[i] = Math.atan2(pos.getZ(i), pos.getX(i)) + Math.PI;
+        }
+        geo.setAttribute('aAngle', new THREE.BufferAttribute(angles, 1));
+        const mat = new THREE.ShaderMaterial({
+            vertexShader: coronaVert,
+            fragmentShader: coronaFrag,
+            uniforms: {
+                u_time: { value: 0 },
+                uCoronaColor: { value: coronaColorVec },
+                uOpacity: { value: opacity * 0.85 },
+                uIntensity: { value: intensity },
+            },
+            transparent: true,
+            depthWrite: false,
+            blending: THREE.AdditiveBlending,
+        });
+        return { coronaGeo: geo, coronaMat: mat };
+    }, [coreR, coronaColorVec, opacity, intensity]);
+    const coronaGroupRef = useRef(null);
+    const allMats = useMemo(() => [coreMat, ...shellMats, glowMat, coronaMat], [coreMat, shellMats, glowMat, coronaMat]);
+    useFrame((state, delta) => {
+        const t = state.clock.getElapsedTime();
+        for (const mat of allMats)
+            mat.uniforms.u_time.value = t;
+        // Tilt the corona ring and rotate slowly
+        if (coronaGroupRef.current) {
+            coronaGroupRef.current.rotation.z += delta * speed * 0.4;
+        }
+        if (animations?.length) {
+            applyGenerativeAnimations(allMats, animations, startValuesCacheRef.current, Date.now(), false);
+        }
+    });
+    const glowR = coreR * (3.5 + glowLayers * 0.6);
+    return (_jsxs("group", { children: [_jsx("mesh", { material: coreMat, children: _jsx("sphereGeometry", { args: [coreR, 48, 48] }) }), Array.from({ length: glowLayers }, (_, i) => {
+                const layerT = glowLayers > 1 ? i / (glowLayers - 1) : 0;
+                const r = coreR * (1.35 + layerT * layerT * 1.8);
+                return (_jsx("mesh", { material: shellMats[i], children: _jsx("sphereGeometry", { args: [r, 40, 40] }) }, i));
+            }), _jsx("mesh", { material: glowMat, children: _jsx("sphereGeometry", { args: [glowR, 32, 32] }) }), coronaEnabled && (_jsx("group", { ref: coronaGroupRef, rotation: [Math.PI * 0.18, 0, Math.PI * 0.08], children: _jsx("mesh", { geometry: coronaGeo, material: coronaMat }) }))] }));
+};
+export default OrbEffect;

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"PortalEffect.d.ts","sourceRoot":"","sources":["../../../src/components/effects/PortalEffect.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;AAgHD,QAAA,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC,iBAAiB,CA2E7C,CAAC;AACF,eAAe,YAAY,CAAC"}

package/dist/components/effects/PortalEffect.js

@@ -0,0 +1,191 @@
+import { jsx as _jsx, 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';
+// Multi-layer vortex disc
+const discVertShader = /* glsl */ `
+  varying vec2 vUv;
+  void main() {
+    vUv = uv;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+  }
+`;
+const discFragShader = /* glsl */ `
+  uniform float u_time;
+  uniform float uSpiralTurns;
+  uniform float uRotationSpeed;
+  uniform vec3  uInnerColor;
+  uniform vec3  uOuterColor;
+  uniform float uOpacity;
+  uniform float uIntensity;
+
+  varying vec2 vUv;
+
+  float hash(vec2 p){ return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453); }
+
+  void main() {
+    vec2  centered = vUv * 2.0 - 1.0;
+    float dist     = length(centered);
+    if (dist > 1.0) discard;
+
+    float angle = atan(centered.y, centered.x);
+    const float TAU = 6.28318530718;
+    float t     = u_time * uRotationSpeed;
+
+    // Three counter-rotating spiral layers
+    float s1 = fract(dist * uSpiralTurns        - angle / TAU + t);
+    float s2 = fract(dist * uSpiralTurns * 0.6  + angle / TAU - t * 1.4);
+    float s3 = fract(dist * uSpiralTurns * 2.2  - angle / TAU * 1.5 + t * 2.1);
+
+    float w3    = pow(1.0 - dist, 2.0);
+    float vortex = s1 * 0.45 + s2 * 0.30 * (1.0 - w3) + s3 * 0.60 * w3;
+
+    // Gravitational lensing rim
+    float rimRing = exp(-pow((dist - 0.92) / 0.04, 2.0)) * 3.0;
+    float rim     = pow(smoothstep(0.85, 1.0, dist), 0.7) * 1.5;
+
+    // Singularity core
+    float core        = exp(-dist * dist * 22.0) * 4.0;
+    float singularity = exp(-dist * dist * 90.0) * 8.0;
+
+    float edgeFade = 1.0 - smoothstep(0.72, 1.0, dist);
+    float noise    = hash(vec2(dist * 8.0 + t * 0.3, angle));
+    float flux     = 0.85 + 0.15 * noise;
+
+    vec3 rimLight = mix(uOuterColor * 2.0, vec3(1.0, 0.9, 0.7), rimRing * 0.5);
+    vec3 col      = mix(rimLight, uInnerColor, vortex * 0.7 + core * 0.3) * flux;
+    col += vec3(1.0, 0.95, 0.85) * (singularity + core * 0.4);
+    col += uOuterColor * rim * 0.8;
+
+    float alpha = (vortex * 0.5 + edgeFade * 0.25 + core * 0.5 + rim * 0.4 + singularity * 0.3)
+                  * uOpacity * uIntensity;
+    if (alpha < 0.008) discard;
+    gl_FragColor = vec4(col, alpha);
+  }
+`;
+// ── Event-horizon dust — GPU animated, all motion in vertex shader ────────────
+// Each particle orbits independently at a slightly perturbed radius, height, and speed.
+const dustVertShader = /* glsl */ `
+  attribute float aAngle;     // initial angle 0..TAU
+  attribute float aRadiusOff; // -0.12..+0.12 (fractional deviation from rim radius)
+  attribute float aHeightOff; // -0.08..+0.08 relative height deviation
+  attribute float aSpeed;     // orbit speed multiplier 0.3..1.7
+  attribute float aPhase;     // twinkle phase
+
+  uniform float u_time;
+  uniform float uRadius;
+  uniform float uPointSize;
+  uniform float u_speed;
+
+  varying float vAlpha;
+
+  void main() {
+    const float TAU = 6.28318530718;
+
+    float angle = aAngle + u_time * u_speed * aSpeed;
+    float r     = uRadius * (1.0 + aRadiusOff);
+    float y     = uRadius * aHeightOff * sin(angle * 2.3 + aPhase + u_time * 0.7);
+
+    vec3 pos = vec3(cos(angle) * r, y, sin(angle) * r);
+
+    // Subtle twinkle — most dust is nearly invisible, occasionally flickers bright
+    float twinkle = pow(max(0.0, sin(u_time * 1.8 + aPhase)), 6.0); // sharp spikes
+    float base    = 0.08 + 0.12 * (0.5 + 0.5 * sin(aPhase + u_time * 0.4));
+    vAlpha        = base + twinkle * 0.7;
+
+    vec4 mv      = modelViewMatrix * vec4(pos, 1.0);
+    gl_PointSize = uPointSize * (0.4 + twinkle * 1.6) * (180.0 / -mv.z);
+    gl_Position  = projectionMatrix * mv;
+  }
+`;
+const dustFragShader = /* glsl */ `
+  uniform vec3  uColor;
+  uniform float uOpacity;
+  varying float vAlpha;
+
+  void main() {
+    vec2  coord = gl_PointCoord - 0.5;
+    float dist  = length(coord);
+    if (dist > 0.5) discard;
+    float glow  = exp(-dist * dist * 9.0);
+    gl_FragColor = vec4(uColor, vAlpha * uOpacity * glow);
+  }
+`;
+const PortalEffect = ({ boundingRadius, config, animations }) => {
+    const { radius, spiralTurns, innerGlowColor, outerGlowColor, rotationSpeed, particleRingEnabled, particleCount, opacity, speed, intensity } = config;
+    const startValuesCacheRef = useRef({});
+    const r = boundingRadius * radius;
+    const innerColorVec = useMemo(() => { const c = new THREE.Color(innerGlowColor); return new THREE.Vector3(c.r, c.g, c.b); }, [innerGlowColor]);
+    const outerColorVec = useMemo(() => { const c = new THREE.Color(outerGlowColor); return new THREE.Vector3(c.r, c.g, c.b); }, [outerGlowColor]);
+    const discMaterial = useMemo(() => new THREE.ShaderMaterial({
+        vertexShader: discVertShader,
+        fragmentShader: discFragShader,
+        uniforms: {
+            u_time: { value: 0 },
+            uSpiralTurns: { value: spiralTurns },
+            uRotationSpeed: { value: rotationSpeed * speed },
+            uInnerColor: { value: innerColorVec },
+            uOuterColor: { value: outerColorVec },
+            uOpacity: { value: opacity },
+            uIntensity: { value: intensity },
+        },
+        transparent: true,
+        depthWrite: false,
+        blending: THREE.AdditiveBlending,
+        side: THREE.DoubleSide,
+    }), [spiralTurns, rotationSpeed, speed, innerColorVec, outerColorVec, opacity, intensity]);
+    // ── Event-horizon dust ──────────────────────────────────────────────────────
+    const { dustGeo, dustMat } = useMemo(() => {
+        const count = particleCount;
+        const angles = new Float32Array(count);
+        const radOffsets = new Float32Array(count);
+        const heightOffs = new Float32Array(count);
+        const speeds = new Float32Array(count);
+        const phases = new Float32Array(count);
+        for (let i = 0; i < count; i++) {
+            angles[i] = (i / count) * Math.PI * 2 + Math.random() * 0.2;
+            radOffsets[i] = (Math.random() - 0.5) * 0.24;
+            heightOffs[i] = (Math.random() - 0.5) * 0.16;
+            speeds[i] = 0.3 + Math.random() * 1.4; // wide speed spread
+            phases[i] = Math.random() * Math.PI * 2;
+        }
+        const geo = new THREE.BufferGeometry();
+        // Positions are computed entirely in vertex shader; use dummy zero positions
+        geo.setAttribute('position', new THREE.BufferAttribute(new Float32Array(count * 3), 3));
+        geo.setAttribute('aAngle', new THREE.BufferAttribute(angles, 1));
+        geo.setAttribute('aRadiusOff', new THREE.BufferAttribute(radOffsets, 1));
+        geo.setAttribute('aHeightOff', new THREE.BufferAttribute(heightOffs, 1));
+        geo.setAttribute('aSpeed', new THREE.BufferAttribute(speeds, 1));
+        geo.setAttribute('aPhase', new THREE.BufferAttribute(phases, 1));
+        // Dust color: mostly white, very slightly tinted toward innerGlowColor
+        const dustCol = new THREE.Color(innerGlowColor).lerp(new THREE.Color('#ffffff'), 0.75);
+        const dustColVec = new THREE.Vector3(dustCol.r, dustCol.g, dustCol.b);
+        const mat = new THREE.ShaderMaterial({
+            vertexShader: dustVertShader,
+            fragmentShader: dustFragShader,
+            uniforms: {
+                u_time: { value: 0 },
+                uRadius: { value: r },
+                uPointSize: { value: 5 * intensity },
+                u_speed: { value: speed * 0.5 },
+                uColor: { value: dustColVec },
+                uOpacity: { value: opacity * 0.6 },
+            },
+            transparent: true,
+            depthWrite: false,
+            blending: THREE.AdditiveBlending,
+        });
+        return { dustGeo: geo, dustMat: mat };
+    }, [particleCount, r, innerGlowColor, intensity, speed, opacity]);
+    useFrame((state) => {
+        const t = state.clock.getElapsedTime();
+        discMaterial.uniforms.u_time.value = t;
+        dustMat.uniforms.u_time.value = t;
+        if (animations?.length) {
+            applyGenerativeAnimations([discMaterial, dustMat], animations, startValuesCacheRef.current, Date.now(), false);
+        }
+    });
+    return (_jsxs("group", { rotation: [-Math.PI / 2, 0, 0], position: [0, -boundingRadius * 0.75, 0], children: [_jsx("mesh", { material: discMaterial, children: _jsx("circleGeometry", { args: [r, 80] }) }), particleRingEnabled && (_jsx("points", { geometry: dustGeo, material: dustMat }))] }));
+};
+export default PortalEffect;

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"ShockwaveEffect.d.ts","sourceRoot":"","sources":["../../../src/components/effects/ShockwaveEffect.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;AAkFD,QAAA,MAAM,eAAe,EAAE,KAAK,CAAC,EAAE,CAAC,oBAAoB,CA0EnD,CAAC;AACF,eAAe,eAAe,CAAC"}

package/dist/components/effects/ShockwaveEffect.js

@@ -0,0 +1,160 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useRef, useMemo, useEffect } from 'react';
+import { useFrame } from '@react-three/fiber';
+import * as THREE from 'three';
+import { applyGenerativeAnimations } from '../../utils/handleGenerativeEffectsAnimations.js';
+// Ring vertex — organic warp + vertical ripple
+const vertexShader = /* glsl */ `
+  uniform float uProgress;
+  uniform float uExpansionScale;
+
+  void main() {
+    vec3 pos = position;
+    float expansion = 1.0 + uProgress * uExpansionScale;
+    pos.x *= expansion;
+    pos.y *= expansion;
+
+    // Organic warp: slight Z ripple based on angle along the torus
+    float angle = atan(pos.y, pos.x);
+    float warp = sin(angle * 8.0 + uProgress * 18.0) * 0.018 * (1.0 - uProgress);
+    pos.z += warp;
+
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(pos, 1.0);
+  }
+`;
+const fragmentShader = /* glsl */ `
+  uniform float uProgress;
+  uniform vec3  uColor;
+  uniform vec3  uRimColor;
+  uniform float uOpacity;
+  uniform float u_time;
+
+  // Cheap 1D noise for surface texture
+  float hash(float n){ return fract(sin(n) * 43758.5453); }
+
+  void main() {
+    // Core fade
+    float fade   = 1.0 - uProgress;
+
+    // Leading-edge corona: ultra-bright blast front
+    float corona = exp(-uProgress * 6.0) * 2.5;
+
+    // High-frequency energy shimmer on the ring surface
+    float shimmer = 0.75 + 0.25 * hash(uProgress * 40.0 + u_time * 7.0);
+
+    // Rim glow (raised power = tighter, brighter rim)
+    float rim     = pow(max(0.0, 1.0 - uProgress), 4.0);
+
+    // Chromatic split — push rim color toward white at the leading edge
+    vec3 rimBoosted = mix(uRimColor, vec3(1.4, 1.4, 1.6), corona * 0.5);
+    vec3 finalColor  = mix(uColor, rimBoosted, rim + corona * 0.4);
+    finalColor      += rimBoosted * corona * 0.6;
+
+    float alpha = fade * uOpacity * shimmer;
+    if (alpha < 0.005) discard;
+
+    gl_FragColor = vec4(finalColor, alpha);
+  }
+`;
+// Flash disc at ring birth — bright flat burst that fades in ~0.2 progress
+const flashFrag = /* glsl */ `
+  uniform float uProgress;
+  uniform vec3  uColor;
+  uniform float uOpacity;
+
+  varying vec2 vUv;
+
+  void main() {
+    vec2 c = vUv * 2.0 - 1.0;
+    float dist = length(c);
+    if (dist > 1.0) discard;
+    float fade = exp(-uProgress * 12.0);
+    float radial = 1.0 - smoothstep(0.4, 1.0, dist);
+    float alpha = fade * radial * uOpacity * 0.9;
+    if (alpha < 0.005) discard;
+    gl_FragColor = vec4(uColor * 2.0, alpha);
+  }
+`;
+const flashVert = /* glsl */ `
+  varying vec2 vUv;
+  void main() {
+    vUv = uv;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+  }
+`;
+const ShockwaveEffect = ({ boundingRadius, config, animations }) => {
+    const { ringCount, expansionRadius, thickness, intervalSeconds, color, rimColor, opacity, speed, intensity } = config;
+    const startValuesCacheRef = useRef({});
+    const meshRefs = useRef([]);
+    const flashRefs = useRef([]);
+    const makeRingStates = (count, interval) => Array.from({ length: count }, (_, i) => ({
+        progress: 0,
+        cooldown: (i / Math.max(count, 1)) * interval,
+    }));
+    const ringStates = useRef(makeRingStates(ringCount, intervalSeconds));
+    useEffect(() => {
+        ringStates.current = makeRingStates(ringCount, intervalSeconds);
+    }, [ringCount, intervalSeconds]);
+    const colorVec = useMemo(() => { const c = new THREE.Color(color); return new THREE.Vector3(c.r, c.g, c.b); }, [color]);
+    const rimColorVec = useMemo(() => { const c = new THREE.Color(rimColor); return new THREE.Vector3(c.r, c.g, c.b); }, [rimColor]);
+    const materials = useMemo(() => Array.from({ length: ringCount }, () => new THREE.ShaderMaterial({
+        vertexShader,
+        fragmentShader,
+        uniforms: {
+            uProgress: { value: 0 },
+            uExpansionScale: { value: (expansionRadius - 1) * intensity },
+            uColor: { value: colorVec },
+            uRimColor: { value: rimColorVec },
+            uOpacity: { value: opacity },
+            u_time: { value: 0 },
+        },
+        transparent: true,
+        depthWrite: false,
+        blending: THREE.AdditiveBlending,
+        side: THREE.DoubleSide,
+    })), [ringCount, expansionRadius, intensity, colorVec, rimColorVec, opacity]);
+    const flashMaterials = useMemo(() => Array.from({ length: ringCount }, () => new THREE.ShaderMaterial({
+        vertexShader: flashVert,
+        fragmentShader: flashFrag,
+        uniforms: {
+            uProgress: { value: 0 },
+            uColor: { value: colorVec },
+            uOpacity: { value: opacity },
+        },
+        transparent: true,
+        depthWrite: false,
+        blending: THREE.AdditiveBlending,
+        side: THREE.DoubleSide,
+    })), [ringCount, colorVec, opacity]);
+    const radius = boundingRadius;
+    console.log('ShockwaveEffect render with boundingRadius:', boundingRadius, 'and config:', config);
+    useFrame((state, delta) => {
+        const t = state.clock.getElapsedTime();
+        for (let i = 0; i < ringCount; i++) {
+            const state_ = ringStates.current[i];
+            const mat = materials[i];
+            const fMat = flashMaterials[i];
+            mat.uniforms.u_time.value = t;
+            if (state_.cooldown > 0) {
+                state_.cooldown -= delta;
+                mat.uniforms.uProgress.value = 1;
+                fMat.uniforms.uProgress.value = 1;
+                continue;
+            }
+            state_.progress += delta * speed;
+            const p = Math.min(state_.progress, 1);
+            mat.uniforms.uProgress.value = p;
+            fMat.uniforms.uProgress.value = p;
+            if (state_.progress >= 1) {
+                state_.progress = 0;
+                state_.cooldown = intervalSeconds / speed;
+            }
+        }
+        if (animations?.length) {
+            applyGenerativeAnimations([...materials, ...flashMaterials], animations, startValuesCacheRef.current, Date.now(), false);
+        }
+    });
+    const flashR = radius * 1.05;
+    return (_jsx("group", { children: Array.from({ length: ringCount }, (_, i) => (_jsxs("group", { children: [_jsx("mesh", { ref: el => { meshRefs.current[i] = el; }, material: materials[i], rotation: [-Math.PI / 2, 0, 0], children: _jsx("torusGeometry", { args: [radius, thickness * intensity, 10, 80] }) }), _jsx("mesh", { ref: el => { flashRefs.current[i] = el; }, material: flashMaterials[i], rotation: [-Math.PI / 2, 0, 0], children: _jsx("circleGeometry", { args: [flashR, 48] }) })] }, i))) }));
+};
+export default ShockwaveEffect;