@3driseai/3drise-viewer 0.1.1

package/dist/components/Clouds.js

@@ -0,0 +1,278 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useRef, useCallback } from 'react';
+import * as THREE from 'three';
+import { useThree, useFrame } from '@react-three/fiber';
+import { useSkySystem } from '../hooks/useSkySystem.js';
+import { useAnimationEvents } from '../hooks/useAnimationEvents.js';
+import { useNumericAnimation } from '../hooks/useNumericAnimation.js';
+import { calculateTimeProgress, applyEasing, gsapEasingMap, interpolateValue, interpolateMouseMoveProperty, } from '@3driseai/3drise-core';
+const CLOUD_COLORS = {
+    night: new THREE.Color(0.1, 0.1, 0.2),
+    sunrise: new THREE.Color(0.8, 0.4, 0.4),
+    midday: new THREE.Color(1.0, 1.0, 1.0),
+    sunset: new THREE.Color(0.8, 0.3, 0.3),
+};
+const DEFAULT_MATERIAL = {
+    materialType: 'clouds',
+    materialVariant: 'Sky Clouds Bright',
+    u_time: 0,
+    u_resolution: [800, 600],
+    u_cameraPos: [0, 0, 0],
+    u_cloudColor: [1.0, 1.0, 1.0],
+};
+// =============================================================================
+// Per-domain helpers (clouds-specific writes for the `clouds` domain)
+// =============================================================================
+function applyCloudsKeyframeAnimations(animations, startValuesCache, config, override, currentTime) {
+    if (!animations?.length)
+        return;
+    override.speed = undefined; // reset before each pass
+    for (const anim of animations) {
+        const { property, to, duration, ease, loop = false, yoyo = false, active } = anim;
+        if (!active || to === undefined)
+            continue;
+        if (property !== 'speed')
+            continue;
+        let from = anim.from;
+        if (from === undefined) {
+            from = startValuesCache[property] ??= (config.speed ?? 1);
+        }
+        let p = calculateTimeProgress(currentTime, duration, yoyo, loop);
+        if (ease) {
+            const fn = gsapEasingMap[ease] || ease;
+            p = applyEasing(fn, p);
+        }
+        override.speed = interpolateValue(property, from, to, p);
+    }
+}
+function applyCloudsMouseMove(properties, config, override, pointer) {
+    if (!properties?.length)
+        return;
+    override.speed = undefined;
+    for (const { property, enabled, propertySettings } of properties) {
+        if (!enabled || property !== 'speed')
+            continue;
+        const { axis = 'both', sensitivity = 1, inverted = false, min, max } = propertySettings || {};
+        const base = config.speed ?? 1;
+        override.speed = interpolateMouseMoveProperty(base, min, max, pointer, axis, sensitivity, inverted);
+    }
+}
+// Project legacy flat `handlers.onMouseMove.properties[]` shape into per-domain
+// buckets so we can route it through the new handlers without a save migration.
+function projectLegacyHandlersToDomain(legacy) {
+    const transform = [];
+    const material = [];
+    const clouds = [];
+    if (!legacy)
+        return { transform, material, clouds };
+    for (const cfg of legacy) {
+        const enabledP = { property: cfg.property, enabled: cfg.enabled ?? true, propertySettings: cfg.propertySettings };
+        if (cfg.property === 'speed')
+            clouds.push(enabledP);
+        else if (cfg.property === 'position' || cfg.property === 'rotation' || cfg.property === 'scale')
+            transform.push(enabledP);
+        else
+            material.push(enabledP);
+    }
+    return { transform, material, clouds };
+}
+// =============================================================================
+// MAIN COMPONENT
+// =============================================================================
+const defaultTimeSettings = {
+    enabled: false,
+    timescale: 1,
+    timeOfDay: 12,
+    syncWithRealTime: false,
+    autoAnimate: false,
+};
+const Clouds = ({ settings, timeSettings = defaultTimeSettings }) => {
+    const visible = settings.meshSettings.visible ?? true;
+    const meshSettings = settings.meshSettings;
+    const config = settings.config;
+    const materialSettings = settings.materialSettings;
+    const position = meshSettings.position;
+    const scale = meshSettings.scale;
+    // console.log(config.speed)
+    const baseSpeed = config.speed ?? 1;
+    // console.log(baseSpeed)
+    const height = position[1];
+    const planeSize = config?.planeSize || [10000, 10000];
+    const planeSegments = config?.planeSegments || 64;
+    const meshRef = useRef(null);
+    const cloudAnimTime = useRef(0);
+    const { camera } = useThree();
+    const cloudColorRef = useRef(new THREE.Color(1, 1, 1));
+    const targetCloudColorRef = useRef(new THREE.Color(1, 1, 1));
+    // Sequence-driven numeric anims (legacy `useAnimationEvents` path)
+    const numericOverrideRef = useRef(null);
+    const { animateNumeric } = useNumericAnimation();
+    // Per-domain animation + mouseMove overrides
+    const animatedOverrideRef = useRef({});
+    const mouseOverrideRef = useRef({});
+    // Keyframe-animation start-value caches (one per domain that uses them)
+    const transformAnimCacheRef = useRef({});
+    const materialAnimCacheRef = useRef({});
+    const cloudsAnimCacheRef = useRef({});
+    // useMaterialApplication(visible ? (meshRef.current as any) : null, materialSettings, true);
+    const handleTimeUpdate = useCallback((state) => {
+        const { normalizedTime, isDaytime, delta } = state;
+        if (isDaytime) {
+            if (normalizedTime <= 0.15) {
+                targetCloudColorRef.current.lerpColors(CLOUD_COLORS.night, CLOUD_COLORS.sunrise, normalizedTime / 0.15);
+            }
+            else if (normalizedTime <= 0.25) {
+                targetCloudColorRef.current.lerpColors(CLOUD_COLORS.sunrise, CLOUD_COLORS.midday, (normalizedTime - 0.15) / 0.10);
+            }
+            else if (normalizedTime <= 0.75) {
+                targetCloudColorRef.current.copy(CLOUD_COLORS.midday);
+            }
+            else if (normalizedTime <= 0.85) {
+                targetCloudColorRef.current.lerpColors(CLOUD_COLORS.midday, CLOUD_COLORS.sunset, (normalizedTime - 0.75) / 0.10);
+            }
+            else {
+                targetCloudColorRef.current.lerpColors(CLOUD_COLORS.sunset, CLOUD_COLORS.night, (normalizedTime - 0.85) / 0.15);
+            }
+        }
+        else {
+            targetCloudColorRef.current.copy(CLOUD_COLORS.night);
+        }
+        const colorLerpSpeed = Math.min(1, 2.0 * (delta || 0.016));
+        cloudColorRef.current.lerp(targetCloudColorRef.current, colorLerpSpeed);
+    }, []);
+    const { sunDirection } = useSkySystem({
+        timeSettings,
+        onTimeUpdate: handleTimeUpdate,
+        enabled: visible,
+    });
+    // Legacy sequence-driven `speed`/`scale` anims via `useAnimationEvents`
+    useAnimationEvents({
+        onStepStart: (event) => {
+            if (!event.step?.transitions)
+                return;
+            for (const transition of event.step.transitions) {
+                if (transition.state !== 'clouds' || !meshRef.current)
+                    continue;
+                const toProps = transition.properties.to || {};
+                const fromProps = transition.properties.from || {};
+                if (toProps.visible !== undefined)
+                    meshRef.current.visible = toProps.visible;
+                const KEYS = ['speed', 'scale'];
+                const from = {};
+                const to = {};
+                for (const k of KEYS) {
+                    const toVal = toProps[k];
+                    if (toVal === undefined)
+                        continue;
+                    to[k] = toVal;
+                    const sourceFallback = k === 'speed' ? baseSpeed : scale;
+                    from[k] = fromProps[k] ?? sourceFallback;
+                }
+                if (Object.keys(to).length > 0) {
+                    animateNumeric(from, to, (updated) => {
+                        numericOverrideRef.current = { ...numericOverrideRef.current, ...updated };
+                    }, () => {
+                        numericOverrideRef.current = null;
+                    }, event.step?.duration);
+                }
+            }
+        },
+    });
+    useFrame((state) => {
+        const mesh = meshRef.current;
+        if (!mesh || !mesh.visible || !mesh.material)
+            return;
+        const material = mesh.material;
+        const uniforms = material?.uniforms;
+        if (!uniforms)
+            return;
+        const now = Date.now();
+        const pointer = state.pointer;
+        // ── PER-DOMAIN ANIMATIONS ────────────────────────────────────────────────
+        const mouseMove = settings.mouseMove;
+        // const isPerDomain = mm && ('transform' in mm || 'material' in mm || 'edges' in mm || 'light' in mm || 'clouds' in mm);
+        // transform: position / rotation / scale
+        // const transformAnims = settings.animations?.transform?.animations;
+        // if (transformAnims?.length) {
+        //   handleTransformAnimations(
+        //     { object: mesh, meshSettings: meshSettings as any, pathIsActive: false },
+        //     transformAnims,
+        //     now,
+        //     false,
+        //   );
+        // }
+        // // material: shader uniforms
+        // const materialAnims = settings.animations?.material?.animations;
+        // if (materialAnims?.length) {
+        //   handleMaterialAnimations(
+        //     { object: mesh, materialSettings: materialSettings as any, startValuesCache: materialAnimCacheRef.current },
+        //     materialAnims,
+        //     now,
+        //     false,
+        //   );
+        // }
+        // clouds: speed
+        applyCloudsKeyframeAnimations(settings.animations?.clouds?.animations, cloudsAnimCacheRef.current, config, animatedOverrideRef.current, now);
+        // ── PER-DOMAIN MOUSE-MOVE ─────────────────────────────────────────────────
+        if (mouseMove) {
+            const perDomain = mouseMove;
+            // if (perDomain.transform?.enabled && perDomain.transform.properties?.length) {
+            //   handleTransformMouseMove(
+            //     { object: mesh, meshSettings: meshSettings as any },
+            //     perDomain.transform.properties,
+            //     pointer,
+            //   );
+            // }
+            // if (perDomain.material?.enabled && perDomain.material.properties?.length) {
+            //   handleMaterialMouseMove(
+            //     { object: mesh, materialSettings: materialSettings as any },
+            //     perDomain.material.properties,
+            //     pointer,
+            //   );
+            // }
+            applyCloudsMouseMove(perDomain.clouds?.enabled ? perDomain.clouds.properties : undefined, config, mouseOverrideRef.current, pointer);
+        }
+        // ── EFFECTIVE SPEED + UNIFORM UPDATES ─────────────────────────────────────
+        const effectiveSpeed = animatedOverrideRef.current.speed
+            ?? numericOverrideRef.current?.speed
+            ?? mouseOverrideRef.current.speed
+            ?? baseSpeed;
+        // console.log(effectiveSpeed)
+        // console.log(effectiveSpeed)
+        cloudAnimTime.current += 0.02 * effectiveSpeed;
+        // console.log(cloudAnimTime.current)
+        if (uniforms.u_time)
+            uniforms.u_time.value = cloudAnimTime.current;
+        if (uniforms.u_cameraPos) {
+            uniforms.u_cameraPos.value?.copy
+                ? uniforms.u_cameraPos.value.copy(camera.position)
+                : (uniforms.u_cameraPos.value = camera.position.clone());
+        }
+        if (uniforms.u_cloudColor) {
+            uniforms.u_cloudColor.value?.copy
+                ? uniforms.u_cloudColor.value.copy(cloudColorRef.current)
+                : (uniforms.u_cloudColor.value = cloudColorRef.current.clone());
+        }
+        if (uniforms.u_resolution) {
+            uniforms.u_resolution.value?.set
+                ? uniforms.u_resolution.value.set(window.innerWidth, window.innerHeight)
+                : (uniforms.u_resolution.value = new THREE.Vector2(window.innerWidth, window.innerHeight));
+        }
+        if (uniforms.u_sunPosition && sunDirection) {
+            uniforms.u_sunPosition.value?.copy
+                ? uniforms.u_sunPosition.value.copy(sunDirection)
+                : (uniforms.u_sunPosition.value = sunDirection.clone());
+        }
+        // Apply scale override (sequence-driven path only — per-domain transform anims
+        // already mutate mesh.scale through handleTransformAnimations).
+        if (numericOverrideRef.current?.scale !== undefined) {
+            mesh.scale.setScalar(numericOverrideRef.current.scale);
+        }
+    });
+    return (_jsx("mesh", { ref: meshRef, name: "SkyClouds", userData: { id: '3drise-clouds' }, 
+        // position={[0, height, 0]}
+        // rotation={[Math.PI / 2, 0, 0]}
+        // scale={scale}
+        renderOrder: -1, frustumCulled: false, visible: visible, children: _jsx("planeGeometry", { args: [planeSize[0], planeSize[1], planeSegments, planeSegments] }) }));
+};
+export default Clouds;

package/dist/components/Corona.d.ts

@@ -0,0 +1,18 @@
+import * as THREE from "three";
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            sunCoronaMaterial: any;
+        }
+    }
+}
+export type CoronaProps = {
+    /** Radius of the core this corona surrounds. Default 1. */
+    radius?: number;
+    /** Shell size relative to the core. Default 1.25. Synced with u_shellScale. */
+    shellScale?: number;
+    /** Uniform overrides for SunCoronaMaterial (u_intensity, u_innerColor, ...). */
+    uniforms?: Record<string, number | THREE.Vector3 | number[]>;
+};
+export default function Corona({ radius, shellScale, uniforms }: CoronaProps): import("react").JSX.Element;
+//# sourceMappingURL=Corona.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Corona.d.ts","sourceRoot":"","sources":["../../src/components/Corona.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAG/B,OAAO,CAAC,MAAM,CAAC;IACX,UAAU,GAAG,CAAC;QACV,UAAU,iBAAiB;YACvB,iBAAiB,EAAE,GAAG,CAAC;SAC1B;KACJ;CACJ;AAED,MAAM,MAAM,WAAW,GAAG;IACtB,2DAA2D;IAC3D,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,+EAA+E;IAC/E,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,gFAAgF;IAChF,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,KAAK,CAAC,OAAO,GAAG,MAAM,EAAE,CAAC,CAAC;CAChE,CAAC;AAEF,MAAM,CAAC,OAAO,UAAU,MAAM,CAAC,EAAE,MAAU,EAAE,UAAiB,EAAE,QAAQ,EAAE,EAAE,WAAW,+BAOtF"}

package/dist/components/Corona.js

@@ -0,0 +1,12 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import * as THREE from "three";
+import { useRef } from "react";
+import { useFrame } from "@react-three/fiber";
+export default function Corona({ radius = 1, shellScale = 1.25, uniforms }) {
+    const matRef = useRef(null);
+    useFrame((_, delta) => {
+        if (matRef.current)
+            matRef.current.u_time += delta;
+    });
+    return (_jsxs("mesh", { scale: radius * shellScale, children: [_jsx("sphereGeometry", { args: [1, 64, 64] }), _jsx("coronaMaterial", { ref: matRef, u_shellScale: shellScale, side: THREE.BackSide, transparent: true, depthWrite: false, blending: THREE.AdditiveBlending, ...uniforms })] }));
+}

package/dist/components/CreatedObject.d.ts

@@ -0,0 +1,14 @@
+import type { CreatedObjectSettings } from '@3driseai/3drise-core';
+import React from "react";
+import { Object3D } from "three";
+import { type ThreeEvent } from "@react-three/fiber";
+interface CreatedObjectProps {
+    createdObject: CreatedObjectSettings;
+    children: React.ReactNode;
+    shouldApply3driseMaterial?: boolean;
+    onObjectReady?: (object: CreatedObjectSettings, ref: Object3D) => void;
+    handleObjectClick?: (createdObject: CreatedObjectSettings, ref: Object3D, event: ThreeEvent<MouseEvent>) => void;
+}
+declare const CreatedObject: React.FC<CreatedObjectProps>;
+export default CreatedObject;
+//# sourceMappingURL=CreatedObject.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"CreatedObject.d.ts","sourceRoot":"","sources":["../../src/components/CreatedObject.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AASnE,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AACjC,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACrD,UAAU,kBAAkB;IACxB,aAAa,EAAE,qBAAqB,CAAC;IACrC,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;IAC1B,yBAAyB,CAAC,EAAE,OAAO,CAAC;IACpC,aAAa,CAAC,EAAE,CAAC,MAAM,EAAE,qBAAqB,EAAE,GAAG,EAAE,QAAQ,KAAK,IAAI,CAAC;IACvE,iBAAiB,CAAC,EAAE,CAAC,aAAa,EAAE,qBAAqB,EAAE,GAAG,EAAE,QAAQ,EAAE,KAAK,EAAE,UAAU,CAAC,UAAU,CAAC,KAAK,IAAI,CAAC;CACpH;AAGD,QAAA,MAAM,aAAa,EAAE,KAAK,CAAC,EAAE,CAAC,kBAAkB,CAuF9C,CAAC;AAEH,eAAe,aAAa,CAAC"}

package/dist/components/CreatedObject.js

@@ -0,0 +1,103 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useRef, useEffect, useState, memo } from "react";
+import { DEFAULT_EDGES_SETTINGS } from "@3driseai/3drise-core";
+import { useMaterialApplication } from "../hooks/useMaterialApplication.js";
+import { useShadowApplication } from "../hooks/useShadowApplication.js";
+import { useTransformControls } from "../hooks/useTransformControls.js";
+import { RigidBody } from '@react-three/rapier';
+import { cameraManager } from "../utils/CameraSingleton.js";
+import AnimatedObject from "./AnimatedObject.js";
+import { useFrameEffects } from "../hooks/useFrameEffects.js";
+import { useObjectEdges } from "../hooks/useObjectEdges.js";
+const CreatedObject = memo(({ createdObject, children, shouldApply3driseMaterial = true, onObjectReady, handleObjectClick, }) => {
+    const isSelected = false;
+    // const isSelected = useObjectSelection(createdObject.id);
+    // const { handleObjectClick: contextHandleObjectClick } = useSceneClick();
+    const meshRef = useRef(null);
+    const transformRef = useRef(null);
+    // const baseColorRef = useRef<string>(("color" in createdObject.materialSettings && createdObject.materialSettings.color) || '#ffffff');  
+    // const [hovered, setHovered] = useState(false);
+    const [animatedTransform, setAnimatedTransform] = useState({
+        position: createdObject.meshSettings.position,
+        rotation: createdObject.meshSettings.rotation,
+        scale: createdObject.meshSettings.scale,
+    });
+    // Initialize transform controls
+    const { controllersRef } = useTransformControls();
+    const { handlePointerEnter, handlePointerLeave, hovered } = useFrameEffects(isSelected);
+    const [mountedObject, setMountedObject] = useState(null);
+    useObjectEdges(createdObject.id, createdObject.edgesSettings ?? DEFAULT_EDGES_SETTINGS);
+    // useObjectGenerativeEffects(mountedObject, createdObject.effects);
+    useMaterialApplication(meshRef.current, createdObject.materialSettings, shouldApply3driseMaterial);
+    useShadowApplication(meshRef.current, createdObject.meshSettings.castShadow, createdObject.meshSettings.receiveShadow);
+    const anchoredPosition = cameraManager.getAnchorPosition(createdObject.meshSettings.anchor?.anchor || 'center', 0, createdObject.meshSettings.anchor?.offset || { y: 0, x: 0, z: 0 }, createdObject.meshSettings.anchor?.padding || 0);
+    useEffect(() => {
+        if (meshRef.current) {
+            meshRef.current.userData.id = createdObject.id;
+            onObjectReady && onObjectReady(createdObject, meshRef.current);
+        }
+        return () => {
+        };
+    }, [meshRef.current]);
+    useEffect(() => {
+        if (transformRef.current && isSelected) {
+            controllersRef.current.set(createdObject.id.toString(), transformRef.current);
+            // console.log('Transform controls registered for object:', createdObject.id, createdObject.name);
+        }
+        return () => {
+            controllersRef.current.delete(createdObject.id.toString());
+            // console.log('Transform controls unregistered for object:', createdObject.id, createdObject.name);
+        };
+    }, [createdObject.id, isSelected]);
+    useEffect(() => {
+        setAnimatedTransform({
+            position: createdObject.meshSettings.position,
+            rotation: createdObject.meshSettings.rotation,
+            scale: createdObject.meshSettings.scale,
+        });
+    }, [createdObject.meshSettings.position, createdObject.meshSettings.rotation, createdObject.meshSettings.scale]);
+    // const [noiseTexture, setNoiseTexture] = useState<Texture | null>(null);
+    const isTransforming = useRef(false);
+    // useMaterialApplication(obj.object, createdObject.materialSettings);
+    // Check if this should use the new MaterialLibrary system for Drei materials
+    // console.log(object)
+    const handleObjectEnter = (e) => {
+        // console.log(e)
+        // Only handle if this is the actual mesh group, not a child
+        if (e.eventObject !== meshRef.current)
+            return;
+        if (createdObject.type === 'particles' || createdObject.type === 'gallery')
+            return;
+        // e.stopPropagation();
+        handlePointerEnter(e);
+        if (createdObject.actions?.length || createdObject.mouseMove?.enabled) {
+            document.body.style.cursor = 'pointer';
+        }
+    };
+    const handleObjectLeave = (e) => {
+        // Only handle if this is the actual mesh group, not a child
+        if (e.eventObject !== meshRef.current)
+            return;
+        if (createdObject.type === 'particles' || createdObject.type === 'gallery')
+            return;
+        handlePointerLeave();
+        document.body.style.cursor = 'auto';
+        e.stopPropagation();
+    };
+    const anchorEnabled = createdObject.meshSettings.anchor && createdObject.meshSettings.anchor.enabled;
+    return (_jsx(AnimatedObject
+    // animationId={createdObject.animationId || ''}
+    , { 
+        // animationId={createdObject.animationId || ''}
+        stateKey: createdObject.id, transitionSettings: {
+            ...animatedTransform,
+            position: anchorEnabled ? [anchoredPosition.x, anchoredPosition.y, anchoredPosition.z] : animatedTransform.position
+        }, createdObject: createdObject, 
+        // animateMaterial={!useDreiMaterials}
+        parentRef: meshRef, visible: createdObject.meshSettings.visible, handleObjectClick: handleObjectClick, onPointerEnter: handleObjectEnter, onPointerLeave: e => handleObjectLeave(e), hovered: hovered, children: createdObject.rigidBodySettings?.enabled ? (_jsx(RigidBody, { type: createdObject.rigidBodySettings?.type || 'dynamic', mass: createdObject.rigidBodySettings?.mass || 1, colliders: createdObject.userData?.type === 'plane'
+                ? 'cuboid' // Force box collider for planes
+                : undefined // Auto-detect for others
+            , friction: createdObject.rigidBodySettings?.friction, restitution: createdObject.rigidBodySettings?.restitution, gravityScale: createdObject.rigidBodySettings?.gravityScale ?? 1, linearDamping: createdObject.rigidBodySettings?.linearDamping ?? 0.01, angularDamping: createdObject.rigidBodySettings?.angularDamping ?? 0.01, children: children })) : (children) }));
+});
+CreatedObject.displayName = 'CreatedObject';
+export default CreatedObject;

package/dist/components/CustomPrimitive.d.ts

@@ -0,0 +1,12 @@
+import type { CreatedObjectSettings } from '@3driseai/3drise-core';
+import type { Object3D } from 'three';
+import React from "react";
+import { type ThreeEvent } from "@react-three/fiber";
+interface CustomPrimitiveProps {
+    createdObject: CreatedObjectSettings;
+    onObjectReady?: (object: CreatedObjectSettings, ref: Object3D) => void;
+    handleObjectClick?: (createdObject: CreatedObjectSettings, ref: Object3D, event: ThreeEvent<MouseEvent>) => void;
+}
+declare const CustomPrimitive: React.FC<CustomPrimitiveProps>;
+export default CustomPrimitive;
+//# sourceMappingURL=CustomPrimitive.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"CustomPrimitive.d.ts","sourceRoot":"","sources":["../../src/components/CustomPrimitive.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAEnE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAItC,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACrD,UAAU,oBAAoB;IAC1B,aAAa,EAAE,qBAAqB,CAAC;IACrC,aAAa,CAAC,EAAE,CAAC,MAAM,EAAE,qBAAqB,EAAE,GAAG,EAAE,QAAQ,KAAK,IAAI,CAAC;IACvE,iBAAiB,CAAC,EAAE,CAAC,aAAa,EAAE,qBAAqB,EAAE,GAAG,EAAE,QAAQ,EAAE,KAAK,EAAE,UAAU,CAAC,UAAU,CAAC,KAAK,IAAI,CAAC;CACpH;AAGD,QAAA,MAAM,eAAe,EAAE,KAAK,CAAC,EAAE,CAAC,oBAAoB,CA6ElD,CAAC;AAEH,eAAe,eAAe,CAAC"}

package/dist/components/CustomPrimitive.js

@@ -0,0 +1,87 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useRef, memo, useMemo } from "react";
+import { ObjectManager, } from "@3driseai/3drise-core";
+import { Vector3 } from "three";
+import MaterialLibrary from "./MaterialLibrary.js";
+import { useWaterReflections } from "../hooks/useWaterReflections.js";
+import { GeometryMesh } from "./GeometryShape.js";
+const CustomPrimitive = memo(({ createdObject, onObjectReady, handleObjectClick, }) => {
+    const meshRef = useRef(null);
+    const resolvedObject = useMemo(() => {
+        // console.log(`Resolving object for ${createdObject.name}`, createdObject);
+        if (!createdObject)
+            return null;
+        const obj = ObjectManager.getObject(createdObject.id);
+        if (!obj) {
+            console.warn(`CustomPrimitive - Object with ID ${createdObject.id} not found.`);
+            return null;
+        }
+        return obj.object;
+    }, [createdObject.id]);
+    // const objectRef = useRef<Mesh>(resolvedObject as Mesh);
+    // useEffect(() => {
+    //   if (createdObject.type !== 'mesh' || !objectRef.current) return;
+    //   // const managedObject = ObjectManager.getObject(createdObject.id);
+    //   // if (!managedObject || !(managedObject.object instanceof Mesh)) return;
+    //   const targetMesh = objectRef.current;
+    //   const meshType = (createdObject.config as any)?.type || targetMesh.userData?.type || 'box';
+    //   const meshData = {
+    //     position: [targetMesh.position.x, targetMesh.position.y, targetMesh.position.z],
+    //     rotation: [targetMesh.rotation.x, targetMesh.rotation.y, targetMesh.rotation.z],
+    //     scale: [targetMesh.scale.x, targetMesh.scale.y, targetMesh.scale.z],
+    //     visible: targetMesh.visible,
+    //     name: targetMesh.name || createdObject.name,
+    //     ...createdObject.config,
+    //     type: meshType,
+    //     id: createdObject.id,
+    //   } as any;
+    //   const generated = createMeshByType(meshData);
+    //   if (!generated) return;
+    //   if (targetMesh.geometry !== generated.mesh.geometry) {
+    //     targetMesh.geometry?.dispose();
+    //     targetMesh.geometry = generated.mesh.geometry;
+    //   }
+    //   targetMesh.userData = {
+    //     ...targetMesh.userData,
+    //     type: meshType,
+    //     id: createdObject.id,
+    //     options: generated.config,
+    //   };
+    //   if (generated.mesh.material && generated.mesh.material !== targetMesh.material) {
+    //     if (Array.isArray(generated.mesh.material)) {
+    //       generated.mesh.material.forEach((m) => m.dispose());
+    //     } else {
+    //       generated.mesh.material.dispose();
+    //     }
+    //   }
+    // }, [
+    //   createdObject.config,
+    // ]);
+    const isWaterMaterial = createdObject.materialSettings.materialVariant === 'water' || createdObject.materialSettings.materialType === 'water';
+    //  console.log({isWaterMaterial, materialVariant: createdObject.materialSettings.materialVariant, materialType: createdObject.materialSettings.materialType})
+    useWaterReflections(createdObject.meshSettings.visible && isWaterMaterial ? meshRef : { current: null }, {
+        waterPosition: new Vector3(...createdObject.meshSettings.position),
+        resolution: 256,
+        updateFrequency: 1,
+        enabled: createdObject.meshSettings.visible && isWaterMaterial,
+    });
+    const useDreiMaterials = createdObject.materialSettings.materialType === "advanced";
+    // const obj = ObjectManager.getObject(createdObject.id);
+    const materialType = createdObject.materialSettings?.materialType || 'basic';
+    // let mode = 'solid';
+    // if (materialType === 'particles') {
+    //   mode = 'particles';
+    // } 
+    // else if (materialType === 'line') {
+    //   mode = 'outline';
+    // }
+    if (createdObject.type === 'mesh')
+        return _jsx("mesh", { ref: meshRef, name: createdObject.name, children: _jsx(GeometryMesh, { config: createdObject.config, materialSettings: createdObject.materialSettings, animations: createdObject.animations, modeConfig: createdObject.modeConfig || { mode: 'solid', count: 1000, symmetry: 3, spacing: 0.1, slices: 8, linkRadius: 0.05, angle: 18, lineWidth: 1 } }) }, createdObject.id);
+    if (!resolvedObject) {
+        console.warn(`no resolved object for ${createdObject.name} (${createdObject.id})`);
+        return null;
+    }
+    return (_jsx("primitive", { ref: meshRef, name: createdObject.name, object: resolvedObject, children: useDreiMaterials && createdObject.meshSettings.visible && (_jsx(MaterialLibrary, { materialSettings: createdObject.materialSettings })) }, createdObject.id));
+});
+CustomPrimitive.displayName = 'CustomPrimitive';
+export default CustomPrimitive;

package/dist/components/Earth.d.ts

@@ -0,0 +1,8 @@
+import * as THREE from 'three';
+import React from "react";
+import { EarthConfig } from "@3driseai/3drise-core";
+declare const Earth: React.FC<EarthConfig & {
+    onMeshReady?: (mesh: THREE.Mesh) => void;
+}>;
+export default Earth;
+//# sourceMappingURL=Earth.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Earth.d.ts","sourceRoot":"","sources":["../../src/components/Earth.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAMpD,QAAA,MAAM,KAAK,EAAE,KAAK,CAAC,EAAE,CAAC,WAAW,GAAG;IACxB,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,KAAK,IAAI,CAAC;CAC5C,CA2BR,CAAC;AAEF,eAAe,KAAK,CAAC"}

package/dist/components/Earth.js

@@ -0,0 +1,38 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useRef, useMemo, useCallback, useEffect } from 'react';
+import * as THREE from 'three';
+import { useTexture } from '@react-three/drei';
+const CDN = 'https://3d-rise.sfo3.cdn.digitaloceanspaces.com/app/images/planets';
+const EARTH_DAY_URL = `${CDN}/earth_day_4096.jpg`;
+const EARTH_NIGHT_URL = `${CDN}/earth_night_4096.jpg`;
+const EARTH_BUMP_ROUGHNESS_CLOUDS_URL = `${CDN}/earth_bump_roughness_clouds_4096.jpg`;
+const Earth = ({ sunPosition = [0, 0, 3], atmosphereDayColor = '#4db2ff', atmosphereTwilightColor = '#bc490b', radius = 1, onMeshReady, }) => {
+    const globeRef = useRef(null);
+    const globeMatRef = useRef(null);
+    const atmosphereMatRef = useRef(null);
+    const segments = 64;
+    const [dayMap, nightMap, bumpRoughnessClouds] = useTexture([
+        EARTH_DAY_URL,
+        EARTH_NIGHT_URL,
+        EARTH_BUMP_ROUGHNESS_CLOUDS_URL,
+    ]);
+    useEffect(() => {
+        dayMap.colorSpace = THREE.SRGBColorSpace;
+        nightMap.colorSpace = THREE.SRGBColorSpace;
+        dayMap.anisotropy = 8;
+        nightMap.anisotropy = 8;
+        bumpRoughnessClouds.anisotropy = 8;
+    }, [dayMap, nightMap, bumpRoughnessClouds]);
+    const sunDirection = useMemo(() => new THREE.Vector3(sunPosition[0], sunPosition[1], sunPosition[2]).normalize(), [sunPosition]);
+    const dayColor = useMemo(() => new THREE.Color(atmosphereDayColor), [atmosphereDayColor]);
+    const twilightColor = useMemo(() => new THREE.Color(atmosphereTwilightColor), [atmosphereTwilightColor]);
+    const handleGlobeRef = useCallback((mesh) => {
+        if (mesh) {
+            globeRef.current = mesh;
+            onMeshReady?.(mesh);
+        }
+    }, [onMeshReady]);
+    return (_jsxs("group", { userData: { id: '3drise-earth' }, children: [_jsxs("mesh", { ref: handleGlobeRef, children: [_jsx("sphereGeometry", { args: [radius, segments, segments] }), _jsx("earthMaterial", { ref: globeMatRef, uDayMap: dayMap, uNightMap: nightMap, uBumpRoughnessClouds: bumpRoughnessClouds, uSunDirection: sunDirection, uAtmosphereDayColor: dayColor, uAtmosphereTwilightColor: twilightColor })] }), _jsxs("mesh", { scale: 1.04, children: [_jsx("sphereGeometry", { args: [radius, segments, segments] }), _jsx("earthAtmosphereMaterial", { ref: atmosphereMatRef, transparent: true, side: THREE.BackSide, depthWrite: false, uSunDirection: sunDirection, uAtmosphereDayColor: dayColor, uAtmosphereTwilightColor: twilightColor })] })] }));
+};
+Earth.displayName = 'Earth';
+export default Earth;

package/dist/components/EffectsGenerator.d.ts

@@ -0,0 +1,10 @@
+import type { Object3D } from 'three';
+import React from "react";
+import type { GenerativeEffectSettings } from "@3driseai/3drise-core";
+export interface EffectsGeneratorProps {
+    settings: GenerativeEffectSettings;
+    object?: Object3D | null;
+}
+declare const EffectsGenerator: React.FC<EffectsGeneratorProps>;
+export default EffectsGenerator;
+//# sourceMappingURL=EffectsGenerator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"EffectsGenerator.d.ts","sourceRoot":"","sources":["../../src/components/EffectsGenerator.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAyBtC,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AACtE,MAAM,WAAW,qBAAqB;IAClC,QAAQ,EAAE,wBAAwB,CAAC;IACnC,MAAM,CAAC,EAAE,QAAQ,GAAG,IAAI,CAAC;CAC5B;AAGD,QAAA,MAAM,gBAAgB,EAAE,KAAK,CAAC,EAAE,CAAC,qBAAqB,CA0CrD,CAAC;AACF,eAAe,gBAAgB,CAAC"}