@3driseai/3drise-viewer 0.1.1

package/dist/components/ProjectLoader.js

@@ -0,0 +1,85 @@
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import { dataCenterServer } from '../constants.js';
+import SceneBuilder from "./SceneBuilder.js";
+import { loadAssets, } from "@3driseai/3drise-core";
+import LoadingIndicator from "./LoadingIndicator.js";
+import { useMeshController } from "../hooks/useMeshController.js";
+const PROJECT_LOADER_DEBUG_PREFIX = '[ProjectLoaderDebug]';
+const ProjectLoader = ({ projectId, onObjectClick, onObjectHover, onElementClick, onElementHover, onSceneInitialized, loadingIndicator = _jsx(LoadingIndicator, { text: "Loading project...", fullScreen: true, animate: true }) }) => {
+    const [project, setProject] = useState(null);
+    const meshController = useMeshController();
+    useEffect(() => {
+        if (projectId) {
+            loadProject(projectId);
+        }
+    }, [projectId]);
+    const loadProject = async (projectId) => {
+        try {
+            const url = `${dataCenterServer}projects/${projectId}/view`;
+            console.log(PROJECT_LOADER_DEBUG_PREFIX, 'Fetching project', {
+                projectId,
+                url,
+            });
+            const response = await fetch(url, {
+                method: "GET",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+            });
+            console.log(PROJECT_LOADER_DEBUG_PREFIX, 'Received project response', {
+                projectId,
+                status: response.status,
+                ok: response.ok,
+                url,
+            });
+            if (!response.ok) {
+                if (response.status === 404) {
+                    throw new Error("Project not found");
+                }
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            const responseData = await response.json();
+            // console.log(PROJECT_LOADER_DEBUG_PREFIX, 'Parsed project payload', {
+            //     projectId,
+            //     sceneObjectsCount: responseData.sceneObjects?.length || 0,
+            //     projectName: responseData.name,
+            // });
+            console.log("Loaded project:", responseData);
+            const sceneObjects = responseData.sceneObjects || [];
+            const modelObjects = sceneObjects.filter(obj => obj.type === 'model');
+            const meshObjects = sceneObjects.filter(obj => obj.type === 'mesh');
+            console.log('Model objects in loaded project:', modelObjects);
+            try {
+                const models = modelObjects.map(obj => ({
+                    ...obj.userData,
+                    id: obj.id,
+                }));
+                await loadAssets(models);
+                console.log('[useLoadProject] Assets loaded for model objects');
+            }
+            catch (assetError) {
+                console.error('[useLoadProject] Failed to load model assets, continuing with project load:', assetError);
+            }
+            meshController.createObjects(meshObjects);
+            console.log("PROJECT LOAD COMPLETE");
+            setProject(responseData);
+        }
+        catch (error) {
+            console.error(PROJECT_LOADER_DEBUG_PREFIX, 'Error fetching project', {
+                projectId,
+                error,
+            });
+        }
+    };
+    if (!project) {
+        return _jsx("div", { style: {
+                width: '100%', height: '100%', display: 'flex',
+                alignItems: 'center', justifyContent: 'center',
+                backgroundColor: 'black',
+                flexDirection: 'column', gap: '1rem'
+            }, children: loadingIndicator });
+    }
+    return _jsx(_Fragment, { children: _jsx(SceneBuilder, { project: project, onSceneInitialized: onSceneInitialized, onUiElementClick: onElementClick, onUiElementHover: onElementHover, onObjectClick: onObjectClick }) });
+};
+export default ProjectLoader;

package/dist/components/Rain.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"Rain.d.ts","sourceRoot":"","sources":["../../src/components/Rain.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AACnE,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,MAAM,WAAW,SAAS;IACtB,QAAQ,EAAE,qBAAqB,CAAC;CACnC;AA+ED,QAAA,MAAM,IAAI,EAAE,KAAK,CAAC,EAAE,CAAC,SAAS,CAgL7B,CAAC;AACF,eAAe,IAAI,CAAC"}

package/dist/components/Rain.js

@@ -0,0 +1,259 @@
+import { useEffect, useRef, useMemo } from 'react';
+import * as THREE from 'three';
+import { useThree, useFrame } from '@react-three/fiber';
+import { RainMaterial } from '@3driseai/3drise-core';
+import { applyEasing, calculateTimeProgress, gsapEasingMap, handleTransformAnimations, handleTransformMouseMove, interpolateMouseMoveProperty, interpolateValue, } from '@3driseai/3drise-core';
+const MAX_PARTICLES = 20000;
+const DEG_TO_RAD = Math.PI / 180;
+// Properties on RainConfig that can be driven per-frame by animations / mouseMove.
+const RAIN_ANIMATABLE = new Set([
+    'color', 'size', 'opacity', 'speed', 'windStrength', 'windDirection', 'turbulence',
+]);
+// =============================================================================
+// Rain-domain helpers
+// =============================================================================
+function applyRainKeyframeAnimations(animations, startValuesCache, config, override, currentTime) {
+    // Reset overrides each pass so removed animations don't linger.
+    for (const k of Object.keys(override))
+        delete override[k];
+    if (!animations?.length)
+        return;
+    for (const anim of animations) {
+        const { property, to, duration, ease, loop = false, yoyo = false, active } = anim;
+        if (!active || to === undefined)
+            continue;
+        if (!RAIN_ANIMATABLE.has(property))
+            continue;
+        let from = anim.from;
+        if (from === undefined) {
+            from = startValuesCache[property] ??= config[property];
+        }
+        if (from === undefined || from === null)
+            continue;
+        let p = calculateTimeProgress(currentTime, duration, yoyo, loop);
+        if (ease) {
+            const fn = gsapEasingMap[ease] || ease;
+            p = applyEasing(fn, p);
+        }
+        override[property] = interpolateValue(property, from, to, p);
+    }
+}
+function applyRainMouseMove(properties, config, override, pointer) {
+    for (const k of Object.keys(override))
+        delete override[k];
+    if (!properties?.length)
+        return;
+    for (const { property, enabled, propertySettings } of properties) {
+        if (!enabled || !RAIN_ANIMATABLE.has(property))
+            continue;
+        const { axis = 'both', sensitivity = 1, inverted = false, min, max } = propertySettings || {};
+        const base = config[property];
+        if (base === undefined)
+            continue;
+        override[property] = interpolateMouseMoveProperty(base, min, max, pointer, axis, sensitivity, inverted);
+    }
+}
+function applyRainOverridesToUniforms(material, overrides) {
+    if (!material?.uniforms)
+        return;
+    const u = material.uniforms;
+    if (overrides.color !== undefined && u.uColor) {
+        const c = overrides.color;
+        if (c instanceof THREE.Color)
+            u.uColor.value.copy(c);
+        else if (typeof c === 'string')
+            u.uColor.value.set(c);
+    }
+    if (overrides.opacity !== undefined && u.opacity)
+        u.opacity.value = overrides.opacity;
+    if (overrides.size !== undefined && u.streakLength) {
+        u.streakLength.value = Math.max(overrides.size * 30, 1.0);
+    }
+    if (overrides.windDirection !== undefined && u.windAngle) {
+        u.windAngle.value = overrides.windDirection * DEG_TO_RAD;
+    }
+    if (overrides.windStrength !== undefined && u.windTilt) {
+        u.windTilt.value = overrides.windStrength;
+    }
+}
+// =============================================================================
+// MAIN COMPONENT
+// =============================================================================
+const Rain = ({ settings }) => {
+    const { scene } = useThree();
+    const materialRef = useRef(null);
+    const geometryRef = useRef(null);
+    const pointsRef = useRef(null);
+    const velocitiesRef = useRef(null);
+    const { meshSettings, animations, mouseMove } = settings;
+    const areaSize = meshSettings.scale?.[0] ?? 200;
+    const config = settings.config;
+    const particleCount = useMemo(() => {
+        const density = config.density ?? 100;
+        return Math.min(Math.max(Math.round(density * 100), 100), MAX_PARTICLES);
+    }, [config.density]);
+    // Per-domain override refs + caches
+    const animatedRainOverrideRef = useRef({});
+    const mouseRainOverrideRef = useRef({});
+    const rainAnimCacheRef = useRef({});
+    useEffect(() => {
+        const halfArea = areaSize / 2;
+        const height = areaSize * 1.25;
+        const positions = new Float32Array(particleCount * 3);
+        const speeds = new Float32Array(particleCount);
+        const velocities = new Float32Array(particleCount);
+        for (let i = 0; i < particleCount; i++) {
+            const i3 = i * 3;
+            positions[i3] = Math.random() * areaSize - halfArea;
+            positions[i3 + 1] = Math.random() * height - height / 4;
+            positions[i3 + 2] = Math.random() * areaSize - halfArea;
+            const v = 0.8 + Math.random() * 0.4;
+            speeds[i] = v;
+            velocities[i] = v;
+        }
+        const geometry = new THREE.BufferGeometry();
+        geometry.setAttribute('position', new THREE.BufferAttribute(positions, 3));
+        geometry.setAttribute('speed', new THREE.BufferAttribute(speeds, 1));
+        const material = new RainMaterial();
+        material.transparent = true;
+        material.depthWrite = false;
+        material.blending = THREE.NormalBlending;
+        material.uniforms.uColor.value.set(config.color || '#ffffff');
+        material.uniforms.opacity.value = config.opacity ?? 0.5;
+        material.uniforms.streakLength.value = Math.max((config.size ?? 0.1) * 30, 1.0);
+        const points = new THREE.Points(geometry, material);
+        points.name = meshSettings.name;
+        points.userData.id = settings.id;
+        points.frustumCulled = false;
+        if (pointsRef.current) {
+            scene.remove(pointsRef.current);
+            geometryRef.current?.dispose();
+            materialRef.current?.dispose();
+        }
+        geometryRef.current = geometry;
+        materialRef.current = material;
+        pointsRef.current = points;
+        velocitiesRef.current = velocities;
+        if (meshSettings.visible)
+            scene.add(points);
+        return () => {
+            if (pointsRef.current)
+                scene.remove(pointsRef.current);
+            geometry.dispose();
+            material.dispose();
+        };
+    }, [particleCount, areaSize]); // eslint-disable-line react-hooks/exhaustive-deps
+    useEffect(() => {
+        if (!pointsRef.current)
+            return;
+        if (meshSettings.visible) {
+            if (!pointsRef.current.parent)
+                scene.add(pointsRef.current);
+        }
+        else {
+            scene.remove(pointsRef.current);
+        }
+    }, [meshSettings.visible, scene]);
+    useEffect(() => {
+        if (!materialRef.current)
+            return;
+        const u = materialRef.current.uniforms;
+        u.uColor.value.set(config.color || '#ffffff');
+        u.opacity.value = config.opacity ?? 0.5;
+        u.streakLength.value = Math.max((config.size ?? 0.1) * 30, 1.0);
+    }, [config.color, config.size, config.opacity]);
+    useEffect(() => {
+        if (!materialRef.current)
+            return;
+        const u = materialRef.current.uniforms;
+        u.windAngle.value = (config.windDirection ?? 0) * DEG_TO_RAD;
+        u.windTilt.value = config.windStrength ?? 0;
+    }, [config.windDirection, config.windStrength]);
+    useFrame((state, delta) => {
+        if (!geometryRef.current || !meshSettings.visible || !velocitiesRef.current)
+            return;
+        const points = pointsRef.current;
+        const material = materialRef.current;
+        const now = Date.now();
+        const pointer = state.pointer;
+        // ── PER-DOMAIN ANIMATIONS ───────────────────────────────────────────────
+        const transformAnims = animations?.transform?.animations;
+        if (points && transformAnims?.length) {
+            handleTransformAnimations({ object: points, meshSettings: meshSettings, pathIsActive: false }, transformAnims, now, false);
+        }
+        applyRainKeyframeAnimations(animations?.rain?.animations, rainAnimCacheRef.current, config, animatedRainOverrideRef.current, now);
+        // ── PER-DOMAIN MOUSE-MOVE ───────────────────────────────────────────────
+        const mm = mouseMove;
+        const isPerDomain = mm && ('transform' in mm || 'rain' in mm);
+        if (isPerDomain) {
+            const md = mm;
+            if (points && md.transform?.enabled && md.transform.properties?.length) {
+                handleTransformMouseMove({ object: points, meshSettings: meshSettings }, md.transform.properties, pointer);
+            }
+            applyRainMouseMove(md.rain?.enabled ? md.rain.properties : undefined, config, mouseRainOverrideRef.current, pointer);
+        }
+        else {
+            for (const k of Object.keys(mouseRainOverrideRef.current))
+                delete mouseRainOverrideRef.current[k];
+        }
+        // Push override-driven values to material uniforms (mouse first, animation wins).
+        applyRainOverridesToUniforms(material, mouseRainOverrideRef.current);
+        applyRainOverridesToUniforms(material, animatedRainOverrideRef.current);
+        // Effective values for the particle simulation (animation wins, then mouse, then config).
+        const effectiveSpeed = animatedRainOverrideRef.current.speed
+            ?? mouseRainOverrideRef.current.speed
+            ?? config.speed
+            ?? 1;
+        const effectiveWindStrength = animatedRainOverrideRef.current.windStrength
+            ?? mouseRainOverrideRef.current.windStrength
+            ?? config.windStrength
+            ?? 0;
+        const effectiveWindDirection = animatedRainOverrideRef.current.windDirection
+            ?? mouseRainOverrideRef.current.windDirection
+            ?? config.windDirection
+            ?? 0;
+        const effectiveTurbulence = animatedRainOverrideRef.current.turbulence
+            ?? mouseRainOverrideRef.current.turbulence
+            ?? config.turbulence
+            ?? 0;
+        // ── PARTICLE SIMULATION ─────────────────────────────────────────────────
+        const posAttr = geometryRef.current.attributes.position;
+        const positions = posAttr.array;
+        const velocities = velocitiesRef.current;
+        const fallSpeed = effectiveSpeed * 60;
+        const windMag = effectiveWindStrength * 30;
+        const windAngle = effectiveWindDirection * DEG_TO_RAD;
+        const windX = Math.sin(windAngle) * windMag;
+        const windZ = Math.cos(windAngle) * windMag;
+        const halfArea = areaSize / 2;
+        const height = areaSize * 1.25;
+        const groundY = -height / 4;
+        const dt = Math.min(delta, 0.05);
+        for (let i = 0; i < particleCount; i++) {
+            const i3 = i * 3;
+            const v = velocities[i];
+            const turbX = effectiveTurbulence > 0 ? (Math.random() - 0.5) * effectiveTurbulence * 10 * dt : 0;
+            const turbZ = effectiveTurbulence > 0 ? (Math.random() - 0.5) * effectiveTurbulence * 10 * dt : 0;
+            positions[i3] += (windX * v + turbX) * dt;
+            positions[i3 + 1] -= fallSpeed * v * dt;
+            positions[i3 + 2] += (windZ * v + turbZ) * dt;
+            if (positions[i3 + 1] < groundY) {
+                positions[i3] = Math.random() * areaSize - halfArea;
+                positions[i3 + 1] = height * 0.75;
+                positions[i3 + 2] = Math.random() * areaSize - halfArea;
+                velocities[i] = 0.8 + Math.random() * 0.4;
+            }
+            if (positions[i3] > halfArea)
+                positions[i3] -= areaSize;
+            if (positions[i3] < -halfArea)
+                positions[i3] += areaSize;
+            if (positions[i3 + 2] > halfArea)
+                positions[i3 + 2] -= areaSize;
+            if (positions[i3 + 2] < -halfArea)
+                positions[i3 + 2] += areaSize;
+        }
+        posAttr.needsUpdate = true;
+    });
+    return null;
+};
+export default Rain;

package/dist/components/RiseLogo.d.ts

@@ -0,0 +1,19 @@
+interface RiseLogoProps {
+    /** Width/height in px @default 160 */
+    size?: number;
+    /** Play the staggered build-up animation @default true */
+    animated?: boolean;
+    /** Loop the center dot pulse @default true */
+    loop?: boolean;
+    /** Animation speed multiplier @default 1 */
+    speed?: number;
+    /** Primary accent hex color @default "#00f5ff" */
+    color?: string;
+    /** SVG background fill — use "transparent" for none @default "transparent" */
+    bgColor?: string;
+    /** Called once the build animation completes */
+    onComplete?: () => void;
+}
+declare const RiseLogo: ({ size, animated, loop, speed, color, bgColor, onComplete, }: RiseLogoProps) => import("react").JSX.Element;
+export default RiseLogo;
+//# sourceMappingURL=RiseLogo.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"RiseLogo.d.ts","sourceRoot":"","sources":["../../src/components/RiseLogo.tsx"],"names":[],"mappings":"AACA,UAAU,aAAa;IACnB,sCAAsC;IACtC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,0DAA0D;IAC1D,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,8CAA8C;IAC9C,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,4CAA4C;IAC5C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,kDAAkD;IAClD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,8EAA8E;IAC9E,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,gDAAgD;IAChD,UAAU,CAAC,EAAE,MAAM,IAAI,CAAC;CAC3B;AAED,QAAA,MAAM,QAAQ,GAAI,8DAAkH,aAAa,gCA6DhJ,CAAC;AAWF,eAAe,QAAQ,CAAC"}

package/dist/components/RiseLogo.js

@@ -0,0 +1,75 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useState, useEffect, useRef } from "react";
+const RiseLogo = ({ size = 160, animated = true, loop = true, speed = 1, color = "#00f5ff", bgColor = "transparent", onComplete, }) => {
+    const [phase, setPhase] = useState(animated ? "idle" : "done");
+    const timers = useRef([]);
+    const colorDark = blendHex(color, "#000000", 0.55);
+    const colorMid = blendHex(color, "#000000", 0.72);
+    const colorDarker = blendHex(colorMid, "#000000", 0.15);
+    const baseDuration = 350 / speed;
+    useEffect(() => {
+        if (!animated) {
+            setPhase("done");
+            return;
+        }
+        timers.current.forEach(clearTimeout);
+        timers.current = [];
+        setPhase("idle");
+        timers.current = [
+            setTimeout(() => setPhase("block1"), 80),
+            setTimeout(() => setPhase("block2"), 80 + baseDuration),
+            setTimeout(() => setPhase("block3"), 80 + baseDuration * 2),
+            setTimeout(() => { setPhase("done"); onComplete?.(); }, 80 + baseDuration * 3 + 120),
+        ];
+        return () => timers.current.forEach(clearTimeout);
+    }, [animated, speed]);
+    const ease = "cubic-bezier(0.22, 1, 0.36, 1)";
+    const dur = `${baseDuration}ms`;
+    const b1 = ["block1", "block2", "block3", "done"].includes(phase);
+    const b2 = ["block2", "block3", "done"].includes(phase);
+    const b3 = ["block3", "done"].includes(phase);
+    const apex = phase === "done";
+    const blockStyle = (visible) => ({
+        opacity: visible ? 1 : 0,
+        transform: visible ? "translateY(0)" : "translateY(14px)",
+        transition: visible
+            ? `opacity ${dur} ${ease}, transform ${dur} ${ease}`
+            : "none",
+    });
+    const apexStyle = {
+        opacity: apex ? 1 : 0,
+        transition: apex ? `opacity ${dur} ease` : "none",
+    };
+    // ViewBox: 170 × 175
+    // Top block face vertices: top(85,76) left(64,88) right(106,88) bottom(85,100)
+    // Center of top face = (85, 88)
+    const CX = 85;
+    const CY = 88;
+    const pulseDur = `${(1800 / speed).toFixed(0)}ms`;
+    const beamDur = `${(900 / speed).toFixed(0)}ms`;
+    const loopVal = loop ? "infinite" : "1";
+    return (_jsxs(_Fragment, { children: [_jsx("style", { children: `
+        @keyframes rl-pulse {
+          0%   { r: 5;  opacity: 0.9; }
+          70%  { r: 17; opacity: 0.12; }
+          100% { r: 22; opacity: 0; }
+        }
+        @keyframes rl-beam {
+          0%   { stroke-dashoffset: 0; }
+          100% { stroke-dashoffset: -28; }
+        }
+        .rl-pulse { animation: rl-pulse ${pulseDur} ease-out ${loopVal} forwards; }
+        .rl-beam  { animation: rl-beam  ${beamDur}  linear   ${loopVal}; }
+      ` }), _jsxs("svg", { width: size, height: size, viewBox: "0 0 170 175", xmlns: "http://www.w3.org/2000/svg", "aria-label": "3D-Rise logo", role: "img", style: { background: bgColor, display: "block" }, children: [_jsxs("g", { style: blockStyle(b1), children: [_jsx("polygon", { points: "45,120 85,98 125,120 85,142", fill: colorDark, stroke: color, strokeWidth: "1" }), _jsx("polygon", { points: "45,120 45,132 85,154 85,142", fill: colorMid, stroke: color, strokeWidth: "1" }), _jsx("polygon", { points: "125,120 125,132 85,154 85,142", fill: colorDarker, stroke: color, strokeWidth: "1" })] }), _jsxs("g", { style: blockStyle(b2), children: [_jsx("polygon", { points: "55,103 85,85 115,103 85,121", fill: colorDark, stroke: color, strokeWidth: "1" }), _jsx("polygon", { points: "55,103 55,114 85,132 85,121", fill: colorMid, stroke: color, strokeWidth: "1" }), _jsx("polygon", { points: "115,103 115,114 85,132 85,121", fill: colorDarker, stroke: color, strokeWidth: "1" })] }), _jsxs("g", { style: blockStyle(b3), children: [_jsx("polygon", { points: "64,88 85,76 106,88 85,100", fill: colorDark, stroke: color, strokeWidth: "1" }), _jsx("polygon", { points: "64,88 64,97 85,109 85,100", fill: colorMid, stroke: color, strokeWidth: "1" }), _jsx("polygon", { points: "106,88 106,97 85,109 85,100", fill: colorDarker, stroke: color, strokeWidth: "1" })] }), _jsxs("g", { style: apexStyle, children: [_jsx("line", { x1: CX, y1: "44", x2: CX, y2: CY, stroke: color, strokeWidth: "1.4", strokeDasharray: "5 4", className: "rl-beam", opacity: "0.55" }), _jsx("circle", { cx: CX, cy: CY, r: "5", fill: "none", stroke: color, strokeWidth: "1", className: "rl-pulse" }), _jsx("circle", { cx: CX, cy: CY, r: "9", fill: "none", stroke: color, strokeWidth: "0.7", opacity: "0.3" }), _jsx("circle", { cx: CX, cy: CY, r: "4.5", fill: color }), _jsx("circle", { cx: CX, cy: CY, r: "2", fill: "#ffffff", opacity: "0.85" })] })] })] }));
+};
+/** Linearly blend two hex colors. ratio: 0 = all a, 1 = all b */
+function blendHex(a, b, ratio) {
+    const parse = (h) => {
+        h = h.replace("#", "");
+        return [parseInt(h.slice(0, 2), 16), parseInt(h.slice(2, 4), 16), parseInt(h.slice(4, 6), 16)];
+    };
+    const [ar, ag, ab] = parse(a);
+    const [br, bg, bb] = parse(b);
+    return `rgb(${Math.round(ar + (br - ar) * ratio)},${Math.round(ag + (bg - ag) * ratio)},${Math.round(ab + (bb - ab) * ratio)})`;
+}
+export default RiseLogo;

package/dist/components/SceneBuilder.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"SceneBuilder.d.ts","sourceRoot":"","sources":["../../src/components/SceneBuilder.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAQ/D,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,QAAA,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC,iBAAiB,CAwH7C,CAAC;AACF,eAAe,YAAY,CAAC"}

package/dist/components/SceneBuilder.js

@@ -0,0 +1,133 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from "react";
+import { Canvas } from "@react-three/fiber";
+import { LIGHTING_PRESETS, SceneStore } from "@3driseai/3drise-core";
+import { NoToneMapping } from "three";
+import LightsManager from "./LightsManager.js";
+import EnvironmentManager from "./EnvironmentManager.js";
+import CameraController from "./CameraController.js";
+import ObjectsRenderer from "./ObjectsRenderer.js";
+import CursorController from "./cursor/CursorController.js";
+import { Physics } from "@react-three/rapier";
+const SceneBuilder = ({ project, width = "100%", height = "100vh", style = {}, className = "", onSceneInitialized, onUiElementClick, onObjectClick, }) => {
+    const sceneSettings = (project.sceneSettingsData || {});
+    // const meshController = useMeshController();
+    const [isThreeJsMounted, setIsThreeJsMounted] = useState(false);
+    const environment = (project.environments && project.environments.length > 0
+        ? project.environments[0]
+        : null);
+    const camera = (project.camera || {
+        position: [0, 5, 10],
+        orientation: [0, 0, 0],
+        fov: 50,
+        near: 0.1,
+        far: 1000,
+        controls: {
+            enabled: true,
+            enablePan: true,
+            enableRotate: true,
+            autoRotate: false,
+            autoRotateSpeed: 2,
+            target: [0, 0, 0],
+            zoomSpeed: 1,
+            panSpeed: 1,
+            rotateSpeed: 1,
+            minDistance: 1,
+            maxDistance: 1000,
+            minPolarAngle: -Infinity,
+            maxPolarAngle: Infinity,
+            minAzimuthAngle: -Infinity,
+            maxAzimuthAngle: Infinity,
+        }
+    });
+    const animationSequences = project.animationSequences || [];
+    const sceneObjects = project.sceneObjects || sceneSettings.scene?.objectSettings || [];
+    const modelObjects = sceneObjects.filter((obj) => obj.type === "model");
+    const meshObjects = sceneObjects.filter((obj) => obj.type === "mesh");
+    const sceneCanvas = sceneSettings.canvas || sceneSettings.scene?.canvas || {};
+    const physicsSettings = sceneSettings.physicsSettings || sceneSettings.scene?.physicsSettings || {
+        enabled: true,
+        debug: false,
+        gravity: [0, -3, 0],
+    };
+    const generalObjectSettings = sceneSettings.generalObjectSettings || sceneSettings.scene?.generalObjectSettings || {
+        meshSettings: {
+            id: 'scene-general-settings',
+            name: "All Objects",
+            visible: true,
+            position: [0, 0, 0],
+            rotation: [0, 0, 0],
+            scale: [1, 1, 1],
+            anchor: null,
+        },
+        materialSettings: {
+            color: '#ffffff',
+            opacity: 1,
+            transparent: true,
+            materialType: "basic",
+            materialName: "Standard",
+        },
+    };
+    const timeSettings = sceneSettings.timeSettings || sceneSettings.scene?.timeSettings || {};
+    const lighting = project.lights && project.lights.length > 0 ? project.lights : [{ ...LIGHTING_PRESETS.ambient.config, enabled: true, showHelpers: false }];
+    const controls = camera.controls;
+    const { shadows = false, antialias = true, dpr = window.devicePixelRatio, gl = {}, backgroundColor = "#000000" } = sceneCanvas;
+    const { position, orientation, fov, near, far } = camera;
+    const containerStyle = {
+        width,
+        height,
+        position: "relative",
+        overflow: "hidden",
+        ...style,
+    };
+    // useEffect(() => {
+    //   const initializeSceneAssets = async () => {
+    //     if (modelObjects.length > 0) {
+    //       const modelData: ModelData[] = modelObjects.map((obj) => {
+    //         return {
+    //           id: obj.id,
+    //           ...obj.userData,
+    //         };
+    //       }) as ModelData[];
+    //       await loadAssets(modelData);
+    //     }
+    //     const meshes = meshObjects.map((obj) => {
+    //       return {
+    //         id: obj.id,
+    //         ...obj.userData,
+    //       };
+    //     });
+    //     meshController.createMeshes(meshes);
+    //   };
+    //   initializeSceneAssets();
+    // }, [meshController, modelObjects, meshObjects]);
+    const handleElementClick = (element) => {
+        console.log("Element clicked in scene:", element);
+        if (element && onUiElementClick) {
+            onUiElementClick(element);
+        }
+    };
+    return (_jsx("div", { className: className, style: containerStyle, children: _jsx(Canvas, { style: {
+                backgroundColor: backgroundColor,
+            }, shadows: shadows, dpr: dpr, gl: {
+                antialias,
+                alpha: true,
+                powerPreference: "high-performance",
+                ...gl,
+            }, camera: {
+                fov,
+                near,
+                far,
+                position: [position[0], position[1], position[2]],
+                rotation: [orientation[0], orientation[1], orientation[2]],
+            }, onCreated: (state) => {
+                state.gl.toneMapping = NoToneMapping;
+                setIsThreeJsMounted(true);
+                SceneStore.scene = state.scene;
+                SceneStore.gl = state.gl;
+                if (onSceneInitialized) {
+                    onSceneInitialized();
+                }
+            }, children: _jsxs(Physics, { gravity: physicsSettings.gravity, paused: !physicsSettings.enabled, debug: physicsSettings.debug, children: [_jsx(LightsManager, { config: lighting[0] }), environment && _jsx(EnvironmentManager, { environment: environment, timeSettings: timeSettings }), _jsx(CameraController, { settings: camera }), _jsx(ObjectsRenderer, { cameraSettings: camera, generalObjectSettings: generalObjectSettings, createdObjects: sceneObjects, onObjectsReady: undefined, sequences: animationSequences, handleObjectClick: onObjectClick ? (object, ref, event) => onObjectClick(object, ref, event) : undefined }), _jsx(CursorController, { effects: project.cursor?.effects, clickActions: project.cursor?.clickActions })] }) }) }));
+};
+export default SceneBuilder;

package/dist/components/SceneFog.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"SceneFog.d.ts","sourceRoot":"","sources":["../../src/components/SceneFog.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACzD,MAAM,WAAW,aAAa;IAC1B,GAAG,EAAE,WAAW,CAAC;CACpB;AAGD,QAAA,MAAM,QAAQ,EAAE,KAAK,CAAC,EAAE,CAAC,aAAa,CAcrC,CAAC;AACF,eAAe,QAAQ,CAAC"}

package/dist/components/SceneFog.js

@@ -0,0 +1,19 @@
+import { useEffect } from 'react';
+import * as THREE from 'three';
+import { useThree } from '@react-three/fiber';
+const SceneFog = ({ fog }) => {
+    const { scene } = useThree();
+    useEffect(() => {
+        if (fog.visible) {
+            scene.fog = new THREE.Fog(fog.color, fog.near, fog.far);
+        }
+        else {
+            scene.fog = null;
+        }
+        return () => {
+            scene.fog = null;
+        };
+    }, [scene, fog.visible, fog.color, fog.near, fog.far]);
+    return null;
+};
+export default SceneFog;

package/dist/components/Shape.d.ts

@@ -0,0 +1,5 @@
+import React from "react";
+type ShapeProps = {};
+declare const SuperMesh: React.FC<ShapeProps>;
+export default SuperMesh;
+//# sourceMappingURL=Shape.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Shape.d.ts","sourceRoot":"","sources":["../../src/components/Shape.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,KAAK,UAAU,GAAG,EAAE,CAAC;AAGrB,QAAA,MAAM,SAAS,EAAE,KAAK,CAAC,EAAE,CAAC,UAAU,CAInC,CAAC;AACF,eAAe,SAAS,CAAC"}

package/dist/components/Shape.js

@@ -0,0 +1,11 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// @ts-nocheck
+import { GeometryShape } from "./GeometryShape.js";
+const SuperMesh = ({}) => {
+    return (_jsx(GeometryShape
+    // ref={meshRef}
+    , { 
+        // ref={meshRef}
+        shape: createdObject.config?.type || 'box', mode: createdObject.config?.mode || 'solid' }));
+};
+export default SuperMesh;