@3driseai/3drise-viewer 0.1.1

package/dist/components/SolarSystem.js

@@ -0,0 +1,77 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useRef, useMemo, useState, useCallback } from 'react';
+import { BufferGeometry, BufferAttribute, Vector3 } from 'three';
+import { useFrame } from '@react-three/fiber';
+import Planet from './Planet.js';
+import Earth from './Earth.js';
+import Sun from './Sun.js';
+// Stylized constants — distances compressed, sizes exaggerated for legibility.
+const PLANETS = [
+    { body: { name: 'mercury', kind: 'planet', type: 'mercury' }, radius: 0.6, orbitRadius: 18, periodYears: 0.24, axialTilt: 0.03, spinRate: 1.0, initialPhase: 0.2 },
+    { body: { name: 'venus', kind: 'planet', type: 'venus' }, radius: 1.2, orbitRadius: 26, periodYears: 0.62, axialTilt: 3.10, spinRate: -0.4, initialPhase: 1.1 },
+    { body: { name: 'earth', kind: 'earth' }, radius: 1.3, orbitRadius: 36, periodYears: 1.00, axialTilt: 0.41, spinRate: 1.0, initialPhase: 2.3 },
+    { body: { name: 'mars', kind: 'planet', type: 'mars' }, radius: 0.9, orbitRadius: 46, periodYears: 1.88, axialTilt: 0.44, spinRate: 0.97, initialPhase: 3.7 },
+    { body: { name: 'jupiter', kind: 'planet', type: 'jupiter' }, radius: 3.6, orbitRadius: 70, periodYears: 11.86, axialTilt: 0.05, spinRate: 2.4, initialPhase: 0.8 },
+    { body: { name: 'saturn', kind: 'planet', type: 'saturn' }, radius: 3.2, orbitRadius: 92, periodYears: 29.46, axialTilt: 0.47, spinRate: 2.2, initialPhase: 4.2 },
+    { body: { name: 'uranus', kind: 'planet', type: 'uranus' }, radius: 2.0, orbitRadius: 114, periodYears: 84.0, axialTilt: 1.71, spinRate: 1.4, initialPhase: 5.5 },
+    { body: { name: 'neptune', kind: 'planet', type: 'neptune' }, radius: 2.0, orbitRadius: 134, periodYears: 164.8, axialTilt: 0.49, spinRate: 1.5, initialPhase: 1.9 },
+];
+// Default: one Earth-year = 8 scene-seconds.
+const EARTH_YEAR_SECONDS = 8;
+const OrbitRing = ({ radius, color, opacity }) => {
+    const geometry = useMemo(() => {
+        const segments = 128;
+        const points = new Float32Array((segments + 1) * 3);
+        for (let i = 0; i <= segments; i++) {
+            const t = (i / segments) * Math.PI * 2;
+            points[i * 3 + 0] = Math.cos(t) * radius;
+            points[i * 3 + 1] = 0;
+            points[i * 3 + 2] = Math.sin(t) * radius;
+        }
+        const geom = new BufferGeometry();
+        geom.setAttribute('position', new BufferAttribute(points, 3));
+        return geom;
+    }, [radius]);
+    return (_jsx("lineLoop", { geometry: geometry, children: _jsx("lineBasicMaterial", { color: color, transparent: true, opacity: opacity, depthWrite: false }) }));
+};
+const OrbitedBody = ({ orbitRadius, orbitSpeed, spinSpeed, axialTilt, enableOrbit, enableSelfRotation, initialPhase, onWorldPositionChange, children, }) => {
+    const orbitRef = useRef(null);
+    const spinRef = useRef(null);
+    const worldPosRef = useRef(new Vector3());
+    useFrame((_, delta) => {
+        if (enableOrbit && orbitRef.current) {
+            orbitRef.current.rotation.y += delta * orbitSpeed;
+        }
+        if (enableSelfRotation && spinRef.current) {
+            spinRef.current.rotation.y += delta * spinSpeed;
+        }
+        if (onWorldPositionChange && spinRef.current) {
+            spinRef.current.getWorldPosition(worldPosRef.current);
+            onWorldPositionChange(worldPosRef.current);
+        }
+    });
+    return (_jsx("group", { ref: orbitRef, "rotation-y": initialPhase, children: _jsx("group", { position: [orbitRadius, 0, 0], "rotation-z": axialTilt, children: _jsx("group", { ref: spinRef, children: children }) }) }));
+};
+const SolarSystem = ({ enableOrbit = true, enableSelfRotation = true, showOrbitRings = true, orbitSpeedMultiplier = 1, sunColor = '#ffd27a', sunRadius = 8, sunIntensity = 3, orbitRingColor = '#444444', orbitRingOpacity = 0.35, }) => {
+    const [earthSunPos, setEarthSunPos] = useState([1, 0, 0]);
+    const lastEarthSyncRef = useRef(0);
+    const ref = useRef(null);
+    const handleEarthWorld = useCallback((p) => {
+        const now = performance.now();
+        if (now - lastEarthSyncRef.current < 100)
+            return;
+        lastEarthSyncRef.current = now;
+        setEarthSunPos([-p.x, -p.y, -p.z]);
+    }, []);
+    return (_jsxs("group", { userData: { id: '3drise-solar-system' }, ref: ref, children: [_jsx(Sun, { radius: sunRadius }), showOrbitRings &&
+                PLANETS.map((p) => (_jsx(OrbitRing, { radius: p.orbitRadius, color: orbitRingColor, opacity: orbitRingOpacity }, `ring-${p.body.name}`))), PLANETS.map((p) => {
+                const orbitSpeed = ((2 * Math.PI) / (p.periodYears * EARTH_YEAR_SECONDS)) * orbitSpeedMultiplier;
+                const spinSpeed = p.spinRate * orbitSpeedMultiplier;
+                if (p.body.kind === 'earth') {
+                    return (_jsx(OrbitedBody, { orbitRadius: p.orbitRadius, orbitSpeed: orbitSpeed, spinSpeed: spinSpeed, axialTilt: p.axialTilt, enableOrbit: enableOrbit, enableSelfRotation: enableSelfRotation, initialPhase: p.initialPhase, onWorldPositionChange: handleEarthWorld, children: _jsx(Earth, { radius: p.radius, sunPosition: earthSunPos, atmosphereDayColor: "#6db3f2", atmosphereTwilightColor: "#d97e54" }) }, "earth"));
+                }
+                return (_jsx(OrbitedBody, { orbitRadius: p.orbitRadius, orbitSpeed: orbitSpeed, spinSpeed: spinSpeed, axialTilt: p.axialTilt, enableOrbit: enableOrbit, enableSelfRotation: enableSelfRotation, initialPhase: p.initialPhase, children: _jsx(Planet, { type: p.body.type, scale: p.radius }) }, p.body.name));
+            })] }));
+};
+SolarSystem.displayName = 'SolarSystem';
+export default SolarSystem;

package/dist/components/SparklesBurst.d.ts

@@ -0,0 +1,9 @@
+import type { SparklesBurstConfig } from '@3driseai/3drise-core';
+import React from "react";
+export interface SparklesBurstProps {
+    config: SparklesBurstConfig;
+    boundingRadius?: number;
+}
+declare const SparklesBurst: React.FC<SparklesBurstProps>;
+export default SparklesBurst;
+//# sourceMappingURL=SparklesBurst.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SparklesBurst.d.ts","sourceRoot":"","sources":["../../src/components/SparklesBurst.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AACjE,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,MAAM,WAAW,kBAAkB;IAC/B,MAAM,EAAE,mBAAmB,CAAC;IAC5B,cAAc,CAAC,EAAE,MAAM,CAAC;CAC3B;AAGD,QAAA,MAAM,aAAa,EAAE,KAAK,CAAC,EAAE,CAAC,kBAAkB,CAuD/C,CAAC;AACF,eAAe,aAAa,CAAC"}

package/dist/components/SparklesBurst.js

@@ -0,0 +1,62 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useMemo, useRef } from 'react';
+import { useFrame } from '@react-three/fiber';
+import * as THREE from 'three';
+import { SparklesBurstMaterial } from '@3driseai/3drise-core';
+const SparklesBurst = ({ config, boundingRadius }) => {
+    // console.log("Rendering SparklesBurst with config:", config, "and boundingRadius:", boundingRadius);
+    const planeSize = useMemo(() => Math.max(0.05, config.scale ?? 2.5), [config.scale]);
+    const geometry = useMemo(() => new THREE.PlaneGeometry(planeSize, planeSize, 1, 1), [planeSize]);
+    const material = useMemo(() => {
+        const m = new SparklesBurstMaterial();
+        m.transparent = true;
+        m.depthWrite = false;
+        m.side = THREE.DoubleSide;
+        m.blending = THREE.AdditiveBlending;
+        return m;
+    }, []);
+    useEffect(() => {
+        const u = material.uniforms;
+        u.uCoreColor.value.set(config.coreColor ?? '#ffffff');
+        u.uBurstColor.value.set(config.burstColor ?? '#ffaa00');
+        u.uRayCount.value = Math.max(3, config.rayCount ?? 8);
+        u.uIntensity.value = config.intensity ?? 1.0;
+        u.uOpacity.value = config.opacity ?? 1.0;
+        u.uHoverColor.value.set(config.hoverColor ?? '#ffffff');
+        u.uHoverRadius.value = config.hoverRadius ?? 0.3;
+        u.uHoverIntensity.value = config.hoverIntensity ?? 0.0;
+    }, [
+        config.coreColor,
+        config.burstColor,
+        config.rayCount,
+        config.intensity,
+        config.opacity,
+        config.hoverColor,
+        config.hoverRadius,
+        config.hoverIntensity,
+        material,
+    ]);
+    useEffect(() => () => { geometry.dispose(); material.dispose(); }, [geometry, material]);
+    // Track elapsed time JS-side so loop on/off toggles cleanly without
+    // depending on the global clock for the progress phase.
+    const startRef = useRef(null);
+    // Reset start when loop toggles so behaviour is predictable.
+    useEffect(() => { startRef.current = null; }, [config.loop, config.durationMs]);
+    useFrame((state) => {
+        const now = state.clock.getElapsedTime();
+        if (startRef.current === null)
+            startRef.current = now;
+        const elapsedMs = (now - startRef.current) * 1000;
+        const duration = Math.max(1, config.durationMs ?? 1500);
+        const loop = config.loop ?? true;
+        const progress = loop
+            ? (elapsedMs % duration) / duration
+            : Math.min(elapsedMs / duration, 1);
+        material.uniforms.uProgress.value = progress;
+        material.uniforms.uTime.value = now;
+    });
+    if (!config.enabled)
+        return null;
+    return _jsx("mesh", { geometry: geometry, material: material, frustumCulled: false });
+};
+export default SparklesBurst;

package/dist/components/Stars.d.ts

@@ -0,0 +1,15 @@
+import { BufferGeometry } from 'three';
+import type { Object3D } from 'three';
+import React from "react";
+import type { CreatedObjectSettings } from "@3driseai/3drise-core";
+import type { TimeSettings } from "@3driseai/3drise-core";
+export interface StarsProps {
+    settings: CreatedObjectSettings;
+    timeSettings?: TimeSettings;
+    sunSystemEnabled?: boolean;
+    onObjectReady?: (object: CreatedObjectSettings, ref: Object3D) => void;
+}
+export declare function generateStarsGeometry(count: number): BufferGeometry;
+declare const Stars: React.FC<StarsProps>;
+export default Stars;
+//# sourceMappingURL=Stars.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Stars.d.ts","sourceRoot":"","sources":["../../src/components/Stars.tsx"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAA4C,MAAM,OAAO,CAAC;AACjF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAOtC,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AACnE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAC1D,MAAM,WAAW,UAAU;IACvB,QAAQ,EAAE,qBAAqB,CAAC;IAChC,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,aAAa,CAAC,EAAE,CAAC,MAAM,EAAE,qBAAqB,EAAE,GAAG,EAAE,QAAQ,KAAK,IAAI,CAAC;CAC1E;AAOD,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,CAuDnE;AAYD,QAAA,MAAM,KAAK,EAAE,KAAK,CAAC,EAAE,CAAC,UAAU,CAwK/B,CAAC;AACF,eAAe,KAAK,CAAC"}

package/dist/components/Stars.js

@@ -0,0 +1,250 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useRef, useMemo, useCallback, useState, useEffect } from 'react';
+import { BufferGeometry, BufferAttribute, AdditiveBlending, Color } from 'three';
+import { useFrame } from '@react-three/fiber';
+import { useSkySystem } from '../hooks/useSkySystem.js';
+import { useParticlesColors } from '../hooks/useParticlesColors.js';
+import { useAnimationEvents } from '../hooks/useAnimationEvents.js';
+import { useNumericAnimation } from '../hooks/useNumericAnimation.js';
+import { useMouseHandlers } from '../hooks/useMouseHandlers.js';
+const STARS_SHADER_UNIFORM_MAP = {
+    color: 'uColor',
+    opacity: 'opacity',
+};
+export function generateStarsGeometry(count) {
+    const halfCount = Math.floor(count / 2);
+    const geometry = new BufferGeometry();
+    const topPositions = new Float32Array(halfCount * 3);
+    for (let i = 0; i < halfCount; i++) {
+        const u = Math.random();
+        const v = Math.random() * 0.5 + 0.5;
+        const theta = 2 * Math.PI * u;
+        const phi = Math.acos(2 * v - 1);
+        topPositions.set([
+            Math.sin(phi) * Math.cos(theta),
+            Math.cos(phi),
+            Math.sin(phi) * Math.sin(theta),
+        ], i * 3);
+    }
+    const positions = new Float32Array(halfCount * 6);
+    positions.set(topPositions, 0);
+    for (let i = 0; i < halfCount; i++) {
+        positions.set([topPositions[i * 3], -topPositions[i * 3 + 1], topPositions[i * 3 + 2]], (i + halfCount) * 3);
+    }
+    const colors = new Float32Array(halfCount * 3);
+    for (let i = 0; i < halfCount; i++) {
+        const v = Math.random();
+        const c = v < 0.15 ? [0.8, 0.85, 1.0] : v < 0.3 ? [1.0, 0.95, 0.8] : [1.0, 1.0, 1.0];
+        colors.set(c, i * 3);
+    }
+    const mirroredColors = new Float32Array(halfCount * 6);
+    mirroredColors.set(colors, 0);
+    mirroredColors.set(colors, colors.length);
+    const sizes = new Float32Array(halfCount);
+    for (let i = 0; i < halfCount; i++) {
+        const v = Math.random();
+        sizes[i] = v < 0.01 ? 40 + Math.random() * 20 : v < 0.05 ? 25 + Math.random() * 15 : v < 0.2 ? 15 + Math.random() * 10 : 5 + Math.random() * 5;
+    }
+    const mirroredSizes = new Float32Array(halfCount * 2);
+    mirroredSizes.set(sizes, 0);
+    mirroredSizes.set(sizes, sizes.length);
+    const phases = new Float32Array(halfCount);
+    for (let i = 0; i < halfCount; i++)
+        phases[i] = Math.random() * Math.PI * 2;
+    const mirroredPhases = new Float32Array(halfCount * 2);
+    mirroredPhases.set(phases, 0);
+    mirroredPhases.set(phases, phases.length);
+    const freqs = new Float32Array(halfCount);
+    for (let i = 0; i < halfCount; i++)
+        freqs[i] = 1.0 + Math.random() * 2.0;
+    const mirroredFreqs = new Float32Array(halfCount * 2);
+    mirroredFreqs.set(freqs, 0);
+    mirroredFreqs.set(freqs, freqs.length);
+    geometry.setAttribute('position', new BufferAttribute(positions, 3));
+    geometry.setAttribute('color', new BufferAttribute(mirroredColors, 3));
+    geometry.setAttribute('size', new BufferAttribute(mirroredSizes, 1));
+    geometry.setAttribute('phase', new BufferAttribute(mirroredPhases, 1));
+    geometry.setAttribute('freq', new BufferAttribute(mirroredFreqs, 1));
+    return geometry;
+}
+// Module-scoped so the reference is stable across renders. A new object per
+// render would make useSkySystem's [timeSettings] effect re-fire on every
+// Stars re-render (its useFrame calls setIsVisible), stomping
+// skySystemManager.enabled back to false between parent ticks.
+const DEFAULT_TIME_SETTINGS = {
+    enabled: false,
+    timeOfDay: 12,
+    timescale: 60,
+    autoAnimate: false,
+    syncWithRealTime: false,
+};
+const Stars = ({ settings, timeSettings, sunSystemEnabled = false, onObjectReady }) => {
+    const pointsRef = useRef(null);
+    const materialRef = useRef(null);
+    const { meshSettings, config, animations, mouseMove } = settings;
+    const { position, rotation, scale, visible } = meshSettings;
+    const { count = 1000, color = '#ffffff', opacity = 1, rotateSpeed } = config;
+    const opacityRef = useRef(1);
+    const targetOpacityRef = useRef(1);
+    const [isVisible, setIsVisible] = useState(true);
+    const [visibleOverride, setVisibleOverride] = useState(null);
+    const numericOverrideRef = useRef(null);
+    const mouseOverrideRef = useRef({});
+    const { interpolateProperty } = useMouseHandlers();
+    const [animatedTransform, setAnimatedTransform] = useState({
+        position, rotation, scale, targetPosition: position, targetRotation: rotation, targetScale: scale,
+    });
+    const [duration, setDuration] = useState(1);
+    const [colors, setColors] = useState({ baseColor: color, targetColor: color });
+    const { baseColorRef, targetColorRef, colorAnimationProgress } = useParticlesColors({
+        color: colors.baseColor,
+        targetColor: colors.targetColor,
+    });
+    const geometry = useMemo(() => generateStarsGeometry(count), [count]);
+    useEffect(() => {
+        onObjectReady && onObjectReady(settings, pointsRef.current);
+        return () => { geometry.dispose(); };
+    }, [geometry]);
+    useEffect(() => {
+        setAnimatedTransform({ position, rotation, scale });
+    }, [position, rotation, scale]);
+    useEffect(() => {
+        setColors(prev => ({ ...prev, baseColor: color, targetColor: color }));
+    }, [color]);
+    useEffect(() => {
+        if (!sunSystemEnabled) {
+            setIsVisible(true);
+            opacityRef.current = 1;
+            targetOpacityRef.current = 1;
+        }
+    }, [sunSystemEnabled]);
+    const { animateNumeric } = useNumericAnimation();
+    useAnimationEvents({
+        onStepStart: (event) => {
+            if (!event.step?.transitions)
+                return;
+            for (const transition of event.step.transitions) {
+                if (transition.state !== 'stars' && !pointsRef.current)
+                    continue;
+                const toProps = transition.properties.to || {};
+                const fromProps = transition.properties.from || {};
+                // visible — immediate boolean switch
+                if (toProps.visible !== undefined && pointsRef.current) {
+                    // setVisibleOverride(toProps.visible);
+                    pointsRef.current.visible = toProps.visible;
+                }
+                // color — existing path
+                setDuration(event.step.duration);
+                if (toProps.color !== undefined) {
+                    setColors({
+                        baseColor: fromProps.color,
+                        targetColor: toProps.color,
+                    });
+                }
+                // numeric: rotateSpeed, size
+                const STARS_NUMERIC_KEYS = ['rotateSpeed', 'size'];
+                const from = {};
+                const to = {};
+                for (const key of STARS_NUMERIC_KEYS) {
+                    const toVal = toProps[key];
+                    if (toVal === undefined)
+                        continue;
+                    to[key] = toVal;
+                    from[key] = fromProps[key] ?? settings[key] ?? toVal;
+                }
+                if (Object.keys(to).length > 0) {
+                    animateNumeric(from, to, (updated) => {
+                        numericOverrideRef.current = { ...numericOverrideRef.current, ...updated };
+                    }, () => {
+                        numericOverrideRef.current = null;
+                        // setVisibleOverride(null);
+                    }, event.step?.duration);
+                }
+            }
+        },
+    });
+    const handleTimeUpdate = useCallback((state) => {
+        const { normalizedTime, isDaytime, elapsedTime, delta, autoAnimate } = state;
+        if (!autoAnimate || !sunSystemEnabled)
+            return;
+        if (!isDaytime) {
+            targetOpacityRef.current = 1;
+        }
+        else {
+            const sunriseEnd = 0.15;
+            const sunsetStart = 0.85;
+            if (normalizedTime <= sunriseEnd) {
+                targetOpacityRef.current = 1 - normalizedTime / sunriseEnd;
+            }
+            else if (normalizedTime >= sunsetStart) {
+                targetOpacityRef.current = (normalizedTime - sunsetStart) / (1 - sunsetStart);
+            }
+            else {
+                targetOpacityRef.current = 0;
+            }
+        }
+        const opacityLerpSpeed = Math.min(1, 1.5 * (delta !== 0 ? delta : 1));
+        opacityRef.current += (targetOpacityRef.current - opacityRef.current) * opacityLerpSpeed;
+        const shouldBeVisible = opacityRef.current > 0.01;
+        if (shouldBeVisible !== isVisible)
+            setIsVisible(shouldBeVisible);
+        if (materialRef.current) {
+            materialRef.current.uTime = elapsedTime;
+            materialRef.current.uOpacity = opacityRef.current;
+        }
+    }, [isVisible, sunSystemEnabled]);
+    useSkySystem({
+        timeSettings: timeSettings ?? DEFAULT_TIME_SETTINGS,
+        onTimeUpdate: handleTimeUpdate,
+        enabled: sunSystemEnabled && !!timeSettings,
+    });
+    const speed = 1 / duration;
+    const handleMouseMove = (mouse) => {
+        // if (!handlers?.onMouseMove?.enabled) return;
+        // if (!handlers.onMouseMove.properties.length) return;
+        // if (!materialRef.current || !pointsRef.current) return;
+        // handlers.onMouseMove.properties.forEach((cfg: any) => {
+        //   const { property, propertySettings } = cfg;
+        //   const { min: minValue, max: maxValue, axis, sensitivity = 1, inverted = false } = propertySettings;
+        //   const baseValue = (settings as any)[property];
+        //   if (baseValue === undefined) return;
+        //   const interpolated = interpolateProperty(
+        //     baseValue, minValue, maxValue, mouse, axis, sensitivity, inverted,
+        //   );
+        //   const uniformName = STARS_SHADER_UNIFORM_MAP[property];
+        //   if (uniformName) {
+        //     applySingleProperty(materialRef.current, uniformName, interpolated);
+        //     return;
+        //   }
+        //   if (property === 'rotateSpeed' || property === 'size') {
+        //     const key: 'rotateSpeed' | 'size' = property;
+        //     mouseOverrideRef.current[key] = interpolated as number;
+        //   }
+        // });
+    };
+    useFrame((state, delta) => {
+        if (!pointsRef.current)
+            return;
+        if (pointsRef.current.visible === false)
+            return;
+        const effectiveRotateSpeed = numericOverrideRef.current?.rotateSpeed
+            ?? mouseOverrideRef.current.rotateSpeed
+            ?? rotateSpeed;
+        pointsRef.current.rotation.y += effectiveRotateSpeed * 0.01;
+        const effectiveSize = numericOverrideRef.current?.size
+            ?? mouseOverrideRef.current.size;
+        if (effectiveSize !== undefined && materialRef.current) {
+            materialRef.current.size = effectiveSize;
+        }
+        if (materialRef.current && colors.targetColor !== colors.baseColor) {
+            colorAnimationProgress.current = Math.min(1, colorAnimationProgress.current + (delta || 1) * speed);
+            materialRef.current.colorMix = colorAnimationProgress.current;
+            materialRef.current.uColor = baseColorRef.current;
+            materialRef.current.targetColor = targetColorRef.current;
+        }
+        handleMouseMove(state.pointer);
+    });
+    // if (!(visibleOverride ?? visible) || !isVisible) return null;
+    return (_jsx("points", { ref: pointsRef, geometry: geometry, scale: typeof scale === 'number' ? scale : scale[0], renderOrder: -1, frustumCulled: false, userData: { id: '3drise-stars' }, visible: visible, children: _jsx("starsMaterial", { ref: materialRef, transparent: true, depthWrite: false, depthTest: true, blending: AdditiveBlending, uColor: new Color(color), uOpacity: opacity, targetColor: new Color(colors.targetColor), colorMix: 0 }) }));
+};
+export default Stars;

package/dist/components/Sun.d.ts

@@ -0,0 +1,15 @@
+type SunProps = {
+    /** Radius of the sun core. Default 1. */
+    radius?: number;
+    /** Corona shell size relative to the core. Default 1.25. */
+    coronaScale?: number;
+    /** Uniform overrides for SunCoreMaterial. */
+    coreUniforms?: Record<string, any>;
+    /** Uniform overrides for SunCoronaMaterial. */
+    coronaUniforms?: Record<string, any>;
+    /** Uniform overrides for SunFlareMaterial. */
+    flareUniforms?: Record<string, any>;
+};
+export default function Sun({ radius, coronaScale, coreUniforms, coronaUniforms, flareUniforms, }: SunProps): import("react").JSX.Element;
+export {};
+//# sourceMappingURL=Sun.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Sun.d.ts","sourceRoot":"","sources":["../../src/components/Sun.tsx"],"names":[],"mappings":"AAGA,KAAK,QAAQ,GAAG;IACZ,yCAAyC;IACzC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,4DAA4D;IAC5D,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,6CAA6C;IAC7C,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IACnC,+CAA+C;IAC/C,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IACrC,8CAA8C;IAC9C,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CACvC,CAAC;AAEF,MAAM,CAAC,OAAO,UAAU,GAAG,CAAC,EAAE,MAAU,EAAE,WAAkB,EAAE,YAAY,EAAE,cAAc,EAAE,aAAa,GAAG,EAAE,QAAQ,+BAErH"}

package/dist/components/Sun.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// import { ReactNode } from "react";
+import SunCore from "./SunCore.js";
+import Corona from "./Corona.js";
+export default function Sun({ radius = 1, coronaScale = 1.25, coreUniforms, coronaUniforms, flareUniforms, }) {
+    return (_jsxs("group", { children: [_jsx(SunCore, { radius: radius, uniforms: coreUniforms }), _jsx(Corona, { radius: radius, shellScale: coronaScale, uniforms: coronaUniforms }), _jsx("pointLight", { color: "#ffa544", intensity: 6, distance: 60, decay: 1.6 })] }));
+}

package/dist/components/SunCore.d.ts

@@ -0,0 +1,18 @@
+import type * as THREE from "three";
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            sunCoreMaterial: any;
+        }
+    }
+}
+export type SunCoreProps = {
+    /** Radius of the core. Default 1. */
+    radius?: number;
+    /** Self-rotation speed in rad/s. Default 0.02. */
+    rotationSpeed?: number;
+    /** Uniform overrides for SunCoreMaterial (u_speed, u_cellScale, u_color1..5, ...). */
+    uniforms?: Record<string, number | THREE.Vector3 | number[]>;
+};
+export default function SunCore({ radius, rotationSpeed, uniforms }: SunCoreProps): import("react").JSX.Element;
+//# sourceMappingURL=SunCore.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SunCore.d.ts","sourceRoot":"","sources":["../../src/components/SunCore.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAC;AAGpC,OAAO,CAAC,MAAM,CAAC;IACX,UAAU,GAAG,CAAC;QACV,UAAU,iBAAiB;YACvB,eAAe,EAAE,GAAG,CAAC;SACxB;KACJ;CACJ;AAED,MAAM,MAAM,YAAY,GAAG;IACvB,qCAAqC;IACrC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,kDAAkD;IAClD,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,sFAAsF;IACtF,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,KAAK,CAAC,OAAO,GAAG,MAAM,EAAE,CAAC,CAAC;CAChE,CAAC;AAEF,MAAM,CAAC,OAAO,UAAU,OAAO,CAAC,EAAE,MAAU,EAAE,aAAoB,EAAE,QAAQ,EAAE,EAAE,YAAY,+BAU3F"}

package/dist/components/SunCore.js

@@ -0,0 +1,14 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useRef } from "react";
+import { useFrame } from "@react-three/fiber";
+export default function SunCore({ radius = 1, rotationSpeed = 0.02, uniforms }) {
+    const meshRef = useRef(null);
+    // drei's shaderMaterial exposes each uniform as a property on the instance.
+    const matRef = useRef(null);
+    useFrame((_, delta) => {
+        if (matRef.current)
+            matRef.current.u_time += delta;
+        // if (meshRef.current) meshRef.current.rotation.y += delta * rotationSpeed;
+    });
+    return (_jsxs("mesh", { ref: meshRef, scale: radius, children: [_jsx("icosahedronGeometry", { args: [1, 64] }), _jsx("lavaMaterial", { ref: matRef, ...uniforms })] }));
+}

package/dist/components/SunLight.d.ts

@@ -0,0 +1,15 @@
+import * as THREE from 'three';
+import React from "react";
+import type { TimeSettings } from "@3driseai/3drise-core";
+export interface SunLightProps {
+    visible?: boolean;
+    timeSettings: TimeSettings;
+    targetPosition?: THREE.Vector3;
+    shadowDistance?: number;
+    intensity?: number;
+    castShadow?: boolean;
+    shadowMapSize?: number;
+}
+declare const SunLight: React.FC<SunLightProps>;
+export default SunLight;
+//# sourceMappingURL=SunLight.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SunLight.d.ts","sourceRoot":"","sources":["../../src/components/SunLight.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAC1D,MAAM,WAAW,aAAa;IAC1B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,YAAY,EAAE,YAAY,CAAC;IAC3B,cAAc,CAAC,EAAE,KAAK,CAAC,OAAO,CAAC;IAC/B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,CAAC;CAC1B;AAaD,QAAA,MAAM,QAAQ,EAAE,KAAK,CAAC,EAAE,CAAC,aAAa,CAyCrC,CAAC;AACF,eAAe,QAAQ,CAAC"}

package/dist/components/SunLight.js

@@ -0,0 +1,57 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useRef, useCallback } from 'react';
+import * as THREE from 'three';
+import { useSkySystem } from '../hooks/useSkySystem.js';
+const COLORS = {
+    white: new THREE.Color(0xffffff),
+    orange: new THREE.Color(0xff4500),
+    moon: new THREE.Color(0xe6e8fa),
+};
+const MAX_ELEVATION = 42;
+const SUNRISE = 6;
+const SUNSET = 21;
+const DARKNESS_START = 20.42;
+const DARKNESS_END = 6.58;
+const SunLight = ({ visible = true, timeSettings, targetPosition = new THREE.Vector3(0, 0, 0), shadowDistance = 300, intensity: intensityMultiplier = 1, castShadow = true, shadowMapSize = 2048, }) => {
+    const lightRef = useRef(null);
+    const colorRef = useRef(new THREE.Color(0xffe5b0));
+    const targetColorRef = useRef(new THREE.Color(0xffe5b0));
+    const intensityRef = useRef(1);
+    const targetIntensityRef = useRef(1);
+    const handleTimeUpdate = useCallback((state) => {
+        const { timeInHours, normalizedTime, isDaytime, sunDirection, sunElevation } = state;
+        const isInDarkTransition = (timeInHours >= DARKNESS_START && timeInHours <= SUNSET) ||
+            (timeInHours >= SUNRISE && timeInHours <= DARKNESS_END);
+        if (isDaytime) {
+            const normalizedElevation = Math.min(sunElevation / MAX_ELEVATION, 1);
+            const t = Math.pow(1 - normalizedElevation, 3);
+            targetColorRef.current.lerpColors(COLORS.white, COLORS.orange, t);
+            targetIntensityRef.current = isInDarkTransition
+                ? 0.1
+                : Math.min(40, Math.pow(normalizedElevation, 1.2) * 4);
+        }
+        else {
+            targetColorRef.current.copy(COLORS.moon).multiplyScalar(1.8);
+            targetIntensityRef.current = 0.5;
+        }
+        const lerpSpeed = Math.min(1, 2.0 * (state.delta || 1));
+        colorRef.current.lerp(targetColorRef.current, lerpSpeed);
+        intensityRef.current += (targetIntensityRef.current - intensityRef.current) * lerpSpeed;
+        if (lightRef.current) {
+            lightRef.current.position.set(targetPosition.x + sunDirection.x * shadowDistance, targetPosition.y + sunDirection.y * shadowDistance, targetPosition.z + sunDirection.z * shadowDistance);
+            lightRef.current.target.position.copy(targetPosition);
+            lightRef.current.target.updateMatrixWorld();
+            lightRef.current.intensity = intensityRef.current * intensityMultiplier;
+            lightRef.current.color.copy(colorRef.current);
+        }
+    }, [targetPosition, shadowDistance, intensityMultiplier]);
+    useSkySystem({
+        timeSettings,
+        onTimeUpdate: handleTimeUpdate,
+        enabled: visible,
+    });
+    if (!visible)
+        return null;
+    return (_jsx("directionalLight", { ref: lightRef, castShadow: castShadow, "shadow-mapSize-width": shadowMapSize, "shadow-mapSize-height": shadowMapSize, "shadow-camera-left": -50, "shadow-camera-right": 50, "shadow-camera-top": 50, "shadow-camera-bottom": -50, "shadow-camera-near": 0.5, "shadow-camera-far": 1000, "shadow-normalBias": 0.02, "shadow-bias": 0.000002, "shadow-radius": 2 }));
+};
+export default SunLight;

package/dist/components/Text2D.d.ts

@@ -0,0 +1,9 @@
+import type { TextSettings } from '@3driseai/3drise-core';
+import React from "react";
+export interface Text2DProps {
+    textSettings: TextSettings;
+    onTextClick?: (textSettings: TextSettings) => void;
+}
+declare const Text2D: React.FC<Text2DProps>;
+export default Text2D;
+//# sourceMappingURL=Text2D.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Text2D.d.ts","sourceRoot":"","sources":["../../src/components/Text2D.tsx"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAE1D,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,MAAM,WAAW,WAAW;IACxB,YAAY,EAAE,YAAY,CAAC;IAC3B,WAAW,CAAC,EAAE,CAAC,YAAY,EAAE,YAAY,KAAK,IAAI,CAAC;CACtD;AAGD,QAAA,MAAM,MAAM,EAAE,KAAK,CAAC,EAAE,CAAC,WAAW,CA+CjC,CAAC;AACF,eAAe,MAAM,CAAC"}

package/dist/components/Text2D.js

@@ -0,0 +1,56 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useRef, useState, useCallback, useMemo } from 'react';
+import { useFrame } from '@react-three/fiber';
+import { Text, useCursor } from '@react-three/drei';
+import { createDefaultEffectState, applyTransformEffects } from '@3driseai/3drise-core';
+import { fontManager } from '@3driseai/3drise-core';
+import { getTextEffectProps } from '../utils/textEffects.js';
+const Text2D = ({ textSettings, onTextClick }) => {
+    const groupRef = useRef(null);
+    const textRef = useRef(null);
+    const [hovered, setHovered] = useState(false);
+    const [clicked, setClicked] = useState(false);
+    const effectStateRef = useRef(null);
+    const { config, materialSettings } = textSettings;
+    const text2DConfig = config;
+    const { text } = text2DConfig;
+    const { fontSize = 0.5, lineHeight = 1.2, letterSpacing = 0, textAlign = 'center', anchorX = 'center', anchorY = 'middle', font, maxWidth, } = text2DConfig;
+    const fontInfo = font ? fontManager.getFont(font) : null;
+    const fontUrl = fontInfo?.googleFont;
+    const color = 'color' in materialSettings ? materialSettings.color : '#ffffff';
+    const opacity = 'opacity' in materialSettings ? materialSettings.opacity : 1;
+    const transformEffects = textSettings.animations?.transform?.effects || [];
+    const defaultHoverSettings = { sensitivity: 0.5, applyToChildren: true };
+    const { sensitivity = 0.5 } = defaultHoverSettings;
+    useCursor(hovered);
+    const handlePointerEnter = useCallback((e) => {
+        e.stopPropagation();
+        setHovered(true);
+    }, []);
+    const handlePointerLeave = useCallback(() => {
+        setHovered(false);
+    }, []);
+    const handleClick = useCallback((e) => {
+        e.stopPropagation();
+        onTextClick?.(textSettings);
+    }, [onTextClick, textSettings]);
+    useFrame((state, dt) => {
+        if (!groupRef.current)
+            return;
+        const time = state.clock.elapsedTime;
+        if (!effectStateRef.current) {
+            effectStateRef.current = createDefaultEffectState(groupRef.current);
+        }
+        if (transformEffects.length > 0) {
+            const enabledEffects = transformEffects.filter(e => e.enabled !== false);
+            if (enabledEffects.length > 0) {
+                applyTransformEffects(groupRef.current, enabledEffects, time, dt, effectStateRef.current, hovered, clicked, sensitivity);
+            }
+        }
+    });
+    const hasFadeEffect = transformEffects.some(e => e.type === 'fade' && e.enabled !== false);
+    const finalOpacity = hasFadeEffect ? opacity : opacity;
+    const effectProps = useMemo(() => getTextEffectProps([]), []);
+    return (_jsx("group", { ref: groupRef, name: `text2d-${textSettings.name}`, userData: { textSettings }, children: _jsx(Text, { ref: textRef, fontSize: fontSize, color: color, maxWidth: maxWidth, lineHeight: lineHeight, letterSpacing: letterSpacing, textAlign: textAlign, anchorX: anchorX, anchorY: anchorY, font: fontUrl || undefined, fillOpacity: finalOpacity, onPointerEnter: handlePointerEnter, onPointerLeave: handlePointerLeave, onClick: handleClick, ...effectProps, children: text }) }));
+};
+export default Text2D;