@3driseai/3drise-viewer 0.1.1

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"SmokePlumeEffect.d.ts","sourceRoot":"","sources":["../../../src/components/effects/SmokePlumeEffect.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAChF,UAAU,qBAAqB;IAC3B,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,gBAAgB,CAAC;IACzB,UAAU,CAAC,EAAE,gBAAgB,EAAE,CAAC;CACnC;AA6ED,QAAA,MAAM,gBAAgB,EAAE,KAAK,CAAC,EAAE,CAAC,qBAAqB,CA4DrD,CAAC;AACF,eAAe,gBAAgB,CAAC"}

package/dist/components/effects/SmokePlumeEffect.js

@@ -0,0 +1,141 @@
+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';
+// ── Fully GPU-animated smoke puff vertex shader ───────────────────────────────
+// Each particle has a lifetime t ∈ [0,1). It rises, expands, and billows.
+// All motion driven by u_time — zero CPU writes per frame.
+const smokeVert = /* glsl */ `
+  attribute float aT;       // birth offset 0..1 → staggered spawn
+  attribute vec2  aBase;    // (x,z) spawn footprint
+  attribute float aPhase;   // per-particle noise phase
+  attribute float aRotOff;  // per-particle billboard rotation offset
+  attribute float aSize;    // per-particle max size
+
+  uniform float u_time;
+  uniform float u_speed;
+  uniform float uHeight;
+  uniform float uSpread;
+  uniform float uTurb;
+  uniform float uSizeScale;
+
+  varying float vLife;   // 0=just born, 1=about to die
+  varying float vAlpha;
+
+  void main() {
+    // Age loops continuously
+    float life = fract(aT + u_time * u_speed * 0.22);
+    vLife = life;
+
+    // Footprint expands as smoke rises and dissipates
+    float expand  = 1.0 + life * 2.5;
+    float x = aBase.x * expand * uSpread;
+    float z = aBase.y * expand * uSpread;
+
+    // Turbulent horizontal drift — two layers of sine turbulence
+    float t1 = sin(life * 4.2 + aPhase)               * uTurb * uSpread * life * 0.9;
+    float t2 = sin(life * 7.1 + aPhase * 1.7 + 1.3)   * uTurb * uSpread * life * 0.4;
+    float t3 = cos(life * 3.5 - aPhase * 0.8)          * uTurb * uSpread * life * 0.3;
+    x += t1 + t2;
+    z += t3 + t2 * 0.5;
+
+    float y = life * uHeight - uHeight * 0.45;
+
+    // Particle grows from tiny to large, then fades to nothing
+    float growFade = smoothstep(0.0, 0.15, life) * smoothstep(1.0, 0.6, life);
+    float sz = aSize * uSizeScale * growFade;
+
+    // Alpha: ramp in quickly, stay opaque, fade out
+    vAlpha = growFade * growFade;
+
+    vec4 mv = modelViewMatrix * vec4(x, y, z, 1.0);
+    gl_PointSize = sz * (200.0 / -mv.z);
+    gl_Position  = projectionMatrix * mv;
+  }
+`;
+const smokeFrag = /* glsl */ `
+  uniform vec3  uSmokeColor;
+  uniform float uOpacity;
+  varying float vLife;
+  varying float vAlpha;
+
+  void main() {
+    if (vAlpha < 0.01) discard;
+
+    vec2  c = gl_PointCoord - 0.5;
+    float d = length(c);
+    if (d > 0.5) discard;
+
+    // Soft gaussian puff — not a crisp disc
+    float g = exp(-d * d * 3.8);
+
+    // Slightly darken as smoke ages (hot white → grey → dark)
+    float darkening = 1.0 - vLife * 0.45;
+    vec3  col = uSmokeColor * darkening;
+
+    gl_FragColor = vec4(col, g * vAlpha * uOpacity);
+  }
+`;
+const SmokePlumeEffect = ({ boundingRadius, config, animations }) => {
+    const { particleCount, height, spread, smokeColor, turbulence, opacity, speed, intensity } = config;
+    const startValuesCacheRef = useRef({});
+    const h = boundingRadius * height;
+    const s = boundingRadius * spread;
+    const { geo, mat } = useMemo(() => {
+        const N = Math.max(40, particleCount);
+        const aT = new Float32Array(N);
+        const aBase = new Float32Array(N * 2);
+        const aPhase = new Float32Array(N);
+        const aRotOff = new Float32Array(N);
+        const aSize = new Float32Array(N);
+        for (let i = 0; i < N; i++) {
+            aT[i] = i / N;
+            // Concentrate spawns near center, sparse toward edges
+            const r = Math.pow(Math.random(), 0.6) * s;
+            const a = Math.random() * Math.PI * 2;
+            aBase[i * 2] = Math.cos(a) * r;
+            aBase[i * 2 + 1] = Math.sin(a) * r;
+            aPhase[i] = Math.random() * Math.PI * 2;
+            aRotOff[i] = Math.random() * Math.PI * 2;
+            aSize[i] = 35 + Math.random() * 45; // puff screen size
+        }
+        const g = new THREE.BufferGeometry();
+        g.setAttribute('position', new THREE.BufferAttribute(new Float32Array(N * 3), 3));
+        g.setAttribute('aT', new THREE.BufferAttribute(aT, 1));
+        g.setAttribute('aBase', new THREE.BufferAttribute(aBase, 2));
+        g.setAttribute('aPhase', new THREE.BufferAttribute(aPhase, 1));
+        g.setAttribute('aRotOff', new THREE.BufferAttribute(aRotOff, 1));
+        g.setAttribute('aSize', new THREE.BufferAttribute(aSize, 1));
+        g.frustumCulled = false;
+        const sc = new THREE.Color(smokeColor);
+        const m = new THREE.ShaderMaterial({
+            vertexShader: smokeVert,
+            fragmentShader: smokeFrag,
+            uniforms: {
+                u_time: { value: 0 },
+                u_speed: { value: speed },
+                uHeight: { value: h },
+                uSpread: { value: s },
+                uTurb: { value: turbulence },
+                uSizeScale: { value: intensity },
+                uSmokeColor: { value: new THREE.Vector3(sc.r, sc.g, sc.b) },
+                uOpacity: { value: opacity },
+            },
+            transparent: true,
+            depthWrite: false,
+            // Normal blending (not additive) — smoke should look opaque/grey, not glowy
+            blending: THREE.NormalBlending,
+        });
+        return { geo: g, mat: m };
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [particleCount, h, s, smokeColor, turbulence, opacity, speed, intensity]);
+    useFrame((state) => {
+        mat.uniforms.u_time.value = state.clock.getElapsedTime();
+        if (animations?.length) {
+            applyGenerativeAnimations([mat], animations, startValuesCacheRef.current, Date.now(), false);
+        }
+    });
+    return _jsx("points", { geometry: geo, material: mat });
+};
+export default SmokePlumeEffect;

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

@@ -0,0 +1,13 @@
+import type { SmokeRibbonConfig } from '@3driseai/3drise-core';
+export interface SmokeRibbonProps {
+    config?: SmokeRibbonConfig;
+    boundingRadius?: number;
+}
+/**
+ * Place where you want the smoke to rise from — it climbs the parent's local +Y:
+ *
+ *   <SmokeRibbon position={[0, 0, 0]} config={{ planes: 2, twistStart: 0.2 }} />
+ */
+declare const SmokeRibbon: ({ config, boundingRadius, ...groupProps }: SmokeRibbonProps) => import("react").JSX.Element;
+export default SmokeRibbon;
+//# sourceMappingURL=SmokeRibbon.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SmokeRibbon.d.ts","sourceRoot":"","sources":["../../../src/components/effects/SmokeRibbon.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC/D,MAAM,WAAW,gBAAgB;IAC7B,MAAM,CAAC,EAAE,iBAAiB,CAAC;IAC3B,cAAc,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;;;GAIG;AACH,QAAA,MAAM,WAAW,GAAI,2CAAoD,gBAAgB,gCAyDxF,CAAC;AACF,eAAe,WAAW,CAAC"}

package/dist/components/effects/SmokeRibbon.js

@@ -0,0 +1,69 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { PlaneGeometry } from 'three';
+import { useEffect, useLayoutEffect, useMemo, useRef } from 'react';
+import { useFrame, useThree } from '@react-three/fiber';
+import { SmokeRibbonMaterial } from '@3driseai/3drise-core';
+/**
+ * Place where you want the smoke to rise from — it climbs the parent's local +Y:
+ *
+ *   <SmokeRibbon position={[0, 0, 0]} config={{ planes: 2, twistStart: 0.2 }} />
+ */
+const SmokeRibbon = ({ config = {}, boundingRadius = 1, ...groupProps }) => {
+    const { width = 1.5, height = 5, segmentsPerLength = 12, planes = 2, color = '#f2f2f7', colorTop = '#b3b8c7', speed = 0.18, detail = 1.4, remapLow = 0.38, remapHigh = 1.0, edgeX = 0.4, edgeY = 0.32, density = 1.0, twistStrength = 9, twistSpeed = 0.4, twistScale = 0.9, twistStart = 0.18, wind = [0.15, 0], animate = true, interactive = false, } = config;
+    // One material instance shared across the crossed planes -> one set of uniforms.
+    const material = useMemo(() => new SmokeRibbonMaterial(), []);
+    // One subdivided plane, bottom at the origin; reused per crossed copy.
+    const geometry = useMemo(() => {
+        const g = new PlaneGeometry(boundingRadius ? boundingRadius : width, height, Math.max(1, Math.round((boundingRadius ? boundingRadius : width) * segmentsPerLength)), Math.max(1, Math.round(height * segmentsPerLength)));
+        g.translate(0, height / 2, 0);
+        return g;
+    }, [boundingRadius, width, height, segmentsPerLength]);
+    useEffect(() => () => geometry.dispose(), [geometry]);
+    useEffect(() => () => material.dispose(), [material]);
+    // Crossed-plane angles about Y.
+    const angles = useMemo(() => {
+        if (planes <= 1)
+            return [0];
+        if (planes === 2)
+            return [0, Math.PI / 2];
+        return [0, Math.PI / 3, (2 * Math.PI) / 3];
+    }, [planes]);
+    // Push the look config onto the shared uniforms whenever it changes.
+    useLayoutEffect(() => {
+        material.u_color.set(color);
+        material.u_colorTop.set(colorTop);
+        material.u_speed = speed;
+        material.u_detail = detail;
+        material.u_remapLow = remapLow;
+        material.u_remapHigh = remapHigh;
+        material.u_edgeX = edgeX;
+        material.u_edgeY = edgeY;
+        material.u_density = density;
+        material.u_twistStrength = twistStrength;
+        material.u_twistSpeed = twistSpeed;
+        material.u_twistScale = twistScale;
+        material.u_twistStart = twistStart;
+        material.u_windDir.set(wind[0], wind[1]);
+    }, [
+        material, color, colorTop, speed, detail, remapLow, remapHigh, edgeX, edgeY,
+        density, twistStrength, twistSpeed, twistScale, twistStart, wind,
+    ]);
+    const { pointer } = useThree();
+    const hovering = useRef(false);
+    useFrame(({ clock }) => {
+        if (animate)
+            material.u_time = clock.getElapsedTime();
+        if (interactive) {
+            // u_mouse is the normalized pointer (NDC); .x leans the ribbon.
+            material.u_mouse.set(pointer.x, pointer.y);
+            const target = hovering.current ? 1 : 0;
+            material.u_mouseStrength += (target - material.u_mouseStrength) * 0.1;
+        }
+        else {
+            material.u_mouseStrength = 0;
+        }
+    });
+    console.log('SmokeRibbon render with config:', config, 'and groupProps:', groupProps);
+    return (_jsx("group", { ...groupProps, onPointerOver: interactive ? () => (hovering.current = true) : undefined, onPointerOut: interactive ? () => (hovering.current = false) : undefined, children: angles.map((a, i) => (_jsx("mesh", { geometry: geometry, material: material, "rotation-y": a }, i))) }));
+};
+export default SmokeRibbon;

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

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

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

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

package/dist/components/effects/SmokeRingEffect.js

@@ -0,0 +1,158 @@
+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';
+// ── Per-ring puff shader (one Points per ring — GPU computes torus positions) ──
+const ringVert = /* glsl */ `
+  attribute float aAngle;    // 0..TAU position around torus
+  attribute float aPuff;     // sub-angle within tube cross-section 0..TAU
+  attribute float aPhase;
+
+  uniform float uProgress;   // 0=born, 1=dead
+  uniform float uMaxRadius;
+  uniform float uThickness;  // tube radius
+  uniform float uRiseSpeed;  // Y lift per unit progress
+  uniform float uBaseY;
+  uniform float u_time;
+
+  varying float vAlpha;
+
+  void main() {
+    if (uProgress < 0.0 || uProgress > 1.0) {
+      gl_PointSize = 0.0;
+      gl_Position  = vec4(0.0);
+      vAlpha = 0.0;
+      return;
+    }
+
+    float ringR = uMaxRadius * uProgress;
+
+    // Tube cross-section wiggles outward slightly as ring expands
+    float tubeR = uThickness * (0.8 + 0.4 * uProgress);
+    float tubePhi = aPuff + u_time * 0.4 + aPhase;
+    float offR = tubeR * cos(tubePhi);
+    float offY = tubeR * sin(tubePhi);
+
+    float r   = ringR + offR;
+    float x   = cos(aAngle) * r;
+    float z   = sin(aAngle) * r;
+    float y   = uBaseY + uProgress * uRiseSpeed + offY;
+
+    // Puff grows then fades
+    float lifeAlpha = smoothstep(0.0, 0.12, uProgress) * smoothstep(1.0, 0.65, uProgress);
+    vAlpha = lifeAlpha;
+
+    float puffSize = uThickness * 50.0 * lifeAlpha;
+
+    vec4 mv = modelViewMatrix * vec4(x, y, z, 1.0);
+    gl_PointSize = puffSize * (200.0 / -mv.z);
+    gl_Position  = projectionMatrix * mv;
+  }
+`;
+const ringFrag = /* glsl */ `
+  uniform vec3  uSmokeColor;
+  uniform float uOpacity;
+  varying float vAlpha;
+
+  void main() {
+    if (vAlpha < 0.01) discard;
+    vec2  c = gl_PointCoord - 0.5;
+    float d = length(c);
+    if (d > 0.5) discard;
+    float g = exp(-d * d * 3.0);
+    gl_FragColor = vec4(uSmokeColor, g * vAlpha * uOpacity);
+  }
+`;
+const PUFFS_PER_RING = 120;
+const SmokeRingEffect = ({ boundingRadius, config, animations }) => {
+    const { ringCount, expansionRadius, riseSpeed, intervalSeconds, smokeColor, thickness, opacity, speed, intensity } = config;
+    const startValuesCacheRef = useRef({});
+    const N = Math.max(1, Math.min(ringCount, 4));
+    // Ring states — one per slot
+    const ringStates = useRef([]);
+    const { geos, mats } = useMemo(() => {
+        const maxR = boundingRadius * expansionRadius;
+        const tubeR = boundingRadius * thickness;
+        const riseH = boundingRadius * riseSpeed;
+        const sc = new THREE.Color(smokeColor);
+        const scv = new THREE.Vector3(sc.r, sc.g, sc.b);
+        // Stagger initial timers so rings don't all fire together
+        ringStates.current = Array.from({ length: N }, (_, i) => ({
+            progress: 0,
+            timer: (i / N) * intervalSeconds,
+            active: false,
+        }));
+        const geos = [];
+        const mats = [];
+        for (let ri = 0; ri < N; ri++) {
+            const aAngle = new Float32Array(PUFFS_PER_RING);
+            const aPuff = new Float32Array(PUFFS_PER_RING);
+            const aPhase = new Float32Array(PUFFS_PER_RING);
+            for (let i = 0; i < PUFFS_PER_RING; i++) {
+                aAngle[i] = (i / PUFFS_PER_RING) * Math.PI * 2;
+                aPuff[i] = Math.random() * Math.PI * 2;
+                aPhase[i] = Math.random() * Math.PI * 2;
+            }
+            const geo = new THREE.BufferGeometry();
+            geo.setAttribute('position', new THREE.BufferAttribute(new Float32Array(PUFFS_PER_RING * 3), 3));
+            geo.setAttribute('aAngle', new THREE.BufferAttribute(aAngle, 1));
+            geo.setAttribute('aPuff', new THREE.BufferAttribute(aPuff, 1));
+            geo.setAttribute('aPhase', new THREE.BufferAttribute(aPhase, 1));
+            geo.frustumCulled = false;
+            const mat = new THREE.ShaderMaterial({
+                vertexShader: ringVert,
+                fragmentShader: ringFrag,
+                uniforms: {
+                    uProgress: { value: -1 }, // -1 = hidden
+                    uMaxRadius: { value: maxR },
+                    uThickness: { value: tubeR * intensity },
+                    uRiseSpeed: { value: riseH },
+                    uBaseY: { value: -boundingRadius * 0.2 },
+                    u_time: { value: 0 },
+                    uSmokeColor: { value: scv },
+                    uOpacity: { value: opacity },
+                },
+                transparent: true,
+                depthWrite: false,
+                blending: THREE.NormalBlending,
+            });
+            geos.push(geo);
+            mats.push(mat);
+        }
+        return { geos, mats };
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [N, boundingRadius, expansionRadius, riseSpeed, intervalSeconds, smokeColor, thickness, opacity, intensity]);
+    useFrame((state, delta) => {
+        const t = state.clock.getElapsedTime();
+        const dt = delta * speed;
+        ringStates.current.forEach((ring, ri) => {
+            const mat = mats[ri];
+            mat.uniforms.u_time.value = t;
+            if (ring.active) {
+                ring.progress += dt * 0.32;
+                if (ring.progress >= 1) {
+                    ring.active = false;
+                    ring.progress = 0;
+                    ring.timer = intervalSeconds / speed;
+                    mat.uniforms.uProgress.value = -1;
+                }
+                else {
+                    mat.uniforms.uProgress.value = ring.progress;
+                }
+            }
+            else {
+                ring.timer -= delta;
+                if (ring.timer <= 0) {
+                    ring.active = true;
+                    ring.progress = 0;
+                }
+            }
+        });
+        if (animations?.length) {
+            applyGenerativeAnimations(mats, animations, startValuesCacheRef.current, Date.now(), false);
+        }
+    });
+    return (_jsx("group", { children: geos.map((geo, i) => (_jsx("points", { geometry: geo, material: mats[i] }, i))) }));
+};
+export default SmokeRingEffect;

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

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

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

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

package/dist/components/effects/VolumetricFogEffect.js

@@ -0,0 +1,111 @@
+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';
+// ── Billboard fog puff — drifts slowly, never rises far ───────────────────────
+const fogVert = /* glsl */ `
+  attribute float aT;       // stagger offset 0..1
+  attribute vec3  aCenter;  // resting (x,y,z) position in fog layer
+  attribute float aPhase;
+  attribute float aSize;
+
+  uniform float u_time;
+  uniform float uDrift;    // horizontal drift speed
+  uniform float uFogRadius;
+
+  varying float vAlpha;
+
+  void main() {
+    float t = fract(aT + u_time * 0.05);  // very slow life cycle — fog is persistent
+
+    // Gentle horizontal drift — fog rolls around the base
+    float dx = sin(u_time * uDrift + aPhase)          * uFogRadius * 0.18;
+    float dz = cos(u_time * uDrift * 0.7 + aPhase * 1.3) * uFogRadius * 0.14;
+    // Slow vertical bob
+    float dy = sin(u_time * 0.25 + aPhase) * uFogRadius * 0.06;
+
+    vec3 pos = aCenter + vec3(dx, dy, dz);
+
+    // Puff fades in/out with its own phase to prevent popping
+    float pulse = 0.55 + 0.45 * sin(u_time * 0.35 + aPhase * 2.1);
+    vAlpha = pulse;
+
+    vec4 mv = modelViewMatrix * vec4(pos, 1.0);
+    gl_PointSize = aSize * (220.0 / -mv.z);
+    gl_Position  = projectionMatrix * mv;
+  }
+`;
+const fogFrag = /* glsl */ `
+  uniform vec3  uFogColor;
+  uniform float uDensity;
+  varying float vAlpha;
+
+  void main() {
+    vec2  c = gl_PointCoord - 0.5;
+    float d = length(c);
+    if (d > 0.5) discard;
+
+    // Very soft — almost no hard edge at all
+    float g = exp(-d * d * 2.2);
+
+    gl_FragColor = vec4(uFogColor, g * vAlpha * uDensity);
+  }
+`;
+const VolumetricFogEffect = ({ boundingRadius, config, animations }) => {
+    const { particleCount, fogRadius, driftSpeed, fogColor, density, opacity, intensity } = config;
+    const startValuesCacheRef = useRef({});
+    const r = boundingRadius * fogRadius;
+    const { geo, mat } = useMemo(() => {
+        const N = Math.max(20, Math.min(particleCount, 200));
+        const aT = new Float32Array(N);
+        const aCenter = new Float32Array(N * 3);
+        const aPhase = new Float32Array(N);
+        const aSize = new Float32Array(N);
+        for (let i = 0; i < N; i++) {
+            aT[i] = i / N;
+            // Distribute puffs in a disc with vertical variation at base level
+            const angle = Math.random() * Math.PI * 2;
+            const rad = Math.sqrt(Math.random()) * r;
+            const yOff = (Math.random() - 0.3) * boundingRadius * 0.35; // mostly at base, slight spread
+            aCenter[i * 3] = Math.cos(angle) * rad;
+            aCenter[i * 3 + 1] = yOff - boundingRadius * 0.3; // sit at/below object base
+            aCenter[i * 3 + 2] = Math.sin(angle) * rad;
+            aPhase[i] = Math.random() * Math.PI * 2;
+            // Large puffs — fog is billowy
+            aSize[i] = (50 + Math.random() * 70) * intensity;
+        }
+        const g = new THREE.BufferGeometry();
+        g.setAttribute('position', new THREE.BufferAttribute(new Float32Array(N * 3), 3));
+        g.setAttribute('aT', new THREE.BufferAttribute(aT, 1));
+        g.setAttribute('aCenter', new THREE.BufferAttribute(aCenter, 3));
+        g.setAttribute('aPhase', new THREE.BufferAttribute(aPhase, 1));
+        g.setAttribute('aSize', new THREE.BufferAttribute(aSize, 1));
+        g.frustumCulled = false;
+        const fc = new THREE.Color(fogColor);
+        const m = new THREE.ShaderMaterial({
+            vertexShader: fogVert,
+            fragmentShader: fogFrag,
+            uniforms: {
+                u_time: { value: 0 },
+                uDrift: { value: driftSpeed },
+                uFogRadius: { value: r },
+                uFogColor: { value: new THREE.Vector3(fc.r, fc.g, fc.b) },
+                uDensity: { value: density * opacity },
+            },
+            transparent: true,
+            depthWrite: false,
+            blending: THREE.NormalBlending,
+        });
+        return { geo: g, mat: m };
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [particleCount, r, fogColor, density, driftSpeed, opacity, intensity, boundingRadius]);
+    useFrame((state) => {
+        mat.uniforms.u_time.value = state.clock.getElapsedTime();
+        if (animations?.length) {
+            applyGenerativeAnimations([mat], animations, startValuesCacheRef.current, Date.now(), false);
+        }
+    });
+    return _jsx("points", { geometry: geo, material: mat });
+};
+export default VolumetricFogEffect;

package/dist/components/extractOutline.d.ts

@@ -0,0 +1,18 @@
+import type { BufferGeometry } from 'three';
+export type OutlineMode = '2d' | '3d';
+export type Point3 = [number, number, number];
+/**
+ * 3D feature edges: every edge whose dihedral angle exceeds `angle` (degrees).
+ * Returns endpoints in segment order (pairs form independent segments).
+ */
+export declare function edges3D(geometry: BufferGeometry, angle: number): Point3[];
+/**
+ * 2D profile: the hard edges lying on the front (max-Z) plane, flattened to
+ * z = 0. For a Z-extruded solid this equals the projected silhouette, so the
+ * heart yields its bezier contour and the box yields a square.
+ *
+ * For a general (non-extruded) mesh the true 2D outline is a projected
+ * silhouette boolean — swap this implementation when generalizing.
+ */
+export declare function contour2D(geometry: BufferGeometry): Point3[];
+//# sourceMappingURL=extractOutline.d.ts.map

package/dist/components/extractOutline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extractOutline.d.ts","sourceRoot":"","sources":["../../src/components/extractOutline.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC;AAC5C,MAAM,MAAM,WAAW,GAAG,IAAI,GAAG,IAAI,CAAC;AAEtC,MAAM,MAAM,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AAE9C;;;GAGG;AACH,wBAAgB,OAAO,CAAC,QAAQ,EAAE,cAAc,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAKzE;AACD;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,QAAQ,EAAE,cAAc,GAAG,MAAM,EAAE,CAoB5D"}

package/dist/components/extractOutline.js

@@ -0,0 +1,47 @@
+import { EdgesGeometry } from 'three';
+/**
+ * 3D feature edges: every edge whose dihedral angle exceeds `angle` (degrees).
+ * Returns endpoints in segment order (pairs form independent segments).
+ */
+export function edges3D(geometry, angle) {
+    const edges = new EdgesGeometry(geometry, angle);
+    const pts = toPairs(edges.attributes.position.array);
+    edges.dispose();
+    return pts;
+}
+/**
+ * 2D profile: the hard edges lying on the front (max-Z) plane, flattened to
+ * z = 0. For a Z-extruded solid this equals the projected silhouette, so the
+ * heart yields its bezier contour and the box yields a square.
+ *
+ * For a general (non-extruded) mesh the true 2D outline is a projected
+ * silhouette boolean — swap this implementation when generalizing.
+ */
+export function contour2D(geometry) {
+    const edges = new EdgesGeometry(geometry, 1);
+    const a = edges.attributes.position.array;
+    let maxZ = -Infinity;
+    let minZ = Infinity;
+    for (let i = 2; i < a.length; i += 3) {
+        if (a[i] > maxZ)
+            maxZ = a[i];
+        if (a[i] < minZ)
+            minZ = a[i];
+    }
+    const eps = Math.max((maxZ - minZ) * 1e-3, 1e-4);
+    const out = [];
+    for (let i = 0; i < a.length; i += 6) {
+        if (Math.abs(a[i + 2] - maxZ) < eps && Math.abs(a[i + 5] - maxZ) < eps) {
+            out.push([a[i], a[i + 1], 0], [a[i + 3], a[i + 4], 0]);
+        }
+    }
+    edges.dispose();
+    return out;
+}
+function toPairs(arr) {
+    const out = [];
+    for (let i = 0; i < arr.length; i += 3) {
+        out.push([arr[i], arr[i + 1], arr[i + 2]]);
+    }
+    return out;
+}

package/dist/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const dataCenterServer = "https://3drise.ai/api/data/";
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,gBAAgB,gCAAgC,CAAC"}

package/dist/constants.js

@@ -0,0 +1,5 @@
+const LOCAL_DATA_CENTER_SERVER = 'http://localhost:3001/api/data/';
+const PRODUCTION_DATA_CENTER_SERVER = 'https://3drise.ai/api/data/';
+const isLocalHostRuntime = typeof window !== 'undefined' &&
+    (window.location.hostname === 'localhost' || window.location.hostname === '127.0.0.1');
+export const dataCenterServer = PRODUCTION_DATA_CENTER_SERVER;

package/dist/hooks/index.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=index.d.ts.map

package/dist/hooks/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/hooks/index.ts"],"names":[],"mappings":""}

package/dist/hooks/index.js

@@ -0,0 +1 @@
+"use strict";

package/dist/hooks/use3driseShader.d.ts

@@ -0,0 +1,17 @@
+import type { ShaderEffect } from '@3driseai/3drise-core';
+export interface Update3driseShaderOptions {
+    pointerRadius?: number;
+}
+export declare function update3driseShaderUniforms(uniforms: Record<string, {
+    value: unknown;
+}> | undefined | null, effects: ShaderEffect[] | undefined | null, time: number, pointer: {
+    x: number;
+    y: number;
+}, options?: Update3driseShaderOptions): void;
+export declare function use3driseShader(effects: ShaderEffect[]): (uniforms: Record<string, {
+    value: unknown;
+}>, time: number, pointer: {
+    x: number;
+    y: number;
+}) => void;
+//# sourceMappingURL=use3driseShader.d.ts.map

package/dist/hooks/use3driseShader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use3driseShader.d.ts","sourceRoot":"","sources":["../../src/hooks/use3driseShader.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAC1D,MAAM,WAAW,yBAAyB;IACtC,aAAa,CAAC,EAAE,MAAM,CAAC;CAC1B;AAuDD,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE;IACxD,KAAK,EAAE,OAAO,CAAC;CAClB,CAAC,GAAG,SAAS,GAAG,IAAI,EAAE,OAAO,EAAE,YAAY,EAAE,GAAG,SAAS,GAAG,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE;IACtF,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACb,EAAE,OAAO,CAAC,EAAE,yBAAyB,GAAG,IAAI,CAuCpD;AACD,wBAAgB,eAAe,CAAC,OAAO,EAAE,YAAY,EAAE,GAAG,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE;IAC5E,KAAK,EAAE,OAAO,CAAC;CAClB,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE;IACvB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACb,KAAK,IAAI,CAIb"}