@3driseai/3drise-viewer 0.1.1

package/dist/components/Letters.js

@@ -0,0 +1,18 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useRef } from 'react';
+import Letter from './Letter.js';
+export default function Letters({ text, config, materialSettings, hoverSettings, transformEffects = [], colorEffects = [], onLetterClick, }) {
+    const ref = useRef(null);
+    const characters = text.split('');
+    const letterSpacing = config.letterSpacing || 0;
+    const spacing = 0.6 + letterSpacing;
+    const letters = characters.map((char, index) => {
+        const totalWidth = (characters.length - 1) * spacing;
+        const xOffset = index * spacing - totalWidth / 2;
+        return { char, index, position: [xOffset, 0, 0] };
+    });
+    const handleLetterClick = (object, letterData) => {
+        onLetterClick?.(letterData);
+    };
+    return (_jsx("group", { ref: ref, scale: [1, 1, 1], position: [0, 0, 0], rotation: [0, 0, 0], children: letters.map((letterData) => (_jsx(Letter, { letterData: letterData, config: config, materialSettings: materialSettings, hoverSettings: hoverSettings, transformEffects: transformEffects, colorEffects: colorEffects, isActive: false, onClick: (object) => handleLetterClick(object, letterData) }, `${letterData.char}-${letterData.index}`))) }));
+}

package/dist/components/LightObject.d.ts

@@ -0,0 +1,8 @@
+import React from "react";
+import type { CreatedObjectSettings } from "@3driseai/3drise-core";
+type LightObjectProps = {
+    createdObject: CreatedObjectSettings;
+};
+declare const LightObject: React.FC<LightObjectProps>;
+export default LightObject;
+//# sourceMappingURL=LightObject.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"LightObject.d.ts","sourceRoot":"","sources":["../../src/components/LightObject.tsx"],"names":[],"mappings":"AAKA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AACnE,KAAK,gBAAgB,GAAG;IACpB,aAAa,EAAE,qBAAqB,CAAC;CACxC,CAAC;AA4CF,QAAA,MAAM,WAAW,EAAE,KAAK,CAAC,EAAE,CAAC,gBAAgB,CAgB3C,CAAC;AACF,eAAe,WAAW,CAAC"}

package/dist/components/LightObject.js

@@ -0,0 +1,65 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useRef } from 'react';
+import { useThree } from '@react-three/fiber';
+import { useLightShadow } from '../hooks/useLightShadow.js';
+import { useLightAnimation } from '../hooks/useLightAnimation.js';
+import { useLightMouseMove } from '../hooks/useLightMouseMove.js';
+const DirectionalLightR3F = ({ config, animations, mouseMove }) => {
+    const lightRef = useRef(null);
+    useLightShadow(lightRef, config.shadow);
+    useLightAnimation(lightRef, animations);
+    useLightMouseMove(lightRef, mouseMove, { lightConfig: config });
+    return (_jsx("directionalLight", { ref: lightRef, color: config.color || '#ffffff', intensity: config.intensity ?? 1 }));
+};
+const SpotLightR3F = ({ config, animations, mouseMove }) => {
+    const { scene } = useThree();
+    const lightRef = useRef(null);
+    const targetRef = useRef(null);
+    const [tx, ty, tz] = config.targetPosition ?? [0, 0, 0];
+    useEffect(() => {
+        const light = lightRef.current;
+        if (!light)
+            return;
+        if (!targetRef.current) {
+            targetRef.current = light.target;
+            scene.add(targetRef.current);
+        }
+        targetRef.current.position.set(tx, ty, tz);
+        targetRef.current.updateMatrixWorld();
+        return () => {
+            if (targetRef.current) {
+                scene.remove(targetRef.current);
+                targetRef.current = null;
+            }
+        };
+    }, [scene, tx, ty, tz]);
+    useLightShadow(lightRef, config.shadow);
+    useLightAnimation(lightRef, animations);
+    useLightMouseMove(lightRef, mouseMove, { lightConfig: config });
+    return (_jsx("spotLight", { ref: lightRef, color: config.color || '#ffffff', intensity: config.intensity ?? 1, angle: config.angle ?? Math.PI / 4, penumbra: config.penumbra ?? 0.1, decay: config.decay ?? 1, distance: config.distance ?? 0 }));
+};
+const PointLightR3F = ({ config, animations, mouseMove }) => {
+    const lightRef = useRef(null);
+    useLightShadow(lightRef, config.shadow);
+    useLightAnimation(lightRef, animations);
+    useLightMouseMove(lightRef, mouseMove, { lightConfig: config });
+    return (_jsx("pointLight", { ref: lightRef, color: config.color || '#ffffff', intensity: config.intensity ?? 1, decay: config.decay ?? 1, distance: config.distance ?? 0 }));
+};
+const LightObject = ({ createdObject }) => {
+    const config = createdObject.config;
+    if (!config || config.enabled === false)
+        return null;
+    const animations = createdObject.animations?.light?.animations;
+    const mouseMove = createdObject.mouseMove?.light;
+    switch (config.type) {
+        case 'directional':
+            return _jsx(DirectionalLightR3F, { config: config, animations: animations, mouseMove: mouseMove });
+        case 'spot':
+            return _jsx(SpotLightR3F, { config: config, animations: animations, mouseMove: mouseMove });
+        case 'point':
+            return _jsx(PointLightR3F, { config: config, animations: animations, mouseMove: mouseMove });
+        default:
+            return null;
+    }
+};
+export default LightObject;

package/dist/components/LightsManager.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"LightsManager.d.ts","sourceRoot":"","sources":["../../src/components/LightsManager.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAG9D,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,MAAM,WAAW,kBAAkB;IAC/B,MAAM,EAAE,gBAAgB,CAAC;CAC5B;AAID,QAAA,MAAM,aAAa,EAAE,KAAK,CAAC,EAAE,CAAC,kBAAkB,CA+F/C,CAAC;AACF,eAAe,aAAa,CAAC"}

package/dist/components/LightsManager.js

@@ -0,0 +1,104 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { useRef, useEffect } from 'react';
+import { useFrame, useThree } from '@react-three/fiber';
+import { createSunPosition } from '@3driseai/3drise-core';
+import { Color, } from 'three';
+import { useLightAnimation } from '../hooks/useLightAnimation.js';
+const SUN_DISTANCE = 100;
+const LightsManager = ({ config }) => {
+    const { scene } = useThree();
+    const ambientLightRef = useRef(null);
+    const sunLightRef = useRef(null);
+    const ambientConfig = config.ambient;
+    const sunConfig = config.sun;
+    const followSun = config.followSun;
+    const handleAmbientLightChange = () => {
+        if (ambientLightRef.current && ambientConfig && ambientConfig.color) {
+            const light = ambientLightRef.current;
+            light.color = new Color(ambientConfig.color);
+            light.intensity = ambientConfig.intensity || 1;
+        }
+    };
+    const handleSunLightChange = () => {
+        const light = sunLightRef.current;
+        if (!light)
+            return;
+        const elevation = sunConfig?.elevation ?? 45;
+        const azimuth = sunConfig?.azimuth ?? -90;
+        const sunPos = createSunPosition(elevation, azimuth);
+        light.position.set(sunPos.x * SUN_DISTANCE, sunPos.y * SUN_DISTANCE, sunPos.z * SUN_DISTANCE);
+        light.target.position.set(0, 0, 0);
+        light.target.updateMatrixWorld();
+        light.color = new Color(sunConfig?.color || '#ffffff');
+        light.intensity = sunConfig?.intensity ?? 1;
+        const shadow = sunConfig?.shadow;
+        // undefined shadow.enabled → treat as on; only an explicit `false` disables.
+        const shadowsEnabled = (shadow?.enabled ?? true) && (config.enableShadows ?? true);
+        light.castShadow = shadowsEnabled;
+        if (shadow) {
+            if (shadow.mapSize !== undefined) {
+                const previousMapSize = light.shadow.mapSize.x;
+                light.shadow.mapSize.set(shadow.mapSize, shadow.mapSize);
+                // Force the renderer to recreate the shadow map texture when size changes
+                if (previousMapSize !== shadow.mapSize && light.shadow.map) {
+                    light.shadow.map.dispose();
+                    light.shadow.map = null;
+                }
+            }
+            if (shadow.bias !== undefined)
+                light.shadow.bias = shadow.bias;
+            if (shadow.normalBias !== undefined)
+                light.shadow.normalBias = shadow.normalBias;
+            if (shadow.radius !== undefined)
+                light.shadow.radius = shadow.radius;
+            if (shadow.intensity !== undefined)
+                light.shadow.intensity = shadow.intensity;
+            const cam = light.shadow.camera;
+            if (shadow.cameraNear !== undefined)
+                cam.near = shadow.cameraNear;
+            if (shadow.cameraFar !== undefined)
+                cam.far = shadow.cameraFar;
+            if (shadow.cameraLeft !== undefined)
+                cam.left = shadow.cameraLeft;
+            if (shadow.cameraRight !== undefined)
+                cam.right = shadow.cameraRight;
+            if (shadow.cameraTop !== undefined)
+                cam.top = shadow.cameraTop;
+            if (shadow.cameraBottom !== undefined)
+                cam.bottom = shadow.cameraBottom;
+            cam.updateProjectionMatrix();
+        }
+    };
+    useEffect(() => {
+        handleAmbientLightChange();
+    }, [ambientConfig]);
+    useEffect(() => {
+        handleSunLightChange();
+    }, [sunConfig]);
+    // Drive keyframe animations stored on ambient / sun configs. These arrays are
+    // populated by the per-light Animation tab in LightSettings.
+    useLightAnimation(ambientLightRef, ambientConfig?.animations);
+    useLightAnimation(sunLightRef, sunConfig?.animations);
+    // directionalLight needs its target object in the scene
+    useEffect(() => {
+        const light = sunLightRef.current;
+        if (!light)
+            return;
+        scene.add(light.target);
+        return () => {
+            scene.remove(light.target);
+        };
+    }, [scene]);
+    useFrame((state) => {
+        if (followSun && sunLightRef.current) {
+            const time = state.clock.getElapsedTime();
+            const slowRotation = time * 0.01;
+            const dynamicElevation = sunConfig?.elevation || 45;
+            const dynamicAzimuth = (sunConfig?.azimuth || -90) + slowRotation;
+            const sunPosition = createSunPosition(dynamicElevation, dynamicAzimuth);
+            sunLightRef.current.position.set(sunPosition.x * SUN_DISTANCE, sunPosition.y * SUN_DISTANCE, sunPosition.z * SUN_DISTANCE);
+        }
+    });
+    return (_jsxs(_Fragment, { children: [_jsx("ambientLight", { ref: ambientLightRef, color: ambientConfig?.color, intensity: ambientConfig?.intensity, visible: ambientConfig?.enabled }), _jsx("directionalLight", { visible: sunConfig?.enabled, ref: sunLightRef, color: sunConfig?.color || '#ffffff', intensity: sunConfig?.intensity ?? 1, castShadow: config.enableShadows ?? true })] }));
+};
+export default LightsManager;

package/dist/components/Lines.d.ts

@@ -0,0 +1,9 @@
+import type { ParticlesSettings } from '@3driseai/3drise-core';
+import React from "react";
+interface LinesProps {
+    createdObject: ParticlesSettings;
+    transitionSettings?: Record<string, any>;
+}
+declare const Lines: React.FC<LinesProps>;
+export default Lines;
+//# sourceMappingURL=Lines.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Lines.d.ts","sourceRoot":"","sources":["../../src/components/Lines.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE/D,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,UAAU,UAAU;IAChB,aAAa,EAAE,iBAAiB,CAAC;IACjC,kBAAkB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAC5C;AAGD,QAAA,MAAM,KAAK,EAAE,KAAK,CAAC,EAAE,CAAC,UAAU,CAa/B,CAAC;AACF,eAAe,KAAK,CAAC"}

package/dist/components/Lines.js

@@ -0,0 +1,19 @@
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { useMemo } from 'react';
+import { PositionsCreator } from '@3driseai/3drise-core';
+import Path from './Path.js';
+const Lines = ({ createdObject, transitionSettings }) => {
+    if (!createdObject)
+        return null;
+    const { config } = createdObject;
+    const color = createdObject.materialSettings && 'color' in createdObject.materialSettings
+        ? createdObject.materialSettings.color
+        : '#ffffff';
+    const targetShape = (transitionSettings?.shapeType && typeof transitionSettings.shapeType === 'string')
+        ? transitionSettings.shapeType
+        : config.shapeType;
+    const curves = useMemo(() => PositionsCreator.generatePaths(config.shapeType), [config.shapeType]);
+    const targetCurves = useMemo(() => PositionsCreator.generatePaths(targetShape), [targetShape]);
+    return (_jsx(_Fragment, { children: curves.map((currentCurve, index) => (_jsx(Path, { curve: currentCurve, targetCurve: targetCurves[index % targetCurves.length], duration: 1, color: color }, `path-${index}`))) }));
+};
+export default Lines;

package/dist/components/LoadingIndicator.d.ts

@@ -0,0 +1,10 @@
+import React from "react";
+export interface LoadingIndicatorProps {
+    text?: string;
+    fullScreen?: boolean;
+    animate?: boolean;
+    size?: number;
+}
+declare const LoadingIndicator: React.FC<LoadingIndicatorProps>;
+export default LoadingIndicator;
+//# sourceMappingURL=LoadingIndicator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"LoadingIndicator.d.ts","sourceRoot":"","sources":["../../src/components/LoadingIndicator.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,MAAM,WAAW,qBAAqB;IAClC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;CACjB;AAGD,QAAA,MAAM,gBAAgB,EAAE,KAAK,CAAC,EAAE,CAAC,qBAAqB,CAErD,CAAC;AACF,eAAe,gBAAgB,CAAC"}

package/dist/components/LoadingIndicator.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import RiseLogo from './RiseLogo.js';
+const LoadingIndicator = ({ text, fullScreen = false, animate = true, size = 80, }) => {
+    return (_jsxs(_Fragment, { children: [text && _jsx("div", { className: "loading-text", children: text }), _jsx(RiseLogo, { size: size, animated: animate, loop: true })] }));
+};
+export default LoadingIndicator;

package/dist/components/MaterialLibrary.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+import type { MaterialSettings } from "@3driseai/3drise-core";
+export interface MaterialLibraryProps {
+    materialSettings: MaterialSettings;
+    children?: React.ReactNode;
+}
+declare const MaterialLibrary: React.FC<MaterialLibraryProps>;
+export default MaterialLibrary;
+//# sourceMappingURL=MaterialLibrary.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MaterialLibrary.d.ts","sourceRoot":"","sources":["../../src/components/MaterialLibrary.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,MAAM,WAAW,oBAAoB;IACjC,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;CAC9B;AAGD,QAAA,MAAM,eAAe,EAAE,KAAK,CAAC,EAAE,CAAC,oBAAoB,CAoDnD,CAAC;AACF,eAAe,eAAe,CAAC"}

package/dist/components/MaterialLibrary.js

@@ -0,0 +1,57 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useRef } from 'react';
+import { MeshReflectorMaterial, MeshRefractionMaterial, MeshTransmissionMaterial, MeshDistortMaterial, MeshWobbleMaterial, MeshDiscardMaterial, MeshPortalMaterial, } from '@react-three/drei';
+const MaterialLibrary = ({ materialSettings }) => {
+    const variant = materialSettings.materialVariant;
+    const cubeCameraTexture = useRef(null);
+    const getSettings = (defaultSettings) => {
+        const settings = { ...defaultSettings };
+        Object.keys(materialSettings).forEach(key => {
+            if (key in settings && key !== 'materialType' && key !== 'materialVariant' && key !== 'handlers') {
+                settings[key] = materialSettings[key];
+            }
+        });
+        return settings;
+    };
+    switch (variant) {
+        case 'Reflector':
+            return _jsx(MeshReflectorMaterial, { ...getSettings({
+                    color: "#777777", roughness: 0.1, metalness: 1.0,
+                    blur: [300, 100], resolution: 512, mixBlur: 1, mixStrength: 40,
+                    depthScale: 1, minDepthThreshold: 0.1, maxDepthThreshold: 1,
+                    depthToBlurRatioBias: 0.25, mirror: 1, distortion: 1, mixContrast: 1,
+                    ...materialSettings,
+                }) });
+        case 'Refraction':
+            if (cubeCameraTexture.current)
+                return _jsx(MeshRefractionMaterial, { envMap: cubeCameraTexture.current, ...getSettings({
+                        color: "#ffffff", ior: 2.4, fresnel: 0, aberrationStrength: 0.01, fastChroma: true, ...materialSettings,
+                    }) });
+            return _jsx("meshStandardMaterial", { color: "#ffffff" });
+        case 'Transmission':
+            return _jsx(MeshTransmissionMaterial, { ...getSettings({
+                    transmission: 1, thickness: 0.2, roughness: 0.0, chromaticAberration: 0.03,
+                    anisotropy: 0.1, anisotropicBlur: 0.1, distortion: 0.0, distortionScale: 0.3,
+                    temporalDistortion: 0.5, transmissionSampler: true, backside: false,
+                    backsideThickness: 0.2, backsideEnvMapIntensity: 1, resolution: 256,
+                    backsideResolution: 256, samples: 10, ...materialSettings,
+                }) });
+        case 'Distort':
+            return _jsx(MeshDistortMaterial, { ...getSettings({
+                    color: "#ffffff", distort: 0.5, speed: 2, radius: 1, ...materialSettings,
+                }) });
+        case 'Wobble':
+            return _jsx(MeshWobbleMaterial, { ...getSettings({
+                    color: "#ffffff", factor: 1, speed: 2, ...materialSettings,
+                }) });
+        case 'Discard':
+            return _jsx(MeshDiscardMaterial, {});
+        case 'Portal':
+            return _jsx(MeshPortalMaterial, { blur: 0, resolution: 512, ...getSettings({
+                    blend: 1, resolution: 512, ...materialSettings,
+                }) });
+        default:
+            return _jsx("meshStandardMaterial", { color: "#ffffff" });
+    }
+};
+export default MaterialLibrary;

package/dist/components/Moon.d.ts

@@ -0,0 +1,13 @@
+import type { Mesh } from 'three';
+import React from "react";
+import type { MoonSettings } from "@3driseai/3drise-core";
+export interface MoonProps {
+    settings?: MoonSettings;
+    sunPosition?: [number, number, number];
+    onMeshReady?: (mesh: Mesh) => void;
+}
+export type { MoonSettings };
+export { defaultMoonSettings } from '@3driseai/3drise-core';
+declare const Moon: React.FC<MoonProps>;
+export default Moon;
+//# sourceMappingURL=Moon.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Moon.d.ts","sourceRoot":"","sources":["../../src/components/Moon.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC;AAElC,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAC1D,MAAM,WAAW,SAAS;IACtB,QAAQ,CAAC,EAAE,YAAY,CAAC;IACxB,WAAW,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACvC,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI,CAAC;CACtC;AAED,YAAY,EAAE,YAAY,EAAE,CAAC;AAG7B,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAE5D,QAAA,MAAM,IAAI,EAAE,KAAK,CAAC,EAAE,CAAC,SAAS,CAyD7B,CAAC;AAEF,eAAe,IAAI,CAAC"}

package/dist/components/Moon.js

@@ -0,0 +1,66 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useRef, useEffect, useState, useCallback } from 'react';
+import { TextureLoader, Vector3 } from 'three';
+import { useFrame } from '@react-three/fiber';
+export { defaultMoonSettings } from '@3driseai/3drise-core';
+const MOON_TEXTURE_URL = "https://3d-rise.sfo3.cdn.digitaloceanspaces.com/app/images/moon_1024.jpg";
+const Moon = ({ settings, sunPosition, onMeshReady }) => {
+    const meshRef = useRef(null);
+    const lightRef = useRef(null);
+    const targetRef = useRef(null);
+    const [texture, setTexture] = useState(null);
+    useEffect(() => {
+        const loader = new TextureLoader();
+        loader.setCrossOrigin('anonymous');
+        let cancelled = false;
+        loader.load(MOON_TEXTURE_URL, (loaded) => {
+            console.log("Moon texture loaded:", loaded);
+            if (!cancelled)
+                setTexture(loaded);
+        }, undefined, () => {
+            // Silently ignore — moon renders as a plain lit sphere if the texture fails.
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, []);
+    const s = settings ?? {
+        visible: true,
+        position: [0, 0, 0],
+        scale: 3,
+        rotation: [0, 0, 0.5],
+        emissiveIntensity: 0.3,
+        orbitRadius: 250,
+        enableOrbit: false,
+        orbitSpeed: 0.1,
+    };
+    const handleMeshRef = useCallback((mesh) => {
+        if (mesh) {
+            meshRef.current = mesh;
+            onMeshReady?.(mesh);
+        }
+    }, [onMeshReady]);
+    useFrame((state) => {
+        const moonPos = sunPosition ?? s.position;
+        if (meshRef.current && s.enableOrbit) {
+            const time = state.clock.getElapsedTime();
+            const speed = s.orbitSpeed ?? 0.1;
+            const radius = s.orbitRadius ?? 250;
+            meshRef.current.position.x = Math.cos(time * speed) * radius;
+            meshRef.current.position.z = Math.sin(time * speed) * radius;
+            meshRef.current.rotation.y += 0.001;
+        }
+        if (lightRef.current && targetRef.current) {
+            const cameraPos = state.camera.position;
+            const moonPosition = meshRef.current?.position ?? new Vector3(...moonPos);
+            const dirToMoon = new Vector3().subVectors(moonPosition, cameraPos).normalize();
+            const dist = cameraPos.distanceTo(moonPosition) * 0.2;
+            lightRef.current.position.copy(cameraPos).addScaledVector(dirToMoon, dist);
+            targetRef.current.position.copy(moonPosition);
+        }
+    });
+    const moonPos = sunPosition ?? s.position;
+    return (_jsxs("group", { userData: { id: '3drise-moon' }, children: [_jsx("object3D", { ref: targetRef, position: moonPos }), _jsx("directionalLight", { ref: lightRef, intensity: 2, color: 0xffffff, target: targetRef.current ?? undefined }), _jsxs("mesh", { ref: handleMeshRef, position: moonPos, rotation: s.rotation, scale: s.scale, visible: s.visible, children: [_jsx("sphereGeometry", { args: [1, 32, 32] }), _jsx("meshPhongMaterial", { color: 0xb2b2b2, normalMap: texture, shininess: 0 })] })] }));
+};
+Moon.displayName = 'Moon';
+export default Moon;

package/dist/components/MyGrid.d.ts

@@ -0,0 +1,15 @@
+import type { ThreeElements } from '@react-three/fiber';
+import type { MyGridConfig } from '@3driseai/3drise-core';
+export interface MyGridProps {
+    config?: MyGridConfig;
+    groupProps?: ThreeElements['group'];
+}
+/**
+ * MyGridConfig — the single source of truth for a grid instance.
+ * Colors are hex strings so they round-trip cleanly through the controller
+ * and any preset/serialization layer.
+ */
+export declare const defaultMyGridConfig: MyGridConfig;
+export declare function MyGrid({ config, groupProps }: MyGridProps): import("react").JSX.Element;
+export default MyGrid;
+//# sourceMappingURL=MyGrid.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MyGrid.d.ts","sourceRoot":"","sources":["../../src/components/MyGrid.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAExD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAC1D,MAAM,WAAW,WAAW;IACxB,MAAM,CAAC,EAAE,YAAY,CAAC;IACtB,UAAU,CAAC,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;CACvC;AAID;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,EAAE,YAuBjC,CAAC;AACF,wBAAgB,MAAM,CAAC,EAAE,MAA4B,EAAE,UAAU,EAAE,EAAE,WAAW,+BAkC/E;AACD,eAAe,MAAM,CAAC"}

package/dist/components/MyGrid.js

@@ -0,0 +1,72 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useMemo, useRef } from 'react';
+import * as THREE from 'three';
+import { useFrame } from '@react-three/fiber';
+import { MyGridMaterial, } from '@3driseai/3drise-core';
+// Side-effect import registers <myGridMaterial> via extend() in MyGridMaterial.ts.
+void MyGridMaterial;
+/**
+ * MyGridConfig — the single source of truth for a grid instance.
+ * Colors are hex strings so they round-trip cleanly through the controller
+ * and any preset/serialization layer.
+ */
+export const defaultMyGridConfig = {
+    cellSize: 1,
+    size: 50,
+    segments: undefined,
+    flat: true,
+    lineMode: 2, // flow
+    cellMode: 2, // twinkle
+    lineWidth: 1,
+    sectionSize: 5,
+    sectionWidth: 1.6,
+    animSpeed: 1,
+    animScale: 0.5,
+    animIntensity: 1,
+    fadeDistance: undefined,
+    fadeStrength: 0.65,
+    displace: 0,
+    lineColor: '#477fb8',
+    sectionColor: '#80c7ff',
+    cellColor: '#1a5999',
+    glowColor: '#339eff',
+    bgColor: '#05080d',
+    bgOpacity: 0,
+    followMouse: false,
+};
+export function MyGrid({ config = defaultMyGridConfig, groupProps }) {
+    const matRef = useRef(null);
+    const meshRef = useRef(null);
+    const { cellSize, size, segments, flat, lineMode, cellMode, lineWidth, sectionSize, sectionWidth, animSpeed, animScale, animIntensity, fadeDistance, fadeStrength, displace, lineColor, sectionColor, cellColor, glowColor, bgColor, bgOpacity, followMouse, } = config;
+    const segs = segments ?? (displace > 0 ? Math.max(64, Math.ceil(size / cellSize) * 2) : 1);
+    const fade = fadeDistance ?? size * 0.5;
+    // memoize Color objects so we only re-allocate when the hex actually changes
+    const colors = useMemo(() => ({
+        line: new THREE.Color(lineColor),
+        section: new THREE.Color(sectionColor),
+        cell: new THREE.Color(cellColor),
+        glow: new THREE.Color(glowColor),
+        bg: new THREE.Color(bgColor),
+    }), [lineColor, sectionColor, cellColor, glowColor, bgColor]);
+    // scratch objects for mouse → plane projection
+    const ray = useMemo(() => new THREE.Raycaster(), []);
+    const plane = useMemo(() => new THREE.Plane(new THREE.Vector3(0, 1, 0), 0), []);
+    const hit = useMemo(() => new THREE.Vector3(), []);
+    useFrame((state) => {
+        const m = matRef.current;
+        if (!m)
+            return;
+        m.u_time = state.clock.elapsedTime;
+        m.u_mouse.copy(state.pointer); // NDC Vector2 — convention
+        if (followMouse && meshRef.current) {
+            ray.setFromCamera(state.pointer, state.camera);
+            plane.normal.set(0, 1, 0);
+            if (ray.ray.intersectPlane(plane, hit)) {
+                meshRef.current.worldToLocal(hit); // works regardless of host transform
+                m.u_focus.set(hit.x, hit.y);
+            }
+        }
+    });
+    return (_jsx("group", { ...groupProps, children: _jsxs("mesh", { ref: meshRef, rotation: flat ? [-Math.PI / 2, 0, 0] : [0, 0, 0], children: [_jsx("planeGeometry", { args: [size, size, segs, segs] }), _jsx("myGridMaterial", { ref: matRef, transparent: true, depthWrite: false, blending: THREE.AdditiveBlending, side: THREE.DoubleSide, u_cellSize: cellSize, u_lineWidth: lineWidth, u_sectionSize: sectionSize, u_sectionWidth: sectionWidth, u_lineMode: lineMode, u_cellMode: cellMode, u_animSpeed: animSpeed, u_animScale: animScale, u_animIntensity: animIntensity, u_fadeDistance: fade, u_fadeStrength: fadeStrength, u_displace: displace, u_lineColor: colors.line, u_sectionColor: colors.section, u_cellColor: colors.cell, u_glowColor: colors.glow, u_bgColor: colors.bg, u_bgOpacity: bgOpacity }, MyGridMaterial.key)] }) }));
+}
+export default MyGrid;

package/dist/components/ObjectNode.d.ts

@@ -0,0 +1,13 @@
+import React from "react";
+import { Object3D } from "three";
+import type { CameraState, CreatedObjectSettings, ObjectTreeNode } from "@3driseai/3drise-core";
+import { type ThreeEvent } from "@react-three/fiber";
+type ObjectNodeProps = {
+    node: ObjectTreeNode;
+    cameraSettings: CameraState;
+    onObjectReady?: (object: CreatedObjectSettings, ref: Object3D) => void;
+    handleObjectClick?: (object: CreatedObjectSettings, ref: Object3D, event: ThreeEvent<MouseEvent>) => void;
+};
+declare const ObjectNode: React.FC<ObjectNodeProps>;
+export default ObjectNode;
+//# sourceMappingURL=ObjectNode.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ObjectNode.d.ts","sourceRoot":"","sources":["../../src/components/ObjectNode.tsx"],"names":[],"mappings":"AAcA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AACjC,OAAO,KAAK,EAAE,WAAW,EAAE,qBAAqB,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAChG,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACrD,KAAK,eAAe,GAAG;IACnB,IAAI,EAAE,cAAc,CAAC;IACrB,cAAc,EAAE,WAAW,CAAC;IAC5B,aAAa,CAAC,EAAE,CAAC,MAAM,EAAE,qBAAqB,EAAE,GAAG,EAAE,QAAQ,KAAK,IAAI,CAAC;IACvE,iBAAiB,CAAC,EAAE,CAAC,MAAM,EAAE,qBAAqB,EAAE,GAAG,EAAE,QAAQ,EAAE,KAAK,EAAE,UAAU,CAAC,UAAU,CAAC,KAAK,IAAI,CAAC;CAC7G,CAAC;AA8BF,QAAA,MAAM,UAAU,EAAE,KAAK,CAAC,EAAE,CAAC,eAAe,CA+FzC,CAAC;AACF,eAAe,UAAU,CAAC"}