@ntalmagor/3drize-viewer 0.1.2

package/dist/components/Lensflare.js

@@ -0,0 +1,66 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useRef, useMemo, useCallback } from 'react';
+import * as THREE from 'three';
+import { useThree } from '@react-three/fiber';
+import { useSkySystem } from '../hooks/useSkySystem';
+export function createFlareTexture(type) {
+    const canvas = document.createElement('canvas');
+    canvas.width = 256;
+    canvas.height = 256;
+    const ctx = canvas.getContext('2d');
+    if (type === 0) {
+        const gradient = ctx.createRadialGradient(128, 128, 0, 128, 128, 128);
+        gradient.addColorStop(0, 'rgba(255, 255, 255, 1)');
+        gradient.addColorStop(0.1, 'rgba(255, 250, 240, 0.9)');
+        gradient.addColorStop(0.25, 'rgba(255, 229, 176, 0.6)');
+        gradient.addColorStop(0.5, 'rgba(255, 229, 176, 0.2)');
+        gradient.addColorStop(1, 'rgba(255, 229, 176, 0)');
+        ctx.fillStyle = gradient;
+        ctx.fillRect(0, 0, 256, 256);
+    }
+    else {
+        const gradient = ctx.createRadialGradient(128, 128, 0, 128, 128, 128);
+        gradient.addColorStop(0, 'rgba(255, 229, 176, 0.6)');
+        gradient.addColorStop(0.3, 'rgba(255, 229, 176, 0.3)');
+        gradient.addColorStop(0.6, 'rgba(255, 229, 176, 0.1)');
+        gradient.addColorStop(1, 'rgba(255, 229, 176, 0)');
+        ctx.fillStyle = gradient;
+        ctx.fillRect(0, 0, 256, 256);
+    }
+    const texture = new THREE.CanvasTexture(canvas);
+    texture.minFilter = THREE.LinearFilter;
+    texture.magFilter = THREE.LinearFilter;
+    return texture;
+}
+const Lensflare = ({ visible = true, intensity = 1, timeSettings, }) => {
+    const spriteRef = useRef(null);
+    const { camera } = useThree();
+    const texture = useMemo(() => createFlareTexture(0), []);
+    const material = useMemo(() => new THREE.SpriteMaterial({
+        map: texture,
+        transparent: true,
+        blending: THREE.AdditiveBlending,
+        depthWrite: false,
+        depthTest: false,
+    }), [texture]);
+    const handleTimeUpdate = useCallback((state) => {
+        const { sunDirection } = state;
+        if (spriteRef.current) {
+            const distance = Math.min(camera.far * 0.5, 200);
+            spriteRef.current.position.copy(camera.position);
+            spriteRef.current.position.addScaledVector(sunDirection, distance);
+            const flareScale = 5 * intensity;
+            spriteRef.current.scale.setScalar(flareScale);
+            material.opacity = sunDirection.y > 0 ? Math.min(sunDirection.y * 2, 1) : 0;
+        }
+    }, [camera, intensity, material]);
+    useSkySystem({
+        timeSettings,
+        onTimeUpdate: handleTimeUpdate,
+        enabled: visible,
+    });
+    if (!visible)
+        return null;
+    return (_jsx("sprite", { ref: spriteRef, material: material, renderOrder: Infinity }));
+};
+export default Lensflare;

package/dist/components/Letter.d.ts

@@ -0,0 +1,20 @@
+import { Object3D } from 'three';
+import type { HoverSettings, Vector3Array } from '@ntalmagor/3drize-core';
+import type { TransformEffect, MaterialSettings, ColorEffect, TextConfig } from '@ntalmagor/3drize-core';
+export interface LetterData {
+    char: string;
+    position: Vector3Array;
+    index: number;
+}
+export interface LetterProps {
+    letterData: LetterData;
+    config: TextConfig;
+    materialSettings: MaterialSettings;
+    hoverSettings: HoverSettings;
+    transformEffects?: TransformEffect[];
+    colorEffects?: ColorEffect[];
+    isActive: boolean;
+    onClick?: (object: Object3D) => void;
+}
+export default function Letter({ letterData, config, materialSettings, hoverSettings, transformEffects, colorEffects, isActive, onClick, }: LetterProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=Letter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Letter.d.ts","sourceRoot":"","sources":["../../src/components/Letter.tsx"],"names":[],"mappings":"AAGA,OAAO,EAAe,QAAQ,EAAE,MAAM,OAAO,CAAC;AAE9C,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAC1E,OAAO,KAAK,EAAE,eAAe,EAAC,gBAAgB,EAAe,WAAW,EAAE,UAAU,EAA8B,MAAM,wBAAwB,CAAC;AAMjJ,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,YAAY,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,WAAW;IAC1B,UAAU,EAAE,UAAU,CAAC;IACvB,MAAM,EAAE,UAAU,CAAC;IACnB,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,aAAa,EAAE,aAAa,CAAC;IAC7B,gBAAgB,CAAC,EAAE,eAAe,EAAE,CAAC;IACrC,YAAY,CAAC,EAAE,WAAW,EAAE,CAAC;IAC7B,QAAQ,EAAE,OAAO,CAAC;IAClB,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,QAAQ,KAAK,IAAI,CAAC;CACtC;AA8BD,MAAM,CAAC,OAAO,UAAU,MAAM,CAAC,EAC7B,UAAU,EACV,MAAM,EACN,gBAAgB,EAChB,aAAa,EACb,gBAAqB,EACrB,YAAiB,EACjB,QAAQ,EACR,OAAO,GACR,EAAE,WAAW,2CA6Gb"}

package/dist/components/Letter.js

@@ -0,0 +1,83 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useRef, useState, useEffect } from 'react';
+import { useFrame } from '@react-three/fiber';
+import { useCursor, Text, Text3D, Center } from '@react-three/drei';
+import MaterialLibrary from './MaterialLibrary';
+import { createDefaultEffectState, applyTransformEffects } from '@ntalmagor/3drize-core';
+import { useFrameEffects } from '../hooks/useFrameEffects';
+import { fontManager } from '../../../core/src/services/FontManager';
+const getText3DConfig = (config) => {
+    const c = config;
+    return {
+        size: c.size ?? 1,
+        height: c.height ?? 0.2,
+        curveSegments: c.curveSegments ?? 12,
+        bevelEnabled: c.bevelEnabled ?? true,
+        bevelThickness: c.bevelThickness ?? 0.03,
+        bevelSize: c.bevelSize ?? 0.02,
+        bevelOffset: c.bevelOffset ?? 0,
+        bevelSegments: c.bevelSegments ?? 5,
+        letterSpacing: c.letterSpacing ?? 0,
+    };
+};
+const getText2DConfig = (config) => {
+    const c = config;
+    return {
+        fontSize: c.fontSize ?? 1,
+        maxWidth: c.maxWidth ?? Infinity,
+        lineHeight: c.lineHeight ?? 1,
+        letterSpacing: c.letterSpacing ?? 0,
+        textAlign: c.textAlign ?? 'center',
+        anchorX: c.anchorX ?? 'center',
+        anchorY: c.anchorY ?? 'middle',
+    };
+};
+export default function Letter({ letterData, config, materialSettings, hoverSettings, transformEffects = [], colorEffects = [], isActive, onClick, }) {
+    const groupRef = useRef(null);
+    const letterRef = useRef(null);
+    const hitboxRef = useRef(null);
+    const effectStateRef = useRef(null);
+    const [rnd] = useState(() => Math.random());
+    const [clicked, setClicked] = useState(false);
+    const { handlePointerEnter, handlePointerLeave, hovered } = useFrameEffects(isActive);
+    const { renderMode = 'bitmap', font } = config;
+    const text3DConfig = getText3DConfig(config);
+    const text2DConfig = getText2DConfig(config);
+    const { sensitivity = 0.5, applyToChildren = false } = hoverSettings;
+    const color = 'color' in materialSettings ? materialSettings.color : '#ffffff';
+    const opacity = 'opacity' in materialSettings ? materialSettings.opacity : 1;
+    const useDreiMaterials = materialSettings.materialType === 'advanced';
+    useEffect(() => {
+        if (useDreiMaterials && renderMode === 'bitmap') {
+            console.warn('[Letter] Advanced materials not supported with bitmap text. Switch to text3d render mode.');
+        }
+    }, [useDreiMaterials, renderMode]);
+    useCursor(hovered);
+    const fontInfo = font ? fontManager.getFont(font) : null;
+    const bitmapFontUrl = fontInfo?.googleFont;
+    const text3dFontUrl = fontInfo?.threejsFont;
+    const enabledEffects = transformEffects.filter(e => e.enabled !== false);
+    useFrame((state, dt) => {
+        if (!groupRef.current || !letterRef.current || !applyToChildren)
+            return;
+        const time = state.clock.elapsedTime;
+        if (!effectStateRef.current) {
+            effectStateRef.current = createDefaultEffectState(letterRef.current);
+        }
+        if (enabledEffects.length > 0) {
+            applyTransformEffects(letterRef.current, enabledEffects, time, dt, effectStateRef.current, hovered, clicked, sensitivity);
+        }
+    });
+    const handleClick = (e) => {
+        e.stopPropagation();
+        setClicked(!clicked);
+        if (groupRef.current)
+            onClick?.(groupRef.current);
+    };
+    const actualRenderMode = renderMode === 'text3d' && !font ? 'bitmap' : renderMode;
+    const fontSize = actualRenderMode === 'text3d' ? text3DConfig.size : text2DConfig.fontSize;
+    const boxWidth = fontSize * 0.8;
+    const boxHeight = fontSize * 1.2;
+    const boxDepth = actualRenderMode === 'text3d' ? text3DConfig.height + text3DConfig.bevelThickness * 2 : text3DConfig.height + 1;
+    return (_jsxs("group", { position: letterData.position, rotation: [0, 0, 0], ref: groupRef, name: `letter-${letterData.char}-${letterData.index}`, userData: { char: letterData.char, index: letterData.index, position: letterData.position }, children: [_jsx("mesh", { ref: hitboxRef, visible: false, onPointerEnter: handlePointerEnter, onPointerLeave: handlePointerLeave, onClick: handleClick, children: _jsx("boxGeometry", { args: [boxWidth, boxHeight, boxDepth] }) }), _jsx("group", { ref: letterRef, raycast: () => null, children: actualRenderMode === 'text3d' ? (_jsx(Center, { disableX: text2DConfig.anchorX === 'left', disableY: text2DConfig.anchorY === 'top', disableZ: false, children: _jsxs(Text3D, { font: text3dFontUrl || 'https://threejs.org/examples/fonts/helvetiker_regular.typeface.json', size: text3DConfig.size, height: text3DConfig.height, curveSegments: text3DConfig.curveSegments, bevelEnabled: text3DConfig.bevelEnabled, bevelThickness: text3DConfig.bevelThickness, bevelSize: text3DConfig.bevelSize, bevelOffset: text3DConfig.bevelOffset, bevelSegments: text3DConfig.bevelSegments, children: [letterData.char, useDreiMaterials && actualRenderMode === 'text3d' ? (_jsx(MaterialLibrary, { materialSettings: materialSettings })) : (_jsx("meshStandardMaterial", { color: color, transparent: opacity < 1, opacity: opacity }))] }) })) : (_jsx(Text, { fontSize: text2DConfig.fontSize, color: color, maxWidth: text2DConfig.maxWidth, lineHeight: text2DConfig.lineHeight, letterSpacing: text2DConfig.letterSpacing, textAlign: text2DConfig.textAlign, anchorX: text2DConfig.anchorX, anchorY: text2DConfig.anchorY, font: bitmapFontUrl || undefined, fillOpacity: opacity, children: letterData.char })) })] }));
+}

package/dist/components/Letters.d.ts

@@ -0,0 +1,16 @@
+import type { LetterData } from './Letter';
+import type { HoverSettings } from '@ntalmagor/3drize-core';
+import type { TextConfig } from '@ntalmagor/3drize-core';
+import type { MaterialSettings } from '@ntalmagor/3drize-core';
+import type { ColorEffect, TransformEffect } from '@ntalmagor/3drize-core';
+export interface LettersProps {
+    text: string;
+    config: TextConfig;
+    materialSettings: MaterialSettings;
+    hoverSettings: HoverSettings;
+    transformEffects?: TransformEffect[];
+    colorEffects?: ColorEffect[];
+    onLetterClick?: (letterData: LetterData) => void;
+}
+export default function Letters({ text, config, materialSettings, hoverSettings, transformEffects, colorEffects, onLetterClick, }: LettersProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=Letters.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Letters.d.ts","sourceRoot":"","sources":["../../src/components/Letters.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAC3C,OAAO,KAAK,EAAE,aAAa,EAAgB,MAAM,wBAAwB,CAAC;AAC1E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACzD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,KAAK,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAE3E,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,UAAU,CAAC;IACnB,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,aAAa,EAAE,aAAa,CAAC;IAC7B,gBAAgB,CAAC,EAAE,eAAe,EAAE,CAAC;IACrC,YAAY,CAAC,EAAE,WAAW,EAAE,CAAC;IAC7B,aAAa,CAAC,EAAE,CAAC,UAAU,EAAE,UAAU,KAAK,IAAI,CAAC;CAClD;AAED,MAAM,CAAC,OAAO,UAAU,OAAO,CAAC,EAC9B,IAAI,EACJ,MAAM,EACN,gBAAgB,EAChB,aAAa,EACb,gBAAqB,EACrB,YAAiB,EACjB,aAAa,GACd,EAAE,YAAY,2CAkCd"}

package/dist/components/Letters.js

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

package/dist/components/LightsManager.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { LightConfig } from '@ntalmagor/3drize-core';
+export interface LightsManagerProps {
+    lights: LightConfig[];
+    selectedLight?: string | null;
+}
+declare const LightsManager: React.FC<LightsManagerProps>;
+export default LightsManager;
+//# sourceMappingURL=LightsManager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"LightsManager.d.ts","sourceRoot":"","sources":["../../src/components/LightsManager.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAqC,MAAM,OAAO,CAAC;AAI1D,OAAO,KAAK,EAAmB,WAAW,EAAqC,MAAM,wBAAwB,CAAC;AAc9G,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,WAAW,EAAE,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B;AA6BD,QAAA,MAAM,aAAa,EAAE,KAAK,CAAC,EAAE,CAAC,kBAAkB,CAkM/C,CAAC;AAEF,eAAe,aAAa,CAAC"}

package/dist/components/LightsManager.js

@@ -0,0 +1,121 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useRef, useEffect, useMemo } from 'react';
+import { useFrame, useThree } from '@react-three/fiber';
+import { useHelper } from '@react-three/drei';
+import { createSunPosition } from '../utils/utils3d';
+import { useLightHandlers } from '../hooks/useLightHandlers';
+import { Color, DirectionalLightHelper, SpotLightHelper, PointLightHelper, } from 'three';
+const LightHelperMesh = ({ position, lightName, lightColor, hasHandlers, onEnter, onLeave, size = 0.5, }) => {
+    if (!hasHandlers)
+        return null;
+    return (_jsxs("mesh", { visible: false, position: position, onPointerEnter: (e) => { e.stopPropagation(); onEnter(lightName); }, onPointerLeave: (e) => { e.stopPropagation(); onLeave(lightName); }, children: [_jsx("sphereGeometry", { args: [size, 16, 16] }), _jsx("meshBasicMaterial", { color: lightColor, transparent: true, opacity: 0.3, depthWrite: false })] }));
+};
+const LightsManager = ({ lights, selectedLight = null }) => {
+    const { scene } = useThree();
+    const config = lights[0];
+    const debug = config.showHelpers || false;
+    const ambientLightRef = useRef(null);
+    const directionalLightRefs = useRef(new Map());
+    const spotLightRefs = useRef(new Map());
+    const spotLightTargets = useRef(new Map());
+    const pointLightRefs = useRef(new Map());
+    const sunLightRef = useRef(null);
+    const allLightConfigs = useMemo(() => {
+        const configs = [];
+        if (config.directionalLights)
+            configs.push(...config.directionalLights);
+        if (config.spotLights)
+            configs.push(...config.spotLights);
+        if (config.pointLights)
+            configs.push(...config.pointLights);
+        return configs;
+    }, [config.directionalLights, config.spotLights, config.pointLights]);
+    const { handleLightEnter, handleLightLeave } = useLightHandlers({ directionalLightRefs, spotLightRefs, pointLightRefs }, allLightConfigs);
+    useEffect(() => {
+        if (!config.directionalLights)
+            return;
+        config.directionalLights.forEach((dc) => {
+            const light = directionalLightRefs.current.get(dc.name);
+            if (!light)
+                return;
+            light.color = new Color(dc.color || '#ffffff');
+            light.intensity = dc.intensity || 1;
+            light.position.set(dc.position?.[0] ?? 0, dc.position?.[1] ?? 10, dc.position?.[2] ?? 0);
+        });
+    }, [config.directionalLights]);
+    useEffect(() => {
+        if (ambientLightRef.current && config.ambient?.color) {
+            ambientLightRef.current.color = new Color(config.ambient.color);
+            ambientLightRef.current.intensity = config.ambient.intensity || 1;
+        }
+    }, [config.ambient]);
+    useEffect(() => {
+        if (!config.spotLights)
+            return;
+        config.spotLights.forEach((sc) => {
+            const light = spotLightRefs.current.get(sc.name);
+            if (!light)
+                return;
+            light.color = new Color(sc.color || '#ffffff');
+            light.intensity = sc.intensity || 1;
+            light.position.set(sc.position?.[0] ?? 0, sc.position?.[1] ?? 10, sc.position?.[2] ?? 0);
+            light.angle = sc.angle || Math.PI / 3;
+            light.penumbra = sc.penumbra || 0;
+            light.decay = sc.decay || 1;
+            light.distance = sc.distance || 0;
+            if (sc.targetPosition) {
+                light.target.position.set(sc.targetPosition[0], sc.targetPosition[1], sc.targetPosition[2]);
+                light.target.updateMatrixWorld();
+            }
+        });
+    }, [config.spotLights, config.enableShadows]);
+    useEffect(() => {
+        if (!config.pointLights)
+            return;
+        config.pointLights.forEach((pc) => {
+            const light = pointLightRefs.current.get(pc.name);
+            if (!light)
+                return;
+            light.color = new Color(pc.color || '#ffffff');
+            light.intensity = pc.intensity || 1;
+            light.position.set(pc.position?.[0] ?? 0, pc.position?.[1] ?? 10, pc.position?.[2] ?? 0);
+            light.decay = pc.decay || 1;
+            light.distance = pc.distance || 0;
+        });
+    }, [config.pointLights, config.enableShadows]);
+    useFrame((state) => {
+        if (config.followSun && sunLightRef.current) {
+            const time = state.clock.getElapsedTime();
+            const sunPosition = createSunPosition(config.sun?.elevation ?? 45, (config.sun?.azimuth ?? -90) + time * 0.01);
+            sunLightRef.current.position.set(sunPosition.x * 100, sunPosition.y * 100, sunPosition.z * 100);
+        }
+    });
+    useHelper(debug && selectedLight === 'sun' ? sunLightRef : null, DirectionalLightHelper, 5, 'orange');
+    const hasHandlers = (lightConfig) => !!lightConfig.handlers && (!!lightConfig.handlers.onMouseMove?.enabled ||
+        !!lightConfig.handlers.onMouseEnter?.enabled ||
+        !!lightConfig.handlers.onMouseLeave?.enabled);
+    return (_jsxs(_Fragment, { children: [_jsx("ambientLight", { ref: ambientLightRef, color: config.ambient?.color, intensity: config.ambient?.intensity }), config.enabled && (_jsxs(_Fragment, { children: [config.directionalLights?.map((dc) => dc.enabled !== false ? (_jsxs("group", { children: [_jsx("directionalLight", { color: dc.color || '#ffffff', intensity: dc.intensity || 1, position: dc.position || [0, 10, 0], castShadow: true, ref: (ref) => { if (ref)
+                                    directionalLightRefs.current.set(dc.name, ref); } }), _jsx(LightHelperMesh, { position: dc.position || [0, 10, 0], lightName: dc.name, lightColor: dc.color || '#ffffff', hasHandlers: hasHandlers(dc), onEnter: handleLightEnter, onLeave: handleLightLeave, size: 1 })] }, dc.name)) : null), config.spotLights?.map((sc) => sc.enabled !== false ? (_jsxs("group", { children: [_jsx("spotLight", { ref: (ref) => {
+                                    if (ref) {
+                                        spotLightRefs.current.set(sc.name, ref);
+                                        if (!spotLightTargets.current.has(sc.name)) {
+                                            scene.add(ref.target);
+                                            spotLightTargets.current.set(sc.name, ref.target);
+                                        }
+                                        if (sc.targetPosition) {
+                                            ref.target.position.set(sc.targetPosition[0], sc.targetPosition[1], sc.targetPosition[2]);
+                                            ref.target.updateMatrixWorld();
+                                        }
+                                    }
+                                    else {
+                                        const target = spotLightTargets.current.get(sc.name);
+                                        if (target) {
+                                            scene.remove(target);
+                                            spotLightTargets.current.delete(sc.name);
+                                        }
+                                        spotLightRefs.current.delete(sc.name);
+                                    }
+                                }, color: sc.color || '#ffffff', intensity: sc.intensity || 1, position: sc.position || [0, 10, 0], angle: sc.angle || Math.PI / 3, penumbra: sc.penumbra || 0, decay: sc.decay || 1, distance: sc.distance || 0, castShadow: config.enableShadows }), _jsx(LightHelperMesh, { position: sc.position || [0, 10, 0], lightName: sc.name, lightColor: sc.color || '#ffffff', hasHandlers: hasHandlers(sc), onEnter: handleLightEnter, onLeave: handleLightLeave, size: 0.8 })] }, sc.name)) : null), config.pointLights?.map((pc) => pc.enabled !== false ? (_jsxs("group", { children: [_jsx("pointLight", { ref: (ref) => { if (ref)
+                                    pointLightRefs.current.set(pc.name, ref); }, color: pc.color || '#ffffff', intensity: pc.intensity || 1, position: pc.position || [0, 10, 0], decay: pc.decay || 1, distance: pc.distance || 0, castShadow: config.enableShadows }), _jsx(LightHelperMesh, { position: pc.position || [0, 10, 0], lightName: pc.name, lightColor: pc.color || '#ffffff', hasHandlers: hasHandlers(pc), onEnter: handleLightEnter, onLeave: handleLightLeave, size: 0.6 })] }, pc.name)) : null)] })), debug && selectedLight && (_jsxs(_Fragment, { children: [config.directionalLights?.map((lc) => lc.enabled !== false && selectedLight === lc.name && directionalLightRefs.current.get(lc.name) ? (_jsx("primitive", { object: new DirectionalLightHelper(directionalLightRefs.current.get(lc.name), 3, 'red') }, `helper-${lc.name}`)) : null), config.spotLights?.map((lc) => lc.enabled !== false && selectedLight === lc.name && spotLightRefs.current.get(lc.name) ? (_jsx("primitive", { object: new SpotLightHelper(spotLightRefs.current.get(lc.name), 'yellow') }, `helper-${lc.name}`)) : null), config.pointLights?.map((lc) => lc.enabled !== false && selectedLight === lc.name && pointLightRefs.current.get(lc.name) ? (_jsx("primitive", { object: new PointLightHelper(pointLightRefs.current.get(lc.name), 1, 'blue') }, `helper-${lc.name}`)) : null)] }))] }));
+};
+export default LightsManager;

package/dist/components/Lines.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"Lines.d.ts","sourceRoot":"","sources":["../../src/components/Lines.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAkB,MAAM,OAAO,CAAC;AAGvC,OAAO,KAAK,EAAE,iBAAiB,EAAiB,MAAM,wBAAwB,CAAC;AAE/E,UAAU,UAAU;IAClB,aAAa,EAAE,iBAAiB,CAAC;IACjC,kBAAkB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAC1C;AAED,QAAA,MAAM,KAAK,EAAE,KAAK,CAAC,EAAE,CAAC,UAAU,CA4B/B,CAAC;AAEF,eAAe,KAAK,CAAC"}

package/dist/components/Lines.js

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

package/dist/components/LoadingIndicator.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"LoadingIndicator.d.ts","sourceRoot":"","sources":["../../src/components/LoadingIndicator.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAoB,MAAM,OAAO,CAAC;AAEzC,MAAM,WAAW,qBAAqB;IACpC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AA4ID,eAAO,MAAM,gBAAgB,EAAE,KAAK,CAAC,EAAE,CAAC,qBAAqB,CAuB5D,CAAC;AAEF,eAAe,gBAAgB,CAAC"}

package/dist/components/LoadingIndicator.js

@@ -0,0 +1,143 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect } from 'react';
+const STYLE_ID = '3drise-loading-indicator-styles';
+const CSS = `
+.loading-indicator {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  position: relative;
+}
+.loading-indicator-fullscreen {
+  position: fixed;
+  top: 0;
+  left: 0;
+  width: 100vw;
+  height: 100vh;
+  background-color: rgba(0, 0, 0, 0.75);
+  backdrop-filter: blur(4px);
+  z-index: 9999;
+  margin: 0;
+  padding: 0;
+}
+.loading-indicator.animate .loading-spinner {
+  animation: _3drise-spin 2s linear infinite;
+}
+.loading-indicator.animate .spinner-ring {
+  animation: _3drise-spinY 2s cubic-bezier(0.68, -0.55, 0.265, 1.55) infinite;
+}
+.loading-indicator.animate .spinner-ring:nth-child(1) {
+  animation-duration: 2s;
+}
+.loading-indicator.animate .spinner-ring:nth-child(2) {
+  animation-duration: 2.5s;
+  animation-direction: reverse;
+}
+.loading-indicator.animate .spinner-ring:nth-child(3) {
+  animation-duration: 3s;
+}
+.loading-indicator.animate .loading-text {
+  animation: _3drise-shimmer 3s linear infinite;
+}
+.loading-spinner {
+  position: relative;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  perspective: 1000px;
+  transform-style: preserve-3d;
+}
+.spinner-ring {
+  position: absolute;
+  width: 100%;
+  height: 100%;
+  border: 3px solid transparent;
+  transform-style: preserve-3d;
+}
+.spinner-ring:nth-child(1) {
+  border-top-color: #007bff;
+  border-right-color: #007bff;
+  width: 100%;
+  height: 100%;
+}
+.spinner-ring:nth-child(2) {
+  border-bottom-color: #17a2b8;
+  border-left-color: #17a2b8;
+  width: 70%;
+  height: 70%;
+}
+.spinner-ring:nth-child(3) {
+  border-top-color: #6f42c1;
+  border-right-color: #6f42c1;
+  width: 40%;
+  height: 40%;
+}
+@keyframes _3drise-spinY {
+  0% { transform: rotateY(0deg); }
+  100% { transform: rotateY(360deg); }
+}
+@keyframes _3drise-spin {
+  0% { transform: rotate(0deg); }
+  100% { transform: rotate(360deg); }
+}
+.loading-text {
+  font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
+  font-size: 1rem;
+  font-weight: 500;
+  letter-spacing: 0.5px;
+  text-transform: uppercase;
+  background: linear-gradient(90deg, #007bff, #17a2b8, #6f42c1, #007bff);
+  background-size: 200% auto;
+  -webkit-background-clip: text;
+  -webkit-text-fill-color: transparent;
+  background-clip: text;
+}
+@keyframes _3drise-shimmer {
+  0% { background-position: 0% center; }
+  100% { background-position: 200% center; }
+}
+@media (prefers-color-scheme: dark) {
+  .loading-text {
+    background: linear-gradient(90deg, #4dabf7, #22b8cf, #9775fa, #4dabf7);
+    background-size: 200% auto;
+    -webkit-background-clip: text;
+    -webkit-text-fill-color: transparent;
+    background-clip: text;
+  }
+  .spinner-ring:nth-child(1) {
+    border-top-color: #4dabf7;
+    border-right-color: #4dabf7;
+  }
+  .spinner-ring:nth-child(2) {
+    border-bottom-color: #22b8cf;
+    border-left-color: #22b8cf;
+  }
+  .spinner-ring:nth-child(3) {
+    border-top-color: #9775fa;
+    border-right-color: #9775fa;
+  }
+}
+@media (max-width: 576px) {
+  .loading-spinner {
+    width: 60px;
+    height: 60px;
+  }
+  .loading-text {
+    font-size: 0.875rem;
+  }
+}
+`;
+function injectStyles() {
+    if (typeof document === 'undefined' || document.getElementById(STYLE_ID))
+        return;
+    const style = document.createElement('style');
+    style.id = STYLE_ID;
+    style.textContent = CSS;
+    document.head.appendChild(style);
+}
+export const LoadingIndicator = ({ text, fullScreen = false, animate = true, size = 80, }) => {
+    useEffect(() => { injectStyles(); }, []);
+    return (_jsxs("div", { className: `loading-indicator${animate ? ' animate' : ''}${fullScreen ? ' loading-indicator-fullscreen' : ''}`, children: [_jsxs("div", { className: "loading-spinner", style: { width: `${size}px`, height: `${size}px` }, children: [_jsx("div", { className: "spinner-ring" }), _jsx("div", { className: "spinner-ring" }), _jsx("div", { className: "spinner-ring" })] }), text && _jsx("div", { className: "loading-text", children: text })] }));
+};
+export default LoadingIndicator;

package/dist/components/MaterialLibrary.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"MaterialLibrary.d.ts","sourceRoot":"","sources":["../../src/components/MaterialLibrary.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAiB,MAAM,OAAO,CAAC;AAUtC,OAAO,KAAK,EACV,gBAAgB,EAOjB,MAAM,wBAAwB,CAAC;AAGhC,MAAM,WAAW,oBAAoB;IACnC,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;CAC5B;AAED,QAAA,MAAM,eAAe,EAAE,KAAK,CAAC,EAAE,CAAC,oBAAoB,CA6DnD,CAAC;AAEF,eAAe,eAAe,CAAC"}

package/dist/components/MaterialLibrary.js

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

package/dist/components/Moon.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"Moon.d.ts","sourceRoot":"","sources":["../../src/components/Moon.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAyC,MAAM,OAAO,CAAC;AAC9D,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAG/B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAE3D,OAAO,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAK7D,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,EAAE,YAAY,CAAC;IACxB,WAAW,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACvC,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,KAAK,IAAI,CAAC;CAC1C;AAED,QAAA,MAAM,IAAI,EAAE,KAAK,CAAC,EAAE,CAAC,SAAS,CAmE7B,CAAC;AAGF,eAAe,IAAI,CAAC;AACpB,YAAY,EAAE,YAAY,EAAE,CAAC"}