@ntalmagor/3drize-viewer 0.1.2

package/dist/utils/frameAnimations.js

@@ -0,0 +1,213 @@
+import { easing } from 'maath';
+import { Color } from 'three';
+export function shouldEffectBeActive(effect, hovered, clicked) {
+    if (!effect.enabled)
+        return false;
+    const mode = effect.triggerMode ?? 'always';
+    switch (mode) {
+        case 'always': return true;
+        case 'hover': return hovered;
+        case 'click': return clicked;
+        default: return true;
+    }
+}
+export function getActiveEffects(effects, hovered, clicked) {
+    return effects.filter(effect => shouldEffectBeActive(effect, hovered, clicked));
+}
+export function applyWaveEffect(object, effect, time, originalY) {
+    const options = effect.options;
+    const amplitude = options?.amplitude ?? 0.1;
+    const frequency = options?.frequency ?? 2;
+    object.position.y = originalY + Math.sin(time * frequency * (effect.speed ?? 1)) * amplitude * (effect.intensity ?? 1);
+}
+export function applyFloatEffect(object, effect, time, originalPosition) {
+    const options = effect.options;
+    const speed = effect.speed ?? 1;
+    const intensity = effect.intensity ?? 1;
+    object.position.x = originalPosition.x + Math.cos(time * speed * 0.5) * ((options?.amplitudeX ?? 0.05) * intensity);
+    object.position.y = originalPosition.y + Math.sin(time * speed) * ((options?.amplitudeY ?? 0.1) * intensity);
+    object.position.z = originalPosition.z + Math.sin(time * speed * 0.3) * ((options?.amplitudeZ ?? 0.03) * intensity);
+}
+export function applyPulseEffect(object, effect, time, originalScale) {
+    const options = effect.options;
+    const minScale = options?.minScale ?? 0.95;
+    const maxScale = options?.maxScale ?? 1.05;
+    const scaleFactor = minScale + (Math.sin(time * (effect.speed ?? 2)) + 1) * 0.5 * (maxScale - minScale);
+    object.scale.set(originalScale.x * scaleFactor, originalScale.y * scaleFactor, originalScale.z * scaleFactor);
+}
+export function applyShakeEffect(object, effect, originalPosition) {
+    const options = effect.options;
+    const intensity = effect.intensity ?? 1;
+    object.position.x = originalPosition.x + (Math.random() - 0.5) * ((options?.amplitudeX ?? 0.02) * intensity);
+    object.position.y = originalPosition.y + (Math.random() - 0.5) * ((options?.amplitudeY ?? 0.02) * intensity);
+}
+export function applyBounceEffect(object, effect, time, originalY) {
+    const options = effect.options;
+    object.position.y = originalY + Math.abs(Math.sin(time * (effect.speed ?? 3))) * (options?.bounceHeight ?? 0.2) * (effect.intensity ?? 1);
+}
+export function applyRotate3DEffect(object, effect, time, originalRotation) {
+    const options = effect.options;
+    const speed = effect.speed ?? 1;
+    const intensity = (effect.intensity ?? 1) * 0.1;
+    if (options?.axisX !== false)
+        object.rotation.x = originalRotation.x + Math.cos(time * speed * 0.7) * intensity * 0.5;
+    if (options?.axisY !== false)
+        object.rotation.y = originalRotation.y + Math.sin(time * speed) * intensity;
+    if (options?.axisZ)
+        object.rotation.z = originalRotation.z + Math.sin(time * speed * 0.5) * intensity * 0.3;
+}
+export function applyFadeEffect(effect, time) {
+    const options = effect.options;
+    const fadeMin = options?.fadeMin ?? 0.3;
+    const fadeMax = options?.fadeMax ?? 1;
+    return fadeMin + (Math.sin(time * (effect.speed ?? 1)) + 1) * 0.5 * (fadeMax - fadeMin);
+}
+export function applySpinEffect(object, effect, dt) {
+    const options = effect.options;
+    const axis = options?.axis ?? 'y';
+    object.rotation[axis] += dt * (effect.speed ?? 1);
+}
+export function applySwayEffect(object, effect, time, originalRotation) {
+    const options = effect.options;
+    const axis = options?.axis ?? 'z';
+    object.rotation[axis] = originalRotation[axis] + Math.sin(time * (effect.speed ?? 1)) * (options?.angle ?? 0.2) * (effect.intensity ?? 1);
+}
+export function applyFlipEffect(object, effect, isActive, dt, originalRotation, sensitivity = 0.5) {
+    const options = effect.options;
+    const axis = options?.axis ?? 'y';
+    const dampSpeed = (effect.speed ?? 0.3) * (1 - sensitivity * 0.5);
+    easing.damp(object.rotation, axis, isActive ? originalRotation[axis] + Math.PI : originalRotation[axis], dampSpeed, dt);
+}
+export function applyScaleEffect(object, effect, isActive, dt, originalScale, sensitivity = 0.5) {
+    const options = effect.options;
+    const targetScale = options?.targetScale ?? 1.2;
+    const dampSpeed = (effect.speed ?? 0.1) * (1 - sensitivity * 0.5);
+    const scale = isActive
+        ? [originalScale.x * targetScale, originalScale.y * targetScale, originalScale.z * targetScale]
+        : [originalScale.x, originalScale.y, originalScale.z];
+    easing.damp3(object.scale, scale, dampSpeed, dt);
+}
+export function applyTransformEffects(object, effects, time, dt, state, hovered, clicked, sensitivity = 0.5) {
+    const result = {};
+    for (const effect of effects) {
+        const isActive = shouldEffectBeActive(effect, hovered, clicked);
+        if (!isActive)
+            continue;
+        switch (effect.type) {
+            case 'wave':
+                applyWaveEffect(object, effect, time, state.originalPosition.y);
+                break;
+            case 'float':
+                applyFloatEffect(object, effect, time, state.originalPosition);
+                break;
+            case 'pulse':
+                applyPulseEffect(object, effect, time, state.originalScale);
+                break;
+            case 'shake':
+                applyShakeEffect(object, effect, state.originalPosition);
+                break;
+            case 'bounce':
+                applyBounceEffect(object, effect, time, state.originalPosition.y);
+                break;
+            case 'rotate3d':
+                applyRotate3DEffect(object, effect, time, state.originalRotation);
+                break;
+            case 'fade':
+                result.opacity = applyFadeEffect(effect, time);
+                break;
+            case 'spin':
+                applySpinEffect(object, effect, dt);
+                break;
+            case 'sway':
+                applySwayEffect(object, effect, time, state.originalRotation);
+                break;
+        }
+    }
+    for (const effect of effects) {
+        if (!effect.enabled)
+            continue;
+        const isActive = shouldEffectBeActive(effect, hovered, clicked);
+        switch (effect.type) {
+            case 'flip':
+                applyFlipEffect(object, effect, isActive, dt, state.originalRotation, sensitivity);
+                break;
+            case 'scale':
+                applyScaleEffect(object, effect, isActive, dt, state.originalScale, sensitivity);
+                break;
+        }
+    }
+    return result;
+}
+function getColorFromPath(material, path) {
+    let current = material;
+    for (const part of path.split('.')) {
+        if (current == null)
+            return null;
+        current = current[part];
+    }
+    if (current?.value instanceof Color)
+        return current.value;
+    if (current instanceof Color)
+        return current;
+    return null;
+}
+export function applyColorTransitionEffect(object, effect, isActive, dt, baseColors, applyToChildren = true, sensitivity = 0.5) {
+    const targetProperties = effect.targetProperties ?? ['color'];
+    const targetColor = isActive ? effect.targetColor : null;
+    const dampSpeed = 0.1 * (1 - sensitivity * 0.5);
+    const applyToMaterial = (material) => {
+        for (const propPath of targetProperties) {
+            const color = getColorFromPath(material, propPath);
+            if (color)
+                easing.dampC(color, targetColor || baseColors[propPath] || '#ffffff', dampSpeed, dt);
+        }
+    };
+    if (applyToChildren)
+        object.traverse((child) => { if (child.material)
+            applyToMaterial(child.material); });
+    else {
+        const mesh = object;
+        if (mesh.material)
+            applyToMaterial(mesh.material);
+    }
+}
+export function applyPulseColorEffect(object, effect, time, baseColors, applyToChildren = true) {
+    const targetProperties = effect.targetProperties ?? ['color'];
+    const blend = (Math.sin(time * (effect.speed ?? 1) * 2) + 1) * 0.5 * (effect.intensity ?? 1);
+    const baseColorObj = new Color();
+    const targetColorObj = new Color(effect.targetColor);
+    const resultColor = new Color();
+    const applyToMaterial = (material) => {
+        for (const propPath of targetProperties) {
+            const color = getColorFromPath(material, propPath);
+            if (color) {
+                baseColorObj.set(baseColors[propPath] || '#ffffff');
+                color.copy(resultColor.copy(baseColorObj).lerp(targetColorObj, blend));
+            }
+        }
+    };
+    if (applyToChildren)
+        object.traverse((child) => { if (child.material)
+            applyToMaterial(child.material); });
+    else {
+        const mesh = object;
+        if (mesh.material)
+            applyToMaterial(mesh.material);
+    }
+}
+export function applyAllColorEffects(object, effects, time, dt, baseColors, hovered, clicked, applyToChildren = true, sensitivity = 0.5) {
+    for (const effect of effects) {
+        if (!effect.enabled)
+            continue;
+        const isActive = shouldEffectBeActive(effect, hovered, clicked);
+        switch (effect.type) {
+            case 'color-transition':
+                applyColorTransitionEffect(object, effect, isActive, dt, baseColors, applyToChildren, sensitivity);
+                break;
+            case 'pulse-color':
+                if (isActive)
+                    applyPulseColorEffect(object, effect, time, baseColors, applyToChildren);
+                break;
+        }
+    }
+}

package/dist/utils/handleGenerativeEffectsAnimations.d.ts

@@ -0,0 +1,5 @@
+import * as THREE from 'three';
+import type { AnimationOptions } from '@ntalmagor/3drize-core';
+export declare const DEBUG_GENERATIVE_EFFECTS = false;
+export declare function applyGenerativeAnimations(materials: THREE.ShaderMaterial[], animations: AnimationOptions[] | undefined, startValuesCache: Record<string, any>, currentTime: number, hovered: boolean): void;
+//# sourceMappingURL=handleGenerativeEffectsAnimations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"handleGenerativeEffectsAnimations.d.ts","sourceRoot":"","sources":["../../src/utils/handleGenerativeEffectsAnimations.ts"],"names":[],"mappings":"AAoBA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAuG/D,eAAO,MAAM,wBAAwB,QAAQ,CAAC;AA4F9C,wBAAgB,yBAAyB,CACvC,SAAS,EAAE,KAAK,CAAC,cAAc,EAAE,EACjC,UAAU,EAAE,gBAAgB,EAAE,GAAG,SAAS,EAC1C,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EACrC,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,OAAO,GACf,IAAI,CA4DN"}

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 '@ntalmagor/3drize-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,wBAAwB,CAAC;AAE/D,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,gBAAgB,GAAG,SAAS,GAAG,OAAO,CAQnF"}

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/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,GAC/B,OAAO,MAAM,EACb,OAAO,MAAM,EACb,mBAAmB,KAAK,CAAC,SAAS,CAAC,MAAM,CAAC,EAC1C,WAAW,KAAK,CAAC,SAAS,CAAC,MAAM,GAAG,IAAI,CAAC,EACzC,eAAe,KAAK,CAAC,SAAS,CAAC,YAAY,GAAG,IAAI,CAAC,EACnD,iBAAiB,KAAK,CAAC,SAAS,CAAC,YAAY,GAAG,IAAI,CAAC,KACpD,IAkBF,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/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;AAItC,wBAAgB,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI,CASpD;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI,CAGxD"}

package/dist/utils/sceneQuery.js

@@ -0,0 +1,22 @@
+import { SceneStore } from '@ntalmagor/3drize-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 '@ntalmagor/3drize-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,wBAAwB,CAAC;AAErE,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,GAAG,EACb,OAAO,EAAE,sBAAsB,EAC/B,MAAM,EAAE,MAAM,EACd,OAAO,EAAE;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,GAChC,IAAI,CAqGN"}