@3driseai/3drise-viewer 0.1.1

package/dist/components/ObjectNode.js

@@ -0,0 +1,139 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useCallback, useMemo } from "react";
+import CustomPrimitive from "./CustomPrimitive.js";
+import CreatedObject from "./CreatedObject.js";
+import Text3D from './Text3D.js';
+import Text2D from './Text2D.js';
+import PathRenderer from './PathRenderer.js';
+import GalleryLayout from './GalleryLayout.js';
+import EffectsGenerator from './EffectsGenerator.js';
+import ParticlesR3f from "./ParticlesR3f.js";
+import Lines from "./Lines.js";
+import LightObject from "./LightObject.js";
+import EnvironmentObject from "./EnvironmentObject.js";
+import Galaxy from "./Galaxy.js";
+import GridGenerator from "./GridsGenerator.js";
+// Types whose React component instantiates and drives its own ShaderMaterial.
+// useMaterialApplication would otherwise traverse the mesh tree and replace
+// that material with a registry-default instance, breaking config-driven
+// uniform updates (e.g. only ringRadius worked on glyphs because that drives
+// geometry, not the material).
+const SELF_MANAGED_MATERIAL = new Set([
+    'effect',
+    // 'gallery',
+    'earth',
+    'solarSystem',
+    'shootingStars',
+    'grid',
+    // 'moon'
+]);
+// const EffectsLayer: React.FC<{ effects: CreatedObjectSettings['effects'] }> = ({ effects }) =>
+//     effects?.length ? (
+//         <>
+//             {effects.map((effect, index) => (
+//                 <EffectsGenerator key={index} settings={effect} />
+//             ))}
+//         </>
+//     ) : null;
+const GroupWithChildren = ({ createdObject, children, cameraSettings, onObjectReady, handleObjectClick, renderObject }) => {
+    const isGroup = createdObject.type === 'group';
+    const selfManagedMaterial = SELF_MANAGED_MATERIAL.has(createdObject.type);
+    return (_jsxs(CreatedObject, { createdObject: createdObject, onObjectReady: onObjectReady, handleObjectClick: handleObjectClick, shouldApply3driseMaterial: !isGroup && !selfManagedMaterial, children: [!isGroup && renderObject(createdObject, handleObjectClick), children.map(childNode => (_jsx(ObjectNode, { node: childNode, cameraSettings: cameraSettings, handleObjectClick: handleObjectClick, onObjectReady: onObjectReady }, childNode.objectId)))] }, createdObject.id));
+};
+const ObjectNode = ({ node, cameraSettings, onObjectReady, handleObjectClick }) => {
+    const { children, createdObject } = node;
+    // console.log(createdObject.meshSettings.name, createdObject.actions, createdObject.mouseMove)
+    // Specialized renderers for each object type
+    const renderers = useMemo(() => ({
+        group: () => null,
+        mesh: (obj, cameraSettings, onObjectReady) => (_jsx(CustomPrimitive, { createdObject: obj, onObjectReady: onObjectReady, handleObjectClick: handleObjectClick }, obj.id)),
+        // water: (obj: CreatedObjectSettings, cameraSettings: CameraState, onObjectReady?: (object: CreatedObjectSettings, ref: Object3D) => void) => (
+        //     <Ocean
+        //         settings={obj}
+        //     />
+        // ),
+        // stars: (obj: CreatedObjectSettings, cameraSettings: CameraState, onObjectReady?: (object: CreatedObjectSettings, ref: Object3D) => void) => (
+        //     <Stars
+        //         settings={obj}
+        //     />
+        // ),
+        // clouds: (obj: CreatedObjectSettings, cameraSettings: CameraState, onObjectReady?: (object: CreatedObjectSettings, ref: Object3D) => void) => (
+        //     <Clouds
+        //         settings={obj}
+        //     />
+        // ),
+        model: (obj, cameraSettings, onObjectReady) => (_jsx(CustomPrimitive, { createdObject: obj, onObjectReady: onObjectReady, handleObjectClick: handleObjectClick }, obj.id)),
+        // custom_primitive: (obj: CreatedObjectSettings, cameraSettings: CameraState, onObjectReady?: (object: CreatedObjectSettings, ref: Object3D) => void) => (
+        //     <CustomPrimitive
+        //         key={obj.id}
+        //         createdObject={obj}
+        //         onObjectReady={onObjectReady}
+        //         handleObjectClick={handleObjectClick}
+        //     />
+        // ),
+        text: (obj, cameraSettings, onObjectReady) => {
+            const renderMode = obj.config?.renderMode ?? 'bitmap';
+            return (_jsx(_Fragment, { children: renderMode === 'text3d'
+                    ? _jsx(Text3D, { textSettings: obj })
+                    : _jsx(Text2D, { textSettings: obj }) }));
+        },
+        particles: (obj, cameraSettings, onObjectReady) => {
+            const particlesSettings = obj;
+            return (_jsxs(_Fragment, { children: [particlesSettings.config?.particles && (_jsx(ParticlesR3f, { particlesSettings: particlesSettings, cameraFov: cameraSettings.fov, duration: 1, transitionSettings: particlesSettings.meshSettings })), particlesSettings.config?.paths && (_jsx(Lines, { createdObject: particlesSettings }))] }));
+        },
+        path: (obj, cameraSettings, onObjectReady) => (_jsx(PathRenderer, { pathSettings: obj.config }, obj.id)),
+        grid: (obj, cameraSettings, onObjectReady) => (
+        // <GridHelper {...(obj.config as GridConfig)} side={2} />
+        _jsx(GridGenerator, { config: obj.config })),
+        effect: (obj) => (_jsx(EffectsGenerator, { settings: {
+                config: obj.config,
+            } }, obj.id)),
+        gallery: (obj, cameraSettings, onObjectReady) => (_jsx(GalleryLayout, { createdObject: obj, handleObjectClick: handleObjectClick })),
+        light: (obj, cameraSettings, onObjectReady) => (_jsx(LightObject, { createdObject: obj })),
+        environment: (obj, cameraSettings, onObjectReady) => (_jsx(EnvironmentObject, { createdObject: obj })),
+        space: (obj, cameraSettings, onObjectReady) => (_jsx(Galaxy, { createdObject: obj, onObjectReady: onObjectReady })),
+        // rain: (obj: CreatedObjectSettings, cameraSettings: CameraState, onObjectReady?: (object: CreatedObjectSettings, ref: Object3D) => void) => (
+        //     <Rain
+        //         settings={obj}
+        //     />
+        // ),
+        // earth: (obj: CreatedObjectSettings, cameraSettings: CameraState, onObjectReady?: (object: CreatedObjectSettings, ref: Object3D) => void) => (
+        //     <Earth
+        //         {...obj.config as EarthConfig}
+        //     />
+        // ),
+        // solarSystem: (obj: CreatedObjectSettings, cameraSettings: CameraState, onObjectReady?: (object: CreatedObjectSettings, ref: Object3D) => void) => (
+        //     <SolarSystem
+        //         {...obj.config as SolarSystemConfig}
+        //     />
+        // ),
+        // shootingStars: (obj: CreatedObjectSettings, cameraSettings: CameraState, onObjectReady?: (object: CreatedObjectSettings, ref: Object3D) => void) => (
+        //     <ShootingStars
+        //         settings={obj.config as ShootingStarsSettings}
+        //     />
+        // ),
+    }), [handleObjectClick]);
+    if (!createdObject) {
+        console.warn(`createdObject not found.`);
+        return null;
+    }
+    const meshSettings = createdObject.meshSettings;
+    const hasChildren = children.length > 0;
+    const shouldRenderAsGroup = hasChildren || createdObject.type === 'group' || createdObject.type === 'effect';
+    const renderObject = useCallback((obj, handleObjectClick) => {
+        // console.log('Rendering object:', obj);
+        const renderer = renderers[obj.type];
+        return renderer?.(obj, cameraSettings, onObjectReady) ?? null;
+    }, [cameraSettings, onObjectReady, renderers]);
+    const renderedObject = shouldRenderAsGroup
+        ? _jsx(GroupWithChildren, { createdObject: createdObject, children: children, cameraSettings: cameraSettings, onObjectReady: onObjectReady, handleObjectClick: handleObjectClick, renderObject: renderObject })
+        : _jsx(CreatedObject, { createdObject: createdObject, onObjectReady: onObjectReady, handleObjectClick: handleObjectClick, shouldApply3driseMaterial: !SELF_MANAGED_MATERIAL.has(createdObject.type), children: renderObject(createdObject) }, createdObject.id);
+    // createdObject.effects
+    //     ? <>
+    //         {renderObject(createdObject)}
+    //         {/* <EffectsLayer effects={createdObject.effects} /> */}
+    //     </>
+    //     : renderObject(createdObject);
+    return renderedObject;
+};
+export default ObjectNode;

package/dist/components/ObjectNodeApi.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"ObjectNodeApi.d.ts","sourceRoot":"","sources":["../../src/components/ObjectNodeApi.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AACjC,OAAO,KAAK,EAAE,WAAW,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAChF,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACrD,KAAK,kBAAkB,GAAG;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,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;AAGF,QAAA,MAAM,aAAa,EAAE,KAAK,CAAC,EAAE,CAAC,kBAAkB,CAW/C,CAAC;AACF,eAAe,aAAa,CAAC"}

package/dist/components/ObjectNodeApi.js

@@ -0,0 +1,18 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useState } from 'react';
+// import { apiFetch } from '../utils/apiFetch';
+import ObjectNode from './ObjectNode.js';
+import { dataCenterServer } from '../constants.js';
+const ObjectNodeApi = ({ objectId, cameraSettings, onObjectReady, handleObjectClick }) => {
+    const [node, setNode] = useState(null);
+    useEffect(() => {
+        fetch(`${dataCenterServer}scene-objects/${objectId}/tree`)
+            .then(res => res.ok ? res.json() : Promise.reject(res.status))
+            .then(({ tree }) => setNode(tree))
+            .catch(err => console.error('Failed to fetch scene object tree:', err));
+    }, [objectId]);
+    if (!node)
+        return null;
+    return (_jsx(ObjectNode, { node: node, cameraSettings: cameraSettings, onObjectReady: onObjectReady, handleObjectClick: handleObjectClick }));
+};
+export default ObjectNodeApi;

package/dist/components/ObjectsRenderer.d.ts

@@ -0,0 +1,15 @@
+import type { AnimationSequence, GeneralObjectSettings, CameraState, CreatedObjectSettings } from '@3driseai/3drise-core';
+import React from "react";
+import { Object3D } from "three";
+import { type ThreeEvent } from "@react-three/fiber";
+interface ObjectsRendererProps {
+    cameraSettings: CameraState;
+    generalObjectSettings: GeneralObjectSettings;
+    createdObjects: CreatedObjectSettings[];
+    onObjectsReady?: () => void;
+    handleObjectClick?: (object: CreatedObjectSettings, ref: Object3D, event: ThreeEvent<MouseEvent>) => void;
+    sequences?: AnimationSequence[];
+}
+declare const ObjectsRenderer: React.FC<ObjectsRendererProps>;
+export default ObjectsRenderer;
+//# sourceMappingURL=ObjectsRenderer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ObjectsRenderer.d.ts","sourceRoot":"","sources":["../../src/components/ObjectsRenderer.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,qBAAqB,EAAE,WAAW,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAG1H,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AACjC,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACrD,UAAU,oBAAoB;IAC1B,cAAc,EAAE,WAAW,CAAC;IAC5B,qBAAqB,EAAE,qBAAqB,CAAC;IAC7C,cAAc,EAAE,qBAAqB,EAAE,CAAC;IACxC,cAAc,CAAC,EAAE,MAAM,IAAI,CAAC;IAC5B,iBAAiB,CAAC,EAAE,CAAC,MAAM,EAAE,qBAAqB,EAAE,GAAG,EAAE,QAAQ,EAAE,KAAK,EAAE,UAAU,CAAC,UAAU,CAAC,KAAK,IAAI,CAAC;IAC1G,SAAS,CAAC,EAAE,iBAAiB,EAAE,CAAC;CACnC;AAGD,QAAA,MAAM,eAAe,EAAE,KAAK,CAAC,EAAE,CAAC,oBAAoB,CAgClD,CAAC;AAEH,eAAe,eAAe,CAAC"}

package/dist/components/ObjectsRenderer.js

@@ -0,0 +1,40 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { memo, useRef, useCallback, useMemo } from 'react';
+import { buildObjectTree } from '@3driseai/3drise-core';
+import ObjectNode from './ObjectNode.js';
+import useInteraction from '../hooks/useInteraction.js';
+const ObjectsRenderer = memo(({ cameraSettings, createdObjects, generalObjectSettings, onObjectsReady, handleObjectClick, sequences = [], }) => {
+    const groupRef = useRef(null);
+    const objectsTree = useMemo(() => buildObjectTree(createdObjects), [createdObjects]);
+    const readyObjectsCount = useRef(0);
+    const onObjectReady = useCallback((object, ref) => {
+        readyObjectsCount.current += 1;
+        if (readyObjectsCount.current === objectsTree.length) {
+            console.log("All objects are ready!");
+            onObjectsReady && onObjectsReady();
+        }
+    }, [objectsTree.length, onObjectsReady]);
+    function filterInteractionsByEvent(interactions, mouseEvent) {
+        if (!interactions)
+            return [];
+        return interactions.filter((interaction) => interaction.mouseEvent === mouseEvent);
+    }
+    const { executeInteraction } = useInteraction({
+        cameraSettings,
+        sequences,
+    });
+    const handleObjectClickHandler = (createdObject, ref, event) => {
+        console.log('Object clicked:', createdObject.meshSettings.name);
+        console.log('Object ref:', ref);
+        const clickInteractions = filterInteractionsByEvent(createdObject.actions, "click");
+        clickInteractions.forEach((interaction) => {
+            executeInteraction({ interaction, ref, createdObject });
+        });
+        if (handleObjectClick) {
+            handleObjectClick(createdObject, ref, event);
+        }
+    };
+    return (_jsx("group", { ref: groupRef, name: "main-objects", position: generalObjectSettings.meshSettings.position, rotation: generalObjectSettings.meshSettings.rotation, scale: generalObjectSettings.meshSettings.scale, children: objectsTree.map(node => (_jsx(ObjectNode, { node: node, cameraSettings: cameraSettings, onObjectReady: onObjectReady, handleObjectClick: handleObjectClickHandler }, node.objectId))) }));
+});
+ObjectsRenderer.displayName = 'ObjectsRenderer';
+export default ObjectsRenderer;

package/dist/components/ObjectsRendererApi.d.ts

@@ -0,0 +1,31 @@
+import React from "react";
+import { CreatedObjectSettings, CameraState, GeneralObjectSettings } from "@3driseai/3drise-core";
+import { type ThreeEvent } from "@react-three/fiber";
+import { Object3D } from "three";
+export interface ObjectsRendererApiProps {
+    objectIds: string[];
+    cameraSettings: CameraState;
+    generalObjectSettings: GeneralObjectSettings;
+    apiBaseUrl?: string;
+    onObjectsReady?: () => void;
+    handleObjectClick?: (object: CreatedObjectSettings, ref: Object3D, event: ThreeEvent<MouseEvent>) => void;
+    onError?: (error: Error) => void;
+    onLoading?: (isLoading: boolean) => void;
+}
+/**
+ * ObjectsRendererApi
+ *
+ * A wrapper component that fetches scene objects by their IDs from the data-center API
+ * and passes them to ObjectsRenderer for 3D rendering.
+ *
+ * @example
+ * <ObjectsRendererApi
+ *   objectIds={['obj-1', 'obj-2', 'obj-3']}
+ *   cameraSettings={cameraState}
+ *   generalObjectSettings={generalSettings}
+ *   apiBaseUrl="http://localhost:3001"
+ * />
+ */
+declare const ObjectsRendererApi: React.FC<ObjectsRendererApiProps>;
+export default ObjectsRendererApi;
+//# sourceMappingURL=ObjectsRendererApi.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ObjectsRendererApi.d.ts","sourceRoot":"","sources":["../../src/components/ObjectsRendererApi.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,EAAE,qBAAqB,EAAE,WAAW,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAClG,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AACjC,MAAM,WAAW,uBAAuB;IACpC,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,cAAc,EAAE,WAAW,CAAC;IAC5B,qBAAqB,EAAE,qBAAqB,CAAC;IAC7C,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,cAAc,CAAC,EAAE,MAAM,IAAI,CAAC;IAC5B,iBAAiB,CAAC,EAAE,CAAC,MAAM,EAAE,qBAAqB,EAAE,GAAG,EAAE,QAAQ,EAAE,KAAK,EAAE,UAAU,CAAC,UAAU,CAAC,KAAK,IAAI,CAAC;IAC1G,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IACjC,SAAS,CAAC,EAAE,CAAC,SAAS,EAAE,OAAO,KAAK,IAAI,CAAC;CAC5C;AAGD;;;;;;;;;;;;;GAaG;AACH,QAAA,MAAM,kBAAkB,EAAE,KAAK,CAAC,EAAE,CAAC,uBAAuB,CAyDzD,CAAC;AACF,eAAe,kBAAkB,CAAC"}

package/dist/components/ObjectsRendererApi.js

@@ -0,0 +1,76 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from 'react';
+import ObjectsRenderer from './ObjectsRenderer.js';
+/**
+ * ObjectsRendererApi
+ *
+ * A wrapper component that fetches scene objects by their IDs from the data-center API
+ * and passes them to ObjectsRenderer for 3D rendering.
+ *
+ * @example
+ * <ObjectsRendererApi
+ *   objectIds={['obj-1', 'obj-2', 'obj-3']}
+ *   cameraSettings={cameraState}
+ *   generalObjectSettings={generalSettings}
+ *   apiBaseUrl="http://localhost:3001"
+ * />
+ */
+const ObjectsRendererApi = ({ objectIds, cameraSettings, generalObjectSettings, apiBaseUrl = 'http://localhost:3001', onObjectsReady, handleObjectClick, onError, onLoading, }) => {
+    const [createdObjects, setCreatedObjects] = useState([]);
+    const [isLoading, setIsLoading] = useState(true);
+    const [error, setError] = useState(null);
+    useEffect(() => {
+        const fetchObjects = async () => {
+            try {
+                setIsLoading(true);
+                onLoading?.(true);
+                setError(null);
+                if (!objectIds || objectIds.length === 0) {
+                    setCreatedObjects([]);
+                    setIsLoading(false);
+                    onLoading?.(false);
+                    return;
+                }
+                // Fetch scene objects from the data-center API
+                const idsParam = objectIds.join(',');
+                const response = await fetch(`${apiBaseUrl}/api/data/scene-objects?ids=${encodeURIComponent(idsParam)}`, {
+                    method: 'GET',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    credentials: 'include', // Include cookies for authentication
+                });
+                if (!response.ok) {
+                    throw new Error(`Failed to fetch scene objects: ${response.status} ${response.statusText}`);
+                }
+                const data = await response.json();
+                const objects = data.sceneObjects;
+                // Sort objects by their position in the original objectIds array to maintain order
+                const orderedObjects = objectIds
+                    .map(id => objects.find(obj => obj.id === id))
+                    .filter((obj) => obj !== undefined);
+                setCreatedObjects(orderedObjects);
+                setIsLoading(false);
+                onLoading?.(false);
+            }
+            catch (err) {
+                const error = err instanceof Error ? err : new Error(String(err));
+                setError(error);
+                onError?.(error);
+                setIsLoading(false);
+                onLoading?.(false);
+                console.error('Failed to fetch scene objects:', error);
+            }
+        };
+        fetchObjects();
+    }, [objectIds, apiBaseUrl, onError, onLoading]);
+    if (isLoading) {
+        return (_jsx("group", { children: _jsxs("mesh", { position: [0, 0, 0], children: [_jsx("sphereGeometry", { args: [0.5, 32, 32] }), _jsx("meshStandardMaterial", { color: 0x00ff00, wireframe: true })] }) }));
+    }
+    if (error) {
+        console.error('ObjectsRendererApi Error:', error);
+        return (_jsx("group", { children: _jsxs("mesh", { position: [0, 0, 0], children: [_jsx("sphereGeometry", { args: [0.5, 32, 32] }), _jsx("meshStandardMaterial", { color: 0xff0000, wireframe: true })] }) }));
+    }
+    return (_jsx(ObjectsRenderer, { cameraSettings: cameraSettings, createdObjects: createdObjects, generalObjectSettings: generalObjectSettings, onObjectsReady: onObjectsReady, handleObjectClick: handleObjectClick }));
+};
+export default ObjectsRendererApi;

package/dist/components/Ocean.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"Ocean.d.ts","sourceRoot":"","sources":["../../src/components/Ocean.tsx"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AACnE,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,MAAM,WAAW,UAAU;IACvB,QAAQ,EAAE,qBAAqB,CAAC;CACnC;AAGD,QAAA,MAAM,KAAK,EAAE,KAAK,CAAC,EAAE,CAAC,UAAU,CA6J/B,CAAC;AACF,eAAe,KAAK,CAAC"}

package/dist/components/Ocean.js

@@ -0,0 +1,169 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useRef, useState } from 'react';
+import * as THREE from 'three';
+import { useFrame } from '@react-three/fiber';
+import { useMaterialApplication } from '../hooks/useMaterialApplication.js';
+import { useWaterEnvironment } from '../hooks/useWaterEnvironment.js';
+import { useWaterReflections } from '../hooks/useWaterReflections.js';
+import { useAnimationEvents } from '../hooks/useAnimationEvents.js';
+import { useNumericAnimation } from '../hooks/useNumericAnimation.js';
+import { handleTransformAnimations, handleMaterialAnimations, handleTransformMouseMove, handleMaterialMouseMove, } from '@3driseai/3drise-core';
+const Ocean = ({ settings }) => {
+    const meshRef = useRef(null);
+    const uniformOverrideRef = useRef(null);
+    const matAnimCacheRef = useRef({});
+    const [meshVisible, setMeshVisible] = useState(null);
+    const { meshSettings, materialSettings, animations, mouseMove } = settings;
+    const { animateNumeric } = useNumericAnimation();
+    const config = settings.config || {
+        planeSize: [10000, 10000],
+        planeSegments: 64,
+    };
+    const planeSize = config?.planeSize || [10000, 10000];
+    const planeSegments = config?.planeSegments || 64;
+    const position = meshSettings.position || [0, -1, 0];
+    const rotation = meshSettings.rotation || [-Math.PI / 2, 0, 0];
+    const scale = meshSettings.scale || 1;
+    useMaterialApplication(meshSettings.visible ? meshRef.current : null, materialSettings);
+    useWaterEnvironment(meshSettings.visible ? meshRef : { current: null });
+    useWaterReflections(meshSettings.visible ? meshRef : { current: null }, {
+        waterPosition: new THREE.Vector3(...position),
+        resolution: 256,
+        updateFrequency: 1,
+        enabled: meshSettings.visible,
+    });
+    useAnimationEvents({
+        onStepStart: (event) => {
+            if (!event.step?.transitions)
+                return;
+            for (const transition of event.step.transitions) {
+                if (transition.state !== 'ocean' || !meshRef.current)
+                    continue;
+                const toProps = transition.properties.to || {};
+                const fromProps = transition.properties.from || {};
+                // visible — update state so JSX visible prop re-renders
+                if (toProps.visible !== undefined) {
+                    setMeshVisible(toProps.visible);
+                }
+                // numeric uniforms: animate any key in `to` that maps to a shader uniform
+                const material = meshRef.current.material;
+                const uniforms = material?.uniforms;
+                if (!uniforms)
+                    continue;
+                const from = {};
+                const to = {};
+                for (const key of Object.keys(toProps)) {
+                    if (key === 'visible')
+                        continue;
+                    const toVal = toProps[key];
+                    if (toVal === undefined)
+                        continue;
+                    to[key] = toVal;
+                    const fromExplicit = fromProps[key];
+                    if (fromExplicit !== undefined) {
+                        from[key] = fromExplicit;
+                    }
+                    else if (uniforms[key]?.value !== undefined) {
+                        const liveVal = uniforms[key].value;
+                        if (typeof liveVal === 'number') {
+                            from[key] = liveVal;
+                        }
+                        else if (liveVal?.toArray) {
+                            from[key] = liveVal.toArray();
+                        }
+                        else if (Array.isArray(liveVal)) {
+                            from[key] = [...liveVal];
+                        }
+                        else {
+                            from[key] = toVal;
+                        }
+                    }
+                    else {
+                        from[key] = toVal;
+                    }
+                }
+                if (Object.keys(to).length > 0) {
+                    animateNumeric(from, to, (updated) => {
+                        uniformOverrideRef.current = { ...uniformOverrideRef.current, ...updated };
+                    }, () => {
+                        uniformOverrideRef.current = null;
+                        if (toProps.visible !== undefined)
+                            setMeshVisible(null);
+                    }, event.step?.duration);
+                }
+            }
+        },
+    });
+    useFrame((state) => {
+        const mesh = meshRef.current;
+        if (!mesh?.material || !(meshVisible ?? meshSettings.visible))
+            return;
+        const material = mesh.material;
+        const uniforms = material?.uniforms;
+        if (!uniforms)
+            return;
+        const u_time = state.clock.getElapsedTime();
+        const mouse = state.pointer;
+        if (uniforms.u_time)
+            uniforms.u_time.value = u_time;
+        if (uniforms.u_cameraPosition)
+            uniforms.u_cameraPosition.value.copy(state.camera.position);
+        if (uniforms.u_resolution)
+            uniforms.u_resolution.value.set(window.innerWidth, window.innerHeight);
+        if (uniforms.u_mouse)
+            uniforms.u_mouse.value.set(mouse.x, mouse.y);
+        // Sequence-driven uniform overrides
+        if (uniformOverrideRef.current) {
+            for (const [key, val] of Object.entries(uniformOverrideRef.current)) {
+                if (!uniforms[key])
+                    continue;
+                const target = uniforms[key].value;
+                if (typeof val === 'number') {
+                    uniforms[key].value = val;
+                }
+                else if (Array.isArray(val)) {
+                    if (target?.set) {
+                        target.set(...val);
+                    }
+                    else if (target?.fromArray) {
+                        target.fromArray(val);
+                    }
+                    else {
+                        uniforms[key].value = val;
+                    }
+                }
+            }
+        }
+        // ── PER-DOMAIN ANIMATIONS ───────────────────────────────────────────────
+        const now = Date.now();
+        const transformAnims = animations?.transform?.animations;
+        if (transformAnims?.length) {
+            handleTransformAnimations({ object: mesh, meshSettings: meshSettings, pathIsActive: false }, transformAnims, now, false);
+        }
+        const materialAnims = animations?.material?.animations;
+        if (materialAnims?.length) {
+            handleMaterialAnimations({ object: mesh, materialSettings: materialSettings, startValuesCache: matAnimCacheRef.current }, materialAnims, now, false);
+        }
+        // ── PER-DOMAIN MOUSE-MOVE ───────────────────────────────────────────────
+        const mm = mouseMove;
+        const isPerDomain = mm && ('transform' in mm || 'material' in mm);
+        if (isPerDomain) {
+            const md = mm;
+            if (md.transform?.enabled && md.transform.properties?.length) {
+                handleTransformMouseMove({ object: mesh, meshSettings: meshSettings }, md.transform.properties, mouse);
+            }
+            if (md.material?.enabled && md.material.properties?.length) {
+                handleMaterialMouseMove({ object: mesh, materialSettings: materialSettings }, md.material.properties, mouse);
+            }
+        }
+    });
+    // console.log(rotation)
+    return (_jsx("mesh", { ref: meshRef, 
+        // name={settings.meshSettings.name || 'Water'}
+        // position={position}
+        // rotation={rotation}
+        // scale={scale}
+        // visible={meshVisible ?? meshSettings.visible}
+        userData: { id: '3drise-water' }, children: _jsx("planeGeometry", { args: [planeSize[0], planeSize[1], planeSegments, planeSegments] }) }));
+};
+export default Ocean;

package/dist/components/Outline.d.ts

@@ -0,0 +1,21 @@
+import { Line } from '@react-three/drei';
+import type { ComponentProps } from "react";
+import type { BufferGeometry } from "three";
+import { OutlineMode } from "./extractOutline";
+type DreiLineProps = ComponentProps<typeof Line>;
+export interface OutlineProps extends Omit<DreiLineProps, 'points' | 'segments' | 'ref' | 'geometry'> {
+    /** Any host geometry to outline. */
+    geometry: BufferGeometry;
+    /** '3d' = feature edges (uses `angle`), '2d' = flat front-plane profile. */
+    mode?: OutlineMode;
+    /** Dihedral threshold in degrees (3d mode only). */
+    angle?: number;
+}
+/**
+ * Fat-line outline of any host geometry. Resolution-correct pixel width is
+ * handled by drei's <Line>. Color / lineWidth / dashed are forwarded straight
+ * through, so the parent owns all appearance.
+ */
+export declare function Outline({ geometry, mode, angle, ...lineProps }: OutlineProps): import("react").JSX.Element;
+export {};
+//# sourceMappingURL=Outline.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Outline.d.ts","sourceRoot":"","sources":["../../src/components/Outline.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAEzC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC;AAC5C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC;AAC5C,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,KAAK,aAAa,GAAG,cAAc,CAAC,OAAO,IAAI,CAAC,CAAC;AAEjD,MAAM,WAAW,YAAa,SAAQ,IAAI,CAAC,aAAa,EAAE,QAAQ,GAAG,UAAU,GAAG,KAAK,GAAG,UAAU,CAAC;IACjG,oCAAoC;IACpC,QAAQ,EAAE,cAAc,CAAC;IACzB,4EAA4E;IAC5E,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,oDAAoD;IACpD,KAAK,CAAC,EAAE,MAAM,CAAC;CAClB;AAGD;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,EAAE,QAAQ,EAAE,IAAW,EAAE,KAAU,EAAE,GAAG,SAAS,EAAE,EAAE,YAAY,+BAKxF"}

package/dist/components/Outline.js

@@ -0,0 +1,14 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Line } from '@react-three/drei';
+import { useOutline } from '../hooks/useOutline.js';
+/**
+ * Fat-line outline of any host geometry. Resolution-correct pixel width is
+ * handled by drei's <Line>. Color / lineWidth / dashed are forwarded straight
+ * through, so the parent owns all appearance.
+ */
+export function Outline({ geometry, mode = '3d', angle = 18, ...lineProps }) {
+    const points = useOutline(geometry, mode, angle);
+    if (points.length === 0)
+        return null;
+    return _jsx(Line, { points: points, segments: true, ...lineProps });
+}

package/dist/components/ParticlesR3f.d.ts

@@ -0,0 +1,11 @@
+import type { ParticlesSettings } from '@3driseai/3drise-core';
+import React from "react";
+interface ParticlesR3fProps {
+    particlesSettings: ParticlesSettings;
+    cameraFov?: number;
+    duration?: number;
+    transitionSettings?: Record<string, unknown>;
+}
+declare const ParticlesR3f: React.FC<ParticlesR3fProps>;
+export default ParticlesR3f;
+//# sourceMappingURL=ParticlesR3f.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ParticlesR3f.d.ts","sourceRoot":"","sources":["../../src/components/ParticlesR3f.tsx"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE/D,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,UAAU,iBAAiB;IACvB,iBAAiB,EAAE,iBAAiB,CAAC;IACrC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,kBAAkB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAChD;AAMD,QAAA,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC,iBAAiB,CAiG7C,CAAC;AACF,eAAe,YAAY,CAAC"}