@3driseai/3drise-core 1.0.1

package/dist/three/SceneBuilderV.js

@@ -0,0 +1,263 @@
+import * as THREE from 'three';
+import { OrbitControls } from 'three/addons/controls/OrbitControls.js';
+import { buildObjectTree } from '../utils/objectTreeUtils.js';
+import { LightsManagerV } from './LightsManagerV.js';
+import { EnvironmentManagerV } from './EnvironmentManagerV.js';
+import { Text3DV } from './Text3DV.js';
+import { Text2DV } from './Text2DV.js';
+import { ParticlesV } from './ParticlesV.js';
+import { PathRendererV } from './PathRendererV.js';
+import { GridHelperV } from './GridHelperV.js';
+import { createMeshByType } from '../utils/meshUtils.js';
+export class SceneBuilderV {
+    scene;
+    renderer;
+    camera;
+    controls;
+    container;
+    lightsManager = null;
+    environmentManager = null;
+    updatables = [];
+    animationId = null;
+    resizeObserver = null;
+    clock = new THREE.Clock();
+    constructor(container, project, options = {}) {
+        this.container = container;
+        const sceneSettings = (project.sceneSettingsData || {});
+        const env = (project.environments?.[0] ?? sceneSettings.environment ?? {});
+        const cam = (project.camera ?? sceneSettings.camera ?? {});
+        const sceneCanvas = sceneSettings.canvas ?? sceneSettings.scene?.canvas ?? {};
+        const generalObjSettings = (sceneSettings.generalObjectSettings ?? sceneSettings.scene?.generalObjectSettings ?? {});
+        const timeSettings = sceneSettings.timeSettings ?? sceneSettings.scene?.timeSettings ?? {};
+        const controls = cam.controls ?? {};
+        // Renderer
+        this.renderer = new THREE.WebGLRenderer({
+            antialias: sceneCanvas.antialias ?? true,
+            alpha: true,
+            powerPreference: 'high-performance',
+        });
+        this.renderer.setPixelRatio(sceneCanvas.dpr ?? window.devicePixelRatio);
+        this.renderer.setSize(container.clientWidth || 300, container.clientHeight || 300);
+        this.renderer.shadowMap.enabled = sceneCanvas.shadows ?? true;
+        this.renderer.shadowMap.type = THREE.PCFSoftShadowMap;
+        this.renderer.toneMapping = THREE.NoToneMapping;
+        if (sceneCanvas.backgroundColor) {
+            this.renderer.setClearColor(sceneCanvas.backgroundColor, 1);
+        }
+        container.style.overflow = 'hidden';
+        container.appendChild(this.renderer.domElement);
+        // Scene
+        this.scene = new THREE.Scene();
+        // Camera
+        const pos = cam.position ?? [0, 2, 8];
+        const ori = cam.orientation ?? [0, 0, 0];
+        this.camera = new THREE.PerspectiveCamera(cam.fov ?? 60, (container.clientWidth || 300) / (container.clientHeight || 300), cam.near ?? 0.1, cam.far ?? 1000);
+        this.camera.position.set(pos[0] ?? 0, pos[1] ?? 2, pos[2] ?? 8);
+        this.camera.rotation.set(ori[0] ?? 0, ori[1] ?? 0, ori[2] ?? 0);
+        // Orbit controls
+        this.controls = new OrbitControls(this.camera, this.renderer.domElement);
+        this.controls.enabled = controls.enabled ?? true;
+        this.controls.enablePan = controls.enablePan ?? true;
+        this.controls.enableRotate = controls.enableRotate ?? true;
+        this.controls.autoRotate = controls.autoRotate ?? false;
+        this.controls.autoRotateSpeed = controls.autoRotateSpeed ?? 2;
+        this.controls.zoomSpeed = controls.zoomSpeed ?? 1;
+        this.controls.panSpeed = controls.panSpeed ?? 1;
+        this.controls.rotateSpeed = controls.rotateSpeed ?? 1;
+        this.controls.minDistance = controls.minDistance ?? 1;
+        this.controls.maxDistance = controls.maxDistance ?? 1000;
+        if (controls.target) {
+            const t = controls.target;
+            this.controls.target.set(t[0] ?? 0, t[1] ?? 0, t[2] ?? 0);
+        }
+        if (controls.minPolarAngle)
+            this.controls.minPolarAngle = controls.minPolarAngle;
+        if (controls.maxPolarAngle)
+            this.controls.maxPolarAngle = controls.maxPolarAngle;
+        if (controls.minAzimuthAngle)
+            this.controls.minAzimuthAngle = controls.minAzimuthAngle;
+        if (controls.maxAzimuthAngle)
+            this.controls.maxAzimuthAngle = controls.maxAzimuthAngle;
+        // Lights
+        if (project.lights?.length) {
+            this.lightsManager = new LightsManagerV(this.scene, project.lights[0]);
+        }
+        // Environment
+        if (env) {
+            this.environmentManager = new EnvironmentManagerV(this.scene, {
+                scene: this.scene,
+                renderer: this.renderer,
+                camera: this.camera,
+                hdrSettings: env.hdr,
+                timeSettings: timeSettings.enabled ? timeSettings : undefined,
+                sunSystemVisible: env.sky?.sunSystem?.visible ?? false,
+                sunSize: env.sky?.sunSystem?.sunSize ?? 1,
+                moonSize: env.sky?.sunSystem?.moonSize ?? 1,
+                sunIntensity: env.sky?.sunSystem?.intensity ?? 1,
+                castShadow: env.sky?.sunSystem?.castShadow,
+                shadowMapSize: env.sky?.sunSystem?.shadowMapSize,
+                starsSettings: env.stars,
+                skyControllerSettings: env.sky?.visible && !env.sky?.sunSystem?.visible ? env.sky : undefined,
+                cloudsSettings: env.clouds,
+                rainSettings: env.rain,
+                fogSettings: env.fog,
+            });
+            this.updatables.push(this.environmentManager);
+        }
+        // Objects
+        const objectsGroup = new THREE.Group();
+        objectsGroup.name = 'main-objects';
+        const ms = generalObjSettings?.meshSettings;
+        if (ms?.position)
+            objectsGroup.position.set(ms.position[0] ?? 0, ms.position[1] ?? 0, ms.position[2] ?? 0);
+        if (ms?.rotation)
+            objectsGroup.rotation.set(ms.rotation[0] ?? 0, ms.rotation[1] ?? 0, ms.rotation[2] ?? 0);
+        if (ms?.scale)
+            objectsGroup.scale.set(ms.scale[0] ?? 1, ms.scale[1] ?? 1, ms.scale[2] ?? 1);
+        this.scene.add(objectsGroup);
+        const tree = buildObjectTree(project.sceneObjects ?? []);
+        tree.forEach(node => this.buildNode(node, objectsGroup));
+        // Resize
+        this.resizeObserver = new ResizeObserver(() => this.handleResize());
+        this.resizeObserver.observe(container);
+        // Start loop
+        this.animate();
+        options.onInitialized?.();
+    }
+    buildNode(node, parent) {
+        const { createdObject, children } = node;
+        if (!createdObject)
+            return;
+        const ms = createdObject.meshSettings;
+        const group = new THREE.Group();
+        group.name = createdObject.name;
+        group.userData.id = createdObject.id;
+        group.userData.type = createdObject.type;
+        if (ms?.position)
+            group.position.set(ms.position[0] ?? 0, ms.position[1] ?? 0, ms.position[2] ?? 0);
+        if (ms?.rotation)
+            group.rotation.set(ms.rotation[0] ?? 0, ms.rotation[1] ?? 0, ms.rotation[2] ?? 0);
+        if (ms?.scale)
+            group.scale.set(ms.scale[0] ?? 1, ms.scale[1] ?? 1, ms.scale[2] ?? 1);
+        group.visible = ms?.visible ?? true;
+        parent.add(group);
+        if (createdObject.type !== 'group') {
+            this.buildObject(createdObject, group);
+        }
+        // Per-object effects — EffectsGeneratorV needs the scene as parent
+        if (createdObject.effects?.length) {
+            createdObject.effects.forEach((effect) => {
+                // const fx = new EffectsGeneratorV(this.scene, effect);
+                // this.updatables.push(fx as unknown as Updatable);
+            });
+        }
+        children.forEach((child) => this.buildNode(child, group));
+    }
+    buildObject(obj, parent) {
+        const mat = obj.materialSettings;
+        const color = mat?.color ?? '#ffffff';
+        switch (obj.type) {
+            case 'text': {
+                const textSettings = obj;
+                const config = textSettings.config;
+                if (config?.renderMode === 'text3d') {
+                    const v = new Text3DV(parent, { text: config.text ?? obj.name, config, color });
+                    this.updatables.push(v);
+                }
+                else {
+                    const v = new Text2DV(parent, { text: config?.text ?? obj.name, config, color });
+                    this.updatables.push(v);
+                }
+                break;
+            }
+            case 'particles': {
+                const p = obj;
+                const pc = p.config?.particles;
+                if (pc) {
+                    const v = new ParticlesV(parent, {
+                        shapeType: pc.shapeType ?? 'sphere',
+                        count: pc.count ?? 1000,
+                        color,
+                        pointSize: pc.size ?? 3,
+                    });
+                    this.updatables.push(v);
+                }
+                break;
+            }
+            case 'path': {
+                const pathSettings = obj;
+                const pc = pathSettings.config;
+                if (pc) {
+                    const v = new PathRendererV(parent, { pathConfig: pc, color, showLine: true, showCurve: true });
+                    this.updatables.push(v);
+                }
+                break;
+            }
+            case 'grid': {
+                new GridHelperV(parent);
+                break;
+            }
+            case 'effect': {
+                const config = obj.config;
+                // if (config) {
+                //   const v = new EffectsGeneratorV(this.scene, { enabled: true, config });
+                //   this.updatables.push(v as unknown as Updatable);
+                // }
+                break;
+            }
+            case 'gallery': {
+                // const v = new GalleryLayoutV(parent, obj as any);
+                // this.updatables.push(v as unknown as Updatable);
+                break;
+            }
+            case 'mesh':
+            case 'model':
+            case 'custom_primitive': {
+                const object = createMeshByType(obj.meshSettings);
+                const mesh = object?.mesh;
+                if (mesh) {
+                    mesh.material = new THREE.MeshStandardMaterial({
+                        color,
+                        opacity: mat?.opacity ?? 1,
+                        transparent: (mat?.opacity ?? 1) < 1,
+                    });
+                    mesh.castShadow = true;
+                    mesh.receiveShadow = true;
+                    parent.add(mesh);
+                }
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    animate() {
+        this.animationId = requestAnimationFrame(() => this.animate());
+        const delta = this.clock.getDelta();
+        const elapsed = this.clock.elapsedTime;
+        this.updatables.forEach(u => u.update(elapsed, delta));
+        this.lightsManager?.update(elapsed);
+        this.controls.update();
+        this.renderer.render(this.scene, this.camera);
+    }
+    handleResize() {
+        const w = this.container.clientWidth;
+        const h = this.container.clientHeight;
+        if (!w || !h)
+            return;
+        this.camera.aspect = w / h;
+        this.camera.updateProjectionMatrix();
+        this.renderer.setSize(w, h);
+    }
+    dispose() {
+        if (this.animationId !== null)
+            cancelAnimationFrame(this.animationId);
+        this.resizeObserver?.disconnect();
+        this.updatables.forEach(u => u.dispose());
+        this.lightsManager?.dispose();
+        this.environmentManager?.dispose();
+        this.controls.dispose();
+        this.renderer.dispose();
+        this.renderer.domElement.remove();
+    }
+}

package/dist/three/SkyControllerV.d.ts

@@ -0,0 +1,22 @@
+import * as THREE from 'three';
+import type { SkySettings } from "../types/environment";
+import type { TimeSettings } from "../types/scene3d";
+export interface SkyControllerVOptions {
+    settings: SkySettings;
+    timeSettings?: TimeSettings;
+    scale?: number;
+}
+export declare class SkyControllerV {
+    private parent;
+    private sky;
+    private sunLight;
+    private config;
+    private previousSettings;
+    constructor(parent: THREE.Object3D, options: SkyControllerVOptions);
+    private applySettings;
+    private hasChanges;
+    update(_elapsed: number, _delta?: number): void;
+    updateConfig(options: SkyControllerVOptions): void;
+    dispose(removeFromScene?: boolean): void;
+}
+//# sourceMappingURL=SkyControllerV.d.ts.map

package/dist/three/SkyControllerV.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SkyControllerV.d.ts","sourceRoot":"","sources":["../../src/three/SkyControllerV.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAI/B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACrD,MAAM,WAAW,qBAAqB;IAClC,QAAQ,EAAE,WAAW,CAAC;IACtB,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,KAAK,CAAC,EAAE,MAAM,CAAC;CAClB;AAGD,qBAAa,cAAc;IACvB,OAAO,CAAC,MAAM,CAAC;IACf,OAAO,CAAC,GAAG,CAAC;IACZ,OAAO,CAAC,QAAQ,CAAC;IACjB,OAAO,CAAC,MAAM,CAAC;IACf,OAAO,CAAC,gBAAgB,CAAQ;gBACpB,MAAM,EAAE,KAAK,CAAC,QAAQ,EAAE,OAAO,EAAE,qBAAqB;IAelE,OAAO,CAAC,aAAa;IAiBrB,OAAO,CAAC,UAAU;IAYlB,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,GAAE,MAAc,GAAG,IAAI;IAgBtD,YAAY,CAAC,OAAO,EAAE,qBAAqB,GAAG,IAAI;IAMlD,OAAO,CAAC,eAAe,GAAE,OAAc,GAAG,IAAI;CASjD"}

package/dist/three/SkyControllerV.js

@@ -0,0 +1,114 @@
+import * as THREE from 'three';
+import { Sky } from 'three/examples/jsm/objects/Sky.js';
+import { skySystemManager } from '../services/SkySystemManager.js';
+import { createSunPosition } from '../utils/sunUtils.js';
+export class SkyControllerV {
+    parent;
+    sky;
+    sunLight;
+    config;
+    previousSettings = null;
+    constructor(parent, options) {
+        this.parent = parent;
+        this.config = options;
+        this.sky = new Sky();
+        this.sky.scale.setScalar(10000);
+        this.sky.userData.id = '3drise-sky';
+        parent.add(this.sky);
+        this.sunLight = new THREE.DirectionalLight('#ffffff', 1);
+        this.sunLight.castShadow = true;
+        parent.add(this.sunLight);
+        if (options.timeSettings) {
+            skySystemManager.setTimeSettings(options.timeSettings);
+        }
+        this.applySettings(options.settings);
+    }
+    applySettings(settings) {
+        const uniforms = this.sky.material.uniforms;
+        if (!uniforms)
+            return;
+        uniforms.turbidity.value = settings.turbidity;
+        uniforms.rayleigh.value = settings.rayleigh;
+        uniforms.mieCoefficient.value = settings.mieCoefficient;
+        uniforms.mieDirectionalG.value = settings.mieDirectionalG;
+        const sunPos = createSunPosition(settings.elevation, settings.azimuth);
+        uniforms.sunPosition.value.copy(sunPos);
+        this.sky.visible = settings.visible;
+        this.sunLight.visible = settings.visible;
+        const distance = 100;
+        this.sunLight.position.set(sunPos.x * distance, sunPos.y * distance, sunPos.z * distance);
+        this.sunLight.shadow.camera.updateProjectionMatrix();
+        this.previousSettings = { ...settings };
+    }
+    hasChanges(next) {
+        const prev = this.previousSettings;
+        if (!prev)
+            return true;
+        return (next.visible !== prev.visible ||
+            Math.abs(next.turbidity - prev.turbidity) > 0.01 ||
+            Math.abs(next.rayleigh - prev.rayleigh) > 0.01 ||
+            Math.abs(next.mieCoefficient - prev.mieCoefficient) > 0.001 ||
+            Math.abs(next.mieDirectionalG - prev.mieDirectionalG) > 0.001 ||
+            Math.abs(next.elevation - prev.elevation) > 0.1 ||
+            Math.abs(next.azimuth - prev.azimuth) > 0.1);
+    }
+    update(_elapsed, _delta = 0.016) {
+        const { settings, timeSettings } = this.config;
+        if (!timeSettings?.enabled || !settings.visible)
+            return;
+        const state = skySystemManager.getState();
+        const params = calculateSkyParamsForTime(state.timeInHours);
+        const newSettings = {
+            ...settings,
+            elevation: state.sunElevation,
+            azimuth: state.sunAzimuth,
+            ...params,
+        };
+        if (this.hasChanges(newSettings)) {
+            this.applySettings(newSettings);
+        }
+    }
+    updateConfig(options) {
+        this.config = options;
+        if (options.timeSettings)
+            skySystemManager.setTimeSettings(options.timeSettings);
+        this.applySettings(options.settings);
+    }
+    dispose(removeFromScene = true) {
+        this.sky.geometry?.dispose();
+        this.sky.material?.dispose();
+        this.sunLight.shadow?.map?.dispose();
+        if (removeFromScene) {
+            this.parent.remove(this.sky);
+            this.parent.remove(this.sunLight);
+        }
+    }
+}
+// ─── Atmospheric parameter calculation ───────────────────────────────────────
+function calculateSkyParamsForTime(timeInHours) {
+    const night = { turbidity: 0.5, rayleigh: 0.1, mieCoefficient: 0.001, mieDirectionalG: 0.8 };
+    const sunrise = { turbidity: 4, rayleigh: 3, mieCoefficient: 0.01, mieDirectionalG: 0.9 };
+    const day = { turbidity: 0.7, rayleigh: 0.54, mieCoefficient: 0.005, mieDirectionalG: 0.7 };
+    const sunset = { turbidity: 4.5, rayleigh: 3.5, mieCoefficient: 0.012, mieDirectionalG: 0.92 };
+    const lerp = (a, b, t) => a + (b - a) * Math.max(0, Math.min(1, t));
+    const ss = (t) => t * t * (3 - 2 * t);
+    const lp = (f, to, t) => ({
+        turbidity: lerp(f.turbidity, to.turbidity, ss(t)),
+        rayleigh: lerp(f.rayleigh, to.rayleigh, ss(t)),
+        mieCoefficient: lerp(f.mieCoefficient, to.mieCoefficient, ss(t)),
+        mieDirectionalG: lerp(f.mieDirectionalG, to.mieDirectionalG, ss(t)),
+    });
+    if (timeInHours < 5)
+        return night;
+    if (timeInHours < 6.5)
+        return lp(night, sunrise, (timeInHours - 5) / 1.5);
+    if (timeInHours < 8)
+        return lp(sunrise, day, (timeInHours - 6.5) / 1.5);
+    if (timeInHours < 17)
+        return day;
+    if (timeInHours < 19)
+        return lp(day, sunset, (timeInHours - 17) / 2);
+    if (timeInHours < 21)
+        return lp(sunset, night, (timeInHours - 19) / 2);
+    return night;
+}

package/dist/three/SkySystemV.d.ts

@@ -0,0 +1,40 @@
+import * as THREE from 'three';
+import type { TimeSettings } from "../types/scene3d";
+import type { StarsSettings, CloudsSettings, SkySettings, RainSettings, FogSettings } from "../types/environment";
+export interface SkySystemVOptions {
+    timeSettings: TimeSettings;
+    camera: THREE.PerspectiveCamera | THREE.OrthographicCamera;
+    scene?: THREE.Scene;
+    visible?: boolean;
+    sunSystemVisible?: boolean;
+    sunSize?: number;
+    moonSize?: number;
+    skyboxScale?: number;
+    sunIntensity?: number;
+    castShadow?: boolean;
+    shadowMapSize?: number;
+    targetPosition?: [number, number, number];
+    starsSettings?: StarsSettings;
+    cloudsSettings?: CloudsSettings;
+    skyControllerSettings?: SkySettings;
+    rainSettings?: RainSettings;
+    fogSettings?: FogSettings;
+    onTimeOfDayChange?: (timeOfDay: string, elapsedTime: number) => void;
+}
+export declare class SkySystemV {
+    private parent;
+    private config;
+    private skybox;
+    private lensflare;
+    private sunLight;
+    private clouds;
+    private skyController;
+    private rain;
+    private previousTimeOfDay;
+    constructor(parent: THREE.Object3D, options: SkySystemVOptions);
+    private applyFog;
+    update(_elapsed: number, delta?: number): void;
+    updateConfig(options: SkySystemVOptions): void;
+    dispose(removeFromScene?: boolean): void;
+}
+//# sourceMappingURL=SkySystemV.d.ts.map

package/dist/three/SkySystemV.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SkySystemV.d.ts","sourceRoot":"","sources":["../../src/three/SkySystemV.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAO/B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,WAAW,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAClH,MAAM,WAAW,iBAAiB;IAC9B,YAAY,EAAE,YAAY,CAAC;IAC3B,MAAM,EAAE,KAAK,CAAC,iBAAiB,GAAG,KAAK,CAAC,kBAAkB,CAAC;IAC3D,KAAK,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC;IACpB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,cAAc,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1C,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,qBAAqB,CAAC,EAAE,WAAW,CAAC;IACpC,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,iBAAiB,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,KAAK,IAAI,CAAC;CACxE;AAGD,qBAAa,UAAU;IACnB,OAAO,CAAC,MAAM,CAAC;IACf,OAAO,CAAC,MAAM,CAAC;IACf,OAAO,CAAC,MAAM,CAAQ;IACtB,OAAO,CAAC,SAAS,CAAQ;IACzB,OAAO,CAAC,QAAQ,CAAQ;IACxB,OAAO,CAAC,MAAM,CAAQ;IACtB,OAAO,CAAC,aAAa,CAAQ;IAC7B,OAAO,CAAC,IAAI,CAAQ;IACpB,OAAO,CAAC,iBAAiB,CAAQ;gBACrB,MAAM,EAAE,KAAK,CAAC,QAAQ,EAAE,OAAO,EAAE,iBAAiB;IAwC9D,OAAO,CAAC,QAAQ;IAQhB,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,GAAE,MAAc,GAAG,IAAI;IAkBrD,YAAY,CAAC,OAAO,EAAE,iBAAiB,GAAG,IAAI;IAa9C,OAAO,CAAC,eAAe,GAAE,OAAc,GAAG,IAAI;CAMjD"}

package/dist/three/SkySystemV.js

@@ -0,0 +1,103 @@
+import * as THREE from 'three';
+import { skySystemManager } from '../services/SkySystemManager.js';
+import { SkyboxV } from './SkyboxV.js';
+import { LensflareV } from './LensflareV.js';
+import { SunLightV } from './SunLightV.js';
+import { SkyControllerV } from './SkyControllerV.js';
+import { RainV } from './RainV.js';
+export class SkySystemV {
+    parent;
+    config;
+    skybox = null;
+    lensflare = null;
+    sunLight = null;
+    clouds = null;
+    skyController = null;
+    rain = null;
+    previousTimeOfDay = null;
+    constructor(parent, options) {
+        this.parent = parent;
+        this.config = options;
+        skySystemManager.setTimeSettings(options.timeSettings);
+        if (options.visible !== false && options.sunSystemVisible) {
+            this.skybox = new SkyboxV(parent, {
+                visible: true,
+                scale: options.skyboxScale ?? 100000,
+                sunSize: options.sunSize ?? 1,
+                moonSize: options.moonSize ?? 1,
+                timeSettings: options.timeSettings,
+            });
+            this.lensflare = new LensflareV(parent, {
+                camera: options.camera,
+                visible: true,
+                intensity: options.sunIntensity ?? 1,
+                timeSettings: options.timeSettings,
+            });
+            this.sunLight = new SunLightV(parent, {
+                visible: true,
+                timeSettings: options.timeSettings,
+                targetPosition: options.targetPosition ?? [0, 0, 0],
+                intensity: options.sunIntensity ?? 1,
+                castShadow: options.castShadow ?? true,
+                shadowMapSize: options.shadowMapSize ?? 2048,
+            });
+        }
+        if (!options.sunSystemVisible && options.skyControllerSettings) {
+            this.skyController = new SkyControllerV(parent, {
+                settings: options.skyControllerSettings,
+                timeSettings: options.timeSettings,
+            });
+        }
+        if (options.rainSettings?.meshSettings?.visible) {
+            this.rain = new RainV(parent, { settings: options.rainSettings });
+        }
+        if (options.fogSettings && options.scene) {
+            this.applyFog(options.scene, options.fogSettings);
+        }
+    }
+    applyFog(scene, fogSettings) {
+        if (fogSettings.visible) {
+            scene.fog = new THREE.Fog(fogSettings.color, fogSettings.near, fogSettings.far);
+        }
+        else {
+            scene.fog = null;
+        }
+    }
+    update(_elapsed, delta = 0.016) {
+        const { timeSettings, onTimeOfDayChange } = this.config;
+        if (!timeSettings.enabled)
+            return;
+        if (timeSettings.autoAnimate) {
+            skySystemManager.tick(delta);
+            const current = skySystemManager.getTimeOfDay();
+            if (this.previousTimeOfDay !== null && this.previousTimeOfDay !== current) {
+                const state = skySystemManager.getState();
+                onTimeOfDayChange?.(current, state.elapsedTime);
+            }
+            this.previousTimeOfDay = current;
+        }
+        this.skybox?.update(_elapsed, delta);
+        this.lensflare?.update(_elapsed, delta);
+        this.sunLight?.update(_elapsed, delta);
+        this.skyController?.update(_elapsed, delta);
+    }
+    updateConfig(options) {
+        this.config = options;
+        skySystemManager.setTimeSettings(options.timeSettings);
+        this.skybox?.updateConfig({ ...options, visible: options.sunSystemVisible });
+        this.lensflare?.updateConfig({ ...options, camera: options.camera, visible: options.sunSystemVisible });
+        this.sunLight?.updateConfig({ ...options, visible: options.sunSystemVisible });
+        if (options.skyControllerSettings && this.skyController) {
+            this.skyController.updateConfig({
+                settings: options.skyControllerSettings,
+                timeSettings: options.timeSettings,
+            });
+        }
+    }
+    dispose(removeFromScene = true) {
+        this.skybox?.dispose(removeFromScene);
+        this.lensflare?.dispose(removeFromScene);
+        this.sunLight?.dispose(removeFromScene);
+        this.skyController?.dispose(removeFromScene);
+    }
+}

package/dist/three/SkyboxV.d.ts

@@ -0,0 +1,29 @@
+import * as THREE from 'three';
+import type { TimeSettings } from "../types/scene3d";
+export interface SkyboxVOptions {
+    visible?: boolean;
+    scale?: number;
+    sunSize?: number;
+    moonSize?: number;
+    timeSettings: TimeSettings;
+}
+export declare class SkyboxV {
+    private parent;
+    private mesh;
+    private material;
+    private config;
+    private sunColor;
+    private skyColorLow;
+    private skyColorHigh;
+    private targetSunColor;
+    private targetSkyColorLow;
+    private targetSkyColorHigh;
+    private static readonly vertexShader;
+    private static readonly fragmentShader;
+    constructor(parent: THREE.Object3D, options: SkyboxVOptions);
+    update(_elapsed: number, delta?: number): void;
+    private applyTimeState;
+    updateConfig(options: SkyboxVOptions): void;
+    dispose(removeFromScene?: boolean): void;
+}
+//# sourceMappingURL=SkyboxV.d.ts.map

package/dist/three/SkyboxV.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SkyboxV.d.ts","sourceRoot":"","sources":["../../src/three/SkyboxV.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACrD,MAAM,WAAW,cAAc;IAC3B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,YAAY,CAAC;CAC9B;AAiDD,qBAAa,OAAO;IAChB,OAAO,CAAC,MAAM,CAAC;IACf,OAAO,CAAC,IAAI,CAAC;IACb,OAAO,CAAC,QAAQ,CAAC;IACjB,OAAO,CAAC,MAAM,CAAC;IACf,OAAO,CAAC,QAAQ,CAA6B;IAC7C,OAAO,CAAC,WAAW,CAA6B;IAChD,OAAO,CAAC,YAAY,CAA6B;IACjD,OAAO,CAAC,cAAc,CAA6B;IACnD,OAAO,CAAC,iBAAiB,CAA6B;IACtD,OAAO,CAAC,kBAAkB,CAA6B;IACvD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,YAAY,CAQpC;IACA,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,cAAc,CAwBtC;gBACY,MAAM,EAAE,KAAK,CAAC,QAAQ,EAAE,OAAO,EAAE,cAAc;IA0B3D,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,GAAE,MAAc,GAAG,IAAI;IASrD,OAAO,CAAC,cAAc;IAiBtB,YAAY,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI;IAQ3C,OAAO,CAAC,eAAe,GAAE,OAAc,GAAG,IAAI;CAMjD"}