@ntalmagor/3drize-viewer 0.1.2

package/dist/hooks/useObjectEdges.js

@@ -0,0 +1,199 @@
+import { useEffect, useMemo, useRef } from 'react';
+import { BoxGeometry, BufferGeometry, CylinderGeometry, EdgesGeometry, Group, LineSegments, Mesh, MeshBasicMaterial, Points, PointsMaterial, Quaternion, Vector3, Float32BufferAttribute, } from 'three';
+import { useFrame } from '@react-three/fiber';
+import { collectMeshes, computeThreshold, buildSubdividedEdgeGeometry, EDGES_GROUP_KEY, animateUniforms, cacheChildrenWithMaterials } from '@ntalmagor/3drize-core';
+import { useMaterialApplication } from './useMaterialApplication';
+;
+// import { animateUniforms, cacheChildrenWithMaterials } from "~/utils/materialUtils";
+const DEFAULT_TUBE_RADIUS = 0.01;
+const DEFAULT_CUBE_SIZE = 0.02;
+// ─── Builders ────────────────────────────────────────────────────────────────
+function edgesGeoToQuadMesh(edgesGeo, thickness = 0.008) {
+    const src = edgesGeo.attributes.position;
+    const segCount = src.count / 2; // each segment = 2 vertices
+    const positions = [];
+    const uvs = [];
+    const indices = [];
+    const start = new Vector3();
+    const end = new Vector3();
+    const dir = new Vector3();
+    const up = new Vector3(0, 1, 0);
+    const right = new Vector3();
+    for (let i = 0; i < segCount; i++) {
+        start.fromBufferAttribute(src, i * 2);
+        end.fromBufferAttribute(src, i * 2 + 1);
+        dir.subVectors(end, start).normalize();
+        // Perpendicular axis — fallback to X if segment is vertical
+        right.crossVectors(dir, up).normalize();
+        if (right.lengthSq() < 0.0001) {
+            right.set(1, 0, 0);
+        }
+        const rx = right.x * thickness;
+        const ry = right.y * thickness;
+        const rz = right.z * thickness;
+        const base = i * 4;
+        // v0  start-bottom   uv(0,0)
+        positions.push(start.x - rx, start.y - ry, start.z - rz);
+        uvs.push(0, 0);
+        // v1  end-bottom     uv(1,0)
+        positions.push(end.x - rx, end.y - ry, end.z - rz);
+        uvs.push(1, 0);
+        // v2  start-top      uv(0,1)
+        positions.push(start.x + rx, start.y + ry, start.z + rz);
+        uvs.push(0, 1);
+        // v3  end-top        uv(1,1)
+        positions.push(end.x + rx, end.y + ry, end.z + rz);
+        uvs.push(1, 1);
+        indices.push(base, base + 1, base + 2);
+        indices.push(base + 1, base + 3, base + 2);
+    }
+    const geo = new BufferGeometry();
+    geo.setAttribute("position", new Float32BufferAttribute(positions, 3));
+    geo.setAttribute("uv", new Float32BufferAttribute(uvs, 2));
+    geo.setIndex(indices);
+    geo.computeVertexNormals();
+    return new Mesh(geo);
+}
+function buildLineGroup(object, localParent) {
+    const g = new Group();
+    for (const { mesh, matrixRelativeToRoot } of collectMeshes(object, localParent)) {
+        const threshold = computeThreshold(mesh.geometry);
+        const edgesGeo = new EdgesGeometry(mesh.geometry, threshold);
+        const position = new Vector3();
+        const quaternion = new Quaternion();
+        const scale = new Vector3();
+        matrixRelativeToRoot.decompose(position, quaternion, scale);
+        const quadMesh = edgesGeoToQuadMesh(edgesGeo);
+        quadMesh.position.copy(position);
+        quadMesh.quaternion.copy(quaternion);
+        quadMesh.scale.copy(scale);
+        quadMesh.renderOrder = 1;
+        g.add(quadMesh);
+    }
+    return g;
+}
+function buildSegmentMeshGroup(object, localParent, geoFn) {
+    const g = new Group();
+    for (const { mesh, matrixRelativeToRoot } of collectMeshes(object, localParent)) {
+        const threshold = computeThreshold(mesh.geometry);
+        const edgesGeo = new EdgesGeometry(mesh.geometry, threshold);
+        const posAttr = edgesGeo.attributes.position;
+        const subGroup = new Group();
+        const position = new Vector3();
+        const quaternion = new Quaternion();
+        const scale = new Vector3();
+        matrixRelativeToRoot.decompose(position, quaternion, scale);
+        subGroup.position.copy(position);
+        subGroup.quaternion.copy(quaternion);
+        subGroup.scale.copy(scale);
+        for (let i = 0; i < posAttr.count; i += 2) {
+            const start = new Vector3(posAttr.getX(i), posAttr.getY(i), posAttr.getZ(i));
+            const end = new Vector3(posAttr.getX(i + 1), posAttr.getY(i + 1), posAttr.getZ(i + 1));
+            const dir = end.clone().sub(start);
+            const length = dir.length();
+            if (length < 0.0001)
+                continue;
+            const midpoint = start.clone().add(end).multiplyScalar(0.5);
+            const segQuat = new Quaternion().setFromUnitVectors(new Vector3(0, 1, 0), dir.normalize());
+            const m = new Mesh(geoFn(length), new MeshBasicMaterial());
+            m.position.copy(midpoint);
+            m.quaternion.copy(segQuat);
+            m.renderOrder = 1;
+            subGroup.add(m);
+        }
+        g.add(subGroup);
+        edgesGeo.dispose();
+    }
+    return g;
+}
+function buildTubeGroup(object, localParent, tubeRadius) {
+    return buildSegmentMeshGroup(object, localParent, (length) => new CylinderGeometry(tubeRadius, tubeRadius, length, 4));
+}
+function buildCubeGroup(object, localParent, cubeSize) {
+    return buildSegmentMeshGroup(object, localParent, (length) => new BoxGeometry(cubeSize, length, cubeSize));
+}
+function buildParticlesGroup(object, localParent) {
+    const g = new Group();
+    const geo = buildSubdividedEdgeGeometry(object, 30, localParent);
+    const points = new Points(geo, new PointsMaterial({ size: 0.02 }));
+    points.renderOrder = 1;
+    g.add(points);
+    return g;
+}
+function buildEdgesGroup(object, edgesSettings) {
+    // Compute the inverse of the object's current local matrix so that
+    // collectMeshes results are in object-local space. Without this, the
+    // transforms include the object's own matrix and get double-applied when
+    // the edges group is added as a child of the object.
+    object.updateMatrix();
+    const localParent = object.matrix.clone().invert();
+    const tubeRadius = edgesSettings.tubeRadius ?? DEFAULT_TUBE_RADIUS;
+    const cubeSize = edgesSettings.cubeSize ?? DEFAULT_CUBE_SIZE;
+    let g;
+    switch (edgesSettings.type) {
+        case 'tube':
+            g = buildTubeGroup(object, localParent, tubeRadius);
+            break;
+        case 'cube':
+            g = buildCubeGroup(object, localParent, cubeSize);
+            break;
+        case 'particles':
+            g = buildParticlesGroup(object, localParent);
+            break;
+        default: g = buildLineGroup(object, localParent);
+    }
+    g.userData[EDGES_GROUP_KEY] = true;
+    return g;
+}
+// ─── Cleanup ─────────────────────────────────────────────────────────────────
+function disposeGroup(group) {
+    if (!group)
+        return;
+    group.traverse((child) => {
+        if (child instanceof Mesh || child instanceof LineSegments || child instanceof Points) {
+            child.geometry.dispose();
+            if (Array.isArray(child.material)) {
+                child.material.forEach((m) => m.dispose());
+            }
+            else {
+                child.material.dispose?.();
+            }
+        }
+    });
+}
+// ─── Hook ─────────────────────────────────────────────────────────────────────
+export function useObjectEdges(object, edgesSettings) {
+    const childrenWithMaterialsRef = useRef([]);
+    const edgesGroup = useMemo(() => {
+        // console.log(object)
+        if (!object || !edgesSettings.enabled)
+            return null;
+        return buildEdgesGroup(object, edgesSettings);
+        // Rebuild when geometry-affecting settings change
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [object, edgesSettings.type, edgesSettings.enabled, edgesSettings.tubeRadius, edgesSettings.cubeSize]);
+    // Attach edges to the live object so they move with it
+    useEffect(() => {
+        if (!object || !edgesGroup)
+            return;
+        object.add(edgesGroup);
+        return () => { object.remove(edgesGroup); };
+    }, [object, edgesGroup]);
+    // Dispose Three.js resources when group is rebuilt or hook unmounts
+    useEffect(() => {
+        return () => { disposeGroup(edgesGroup); };
+    }, [edgesGroup]);
+    // Cache edge meshes after the group is attached so useFrame has them on first frame
+    useEffect(() => {
+        childrenWithMaterialsRef.current = edgesGroup ? cacheChildrenWithMaterials(edgesGroup) : [];
+    }, [edgesGroup]);
+    useFrame((state, delta) => {
+        if (!edgesGroup)
+            return;
+        const time = state.clock.getElapsedTime();
+        const mouse = state.pointer;
+        animateUniforms(childrenWithMaterialsRef.current, time, mouse, state.camera.position);
+    });
+    // Apply material reactively — works for all three types since each child has .material
+    useMaterialApplication(edgesGroup, edgesSettings.materialSettings, edgesSettings.enabled);
+}

package/dist/hooks/useOrbitControls.d.ts

@@ -0,0 +1,7 @@
+import { OrbitControls as OrbitControlsImpl } from 'three-stdlib';
+/**
+ * Hook to access OrbitControls from any component within the R3F Canvas
+ * Returns the OrbitControls instance with proper typing, or null if not available
+ */
+export declare function useOrbitControls(): OrbitControlsImpl | null;
+//# sourceMappingURL=useOrbitControls.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useOrbitControls.d.ts","sourceRoot":"","sources":["../../src/hooks/useOrbitControls.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,IAAI,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAElE;;;GAGG;AACH,wBAAgB,gBAAgB,IAEX,iBAAiB,GAAG,IAAI,CAC5C"}

package/dist/hooks/useOrbitControls.js

@@ -0,0 +1,9 @@
+import { useThree } from '@react-three/fiber';
+/**
+ * Hook to access OrbitControls from any component within the R3F Canvas
+ * Returns the OrbitControls instance with proper typing, or null if not available
+ */
+export function useOrbitControls() {
+    const { controls } = useThree();
+    return controls;
+}

package/dist/hooks/useParticlePositions.d.ts

@@ -0,0 +1,19 @@
+import type { PositionShape } from '@ntalmagor/3drize-core';
+import type { Points } from 'three';
+interface UseParticlePositionsProps {
+    shapeType: string;
+    targetShape: PositionShape | undefined;
+    count: number;
+    outlines: boolean;
+    targetOutLines: boolean | undefined;
+    pointsRef: React.RefObject<Points | null>;
+}
+export declare const useParticlePositions: ({ shapeType, targetShape, count, outlines, targetOutLines, pointsRef, }: UseParticlePositionsProps) => {
+    basePositions: import("react").RefObject<Float32Array<ArrayBufferLike> | null>;
+    targetPositions: import("react").RefObject<Float32Array<ArrayBufferLike> | null>;
+    animationProgress: import("react").RefObject<number>;
+    positionsVersion: number;
+    uvs: Float32Array<ArrayBufferLike> | null;
+};
+export {};
+//# sourceMappingURL=useParticlePositions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useParticlePositions.d.ts","sourceRoot":"","sources":["../../src/hooks/useParticlePositions.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAe,MAAM,wBAAwB,CAAC;AACzE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,OAAO,CAAC;AAEpC,UAAU,yBAAyB;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,aAAa,GAAG,SAAS,CAAC;IACvC,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,OAAO,CAAC;IAClB,cAAc,EAAE,OAAO,GAAG,SAAS,CAAC;IACpC,SAAS,EAAE,KAAK,CAAC,SAAS,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;CAC3C;AAsBD,eAAO,MAAM,oBAAoB,GAAI,yEAOlC,yBAAyB;;;;;;CAoC3B,CAAC"}

package/dist/hooks/useParticlePositions.js

@@ -0,0 +1,56 @@
+import { useEffect, useRef, useState } from 'react';
+import { PositionsCreator, shapeConfig } from '@ntalmagor/3drize-core';
+function generateUVsFromPositions(positions) {
+    const count = positions.length / 3;
+    let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;
+    for (let i = 0; i < positions.length; i += 3) {
+        minX = Math.min(minX, positions[i]);
+        maxX = Math.max(maxX, positions[i]);
+        minY = Math.min(minY, positions[i + 1]);
+        maxY = Math.max(maxY, positions[i + 1]);
+    }
+    const rangeX = maxX - minX || 1;
+    const rangeY = maxY - minY || 1;
+    const uvs = new Float32Array(count * 2);
+    for (let i = 0; i < positions.length; i += 3) {
+        const idx = (i / 3) * 2;
+        uvs[idx] = (positions[i] - minX) / rangeX;
+        uvs[idx + 1] = (positions[i + 1] - minY) / rangeY;
+    }
+    return uvs;
+}
+export const useParticlePositions = ({ shapeType, targetShape, count, outlines, targetOutLines, pointsRef, }) => {
+    const basePositions = useRef(null);
+    const targetPositions = useRef(null);
+    const animationProgress = useRef(0);
+    const uvs = useRef(null);
+    const [positionsVersion, setPositionsVersion] = useState(0);
+    useEffect(() => {
+        const shapeParams = {
+            length: count,
+            name: shapeType,
+            outlines,
+            ...(shapeConfig[shapeType] || {}),
+        };
+        const newPositions = PositionsCreator.generatePositions(shapeParams);
+        basePositions.current = newPositions;
+        uvs.current = generateUVsFromPositions(newPositions);
+        setPositionsVersion(v => v + 1);
+    }, [shapeType, count, outlines]);
+    useEffect(() => {
+        if (!targetShape || targetShape === 'none') {
+            targetPositions.current = null;
+        }
+        else {
+            const shapeParams = {
+                length: count,
+                name: targetShape,
+                outlines: targetOutLines,
+                ...(shapeConfig[targetShape] || {}),
+            };
+            targetPositions.current = PositionsCreator.generatePositions(shapeParams);
+            animationProgress.current = 0;
+        }
+    }, [targetShape, count, targetOutLines]);
+    return { basePositions, targetPositions, animationProgress, positionsVersion, uvs: uvs.current };
+};

package/dist/hooks/useParticlesColors.d.ts

@@ -0,0 +1,14 @@
+import { Color } from 'three';
+interface UseParticlesColorsProps {
+    color: string;
+    targetColor?: string;
+}
+export declare const useParticlesColors: ({ color, targetColor }: UseParticlesColorsProps) => {
+    baseColorRef: import("react").RefObject<Color>;
+    targetColorRef: import("react").RefObject<Color>;
+    colorAnimationProgress: import("react").RefObject<number>;
+    currentColorRef: import("react").RefObject<Color>;
+    handleColorsAnimation: (materialRef: React.RefObject<any>, delta: number, speed: number) => void;
+};
+export {};
+//# sourceMappingURL=useParticlesColors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useParticlesColors.d.ts","sourceRoot":"","sources":["../../src/hooks/useParticlesColors.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC;AAE9B,UAAU,uBAAuB;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,eAAO,MAAM,kBAAkB,GAAI,wBAAwB,uBAAuB;;;;;yCAgBhE,KAAK,CAAC,SAAS,CAAC,GAAG,CAAC,SAAS,MAAM,SAAS,MAAM;CAcnE,CAAC"}

package/dist/hooks/useParticlesColors.js

@@ -0,0 +1,27 @@
+import { useRef, useEffect, useCallback } from 'react';
+import { Color } from 'three';
+export const useParticlesColors = ({ color, targetColor }) => {
+    const baseColorRef = useRef(new Color(color));
+    const colorAnimationProgress = useRef(0);
+    const currentColorRef = useRef(new Color());
+    const targetColorRef = useRef(targetColor ? new Color(targetColor) : new Color(color));
+    useEffect(() => { baseColorRef.current.set(color); }, [color]);
+    useEffect(() => {
+        if (targetColor) {
+            colorAnimationProgress.current = 0;
+            targetColorRef.current.set(targetColor);
+        }
+    }, [targetColor]);
+    const handleColorsAnimation = useCallback((materialRef, delta, speed) => {
+        if (!materialRef.current)
+            return;
+        if (!targetColor || targetColor === color) {
+            colorAnimationProgress.current = 0;
+            return;
+        }
+        colorAnimationProgress.current = Math.min(colorAnimationProgress.current + delta * speed, 1);
+        currentColorRef.current.lerpColors(baseColorRef.current, targetColorRef.current, colorAnimationProgress.current);
+        materialRef.current.uniforms.uColor.value = currentColorRef.current;
+    }, [color, targetColor]);
+    return { baseColorRef, targetColorRef, colorAnimationProgress, currentColorRef, handleColorsAnimation };
+};

package/dist/hooks/useParticlesTextures.d.ts

@@ -0,0 +1,10 @@
+import type { Texture } from 'three';
+export declare const useParticlesTextures: () => {
+    currentTexture: import("react").RefObject<Texture | null>;
+    prevTexture: import("react").RefObject<Texture | null>;
+    loadTexture: (url: string) => Promise<Texture | null>;
+    clearPreviousTexture: () => void;
+    textureProgress: import("react").RefObject<number>;
+    handleTextureAnimation: (materialRef: React.RefObject<any>, delta: number, speed: number) => void;
+};
+//# sourceMappingURL=useParticlesTextures.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useParticlesTextures.d.ts","sourceRoot":"","sources":["../../src/hooks/useParticlesTextures.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAGrC,eAAO,MAAM,oBAAoB;;;uBAKC,MAAM,KAAG,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC;;;0CAUhD,KAAK,CAAC,SAAS,CAAC,GAAG,CAAC,SAAS,MAAM,SAAS,MAAM;CASnE,CAAC"}

package/dist/hooks/useParticlesTextures.js

@@ -0,0 +1,23 @@
+import { useRef, useCallback } from 'react';
+import texturesManager from '../../../core/src/services/TexturesManager';
+export const useParticlesTextures = () => {
+    const currentTexture = useRef(null);
+    const prevTexture = useRef(null);
+    const textureProgress = useRef(0);
+    const loadTexture = async (url) => {
+        if (currentTexture.current)
+            prevTexture.current = currentTexture.current;
+        const tex = await texturesManager.loadTexture(`image-${url}`, url, 'images');
+        if (tex)
+            currentTexture.current = tex;
+        return tex;
+    };
+    const clearPreviousTexture = () => { prevTexture.current = null; };
+    const handleTextureAnimation = useCallback((materialRef, delta, speed) => {
+        if (!materialRef.current || !currentTexture.current)
+            return;
+        textureProgress.current = Math.min(textureProgress.current + delta * speed, 1);
+        materialRef.current.uniforms.uMorphProgress.value = textureProgress.current;
+    }, []);
+    return { currentTexture, prevTexture, loadTexture, clearPreviousTexture, textureProgress, handleTextureAnimation };
+};

package/dist/hooks/usePathAnimation.d.ts

@@ -0,0 +1,26 @@
+import * as THREE from 'three';
+import type { Object3D } from 'three';
+import type { Vector3Array } from '@ntalmagor/3drize-core';
+export interface PathAnimationOptions {
+    ease?: string;
+    loop?: boolean;
+    yoyo?: boolean;
+    speed?: number;
+    faceDirection?: boolean;
+    applyRotation?: boolean;
+    offset?: Vector3Array;
+    keepOriginalTransform?: boolean;
+    onComplete?: () => void;
+}
+export declare const usePathAnimation: () => {
+    startPathAnimation: (pathId: string, duration: number, options?: PathAnimationOptions) => boolean;
+    stopPathAnimation: () => void;
+    updatePathAnimation: (delta: number, object: Object3D) => boolean;
+    isAnimating: () => boolean;
+    getPositionAt: (t: number) => {
+        position: THREE.Vector3;
+        direction: THREE.Vector3;
+    };
+};
+export default usePathAnimation;
+//# sourceMappingURL=usePathAnimation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"usePathAnimation.d.ts","sourceRoot":"","sources":["../../src/hooks/usePathAnimation.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AACtC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAI3D,MAAM,WAAW,oBAAoB;IACnC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,MAAM,CAAC,EAAE,YAAY,CAAC;IACtB,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,UAAU,CAAC,EAAE,MAAM,IAAI,CAAC;CACzB;AAED,eAAO,MAAM,gBAAgB;iCAoBjB,MAAM,YACJ,MAAM,YACP,oBAAoB,KAC5B,OAAO;;iCA0DsC,MAAM,UAAU,QAAQ,KAAG,OAAO;;uBAtB5C,MAAM,KAAG;QAAE,QAAQ,EAAE,KAAK,CAAC,OAAO,CAAC;QAAC,SAAS,EAAE,KAAK,CAAC,OAAO,CAAA;KAAE;CA6ErG,CAAC;AAEF,eAAe,gBAAgB,CAAC"}

package/dist/hooks/usePathAnimation.js

@@ -0,0 +1,120 @@
+import { useRef, useCallback, useEffect } from 'react';
+import * as THREE from 'three';
+import { smoothPathCorners, createPathSpline, applyEasing, resolveEasing } from '@ntalmagor/3drize-core';
+import AnimationsManager from '../../../core/src/services/AnimationsManager';
+export const usePathAnimation = () => {
+    const pointsRef = useRef([]);
+    const progressRef = useRef(0);
+    const durationRef = useRef(1);
+    const splineRef = useRef(null);
+    const activeRef = useRef(false);
+    const directionRef = useRef(1);
+    const easeRef = useRef(null);
+    const loopRef = useRef(false);
+    const yoyoRef = useRef(false);
+    const speedRef = useRef(1);
+    const faceRef = useRef(true);
+    const applyRotRef = useRef(true);
+    const offsetRef = useRef(null);
+    const onCompleteRef = useRef(null);
+    const targetQuatRef = useRef(new THREE.Quaternion());
+    useEffect(() => () => { splineRef.current = null; }, []);
+    const startPathAnimation = useCallback((pathId, duration, options = {}) => {
+        const cfg = AnimationsManager.getPath(pathId);
+        if (!cfg || cfg.points.length < 2)
+            return false;
+        const smooth = cfg.smoothCorners ?? 0;
+        const pts = smooth > 0 && cfg.points.length >= 3
+            ? smoothPathCorners(cfg.points, smooth)
+            : cfg.points;
+        pointsRef.current = pts;
+        progressRef.current = 0;
+        durationRef.current = duration;
+        activeRef.current = true;
+        directionRef.current = 1;
+        easeRef.current = options.ease ?? null;
+        loopRef.current = options.loop ?? false;
+        yoyoRef.current = options.yoyo ?? false;
+        speedRef.current = options.speed ?? 1;
+        faceRef.current = options.faceDirection ?? true;
+        applyRotRef.current = options.applyRotation ?? cfg.applyRotation ?? true;
+        offsetRef.current = options.offset ?? cfg.offset ?? null;
+        onCompleteRef.current = options.onComplete ?? null;
+        const curve = cfg.curve ?? 1;
+        splineRef.current = createPathSpline(pts, curve);
+        return true;
+    }, []);
+    const stopPathAnimation = useCallback(() => {
+        activeRef.current = false;
+        splineRef.current = null;
+        progressRef.current = 0;
+        directionRef.current = 1;
+    }, []);
+    const getPositionAt = useCallback((t) => {
+        const pts = pointsRef.current;
+        const spline = splineRef.current;
+        const clamped = Math.max(0, Math.min(1, t));
+        if (spline) {
+            return {
+                position: spline.getPointAt(clamped),
+                direction: spline.getTangentAt(clamped).normalize(),
+            };
+        }
+        const segs = pts.length - 1;
+        const idx = Math.min(Math.floor(clamped * segs), segs - 1);
+        const sp = clamped * segs - idx;
+        const a = pts[idx], b = pts[idx + 1];
+        return {
+            position: new THREE.Vector3(a[0] + (b[0] - a[0]) * sp, a[1] + (b[1] - a[1]) * sp, a[2] + (b[2] - a[2]) * sp),
+            direction: new THREE.Vector3(b[0] - a[0], b[1] - a[1], b[2] - a[2]).normalize(),
+        };
+    }, []);
+    const updatePathAnimation = useCallback((delta, object) => {
+        if (!activeRef.current)
+            return false;
+        progressRef.current += (delta / durationRef.current) * speedRef.current * directionRef.current;
+        let p = progressRef.current;
+        if (p >= 1 || p <= 0) {
+            if (yoyoRef.current) {
+                directionRef.current *= -1;
+                p = Math.max(0, Math.min(1, p));
+                progressRef.current = p;
+                if (!loopRef.current && directionRef.current === 1 && p <= 0) {
+                    activeRef.current = false;
+                    onCompleteRef.current?.();
+                    return false;
+                }
+            }
+            else if (loopRef.current) {
+                progressRef.current = ((p % 1) + 1) % 1;
+                p = progressRef.current;
+            }
+            else {
+                progressRef.current = Math.max(0, Math.min(1, p));
+                activeRef.current = false;
+                onCompleteRef.current?.();
+                return false;
+            }
+        }
+        const eased = easeRef.current ? applyEasing(resolveEasing(easeRef.current), p) : p;
+        const { position, direction } = getPositionAt(eased);
+        if (offsetRef.current) {
+            position.x += offsetRef.current[0];
+            position.y += offsetRef.current[1];
+            position.z += offsetRef.current[2];
+        }
+        object.position.copy(position);
+        if (applyRotRef.current && faceRef.current && direction.lengthSq() > 0.0001) {
+            const up = new THREE.Vector3(0, 1, 0);
+            const mat = new THREE.Matrix4();
+            mat.lookAt(position, new THREE.Vector3().copy(position).add(direction), up);
+            targetQuatRef.current.setFromRotationMatrix(mat);
+            targetQuatRef.current.multiply(new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), Math.PI));
+            object.quaternion.slerp(targetQuatRef.current, 1);
+        }
+        return true;
+    }, [getPositionAt]);
+    const isAnimating = useCallback(() => activeRef.current, []);
+    return { startPathAnimation, stopPathAnimation, updatePathAnimation, isAnimating, getPositionAt };
+};
+export default usePathAnimation;

package/dist/hooks/useSkyAnimation.d.ts

@@ -0,0 +1,14 @@
+import type { SkySettings } from '@ntalmagor/3drize-core';
+interface SkyAnimValues {
+    turbidity: number;
+    rayleigh: number;
+    mieCoefficient: number;
+    mieDirectionalG: number;
+    elevation: number;
+    azimuth: number;
+}
+export declare function useSkyAnimation(): {
+    animateSkyTransition: (currentValues: SkyAnimValues, targetSettings: SkySettings, onUpdate: (s: SkySettings) => void, onComplete: (s: SkySettings) => void, duration?: number) => void;
+};
+export {};
+//# sourceMappingURL=useSkyAnimation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useSkyAnimation.d.ts","sourceRoot":"","sources":["../../src/hooks/useSkyAnimation.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAE1D,UAAU,aAAa;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,eAAe,EAAE,MAAM,CAAC;IACxB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;CACjB;AAYD,wBAAgB,eAAe;0CA6BZ,aAAa,kBACZ,WAAW,YACjB,CAAC,CAAC,EAAE,WAAW,KAAK,IAAI,cACtB,CAAC,CAAC,EAAE,WAAW,KAAK,IAAI;EAsBvC"}

package/dist/hooks/useSkyAnimation.js

@@ -0,0 +1,46 @@
+import { useRef, useCallback } from 'react';
+import { useFrame } from '@react-three/fiber';
+export function useSkyAnimation() {
+    const animRef = useRef(null);
+    useFrame((_, delta) => {
+        if (!animRef.current)
+            return;
+        const anim = animRef.current;
+        anim.elapsed += delta;
+        const t = Math.min(1, anim.elapsed / anim.duration);
+        const st = t * t * (3 - 2 * t); // smoothstep
+        const lerp = (a, b) => a + (b - a) * st;
+        const vals = {
+            turbidity: lerp(anim.from.turbidity, anim.to.turbidity),
+            rayleigh: lerp(anim.from.rayleigh, anim.to.rayleigh),
+            mieCoefficient: lerp(anim.from.mieCoefficient, anim.to.mieCoefficient),
+            mieDirectionalG: lerp(anim.from.mieDirectionalG, anim.to.mieDirectionalG),
+            elevation: lerp(anim.from.elevation, anim.to.elevation),
+            azimuth: lerp(anim.from.azimuth, anim.to.azimuth),
+        };
+        anim.onUpdate({ ...anim.targetSettings, ...vals });
+        if (t >= 1) {
+            anim.onComplete({ ...anim.targetSettings, ...anim.to });
+            animRef.current = null;
+        }
+    });
+    const animateSkyTransition = useCallback((currentValues, targetSettings, onUpdate, onComplete, duration = 3) => {
+        animRef.current = {
+            from: { ...currentValues },
+            to: {
+                turbidity: targetSettings.turbidity,
+                rayleigh: targetSettings.rayleigh,
+                mieCoefficient: targetSettings.mieCoefficient,
+                mieDirectionalG: targetSettings.mieDirectionalG,
+                elevation: targetSettings.elevation,
+                azimuth: targetSettings.azimuth,
+            },
+            duration,
+            elapsed: 0,
+            targetSettings,
+            onUpdate,
+            onComplete,
+        };
+    }, []);
+    return { animateSkyTransition };
+}

package/dist/hooks/useSkySystem.d.ts

@@ -0,0 +1,26 @@
+import * as THREE from 'three';
+import type { SkyTimeState, TimeOfDayLabel } from '../../../core/src/services/SkySystemManager';
+import type { TimeSettings } from '../../../core/src/types/scene3d';
+export type { SkyTimeState, TimeOfDayLabel };
+export interface UseSkySystemOptions {
+    timeSettings: TimeSettings;
+    onTimeUpdate?: (state: SkyTimeState) => void;
+    onTimeOfDayChange?: (timeOfDay: string, elapsedTime: number) => void;
+    enabled?: boolean;
+}
+export interface UseSkySystemReturn {
+    timeInHours: number;
+    normalizedTime: number;
+    isDaytime: boolean;
+    timeOfDay: string;
+    sunElevation: number;
+    sunAzimuth: number;
+    sunDirection: THREE.Vector3;
+    setTime: (hours: number, minutes?: number) => void;
+    getTime: () => Date;
+    getTimeOfDay: () => string;
+    getSunDirection: () => THREE.Vector3;
+}
+export declare function useSkySystem(options: UseSkySystemOptions): UseSkySystemReturn;
+export default useSkySystem;
+//# sourceMappingURL=useSkySystem.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useSkySystem.d.ts","sourceRoot":"","sources":["../../src/hooks/useSkySystem.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAG/B,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,6CAA6C,CAAC;AAChG,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAEpE,YAAY,EAAE,YAAY,EAAE,cAAc,EAAE,CAAC;AAE7C,MAAM,WAAW,mBAAmB;IAClC,YAAY,EAAE,YAAY,CAAC;IAC3B,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,CAAC;IAC7C,iBAAiB,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,KAAK,IAAI,CAAC;IACrE,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,kBAAkB;IACjC,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,OAAO,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,KAAK,CAAC,OAAO,CAAC;IAC5B,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IACnD,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,YAAY,EAAE,MAAM,MAAM,CAAC;IAC3B,eAAe,EAAE,MAAM,KAAK,CAAC,OAAO,CAAC;CACtC;AAED,wBAAgB,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,kBAAkB,CA+D7E;AAED,eAAe,YAAY,CAAC"}