@ntalmagor/3drize-viewer 0.1.2

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

@@ -0,0 +1 @@
+{"version":3,"file":"useContinuousEffects.d.ts","sourceRoot":"","sources":["../../src/hooks/useContinuousEffects.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAEjC,OAAO,EAAyK,KAAK,qBAAqB,EAAE,KAAK,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAU7P,eAAO,MAAM,wBAAwB,QAAQ,CAAC;AAY9C,MAAM,WAAW,2BAA2B;IACxC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,OAAO,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,0BAA0B;IACvC,eAAe,EAAE,MAAM,OAAO,CAAC;IAC/B,cAAc,EAAE,KAAK,CAAC,gBAAgB,CAAC,WAAW,GAAG,IAAI,CAAC,CAAC;CAC9D;AAGD,eAAO,MAAM,oBAAoB,GAE7B,gBAAgB,qBAAqB,GAAG,IAAI,EAC5C,SAAS,2BAA2B,YAAK,EACzC,QAAQ,QAAQ,KACjB,0BA0NF,CAAC;AAEF,eAAe,oBAAoB,CAAC"}

package/dist/hooks/useContinuousEffects.js

@@ -0,0 +1,173 @@
+import { useRef, useEffect } from "react";
+import { useFrame } from "@react-three/fiber";
+import { animateUniforms, cacheChildrenWithMaterials, handleEdgesAnimations, handleMaterialAnimations, handleMaterialEffects, handleTransformAnimations, handleTransformEffect } from "@ntalmagor/3drize-core";
+import usePathAnimation from "./usePathAnimation";
+// ═══════════════════════════════════════════════════════════════════════════════
+// DEBUG LOGGING
+// ═══════════════════════════════════════════════════════════════════════════════
+export const DEBUG_CONTINUOUS_EFFECTS = false;
+const log = (message, ...args) => {
+    if (DEBUG_CONTINUOUS_EFFECTS) {
+        console.log(`[ObjectAnimations] ${message}`, ...args);
+    }
+};
+export const useContinuousEffects = (
+// object: Object3D | null,
+objectSettings, options = {}, object) => {
+    const { enabled = true, animateMaterial = true, hovered = false } = options;
+    // console.log("useObjectAnimation called with:", {
+    //     object
+    // });
+    // const { object } = ref || {};
+    // Path animation hook for animations with pathId
+    const { startPathAnimation, updatePathAnimation, isAnimating: isPathAnimating, stopPathAnimation, } = usePathAnimation();
+    // ─────────────────────────────────────────────────────────────────────────────
+    // REFS
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Track which path animation is currently active
+    const activePathIdRef = useRef(null);
+    const effectStateRef = useRef(null);
+    // Cache children with materials to avoid traverse() every frame
+    const childrenWithMaterialsRef = useRef([]);
+    const lastObjectRef = useRef(null);
+    // Cache start values for material animations
+    const startValuesRef = useRef({});
+    // Cache start values for edges animations
+    const edgesStartValuesRef = useRef({});
+    // ─────────────────────────────────────────────────────────────────────────────
+    // DERIVED STATE (read from new continuous structure)
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Transform domain - now supports multiple effects (one per category)
+    const transformAnimations = objectSettings?.animations?.transform?.animations || [];
+    const transformEffects = objectSettings?.animations?.transform?.effects || [];
+    const enabledTransformEffects = transformEffects.filter(effect => effect.enabled);
+    const hasTransformEffects = enabledTransformEffects.length > 0;
+    // Skip transform animations if any effect is enabled (effects take precedence)
+    const activeTransformAnimations = hasTransformEffects ? [] : transformAnimations;
+    const hasTransformAnimations = activeTransformAnimations.length > 0;
+    // Edges domain
+    const edgesAnimations = objectSettings?.animations?.edges?.animations || [];
+    const hasEdgesAnimations = edgesAnimations.length > 0;
+    // const effectsAnimations = objectSettings?.effects?.animations || [];
+    // const hasEffectsAnimations = effectsAnimations.length > 0;
+    // Material domain
+    const materialAnimations = objectSettings?.animations?.material?.animations || [];
+    const materialEffects = objectSettings?.animations?.material?.effects || [];
+    const enabledMaterialEffects = materialEffects.filter(effect => effect.enabled);
+    const hasMaterialEffects = enabledMaterialEffects.length > 0;
+    // Skip material animations if any effect is enabled (effects take precedence)
+    const activeMaterialAnimations = hasMaterialEffects ? [] : materialAnimations;
+    const hasMaterialAnimations = activeMaterialAnimations.length > 0;
+    // Combined check for any animations
+    const hasAnimations = hasTransformAnimations || hasMaterialAnimations;
+    // Continuous effects config
+    const applyToChildren = false;
+    // ─────────────────────────────────────────────────────────────────────────────
+    // CACHE CHILDREN WITH MATERIALS
+    // ─────────────────────────────────────────────────────────────────────────────
+    useEffect(() => {
+        if (!object || object === lastObjectRef.current)
+            return;
+        lastObjectRef.current = object;
+        childrenWithMaterialsRef.current = cacheChildrenWithMaterials(object);
+        log('cached children with materials', {
+            count: childrenWithMaterialsRef.current.length,
+            objectName: object.name
+        });
+        // Reset start values cache when object changes
+        startValuesRef.current = {};
+        edgesStartValuesRef.current = {};
+    }, [object]);
+    // ─────────────────────────────────────────────────────────────────────────────
+    // PATH ANIMATION LIFECYCLE
+    // ─────────────────────────────────────────────────────────────────────────────
+    useEffect(() => {
+        if (!enabled || !object)
+            return;
+        // Path animations come from transform.animations
+        const animations = objectSettings?.animations?.transform?.animations || [];
+        const pathAnimation = animations.find(anim => anim.pathId && anim.active);
+        if (pathAnimation?.pathId) {
+            // Start path animation if not already active or if pathId changed
+            if (activePathIdRef.current !== pathAnimation.pathId) {
+                activePathIdRef.current = pathAnimation.pathId;
+                log('starting path animation', { pathId: pathAnimation.pathId, duration: pathAnimation.duration });
+                startPathAnimation(pathAnimation.pathId, pathAnimation.duration / 1000, {
+                    ease: pathAnimation.ease,
+                    loop: pathAnimation.loop,
+                    yoyo: pathAnimation.yoyo,
+                    applyRotation: pathAnimation.applyRotation,
+                    offset: pathAnimation.offset,
+                    keepOriginalTransform: pathAnimation.keepOriginalTransform,
+                });
+            }
+        }
+        else if (activePathIdRef.current) {
+            // Stop path animation if no longer active
+            // log('stopping path animation', { pathId: activePathIdRef.current });
+            stopPathAnimation();
+            activePathIdRef.current = null;
+        }
+    }, [enabled, objectSettings?.animations?.transform?.animations, object, startPathAnimation, stopPathAnimation]);
+    useFrame((state, delta) => {
+        // console.log({
+        //   enabled,
+        //   object,
+        //   objectSettings,
+        // })
+        if (!enabled || !object || !objectSettings)
+            return;
+        const time = state.clock.getElapsedTime();
+        const mouse = state.pointer;
+        const currentTime = Date.now();
+        // Update path animation if active
+        const pathIsActive = isPathAnimating();
+        if (pathIsActive) {
+            updatePathAnimation(delta, object);
+        }
+        // ─────────────────────────────────────────────────────────────────────────
+        // TRANSFORM DOMAIN
+        // ─────────────────────────────────────────────────────────────────────────
+        if (hasTransformAnimations) {
+            handleTransformAnimations({
+                object,
+                meshSettings: objectSettings.meshSettings || {},
+                pathIsActive,
+            }, activeTransformAnimations, currentTime, hovered);
+        }
+        // Handle transform effect (wave, float, spin, etc.) - now supports multiple effects
+        if (hasTransformEffects) {
+            handleTransformEffect(object, enabledTransformEffects, time, delta, effectStateRef, hovered);
+        }
+        // ─────────────────────────────────────────────────────────────────────────
+        // MATERIAL DOMAIN
+        // ─────────────────────────────────────────────────────────────────────────
+        if (animateMaterial) {
+            // Handle material animations (any material property)
+            if (hasMaterialAnimations) {
+                handleMaterialAnimations({
+                    object,
+                    materialSettings: objectSettings.materialSettings || {},
+                    startValuesCache: startValuesRef.current,
+                }, activeMaterialAnimations, currentTime, hovered);
+            }
+            // Handle material effects (color effects)
+            if (enabledMaterialEffects.length > 0) {
+                handleMaterialEffects(object, enabledMaterialEffects, time, delta, effectStateRef, applyToChildren);
+            }
+            // ─────────────────────────────────────────────────────────────────────────
+            // EDGES DOMAIN
+            // ─────────────────────────────────────────────────────────────────────────
+            if (hasEdgesAnimations) {
+                handleEdgesAnimations({ object, startValuesCache: edgesStartValuesRef.current }, edgesAnimations, currentTime, hovered);
+            }
+            // Animate uniforms (u_time, u_mouse, u_camera_position)
+            animateUniforms(childrenWithMaterialsRef.current, time, mouse, state.camera.position);
+        }
+    });
+    return {
+        isPathAnimating,
+        effectStateRef,
+    };
+};
+export default useContinuousEffects;

package/dist/hooks/useCubeCamera.d.ts

@@ -0,0 +1,19 @@
+import * as THREE from 'three';
+import type { TimeSettings } from '../../../core/src/types/scene3d';
+import type { HdrSettings } from '../../../core/src/types/environment';
+export interface UseCubeCameraOptions {
+    hdrSettings: HdrSettings;
+    skyVisible: boolean;
+    sunSystemVisible: boolean;
+    timeSettings: TimeSettings;
+    resolution?: number;
+    position?: THREE.Vector3;
+    onEnvironmentUpdate?: (texture: THREE.Texture) => void;
+}
+export declare const useCubeCamera: (options: UseCubeCameraOptions) => {
+    cubeCamera: THREE.CubeCamera | null;
+    updateEnvironment: () => THREE.Texture | null;
+    initializeCubeCamera: () => THREE.CubeCamera | null;
+    dispose: () => void;
+};
+//# sourceMappingURL=useCubeCamera.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useCubeCamera.d.ts","sourceRoot":"","sources":["../../src/hooks/useCubeCamera.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAQ/B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AACpE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qCAAqC,CAAC;AAEvE,MAAM,WAAW,oBAAoB;IACnC,WAAW,EAAE,WAAW,CAAC;IACzB,UAAU,EAAE,OAAO,CAAC;IACpB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,YAAY,EAAE,YAAY,CAAC;IAC3B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,KAAK,CAAC,OAAO,CAAC;IACzB,mBAAmB,CAAC,EAAE,CAAC,OAAO,EAAE,KAAK,CAAC,OAAO,KAAK,IAAI,CAAC;CACxD;AAED,eAAO,MAAM,aAAa,GAAI,SAAS,oBAAoB;;;;;CAqE1D,CAAC"}

package/dist/hooks/useCubeCamera.js

@@ -0,0 +1,73 @@
+import { useRef, useCallback, useEffect } from 'react';
+import { useThree, useFrame } from '@react-three/fiber';
+import * as THREE from 'three';
+import { createCubeCamera, updateCubeCamera, disposeCubeCamera, setSceneEnvironment, clearSceneEnvironment, } from '../../../core/src/utils/environmentUtils';
+export const useCubeCamera = (options) => {
+    const { hdrSettings, skyVisible, sunSystemVisible, timeSettings, resolution = 512, position = new THREE.Vector3(0, 50, 0), onEnvironmentUpdate } = options;
+    const { scene, gl: renderer } = useThree();
+    const cubeCameraRef = useRef(null);
+    const isUpdatingRef = useRef(false);
+    const backgroundName = hdrSettings.visible ? hdrSettings.name : null;
+    const initializeCubeCamera = useCallback(() => {
+        if (!renderer || !scene)
+            return null;
+        if (cubeCameraRef.current)
+            disposeCubeCamera(cubeCameraRef.current, scene);
+        cubeCameraRef.current = createCubeCamera(scene, resolution, position);
+        return cubeCameraRef.current;
+    }, [scene, renderer, resolution, position]);
+    const updateEnvironment = useCallback(() => {
+        if (!cubeCameraRef.current || !renderer || !scene)
+            return null;
+        if (isUpdatingRef.current)
+            return null;
+        try {
+            isUpdatingRef.current = true;
+            const texture = updateCubeCamera(cubeCameraRef.current, renderer, scene);
+            setSceneEnvironment(scene, texture);
+            onEnvironmentUpdate?.(texture);
+            return texture;
+        }
+        catch {
+            return null;
+        }
+        finally {
+            isUpdatingRef.current = false;
+        }
+    }, [scene, renderer, onEnvironmentUpdate]);
+    const dispose = useCallback(() => {
+        if (cubeCameraRef.current && scene) {
+            disposeCubeCamera(cubeCameraRef.current, scene);
+            cubeCameraRef.current = null;
+        }
+    }, [scene]);
+    // Create or dispose cube camera based on active sky / HDR state
+    useEffect(() => {
+        if (backgroundName) {
+            dispose();
+            return;
+        }
+        if (skyVisible || sunSystemVisible) {
+            initializeCubeCamera();
+            updateEnvironment();
+        }
+        else {
+            dispose();
+            clearSceneEnvironment(scene);
+        }
+    }, [backgroundName, skyVisible, sunSystemVisible]);
+    // Live update when auto-animating (sky moves, environment changes)
+    const UPDATE_INTERVAL_MS = 300;
+    useFrame((state) => {
+        if (backgroundName || !(skyVisible || sunSystemVisible))
+            return;
+        if (!timeSettings.autoAnimate)
+            return;
+        if (state.clock.getElapsedTime() * 1000 > UPDATE_INTERVAL_MS) {
+            updateEnvironment();
+        }
+    });
+    // Cleanup on unmount
+    useEffect(() => () => dispose(), [dispose]);
+    return { cubeCamera: cubeCameraRef.current, updateEnvironment, initializeCubeCamera, dispose };
+};

package/dist/hooks/useEnvironmentEffects.d.ts

@@ -0,0 +1,12 @@
+import type { TimeSettings } from '../../../core/src/types/scene3d';
+export interface UseEnvironmentEffectsOptions {
+    updateEnvironment: () => void;
+    skyVisible: boolean;
+    sunSystemVisible: boolean;
+    timeSettings: TimeSettings;
+    updateDelay?: number;
+}
+export declare const useEnvironmentEffects: (options: UseEnvironmentEffectsOptions) => {
+    triggerUpdate: () => void;
+};
+//# sourceMappingURL=useEnvironmentEffects.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useEnvironmentEffects.d.ts","sourceRoot":"","sources":["../../src/hooks/useEnvironmentEffects.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAEpE,MAAM,WAAW,4BAA4B;IAC3C,iBAAiB,EAAE,MAAM,IAAI,CAAC;IAC9B,UAAU,EAAE,OAAO,CAAC;IACpB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,YAAY,EAAE,YAAY,CAAC;IAC3B,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,eAAO,MAAM,qBAAqB,GAAI,SAAS,4BAA4B;;CAwB1E,CAAC"}

package/dist/hooks/useEnvironmentEffects.js

@@ -0,0 +1,22 @@
+import { useRef, useCallback, useEffect } from 'react';
+import { createDebouncedUpdate } from '../../../core/src/utils/environmentUtils';
+export const useEnvironmentEffects = (options) => {
+    const { updateEnvironment, skyVisible, sunSystemVisible, timeSettings, updateDelay = 50 } = options;
+    const debouncedUpdate = useRef(createDebouncedUpdate(updateEnvironment, updateDelay));
+    useEffect(() => {
+        debouncedUpdate.current = createDebouncedUpdate(updateEnvironment, updateDelay);
+    }, [updateEnvironment, updateDelay]);
+    // Trigger debounced update when sky visibility changes
+    useEffect(() => {
+        debouncedUpdate.current();
+    }, [skyVisible, sunSystemVisible]);
+    // Trigger update when time settings change
+    useEffect(() => {
+        if (timeSettings.enabled)
+            updateEnvironment();
+    }, [timeSettings, updateEnvironment]);
+    const triggerUpdate = useCallback(() => {
+        updateEnvironment();
+    }, [updateEnvironment]);
+    return { triggerUpdate };
+};

package/dist/hooks/useFrameEffects.d.ts

@@ -0,0 +1,6 @@
+export declare function useFrameEffects(isActive: boolean): {
+    handlePointerEnter: (e: any) => void;
+    handlePointerLeave: () => void;
+    hovered: boolean;
+};
+//# sourceMappingURL=useFrameEffects.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useFrameEffects.d.ts","sourceRoot":"","sources":["../../src/hooks/useFrameEffects.ts"],"names":[],"mappings":"AAEA,wBAAgB,eAAe,CAAC,QAAQ,EAAE,OAAO;4BAIJ,GAAG;;;EAgB/C"}

package/dist/hooks/useFrameEffects.js

@@ -0,0 +1,19 @@
+import { useCallback, useState, useRef } from "react";
+export function useFrameEffects(isActive) {
+    const [hovered, setHovered] = useState(false);
+    const hoveredRef = useRef(false);
+    const handlePointerEnter = useCallback((e) => {
+        e.stopPropagation();
+        if (!isActive && !hoveredRef.current) {
+            hoveredRef.current = true;
+            setHovered(true);
+        }
+    }, [isActive]);
+    const handlePointerLeave = useCallback(() => {
+        if (!isActive && hoveredRef.current) {
+            hoveredRef.current = false;
+            setHovered(false);
+        }
+    }, [isActive]);
+    return { handlePointerEnter, handlePointerLeave, hovered };
+}

package/dist/hooks/useInteractionEffects.d.ts

@@ -0,0 +1,11 @@
+import { Object3D } from "three";
+import type { CreatedObjectSettings } from '@ntalmagor/3drize-core';
+export interface UseInteractionEffectsOptions {
+    enabled?: boolean;
+    animateMaterial?: boolean;
+}
+export interface UseInteractionEffectsResult {
+}
+export declare const useInteractionEffects: (objectSettings: CreatedObjectSettings | null, options: UseInteractionEffectsOptions | undefined, object: Object3D) => UseInteractionEffectsResult;
+export default useInteractionEffects;
+//# sourceMappingURL=useInteractionEffects.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useInteractionEffects.d.ts","sourceRoot":"","sources":["../../src/hooks/useInteractionEffects.ts"],"names":[],"mappings":"AACA,OAAO,EAAS,QAAQ,EAAE,MAAM,OAAO,CAAC;AAExC,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAEpE,MAAM,WAAW,4BAA4B;IAC3C,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED,MAAM,WAAW,2BAA2B;CAE3C;AAED,eAAO,MAAM,qBAAqB,GAChC,gBAAgB,qBAAqB,GAAG,IAAI,EAC5C,SAAS,4BAA4B,YAAK,EAC1C,QAAQ,QAAQ,KACf,2BAkCF,CAAC;AAEF,eAAe,qBAAqB,CAAC"}

package/dist/hooks/useInteractionEffects.js

@@ -0,0 +1,35 @@
+import { useCallback } from "react";
+import { useFrame } from "@react-three/fiber";
+export const useInteractionEffects = (objectSettings, options = {}, object) => {
+    const { enabled = true, animateMaterial = true } = options;
+    const mouseMove = objectSettings?.interactions?.mouseMove;
+    const handleMouseMove = useCallback((pointer) => {
+        if (!objectSettings || !mouseMove?.enabled || !mouseMove.properties?.length || !object)
+            return;
+        mouseMove.properties.forEach(({ property, propertySettings }) => {
+            const { axis, sensitivity = 1, inverted = false, min: minVal, max: maxVal } = propertySettings || {};
+            const rawValue = axis === 'x' ? pointer.x : axis === 'y' ? pointer.y : pointer.x;
+            const t = ((inverted ? -rawValue : rawValue) * sensitivity + 1) / 2; // 0..1
+            const isMeshProp = property in object;
+            const isMaterialProp = !isMeshProp && object.material && property in object.material;
+            if (typeof minVal === 'number' && typeof maxVal === 'number') {
+                const value = minVal + t * (maxVal - minVal);
+                if (isMeshProp) {
+                    object[property] = value;
+                }
+                else if (isMaterialProp && animateMaterial) {
+                    object.material[property] = value;
+                    object.material.needsUpdate = true;
+                }
+            }
+        });
+    }, [object, objectSettings, mouseMove, animateMaterial]);
+    useFrame((state) => {
+        if (!enabled || !object || !objectSettings)
+            return;
+        if (mouseMove?.enabled)
+            handleMouseMove(state.pointer);
+    });
+    return {};
+};
+export default useInteractionEffects;

package/dist/hooks/useKey.d.ts

@@ -0,0 +1,26 @@
+type KeyHandler = (event: KeyboardEvent) => void;
+interface UseKeyOptions {
+    /** Whether the hook should be active */
+    enabled?: boolean;
+    /** Target element to attach the event listener to (defaults to window) */
+    target?: EventTarget | null;
+    /** Prevent default behavior */
+    preventDefault?: boolean;
+    /** Stop event propagation */
+    stopPropagation?: boolean;
+}
+/**
+ * Custom hook for handling keyboard events
+ * @param keyHandlers - Object mapping key names to handler functions
+ * @param options - Configuration options
+ */
+export declare const useKey: (keyHandlers: Record<string, KeyHandler>, options?: UseKeyOptions) => void;
+/**
+ * Custom hook for handling both keydown and keyup events
+ * @param keyDownHandlers - Object mapping key names to keydown handler functions
+ * @param keyUpHandlers - Object mapping key names to keyup handler functions
+ * @param options - Configuration options
+ */
+export declare const useKeyUpDown: (keyDownHandlers: Record<string, KeyHandler>, keyUpHandlers?: Record<string, KeyHandler>, options?: UseKeyOptions) => void;
+export default useKey;
+//# sourceMappingURL=useKey.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useKey.d.ts","sourceRoot":"","sources":["../../src/hooks/useKey.ts"],"names":[],"mappings":"AAEA,KAAK,UAAU,GAAG,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,CAAC;AAEjD,UAAU,aAAa;IACrB,wCAAwC;IACxC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,0EAA0E;IAC1E,MAAM,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC;IAC5B,+BAA+B;IAC/B,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,6BAA6B;IAC7B,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED;;;;GAIG;AACH,eAAO,MAAM,MAAM,GACjB,aAAa,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,EACvC,UAAS,aAAkB,SAgC5B,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,YAAY,GACvB,iBAAiB,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,EAC3C,gBAAe,MAAM,CAAC,MAAM,EAAE,UAAU,CAAM,EAC9C,UAAS,aAAkB,SAgD5B,CAAC;AAEF,eAAe,MAAM,CAAC"}

package/dist/hooks/useKey.js

@@ -0,0 +1,73 @@
+import { useEffect, useCallback } from 'react';
+/**
+ * Custom hook for handling keyboard events
+ * @param keyHandlers - Object mapping key names to handler functions
+ * @param options - Configuration options
+ */
+export const useKey = (keyHandlers, options = {}) => {
+    const { enabled = true, target = typeof window !== 'undefined' ? window : null, preventDefault = false, stopPropagation = false, } = options;
+    const handleKeyDown = useCallback((event) => {
+        if (!enabled)
+            return;
+        const handler = keyHandlers[event.key];
+        if (handler) {
+            if (preventDefault)
+                event.preventDefault();
+            if (stopPropagation)
+                event.stopPropagation();
+            handler(event);
+        }
+    }, [keyHandlers, enabled, preventDefault, stopPropagation]);
+    useEffect(() => {
+        if (!target || !enabled)
+            return;
+        target.addEventListener('keydown', handleKeyDown);
+        return () => {
+            target.removeEventListener('keydown', handleKeyDown);
+        };
+    }, [target, enabled, handleKeyDown]);
+};
+/**
+ * Custom hook for handling both keydown and keyup events
+ * @param keyDownHandlers - Object mapping key names to keydown handler functions
+ * @param keyUpHandlers - Object mapping key names to keyup handler functions
+ * @param options - Configuration options
+ */
+export const useKeyUpDown = (keyDownHandlers, keyUpHandlers = {}, options = {}) => {
+    const { enabled = true, target = typeof window !== 'undefined' ? window : null, preventDefault = false, stopPropagation = false, } = options;
+    const handleKeyDown = useCallback((event) => {
+        if (!enabled)
+            return;
+        const handler = keyDownHandlers[event.key];
+        if (handler) {
+            if (preventDefault)
+                event.preventDefault();
+            if (stopPropagation)
+                event.stopPropagation();
+            handler(event);
+        }
+    }, [keyDownHandlers, enabled, preventDefault, stopPropagation]);
+    const handleKeyUp = useCallback((event) => {
+        if (!enabled)
+            return;
+        const handler = keyUpHandlers[event.key];
+        if (handler) {
+            if (preventDefault)
+                event.preventDefault();
+            if (stopPropagation)
+                event.stopPropagation();
+            handler(event);
+        }
+    }, [keyUpHandlers, enabled, preventDefault, stopPropagation]);
+    useEffect(() => {
+        if (!target || !enabled)
+            return;
+        target.addEventListener('keydown', handleKeyDown);
+        target.addEventListener('keyup', handleKeyUp);
+        return () => {
+            target.removeEventListener('keydown', handleKeyDown);
+            target.removeEventListener('keyup', handleKeyUp);
+        };
+    }, [target, enabled, handleKeyDown, handleKeyUp]);
+};
+export default useKey;

package/dist/hooks/useLightHandlers.d.ts

@@ -0,0 +1,14 @@
+import { type MutableRefObject } from 'react';
+import type { BaseLightConfig, SpotLightConfig, PointLightConfig } from '@ntalmagor/3drize-core';
+import type { DirectionalLight, SpotLight, PointLight } from 'three';
+interface LightRefsInput {
+    directionalLightRefs: MutableRefObject<Map<string, DirectionalLight>>;
+    spotLightRefs: MutableRefObject<Map<string, SpotLight>>;
+    pointLightRefs: MutableRefObject<Map<string, PointLight>>;
+}
+export declare const useLightHandlers: (lightRefs: LightRefsInput, lightConfigs: (BaseLightConfig | SpotLightConfig | PointLightConfig)[]) => {
+    handleLightEnter: (lightName: string) => void;
+    handleLightLeave: (lightName: string) => void;
+};
+export default useLightHandlers;
+//# sourceMappingURL=useLightHandlers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useLightHandlers.d.ts","sourceRoot":"","sources":["../../src/hooks/useLightHandlers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,KAAK,gBAAgB,EAAE,MAAM,OAAO,CAAC;AAGnE,OAAO,KAAK,EAAE,eAAe,EAAE,eAAe,EAAE,gBAAgB,EAAkB,MAAM,wBAAwB,CAAC;AACjH,OAAO,KAAK,EAAE,gBAAgB,EAAE,SAAS,EAAE,UAAU,EAAgB,MAAM,OAAO,CAAC;AAInF,UAAU,cAAc;IACtB,oBAAoB,EAAE,gBAAgB,CAAC,GAAG,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC,CAAC;IACtE,aAAa,EAAE,gBAAgB,CAAC,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC;IACxD,cAAc,EAAE,gBAAgB,CAAC,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC;CAC3D;AAOD,eAAO,MAAM,gBAAgB,GAC3B,WAAW,cAAc,EACzB,cAAc,CAAC,eAAe,GAAG,eAAe,GAAG,gBAAgB,CAAC,EAAE;kCA+FxD,MAAM;kCAYN,MAAM;CAsBrB,CAAC;AAEF,eAAe,gBAAgB,CAAC"}

package/dist/hooks/useLightHandlers.js

@@ -0,0 +1,116 @@
+import { useCallback, useRef } from 'react';
+import { Color, MathUtils } from 'three';
+import { useFrame } from '@react-three/fiber';
+const getLightFromRefs = (refs, lightName) => refs.directionalLightRefs.current.get(lightName) ||
+    refs.spotLightRefs.current.get(lightName) ||
+    refs.pointLightRefs.current.get(lightName);
+export const useLightHandlers = (lightRefs, lightConfigs) => {
+    const hoveredLightRef = useRef(null);
+    const getInterpolatedValue = (baseValue, minValue, maxValue, multiplier, sensitivity = 1) => {
+        const normalizedMultiplier = (multiplier + 1) / 2;
+        const finalMultiplier = Math.max(0, Math.min(1, normalizedMultiplier * sensitivity));
+        if ((typeof minValue === 'string' && minValue.startsWith('#')) ||
+            (typeof maxValue === 'string' && maxValue.startsWith('#'))) {
+            const minColor = new Color(minValue);
+            const maxColor = new Color(maxValue);
+            const minArr = minColor.toArray();
+            const maxArr = maxColor.toArray();
+            return new Color().fromArray(minArr.map((min, i) => MathUtils.lerp(min, maxArr[i], finalMultiplier)));
+        }
+        if (Array.isArray(minValue) && Array.isArray(maxValue) && minValue.length === 3) {
+            return [
+                MathUtils.lerp(minValue[0], maxValue[0], finalMultiplier),
+                MathUtils.lerp(minValue[1], maxValue[1], finalMultiplier),
+                MathUtils.lerp(minValue[2], maxValue[2], finalMultiplier),
+            ];
+        }
+        if (typeof minValue === 'number' && typeof maxValue === 'number') {
+            return MathUtils.lerp(minValue, maxValue, finalMultiplier);
+        }
+        return baseValue;
+    };
+    const applyHandlerToLight = (light, config, handlers, pointer, handlerType) => {
+        const handler = handlers[handlerType];
+        if (!handler?.enabled || !handler.properties?.length)
+            return;
+        handler.properties.forEach((props) => {
+            const { property, propertySettings } = props;
+            const { min: minValue, max: maxValue, axis, sensitivity = 1, inverted = false } = propertySettings;
+            let multiplier = 0;
+            if (handlerType === 'onMouseMove') {
+                if (axis === 'x')
+                    multiplier = pointer.x;
+                if (axis === 'y')
+                    multiplier = pointer.y;
+                if (axis === 'both')
+                    multiplier = (pointer.x + pointer.y) / 2;
+                if (inverted)
+                    multiplier *= -1;
+            }
+            else {
+                multiplier = handlerType === 'onMouseEnter' ? 1 : -1;
+            }
+            const baseValue = config[property];
+            if (baseValue === undefined)
+                return;
+            const interpolatedValue = getInterpolatedValue(baseValue, minValue, maxValue, multiplier, sensitivity);
+            switch (property) {
+                case 'intensity':
+                    light.intensity = interpolatedValue;
+                    break;
+                case 'color':
+                    light.color = interpolatedValue instanceof Color ? interpolatedValue : new Color(interpolatedValue);
+                    break;
+                case 'position':
+                    if (Array.isArray(interpolatedValue) && interpolatedValue.length === 3)
+                        light.position.set(interpolatedValue[0], interpolatedValue[1], interpolatedValue[2]);
+                    break;
+                case 'angle':
+                    if ('angle' in light)
+                        light.angle = interpolatedValue;
+                    break;
+                case 'penumbra':
+                    if ('penumbra' in light)
+                        light.penumbra = interpolatedValue;
+                    break;
+                case 'distance':
+                    if ('distance' in light)
+                        light.distance = interpolatedValue;
+                    break;
+                case 'decay':
+                    if ('decay' in light)
+                        light.decay = interpolatedValue;
+                    break;
+            }
+        });
+    };
+    const handleLightEnter = useCallback((lightName) => {
+        hoveredLightRef.current = lightName;
+        const light = getLightFromRefs(lightRefs, lightName);
+        const config = lightConfigs.find((c) => c.name === lightName);
+        if (light && config?.handlers?.onMouseEnter?.enabled) {
+            applyHandlerToLight(light, config, config.handlers, { x: 0, y: 0 }, 'onMouseEnter');
+        }
+    }, [lightConfigs]);
+    const handleLightLeave = useCallback((lightName) => {
+        hoveredLightRef.current = null;
+        const light = getLightFromRefs(lightRefs, lightName);
+        const config = lightConfigs.find((c) => c.name === lightName);
+        if (light && config?.handlers?.onMouseLeave?.enabled) {
+            applyHandlerToLight(light, config, config.handlers, { x: 0, y: 0 }, 'onMouseLeave');
+        }
+    }, [lightConfigs]);
+    useFrame((state) => {
+        const pointer = state.pointer;
+        lightConfigs.forEach((config) => {
+            if (!config.handlers?.onMouseMove?.enabled)
+                return;
+            const light = getLightFromRefs(lightRefs, config.name);
+            if (!light)
+                return;
+            applyHandlerToLight(light, config, config.handlers, pointer, 'onMouseMove');
+        });
+    });
+    return { handleLightEnter, handleLightLeave };
+};
+export default useLightHandlers;