@3driseai/3drise-viewer 0.1.27 → 0.1.29

package/dist/components/space/ShootingStar.js

@@ -0,0 +1,101 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useObjectReady } from '../../hooks/useObjectReady.js';
+import { useRef, useMemo, useEffect } from 'react';
+import { useFrame } from '@react-three/fiber';
+import { Vector3, BufferGeometry, BufferAttribute, AdditiveBlending } from 'three';
+import { ShootingStarMaterial } from '@3driseai/3drise-core';
+const ShootingStar = ({ position = [0, 0, 0], direction = [1, -1, 0], speed = 0.05, color = '#ffffff', colorRef, trailLength = 30, size = 0.1, opacity = 1.0, onComplete, maxDistance = 50, followMouse = true, onObjectReady, onObjectDispose, }) => {
+    const starRef = useRef(null);
+    const rootRef = useRef(null);
+    useObjectReady(rootRef, { position, direction, speed, color, size, opacity, maxDistance, followMouse }, onObjectReady, onObjectDispose);
+    const glowRef = useRef(null);
+    const trailRef = useRef(null);
+    // One trail material per meteor (it was re-created on every render and never faded).
+    const trailMaterial = useMemo(() => new ShootingStarMaterial(), []);
+    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();
+            starMaterialRef.current?.dispose();
+            glowMaterialRef.current?.dispose();
+        };
+    }, [trailGeometry]);
+    useEffect(() => () => trailMaterial.dispose(), [trailMaterial]);
+    useFrame((state, delta) => {
+        if (!trailRef.current || !starRef.current)
+            return;
+        if (colorRef) {
+            const c = colorRef.current;
+            starMaterialRef.current?.color.copy(c);
+            glowMaterialRef.current?.color.copy(c);
+            trailMaterial.color.copy(c);
+        }
+        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;
+        trailMaterial.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", { ref: rootRef, children: [_jsx("lineSegments", { ref: trailRef, geometry: trailGeometry, children: _jsx("primitive", { object: trailMaterial, attach: "material", transparent: true, blending: AdditiveBlending, depthWrite: false }) }), _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/space/ShootingStars.d.ts

@@ -0,0 +1,16 @@
+import type { ObjectReadyProps } from '../../types/objectReady';
+import type { AnimationOptions, MouseMoveDomain, ShootingStarsSpaceConfig } from '@3driseai/3drise-core';
+import React from "react";
+export interface ShootingStarsProps extends ObjectReadyProps {
+    /** The object's config (config.type 'shootingStars'); missing keys fall back to DEFAULT_SPACE_OBJECTS.shootingStars. */
+    config?: Partial<ShootingStarsSpaceConfig>;
+    /** Scene object id: the live-edit handle is found by it. */
+    id?: string;
+    /** Keyframes on the config knobs (animations.space.animations). */
+    keyframes?: AnimationOptions[];
+    /** Pointer bindings on the config knobs (mouseMove.space). */
+    mouseMove?: MouseMoveDomain;
+}
+declare const ShootingStars: React.FC<ShootingStarsProps>;
+export default ShootingStars;
+//# sourceMappingURL=ShootingStars.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ShootingStars.d.ts","sourceRoot":"","sources":["../../../src/components/space/ShootingStars.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAMhE,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAyB,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAIhI,OAAO,KAAK,MAAM,OAAO,CAAC;AAgB1B,MAAM,WAAW,kBAAmB,SAAQ,gBAAgB;IACxD,wHAAwH;IACxH,MAAM,CAAC,EAAE,OAAO,CAAC,wBAAwB,CAAC,CAAC;IAC3C,4DAA4D;IAC5D,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,mEAAmE;IACnE,SAAS,CAAC,EAAE,gBAAgB,EAAE,CAAC;IAC/B,8DAA8D;IAC9D,SAAS,CAAC,EAAE,eAAe,CAAC;CAC/B;AAED,QAAA,MAAM,aAAa,EAAE,KAAK,CAAC,EAAE,CAAC,kBAAkB,CA+C/C,CAAC;AACF,eAAe,aAAa,CAAC"}

package/dist/components/space/ShootingStars.js

@@ -0,0 +1,71 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useObjectReady } from '../../hooks/useObjectReady.js';
+import { useRef, useState, useEffect, useCallback, useMemo, useLayoutEffect } from 'react';
+import { Color } from 'three';
+import { generateShootingStar, generateShootingStars, DEFAULT_SPACE_OBJECTS, SPACE_OBJECTS_ANIMATABLE } from '@3driseai/3drise-core';
+import { useConfigDriver } from '../../hooks/useConfigDriver.js';
+import { withConfigDefaults } from '../../utils/configAnimations.js';
+import ShootingStar from './ShootingStar.js';
+// =============================================================================
+// ShootingStars — meteors relaunched after a random pause (space object 'shootingStars')
+// =============================================================================
+//
+// count / ranges are committed values (a new count regenerates the meteors). The
+// colour reaches every meteor only through `push`, the one door live drag,
+// keyframes (animations.space) and pointer bindings (mouseMove.space) go through:
+// it writes one shared Color the meteors copy into their materials each frame.
+//
+const DEFAULTS = DEFAULT_SPACE_OBJECTS.shootingStars;
+const STRUCTURAL = ['count'];
+const ANIMATABLE = new Set(SPACE_OBJECTS_ANIMATABLE.shootingStars.map((p) => p.value));
+const ShootingStars = ({ config, id, keyframes, mouseMove, onObjectReady, onObjectDispose }) => {
+    const rootRef = useRef(null);
+    const cfg = useMemo(() => withConfigDefaults(DEFAULTS, config), [config]);
+    const gen = cfg;
+    useObjectReady(rootRef, cfg, onObjectReady, onObjectDispose);
+    const [shootingStars, setShootingStars] = useState(() => (cfg.enabled ? generateShootingStars(cfg.count, gen) : []));
+    const nextIdRef = useRef(cfg.count || 0);
+    const cfgRef = useRef(cfg);
+    useEffect(() => { cfgRef.current = cfg; }, [cfg]);
+    // Relaunch timers, cleared when the meteors are regenerated or the object goes.
+    const timers = useRef(new Set());
+    const clearTimers = useCallback(() => { for (const t of timers.current)
+        clearTimeout(t); timers.current.clear(); }, []);
+    useEffect(() => clearTimers, [clearTimers]);
+    useEffect(() => {
+        clearTimers();
+        if (cfg.enabled) {
+            setShootingStars(generateShootingStars(cfg.count, gen));
+            nextIdRef.current = cfg.count;
+        }
+        else
+            setShootingStars([]);
+    }, [cfg.enabled, cfg.count]); // eslint-disable-line react-hooks/exhaustive-deps
+    const handleComplete = useCallback((starId) => {
+        setShootingStars(prev => prev.filter(star => star.id !== starId));
+        const [lo, hi] = cfgRef.current.intervalRange ?? [0, 0];
+        const delay = Math.max(0, lo + Math.random() * Math.max(0, hi - lo));
+        const t = setTimeout(() => {
+            timers.current.delete(t);
+            const c = cfgRef.current;
+            if (!c.enabled)
+                return;
+            setShootingStars(prev => prev.length >= c.count ? prev : [...prev, generateShootingStar(nextIdRef.current++, c)]);
+        }, delay * 1000);
+        timers.current.add(t);
+    }, []);
+    const colorRef = useRef(new Color(cfg.color));
+    const push = useCallback((m) => {
+        const c = m.color;
+        if (c === undefined)
+            return;
+        if (c?.isColor)
+            colorRef.current.copy(c);
+        else
+            colorRef.current.set(c);
+    }, []);
+    useLayoutEffect(() => { push(cfg); }, [push, cfg]);
+    useConfigDriver({ rootRef, id, family: 'space', base: cfg, structural: STRUCTURAL, allowed: ANIMATABLE, keyframes, mouseMove, push });
+    return (_jsx("group", { ref: rootRef, children: cfg.enabled && shootingStars.map(star => (_jsx(ShootingStar, { position: star.position, direction: star.direction, speed: star.speed, colorRef: colorRef, trailLength: star.trailLength, size: 0.08, opacity: 0.9, maxDistance: star.length, onComplete: () => handleComplete(star.id), followMouse: cfg.followMouse }, star.id))) }));
+};
+export default ShootingStars;

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

@@ -0,0 +1,16 @@
+import type { ObjectReadyProps } from '../../types/objectReady';
+import React from "react";
+import type { AnimationOptions, MouseMoveDomain, SolarSystemSpaceConfig } from "@3driseai/3drise-core";
+export type SolarSystemProps = ObjectReadyProps & {
+    /** The object's config (config.type 'solarSystem'); missing keys fall back to DEFAULT_SPACE_OBJECTS.solarSystem. */
+    config?: Partial<SolarSystemSpaceConfig>;
+    /** Scene object id: the live-edit handle is found by it. */
+    id?: string;
+    /** Keyframes on the config knobs (animations.space.animations). */
+    keyframes?: AnimationOptions[];
+    /** Pointer bindings on the config knobs (mouseMove.space). */
+    mouseMove?: MouseMoveDomain;
+};
+declare const SolarSystem: React.FC<SolarSystemProps>;
+export default SolarSystem;
+//# sourceMappingURL=SolarSystem.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SolarSystem.d.ts","sourceRoot":"","sources":["../../../src/components/space/SolarSystem.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAWhE,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AA4EvG,MAAM,MAAM,gBAAgB,GAAG,gBAAgB,GAAG;IAC9C,oHAAoH;IACpH,MAAM,CAAC,EAAE,OAAO,CAAC,sBAAsB,CAAC,CAAC;IACzC,4DAA4D;IAC5D,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,mEAAmE;IACnE,SAAS,CAAC,EAAE,gBAAgB,EAAE,CAAC;IAC/B,8DAA8D;IAC9D,SAAS,CAAC,EAAE,eAAe,CAAC;CAC/B,CAAC;AAEF,QAAA,MAAM,WAAW,EAAE,KAAK,CAAC,EAAE,CAAC,gBAAgB,CAsD3C,CAAC;AAEF,eAAe,WAAW,CAAC"}

package/dist/components/space/SolarSystem.js

@@ -0,0 +1,141 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useObjectReady } from '../../hooks/useObjectReady.js';
+import { useRef, useMemo, useState, useCallback, useLayoutEffect } from 'react';
+import { BufferGeometry, BufferAttribute, Vector3, Color } from 'three';
+import { useFrame } from '@react-three/fiber';
+import Planet from '../Planet.js';
+import Earth from './Earth.js';
+import Sun from '../Sun.js';
+import { useConfigDriver } from '../../hooks/useConfigDriver.js';
+import { withConfigDefaults } from '../../utils/configAnimations.js';
+import { DEFAULT_SPACE_OBJECTS, SPACE_OBJECTS_ANIMATABLE } from "@3driseai/3drise-core";
+// =============================================================================
+// SolarSystem — sun, eight planets on circular orbits (space object 'solarSystem')
+// =============================================================================
+//
+// Orbits and planet spins are internal motion (sub-bodies moving inside the
+// object); the system as a whole never turns. The orbit time scale, the sun's
+// tint / brightness and the rings' colour / opacity reach the scene only through
+// `push`, the one door live drag, keyframes (animations.space) and pointer
+// bindings (mouseMove.space) go through. The time scale is integrated per frame
+// (phase += delta * rate), so animating it never makes a planet jump.
+//
+const DEFAULTS = DEFAULT_SPACE_OBJECTS.solarSystem;
+const STRUCTURAL = ['sunRadius'];
+const ANIMATABLE = new Set(SPACE_OBJECTS_ANIMATABLE.solarSystem.map((p) => p.value));
+// 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 setColor = (target, v) => { if (v?.isColor)
+    target.copy(v);
+else
+    target.set(v); };
+const OrbitRing = ({ radius, rings }) => {
+    const matRef = useRef(null);
+    useLayoutEffect(() => {
+        const m = matRef.current;
+        if (!m)
+            return;
+        rings.add(m);
+        return () => rings.remove(m);
+    }, [rings]);
+    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", { ref: matRef, transparent: true, depthWrite: false }) }));
+};
+const OrbitedBody = ({ orbitRadius, orbitRate, spinRate, axialTilt, enableOrbit, enableSelfRotation, initialPhase, rateRef, onWorldPositionChange, children, }) => {
+    const orbitRef = useRef(null);
+    const spinRef = useRef(null);
+    const worldPosRef = useRef(new Vector3());
+    useFrame((_, delta) => {
+        const dt = Math.min(delta, 0.1) * rateRef.current;
+        if (enableOrbit && orbitRef.current)
+            orbitRef.current.rotation.y += dt * orbitRate;
+        if (enableSelfRotation && spinRef.current)
+            spinRef.current.rotation.y += dt * spinRate;
+        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 = ({ config, id, keyframes, mouseMove, onObjectReady, onObjectDispose }) => {
+    const { enableOrbit, enableSelfRotation, showOrbitRings, orbitSpeedMultiplier, sunColor, sunRadius, sunIntensity, orbitRingColor, orbitRingOpacity } = config ?? {};
+    const cfg = useMemo(() => withConfigDefaults(DEFAULTS, { enableOrbit, enableSelfRotation, showOrbitRings, orbitSpeedMultiplier, sunColor, sunRadius, sunIntensity, orbitRingColor, orbitRingOpacity }), [enableOrbit, enableSelfRotation, showOrbitRings, orbitSpeedMultiplier, sunColor, sunRadius, sunIntensity, orbitRingColor, orbitRingOpacity]);
+    const [earthSunPos, setEarthSunPos] = useState([1, 0, 0]);
+    const lastEarthSyncRef = useRef(0);
+    const ref = useRef(null);
+    // Stable identity: an inline userData object is re-applied on every render and wipes the live handle stored on it.
+    const userData = useMemo(() => ({ id: '3drise-solar-system' }), []);
+    useObjectReady(ref, cfg, onObjectReady, onObjectDispose);
+    // Live state the push point writes and the frame loops read.
+    const rateRef = useRef(cfg.orbitSpeedMultiplier);
+    const sunControl = useRef({ color: new Color(cfg.sunColor), intensity: cfg.sunIntensity });
+    const ringMats = useRef(new Set());
+    const ringStyle = useRef({ color: new Color(cfg.orbitRingColor), opacity: cfg.orbitRingOpacity });
+    const applyRings = useCallback(() => {
+        for (const m of ringMats.current) {
+            m.color.copy(ringStyle.current.color);
+            m.opacity = ringStyle.current.opacity;
+        }
+    }, []);
+    const rings = useMemo(() => ({
+        add(m) { ringMats.current.add(m); m.color.copy(ringStyle.current.color); m.opacity = ringStyle.current.opacity; },
+        remove(m) { ringMats.current.delete(m); },
+    }), []);
+    const push = useCallback((m) => {
+        if (typeof m.orbitSpeedMultiplier === 'number')
+            rateRef.current = m.orbitSpeedMultiplier;
+        if (m.sunColor !== undefined)
+            setColor(sunControl.current.color, m.sunColor);
+        if (typeof m.sunIntensity === 'number')
+            sunControl.current.intensity = m.sunIntensity;
+        if (m.orbitRingColor !== undefined)
+            setColor(ringStyle.current.color, m.orbitRingColor);
+        if (typeof m.orbitRingOpacity === 'number')
+            ringStyle.current.opacity = m.orbitRingOpacity;
+        applyRings();
+    }, [applyRings]);
+    useLayoutEffect(() => { push(cfg); }, [push, cfg]);
+    useConfigDriver({ rootRef: ref, id, family: 'space', base: cfg, structural: STRUCTURAL, allowed: ANIMATABLE, keyframes, mouseMove, push });
+    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: userData, ref: ref, children: [_jsx(Sun, { radius: cfg.sunRadius, control: sunControl }), cfg.showOrbitRings &&
+                PLANETS.map((p) => (_jsx(OrbitRing, { radius: p.orbitRadius, rings: rings }, `ring-${p.body.name}`))), PLANETS.map((p) => {
+                const orbitRate = (2 * Math.PI) / (p.periodYears * EARTH_YEAR_SECONDS);
+                const common = { orbitRadius: p.orbitRadius, orbitRate, spinRate: p.spinRate, axialTilt: p.axialTilt, enableOrbit: cfg.enableOrbit, enableSelfRotation: cfg.enableSelfRotation, initialPhase: p.initialPhase, rateRef };
+                if (p.body.kind === 'earth') {
+                    return (_jsx(OrbitedBody, { ...common, onWorldPositionChange: handleEarthWorld, children: _jsx(Earth, { config: { radius: p.radius, sunPosition: earthSunPos, atmosphereDayColor: '#6db3f2', atmosphereTwilightColor: '#d97e54' } }) }, "earth"));
+                }
+                return (_jsx(OrbitedBody, { ...common, children: _jsx(Planet, { type: p.body.type, scale: p.radius }) }, p.body.name));
+            })] }));
+};
+SolarSystem.displayName = 'SolarSystem';
+export default SolarSystem;

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

@@ -0,0 +1,20 @@
+import type { ObjectReadyProps } from '../../types/objectReady';
+import { BufferGeometry } from 'three';
+import React from "react";
+import type { AnimationOptions, MouseMoveDomain, StarsSpaceConfig, TimeSettings } from "@3driseai/3drise-core";
+export interface StarsProps extends ObjectReadyProps {
+    /** The object's config (config.type 'stars'); missing keys fall back to DEFAULT_SPACE_OBJECTS.stars. */
+    config?: Partial<StarsSpaceConfig>;
+    timeSettings?: TimeSettings;
+    sunSystemEnabled?: boolean;
+    /** Scene object id: the live-edit handle is found by it. */
+    id?: string;
+    /** Keyframes on the config knobs (animations.space.animations). */
+    keyframes?: AnimationOptions[];
+    /** Pointer bindings on the config knobs (mouseMove.space). */
+    mouseMove?: MouseMoveDomain;
+}
+export declare function generateStarsGeometry(count: number): BufferGeometry;
+declare const Stars: React.FC<StarsProps>;
+export default Stars;
+//# sourceMappingURL=Stars.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Stars.d.ts","sourceRoot":"","sources":["../../../src/components/space/Stars.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE,OAAO,EAAE,cAAc,EAAqC,MAAM,OAAO,CAAC;AAM1E,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAe/G,MAAM,WAAW,UAAW,SAAQ,gBAAgB;IAChD,wGAAwG;IACxG,MAAM,CAAC,EAAE,OAAO,CAAC,gBAAgB,CAAC,CAAC;IACnC,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,4DAA4D;IAC5D,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,mEAAmE;IACnE,SAAS,CAAC,EAAE,gBAAgB,EAAE,CAAC;IAC/B,8DAA8D;IAC9D,SAAS,CAAC,EAAE,eAAe,CAAC;CAC/B;AAQD,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,CAuDnE;AAYD,QAAA,MAAM,KAAK,EAAE,KAAK,CAAC,EAAE,CAAC,UAAU,CA0E/B,CAAC;AACF,eAAe,KAAK,CAAC"}

package/dist/components/space/Stars.js

@@ -0,0 +1,160 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useObjectReady } from '../../hooks/useObjectReady.js';
+import { useRef, useMemo, useCallback, useEffect, useLayoutEffect } from 'react';
+import { BufferGeometry, BufferAttribute, AdditiveBlending } from 'three';
+import { useFrame } from '@react-three/fiber';
+import { useSkySystem } from '../../hooks/useSkySystem.js';
+import { useConfigDriver } from '../../hooks/useConfigDriver.js';
+import { withConfigDefaults } from '../../utils/configAnimations.js';
+import { DEFAULT_SPACE_OBJECTS, SPACE_OBJECTS_ANIMATABLE } from "@3driseai/3drise-core";
+const DEFAULTS = DEFAULT_SPACE_OBJECTS.stars;
+/** Knobs that rebuild the field: never live, they change once, on commit. */
+const STRUCTURAL = ['count'];
+/** Knobs a keyframe or pointer binding may drive per frame — exactly what push applies. */
+const ANIMATABLE = new Set(SPACE_OBJECTS_ANIMATABLE.stars.map((p) => p.value));
+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, 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 = ({ config, timeSettings, sunSystemEnabled = false, id, keyframes, mouseMove, onObjectReady, onObjectDispose }) => {
+    const pointsRef = useRef(null);
+    const materialRef = useRef(null);
+    // Stable identity: an inline userData object is re-applied on every render and wipes the live handle stored on it.
+    const userData = useMemo(() => ({ id: '3drise-stars' }), []);
+    const cfg = useMemo(() => withConfigDefaults(DEFAULTS, config), [config]);
+    useObjectReady(pointsRef, cfg, onObjectReady, onObjectDispose);
+    const geometry = useMemo(() => generateStarsGeometry(cfg.count), [cfg.count]);
+    useEffect(() => () => { geometry.dispose(); }, [geometry]);
+    // The configured opacity (push) times the day / night fade (sky system).
+    const opacityRef = useRef(cfg.opacity);
+    const fadeRef = useRef(1);
+    const targetFadeRef = useRef(1);
+    const push = useCallback((m) => {
+        const mat = materialRef.current;
+        if (typeof m.opacity === 'number')
+            opacityRef.current = m.opacity;
+        if (!mat)
+            return;
+        if (typeof m.starSize === 'number')
+            mat.sizeScale = m.starSize;
+        const c = m.color;
+        if (c !== undefined && mat.uColor) {
+            if (c?.isColor)
+                mat.uColor.copy(c);
+            else
+                mat.uColor.set(c);
+            mat.targetColor.copy(mat.uColor);
+        }
+    }, []);
+    useLayoutEffect(() => { push(cfg); }, [push, cfg]);
+    useConfigDriver({ rootRef: pointsRef, id, family: 'space', base: cfg, structural: STRUCTURAL, allowed: ANIMATABLE, keyframes, mouseMove, push });
+    useEffect(() => {
+        if (!sunSystemEnabled) {
+            fadeRef.current = 1;
+            targetFadeRef.current = 1;
+        }
+    }, [sunSystemEnabled]);
+    const handleTimeUpdate = useCallback((state) => {
+        // Not gated on autoAnimate: scrubbing the time slider to midnight brings the
+        // stars up the same way playing into midnight does.
+        const { normalizedTime, isDaytime, delta } = state;
+        if (!sunSystemEnabled)
+            return;
+        if (!isDaytime) {
+            targetFadeRef.current = 1;
+        }
+        else {
+            const sunriseEnd = 0.15;
+            const sunsetStart = 0.85;
+            if (normalizedTime <= sunriseEnd)
+                targetFadeRef.current = 1 - normalizedTime / sunriseEnd;
+            else if (normalizedTime >= sunsetStart)
+                targetFadeRef.current = (normalizedTime - sunsetStart) / (1 - sunsetStart);
+            else
+                targetFadeRef.current = 0;
+        }
+        const lerp = Math.min(1, 1.5 * (delta !== 0 ? delta : 1));
+        fadeRef.current += (targetFadeRef.current - fadeRef.current) * lerp;
+    }, [sunSystemEnabled]);
+    useSkySystem({
+        timeSettings: timeSettings ?? DEFAULT_TIME_SETTINGS,
+        onTimeUpdate: handleTimeUpdate,
+        enabled: sunSystemEnabled && !!timeSettings,
+    });
+    useFrame((_, delta) => {
+        const mat = materialRef.current;
+        const points = pointsRef.current;
+        if (!mat || !points)
+            return;
+        const alpha = opacityRef.current * fadeRef.current;
+        points.visible = alpha > 0.01;
+        mat.opacity = alpha;
+        // Twinkle clock.
+        mat.time += Math.min(delta, 0.1);
+    });
+    // No scale on <points>: the CreatedObject wrapper applies meshSettings.scale.
+    return (_jsx("points", { ref: pointsRef, geometry: geometry, renderOrder: -1, frustumCulled: false, userData: userData, children: _jsx("starsMaterial", { ref: materialRef, transparent: true, depthWrite: false, depthTest: true, blending: AdditiveBlending, colorMix: 0 }) }));
+};
+export default Stars;

package/dist/components/space/index.d.ts

@@ -0,0 +1,11 @@
+export type { StarsProps } from './Stars';
+export { default as Stars, generateStarsGeometry } from './Stars';
+export type { EarthProps } from './Earth';
+export { default as Earth } from './Earth';
+export type { SolarSystemProps } from './SolarSystem';
+export { default as SolarSystem } from './SolarSystem';
+export type { ShootingStarsProps } from './ShootingStars';
+export { default as ShootingStars } from './ShootingStars';
+export type { ShootingStarProps } from './ShootingStar';
+export { default as ShootingStar } from './ShootingStar';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/space/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/space/index.ts"],"names":[],"mappings":"AAIA,YAAY,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAC1C,OAAO,EAAE,OAAO,IAAI,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAClE,YAAY,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAC1C,OAAO,EAAE,OAAO,IAAI,KAAK,EAAE,MAAM,SAAS,CAAC;AAC3C,YAAY,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACtD,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,eAAe,CAAC;AACvD,YAAY,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAC1D,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAC3D,YAAY,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/components/space/index.js

@@ -0,0 +1,8 @@
+// Space objects (object type 'space'): celestial bodies and sky backdrops.
+// Rendered by Galaxy.tsx from its FAMILY table; each takes the uniform contract
+// (config, id, keyframes, mouseMove, onObjectReady, onObjectDispose).
+export { default as Stars, generateStarsGeometry } from './Stars.js';
+export { default as Earth } from './Earth.js';
+export { default as SolarSystem } from './SolarSystem.js';
+export { default as ShootingStars } from './ShootingStars.js';
+export { default as ShootingStar } from './ShootingStar.js';

package/dist/components/terrain/TerrainSurface.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TerrainSurface.d.ts","sourceRoot":"","sources":["../../../src/components/terrain/TerrainSurface.tsx"],"names":[],"mappings":"AACA,OAAO,KAAqC,MAAM,OAAO,CAAC;AAU1D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAEjD;;;;;;;;;;;;;;;;GAgBG;AACH,QAAA,MAAM,cAAc,EAAE,KAAK,CAAC,EAAE,CAAC,iBAAiB,CAgG/C,CAAC;AAEF,eAAe,cAAc,CAAC"}
+{"version":3,"file":"TerrainSurface.d.ts","sourceRoot":"","sources":["../../../src/components/terrain/TerrainSurface.tsx"],"names":[],"mappings":"AACA,OAAO,KAAqC,MAAM,OAAO,CAAC;AAkB1D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAEjD;;;;;;;;;;;;;;;;GAgBG;AACH,QAAA,MAAM,cAAc,EAAE,KAAK,CAAC,EAAE,CAAC,iBAAiB,CAkI/C,CAAC;AAEF,eAAe,cAAc,CAAC"}

package/dist/components/terrain/TerrainSurface.js

@@ -7,7 +7,10 @@ import { useCloudSun } from '../../hooks/useCloudSun.js';
 import { TERRAIN_LIVE_KEY } from '../../hooks/useTerrainLive.js';
 import { TerrainMaterial } from '../../shaders/terrain/TerrainMaterial.js';
 import { applySunUniforms } from '../../utils/cloudUniforms.js';
-import { applyTerrainAmbient, applyTerrainUniforms } from '../../utils/terrainUniforms.js';
+import { applyTerrainAmbient, applyTerrainTextures, applyTerrainUniforms } from '../../utils/terrainUniforms.js';
+import { useTerrainTextures } from '../../hooks/useTerrainTextures.js';
+import { getAnimatableProperties } from '@3driseai/3drise-core';
+import { applyConfigKeyframeAnimations, applyConfigMouseMove, } from '../../utils/configAnimations.js';
 /**
  * The terrain renderer. One clipmap, one material, four landforms — they differ
  * by the shaping operator the height field applies, not by having separate
@@ -25,10 +28,13 @@ import { applyTerrainAmbient, applyTerrainUniforms } from '../../utils/terrainUn
  * three together), pushes the config into uniforms, and re-snaps the clipmap to
  * the camera. Nothing here re-renders React.
  */
-const TerrainSurface = ({ id = '3drise-terrain', config, quality, skySettings, timeSettings, sunIntensity = 1, onObjectReady, onObjectDispose, }) => {
+const TerrainSurface = ({ id = '3drise-terrain', config, quality, skySettings, timeSettings, sunIntensity = 1, animations, mouseMove, onObjectReady, onObjectDispose, }) => {
     const clipmap = useTerrainClipmap(quality.levels, quality.segments, quality.cellSize);
     const { state: sun, update: updateSun } = useCloudSun({ skySettings, timeSettings });
     const material = useMemo(() => new TerrainMaterial(), []);
+    // The four ground textures, packed into arrays. Repacks only when a map URL
+    // changes; tile size, tint and strength are uniforms, applied per frame.
+    const textures = useTerrainTextures(config.textures);
     useEffect(() => () => { material.dispose(); }, [material]);
     // Live controller overrides. A slider drag writes here every pointer-move and
     // the frame loop reads it on top of the config, so the terrain responds without
@@ -39,6 +45,18 @@ const TerrainSurface = ({ id = '3drise-terrain', config, quality, skySettings, t
     const liveQuality = useRef({});
     useEffect(() => { liveConfig.current = {}; }, [config]);
     useEffect(() => { liveQuality.current = {}; }, [quality]);
+    // The `terrain` keyframe / pointer domains: config -> keyframes -> pointer ->
+    // live drag, the clouds' order. Only the surface's lighting and colour knobs are
+    // in the set — the registry marks every land-shape knob non-animatable, so the
+    // ground itself never moves.
+    const animatable = useMemo(() => new Set(getAnimatableProperties({ type: 'terrain', config }, 'terrain').map(p => p.value)), [config.terrainType]);
+    const override = useRef({});
+    const startValues = useRef({});
+    const animStart = useRef(0);
+    useEffect(() => {
+        animStart.current = performance.now();
+        startValues.current = {};
+    }, [animations]);
     const rootRef = useRef(null);
     const meshRefs = useRef([]);
     // The handle a controller reaches through findById(id).userData. Set in an
@@ -67,9 +85,15 @@ const TerrainSurface = ({ id = '3drise-terrain', config, quality, skySettings, t
         // the sky that is actually being drawn behind it or a sunset landscape
         // comes out black under a blazing sky.
         applyTerrainAmbient(material, sun);
-        const cfg = { ...config, ...liveConfig.current };
+        const o = override.current;
+        applyConfigKeyframeAnimations(animations?.terrain?.animations, startValues.current, config, o, performance.now() - animStart.current, animatable);
+        if (mouseMove?.enabled && mouseMove.terrain?.enabled) {
+            applyConfigMouseMove(mouseMove.terrain.properties, config, o, state.pointer, animatable);
+        }
+        const cfg = { ...config, ...o, ...liveConfig.current };
         const qual = { ...quality, ...liveQuality.current };
         applyTerrainUniforms(material, cfg, qual);
+        applyTerrainTextures(material, cfg, textures);
         // ONE origin for the whole pyramid, snapped to twice the finest cell.
         //
         // Snapping each ring to its own cell grid is the textbook clipmap and it is