@3driseai/3drise-viewer 0.1.1

package/dist/components/ShootingStar.d.ts

@@ -0,0 +1,16 @@
+import React from "react";
+export interface ShootingStarProps {
+    position?: [number, number, number];
+    direction?: [number, number, number];
+    speed?: number;
+    color?: string;
+    trailLength?: number;
+    size?: number;
+    opacity?: number;
+    onComplete?: () => void;
+    maxDistance?: number;
+    followMouse?: boolean;
+}
+declare const ShootingStar: React.FC<ShootingStarProps>;
+export default ShootingStar;
+//# sourceMappingURL=ShootingStar.d.ts.map

package/dist/components/ShootingStar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ShootingStar.d.ts","sourceRoot":"","sources":["../../src/components/ShootingStar.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,MAAM,WAAW,iBAAiB;IAC9B,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,IAAI,CAAC;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,OAAO,CAAC;CACzB;AAGD,QAAA,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC,iBAAiB,CAqF7C,CAAC;AACF,eAAe,YAAY,CAAC"}

package/dist/components/ShootingStar.js

@@ -0,0 +1,92 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useRef, useMemo, useEffect } from 'react';
+import { useFrame } from '@react-three/fiber';
+import { Vector3, BufferGeometry, BufferAttribute, AdditiveBlending, Color } from 'three';
+import { ShootingStarMaterial } from '@3driseai/3drise-core';
+const ShootingStar = ({ position = [0, 0, 0], direction = [1, -1, 0], speed = 0.05, color = '#ffffff', trailLength = 30, size = 0.1, opacity = 1.0, onComplete, maxDistance = 50, followMouse = true, }) => {
+    const starRef = useRef(null);
+    const glowRef = useRef(null);
+    const trailRef = useRef(null);
+    const materialRef = useRef(null);
+    const starMaterialRef = useRef(null);
+    const glowMaterialRef = useRef(null);
+    const trailPositions = useRef([]);
+    const currentPosition = useRef(new Vector3(...position));
+    const directionVector = useRef(new Vector3(...direction).normalize());
+    const distanceTraveled = useRef(0);
+    const fadeInDistance = maxDistance * 0.15;
+    const fadeOutDistance = maxDistance * 0.15;
+    useEffect(() => {
+        const validTrailLength = Math.max(2, trailLength);
+        trailPositions.current = Array(validTrailLength).fill(null).map(() => currentPosition.current.clone());
+        currentPosition.current.set(...position);
+        directionVector.current.set(...direction).normalize();
+        distanceTraveled.current = 0;
+        if (starRef.current)
+            starRef.current.position.set(...position);
+    }, [trailLength, position, direction]);
+    const trailGeometry = useMemo(() => {
+        const validTrailLength = Math.max(2, trailLength);
+        const geometry = new BufferGeometry();
+        const positions = new Float32Array(validTrailLength * 3);
+        const progress = new Float32Array(validTrailLength);
+        const indices = [];
+        for (let i = 0; i < validTrailLength - 1; i++)
+            indices.push(i, i + 1);
+        for (let i = 0; i < validTrailLength; i++) {
+            positions[i * 3] = position[0];
+            positions[i * 3 + 1] = position[1];
+            positions[i * 3 + 2] = position[2];
+            progress[i] = i / (validTrailLength - 1);
+        }
+        geometry.setAttribute('position', new BufferAttribute(positions, 3));
+        geometry.setAttribute('progress', new BufferAttribute(progress, 1));
+        geometry.setIndex(indices);
+        return geometry;
+    }, [trailLength, position]);
+    useEffect(() => {
+        return () => {
+            trailGeometry.dispose();
+            materialRef.current?.dispose();
+            starMaterialRef.current?.dispose();
+            glowMaterialRef.current?.dispose();
+        };
+    }, [trailGeometry]);
+    useFrame((state, delta) => {
+        if (!trailRef.current || !starRef.current)
+            return;
+        if (followMouse) {
+            directionVector.current.set(-state.pointer.x, state.pointer.y, direction[2]).normalize();
+        }
+        const movement = directionVector.current.clone().multiplyScalar(speed);
+        currentPosition.current.add(movement);
+        distanceTraveled.current += speed;
+        let starOpacity = opacity;
+        if (distanceTraveled.current < fadeInDistance) {
+            starOpacity = opacity * (distanceTraveled.current / fadeInDistance);
+        }
+        else if (distanceTraveled.current > maxDistance - fadeOutDistance) {
+            starOpacity = opacity * ((maxDistance - distanceTraveled.current) / fadeOutDistance);
+        }
+        starRef.current.position.copy(currentPosition.current);
+        if (starMaterialRef.current)
+            starMaterialRef.current.opacity = starOpacity;
+        if (glowMaterialRef.current)
+            glowMaterialRef.current.opacity = starOpacity * 0.3;
+        if (materialRef.current)
+            materialRef.current.opacity = starOpacity;
+        trailPositions.current.unshift(currentPosition.current.clone());
+        if (trailPositions.current.length > trailLength)
+            trailPositions.current.pop();
+        const posAttr = trailGeometry.getAttribute('position');
+        for (let i = 0; i < trailPositions.current.length; i++) {
+            const pos = trailPositions.current[i];
+            posAttr.setXYZ(i, pos.x, pos.y, pos.z);
+        }
+        posAttr.needsUpdate = true;
+        if (distanceTraveled.current > maxDistance)
+            onComplete?.();
+    });
+    return (_jsxs("group", { children: [_jsx("lineSegments", { ref: trailRef, geometry: trailGeometry, children: _jsx("shootingStarMaterial", { ref: materialRef, attach: "material", transparent: true, blending: AdditiveBlending, depthWrite: false, color: new Color(color), opacity: opacity }, ShootingStarMaterial.key) }), _jsxs("mesh", { ref: starRef, children: [_jsx("sphereGeometry", { args: [size, 8, 8] }), _jsx("meshBasicMaterial", { ref: starMaterialRef, color: color, transparent: true, opacity: opacity, blending: AdditiveBlending, depthWrite: false }), _jsxs("mesh", { ref: glowRef, children: [_jsx("sphereGeometry", { args: [size * 2, 8, 8] }), _jsx("meshBasicMaterial", { ref: glowMaterialRef, color: color, transparent: true, opacity: opacity * 0.3, blending: AdditiveBlending, depthWrite: false })] })] })] }));
+};
+export default ShootingStar;

package/dist/components/ShootingStars.d.ts

@@ -0,0 +1,8 @@
+import type { ShootingStarsSettings } from '@3driseai/3drise-core';
+import React from "react";
+export interface ShootingStarsProps {
+    settings: ShootingStarsSettings;
+}
+declare const ShootingStars: React.FC<ShootingStarsProps>;
+export default ShootingStars;
+//# sourceMappingURL=ShootingStars.d.ts.map

package/dist/components/ShootingStars.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ShootingStars.d.ts","sourceRoot":"","sources":["../../src/components/ShootingStars.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAEnE,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,MAAM,WAAW,kBAAkB;IAC/B,QAAQ,EAAE,qBAAqB,CAAC;CACnC;AAGD,QAAA,MAAM,aAAa,EAAE,KAAK,CAAC,EAAE,CAAC,kBAAkB,CAmC/C,CAAC;AACF,eAAe,aAAa,CAAC"}

package/dist/components/ShootingStars.js

@@ -0,0 +1,41 @@
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { useRef, useState, useEffect, useCallback } from 'react';
+import { generateShootingStar, generateShootingStars } from '@3driseai/3drise-core';
+import ShootingStar from './ShootingStar.js';
+const ShootingStars = ({ settings }) => {
+    const [shootingStars, setShootingStars] = useState(() => {
+        if (settings?.enabled)
+            return generateShootingStars(settings.count, settings);
+        return [];
+    });
+    const nextIdRef = useRef(settings?.count || 0);
+    const settingsRef = useRef(settings);
+    useEffect(() => {
+        settingsRef.current = settings;
+    }, [settings]);
+    useEffect(() => {
+        const currentCount = shootingStars.length;
+        const targetCount = settings?.count || 0;
+        if (settings?.enabled && currentCount !== targetCount) {
+            setShootingStars(generateShootingStars(targetCount, settings));
+            nextIdRef.current = targetCount;
+        }
+        else if (!settings?.enabled && currentCount > 0) {
+            setShootingStars([]);
+        }
+    }, [settings?.enabled, settings?.count]);
+    const handleComplete = useCallback((starId) => {
+        const s = settingsRef.current;
+        if (!s)
+            return;
+        setShootingStars(prev => {
+            const newStar = generateShootingStar(nextIdRef.current++, s);
+            return prev.map(star => star.id === starId ? newStar : star);
+        });
+    }, []);
+    if (!settings?.enabled)
+        return null;
+    console.log("Rendering ShootingStars with settings:", settings, "and shootingStars:", shootingStars);
+    return (_jsx(_Fragment, { children: shootingStars.map(star => (_jsx(ShootingStar, { position: star.position, direction: star.direction, speed: star.speed, color: star.color, trailLength: star.trailLength, size: 0.08, opacity: 0.9, maxDistance: star.length, onComplete: () => handleComplete(star.id), followMouse: settings.followMouse }, star.id))) }));
+};
+export default ShootingStars;

package/dist/components/SkyController.d.ts

@@ -0,0 +1,10 @@
+import type { SkySettings, TimeSettings } from '@3driseai/3drise-core';
+export interface SkyControllerProps {
+    settings: SkySettings;
+    timeSettings: TimeSettings;
+    scale?: number;
+    onSettingsChange?: (settings: SkySettings) => void;
+}
+declare function SkyController({ settings, timeSettings, scale, onSettingsChange, }: SkyControllerProps): any;
+export default SkyController;
+//# sourceMappingURL=SkyController.d.ts.map

package/dist/components/SkyController.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SkyController.d.ts","sourceRoot":"","sources":["../../src/components/SkyController.tsx"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAEvE,MAAM,WAAW,kBAAkB;IAC/B,QAAQ,EAAE,WAAW,CAAC;IACtB,YAAY,EAAE,YAAY,CAAC;IAC3B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,gBAAgB,CAAC,EAAE,CAAC,QAAQ,EAAE,WAAW,KAAK,IAAI,CAAC;CACtD;AAED,iBAAS,aAAa,CAAC,EAAE,QAAQ,EAAE,YAAY,EAAE,KAAY,EAAE,gBAAgB,GAAG,EAAE,kBAAkB,GAuKyH,GAAG,CACjO;AA6BD,eAAe,aAAa,CAAC"}

package/dist/components/SkyController.js

@@ -0,0 +1,208 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { useRef, useEffect, useCallback } from 'react';
+import { useFrame } from '@react-three/fiber';
+import { useAnimationEvents } from '../hooks/useAnimationEvents.js';
+import { useSkyUniforms } from '../hooks/useSkyUniforms.js';
+import { useSkyAnimation } from '../hooks/useSkyAnimation.js';
+import { useSkySystem } from '../hooks/useSkySystem.js';
+import { findById } from '../utils/sceneQuery.js';
+import { cubeCameraManager } from '@3driseai/3drise-core';
+import SkyMesh from './SkyMesh.js';
+function SkyController({ settings, timeSettings, scale = 1000, onSettingsChange, }) {
+    const skyRef = useRef(null);
+    const sunLightRef = useRef(null);
+    const isAnimatingRef = useRef(false);
+    const previousSettings = useRef(null);
+    // const cubeCameraManager = CubeCameraManager.getInstance();
+    const { updateUniforms, getCurrentValues } = useSkyUniforms();
+    const { animateSkyTransition } = useSkyAnimation();
+    useEffect(() => {
+        return () => {
+            sunLightRef.current?.shadow?.map?.dispose();
+        };
+    }, []);
+    useEffect(() => {
+        handleSettings(settings);
+    }, [settings]);
+    useAnimationEvents({
+        onStepStart: (event) => {
+            if (!event.step?.transitions)
+                return;
+            event.step.transitions.forEach((transition) => {
+                if (transition.state === 'sky' && skyRef.current) {
+                    console.log('Starting sky transition animation', { transition }, skyRef.current.visible);
+                    const toProps = transition.properties.to || {};
+                    const fromProps = transition.properties.from || {};
+                    // Handle `visible` as an immediate boolean switch — not animated
+                    if (toProps.visible !== undefined) {
+                        toggleSky(toProps.visible);
+                    }
+                    else if (fromProps.visible !== undefined) {
+                        toggleSky(fromProps.visible);
+                    }
+                    if (!skyRef.current.visible)
+                        return;
+                    // Only animate numeric sky uniform properties
+                    const SKY_KEYS = ['turbidity', 'rayleigh', 'mieCoefficient', 'mieDirectionalG', 'elevation', 'azimuth'];
+                    const hasNumericTarget = SKY_KEYS.some((k) => toProps[k] !== undefined);
+                    if (!hasNumericTarget)
+                        return;
+                    // Build `from`: current live values as baseline, overridden by explicit fromProps
+                    const liveValues = getCurrentValues() || {};
+                    const from = {};
+                    const to = {};
+                    for (const key of SKY_KEYS) {
+                        if (toProps[key] === undefined)
+                            continue;
+                        to[key] = toProps[key];
+                        from[key] = fromProps[key] ?? liveValues[key] ?? toProps[key];
+                    }
+                    isAnimatingRef.current = true;
+                    animateSkyTransition(from, to, updateUniforms, handleCompletedUniforms, event.step?.duration);
+                }
+            });
+        },
+    });
+    const handleTimeUpdate = useCallback((state) => {
+        const { sunAzimuth, sunElevation, timeInHours } = state;
+        // console.log('SkyController - Time update:', { sunAzimuth, sunElevation, timeInHours });
+        const atmosphericParams = calculateSkyParamsForTime(timeInHours);
+        const newSettings = {
+            ...settings,
+            elevation: sunElevation,
+            azimuth: sunAzimuth,
+            ...atmosphericParams,
+        };
+        handleSettings(newSettings);
+        if (!state.autoAnimate) {
+            onSettingsChange?.(newSettings);
+        }
+    }, [settings, onSettingsChange]);
+    useSkySystem({
+        timeSettings,
+        onTimeUpdate: handleTimeUpdate,
+        enabled: settings.visible && timeSettings.enabled,
+    });
+    const handleMeshReady = useCallback((mesh) => {
+        skyRef.current = mesh;
+        updateUniforms(settings);
+        previousSettings.current = { ...settings };
+    }, [settings, updateUniforms]);
+    const toggleSky = useCallback((show) => {
+        if (!skyRef.current)
+            return;
+        skyRef.current.visible = show;
+        if (sunLightRef.current)
+            sunLightRef.current.visible = show;
+        if (!show) {
+            cubeCameraManager.dispose();
+        }
+        else {
+            cubeCameraManager.updateEnvironment();
+        }
+    }, []);
+    const updateSun = useCallback(() => {
+        if (!skyRef.current?.material || !sunLightRef.current)
+            return;
+        const uniforms = skyRef.current.material.uniforms;
+        if (!uniforms?.sunPosition)
+            return;
+        const distance = 100;
+        const sp = uniforms.sunPosition.value;
+        sunLightRef.current.position.set(sp.x * distance, sp.y * distance, sp.z * distance);
+        sunLightRef.current.shadow.camera.updateProjectionMatrix();
+        const moon = findById('3drise-moon');
+        if (moon)
+            moon.position.set(sp.x * scale, sp.y * scale, sp.z * scale);
+    }, [scale]);
+    const hasActualChanges = useCallback((next, prev) => {
+        if (!prev)
+            return true;
+        return (next.visible !== prev.visible ||
+            Math.abs(next.turbidity - prev.turbidity) > 0.01 ||
+            Math.abs(next.rayleigh - prev.rayleigh) > 0.01 ||
+            Math.abs(next.mieCoefficient - prev.mieCoefficient) > 0.001 ||
+            Math.abs(next.mieDirectionalG - prev.mieDirectionalG) > 0.001 ||
+            Math.abs(next.elevation - prev.elevation) > 0.1 ||
+            Math.abs(next.azimuth - prev.azimuth) > 0.1);
+    }, []);
+    const handleCompletedUniforms = (_finalValues) => {
+        isAnimatingRef.current = false;
+        cubeCameraManager.updateEnvironment();
+    };
+    const handleSettings = (newSettings) => {
+        if (!skyRef.current || isAnimatingRef.current || !newSettings)
+            return;
+        if (!hasActualChanges(newSettings, previousSettings.current))
+            return;
+        if (previousSettings.current?.visible !== newSettings.visible) {
+            toggleSky(newSettings.visible);
+        }
+        if (!skyRef.current.visible) {
+            previousSettings.current = { ...newSettings };
+            return;
+        }
+        updateUniforms(newSettings);
+        updateSun();
+        cubeCameraManager.updateEnvironment();
+        previousSettings.current = { ...newSettings };
+    };
+    const handleMouseMove = (mouse) => {
+        // console.log(skyRef.current.visible)
+        const handlers = settings.handlers;
+        if (!handlers || isAnimatingRef.current || !skyRef.current)
+            return;
+        if (!handlers.onMouseMove?.enabled)
+            return;
+        let updated = { ...settings };
+        handlers.onMouseMove.properties.forEach((propConfig) => {
+            const { property } = propConfig;
+            const { sensitivity, min: minVal, max: maxVal, axis } = propConfig.propertySettings;
+            let movement = axis === 'x' ? mouse.x * sensitivity
+                : axis === 'y' ? mouse.y * sensitivity
+                    : (mouse.x + mouse.y) * 0.5 * sensitivity;
+            if (movement !== 0) {
+                let newVal = updated[property] + movement;
+                if (typeof minVal === 'number')
+                    newVal = Math.max(newVal, minVal);
+                if (typeof maxVal === 'number')
+                    newVal = Math.min(newVal, maxVal);
+                updated[property] = newVal;
+            }
+        });
+        handleSettings(updated);
+    };
+    useFrame((state) => {
+        handleMouseMove({ x: state.pointer.x, y: state.pointer.y });
+    });
+    return (_jsxs(_Fragment, { children: [_jsx(SkyMesh, { ref: skyRef, settings: settings, scale: scale, onMeshReady: handleMeshReady }), settings.visible && (_jsx("directionalLight", { ref: sunLightRef, color: "#ffffff", intensity: 1, castShadow: true }))] }));
+}
+// ─── Atmospheric parameter calculation ───────────────────────────────────────
+function calculateSkyParamsForTime(timeInHours) {
+    const nightParams = { turbidity: 0.5, rayleigh: 0.1, mieCoefficient: 0.001, mieDirectionalG: 0.8 };
+    const sunriseParams = { turbidity: 4, rayleigh: 3, mieCoefficient: 0.01, mieDirectionalG: 0.9 };
+    const dayParams = { turbidity: 0.7, rayleigh: 0.54, mieCoefficient: 0.005, mieDirectionalG: 0.7 };
+    const sunsetParams = { turbidity: 4.5, rayleigh: 3.5, mieCoefficient: 0.012, mieDirectionalG: 0.92 };
+    const lerp = (a, b, t) => a + (b - a) * Math.max(0, Math.min(1, t));
+    const ss = (t) => t * t * (3 - 2 * t);
+    const lerpP = (from, to, t) => ({
+        turbidity: lerp(from.turbidity, to.turbidity, ss(t)),
+        rayleigh: lerp(from.rayleigh, to.rayleigh, ss(t)),
+        mieCoefficient: lerp(from.mieCoefficient, to.mieCoefficient, ss(t)),
+        mieDirectionalG: lerp(from.mieDirectionalG, to.mieDirectionalG, ss(t)),
+    });
+    if (timeInHours < 5)
+        return nightParams;
+    if (timeInHours < 6.5)
+        return lerpP(nightParams, sunriseParams, (timeInHours - 5) / 1.5);
+    if (timeInHours < 8)
+        return lerpP(sunriseParams, dayParams, (timeInHours - 6.5) / 1.5);
+    if (timeInHours < 17)
+        return dayParams;
+    if (timeInHours < 19)
+        return lerpP(dayParams, sunsetParams, (timeInHours - 17) / 2);
+    if (timeInHours < 21)
+        return lerpP(sunsetParams, nightParams, (timeInHours - 19) / 2);
+    return nightParams;
+}
+export default SkyController;

package/dist/components/SkyMesh.d.ts

@@ -0,0 +1,10 @@
+import { Mesh } from "three";
+import type { SkySettings } from "@3driseai/3drise-core";
+export interface SkyMeshProps {
+    settings: SkySettings;
+    scale?: number;
+    onMeshReady?: (mesh: Mesh) => void;
+}
+declare const SkyMesh: any;
+export default SkyMesh;
+//# sourceMappingURL=SkyMesh.d.ts.map

package/dist/components/SkyMesh.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SkyMesh.d.ts","sourceRoot":"","sources":["../../src/components/SkyMesh.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC;AAC7B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACzD,MAAM,WAAW,YAAY;IACzB,QAAQ,EAAE,WAAW,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI,CAAC;CACtC;AAGD,QAAA,MAAM,OAAO,EA8BP,GAAI,CAAC;AAEX,eAAe,OAAO,CAAC"}

package/dist/components/SkyMesh.js

@@ -0,0 +1,36 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import React, { useRef, useMemo, useEffect } from 'react';
+import { Sky } from 'three/examples/jsm/objects/Sky.js';
+const SkyMesh = React.forwardRef(({ settings, scale = 1000, onMeshReady }, ref) => {
+    const meshRef = useRef(null);
+    const skyObject = useMemo(() => {
+        const sky = new Sky();
+        sky.scale.setScalar(scale);
+        return sky;
+    }, [scale]);
+    useEffect(() => {
+        return () => {
+            skyObject.geometry?.dispose();
+            if (Array.isArray(skyObject.material)) {
+                skyObject.material.forEach(m => m.dispose());
+            }
+            else {
+                skyObject.material?.dispose();
+            }
+        };
+    }, [skyObject]);
+    useEffect(() => {
+        if (meshRef.current && onMeshReady)
+            onMeshReady(meshRef.current);
+    }, [onMeshReady]);
+    const combinedRef = (node) => {
+        meshRef.current = node;
+        if (typeof ref === 'function')
+            ref(node);
+        else if (ref)
+            ref.current = node;
+    };
+    return (_jsx("primitive", { ref: combinedRef, object: skyObject, visible: settings.visible, scale: scale, userData: { id: '3drise-sky' } }));
+});
+SkyMesh.displayName = 'SkyMesh';
+export default SkyMesh;

package/dist/components/SkySystem.d.ts

@@ -0,0 +1,32 @@
+import * as THREE from 'three';
+import type { TimeSettings, StarsSettings, CloudsSettings, SkySettings, RainSettings, FogSettings, MaterialSettings } from '@3driseai/3drise-core';
+import React from "react";
+export interface SkySystemRef {
+    setTime: (hours: number, minutes?: number) => void;
+    getTime: () => Date;
+    getTimeOfDay: () => string;
+    getSunDirection: () => THREE.Vector3;
+}
+export interface SkySystemProps {
+    timeSettings: TimeSettings;
+    visible?: boolean;
+    sunSystemVisible?: boolean;
+    sunSize?: number;
+    moonSize?: number;
+    skyboxScale?: number;
+    sunIntensity?: number;
+    castShadow?: boolean;
+    shadowMapSize?: number;
+    playerPosition?: THREE.Vector3;
+    starsSettings?: StarsSettings;
+    cloudsSettings?: CloudsSettings;
+    cloudsMaterialSettings?: MaterialSettings;
+    skyControllerSettings?: SkySettings;
+    rainSettings?: RainSettings;
+    fogSettings?: FogSettings;
+    onTimeOfDayChange?: (timeOfDay: string, elapsedTime: number) => void;
+    onTimeUpdate?: (timeOfDay: number) => void;
+}
+declare const SkySystem: React.ForwardRefExoticComponent<SkySystemProps & React.RefAttributes<SkySystemRef>>;
+export default SkySystem;
+//# sourceMappingURL=SkySystem.d.ts.map

package/dist/components/SkySystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SkySystem.d.ts","sourceRoot":"","sources":["../../src/components/SkySystem.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAG/B,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,cAAc,EAAE,WAAW,EAAE,YAAY,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAMnJ,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,MAAM,WAAW,YAAY;IACzB,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,MAAM,WAAW,cAAc;IAC3B,YAAY,EAAE,YAAY,CAAC;IAC3B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,cAAc,CAAC,EAAE,KAAK,CAAC,OAAO,CAAC;IAC/B,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,sBAAsB,CAAC,EAAE,gBAAgB,CAAC;IAC1C,qBAAqB,CAAC,EAAE,WAAW,CAAC;IACpC,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,iBAAiB,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,KAAK,IAAI,CAAC;IACrE,YAAY,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;CAC9C;AAGD,QAAA,MAAM,SAAS,EAAE,KAAK,CAAC,yBAAyB,CAAC,cAAc,GAAG,KAAK,CAAC,aAAa,CAAC,YAAY,CAAC,CAiCjG,CAAC;AAEH,eAAe,SAAS,CAAC"}

package/dist/components/SkySystem.js

@@ -0,0 +1,46 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useLayoutEffect, useRef, forwardRef, useImperativeHandle } from 'react';
+import * as THREE from 'three';
+import { useFrame } from '@react-three/fiber';
+import { skySystemManager } from '@3driseai/3drise-core';
+import Skybox from './Skybox.js';
+import Lensflare from './Lensflare.js';
+import SunLight from './SunLight.js';
+import SkyController from './SkyController.js';
+import SceneFog from './SceneFog.js';
+const SkySystem = forwardRef(({ timeSettings, visible = true, sunSystemVisible = false, sunSize = 1, moonSize = 1, skyboxScale = 1000, sunIntensity = 1, castShadow = true, shadowMapSize = 2048, playerPosition = new THREE.Vector3(0, 0, 0), starsSettings, cloudsSettings, cloudsMaterialSettings, skyControllerSettings, rainSettings, fogSettings, onTimeOfDayChange, onTimeUpdate, }, ref) => {
+    const previousTimeOfDayRef = useRef(null);
+    useImperativeHandle(ref, () => ({
+        setTime: (h, m) => skySystemManager.setTime(h, m),
+        getTime: () => skySystemManager.getTime(),
+        getTimeOfDay: () => skySystemManager.getTimeOfDay(),
+        getSunDirection: () => skySystemManager.getSunDirection(),
+    }));
+    // useLayoutEffect so the manager is registered before useFrame's first
+    // rAF callback (regular useEffect runs after paint, too late).
+    useLayoutEffect(() => {
+        skySystemManager.setTimeSettings(timeSettings);
+    }, [timeSettings]);
+    useEffect(() => {
+        if (!onTimeUpdate)
+            return;
+        skySystemManager.setOnTimeSync(onTimeUpdate);
+        return () => { skySystemManager.setOnTimeSync(null); };
+    }, [onTimeUpdate]);
+    useFrame((_, delta) => {
+        if (!timeSettings.enabled || !timeSettings.autoAnimate)
+            return;
+        skySystemManager.tick(delta);
+        const current = skySystemManager.getTimeOfDay();
+        if (previousTimeOfDayRef.current !== null && previousTimeOfDayRef.current !== current) {
+            const state = skySystemManager.getState();
+            onTimeOfDayChange?.(current, state.elapsedTime);
+        }
+        previousTimeOfDayRef.current = current;
+    });
+    if (!visible)
+        return null;
+    return (_jsxs("group", { children: [skyControllerSettings && !sunSystemVisible && (_jsx(SkyController, { settings: skyControllerSettings, timeSettings: timeSettings, scale: skyboxScale })), sunSystemVisible && (_jsxs(_Fragment, { children: [_jsx(Skybox, { visible: true, scale: skyboxScale, sunSize: sunSize, moonSize: moonSize, timeSettings: timeSettings }), _jsx(Lensflare, { visible: true, intensity: sunIntensity, timeSettings: timeSettings }), _jsx(SunLight, { visible: true, timeSettings: timeSettings, targetPosition: playerPosition, intensity: sunIntensity, castShadow: castShadow, shadowMapSize: shadowMapSize })] })), fogSettings && (_jsx(SceneFog, { fog: fogSettings }))] }));
+});
+SkySystem.displayName = 'SkySystem';
+export default SkySystem;

package/dist/components/Skybox.d.ts

@@ -0,0 +1,12 @@
+import type { TimeSettings } from '@3driseai/3drise-core';
+import React from "react";
+export interface SkyboxProps {
+    visible?: boolean;
+    scale?: number;
+    sunSize?: number;
+    moonSize?: number;
+    timeSettings: TimeSettings;
+}
+declare const Skybox: React.FC<SkyboxProps>;
+export default Skybox;
+//# sourceMappingURL=Skybox.d.ts.map

package/dist/components/Skybox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Skybox.d.ts","sourceRoot":"","sources":["../../src/components/Skybox.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAG1D,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,MAAM,WAAW,WAAW;IACxB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,YAAY,CAAC;CAC9B;AAkDD,QAAA,MAAM,MAAM,EAAE,KAAK,CAAC,EAAE,CAAC,WAAW,CAoCjC,CAAC;AACF,eAAe,MAAM,CAAC"}

package/dist/components/Skybox.js

@@ -0,0 +1,92 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useRef, useCallback, useEffect } from 'react';
+import * as THREE from 'three';
+import { useSkySystem } from '../hooks/useSkySystem.js';
+import { SkyboxMaterial } from '@3driseai/3drise-core';
+// Extend R3F with skyboxMaterial
+import { extend } from '@react-three/fiber';
+extend({ SkyboxMaterial });
+const COLORS = {
+    white: new THREE.Color(0xffffff),
+    orange: new THREE.Color(0xff4500),
+    yellow: new THREE.Color(0xffd700),
+    red: new THREE.Color(0xff6347),
+    darkRed: new THREE.Color(0xd32f2f),
+    skyBlue: new THREE.Color(0x87ceeb),
+    darkSky: new THREE.Color(0x0d1321),
+    nightSky: new THREE.Color(0x1c2331),
+    moon: new THREE.Color(0xe6e8fa),
+};
+const MOON_GLOW = COLORS.moon.clone().multiplyScalar(1.8);
+const SKY_KEYFRAMES = [
+    { t: 0, horizon: COLORS.darkSky, high: COLORS.nightSky, sun: MOON_GLOW },
+    { t: 5, horizon: COLORS.darkSky, high: COLORS.nightSky, sun: MOON_GLOW },
+    { t: 5.7, horizon: COLORS.darkRed, high: COLORS.darkSky, sun: COLORS.orange },
+    { t: 6.3, horizon: COLORS.red, high: COLORS.darkSky, sun: COLORS.orange },
+    { t: 6.8, horizon: COLORS.yellow, high: COLORS.darkSky, sun: COLORS.yellow },
+    { t: 8, horizon: COLORS.skyBlue, high: COLORS.skyBlue, sun: COLORS.white },
+    { t: 12, horizon: COLORS.skyBlue, high: COLORS.darkSky, sun: COLORS.white },
+    { t: 16, horizon: COLORS.skyBlue, high: COLORS.skyBlue, sun: COLORS.white },
+    { t: 19, horizon: COLORS.yellow, high: COLORS.skyBlue, sun: COLORS.yellow },
+    { t: 20, horizon: COLORS.red, high: COLORS.darkRed, sun: COLORS.orange },
+    { t: 20.7, horizon: COLORS.darkRed, high: COLORS.darkSky, sun: COLORS.orange },
+    { t: 22, horizon: COLORS.darkSky, high: COLORS.nightSky, sun: MOON_GLOW },
+    { t: 24, horizon: COLORS.darkSky, high: COLORS.nightSky, sun: MOON_GLOW },
+];
+function sampleSkyKeyframes(timeInHours, outHorizon, outHigh, outSun) {
+    const wrapped = ((timeInHours % 24) + 24) % 24;
+    for (let i = 0; i < SKY_KEYFRAMES.length - 1; i++) {
+        const k0 = SKY_KEYFRAMES[i];
+        const k1 = SKY_KEYFRAMES[i + 1];
+        if (wrapped <= k1.t) {
+            const span = k1.t - k0.t;
+            const t = span === 0 ? 0 : (wrapped - k0.t) / span;
+            outHorizon.lerpColors(k0.horizon, k1.horizon, t);
+            outHigh.lerpColors(k0.high, k1.high, t);
+            outSun.lerpColors(k0.sun, k1.sun, t);
+            return;
+        }
+    }
+    const last = SKY_KEYFRAMES[SKY_KEYFRAMES.length - 1];
+    outHorizon.copy(last.horizon);
+    outHigh.copy(last.high);
+    outSun.copy(last.sun);
+}
+const Skybox = ({ visible = true, scale = 100000, sunSize = 1, moonSize = 1, timeSettings, }) => {
+    const materialRef = useRef(null);
+    const sunColorRef = useRef(new THREE.Color(0xffe5b0));
+    const skyColorLowRef = useRef(new THREE.Color(0x6fa2ef));
+    const skyColorHighRef = useRef(new THREE.Color(0x2053ff));
+    const targetSunColorRef = useRef(new THREE.Color(0xffe5b0));
+    const targetSkyColorLowRef = useRef(new THREE.Color(0x6fa2ef));
+    const targetSkyColorHighRef = useRef(new THREE.Color(0x2053ff));
+    useEffect(() => {
+        materialRef.current.uSunSize = sunSize;
+    }, [sunSize, moonSize]);
+    const handleTimeUpdate = useCallback((state) => {
+        const { timeInHours, isDaytime, sunElevation, sunAzimuth, delta } = state;
+        sampleSkyKeyframes(timeInHours, targetSkyColorLowRef.current, targetSkyColorHighRef.current, targetSunColorRef.current);
+        const colorLerpSpeed = Math.min(1, 2.0 * (delta !== 0 ? delta : 1));
+        sunColorRef.current.lerp(targetSunColorRef.current, colorLerpSpeed);
+        skyColorLowRef.current.lerp(targetSkyColorLowRef.current, colorLerpSpeed);
+        skyColorHighRef.current.lerp(targetSkyColorHighRef.current, colorLerpSpeed);
+        if (materialRef.current) {
+            materialRef.current.uSunAzimuth = sunAzimuth;
+            materialRef.current.uSunElevation = sunElevation;
+            materialRef.current.uSunColor = sunColorRef.current;
+            materialRef.current.uSkyColorLow = skyColorLowRef.current;
+            materialRef.current.uSkyColorHigh = skyColorHighRef.current;
+            materialRef.current.uSunSize = isDaytime ? sunSize : moonSize;
+        }
+    }, [sunSize, moonSize]);
+    useSkySystem({
+        timeSettings,
+        onTimeUpdate: handleTimeUpdate,
+        enabled: visible,
+    });
+    if (!visible)
+        return null;
+    // console.log(sunSize)
+    return (_jsxs("mesh", { scale: scale, children: [_jsx("boxGeometry", { args: [1, 1, 1] }), _jsx("skyboxMaterial", { ref: materialRef, side: THREE.BackSide, depthWrite: false, fog: false })] }));
+};
+export default Skybox;

package/dist/components/SolarSystem.d.ts

@@ -0,0 +1,8 @@
+import type { Group } from 'three';
+import React from "react";
+import { SolarSystemConfig } from "@3driseai/3drise-core";
+declare const SolarSystem: React.FC<SolarSystemConfig & {
+    onObjectReady?: (ref: Group) => void;
+}>;
+export default SolarSystem;
+//# sourceMappingURL=SolarSystem.d.ts.map

package/dist/components/SolarSystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SolarSystem.d.ts","sourceRoot":"","sources":["../../src/components/SolarSystem.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC;AAKnC,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAiD1D,QAAA,MAAM,WAAW,EAAE,KAAK,CAAC,EAAE,CAAC,iBAAiB,GAAG;IACpC,aAAa,CAAC,EAAE,CAAC,GAAG,EAAE,KAAK,KAAK,IAAI,CAAC;CACxC,CAoBR,CAAC;AAEF,eAAe,WAAW,CAAC"}