@3driseai/3drise-viewer 0.1.1

package/dist/utils/handleGenerativeEffectsAnimations.js

@@ -0,0 +1,268 @@
+// =============================================================================
+// HANDLE GENERATIVE EFFECTS ANIMATIONS — per-effect utility
+// =============================================================================
+//
+// Called from inside each generative effect component's own useFrame loop.
+// Each effect component holds direct refs to its ShaderMaterials and passes
+// them here, avoiding fragile scene-graph traversal.
+//
+// Usage (inside an effect component's useFrame):
+//
+//   useFrame((state) => {
+//     const t = state.clock.getElapsedTime();
+//     mat.uniforms.u_time.value = t;
+//
+//     if (animations?.length) {
+//       applyGenerativeAnimations([mat], animations, startValuesCacheRef.current, Date.now(), hovered ?? false);
+//     }
+//   });
+//
+import * as THREE from 'three';
+import { MathUtils } from 'three';
+// =============================================================================
+// INLINED HELPERS (from client/app/utils/materialUtils.ts and hooks/useAnimations.ts)
+// =============================================================================
+const calculateTimeProgress = (currentTime, duration, yoyo, loop) => {
+    const animationSpeed = 1000 / duration;
+    const rawProgress = currentTime * animationSpeed * 0.001;
+    if (yoyo) {
+        const cycleProgress = rawProgress % 1;
+        return Math.sin(cycleProgress * Math.PI * 2) * 0.5 + 0.5;
+    }
+    if (loop)
+        return rawProgress % 1;
+    return Math.min(rawProgress, 1);
+};
+const easingFunctions = {
+    linear: (t) => t,
+    easeInQuad: (t) => t * t,
+    easeOutQuad: (t) => t * (2 - t),
+    easeInOutQuad: (t) => t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t,
+    easeInCubic: (t) => t * t * t,
+    easeOutCubic: (t) => (--t) * t * t + 1,
+    easeInOutCubic: (t) => t < 0.5 ? 4 * t * t * t : (t - 1) * (2 * t - 2) * (2 * t - 2) + 1,
+    easeInQuart: (t) => t * t * t * t,
+    easeOutQuart: (t) => 1 - (--t) * t * t * t,
+    easeInOutQuart: (t) => t < 0.5 ? 8 * t * t * t * t : 1 - 8 * (--t) * t * t * t,
+    easeInQuint: (t) => t * t * t * t * t,
+    easeOutQuint: (t) => 1 + (--t) * t * t * t * t,
+    easeInOutQuint: (t) => t < 0.5 ? 16 * t * t * t * t * t : 1 + 16 * (--t) * t * t * t * t,
+    easeInSine: (t) => 1 - Math.cos(t * Math.PI / 2),
+    easeOutSine: (t) => Math.sin(t * Math.PI / 2),
+    easeInOutSine: (t) => -(Math.cos(Math.PI * t) - 1) / 2,
+    easeInExpo: (t) => t === 0 ? 0 : Math.pow(2, 10 * (t - 1)),
+    easeOutExpo: (t) => t === 1 ? 1 : 1 - Math.pow(2, -10 * t),
+    easeInOutExpo: (t) => {
+        if (t === 0)
+            return 0;
+        if (t === 1)
+            return 1;
+        if (t < 0.5)
+            return Math.pow(2, 20 * t - 10) / 2;
+        return (2 - Math.pow(2, -20 * t + 10)) / 2;
+    },
+    easeInCirc: (t) => 1 - Math.sqrt(1 - t * t),
+    easeOutCirc: (t) => Math.sqrt(1 - (t - 1) * (t - 1)),
+    easeInOutCirc: (t) => {
+        if (t < 0.5)
+            return (1 - Math.sqrt(1 - 4 * t * t)) / 2;
+        return (Math.sqrt(1 - (-2 * t + 2) * (-2 * t + 2)) + 1) / 2;
+    },
+    easeInBack: (t) => { const c1 = 1.70158; const c3 = c1 + 1; return c3 * t * t * t - c1 * t * t; },
+    easeOutBack: (t) => { const c1 = 1.70158; const c3 = c1 + 1; return 1 + c3 * Math.pow(t - 1, 3) + c1 * Math.pow(t - 1, 2); },
+    easeInOutBack: (t) => {
+        const c1 = 1.70158;
+        const c2 = c1 * 1.525;
+        return t < 0.5 ? (Math.pow(2 * t, 2) * ((c2 + 1) * 2 * t - c2)) / 2 : (Math.pow(2 * t - 2, 2) * ((c2 + 1) * (t * 2 - 2) + c2) + 2) / 2;
+    },
+    easeInElastic: (t) => { const c4 = (2 * Math.PI) / 3; return t === 0 ? 0 : t === 1 ? 1 : -Math.pow(2, 10 * t - 10) * Math.sin((t * 10 - 10.75) * c4); },
+    easeOutElastic: (t) => { const c4 = (2 * Math.PI) / 3; return t === 0 ? 0 : t === 1 ? 1 : Math.pow(2, -10 * t) * Math.sin((t * 10 - 0.75) * c4) + 1; },
+    easeInOutElastic: (t) => {
+        const c5 = (2 * Math.PI) / 4.5;
+        return t === 0 ? 0 : t === 1 ? 1 : t < 0.5
+            ? -(Math.pow(2, 20 * t - 10) * Math.sin((20 * t - 11.125) * c5)) / 2
+            : (Math.pow(2, -20 * t + 10) * Math.sin((20 * t - 11.125) * c5)) / 2 + 1;
+    },
+    easeInBounce: (t) => 1 - easingFunctions.easeOutBounce(1 - t),
+    easeOutBounce: (t) => {
+        const n1 = 7.5625;
+        const d1 = 2.75;
+        if (t < 1 / d1)
+            return n1 * t * t;
+        else if (t < 2 / d1)
+            return n1 * (t -= 1.5 / d1) * t + 0.75;
+        else if (t < 2.5 / d1)
+            return n1 * (t -= 2.25 / d1) * t + 0.9375;
+        else
+            return n1 * (t -= 2.625 / d1) * t + 0.984375;
+    },
+    easeInOutBounce: (t) => t < 0.5
+        ? (1 - easingFunctions.easeOutBounce(1 - 2 * t)) / 2
+        : (1 + easingFunctions.easeOutBounce(2 * t - 1)) / 2,
+};
+const gsapEasingMap = {
+    'power1.in': 'easeInQuad', 'power1.out': 'easeOutQuad', 'power1.inOut': 'easeInOutQuad',
+    'power2.in': 'easeInCubic', 'power2.out': 'easeOutCubic', 'power2.inOut': 'easeInOutCubic',
+    'power3.in': 'easeInQuart', 'power3.out': 'easeOutQuart', 'power3.inOut': 'easeInOutQuart',
+    'power4.in': 'easeInQuint', 'power4.out': 'easeOutQuint', 'power4.inOut': 'easeInOutQuint',
+    'sine.in': 'easeInSine', 'sine.out': 'easeOutSine', 'sine.inOut': 'easeInOutSine',
+    'expo.in': 'easeInExpo', 'expo.out': 'easeOutExpo', 'expo.inOut': 'easeInOutExpo',
+    'circ.in': 'easeInCirc', 'circ.out': 'easeOutCirc', 'circ.inOut': 'easeInOutCirc',
+    'back.in': 'easeInBack', 'back.out': 'easeOutBack', 'back.inOut': 'easeInOutBack',
+    'elastic.in': 'easeInElastic', 'elastic.out': 'easeOutElastic', 'elastic.inOut': 'easeInOutElastic',
+    'bounce.in': 'easeInBounce', 'bounce.out': 'easeOutBounce', 'bounce.inOut': 'easeInOutBounce',
+    'none': 'linear', 'linear': 'linear',
+};
+const applyEasing = (easingName, progress) => {
+    const fn = easingFunctions[easingName];
+    return fn ? fn(progress) : progress;
+};
+// =============================================================================
+// DEBUG
+// =============================================================================
+export const DEBUG_GENERATIVE_EFFECTS = false;
+const log = (message, ...args) => {
+    if (DEBUG_GENERATIVE_EFFECTS)
+        console.log(`[GenerativeEffectsAnimations] ${message}`, ...args);
+};
+const _loggedOnce = new Set();
+const logOnce = (key, message, ...args) => {
+    if (_loggedOnce.has(key))
+        return;
+    _loggedOnce.add(key);
+    console.log(`[GenerativeEffectsAnimations] ${message}`, ...args);
+};
+const warnOnce = (key, message, ...args) => {
+    if (_loggedOnce.has(key))
+        return;
+    _loggedOnce.add(key);
+    console.warn(`[GenerativeEffectsAnimations] ${message}`, ...args);
+};
+// =============================================================================
+// HELPERS
+// =============================================================================
+function candidateUniformNames(property) {
+    const capitalized = property.charAt(0).toUpperCase() + property.slice(1);
+    return [`u${capitalized}`, `u_${property}`];
+}
+function findUniformName(materials, property) {
+    const candidates = candidateUniformNames(property);
+    for (const candidate of candidates) {
+        for (const mat of materials) {
+            if (mat.uniforms[candidate] !== undefined)
+                return candidate;
+        }
+    }
+    return null;
+}
+const _colorFrom = new THREE.Color();
+const _colorTo = new THREE.Color();
+function readUniformValue(materials, uniformName) {
+    for (const mat of materials) {
+        const u = mat.uniforms[uniformName];
+        if (u !== undefined) {
+            if (u.value instanceof THREE.Color)
+                return '#' + u.value.getHexString();
+            if (u.value instanceof THREE.Vector3) {
+                _colorFrom.setRGB(u.value.x, u.value.y, u.value.z);
+                return '#' + _colorFrom.getHexString();
+            }
+            return u.value;
+        }
+    }
+    return undefined;
+}
+function applyNumericToMaterials(materials, uniformName, value) {
+    for (const mat of materials) {
+        const u = mat.uniforms[uniformName];
+        if (u !== undefined)
+            u.value = value;
+    }
+}
+function applyColorToMaterials(materials, uniformName, from, to, t) {
+    _colorFrom.set(from);
+    _colorTo.set(to);
+    const r = MathUtils.lerp(_colorFrom.r, _colorTo.r, t);
+    const g = MathUtils.lerp(_colorFrom.g, _colorTo.g, t);
+    const b = MathUtils.lerp(_colorFrom.b, _colorTo.b, t);
+    for (const mat of materials) {
+        const u = mat.uniforms[uniformName];
+        if (u !== undefined) {
+            const val = u.value;
+            if (val instanceof THREE.Color)
+                val.setRGB(r, g, b);
+            else if (val && typeof val === 'object' && 'x' in val)
+                val.set(r, g, b);
+        }
+    }
+}
+function isColorValue(value) {
+    return typeof value === 'string' && (value.startsWith('#') || value.startsWith('rgb'));
+}
+// =============================================================================
+// MAIN EXPORT
+// =============================================================================
+export function applyGenerativeAnimations(materials, animations, startValuesCache, currentTime, hovered) {
+    if (!animations || animations.length === 0)
+        return;
+    if (materials.length === 0)
+        return;
+    logOnce('called', `Processing ${animations.length} animation(s) across ${materials.length} material(s)`);
+    for (const animation of animations) {
+        try {
+            const { property, to, duration, ease, loop = false, yoyo = false, active, triggerMode = 'always', } = animation;
+            if (active === false) {
+                log(`Skipping "${property}": active=false`);
+                continue;
+            }
+            if (triggerMode === 'hover' && !hovered) {
+                log(`Skipping "${property}": triggerMode=hover but not hovered`);
+                continue;
+            }
+            if (to === undefined) {
+                warnOnce(`no-to-${property}`, `Skipping "${property}": no 'to' value defined`);
+                continue;
+            }
+            const uniformName = findUniformName(materials, property);
+            if (!uniformName) {
+                warnOnce(`no-uniform-${property}`, `No uniform found for property "${property}" (tried: ${candidateUniformNames(property).join(', ')}) — available uniforms on mat[0]: ${Object.keys(materials[0]?.uniforms ?? {}).join(', ')}`);
+                continue;
+            }
+            if (!(property in startValuesCache)) {
+                const currentVal = readUniformValue(materials, uniformName);
+                startValuesCache[property] = animation.from !== undefined ? animation.from : currentVal;
+                log('cached start value', { property, uniformName, startValue: startValuesCache[property] });
+            }
+            const from = startValuesCache[property];
+            if (from === undefined || from === null)
+                continue;
+            let timeProgress = calculateTimeProgress(currentTime, duration, yoyo, loop);
+            if (ease) {
+                const easingFunctionName = gsapEasingMap[ease] || ease;
+                timeProgress = applyEasing(easingFunctionName, timeProgress);
+            }
+            if (isColorValue(from)) {
+                if (typeof to !== 'string') {
+                    warnOnce(`bad-to-${property}`, `Color property "${property}" has non-string 'to' value:`, to);
+                    continue;
+                }
+                applyColorToMaterials(materials, uniformName, from, to, timeProgress);
+            }
+            else if (typeof from === 'number') {
+                if (typeof to !== 'number') {
+                    warnOnce(`bad-to-num-${property}`, `Numeric property "${property}" has non-numeric 'to' value:`, to);
+                    continue;
+                }
+                applyNumericToMaterials(materials, uniformName, MathUtils.lerp(from, to, timeProgress));
+            }
+            else {
+                warnOnce(`bad-from-${property}`, `Unhandled 'from' type for property "${property}":`, typeof from, from);
+                continue;
+            }
+            log('animated', { property, uniformName, from, to, timeProgress });
+        }
+        catch (err) {
+            console.error(`[GenerativeEffectsAnimations] Error animating property "${animation.property}":`, err);
+        }
+    }
+}

package/dist/utils/hasHoverAnimation.d.ts

@@ -0,0 +1,3 @@
+import type { ObjectAnimations } from "@3driseai/3drise-core";
+export declare function hasHoverAnimation(animations: ObjectAnimations | undefined): boolean;
+//# sourceMappingURL=hasHoverAnimation.d.ts.map

package/dist/utils/hasHoverAnimation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hasHoverAnimation.d.ts","sourceRoot":"","sources":["../../src/utils/hasHoverAnimation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAE9D,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,gBAAgB,GAAG,SAAS,GAAG,OAAO,CAcnF"}

package/dist/utils/hasHoverAnimation.js

@@ -0,0 +1,15 @@
+export function hasHoverAnimation(animations) {
+    if (!animations)
+        return false;
+    if (animations.transform?.animations?.some(a => a.triggerMode === 'hover'))
+        return true;
+    if (animations.transform?.effects?.some(e => e.triggerMode === 'hover'))
+        return true;
+    if (animations.material?.animations?.some(a => a.triggerMode === 'hover'))
+        return true;
+    if (animations.edges?.animations?.some(a => a.triggerMode === 'hover'))
+        return true;
+    if (animations.effects?.animations?.some(a => a.triggerMode === 'hover'))
+        return true;
+    return false;
+}

package/dist/utils/materialUtils.d.ts

@@ -0,0 +1,23 @@
+import type { MaterialSettings, MaterialInstance } from '@3driseai/3drise-core';
+import type { Object3D } from "three";
+/**
+ * Read the current live material values for the given keys from a Three.js object.
+ * Used at step-start time to populate missing `from` values so interpolation always
+ * has a defined baseline rather than snapping.
+ */
+export declare function snapshotMaterialValues(object: Object3D, keys: string[]): Record<string, any>;
+/**
+ * Interpolate all material properties from `materialFrom` → `materialTo` at the
+ * given progress (0-1) and apply them to every material on the object.
+ *
+ * Uses `interpolateValue` from core (type-aware: color, vector2, vector3, number).
+ * Always call `snapshotMaterialValues` at step-start so `materialFrom` is fully
+ * populated — avoids the silent-snap bug caused by `undefined ?? toVal` fallback.
+ */
+export declare function interpolateMaterialProps(object: Object3D, materialFrom: Record<string, any>, materialTo: Record<string, any>, progress: number): void;
+/**
+ * Standalone utility: Apply material to a single object (for use outside hooks).
+ * Uses shared utilities for texture resolution and material creation.
+ */
+export declare const applyMaterialToObject: (object: any, materialSettings: MaterialSettings) => Promise<MaterialInstance | undefined>;
+//# sourceMappingURL=materialUtils.d.ts.map

package/dist/utils/materialUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"materialUtils.d.ts","sourceRoot":"","sources":["../../src/utils/materialUtils.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAChF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAKtC;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAS5F;AAID;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAyBrJ;AAID;;;GAGG;AACH,eAAO,MAAM,qBAAqB,GAAU,QAAQ,GAAG,EAAE,kBAAkB,gBAAgB,KAAG,OAAO,CAAC,gBAAgB,GAAG,SAAS,CASjI,CAAC"}

package/dist/utils/materialUtils.js

@@ -0,0 +1,81 @@
+// =============================================================================
+// materialUtils — Material interpolation utilities for viewer hooks
+// =============================================================================
+//
+// Shared utilities for sequence animation material application.
+// Snapshots live material values for smooth interpolation when `from` is
+// omitted in a transition, and applies type-aware interpolation using core utils.
+//
+import { getMaterialPropertyValue, interpolateValue, applySingleProperty, createAndApplyMaterial, MATERIAL_INSTANCE_KEY, resolveTextures, } from '@3driseai/3drise-core';
+// ─────────────────────────────────────────────────────────────────────────────
+// Snapshot
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Read the current live material values for the given keys from a Three.js object.
+ * Used at step-start time to populate missing `from` values so interpolation always
+ * has a defined baseline rather than snapping.
+ */
+export function snapshotMaterialValues(object, keys) {
+    const snapshot = {};
+    for (const key of keys) {
+        const value = getMaterialPropertyValue(object, key);
+        if (value !== null && value !== undefined) {
+            snapshot[key] = value;
+        }
+    }
+    return snapshot;
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Per-frame interpolation
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Interpolate all material properties from `materialFrom` → `materialTo` at the
+ * given progress (0-1) and apply them to every material on the object.
+ *
+ * Uses `interpolateValue` from core (type-aware: color, vector2, vector3, number).
+ * Always call `snapshotMaterialValues` at step-start so `materialFrom` is fully
+ * populated — avoids the silent-snap bug caused by `undefined ?? toVal` fallback.
+ */
+export function interpolateMaterialProps(object, materialFrom, materialTo, progress) {
+    const keys = Object.keys(materialTo);
+    if (keys.length === 0)
+        return;
+    for (const key of keys) {
+        const fromVal = materialFrom[key];
+        const toVal = materialTo[key];
+        if (fromVal === undefined && toVal === undefined)
+            continue;
+        // fromVal is guaranteed to be defined after snapshotMaterialValues at step-start.
+        // Fall back to toVal only as a last resort (e.g. the snapshot found nothing).
+        const interpolated = interpolateValue(key, fromVal ?? toVal, toVal, progress);
+        object.traverse((child) => {
+            if (!child.material)
+                return;
+            const mats = Array.isArray(child.material) ? child.material : [child.material];
+            for (const mat of mats) {
+                // Handle opacity: ensure transparency mode is enabled
+                if (key === 'opacity' && typeof interpolated === 'number' && 'transparent' in mat) {
+                    mat.transparent = interpolated < 1;
+                }
+                applySingleProperty(mat, key, interpolated);
+            }
+        });
+    }
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Standalone material application
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Standalone utility: Apply material to a single object (for use outside hooks).
+ * Uses shared utilities for texture resolution and material creation.
+ */
+export const applyMaterialToObject = async (object, materialSettings) => {
+    if (!object || !materialSettings)
+        return;
+    const variant = materialSettings.materialVariant || 'Standard';
+    const resolvedSettings = await resolveTextures(variant, materialSettings);
+    const materialInstance = createAndApplyMaterial(variant, resolvedSettings);
+    object.material = materialInstance.material;
+    object.userData[MATERIAL_INSTANCE_KEY] = materialInstance;
+    return materialInstance;
+};

package/dist/utils/particleAnimations.d.ts

@@ -0,0 +1,3 @@
+import type { Points } from "three";
+export declare const handleShapeAnimation: (delta: number, speed: number, animationProgress: React.RefObject<number>, pointsRef: React.RefObject<Points | null>, basePositions: React.RefObject<Float32Array | null>, targetPositions: React.RefObject<Float32Array | null>) => void;
+//# sourceMappingURL=particleAnimations.d.ts.map

package/dist/utils/particleAnimations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"particleAnimations.d.ts","sourceRoot":"","sources":["../../src/utils/particleAnimations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,OAAO,CAAC;AAEpC,eAAO,MAAM,oBAAoB,GAAI,OAAO,MAAM,EAAE,OAAO,MAAM,EAAE,mBAAmB,KAAK,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,WAAW,KAAK,CAAC,SAAS,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,eAAe,KAAK,CAAC,SAAS,CAAC,YAAY,GAAG,IAAI,CAAC,EAAE,iBAAiB,KAAK,CAAC,SAAS,CAAC,YAAY,GAAG,IAAI,CAAC,KAAG,IAgBtQ,CAAC"}

package/dist/utils/particleAnimations.js

@@ -0,0 +1,17 @@
+export const handleShapeAnimation = (delta, speed, animationProgress, pointsRef, basePositions, targetPositions) => {
+    if (!pointsRef.current || !basePositions.current)
+        return;
+    const progress = Math.min(animationProgress.current + delta * speed, 1);
+    const geometry = pointsRef.current.geometry;
+    const posAttr = geometry.attributes.position;
+    if (targetPositions.current) {
+        const galPos = targetPositions.current;
+        for (let i = 0; i < basePositions.current.length; i += 3) {
+            posAttr.array[i] = basePositions.current[i] + (galPos[i] - basePositions.current[i]) * progress;
+            posAttr.array[i + 1] = basePositions.current[i + 1] + (galPos[i + 1] - basePositions.current[i + 1]) * progress;
+            posAttr.array[i + 2] = basePositions.current[i + 2] + (galPos[i + 2] - basePositions.current[i + 2]) * progress;
+        }
+    }
+    animationProgress.current = progress;
+    posAttr.needsUpdate = true;
+};

package/dist/utils/sampleVolume.d.ts

@@ -0,0 +1,21 @@
+import type { BufferGeometry } from 'three';
+export interface SampleVolumeOptions {
+    /** Safety cap on candidate attempts, expressed as a multiple of `count`. */
+    oversample?: number;
+}
+/**
+ * Fill the solid interior of a closed mesh with uniformly distributed points.
+ *
+ * Uses point-in-mesh rejection sampling: a ray cast from a candidate crosses
+ * the (double-sided) surface an odd number of times iff the candidate lies
+ * inside the solid. Works on any watertight geometry — heart, box, or an
+ * arbitrary imported host mesh.
+ *
+ * Returns a flat XYZ Float32Array. May fall short of `count` on very sparse
+ * bounding boxes (the cap prevents runaway loops).
+ *
+ * Note: brute-force raycast is fine for preview-scale counts. For heavy host
+ * meshes or large counts, swap `intersectObject` for a BVH-accelerated query.
+ */
+export declare function sampleVolume(geometry: BufferGeometry, count: number, { oversample }?: SampleVolumeOptions): Float32Array;
+//# sourceMappingURL=sampleVolume.d.ts.map

package/dist/utils/sampleVolume.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sampleVolume.d.ts","sourceRoot":"","sources":["../../src/utils/sampleVolume.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC;AAC5C,MAAM,WAAW,mBAAmB;IAChC,4EAA4E;IAC5E,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,cAAc,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE,UAAe,EAAE,GAAE,mBAAwB,GAAG,YAAY,CA4BjI"}

package/dist/utils/sampleVolume.js

@@ -0,0 +1,44 @@
+import { DoubleSide, Mesh, MeshBasicMaterial, Raycaster, Vector3, } from 'three';
+/**
+ * Fill the solid interior of a closed mesh with uniformly distributed points.
+ *
+ * Uses point-in-mesh rejection sampling: a ray cast from a candidate crosses
+ * the (double-sided) surface an odd number of times iff the candidate lies
+ * inside the solid. Works on any watertight geometry — heart, box, or an
+ * arbitrary imported host mesh.
+ *
+ * Returns a flat XYZ Float32Array. May fall short of `count` on very sparse
+ * bounding boxes (the cap prevents runaway loops).
+ *
+ * Note: brute-force raycast is fine for preview-scale counts. For heavy host
+ * meshes or large counts, swap `intersectObject` for a BVH-accelerated query.
+ */
+export function sampleVolume(geometry, count, { oversample = 80 } = {}) {
+    const probe = new Mesh(geometry, new MeshBasicMaterial({ side: DoubleSide }));
+    probe.updateMatrixWorld(true);
+    geometry.computeBoundingBox();
+    const bb = geometry.boundingBox;
+    const sx = bb.max.x - bb.min.x;
+    const sy = bb.max.y - bb.min.y;
+    const sz = bb.max.z - bb.min.z;
+    const ray = new Raycaster();
+    const dir = new Vector3(0, 0, 1);
+    const p = new Vector3();
+    const out = new Float32Array(count * 3);
+    let i = 0;
+    let tries = 0;
+    const maxTries = count * oversample;
+    while (i < count && tries < maxTries) {
+        tries++;
+        p.set(bb.min.x + Math.random() * sx, bb.min.y + Math.random() * sy, bb.min.z + Math.random() * sz);
+        ray.set(p, dir);
+        if (ray.intersectObject(probe, false).length % 2 === 1) {
+            out[i * 3] = p.x;
+            out[i * 3 + 1] = p.y;
+            out[i * 3 + 2] = p.z;
+            i++;
+        }
+    }
+    probe.material.dispose();
+    return i === count ? out : out.slice(0, i * 3);
+}

package/dist/utils/sceneQuery.d.ts

@@ -0,0 +1,9 @@
+import type { Object3D } from "three";
+export declare function findById(id: string): Object3D | null;
+/**
+ * Find a Three.js object in the live scene by its Three.js name (object.name).
+ * Uses the native Three.js getObjectByName for efficiency.
+ * Returns null if the scene is not yet initialised or the object is not found.
+ */
+export declare function findByName(name: string): Object3D | null;
+//# sourceMappingURL=sceneQuery.d.ts.map

package/dist/utils/sceneQuery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sceneQuery.d.ts","sourceRoot":"","sources":["../../src/utils/sceneQuery.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAEtC,wBAAgB,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI,CAUpD;AACD;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI,CAIxD"}

package/dist/utils/sceneQuery.js

@@ -0,0 +1,22 @@
+import { SceneStore } from '@3driseai/3drise-core';
+export function findById(id) {
+    if (!id || !SceneStore.scene)
+        return null;
+    let found = null;
+    SceneStore.scene.traverse((obj) => {
+        if (!found && obj.userData.id === id) {
+            found = obj;
+        }
+    });
+    return found;
+}
+/**
+ * Find a Three.js object in the live scene by its Three.js name (object.name).
+ * Uses the native Three.js getObjectByName for efficiency.
+ * Returns null if the scene is not yet initialised or the object is not found.
+ */
+export function findByName(name) {
+    if (!SceneStore.scene)
+        return null;
+    return SceneStore.scene.getObjectByName(name) ?? null;
+}

package/dist/utils/shaderUtils.d.ts

@@ -0,0 +1,6 @@
+import type { Use3driseShaderEffects } from "@3driseai/3drise-core";
+export declare function update3driseShaderUniforms(uniforms: any, effects: Use3driseShaderEffects, u_time: number, pointer: {
+    x: number;
+    y: number;
+}): void;
+//# sourceMappingURL=shaderUtils.d.ts.map

package/dist/utils/shaderUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shaderUtils.d.ts","sourceRoot":"","sources":["../../src/utils/shaderUtils.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AAEpE,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,GAAG,EAAE,OAAO,EAAE,sBAAsB,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE;IACxG,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACb,GAAG,IAAI,CAqJf"}