@3driseai/3drise-viewer 0.1.1

package/dist/hooks/useSequenceAnimation.js

@@ -0,0 +1,260 @@
+import { useRef } from 'react';
+import { useFrame } from '@react-three/fiber';
+import { AnimationsManager, findById } from '@3driseai/3drise-core';
+import { useAnimationEvents } from './useAnimationEvents.js';
+import { usePathAnimation } from './usePathAnimation.js';
+import { snapshotMaterialValues, interpolateMaterialProps } from '../utils/materialUtils.js';
+const DEBUG_SEQUENCE_ANIMATION = true;
+const debugLog = (...args) => {
+    if (DEBUG_SEQUENCE_ANIMATION) {
+        console.log('[useSequenceAnimation]', ...args);
+    }
+};
+// ─────────────────────────────────────────────────────────────────────────────
+// Helpers
+// ─────────────────────────────────────────────────────────────────────────────
+const TRANSFORM_KEYS = new Set(['position', 'rotation', 'scale', 'visible']);
+function lerp(a, b, t) {
+    return a + (b - a) * t;
+}
+function lerpVec3(a, b, t) {
+    return [lerp(a[0], b[0], t), lerp(a[1], b[1], t), lerp(a[2], b[2], t)];
+}
+/** Get material-related properties from a transition properties record */
+function extractMaterialProps(props) {
+    if (!props)
+        return {};
+    return Object.fromEntries(Object.entries(props).filter(([k]) => !TRANSFORM_KEYS.has(k)));
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Hook
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * useSequenceAnimation
+ *
+ * Subscribes to AnimationsManager step events and, for each frame while a step
+ * is active, interpolates both transform AND material properties on the given
+ * object. Path-based transitions are delegated to usePathAnimation.
+ *
+ * Designed to be called inside useObjectAnimation so that AnimatedObject stays
+ * a thin group wrapper.
+ */
+export const useSequenceAnimation = (objectId, objectRef) => {
+    const { startPathAnimation, updatePathAnimation, stopPathAnimation, isAnimating: isPathAnimating } = usePathAnimation();
+    const resolveObject = () => {
+        const resolved = objectRef ?? (objectId ? findById(objectId) : null);
+        // console.log('Resolved object for sequence animation', {
+        //   objectId,
+        //   hasRefArg: !!objectRef,
+        //   resolved: resolved ? { name: resolved.name, id: resolved.userData?.id } : null,
+        // });
+        return resolved;
+    };
+    // Active step state. Null = no sequence step currently animating.
+    const stepRef = useRef(null);
+    // Progress 0-1; flips to 1 when done so useFrame short-circuits
+    const progressRef = useRef(1);
+    const updateProgressRef = (p) => {
+        progressRef.current = p;
+        // console.log('Progress update', { objectId, progress: p });
+    };
+    const updateStepRef = (state) => {
+        stepRef.current = state;
+    };
+    // ── Event listener ──────────────────────────────────────────────────────────
+    useAnimationEvents({
+        onStepStart: (event) => {
+            if (!objectId || !event.step?.transitions) {
+                // debugLog('stepStart ignored: missing objectId or transitions', {
+                //   objectId,
+                //   hasTransitions: !!event.step?.transitions,
+                //   sequenceId: event.sequenceId,
+                //   stepIndex: event.stepIndex,
+                // });
+                return;
+            }
+            // debugLog('stepStart received', {
+            //   objectId,
+            //   sequenceId: event.sequenceId,
+            //   stepIndex: event.stepIndex,
+            //   transitionStates: event.step.transitions.map(t => t.state),
+            //   resolvedObject: resolvedObject ? {
+            //     name: resolvedObject.name,
+            //     id: resolvedObject.userData?.id,
+            //   } : null,
+            // });
+            // Find the transition targeting this object
+            const transitionIndex = event.step.transitions.findIndex(t => t.state === objectId);
+            if (transitionIndex === -1) {
+                // debugLog('no matching transition for objectId', {
+                //   objectId,
+                //   availableStates: event.step.transitions.map(t => t.state),
+                // });
+                return;
+            }
+            console.log('TRANSTITION START', objectId);
+            const resolvedObject = resolveObject();
+            console.log(objectId, resolvedObject?.name);
+            const transition = event.step.transitions[transitionIndex];
+            const stagger = event.step.stagger || 0;
+            const staggerOffsetMs = transitionIndex * stagger * 1000;
+            const d = event.step.duration || 1;
+            const ease = event.step.ease || 'linear';
+            const { properties, pathId = null } = transition;
+            console.log('Starting sequence step', resolvedObject?.name, properties);
+            // debugLog('matched transition', {
+            //   objectId,
+            //   pathId,
+            //   duration: d,
+            //   ease,
+            //   fromKeys: Object.keys(properties.from || {}),
+            //   toKeys: Object.keys(properties.to || {}),
+            // });
+            // Visibility shortcut
+            if (properties.to?.visible === false) {
+                if (resolvedObject)
+                    resolvedObject.visible = false;
+                // updateStepRef(null);
+                updateProgressRef(1);
+                return;
+            }
+            else {
+                if (resolvedObject)
+                    resolvedObject.visible = true;
+            }
+            // if (resolvedObject) resolvedObject.visible = true;
+            // Snapshot current object transform as defaults
+            const cur = resolvedObject;
+            const curPos = cur
+                ? [cur.position.x, cur.position.y, cur.position.z]
+                : [0, 0, 0];
+            const curRot = cur
+                ? [cur.rotation.x, cur.rotation.y, cur.rotation.z]
+                : [0, 0, 0];
+            const curSca = cur
+                ? [cur.scale.x, cur.scale.y, cur.scale.z]
+                : [1, 1, 1];
+            const fp = properties.from;
+            const tp = properties.to;
+            // Build material from/to — snapshot live values for any key missing a `from`
+            // so interpolation always has a defined baseline instead of snapping.
+            const materialToProps = extractMaterialProps(tp);
+            const materialFromExplicit = extractMaterialProps(fp);
+            const missingFromKeys = Object.keys(materialToProps).filter(k => !(k in materialFromExplicit));
+            const snapshotted = (resolvedObject && missingFromKeys.length > 0)
+                ? snapshotMaterialValues(resolvedObject, missingFromKeys)
+                : {};
+            const materialFrom = { ...materialFromExplicit };
+            // debugLog('material from/to', {
+            //   objectId,
+            //   materialFromExplicit,
+            //   snapshotted,
+            //   materialFrom,
+            //   materialToProps,
+            // });
+            updateStepRef({
+                startTime: performance.now() + staggerOffsetMs,
+                duration: d,
+                ease,
+                fromPosition: (fp?.position ?? curPos),
+                toPosition: (tp?.position ?? curPos),
+                fromRotation: (fp?.rotation ?? curRot),
+                toRotation: (tp?.rotation ?? curRot),
+                fromScale: (fp?.scale ?? curSca),
+                toScale: (tp?.scale ?? curSca),
+                materialFrom,
+                materialTo: materialToProps,
+                visibilityOverride: null,
+                pathId,
+            });
+            // console.log(stepRef.current)
+            updateProgressRef(0);
+            if (pathId) {
+                debugLog('starting path animation', { objectId, pathId, duration: d, ease });
+                startPathAnimation(pathId, d, { ease });
+            }
+            else {
+                stopPathAnimation();
+            }
+        },
+        onStepEnd: (event) => {
+            // Only clear state if this step end targets this object
+            if (!objectId || !event.step?.transitions)
+                return;
+            const isForThisObject = event.step.transitions.some(t => t.state === objectId);
+            if (!isForThisObject)
+                return;
+            // debugLog('stepEnd received', {
+            //   objectId,
+            //   sequenceId: event.sequenceId,
+            //   stepIndex: event.stepIndex,
+            // });
+            // Let useFrame finish the last frame at p=1 naturally; just clear step
+            // after a microtask so the final interpolated position is applied.
+            // Promise.resolve().then(() => {
+            //   updateStepRef(null);
+            //   updateProgressRef(1);
+            // });
+        },
+        onSequenceEnd: (event) => {
+            // Clear any lingering step state when the sequence ends, which is a good
+            // safety measure in case of any timing issues with step end events.
+            if (!objectId)
+                return;
+            const isForThisObject = event.sequence.steps.some(s => s.transitions.some(t => t.state === objectId));
+            if (!isForThisObject)
+                return;
+            debugLog('sequenceEnd received', { objectId, sequenceId: event.sequenceId });
+            updateStepRef(null);
+            updateProgressRef(1);
+        }
+    });
+    // ── Per-frame interpolation ─────────────────────────────────────────────────
+    useFrame((_state, delta) => {
+        const resolvedObject = resolveObject();
+        // Only skip if truly finished (p>=1). During stagger wait, p=0 and we still need to apply fromPosition.
+        // console.log(stepRef.current)
+        if (!stepRef.current || !resolvedObject)
+            return;
+        const step = stepRef.current;
+        // Time-based progress drives property interpolation regardless of transform mode.
+        const p = AnimationsManager.getProgressFromTime(step.startTime, step.duration, step.ease);
+        // console.log(p)
+        // updateProgressRef(p);
+        // Path-based: delegate to usePathAnimation
+        if (step.pathId) {
+            const still = updatePathAnimation(delta, resolvedObject);
+            if (!still) {
+                updateProgressRef(1);
+                updateStepRef(null);
+            }
+            // Keep scale interpolation active while path controls position/rotation.
+            const sca = lerpVec3(step.fromScale, step.toScale, p);
+            resolvedObject.scale.set(...sca);
+        }
+        else {
+            // — Transform —
+            const pos = lerpVec3(step.fromPosition, step.toPosition, p);
+            const rot = lerpVec3(step.fromRotation, step.toRotation, p);
+            const sca = lerpVec3(step.fromScale, step.toScale, p);
+            resolvedObject.position.set(...pos);
+            resolvedObject.rotation.set(...rot);
+            resolvedObject.scale.set(...sca);
+        }
+        if (p === 0 || p >= 0.99) {
+            // debugLog('frame progress', {
+            //   objectId,
+            //   progress: p,
+            //   materialKeys: Object.keys(step.materialTo),
+            //   pathId: step.pathId,
+            // });
+        }
+        // — Material properties —
+        interpolateMaterialProps(resolvedObject, step.materialFrom, step.materialTo, p);
+        if (p >= 1) {
+            updateProgressRef(1);
+            // updateStepRef(null);
+        }
+    });
+};
+export default useSequenceAnimation;

package/dist/hooks/useShadowApplication.d.ts

@@ -0,0 +1,3 @@
+import { Object3D } from "three";
+export declare const useShadowApplication: (obj: Object3D | null | undefined, castShadow: boolean | undefined, receiveShadow: boolean | undefined, triggerKey?: unknown) => void;
+//# sourceMappingURL=useShadowApplication.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useShadowApplication.d.ts","sourceRoot":"","sources":["../../src/hooks/useShadowApplication.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAEjC,eAAO,MAAM,oBAAoB,GAAI,KAAK,QAAQ,GAAG,IAAI,GAAG,SAAS,EAAE,YAAY,OAAO,GAAG,SAAS,EAAE,eAAe,OAAO,GAAG,SAAS,EAAE,aAAa,OAAO,KAAG,IAalK,CAAC"}

package/dist/hooks/useShadowApplication.js

@@ -0,0 +1,31 @@
+// =============================================================================
+// useShadowApplication — applies castShadow / receiveShadow to a subtree
+// =============================================================================
+//
+// Traverses the wrapper Object3D and sets `castShadow` / `receiveShadow` on
+// every mesh descendant. Re-runs when the wrapper ref, castShadow, or
+// receiveShadow value changes.
+//
+// Note on lazy-loaded models: GLTF children mount asynchronously after the
+// wrapper ref is bound. Since `obj` (meshRef.current) is the same reference
+// before and after load, the effect won't re-run on its own when those
+// children appear. Callers can pass `triggerKey` (e.g. a mount-completion
+// counter from the model loader) to force re-application when async meshes
+// arrive.
+//
+import { useEffect } from 'react';
+import { traverseSkippingEdgesAndEffects } from '@3driseai/3drise-core';
+export const useShadowApplication = (obj, castShadow, receiveShadow, triggerKey) => {
+    useEffect(() => {
+        if (!obj)
+            return;
+        const cast = castShadow ?? false;
+        const receive = receiveShadow ?? false;
+        traverseSkippingEdgesAndEffects(obj, true, (child) => {
+            if (child.isMesh) {
+                child.castShadow = cast;
+                child.receiveShadow = receive;
+            }
+        });
+    }, [obj, castShadow, receiveShadow, triggerKey]);
+};

package/dist/hooks/useShapeGeometry.d.ts

@@ -0,0 +1,8 @@
+import type { ShapeName, ShapeOptions } from '../utils//shapes';
+import { BufferGeometry } from "three";
+/**
+ * Build (and memoize) a normalized geometry for a registered shape.
+ * The previous geometry is disposed whenever inputs change or on unmount.
+ */
+export declare function useShapeGeometry(shape: ShapeName, options: ShapeOptions): BufferGeometry;
+//# sourceMappingURL=useShapeGeometry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useShapeGeometry.d.ts","sourceRoot":"","sources":["../../src/hooks/useShapeGeometry.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAChE,OAAO,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC;AAEvC;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,YAAY,GAAG,cAAc,CAKxF"}

package/dist/hooks/useShapeGeometry.js

@@ -0,0 +1,12 @@
+import { useEffect, useMemo } from 'react';
+import { shapeGenerators } from '../utils//shapes.js';
+/**
+ * Build (and memoize) a normalized geometry for a registered shape.
+ * The previous geometry is disposed whenever inputs change or on unmount.
+ */
+export function useShapeGeometry(shape, options) {
+    // const {  curveSegments, subdivisions, points, outer, inner, bevelThickness, bevelSize, bevelSegments, sides } = options;
+    const geometry = useMemo(() => shapeGenerators[shape](options), [shape, options]);
+    useEffect(() => () => geometry.dispose(), [geometry]);
+    return geometry;
+}

package/dist/hooks/useSkyAnimation.d.ts

@@ -0,0 +1,13 @@
+import type { SkySettings } from "@3driseai/3drise-core";
+export interface SkyAnimValues {
+    turbidity?: number;
+    rayleigh?: number;
+    mieCoefficient?: number;
+    mieDirectionalG?: number;
+    elevation?: number;
+    azimuth?: number;
+}
+export declare function useSkyAnimation(): {
+    animateSkyTransition: (from: SkyAnimValues, to: SkyAnimValues, onUpdate: (s: Partial<SkySettings>) => void, onComplete: (s: SkyAnimValues) => void, duration?: number) => void;
+};
+//# 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,uBAAuB,CAAC;AACzD,MAAM,WAAW,aAAa;IAC1B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;CACpB;AAMD,wBAAgB,eAAe,IAAI;IAC3B,oBAAoB,EAAE,CAAC,IAAI,EAAE,aAAa,EAAE,EAAE,EAAE,aAAa,EAAE,QAAQ,EAAE,CAAC,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,KAAK,IAAI,EAAE,UAAU,EAAE,CAAC,CAAC,EAAE,aAAa,KAAK,IAAI,EAAE,QAAQ,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;CAClL,CA8BJ"}

package/dist/hooks/useSkyAnimation.js

@@ -0,0 +1,36 @@
+import { useRef, useCallback } from 'react';
+import { useFrame } from '@react-three/fiber';
+const SKY_NUMERIC_KEYS = [
+    'turbidity', 'rayleigh', 'mieCoefficient', 'mieDirectionalG', 'elevation', 'azimuth',
+];
+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;
+        // Only interpolate keys that are present in `to` — avoids NaN on undefined
+        const update = {};
+        for (const key of SKY_NUMERIC_KEYS) {
+            const toVal = anim.to[key];
+            if (toVal === undefined)
+                continue;
+            const fromVal = anim.from[key];
+            update[key] = fromVal !== undefined ? lerp(fromVal, toVal) : toVal;
+        }
+        anim.onUpdate(update);
+        if (t >= 1) {
+            anim.onComplete(anim.to);
+            animRef.current = null;
+        }
+    });
+    const animateSkyTransition = useCallback((from, to, onUpdate, onComplete, duration = 3) => {
+        console.log('Initiating sky animation', { from, to, duration });
+        animRef.current = { from, to, duration, elapsed: 0, onUpdate, onComplete };
+    }, []);
+    return { animateSkyTransition };
+}

package/dist/hooks/useSkySystem.d.ts

@@ -0,0 +1,25 @@
+import type * as THREE from "three";
+import type { SkyTimeState, TimeOfDayLabel, TimeSettings } from '@3driseai/3drise-core';
+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":"AAAA,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAC;AAIpC,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AACxF,YAAY,EAAE,YAAY,EAAE,cAAc,EAAE,CAAC;AAE7C,MAAM,WAAW,mBAAmB;IAChC,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;CACrB;AAED,MAAM,WAAW,kBAAkB;IAC/B,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;CACxC;AAED,wBAAgB,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,kBAAkB,CAsD7E;AACD,eAAe,YAAY,CAAC"}

package/dist/hooks/useSkySystem.js

@@ -0,0 +1,59 @@
+import { useRef, useCallback, useEffect, useLayoutEffect } from 'react';
+import { useFrame } from '@react-three/fiber';
+import { skySystemManager } from '@3driseai/3drise-core';
+export function useSkySystem(options) {
+    const { timeSettings, onTimeUpdate, onTimeOfDayChange, enabled = true } = options;
+    const previousTimeOfDayRef = useRef(null);
+    // Sync time settings to the manager whenever they change.
+    // useLayoutEffect ensures the manager is registered before useFrame's
+    // first rAF callback runs (regular useEffect runs after paint, too late).
+    useLayoutEffect(() => {
+        skySystemManager.setTimeSettings(timeSettings);
+    }, [timeSettings]);
+    // Manual time mode: respond immediately when timeOfDay changes
+    useEffect(() => {
+        if (!enabled || !timeSettings.enabled || timeSettings.autoAnimate)
+            return;
+        const state = skySystemManager.getStateByTime(timeSettings.timeOfDay);
+        if (previousTimeOfDayRef.current !== null &&
+            previousTimeOfDayRef.current !== state.timeOfDay) {
+            onTimeOfDayChange?.(state.timeOfDay, state.elapsedTime);
+        }
+        previousTimeOfDayRef.current = state.timeOfDay;
+        onTimeUpdate?.(state);
+    }, [timeSettings.timeOfDay, timeSettings.enabled, timeSettings.autoAnimate, enabled, onTimeUpdate, onTimeOfDayChange]);
+    // Auto-animate mode: read state every frame (SkySystem or user is responsible for ticking)
+    useFrame(() => {
+        if (!enabled || !timeSettings.enabled || !timeSettings.autoAnimate)
+            return;
+        const state = skySystemManager.getState();
+        // console.log(state.timeInHours)
+        if (previousTimeOfDayRef.current !== null &&
+            previousTimeOfDayRef.current !== state.timeOfDay) {
+            onTimeOfDayChange?.(state.timeOfDay, state.elapsedTime);
+        }
+        previousTimeOfDayRef.current = state.timeOfDay;
+        onTimeUpdate?.(state);
+    });
+    const setTime = useCallback((hours, minutes = 0) => {
+        skySystemManager.setTime(hours, minutes);
+    }, []);
+    const getTime = useCallback(() => skySystemManager.getTime(), []);
+    const getTimeOfDay = useCallback(() => skySystemManager.getTimeOfDay(), []);
+    const getSunDirection = useCallback(() => skySystemManager.getSunDirection(), []);
+    const state = skySystemManager.getState();
+    return {
+        timeInHours: state.timeInHours,
+        normalizedTime: state.normalizedTime,
+        isDaytime: state.isDaytime,
+        timeOfDay: state.timeOfDay,
+        sunElevation: state.sunElevation,
+        sunAzimuth: state.sunAzimuth,
+        sunDirection: state.sunDirection,
+        setTime,
+        getTime,
+        getTimeOfDay,
+        getSunDirection,
+    };
+}
+export default useSkySystem;

package/dist/hooks/useSkyUniforms.d.ts

@@ -0,0 +1,18 @@
+import type { SkySettings } from '@3driseai/3drise-core';
+import { Vector3 } from "three";
+export declare function useSkyUniforms(): {
+    updateUniforms: (settings: Partial<SkySettings>) => void;
+    getCurrentValues: () => {
+        elevation: number;
+        azimuth: number;
+        turbidity: any;
+        rayleigh: any;
+        mieCoefficient: any;
+        mieDirectionalG: any;
+    } | null;
+    getElevationAndAzimuth: (sunPosition: Vector3) => {
+        elevation: number;
+        azimuth: number;
+    };
+};
+//# sourceMappingURL=useSkyUniforms.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useSkyUniforms.d.ts","sourceRoot":"","sources":["../../src/hooks/useSkyUniforms.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAEhC,wBAAgB,cAAc,IAAI;IAC1B,cAAc,EAAE,CAAC,QAAQ,EAAE,OAAO,CAAC,WAAW,CAAC,KAAK,IAAI,CAAC;IACzD,gBAAgB,EAAE,MAAM;QACpB,SAAS,EAAE,MAAM,CAAC;QAClB,OAAO,EAAE,MAAM,CAAC;QAChB,SAAS,EAAE,GAAG,CAAC;QACf,QAAQ,EAAE,GAAG,CAAC;QACd,cAAc,EAAE,GAAG,CAAC;QACpB,eAAe,EAAE,GAAG,CAAC;KACxB,GAAG,IAAI,CAAC;IACT,sBAAsB,EAAE,CAAC,WAAW,EAAE,OAAO,KAAK;QAC9C,SAAS,EAAE,MAAM,CAAC;QAClB,OAAO,EAAE,MAAM,CAAC;KACnB,CAAC;CACL,CAmEJ"}

package/dist/hooks/useSkyUniforms.js

@@ -0,0 +1,71 @@
+import { useRef, useCallback } from 'react';
+import { createSunPosition } from '../utils/utils3d.js';
+import { findById } from '@3driseai/3drise-core';
+export function useSkyUniforms() {
+    const skyMeshRef = useRef(null);
+    const getSkyRef = useCallback(() => {
+        if (skyMeshRef.current)
+            return skyMeshRef.current;
+        // let found: Mesh | null = null;
+        // scene.traverse((obj) => {
+        //   if (!found && obj.userData?.id === '3drise-sky') {
+        //     found = obj as Mesh;
+        //   }
+        // });
+        skyMeshRef.current = findById('3drise-sky') || null;
+        return skyMeshRef.current;
+    }, []);
+    const getElevationAndAzimuth = useCallback((sunPosition) => {
+        const { x, y, z } = sunPosition;
+        const r = Math.sqrt(x * x + y * y + z * z);
+        const phi = Math.acos(y / r);
+        const theta = Math.atan2(z, x);
+        return {
+            elevation: 90 - phi * (180 / Math.PI),
+            azimuth: theta * (180 / Math.PI),
+        };
+    }, []);
+    const updateUniforms = useCallback((settings) => {
+        const skyRef = getSkyRef();
+        if (!skyRef?.material)
+            return;
+        const uniforms = skyRef.material.uniforms;
+        if (!uniforms)
+            return;
+        if (settings.turbidity !== undefined)
+            uniforms.turbidity.value = settings.turbidity;
+        if (settings.rayleigh !== undefined)
+            uniforms.rayleigh.value = settings.rayleigh;
+        if (settings.mieCoefficient !== undefined)
+            uniforms.mieCoefficient.value = settings.mieCoefficient;
+        if (settings.mieDirectionalG !== undefined)
+            uniforms.mieDirectionalG.value = settings.mieDirectionalG;
+        // Only update sun position when at least one sun-related property is explicitly provided.
+        // Fall back to current uniform value for the axis that wasn't specified.
+        if (settings.elevation !== undefined || settings.azimuth !== undefined) {
+            const current = uniforms.sunPosition
+                ? getElevationAndAzimuth(uniforms.sunPosition.value)
+                : { elevation: 0, azimuth: 0 };
+            const elevation = settings.elevation ?? current.elevation;
+            const azimuth = settings.azimuth ?? current.azimuth;
+            const sunPosition = createSunPosition(elevation, azimuth);
+            uniforms.sunPosition.value.copy(sunPosition);
+        }
+    }, [getSkyRef, getElevationAndAzimuth]);
+    const getCurrentValues = useCallback(() => {
+        const skyRef = getSkyRef();
+        if (!skyRef?.material)
+            return null;
+        const uniforms = skyRef.material.uniforms;
+        if (!uniforms)
+            return null;
+        return {
+            turbidity: uniforms.turbidity.value,
+            rayleigh: uniforms.rayleigh.value,
+            mieCoefficient: uniforms.mieCoefficient.value,
+            mieDirectionalG: uniforms.mieDirectionalG.value,
+            ...getElevationAndAzimuth(uniforms.sunPosition.value),
+        };
+    }, [getSkyRef, getElevationAndAzimuth]);
+    return { updateUniforms, getCurrentValues, getElevationAndAzimuth };
+}

package/dist/hooks/useTransformControls.d.ts

@@ -0,0 +1,6 @@
+export declare const useTransformControls: () => {
+    controllersRef: import("react").RefObject<Map<any, any>>;
+    getControllers: () => any[];
+    applyToAllControllers: (action: any) => void;
+};
+//# sourceMappingURL=useTransformControls.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useTransformControls.d.ts","sourceRoot":"","sources":["../../src/hooks/useTransformControls.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,oBAAoB;;;;CA2GhC,CAAC"}