@ntalmagor/3drize-viewer 0.1.2

package/dist/components/ProductionScene.d.ts

@@ -0,0 +1,29 @@
+import React from "react";
+import type { DeviceType } from "@ntalmagor/3drize-core";
+type ProductionSceneProps = {
+    device: DeviceType;
+    onObjectsReady?: () => void;
+    gridSettings: any;
+    hdr: any;
+    physicsSettings: any;
+    generalObjectSettings: any;
+    ocean: any;
+    cameraSettings: any;
+    selectedLight: any;
+    objects: any;
+    lighting: any;
+    controls: any;
+    geometry: any;
+    structure: any;
+    isPathMode: boolean;
+    editingPath: any;
+    sky: any;
+    timeSettings: any;
+    starsSettings: any;
+    clouds: any;
+    rainSettings: any;
+    fogSettings: any;
+};
+declare const ProductionScene: React.FC<ProductionSceneProps>;
+export default ProductionScene;
+//# sourceMappingURL=ProductionScene.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ProductionScene.d.ts","sourceRoot":"","sources":["../../src/components/ProductionScene.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAK1B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAWzD,KAAK,oBAAoB,GAAG;IAC1B,MAAM,EAAE,UAAU,CAAC;IACnB,cAAc,CAAC,EAAE,MAAM,IAAI,CAAC;IAC5B,YAAY,EAAE,GAAG,CAAC;IAClB,GAAG,EAAE,GAAG,CAAC;IACT,eAAe,EAAE,GAAG,CAAC;IACrB,qBAAqB,EAAE,GAAG,CAAC;IAC3B,KAAK,EAAE,GAAG,CAAC;IACX,cAAc,EAAE,GAAG,CAAC;IACpB,aAAa,EAAE,GAAG,CAAC;IACnB,OAAO,EAAE,GAAG,CAAC;IACb,QAAQ,EAAE,GAAG,CAAC;IACd,QAAQ,EAAE,GAAG,CAAC;IACd,QAAQ,EAAE,GAAG,CAAC;IACd,SAAS,EAAE,GAAG,CAAC;IACf,UAAU,EAAE,OAAO,CAAC;IACpB,WAAW,EAAE,GAAG,CAAC;IACjB,GAAG,EAAE,GAAG,CAAC;IACT,YAAY,EAAE,GAAG,CAAC;IAClB,aAAa,EAAE,GAAG,CAAC;IACnB,MAAM,EAAE,GAAG,CAAC;IACZ,YAAY,EAAE,GAAG,CAAC;IAClB,WAAW,EAAE,GAAG,CAAC;CAClB,CAAC;AAEF,QAAA,MAAM,eAAe,EAAE,KAAK,CAAC,EAAE,CAAC,oBAAoB,CAwFnD,CAAC;AAEF,eAAe,eAAe,CAAC"}

package/dist/components/ProductionScene.js

@@ -0,0 +1,18 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { OrbitControls } from "@react-three/drei";
+import { Physics } from "@react-three/rapier";
+import { Vector3 } from "three";
+// import GridHelper from "/GridHelper";
+// import { ShaderMesh } from "~/components/MaterialCreator/components";
+// import StructureRenderer from "~/components/StructureRenderer/StructureRenderer";
+import PathRenderer from "./PathRenderer";
+import LightsManager from "./LightsManager";
+import EnvironmentManager from "./EnvironmentManager";
+import CameraController from "./CameraController";
+import Ocean from "./Ocean";
+import ObjectsRenderer from "./ObjectsRenderer";
+const ProductionScene = ({ onObjectsReady, gridSettings, hdr, physicsSettings, generalObjectSettings, ocean, cameraSettings, selectedLight, objects, lighting, controls, geometry, structure, isPathMode, editingPath, sky, timeSettings, starsSettings, clouds, rainSettings, fogSettings, }) => {
+    const sunSystem = sky.sunSystem;
+    return (_jsxs(Physics, { gravity: physicsSettings.gravity, paused: !physicsSettings.enabled, debug: physicsSettings.debug, children: [_jsx(LightsManager, { lights: lighting, selectedLight: selectedLight }), _jsx(EnvironmentManager, { hdrSettings: hdr, timeSettings: timeSettings, visible: true, sunSystemVisible: sunSystem.visible, sunSize: sunSystem.sunSize, moonSize: sunSystem.moonSize, sunIntensity: sunSystem.intensity, castShadow: sunSystem.castShadow, shadowMapSize: sunSystem.shadowMapSize, starsSettings: starsSettings, skyControllerSettings: sky.visible && !sunSystem.visible ? sky : undefined, cloudsSettings: clouds, cloudsMaterialSettings: clouds.materialSettings, rainSettings: rainSettings, fogSettings: fogSettings }), _jsx(CameraController, { settings: cameraSettings }), _jsx(Ocean, { settings: ocean }), _jsx(ObjectsRenderer, { cameraSettings: cameraSettings, generalObjectSettings: generalObjectSettings, createdObjects: objects, onObjectsReady: onObjectsReady }), isPathMode && editingPath && _jsx(PathRenderer, { pathSettings: editingPath }), _jsx(OrbitControls, { makeDefault: true, enabled: controls.enabled, target: new Vector3(...controls.target), enablePan: controls.enablePan, enableRotate: controls.enableRotate, autoRotate: controls.autoRotate, autoRotateSpeed: controls.autoRotateSpeed, zoomSpeed: controls.zoomSpeed, panSpeed: controls.panSpeed, rotateSpeed: controls.rotateSpeed, minDistance: controls.minDistance, maxDistance: controls.maxDistance, minPolarAngle: controls.minPolarAngle ? controls.minPolarAngle : -Infinity, maxPolarAngle: controls.maxPolarAngle ? controls.maxPolarAngle : Infinity, minAzimuthAngle: controls.minAzimuthAngle ? controls.minAzimuthAngle : -Infinity, maxAzimuthAngle: controls.maxAzimuthAngle ? controls.maxAzimuthAngle : Infinity })] }));
+};
+export default ProductionScene;

package/dist/components/ProjectLoader.d.ts

@@ -0,0 +1,14 @@
+import React from "react";
+import { type CreatedObjectSettings, type HtmlElement } from "@ntalmagor/3drize-core";
+import { Object3D } from "three";
+type ProjectProps = {
+    projectId: string;
+    onObjectClick?: (object: CreatedObjectSettings, ref: Object3D) => void;
+    onObjectHover?: (object: CreatedObjectSettings, ref: Object3D) => void;
+    onElementClick?: (element: HtmlElement) => void;
+    onElementHover?: (element: HtmlElement | null) => void;
+    onSceneInitialized?: () => void;
+};
+declare const ProjectLoader: React.FC<ProjectProps>;
+export default ProjectLoader;
+//# sourceMappingURL=ProjectLoader.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ProjectLoader.d.ts","sourceRoot":"","sources":["../../src/components/ProjectLoader.tsx"],"names":[],"mappings":"AAAA,OAAO,KAA8B,MAAM,OAAO,CAAC;AAKnD,OAAQ,EAAE,KAAK,qBAAqB,EAAkB,KAAK,WAAW,EAA2C,MAAM,wBAAwB,CAAC;AAIhJ,OAAO,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAGjC,KAAK,YAAY,GAAG;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,CAAC,EAAE,CAAC,MAAM,EAAE,qBAAqB,EAAE,GAAG,EAAE,QAAQ,KAAK,IAAI,CAAC;IACvE,aAAa,CAAC,EAAE,CAAC,MAAM,EAAE,qBAAqB,EAAE,GAAG,EAAE,QAAQ,KAAK,IAAI,CAAC;IACvE,cAAc,CAAC,EAAE,CAAC,OAAO,EAAE,WAAW,KAAK,IAAI,CAAC;IAChD,cAAc,CAAC,EAAE,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI,KAAK,IAAI,CAAC;IACvD,kBAAkB,CAAC,EAAE,MAAM,IAAI,CAAC;CACnC,CAAC;AAEF,QAAA,MAAM,aAAa,EAAE,KAAK,CAAC,EAAE,CAAC,YAAY,CAwFzC,CAAC;AAEF,eAAe,aAAa,CAAC"}

package/dist/components/ProjectLoader.js

@@ -0,0 +1,76 @@
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+// import type { GetProjectPayload, Project } from '~/types/users';
+import { dataCenterServer } from '../constants';
+// import { buildQueryString } from "~/utils/utils";
+import SceneBuilder from "./SceneBuilder";
+import { loadAssets } from "@ntalmagor/3drize-core";
+import { buildQueryString } from "@ntalmagor/3drize-core";
+import useMeshController from '../hooks/useMeshController';
+import LoadingIndicator from "./LoadingIndicator";
+const ProjectLoader = ({ projectId, onObjectClick, onObjectHover, onElementClick, onElementHover, onSceneInitialized }) => {
+    const [project, setProject] = useState(null);
+    const meshController = useMeshController();
+    useEffect(() => {
+        if (projectId) {
+            const queryParams = {
+                id: projectId,
+                includeOwner: false,
+                includeDependencies: false,
+                includeTransactions: false,
+            };
+            loadProject(projectId, queryParams);
+        }
+    }, [projectId]);
+    const loadProject = async (projectId, queryParams) => {
+        try {
+            const queryString = buildQueryString(queryParams);
+            const url = `${dataCenterServer}projects/${projectId}${queryString ? `?${queryString}` : ''}`;
+            const response = await fetch(url, {
+                method: "GET",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+            });
+            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("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);
+            }
+            const meshes = meshObjects.map(obj => {
+                return {
+                    ...obj.userData,
+                    id: obj.id,
+                };
+            });
+            meshController.createMeshes(meshes);
+            setProject(responseData);
+        }
+        catch (error) {
+            console.error("Error fetching project:", error);
+        }
+    };
+    if (!project) {
+        return _jsx(LoadingIndicator, { text: "Loading project...", fullScreen: true });
+    }
+    return _jsx(_Fragment, { children: _jsx(SceneBuilder, { project: project, onSceneInitialized: onSceneInitialized, onUiElementClick: onElementClick, onUiElementHover: onElementHover }) });
+};
+export default ProjectLoader;

package/dist/components/Rain.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import type { RainSettings } from '../../../core/src/types/environment';
+export interface RainProps {
+    settings: RainSettings;
+}
+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.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAqC,MAAM,OAAO,CAAC;AAI1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qCAAqC,CAAC;AAKxE,MAAM,WAAW,SAAS;IACxB,QAAQ,EAAE,YAAY,CAAC;CACxB;AAED,QAAA,MAAM,IAAI,EAAE,KAAK,CAAC,EAAE,CAAC,SAAS,CA2I7B,CAAC;AAEF,eAAe,IAAI,CAAC"}

package/dist/components/Rain.js

@@ -0,0 +1,133 @@
+import { useEffect, useRef, useMemo } from 'react';
+import * as THREE from 'three';
+import { useThree, useFrame } from '@react-three/fiber';
+import { RainMaterial } from '../shaders/RainMaterial';
+const MAX_PARTICLES = 20000;
+const DEG_TO_RAD = Math.PI / 180;
+const Rain = ({ settings }) => {
+    const { scene } = useThree();
+    const materialRef = useRef(null);
+    const geometryRef = useRef(null);
+    const pointsRef = useRef(null);
+    const velocitiesRef = useRef(null);
+    const particleCount = useMemo(() => {
+        const density = settings.density ?? 100;
+        return Math.min(Math.max(Math.round(density * 100), 100), MAX_PARTICLES);
+    }, [settings.density]);
+    useEffect(() => {
+        const areaSize = settings.areaSize ?? 200;
+        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(settings.color || '#ffffff');
+        material.uniforms.opacity.value = settings.opacity ?? 0.5;
+        material.uniforms.streakLength.value = Math.max((settings.size ?? 0.1) * 30, 1.0);
+        const points = new THREE.Points(geometry, material);
+        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 (settings.visible)
+            scene.add(points);
+        return () => {
+            if (pointsRef.current)
+                scene.remove(pointsRef.current);
+            geometry.dispose();
+            material.dispose();
+        };
+    }, [particleCount, settings.areaSize]); // eslint-disable-line react-hooks/exhaustive-deps
+    useEffect(() => {
+        if (!pointsRef.current)
+            return;
+        if (settings.visible) {
+            if (!pointsRef.current.parent)
+                scene.add(pointsRef.current);
+        }
+        else {
+            scene.remove(pointsRef.current);
+        }
+    }, [settings.visible, scene]);
+    useEffect(() => {
+        if (!materialRef.current)
+            return;
+        const u = materialRef.current.uniforms;
+        u.uColor.value.set(settings.color || '#ffffff');
+        u.opacity.value = settings.opacity ?? 0.5;
+        u.streakLength.value = Math.max((settings.size ?? 0.1) * 30, 1.0);
+    }, [settings.color, settings.size, settings.opacity]);
+    useEffect(() => {
+        if (!materialRef.current)
+            return;
+        const u = materialRef.current.uniforms;
+        u.windAngle.value = (settings.windDirection ?? 0) * DEG_TO_RAD;
+        u.windTilt.value = settings.windStrength ?? 0;
+    }, [settings.windDirection, settings.windStrength]);
+    useFrame((_, delta) => {
+        if (!geometryRef.current || !settings.visible || !velocitiesRef.current)
+            return;
+        const posAttr = geometryRef.current.attributes.position;
+        const positions = posAttr.array;
+        const velocities = velocitiesRef.current;
+        const speed = (settings.speed ?? 1) * 60;
+        const windStrength = (settings.windStrength ?? 0) * 30;
+        const windAngle = (settings.windDirection ?? 0) * DEG_TO_RAD;
+        const windX = Math.sin(windAngle) * windStrength;
+        const windZ = Math.cos(windAngle) * windStrength;
+        const turbulence = settings.turbulence ?? 0;
+        const areaSize = settings.areaSize ?? 200;
+        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 = turbulence > 0 ? (Math.random() - 0.5) * turbulence * 10 * dt : 0;
+            const turbZ = turbulence > 0 ? (Math.random() - 0.5) * turbulence * 10 * dt : 0;
+            positions[i3] += (windX * v + turbX) * dt;
+            positions[i3 + 1] -= speed * 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/SceneBuilder.d.ts

@@ -0,0 +1,5 @@
+import React from "react";
+import type { SceneBuilderProps } from "@ntalmagor/3drize-core";
+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":"AAAA,OAAO,KAA8B,MAAM,OAAO,CAAC;AAKnD,OAAO,KAAK,EAAa,iBAAiB,EAAe,MAAM,wBAAwB,CAAC;AAQxF,QAAA,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC,iBAAiB,CAuK7C,CAAC;AAEF,eAAe,YAAY,CAAC"}

package/dist/components/SceneBuilder.js

@@ -0,0 +1,104 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import { Canvas } from "@react-three/fiber";
+// import type { SceneBuilderProps } from "~/types/types";
+import useMeshController from "../hooks/useMeshController";
+import { loadAssets } from "@ntalmagor/3drize-core";
+import { NoToneMapping } from "three";
+import ProductionScene from "./ProductionScene";
+// import UiController from "./UiController";
+// import type { HtmlElement } from "~/types/uiController";
+const SceneBuilder = ({ project, width = "100%", height = "100vh", style = {}, className = '', onSceneInitialized, onUiElementClick, }) => {
+    const sceneSettings = (project.sceneSettingsData || {});
+    const meshController = useMeshController();
+    const [isThreeJsMounted, setIsThreeJsMounted] = useState(false);
+    const environment = (project.environments && project.environments.length > 0
+        ? project.environments[0]
+        : (sceneSettings.environment || {}));
+    const camera = (project.camera || sceneSettings.camera || {});
+    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 || {};
+    const timeSettings = sceneSettings.timeSettings || sceneSettings.scene?.timeSettings || {};
+    const controls = camera.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 { shadows, antialias, dpr, gl, backgroundColor, } = 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 = modelObjects.map((obj) => {
+                    return {
+                        id: obj.id,
+                        ...obj.userData,
+                    };
+                });
+                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);
+                if (onSceneInitialized) {
+                    onSceneInitialized();
+                }
+            }, children: _jsx(ProductionScene, { device: "desktop", onObjectsReady: undefined, gridSettings: environment.grid, hdr: environment.hdr, physicsSettings: physicsSettings, generalObjectSettings: generalObjectSettings, ocean: environment.ocean, cameraSettings: camera, selectedLight: null, objects: sceneObjects, lighting: project.lights || [], controls: controls, geometry: project.settings?.materialCreator?.geometry || null, structure: project.settings?.structure || null, isPathMode: false, editingPath: null, sky: environment.sky, timeSettings: timeSettings, starsSettings: environment.stars, clouds: environment.clouds, rainSettings: environment.rain, fogSettings: environment.fog }) }) }));
+};
+export default SceneBuilder;

package/dist/components/SceneFog.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import type { FogSettings } from '../../../core/src/types/environment';
+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.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAoB,MAAM,OAAO,CAAC;AAGzC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qCAAqC,CAAC;AAEvE,MAAM,WAAW,aAAa;IAC5B,GAAG,EAAE,WAAW,CAAC;CAClB;AAED,QAAA,MAAM,QAAQ,EAAE,KAAK,CAAC,EAAE,CAAC,aAAa,CAerC,CAAC;AAEF,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/ShootingStar.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+export interface ShootingStarProps {
+    position?: [number, number, number];
+    direction?: [number, number, number];
+    speed?: number;
+    color?: string;
+    trailLength?: number;
+    size?: number;
+    opacity?: number;
+    onComplete?: () => void;
+    maxDistance?: number;
+    followMouse?: boolean;
+}
+declare const ShootingStar: React.FC<ShootingStarProps>;
+export default ShootingStar;
+//# sourceMappingURL=ShootingStar.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ShootingStar.d.ts","sourceRoot":"","sources":["../../src/components/ShootingStar.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAqC,MAAM,OAAO,CAAC;AAK1D,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,IAAI,CAAC;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED,QAAA,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC,iBAAiB,CA2I7C,CAAC;AAEF,eAAe,YAAY,CAAC"}

package/dist/components/ShootingStar.js

@@ -0,0 +1,92 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useRef, useMemo, useEffect } from 'react';
+import { useFrame } from '@react-three/fiber';
+import { Vector3, BufferGeometry, BufferAttribute, AdditiveBlending, Color } from 'three';
+import { ShootingStarMaterial } from '../shaders/ShootingStarMaterial';
+const ShootingStar = ({ position = [0, 0, 0], direction = [1, -1, 0], speed = 0.05, color = '#ffffff', trailLength = 30, size = 0.1, opacity = 1.0, onComplete, maxDistance = 50, followMouse = true, }) => {
+    const starRef = useRef(null);
+    const glowRef = useRef(null);
+    const trailRef = useRef(null);
+    const materialRef = useRef(null);
+    const starMaterialRef = useRef(null);
+    const glowMaterialRef = useRef(null);
+    const trailPositions = useRef([]);
+    const currentPosition = useRef(new Vector3(...position));
+    const directionVector = useRef(new Vector3(...direction).normalize());
+    const distanceTraveled = useRef(0);
+    const fadeInDistance = maxDistance * 0.15;
+    const fadeOutDistance = maxDistance * 0.15;
+    useEffect(() => {
+        const validTrailLength = Math.max(2, trailLength);
+        trailPositions.current = Array(validTrailLength).fill(null).map(() => currentPosition.current.clone());
+        currentPosition.current.set(...position);
+        directionVector.current.set(...direction).normalize();
+        distanceTraveled.current = 0;
+        if (starRef.current)
+            starRef.current.position.set(...position);
+    }, [trailLength, position, direction]);
+    const trailGeometry = useMemo(() => {
+        const validTrailLength = Math.max(2, trailLength);
+        const geometry = new BufferGeometry();
+        const positions = new Float32Array(validTrailLength * 3);
+        const progress = new Float32Array(validTrailLength);
+        const indices = [];
+        for (let i = 0; i < validTrailLength - 1; i++)
+            indices.push(i, i + 1);
+        for (let i = 0; i < validTrailLength; i++) {
+            positions[i * 3] = position[0];
+            positions[i * 3 + 1] = position[1];
+            positions[i * 3 + 2] = position[2];
+            progress[i] = i / (validTrailLength - 1);
+        }
+        geometry.setAttribute('position', new BufferAttribute(positions, 3));
+        geometry.setAttribute('progress', new BufferAttribute(progress, 1));
+        geometry.setIndex(indices);
+        return geometry;
+    }, [trailLength, position]);
+    useEffect(() => {
+        return () => {
+            trailGeometry.dispose();
+            materialRef.current?.dispose();
+            starMaterialRef.current?.dispose();
+            glowMaterialRef.current?.dispose();
+        };
+    }, [trailGeometry]);
+    useFrame((state, delta) => {
+        if (!trailRef.current || !starRef.current)
+            return;
+        if (followMouse) {
+            directionVector.current.set(-state.pointer.x, state.pointer.y, direction[2]).normalize();
+        }
+        const movement = directionVector.current.clone().multiplyScalar(speed);
+        currentPosition.current.add(movement);
+        distanceTraveled.current += speed;
+        let starOpacity = opacity;
+        if (distanceTraveled.current < fadeInDistance) {
+            starOpacity = opacity * (distanceTraveled.current / fadeInDistance);
+        }
+        else if (distanceTraveled.current > maxDistance - fadeOutDistance) {
+            starOpacity = opacity * ((maxDistance - distanceTraveled.current) / fadeOutDistance);
+        }
+        starRef.current.position.copy(currentPosition.current);
+        if (starMaterialRef.current)
+            starMaterialRef.current.opacity = starOpacity;
+        if (glowMaterialRef.current)
+            glowMaterialRef.current.opacity = starOpacity * 0.3;
+        if (materialRef.current)
+            materialRef.current.opacity = starOpacity;
+        trailPositions.current.unshift(currentPosition.current.clone());
+        if (trailPositions.current.length > trailLength)
+            trailPositions.current.pop();
+        const posAttr = trailGeometry.getAttribute('position');
+        for (let i = 0; i < trailPositions.current.length; i++) {
+            const pos = trailPositions.current[i];
+            posAttr.setXYZ(i, pos.x, pos.y, pos.z);
+        }
+        posAttr.needsUpdate = true;
+        if (distanceTraveled.current > maxDistance)
+            onComplete?.();
+    });
+    return (_jsxs("group", { children: [_jsx("lineSegments", { ref: trailRef, geometry: trailGeometry, children: _jsx("shootingStarMaterial", { ref: materialRef, attach: "material", transparent: true, blending: AdditiveBlending, depthWrite: false, color: new Color(color), opacity: opacity }, ShootingStarMaterial.key) }), _jsxs("mesh", { ref: starRef, children: [_jsx("sphereGeometry", { args: [size, 8, 8] }), _jsx("meshBasicMaterial", { ref: starMaterialRef, color: color, transparent: true, opacity: opacity, blending: AdditiveBlending, depthWrite: false }), _jsxs("mesh", { ref: glowRef, children: [_jsx("sphereGeometry", { args: [size * 2, 8, 8] }), _jsx("meshBasicMaterial", { ref: glowMaterialRef, color: color, transparent: true, opacity: opacity * 0.3, blending: AdditiveBlending, depthWrite: false })] })] })] }));
+};
+export default ShootingStar;

package/dist/components/ShootingStars.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import type { StarsSettings } from '@ntalmagor/3drize-core';
+export interface ShootingStarsProps {
+    settings: StarsSettings['shootingStars'];
+}
+declare const ShootingStars: React.FC<ShootingStarsProps>;
+export default ShootingStars;
+//# sourceMappingURL=ShootingStars.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ShootingStars.d.ts","sourceRoot":"","sources":["../../src/components/ShootingStars.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAmD,MAAM,OAAO,CAAC;AACxE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAI5D,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,aAAa,CAAC,eAAe,CAAC,CAAC;CAC1C;AAED,QAAA,MAAM,aAAa,EAAE,KAAK,CAAC,EAAE,CAAC,kBAAkB,CAsD/C,CAAC;AAEF,eAAe,aAAa,CAAC"}

package/dist/components/ShootingStars.js

@@ -0,0 +1,40 @@
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { useRef, useState, useEffect, useCallback } from 'react';
+import { generateShootingStar, generateShootingStars } from '@ntalmagor/3drize-core';
+import ShootingStar from './ShootingStar';
+const ShootingStars = ({ settings }) => {
+    const [shootingStars, setShootingStars] = useState(() => {
+        if (settings?.enabled)
+            return generateShootingStars(settings.count, settings);
+        return [];
+    });
+    const nextIdRef = useRef(settings?.count || 0);
+    const settingsRef = useRef(settings);
+    useEffect(() => {
+        settingsRef.current = settings;
+    }, [settings]);
+    useEffect(() => {
+        const currentCount = shootingStars.length;
+        const targetCount = settings?.count || 0;
+        if (settings?.enabled && currentCount !== targetCount) {
+            setShootingStars(generateShootingStars(targetCount, settings));
+            nextIdRef.current = targetCount;
+        }
+        else if (!settings?.enabled && currentCount > 0) {
+            setShootingStars([]);
+        }
+    }, [settings?.enabled, settings?.count]);
+    const handleComplete = useCallback((starId) => {
+        const s = settingsRef.current;
+        if (!s)
+            return;
+        setShootingStars(prev => {
+            const newStar = generateShootingStar(nextIdRef.current++, s);
+            return prev.map(star => star.id === starId ? newStar : star);
+        });
+    }, []);
+    if (!settings?.enabled)
+        return null;
+    return (_jsx(_Fragment, { children: shootingStars.map(star => (_jsx(ShootingStar, { position: star.position, direction: star.direction, speed: star.speed, color: star.color, trailLength: star.trailLength, size: 0.08, opacity: 0.9, maxDistance: star.length, onComplete: () => handleComplete(star.id), followMouse: settings.followMouse }, star.id))) }));
+};
+export default ShootingStars;

package/dist/components/SkyController.d.ts

@@ -0,0 +1,10 @@
+import type { SkySettings, TimeSettings } from '@ntalmagor/3drize-core';
+export interface SkyControllerProps {
+    settings: SkySettings;
+    timeSettings: TimeSettings;
+    scale?: number;
+    onSettingsChange?: (settings: SkySettings) => void;
+}
+declare function SkyController({ settings, timeSettings, scale, onSettingsChange, }: SkyControllerProps): import("react/jsx-runtime").JSX.Element;
+export default SkyController;
+//# sourceMappingURL=SkyController.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SkyController.d.ts","sourceRoot":"","sources":["../../src/components/SkyController.tsx"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAGxE,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,WAAW,CAAC;IACtB,YAAY,EAAE,YAAY,CAAC;IAC3B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,gBAAgB,CAAC,EAAE,CAAC,QAAQ,EAAE,WAAW,KAAK,IAAI,CAAC;CACpD;AAED,iBAAS,aAAa,CAAC,EACrB,QAAQ,EACR,YAAY,EACZ,KAAY,EACZ,gBAAgB,GACjB,EAAE,kBAAkB,2CAiJpB;AA4BD,eAAe,aAAa,CAAC"}