@3driseai/3drise-viewer 0.1.27 → 0.1.29

package/dist/components/SkyStars.js

@@ -0,0 +1,187 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useMemo, useRef } from 'react';
+import * as THREE from 'three';
+import { useFrame } from '@react-three/fiber';
+import { nightAmount, skySystemManager, normalizeSkyStars } from '@3driseai/3drise-core';
+import { useCloudSun } from '../hooks/useCloudSun.js';
+/**
+ * The night sky's stars, built into the sky for either renderer.
+ *
+ * A star dome centred on the camera just inside the far plane (the sky is drawn
+ * at the far plane, so stars sit in front of it and terrain occludes them).
+ * Brightness follows a magnitude-like distribution — a few bright stars, many
+ * faint ones — with a slight colour temperature spread and a gentle twinkle.
+ *
+ * With the clock on they appear with the night (nightAmount: by the SUN'S HEIGHT,
+ * the same phase keys as the atmosphere), fade toward the horizon where real air
+ * extinguishes them, and turn about the celestial pole with the clock: rising in
+ * the same quarter the sun rises, setting where it sets. With the clock off they
+ * are a stand-alone layer: on whenever `stars.visible` is, at full strength.
+ */
+/** Height of the celestial pole above the horizon = observer latitude. */
+const LATITUDE_DEG = 40;
+/** North is opposite the noon sun. The noon sun is toward +X in core's
+ *  convention, so the pole leans toward −X. */
+const POLE = new THREE.Vector3(-Math.cos(THREE.MathUtils.degToRad(LATITUDE_DEG)), Math.sin(THREE.MathUtils.degToRad(LATITUDE_DEG)), 0).normalize();
+/** Sidereal day, hours: the sky turns once in this much clock time. */
+const SIDEREAL_HOURS = 23.934;
+const vertexShader = /* glsl */ `
+attribute float aMag;
+attribute float aPhase;
+attribute vec3 aTint;
+uniform float uTime;
+uniform float uNight;
+uniform float uPixelRatio;
+uniform float uBrightness;
+uniform float uSize;
+uniform float uTwinkle;
+uniform float uWarmth;
+varying vec3 vColor;
+varying float vAlpha;
+void main() {
+    vec4 world = modelMatrix * vec4(position, 1.0);
+    // direction from the camera: stars live on a camera-centred dome
+    vec3 dir = normalize(world.xyz - cameraPosition);
+    float horizon = smoothstep(-0.02, 0.18, dir.y);          // extinction near the horizon
+    // twinkle depth: 0 = steady, 1 = the full 36% flicker
+    float twinkle = 1.0 - 0.36 * uTwinkle * (0.5 + 0.5 * sin(uTime * (1.3 + aPhase * 2.1) + aPhase * 37.0));
+    float b = aMag * twinkle * horizon * uNight * uBrightness;
+    // aTint holds the full-temperature colour; uWarmth blends it toward white
+    vColor = mix(vec3(1.0), aTint, uWarmth);
+    vAlpha = b;
+    gl_PointSize = (1.0 + 2.6 * aMag) * uPixelRatio * uSize;
+    gl_Position = projectionMatrix * viewMatrix * world;
+}
+`;
+const fragmentShader = /* glsl */ `
+varying vec3 vColor;
+varying float vAlpha;
+void main() {
+    vec2 d = gl_PointCoord * 2.0 - 1.0;
+    float r2 = dot(d, d);
+    if (r2 > 1.0 || vAlpha < 0.003) discard;
+    float core = exp(-r2 * 4.0);
+    gl_FragColor = vec4(vColor * core * vAlpha, 1.0);
+}
+`;
+/** Great-circle normal of the Milky Way band: tilted ~60° from the celestial pole
+ *  (the real galactic plane is ~63° off), so the band arches across the sky
+ *  rather than circling the pole. */
+const BAND_NORMAL = new THREE.Vector3(0.5, 0.55, 0.67).normalize();
+const BAND_U = new THREE.Vector3().crossVectors(BAND_NORMAL, new THREE.Vector3(0, 1, 0)).normalize();
+const BAND_V = new THREE.Vector3().crossVectors(BAND_NORMAL, BAND_U).normalize();
+/** Box–Muller normal deviate. */
+const gauss = () => Math.sqrt(-2 * Math.log(1 - Math.random())) * Math.cos(Math.random() * Math.PI * 2);
+/**
+ * Builds the dome. `milkyWay` (0..1) moves that fraction (× 0.7) of the stars into a
+ * dense band of faint stars along a great circle, with a wider, sparser halo — the
+ * unresolved glow reads as the band even though every point is still a star. The
+ * full colour-temperature tint is baked per star; the shader scales it by warmth.
+ */
+function buildStars(count, milkyWay) {
+    const pos = new Float32Array(count * 3);
+    const mag = new Float32Array(count);
+    const phase = new Float32Array(count);
+    const tint = new Float32Array(count * 3);
+    const inBand = Math.round(count * 0.7 * THREE.MathUtils.clamp(milkyWay, 0, 1));
+    const p = new THREE.Vector3();
+    for (let i = 0; i < count; i++) {
+        if (i < inBand) {
+            // along the band: uniform angle; across it: gaussian, 60% in a tight core, 40% in a halo
+            const a = Math.random() * Math.PI * 2;
+            const sigma = Math.random() < 0.6 ? 0.07 : 0.22;
+            const lat = THREE.MathUtils.clamp(gauss() * sigma, -1.2, 1.2);
+            p.copy(BAND_U).multiplyScalar(Math.cos(a) * Math.cos(lat))
+                .addScaledVector(BAND_V, Math.sin(a) * Math.cos(lat))
+                .addScaledVector(BAND_NORMAL, Math.sin(lat));
+            // the band is dust: many faint stars, rarely a bright one
+            mag[i] = 0.06 + 0.3 * Math.pow(Math.random(), 3);
+        }
+        else {
+            // uniform on the sphere
+            const u = Math.random() * 2 - 1;
+            const th = Math.random() * Math.PI * 2;
+            const sr = Math.sqrt(1 - u * u);
+            p.set(sr * Math.cos(th), u, sr * Math.sin(th));
+            // many faint, few bright
+            mag[i] = 0.12 + 0.88 * Math.pow(Math.random(), 6);
+        }
+        pos[i * 3] = p.x;
+        pos[i * 3 + 1] = p.y;
+        pos[i * 3 + 2] = p.z;
+        phase[i] = Math.random();
+        const t = Math.random();
+        // full temperature spread (warmth 1): blue giants, orange dwarfs, the rest near white
+        const c = t < 0.12 ? [0.62, 0.74, 1.0] : t < 0.25 ? [1.0, 0.8, 0.55] : [1.0, 0.97, 0.92];
+        tint.set(c, i * 3);
+    }
+    const g = new THREE.BufferGeometry();
+    g.setAttribute('position', new THREE.BufferAttribute(pos, 3));
+    g.setAttribute('aMag', new THREE.BufferAttribute(mag, 1));
+    g.setAttribute('aPhase', new THREE.BufferAttribute(phase, 1));
+    g.setAttribute('aTint', new THREE.BufferAttribute(tint, 3));
+    return g;
+}
+const SkyStars = ({ timeSettings, skySettings, stars }) => {
+    const pointsRef = useRef(null);
+    const { update } = useCloudSun({ skySettings, timeSettings });
+    const { count, milkyWay, brightness, size, twinkle, warmth } = normalizeSkyStars(stars);
+    // Structural: a new dome only when count or the band changes.
+    const geometry = useMemo(() => buildStars(count, milkyWay), [count, milkyWay]);
+    const material = useMemo(() => new THREE.ShaderMaterial({
+        uniforms: {
+            uTime: { value: 0 },
+            uNight: { value: 0 },
+            uPixelRatio: { value: 1 },
+            uBrightness: { value: 1 },
+            uSize: { value: 1 },
+            uTwinkle: { value: 0.5 },
+            uWarmth: { value: 0.5 },
+        },
+        vertexShader,
+        fragmentShader,
+        transparent: true,
+        depthWrite: false,
+        depthTest: true,
+        blending: THREE.AdditiveBlending,
+        fog: false,
+        toneMapped: false,
+    }), []);
+    useEffect(() => () => geometry.dispose(), [geometry]);
+    useEffect(() => () => material.dispose(), [material]);
+    const spin = useMemo(() => new THREE.Quaternion(), []);
+    useFrame(({ camera, gl, clock }) => {
+        const points = pointsRef.current;
+        if (!points)
+            return;
+        // With the clock on, the stars belong to the day cycle: they come out as the sun
+        // sets (nightAmount). With the clock off they stand alone — the user adds them
+        // whenever they want, at full strength, whatever the sun's elevation.
+        let night = 1;
+        if (timeSettings?.enabled) {
+            const sunDir = update().direction;
+            const sunElevation = THREE.MathUtils.radToDeg(Math.asin(THREE.MathUtils.clamp(sunDir.y, -1, 1)));
+            night = nightAmount(sunElevation);
+        }
+        if (night <= 0.001) {
+            points.visible = false;
+            return;
+        }
+        points.visible = true;
+        const far = camera.far ?? 1000;
+        points.position.copy(camera.position);
+        points.scale.setScalar(far * 0.85);
+        // Turn with the clock about the pole, same sense as the sun (rises −Z, sets +Z).
+        const hours = timeSettings?.enabled ? skySystemManager.getTimeInHours() : 0;
+        points.quaternion.copy(spin.setFromAxisAngle(POLE, -(hours / SIDEREAL_HOURS) * Math.PI * 2));
+        material.uniforms.uTime.value = clock.elapsedTime;
+        material.uniforms.uNight.value = night;
+        material.uniforms.uPixelRatio.value = gl.getPixelRatio();
+        material.uniforms.uBrightness.value = brightness;
+        material.uniforms.uSize.value = size;
+        material.uniforms.uTwinkle.value = twinkle;
+        material.uniforms.uWarmth.value = warmth;
+    });
+    return _jsx("points", { ref: pointsRef, geometry: geometry, material: material, frustumCulled: false, renderOrder: -2 });
+};
+export default SkyStars;

package/dist/components/SkySystem.d.ts

@@ -26,9 +26,9 @@ export interface SkySystemRef {
 export interface SkySystemProps extends ObjectReadyProps {
     timeSettings: TimeSettings;
     visible?: boolean;
-    /** True mounts the physical sun rig (skybox + lensflare + directional light);
-     *  false mounts the analytic Preetham sky instead. They are alternatives, not
-     *  layers — the sun rig draws its own background. */
+    /** True mounts the sun rig background (skybox + lensflare); false mounts the
+     *  analytic Preetham sky instead. The key light (SunLight) is the same in both
+     *  and is mounted whenever either sky is active. */
     sunSystemVisible?: boolean;
     sunSize?: number;
     moonSize?: number;

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

@@ -1 +1 @@
-{"version":3,"file":"SkySystem.d.ts","sourceRoot":"","sources":["../../src/components/SkySystem.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAE7D,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAG/B,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACpF,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAOtE,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B;;;;;;;;;;;;;GAaG;AAEH,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,cAAe,SAAQ,gBAAgB;IACpD,YAAY,EAAE,YAAY,CAAC;IAC3B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;yDAEqD;IACrD,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;;;uBAGmB;IACnB,cAAc,CAAC,EAAE,wBAAwB,CAAC;IAC1C,qBAAqB,CAAC,EAAE,WAAW,CAAC;IACpC;wDACoD;IACpD,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;IAC3C;;;;;;;;;;gFAU4E;IAC5E,SAAS,CAAC,EAAE,OAAO,CAAC;CACvB;AAED,QAAA,MAAM,SAAS,qFAwJb,CAAC;AAGH,eAAe,SAAS,CAAC"}
+{"version":3,"file":"SkySystem.d.ts","sourceRoot":"","sources":["../../src/components/SkySystem.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAE7D,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAG/B,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACpF,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAStE,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B;;;;;;;;;;;;;GAaG;AAEH,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,cAAe,SAAQ,gBAAgB;IACpD,YAAY,EAAE,YAAY,CAAC;IAC3B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;wDAEoD;IACpD,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;;;uBAGmB;IACnB,cAAc,CAAC,EAAE,wBAAwB,CAAC;IAC1C,qBAAqB,CAAC,EAAE,WAAW,CAAC;IACpC;wDACoD;IACpD,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;IAC3C;;;;;;;;;;gFAU4E;IAC5E,SAAS,CAAC,EAAE,OAAO,CAAC;CACvB;AAED,QAAA,MAAM,SAAS,qFAmLb,CAAC;AAGH,eAAe,SAAS,CAAC"}

package/dist/components/SkySystem.js

@@ -4,9 +4,10 @@ import { useEffect, useLayoutEffect, useMemo, useRef, forwardRef, useImperativeH
 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 MoonDisc from './MoonDisc.js';
 import SkyController from './SkyController.js';
+import SkyStars from './SkyStars.js';
 import SceneFog from './SceneFog.js';
 import CloudsGenerator from './CloudsGenerator.js';
 const SkySystem = forwardRef(({ timeSettings, visible = true, sunSystemVisible = false, sunSize = 1, moonSize = 1, skyboxScale = 100000, sunIntensity = 1, castShadow = true, shadowMapSize = 2048, playerPosition, cloudsSettings, skyControllerSettings, fogSettings, onTimeOfDayChange, onTimeUpdate, driveTime = true, onObjectReady, onObjectDispose, }, ref) => {
@@ -81,7 +82,12 @@ const SkySystem = forwardRef(({ timeSettings, visible = true, sunSystemVisible =
     });
     if (!visible)
         return null;
-    return (_jsxs("group", { ref: rootRef, children: [skyControllerSettings && !sunSystemVisible && (_jsx(SkyController, { settings: skyControllerSettings, timeSettings: timeSettings, scale: skyboxScale, ...ready })), sunSystemVisible && (_jsxs(_Fragment, { children: [_jsx(Skybox, { visible: true, scale: skyboxScale, sunSize: sunSize, moonSize: moonSize, timeSettings: timeSettings, ...ready }), _jsx(Lensflare, { visible: true, intensity: sunIntensity, timeSettings: timeSettings, ...ready }), _jsx(SunLight, { visible: true, timeSettings: timeSettings, targetPosition: playerPosition, intensity: sunIntensity, castShadow: castShadow, shadowMapSize: shadowMapSize, ...ready })] })), fogSettings && _jsx(SceneFog, { fog: fogSettings }), cloudsSettings && (_jsx(CloudsGenerator, { settings: cloudsSettings, skySettings: skyControllerSettings, timeSettings: timeSettings, sunIntensity: sunIntensity, ...ready }))] }));
+    // The key light exists whenever there is a sky to own the sun — either
+    // renderer. It is the scene's only sun while mounted (LightsManager's sun
+    // stands down), and it reads the same resolved sun as clouds, water and
+    // terrain.
+    const skyActive = !!skyControllerSettings?.visible || sunSystemVisible;
+    return (_jsxs("group", { ref: rootRef, children: [skyControllerSettings && !sunSystemVisible && (_jsx(SkyController, { settings: skyControllerSettings, timeSettings: timeSettings, scale: skyboxScale, ...ready })), sunSystemVisible && (_jsx(_Fragment, { children: _jsx(Skybox, { visible: true, scale: skyboxScale, sunSize: sunSize, moonSize: moonSize, timeSettings: timeSettings, ...ready }) })), skyActive && (_jsx(SunLight, { visible: true, timeSettings: timeSettings, skySettings: skyControllerSettings, targetPosition: playerPosition, intensity: sunIntensity, moonIntensity: skyControllerSettings?.sunSystem?.moonIntensity ?? 1, castShadow: castShadow, shadowMapSize: shadowMapSize, ...ready })), (skyActive ? skyControllerSettings?.stars?.visible !== false : skyControllerSettings?.stars?.visible === true) && (_jsx(SkyStars, { timeSettings: timeSettings, skySettings: skyControllerSettings, stars: skyControllerSettings?.stars })), skyActive && (_jsx(MoonDisc, { timeSettings: timeSettings, skySettings: skyControllerSettings, size: moonSize })), fogSettings && _jsx(SceneFog, { fog: fogSettings }), cloudsSettings && (_jsx(CloudsGenerator, { settings: cloudsSettings, skySettings: skyControllerSettings, timeSettings: timeSettings, sunIntensity: sunIntensity, ...ready }))] }));
 });
 SkySystem.displayName = 'SkySystem';
 export default SkySystem;

package/dist/components/Sun.d.ts

@@ -1,4 +1,16 @@
+import type { MutableRefObject } from 'react';
+import * as THREE from 'three';
 import type { ObjectReadyProps } from '../types/objectReady';
+/** Live tint / brightness for the sun, written by its owner's push point (SolarSystem). */
+export interface SunControl {
+    /** Tint relative to REFERENCE_TINT: the reference keeps the sun's own palette. */
+    color: THREE.Color;
+    /** Brightness relative to REFERENCE_INTENSITY. */
+    intensity: number;
+}
+/** The SolarSystem defaults: at these values the sun looks exactly as it was designed. */
+export declare const SUN_REFERENCE_TINT: THREE.Color;
+export declare const SUN_REFERENCE_INTENSITY = 3;
 type SunProps = ObjectReadyProps & {
     /** Radius of the sun core. Default 1. */
     radius?: number;
@@ -10,7 +22,9 @@ type SunProps = ObjectReadyProps & {
     coronaUniforms?: Record<string, any>;
     /** Uniform overrides for SunFlareMaterial. */
     flareUniforms?: Record<string, any>;
+    /** Read every frame: tints the surface ramp, the corona and the light, and scales their brightness. */
+    control?: MutableRefObject<SunControl>;
 };
-export default function Sun({ radius, coronaScale, coreUniforms, coronaUniforms, flareUniforms, onObjectReady, onObjectDispose, }: SunProps): import("react").JSX.Element;
+export default function Sun({ radius, coronaScale, coreUniforms, coronaUniforms, flareUniforms, control, onObjectReady, onObjectDispose, }: SunProps): import("react").JSX.Element;
 export {};
 //# sourceMappingURL=Sun.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"Sun.d.ts","sourceRoot":"","sources":["../../src/components/Sun.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAI7D,KAAK,QAAQ,GAAG,gBAAgB,GAAG;IAC/B,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,EAAE,aAAa,EAAE,eAAe,GAAG,EAAE,QAAQ,+BAIrJ"}
+{"version":3,"file":"Sun.d.ts","sourceRoot":"","sources":["../../src/components/Sun.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,OAAO,CAAC;AAC9C,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAG/B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAI7D,2FAA2F;AAC3F,MAAM,WAAW,UAAU;IACvB,kFAAkF;IAClF,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC;IACnB,kDAAkD;IAClD,SAAS,EAAE,MAAM,CAAC;CACrB;AAED,0FAA0F;AAC1F,eAAO,MAAM,kBAAkB,aAA6B,CAAC;AAC7D,eAAO,MAAM,uBAAuB,IAAI,CAAC;AAEzC,KAAK,QAAQ,GAAG,gBAAgB,GAAG;IAC/B,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;IACpC,uGAAuG;IACvG,OAAO,CAAC,EAAE,gBAAgB,CAAC,UAAU,CAAC,CAAC;CAC1C,CAAC;AAeF,MAAM,CAAC,OAAO,UAAU,GAAG,CAAC,EAAE,MAAU,EAAE,WAAkB,EAAE,YAAY,EAAE,cAAc,EAAE,aAAa,EAAE,OAAO,EAAE,aAAa,EAAE,eAAe,GAAG,EAAE,QAAQ,+BA6C9J"}

package/dist/components/Sun.js

@@ -1,11 +1,72 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useRef } from 'react';
+import * as THREE from 'three';
+import { useFrame } from '@react-three/fiber';
 import { useObjectReady } from '../hooks/useObjectReady.js';
-// import { ReactNode } from "react";
 import SunCore from "./SunCore.js";
 import Corona from "./effects/Corona.js";
-export default function Sun({ radius = 1, coronaScale = 1.25, coreUniforms, coronaUniforms, flareUniforms, onObjectReady, onObjectDispose, }) {
+/** The SolarSystem defaults: at these values the sun looks exactly as it was designed. */
+export const SUN_REFERENCE_TINT = new THREE.Color('#ffd27a');
+export const SUN_REFERENCE_INTENSITY = 3;
+const LAVA_COLORS = ['u_color1', 'u_color2', 'u_color3', 'u_color4', 'u_color5', 'u_rimColor'];
+const CORONA_COLORS = ['u_innerColor', 'u_outerColor'];
+const LIGHT_COLOR = '#ffa544';
+const LIGHT_INTENSITY = 6;
+export default function Sun({ radius = 1, coronaScale = 1.25, coreUniforms, coronaUniforms, flareUniforms, control, onObjectReady, onObjectDispose, }) {
     const rootRef = useRef(null);
+    const lightRef = useRef(null);
+    const cache = useRef(null);
+    const ratio = useRef(new THREE.Vector3());
     useObjectReady(rootRef, { radius, coronaScale }, onObjectReady, onObjectDispose);
-    return (_jsxs("group", { ref: rootRef, 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 })] }));
+    useFrame(() => {
+        if (!control || !rootRef.current)
+            return;
+        if (!cache.current) {
+            const c = { lava: null, corona: null, light: lightRef.current, base: {} };
+            rootRef.current.traverse((o) => {
+                const u = o.material?.uniforms;
+                if (!u)
+                    return;
+                if (u.u_color1 && !c.lava)
+                    c.lava = o.material;
+                else if (u.u_innerColor && !c.corona)
+                    c.corona = o.material;
+            });
+            if (!c.lava || !c.corona || !c.light)
+                return;
+            // Own the vectors before writing into them: shaderMaterial defaults may be shared between instances.
+            for (const k of LAVA_COLORS) {
+                const u = c.lava.uniforms[k];
+                c.base[k] = u.value.clone();
+                u.value = u.value.clone();
+            }
+            for (const k of CORONA_COLORS) {
+                const u = c.corona.uniforms[k];
+                c.base[k] = u.value.clone();
+                u.value = u.value.clone();
+            }
+            c.base.u_brightness = c.lava.uniforms.u_brightness.value;
+            c.base.u_intensity = c.corona.uniforms.u_intensity?.value ?? 1;
+            cache.current = c;
+        }
+        const c = cache.current;
+        const { color, intensity } = control.current;
+        // Per-channel ratio to the reference tint (clamped): the designed palette at the reference.
+        ratio.current.set(Math.min(4, color.r / SUN_REFERENCE_TINT.r), Math.min(4, color.g / SUN_REFERENCE_TINT.g), Math.min(4, color.b / SUN_REFERENCE_TINT.b));
+        const gain = Math.max(0, intensity / SUN_REFERENCE_INTENSITY);
+        for (const k of LAVA_COLORS)
+            c.lava.uniforms[k].value.copy(c.base[k]).multiply(ratio.current);
+        for (const k of CORONA_COLORS)
+            c.corona.uniforms[k].value.copy(c.base[k]).multiply(ratio.current);
+        c.lava.uniforms.u_brightness.value = c.base.u_brightness * gain;
+        if (c.corona.uniforms.u_intensity)
+            c.corona.uniforms.u_intensity.value = c.base.u_intensity * gain;
+        const light = c.light;
+        light.color.set(LIGHT_COLOR);
+        light.color.r *= ratio.current.x;
+        light.color.g *= ratio.current.y;
+        light.color.b *= ratio.current.z;
+        light.intensity = LIGHT_INTENSITY * gain;
+    });
+    return (_jsxs("group", { ref: rootRef, children: [_jsx(SunCore, { radius: radius, uniforms: coreUniforms }), _jsx(Corona, { radius: radius, shellScale: coronaScale, uniforms: coronaUniforms }), _jsx("pointLight", { ref: lightRef, color: LIGHT_COLOR, intensity: LIGHT_INTENSITY, distance: 60, decay: 1.6 })] }));
 }

package/dist/components/SunLight.d.ts

@@ -1,13 +1,18 @@
 import type { ObjectReadyProps } from '../types/objectReady';
 import * as THREE from 'three';
 import React from "react";
-import type { TimeSettings } from "@3driseai/3drise-core";
+import type { SkySettings, TimeSettings } from "@3driseai/3drise-core";
 export interface SunLightProps extends ObjectReadyProps {
     visible?: boolean;
     timeSettings: TimeSettings;
+    /** The sky this sun belongs to — the static sun when time of day is off and
+     *  no Preetham sky is publishing what it drew. */
+    skySettings?: SkySettings;
     targetPosition?: THREE.Vector3;
     shadowDistance?: number;
     intensity?: number;
+    /** Multiplier on moonlight. */
+    moonIntensity?: number;
     castShadow?: boolean;
     shadowMapSize?: number;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"SunLight.d.ts","sourceRoot":"","sources":["../../src/components/SunLight.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAE7D,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,aAAc,SAAQ,gBAAgB;IACnD,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;AAiBD,QAAA,MAAM,QAAQ,EAAE,KAAK,CAAC,EAAE,CAAC,aAAa,CA0CrC,CAAC;AACF,eAAe,QAAQ,CAAC"}
+{"version":3,"file":"SunLight.d.ts","sourceRoot":"","sources":["../../src/components/SunLight.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAE7D,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAKvE,MAAM,WAAW,aAAc,SAAQ,gBAAgB;IACnD,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,YAAY,EAAE,YAAY,CAAC;IAC3B;sDACkD;IAClD,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,cAAc,CAAC,EAAE,KAAK,CAAC,OAAO,CAAC;IAC/B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,+BAA+B;IAC/B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,CAAC;CAC1B;AAiED,QAAA,MAAM,QAAQ,EAAE,KAAK,CAAC,EAAE,CAAC,aAAa,CA0DrC,CAAC;AACF,eAAe,QAAQ,CAAC"}

package/dist/components/SunLight.js

@@ -1,59 +1,111 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { useObjectReady } from '../hooks/useObjectReady.js';
-import { useRef, useCallback } from 'react';
+import { useEffect, useRef } 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),
+import { useFrame, useThree } from '@react-three/fiber';
+import { useCloudSun, computeCloudSun } from '../hooks/useCloudSun.js';
+import { claimSceneSun } from '../utils/renderedSky.js';
+import { resolveMoon, moonlightFactor, MOON_LIGHT_COLOR } from '../utils/skyMoon.js';
+/**
+ * The scene's key light while a sky is active — the ONE sun.
+ *
+ * Direction comes from useCloudSun, the same resolver the clouds, the water and
+ * the terrain use: what the sky drew this frame, else the day-cycle clock, else
+ * the stored sun. So the disc, the light and every sky-lit surface agree.
+ *
+ * Colour is the direct beam through a clear atmosphere (Kasten-Young air mass,
+ * the cloud model's own computeCloudSun), white-balanced to the overhead sun:
+ * white at noon, warm through the afternoon, deep orange and dim at the horizon,
+ * with no colour tables or hour constants. The atmosphere for the beam is fixed
+ * to clear air on purpose: Preetham's turbidity/rayleigh are artistic sky knobs
+ * (the time curve pushes rayleigh to 3.5 at sunset) and fed into a physical beam
+ * they black the scene out at exactly the hour it should glow.
+ *
+ * Below the horizon it hands over to the moon: one light, so one set of
+ * shadows. Through twilight (sun −1° … −8°) moonlight fades in; its strength
+ * follows the lit fraction of the moon (full bright, new none) and the moon's
+ * own height. Cool tint, weaker and softer shadows. Neither up → light off.
+ *
+ * While mounted it claims the scene's sun, so LightsManager's general-purpose
+ * sun stands down (see claimSceneSun).
+ */
+/** Light intensity for the overhead sun at `intensity` 1. π because three's
+ *  physically-correct lights divide diffuse by π: at π a white surface facing
+ *  the overhead sun renders at its own albedo. Tuning knob. */
+const KEY_BASE_INTENSITY = Math.PI;
+/** Elevation, in degrees, over which the light fades in: the disc is fully
+ *  set at −1° (half-diameter plus refraction) and the beam is unoccluded by 4°. */
+const FADE_START = -1;
+const FADE_END = 4;
+/** Moonlight at full moon, overhead, `moonIntensity` 1. Real moonlight is
+ *  ~1/400 000 of the sun; this is compressed until exposure handles night.
+ *  Tuning knob. */
+const MOON_BASE_INTENSITY = 0.3;
+const SUN_SHADOW_INTENSITY = 1;
+const MOON_SHADOW_INTENSITY = 0.6;
+const smooth01 = (edge0, edge1, x) => {
+    const t = THREE.MathUtils.clamp((x - edge0) / (edge1 - edge0), 0, 1);
+    return t * t * (3 - 2 * t);
 };
-const MAX_ELEVATION = 42;
-const SUNRISE = 6;
-const SUNSET = 21;
-const DARKNESS_START = 20.42;
-const DARKNESS_END = 6.58;
+const elevationOf = (dir) => THREE.MathUtils.radToDeg(Math.asin(THREE.MathUtils.clamp(dir.y, -1, 1)));
+const CLEAR_AIR = { turbidity: 2, rayleigh: 1, mieCoefficient: 0.005 };
+const newSunState = () => ({
+    direction: new THREE.Vector3(),
+    color: new THREE.Color(),
+    skyAmbient: new THREE.Color(),
+    groundAmbient: new THREE.Color(),
+    turbidity: 0, rayleigh: 0, mieCoefficient: 0, mieG: 0,
+});
+/** Beam colour of the sun straight overhead — the white point. */
+const ZENITH = computeCloudSun(new THREE.Vector3(0, 1, 0), CLEAR_AIR, newSunState()).color.clone();
 /** Shared so the default does not hand a fresh Vector3 to the deps array on every
- *  render, which re-ran the reposition effect every time anything above re-rendered. */
+ *  render. */
 const ORIGIN = new THREE.Vector3(0, 0, 0);
-const SunLight = ({ visible = true, timeSettings, targetPosition = ORIGIN, shadowDistance = 300, intensity: intensityMultiplier = 1, castShadow = true, shadowMapSize = 2048, onObjectReady, onObjectDispose, }) => {
+const SunLight = ({ visible = true, timeSettings, skySettings, targetPosition = ORIGIN, shadowDistance = 300, intensity: intensityMultiplier = 1, moonIntensity = 1, castShadow = true, shadowMapSize = 2048, onObjectReady, onObjectDispose, }) => {
     const lightRef = useRef(null);
     useObjectReady(lightRef, { visible, timeSettings, intensity: intensityMultiplier, castShadow, shadowMapSize }, onObjectReady, onObjectDispose);
-    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);
+    const scene = useThree(s => s.scene);
+    const { update } = useCloudSun({ skySettings, timeSettings });
+    const beam = useRef(newSunState());
+    const moon = useRef({ direction: new THREE.Vector3(), illumination: 0 });
+    useEffect(() => {
+        if (!visible)
+            return;
+        return claimSceneSun(scene);
+    }, [scene, visible]);
+    useFrame(() => {
+        const light = lightRef.current;
+        if (!light)
+            return;
+        const sunDir = update().direction;
+        const sunElevation = elevationOf(sunDir);
+        const sunFade = smooth01(FADE_START, FADE_END, sunElevation);
+        let dir;
+        if (sunFade > 0) {
+            dir = sunDir;
+            const c = computeCloudSun(sunDir, CLEAR_AIR, beam.current).color;
+            light.color.setRGB(Math.min(1, c.r / ZENITH.r), Math.min(1, c.g / ZENITH.g), Math.min(1, c.b / ZENITH.b));
+            light.intensity = KEY_BASE_INTENSITY * intensityMultiplier * sunFade;
+            light.shadow.intensity = SUN_SHADOW_INTENSITY;
         }
         else {
-            targetColorRef.current.copy(COLORS.moon).multiplyScalar(1.8);
-            targetIntensityRef.current = 0.5;
+            // The sun is fully set, so the hand-over is continuous: the sun's term
+            // is already 0 at −1°, which is where night starts fading in.
+            const m = resolveMoon(timeSettings, sunDir, moon.current);
+            dir = m.direction;
+            light.color.setRGB(MOON_LIGHT_COLOR.r, MOON_LIGHT_COLOR.g, MOON_LIGHT_COLOR.b);
+            light.intensity = MOON_BASE_INTENSITY * moonIntensity * moonlightFactor(sunElevation, m);
+            light.shadow.intensity = MOON_SHADOW_INTENSITY;
         }
-        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);
+        if (light.intensity <= 1e-4) {
+            // Off, not dim: an invisible light also skips its shadow pass.
+            light.visible = false;
+            return;
         }
-    }, [targetPosition, shadowDistance, intensityMultiplier]);
-    useSkySystem({
-        timeSettings,
-        onTimeUpdate: handleTimeUpdate,
-        enabled: visible,
+        light.visible = true;
+        light.position.set(targetPosition.x + dir.x * shadowDistance, targetPosition.y + dir.y * shadowDistance, targetPosition.z + dir.z * shadowDistance);
+        light.target.position.copy(targetPosition);
+        light.target.updateMatrixWorld();
     });
     if (!visible)
         return null;

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

@@ -1 +1 @@
-{"version":3,"file":"TerrainBuilder.d.ts","sourceRoot":"","sources":["../../src/components/TerrainBuilder.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAkB,MAAM,OAAO,CAAC;AACvC,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AACvE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAC7D,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,uBAAuB,CAAC;AAOvE,MAAM,WAAW,mBAAoB,SAAQ,gBAAgB;IACzD;;mEAE+D;IAC/D,QAAQ,CAAC,EAAE,OAAO,CAAC,yBAAyB,CAAC,GAAG,IAAI,CAAC;IACrD,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,6EAA6E;IAC7E,YAAY,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;;;;;;GAYG;AACH,QAAA,MAAM,cAAc,EAAE,KAAK,CAAC,EAAE,CAAC,mBAAmB,CA+BjD,CAAC;AAEF,eAAe,cAAc,CAAC"}
+{"version":3,"file":"TerrainBuilder.d.ts","sourceRoot":"","sources":["../../src/components/TerrainBuilder.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAkB,MAAM,OAAO,CAAC;AACvC,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AACvE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAC7D,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,uBAAuB,CAAC;AAOvE,MAAM,WAAW,mBAAoB,SAAQ,gBAAgB;IACzD;;mEAE+D;IAC/D,QAAQ,CAAC,EAAE,OAAO,CAAC,yBAAyB,CAAC,GAAG,IAAI,CAAC;IACrD,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,6EAA6E;IAC7E,YAAY,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;;;;;;GAYG;AACH,QAAA,MAAM,cAAc,EAAE,KAAK,CAAC,EAAE,CAAC,mBAAmB,CAiCjD,CAAC;AAEF,eAAe,cAAc,CAAC"}

package/dist/components/TerrainBuilder.js

@@ -30,6 +30,8 @@ const TerrainBuilder = ({ settings, skySettings, timeSettings, sunIntensity, onO
         timeSettings,
         sunIntensity,
         id: settings?.id,
+        animations: settings?.animations,
+        mouseMove: settings?.mouseMove,
         onObjectReady,
         onObjectDispose,
     };

package/dist/components/TextGenerator.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { CreatedObjectSettings } from '@3driseai/3drise-core';
+import type { ObjectReadyProps } from '../types/objectReady';
+type TextGeneratorProps = ObjectReadyProps & {
+    createdObject: CreatedObjectSettings;
+};
+declare const TextGenerator: React.FC<TextGeneratorProps>;
+export default TextGenerator;
+//# sourceMappingURL=TextGenerator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TextGenerator.d.ts","sourceRoot":"","sources":["../../src/components/TextGenerator.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,KAAK,EAAE,qBAAqB,EAA2C,MAAM,uBAAuB,CAAC;AAC5G,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAG7D,KAAK,kBAAkB,GAAG,gBAAgB,GAAG;IACzC,aAAa,EAAE,qBAAqB,CAAC;CACxC,CAAC;AAkBF,QAAA,MAAM,aAAa,EAAE,KAAK,CAAC,EAAE,CAAC,kBAAkB,CAc/C,CAAC;AACF,eAAe,aAAa,CAAC"}

package/dist/components/TextGenerator.js

@@ -0,0 +1,29 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { HandwritingText, NeonTubeText, FourierSketchText, FrostGrowthText, PlasmaDischargeText, BurnAwayText, LightPaintingText, ConstellationText, InkBleedText, LiquidMetalText, EmbroideryText, ChalkboardText } from './text/index.js';
+/** The text looks' components by config.type (the legacy bitmap / 3D text is rendered by ObjectNode, not here). */
+const FAMILY = {
+    handwriting: HandwritingText,
+    neonTube: NeonTubeText,
+    fourierSketch: FourierSketchText,
+    frostGrowth: FrostGrowthText,
+    plasmaDischarge: PlasmaDischargeText,
+    burnAway: BurnAwayText,
+    lightPainting: LightPaintingText,
+    constellation: ConstellationText,
+    inkBleed: InkBleedText,
+    liquidMetal: LiquidMetalText,
+    embroidery: EmbroideryText,
+    chalkboard: ChalkboardText,
+};
+const TextGenerator = ({ createdObject, onObjectReady, onObjectDispose }) => {
+    const config = createdObject.config;
+    if (!config)
+        return null;
+    const Component = FAMILY[config.type];
+    if (!Component)
+        return null;
+    // Every look renders the same way: FAMILY is the only per-key entry. `enabled` is not a gate here: the text stays
+    // mounted and the look plays its erase animation when it goes false.
+    return _jsx(Component, { config: config, id: createdObject.id, keyframes: createdObject.animations?.text?.animations, mouseMove: createdObject.mouseMove?.text, onObjectReady: (_source, ref) => onObjectReady?.(createdObject, ref), onObjectDispose: (_source, ref) => onObjectDispose?.(createdObject, ref) });
+};
+export default TextGenerator;

package/dist/components/TruchetGrid.d.ts

@@ -0,0 +1,25 @@
+import type { ThreeElements } from '@react-three/fiber';
+import type { ObjectReadyProps } from '../types/objectReady';
+import type { TruchetGridConfig } from '../types/gridConfigs';
+import type { AnimationOptions, MouseMoveDomain } from '@3driseai/3drise-core';
+export interface TruchetGridProps extends ObjectReadyProps {
+    config?: TruchetGridConfig;
+    groupProps?: ThreeElements['group'];
+    /** Scene object id: the live-edit handle is found by it. */
+    id?: string;
+    /** Keyframes on this grid's config knobs (animations.grid.animations). */
+    keyframes?: AnimationOptions[];
+    /** Pointer bindings on this grid's config knobs (mouseMove.grid). */
+    mouseMove?: MouseMoveDomain;
+}
+/** TruchetGridConfig defaults: the core registry entry (DEFAULT_GRIDS.truchetGrid), never a copy. */
+export declare const defaultTruchetGridConfig: TruchetGridConfig;
+/**
+ * Smith quarter-circle Truchet tiles: arcs always meet arcs, so the plane fills with endless two-coloured loops. Tiles re-deal by turning a quarter turn, and comets travel the loops in one direction.
+ *
+ * The grid always lies flat: any other orientation, and any movement of the
+ * whole, is the parent object's transform. Only what happens inside it animates.
+ */
+export declare function TruchetGrid({ config, groupProps, id, keyframes, mouseMove, onObjectReady, onObjectDispose }: TruchetGridProps): import("react").JSX.Element;
+export default TruchetGrid;
+//# sourceMappingURL=TruchetGrid.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TruchetGrid.d.ts","sourceRoot":"","sources":["../../src/components/TruchetGrid.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAOxD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAC7D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAE9D,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAE/E,MAAM,WAAW,gBAAiB,SAAQ,gBAAgB;IACtD,MAAM,CAAC,EAAE,iBAAiB,CAAC;IAC3B,UAAU,CAAC,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;IACpC,4DAA4D;IAC5D,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,0EAA0E;IAC1E,SAAS,CAAC,EAAE,gBAAgB,EAAE,CAAC;IAC/B,qEAAqE;IACrE,SAAS,CAAC,EAAE,eAAe,CAAC;CAC/B;AAKD,qGAAqG;AACrG,eAAO,MAAM,wBAAwB,EAA2C,iBAAiB,CAAC;AAWlG;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,EAAE,MAAiC,EAAE,UAAU,EAAE,EAAE,EAAE,SAAS,EAAE,SAAS,EAAE,aAAa,EAAE,eAAe,EAAE,EAAE,gBAAgB,+BA4CxJ;AAED,eAAe,WAAW,CAAC"}