@3driseai/3drise-core 1.0.1

package/dist/three/FrameV.js

@@ -0,0 +1,43 @@
+import { BoxGeometry, DoubleSide, Group, Mesh, MeshBasicMaterial, MeshStandardMaterial, PlaneGeometry, TextureLoader, } from 'three';
+export class FrameV {
+    group;
+    frameMesh;
+    imageMesh;
+    url;
+    onClick;
+    constructor(scene, options) {
+        const { url, position = [0, 0, 0], rotation = [0, 0, 0], layoutSettings, frameColor = '#333333', side = DoubleSide, onLoad, onClick, } = options;
+        this.url = url;
+        this.onClick = onClick;
+        const w = (layoutSettings.width ?? 1) * (layoutSettings.outerFrameScale ?? 1);
+        const h = (layoutSettings.height ?? 1) * (layoutSettings.outerFrameScale ?? 1);
+        this.frameMesh = new Mesh(new BoxGeometry(w, h, 0.05), new MeshStandardMaterial({ color: frameColor, side }));
+        this.imageMesh = new Mesh(new PlaneGeometry(w * 0.9, h * 0.9), new MeshBasicMaterial({ transparent: true, side }));
+        this.imageMesh.position.z = 0.03;
+        this.group = new Group();
+        this.group.add(this.frameMesh, this.imageMesh);
+        this.group.position.set(...position);
+        this.group.rotation.set(...rotation);
+        scene.add(this.group);
+        new TextureLoader().load(url, (texture) => {
+            this.imageMesh.material.map = texture;
+            this.imageMesh.material.needsUpdate = true;
+            onLoad?.();
+        });
+    }
+    setPosition(position) {
+        this.group.position.set(...position);
+    }
+    setHovered(hovered) {
+        this.frameMesh.material.emissive.set(hovered ? '#444444' : '#000000');
+    }
+    dispose() {
+        this.frameMesh.geometry.dispose();
+        this.frameMesh.material.dispose();
+        this.imageMesh.geometry.dispose();
+        const mat = this.imageMesh.material;
+        mat.map?.dispose();
+        mat.dispose();
+        this.group.parent?.remove(this.group);
+    }
+}

package/dist/three/GalaxyV.d.ts

@@ -0,0 +1,21 @@
+import * as THREE from 'three';
+import type { StarsSettings } from "../types/environment";
+export interface GalaxyVOptions {
+    settings: StarsSettings;
+}
+export declare class GalaxyV {
+    private parent;
+    private starsGroup;
+    private shootingGroup;
+    private starsV;
+    private shootingItems;
+    private config;
+    private nextId;
+    constructor(parent: THREE.Object3D, options: GalaxyVOptions);
+    private initShootingStars;
+    private addShootingStar;
+    update(elapsed: number, delta?: number): void;
+    updateConfig(options: GalaxyVOptions): void;
+    dispose(removeFromScene?: boolean): void;
+}
+//# sourceMappingURL=GalaxyV.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"GalaxyV.d.ts","sourceRoot":"","sources":["../../src/three/GalaxyV.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAG/B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAC1D,MAAM,WAAW,cAAc;IAC3B,QAAQ,EAAE,aAAa,CAAC;CAC3B;AAkJD,qBAAa,OAAO;IAChB,OAAO,CAAC,MAAM,CAAC;IACf,OAAO,CAAC,UAAU,CAAC;IACnB,OAAO,CAAC,aAAa,CAAC;IACtB,OAAO,CAAC,MAAM,CAAC;IACf,OAAO,CAAC,aAAa,CAAM;IAC3B,OAAO,CAAC,MAAM,CAAC;IACf,OAAO,CAAC,MAAM,CAAK;gBACP,MAAM,EAAE,KAAK,CAAC,QAAQ,EAAE,OAAO,EAAE,cAAc;IAU3D,OAAO,CAAC,iBAAiB;IAUzB,OAAO,CAAC,eAAe;IAiBvB,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,GAAE,MAAc,GAAG,IAAI;IAQpD,YAAY,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI;IAY3C,OAAO,CAAC,eAAe,GAAE,OAAc,GAAG,IAAI;CAWjD"}

package/dist/three/GalaxyV.js

@@ -0,0 +1,223 @@
+import * as THREE from 'three';
+import { StarsV } from './StarsV.js';
+import { generateShootingStars, generateShootingStar } from '../utils/shootingStarHelpers.js';
+const shootingStarVertexShader = /*glsl*/ `
+  varying float vProgress;
+  attribute float progress;
+  void main() {
+    vProgress = progress;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+  }
+`;
+const shootingStarFragmentShader = /*glsl*/ `
+  uniform vec3 color;
+  uniform float opacity;
+  varying float vProgress;
+  void main() {
+    float alpha = opacity * (1.0 - vProgress) * (1.0 - vProgress);
+    float glow = 1.0 - vProgress;
+    vec3 glowColor = color * (1.0 + glow * 0.5);
+    gl_FragColor = vec4(glowColor, alpha);
+  }
+`;
+class ShootingStarItemV {
+    group;
+    lineSegments;
+    starMesh;
+    glowMesh;
+    trailGeometry;
+    trailMaterial;
+    starMaterial;
+    glowMaterial;
+    currentPos;
+    direction;
+    trailPositions;
+    distanceTraveled = 0;
+    speed;
+    trailLength;
+    maxDistance;
+    fadeIn;
+    fadeOut;
+    opacity;
+    onComplete;
+    done = false;
+    constructor(data, onComplete) {
+        this.speed = data.speed;
+        this.trailLength = Math.max(2, data.trailLength);
+        this.maxDistance = data.length;
+        this.fadeIn = this.maxDistance * 0.15;
+        this.fadeOut = this.maxDistance * 0.15;
+        this.opacity = 0.9;
+        this.onComplete = onComplete;
+        this.currentPos = new THREE.Vector3(...data.position);
+        this.direction = new THREE.Vector3(...data.direction).normalize();
+        this.trailPositions = Array(this.trailLength).fill(null).map(() => this.currentPos.clone());
+        this.group = new THREE.Group();
+        // Trail geometry
+        this.trailGeometry = new THREE.BufferGeometry();
+        const positions = new Float32Array(this.trailLength * 3);
+        const progress = new Float32Array(this.trailLength);
+        const indices = [];
+        for (let i = 0; i < this.trailLength - 1; i++)
+            indices.push(i, i + 1);
+        for (let i = 0; i < this.trailLength; i++) {
+            positions[i * 3] = data.position[0];
+            positions[i * 3 + 1] = data.position[1];
+            positions[i * 3 + 2] = data.position[2];
+            progress[i] = i / (this.trailLength - 1);
+        }
+        this.trailGeometry.setAttribute('position', new THREE.BufferAttribute(positions, 3));
+        this.trailGeometry.setAttribute('progress', new THREE.BufferAttribute(progress, 1));
+        this.trailGeometry.setIndex(indices);
+        this.trailMaterial = new THREE.ShaderMaterial({
+            vertexShader: shootingStarVertexShader,
+            fragmentShader: shootingStarFragmentShader,
+            uniforms: {
+                color: { value: new THREE.Color(data.color) },
+                opacity: { value: this.opacity },
+            },
+            transparent: true,
+            blending: THREE.AdditiveBlending,
+            depthWrite: false,
+        });
+        this.lineSegments = new THREE.LineSegments(this.trailGeometry, this.trailMaterial);
+        this.group.add(this.lineSegments);
+        const size = 0.08;
+        this.starMaterial = new THREE.MeshBasicMaterial({
+            color: data.color,
+            transparent: true,
+            opacity: this.opacity,
+            blending: THREE.AdditiveBlending,
+            depthWrite: false,
+        });
+        this.glowMaterial = new THREE.MeshBasicMaterial({
+            color: data.color,
+            transparent: true,
+            opacity: this.opacity * 0.3,
+            blending: THREE.AdditiveBlending,
+            depthWrite: false,
+        });
+        this.starMesh = new THREE.Mesh(new THREE.SphereGeometry(size, 8, 8), this.starMaterial);
+        this.glowMesh = new THREE.Mesh(new THREE.SphereGeometry(size * 2, 8, 8), this.glowMaterial);
+        this.starMesh.add(this.glowMesh);
+        this.starMesh.position.copy(this.currentPos);
+        this.group.add(this.starMesh);
+    }
+    update(delta) {
+        if (this.done)
+            return;
+        const movement = this.direction.clone().multiplyScalar(this.speed);
+        this.currentPos.add(movement);
+        this.distanceTraveled += this.speed;
+        let alpha = this.opacity;
+        if (this.distanceTraveled < this.fadeIn) {
+            alpha = this.opacity * (this.distanceTraveled / this.fadeIn);
+        }
+        else if (this.distanceTraveled > this.maxDistance - this.fadeOut) {
+            alpha = this.opacity * ((this.maxDistance - this.distanceTraveled) / this.fadeOut);
+        }
+        alpha = Math.max(0, alpha);
+        this.starMesh.position.copy(this.currentPos);
+        this.starMaterial.opacity = alpha;
+        this.glowMaterial.opacity = alpha * 0.3;
+        this.trailMaterial.uniforms.opacity.value = alpha;
+        this.trailPositions.unshift(this.currentPos.clone());
+        if (this.trailPositions.length > this.trailLength)
+            this.trailPositions.pop();
+        const posAttr = this.trailGeometry.getAttribute('position');
+        for (let i = 0; i < this.trailPositions.length; i++) {
+            const p = this.trailPositions[i];
+            posAttr.setXYZ(i, p.x, p.y, p.z);
+        }
+        posAttr.needsUpdate = true;
+        if (this.distanceTraveled >= this.maxDistance) {
+            this.done = true;
+            this.onComplete();
+        }
+    }
+    dispose() {
+        this.trailGeometry.dispose();
+        this.trailMaterial.dispose();
+        this.starMesh.geometry.dispose();
+        this.starMaterial.dispose();
+        this.glowMesh.geometry.dispose();
+        this.glowMaterial.dispose();
+    }
+}
+export class GalaxyV {
+    parent;
+    starsGroup;
+    shootingGroup;
+    starsV;
+    shootingItems = [];
+    config;
+    nextId = 0;
+    constructor(parent, options) {
+        this.parent = parent;
+        this.config = options;
+        this.starsGroup = new THREE.Group();
+        this.shootingGroup = new THREE.Group();
+        parent.add(this.starsGroup);
+        parent.add(this.shootingGroup);
+        this.starsV = new StarsV(this.starsGroup, { settings: options.settings });
+        this.initShootingStars();
+    }
+    initShootingStars() {
+        const { shootingStars } = this.config.settings;
+        if (!shootingStars?.enabled)
+            return;
+        const stars = generateShootingStars(shootingStars.count, shootingStars);
+        for (const data of stars) {
+            this.addShootingStar(data);
+        }
+        this.nextId = shootingStars.count;
+    }
+    addShootingStar(data) {
+        const item = new ShootingStarItemV(data, () => {
+            // Respawn when complete
+            if (!this.config.settings.shootingStars?.enabled)
+                return;
+            const newData = generateShootingStar(this.nextId++, this.config.settings.shootingStars);
+            newData.id = item.group.id; // reuse group reference
+            item.dispose();
+            this.shootingGroup.remove(item.group);
+            const idx = this.shootingItems.indexOf(item);
+            if (idx >= 0)
+                this.shootingItems.splice(idx, 1);
+            this.addShootingStar(newData);
+        });
+        this.shootingGroup.add(item.group);
+        this.shootingItems.push(item);
+    }
+    update(elapsed, delta = 0.016) {
+        if (!this.config.settings.visible)
+            return;
+        this.starsV.update(elapsed, delta);
+        for (const item of this.shootingItems) {
+            item.update(delta);
+        }
+    }
+    updateConfig(options) {
+        this.config = options;
+        this.starsV.updateConfig({ settings: options.settings });
+        // Rebuild shooting stars if settings changed
+        for (const item of this.shootingItems) {
+            item.dispose();
+            this.shootingGroup.remove(item.group);
+        }
+        this.shootingItems = [];
+        this.nextId = 0;
+        this.initShootingStars();
+    }
+    dispose(removeFromScene = true) {
+        this.starsV.dispose(false);
+        for (const item of this.shootingItems) {
+            item.dispose();
+        }
+        this.shootingItems = [];
+        if (removeFromScene) {
+            this.parent.remove(this.starsGroup);
+            this.parent.remove(this.shootingGroup);
+        }
+    }
+}

package/dist/three/GalleryLayoutV.d.ts

@@ -0,0 +1,20 @@
+import * as THREE from 'three';
+import type { CreatedObjectSettings } from "../types/scene3d";
+export interface GalleryLayoutVOptions {
+    onFrameClick?: (url: string) => void;
+}
+export declare class GalleryLayoutV {
+    private parent;
+    private group;
+    private frames;
+    private imageGeos;
+    private effects;
+    private createdObject;
+    private options;
+    constructor(parent: THREE.Object3D, createdObject: CreatedObjectSettings, options?: GalleryLayoutVOptions);
+    private build;
+    update(elapsed: number, delta?: number): void;
+    updateCreatedObject(createdObject: CreatedObjectSettings): void;
+    dispose(removeFromScene?: boolean): void;
+}
+//# sourceMappingURL=GalleryLayoutV.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"GalleryLayoutV.d.ts","sourceRoot":"","sources":["../../src/three/GalleryLayoutV.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAK/B,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AAC9D,MAAM,WAAW,qBAAqB;IAClC,YAAY,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;CACxC;AAGD,qBAAa,cAAc;IACvB,OAAO,CAAC,MAAM,CAAC;IACf,OAAO,CAAC,KAAK,CAAC;IACd,OAAO,CAAC,MAAM,CAAM;IACpB,OAAO,CAAC,SAAS,CAAM;IACvB,OAAO,CAAC,OAAO,CAAM;IACrB,OAAO,CAAC,aAAa,CAAC;IACtB,OAAO,CAAC,OAAO,CAAC;gBACJ,MAAM,EAAE,KAAK,CAAC,QAAQ,EAAE,aAAa,EAAE,qBAAqB,EAAE,OAAO,GAAE,qBAA0B;IAQ7G,OAAO,CAAC,KAAK;IAmCb,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,GAAE,MAAc,GAAG,IAAI;IAGpD,mBAAmB,CAAC,aAAa,EAAE,qBAAqB,GAAG,IAAI;IAK/D,OAAO,CAAC,eAAe,GAAE,OAAc,GAAG,IAAI;CAWjD"}

package/dist/three/GalleryLayoutV.js

@@ -0,0 +1,76 @@
+import * as THREE from 'three';
+import { updateCurrentLayoutSettings } from '../utils/galleriesUtils.js';
+import { FrameV } from './FrameV.js';
+import { ImageGeometryV } from './ImageGeometryV.js';
+import { EffectsGeneratorV } from './EffectsGeneratorV.js';
+export class GalleryLayoutV {
+    parent;
+    group;
+    frames = [];
+    imageGeos = [];
+    effects = [];
+    createdObject;
+    options;
+    constructor(parent, createdObject, options = {}) {
+        this.parent = parent;
+        this.createdObject = createdObject;
+        this.options = options;
+        this.group = new THREE.Group();
+        parent.add(this.group);
+        this.build();
+    }
+    build() {
+        const { config, materialSettings } = this.createdObject;
+        const galleryLayout = config || { frames: [], geometryType: 'none', outerFrameScale: 1 };
+        const { frames, layoutSettings } = updateCurrentLayoutSettings(galleryLayout);
+        const color = materialSettings?.color ?? '#ffffff';
+        for (const frame of frames) {
+            const fv = new FrameV(this.group, {
+                url: frame.url,
+                position: frame.position,
+                rotation: frame.rotation,
+                layoutSettings,
+                frameColor: color,
+                onClick: this.options.onFrameClick,
+            });
+            this.frames.push(fv);
+            if (layoutSettings.geometryType && layoutSettings.geometryType !== 'none') {
+                const ig = new ImageGeometryV(this.group, {
+                    url: frame.url,
+                    geometryType: layoutSettings.geometryType,
+                    position: frame.position,
+                    rotation: frame.rotation,
+                });
+                this.imageGeos.push(ig);
+            }
+        }
+        if (this.createdObject.effects) {
+            for (const effectSettings of this.createdObject.effects) {
+                if (effectSettings.enabled) {
+                    const fxParent = new THREE.Group();
+                    this.group.add(fxParent);
+                    this.effects.push(new EffectsGeneratorV(fxParent, effectSettings));
+                }
+            }
+        }
+    }
+    update(elapsed, delta = 0.016) {
+        this.effects.forEach(fx => fx.update(elapsed, delta));
+    }
+    updateCreatedObject(createdObject) {
+        this.dispose(false);
+        this.createdObject = createdObject;
+        this.build();
+    }
+    dispose(removeFromScene = true) {
+        this.frames.forEach(f => f.dispose());
+        this.imageGeos.forEach(ig => ig.dispose());
+        this.effects.forEach(fx => fx.dispose());
+        this.frames = [];
+        this.imageGeos = [];
+        this.effects = [];
+        this.group.clear();
+        if (removeFromScene)
+            this.parent.remove(this.group);
+    }
+}

package/dist/three/GridHelperV.d.ts

@@ -0,0 +1,19 @@
+import * as THREE from 'three';
+export interface GridHelperVOptions {
+    size?: number;
+    divisions?: number;
+    cellColor?: THREE.ColorRepresentation;
+    sectionColor?: THREE.ColorRepresentation;
+    position?: [number, number, number];
+    rotation?: [number, number, number];
+    visible?: boolean;
+}
+export declare class GridHelperV {
+    private parent;
+    private grid;
+    constructor(parent: THREE.Object3D, options?: GridHelperVOptions);
+    setVisible(visible: boolean): void;
+    update(_elapsed: number, _delta?: number): void;
+    dispose(removeFromScene?: boolean): void;
+}
+//# sourceMappingURL=GridHelperV.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"GridHelperV.d.ts","sourceRoot":"","sources":["../../src/three/GridHelperV.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,MAAM,WAAW,kBAAkB;IAC/B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,KAAK,CAAC,mBAAmB,CAAC;IACtC,YAAY,CAAC,EAAE,KAAK,CAAC,mBAAmB,CAAC;IACzC,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,OAAO,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,qBAAa,WAAW;IACpB,OAAO,CAAC,MAAM,CAAC;IACf,OAAO,CAAC,IAAI,CAAC;gBACD,MAAM,EAAE,KAAK,CAAC,QAAQ,EAAE,OAAO,GAAE,kBAAuB;IASpE,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAGlC,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI;IAC/C,OAAO,CAAC,eAAe,GAAE,OAAc,GAAG,IAAI;CAUjD"}

package/dist/three/GridHelperV.js

@@ -0,0 +1,28 @@
+import * as THREE from 'three';
+export class GridHelperV {
+    parent;
+    grid;
+    constructor(parent, options = {}) {
+        this.parent = parent;
+        const { size = 100, divisions = 100, cellColor = '#888888', sectionColor = '#444444', position = [0, 0, 0], rotation = [0, 0, 0], visible = true, } = options;
+        this.grid = new THREE.GridHelper(size, divisions, sectionColor, cellColor);
+        this.grid.position.set(...position);
+        this.grid.rotation.set(...rotation);
+        this.grid.visible = visible;
+        parent.add(this.grid);
+    }
+    setVisible(visible) {
+        this.grid.visible = visible;
+    }
+    update(_elapsed, _delta) { }
+    dispose(removeFromScene = true) {
+        this.grid.geometry.dispose();
+        const mat = this.grid.material;
+        if (Array.isArray(mat))
+            mat.forEach(m => m.dispose());
+        else
+            mat.dispose();
+        if (removeFromScene)
+            this.parent.remove(this.grid);
+    }
+}

package/dist/three/ImageGeometryV.d.ts

@@ -0,0 +1,23 @@
+import * as THREE from 'three';
+import type { GeometryType } from "../types/scene3d";
+export interface ImageGeometryVOptions {
+    geometryType: GeometryType;
+    url: string;
+    position?: [number, number, number];
+    rotation?: [number, number, number];
+    scale?: [number, number, number];
+}
+export declare class ImageGeometryV {
+    private parent;
+    private group;
+    private mesh;
+    private material;
+    private config;
+    private loader;
+    constructor(parent: THREE.Object3D, options: ImageGeometryVOptions);
+    private buildMeshConfig;
+    private build;
+    updateConfig(options: ImageGeometryVOptions): void;
+    dispose(removeFromScene?: boolean): void;
+}
+//# sourceMappingURL=ImageGeometryV.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ImageGeometryV.d.ts","sourceRoot":"","sources":["../../src/three/ImageGeometryV.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACrD,MAAM,WAAW,qBAAqB;IAClC,YAAY,EAAE,YAAY,CAAC;IAC3B,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,KAAK,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;CACpC;AAGD,qBAAa,cAAc;IACvB,OAAO,CAAC,MAAM,CAAC;IACf,OAAO,CAAC,KAAK,CAAC;IACd,OAAO,CAAC,IAAI,CAAQ;IACpB,OAAO,CAAC,QAAQ,CAAQ;IACxB,OAAO,CAAC,MAAM,CAAC;IACf,OAAO,CAAC,MAAM,CAA6B;gBAC/B,MAAM,EAAE,KAAK,CAAC,QAAQ,EAAE,OAAO,EAAE,qBAAqB;IAOlE,OAAO,CAAC,eAAe;IA2BvB,OAAO,CAAC,KAAK;IAuBb,YAAY,CAAC,OAAO,EAAE,qBAAqB,GAAG,IAAI;IAKlD,OAAO,CAAC,eAAe,GAAE,OAAc,GAAG,IAAI;CAWjD"}

package/dist/three/ImageGeometryV.js

@@ -0,0 +1,83 @@
+import * as THREE from 'three';
+import { createMeshByType } from '../utils/meshUtils.js';
+export class ImageGeometryV {
+    parent;
+    group;
+    mesh = null;
+    material = null;
+    config;
+    loader = new THREE.TextureLoader();
+    constructor(parent, options) {
+        this.parent = parent;
+        this.config = options;
+        this.group = new THREE.Group();
+        parent.add(this.group);
+        this.build();
+    }
+    buildMeshConfig() {
+        const { geometryType, position = [0, 0, 0], rotation = [0, 0, 0], scale = [1, 1, 1] } = this.config;
+        const base = {
+            type: geometryType,
+            position,
+            rotation,
+            scale,
+            visible: true,
+            id: `image-${geometryType}`,
+            name: `image-${geometryType}`,
+            castShadow: true,
+            receiveShadow: true,
+        };
+        switch (geometryType) {
+            case 'plane':
+                return { ...base, scale: [1, 1, 1], widthSegments: 1, heightSegments: 1 };
+            case 'ring':
+                return { ...base, scale: [1, 1, 1], innerRadius: 0.5, outerRadius: 1, thetaSegments: 32, phiSegments: 8 };
+            case 'arc':
+                return { ...base, scale: [1, 1, 1], radius: 1, startAngle: 0, endAngle: Math.PI, width: 0.3, segments: 32 };
+            case 'bentPlane':
+            case 'bentPlaneInverse':
+                return { ...base, scale: [1, 1, 1], height: 1, radius: 2, arc: Math.PI / 2, widthSegments: 32, heightSegments: 1 };
+            default:
+                return base;
+        }
+    }
+    build() {
+        const { url, position = [0, 0, 0], rotation = [0, 0, 0] } = this.config;
+        const mesh = createMeshByType(this.buildMeshConfig());
+        if (!(mesh instanceof THREE.Mesh))
+            return;
+        this.material = new THREE.MeshBasicMaterial({
+            side: THREE.DoubleSide,
+            toneMapped: false,
+            transparent: true,
+            polygonOffset: true,
+            polygonOffsetFactor: 1,
+            polygonOffsetUnits: 1,
+        });
+        mesh.material = this.material;
+        this.loader.load(url, (texture) => {
+            if (this.material)
+                this.material.map = texture;
+        });
+        this.group.position.set(...position);
+        this.group.rotation.set(...rotation);
+        this.group.add(mesh);
+        this.mesh = mesh;
+    }
+    updateConfig(options) {
+        this.dispose(false);
+        this.config = options;
+        this.build();
+    }
+    dispose(removeFromScene = true) {
+        if (this.mesh) {
+            this.mesh.geometry.dispose();
+        }
+        this.material?.dispose();
+        this.material = null;
+        this.group.clear();
+        if (removeFromScene)
+            this.parent.remove(this.group);
+        this.mesh = null;
+    }
+}

package/dist/three/LensflareV.d.ts

@@ -0,0 +1,19 @@
+import * as THREE from 'three';
+import type { TimeSettings } from "../types/scene3d";
+export interface LensflareVOptions {
+    camera: THREE.PerspectiveCamera | THREE.OrthographicCamera;
+    timeSettings: TimeSettings;
+    visible?: boolean;
+    intensity?: number;
+}
+export declare class LensflareV {
+    private parent;
+    private sprite;
+    private material;
+    private config;
+    constructor(parent: THREE.Object3D, options: LensflareVOptions);
+    update(_elapsed: number, delta?: number): void;
+    updateConfig(options: LensflareVOptions): void;
+    dispose(removeFromScene?: boolean): void;
+}
+//# sourceMappingURL=LensflareV.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"LensflareV.d.ts","sourceRoot":"","sources":["../../src/three/LensflareV.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACrD,MAAM,WAAW,iBAAiB;IAC9B,MAAM,EAAE,KAAK,CAAC,iBAAiB,GAAG,KAAK,CAAC,kBAAkB,CAAC;IAC3D,YAAY,EAAE,YAAY,CAAC;IAC3B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;CACtB;AAgCD,qBAAa,UAAU;IACnB,OAAO,CAAC,MAAM,CAAC;IACf,OAAO,CAAC,MAAM,CAAC;IACf,OAAO,CAAC,QAAQ,CAAC;IACjB,OAAO,CAAC,MAAM,CAAC;gBACH,MAAM,EAAE,KAAK,CAAC,QAAQ,EAAE,OAAO,EAAE,iBAAiB;IAiB9D,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,GAAE,MAAc,GAAG,IAAI;IAcrD,YAAY,CAAC,OAAO,EAAE,iBAAiB,GAAG,IAAI;IAK9C,OAAO,CAAC,eAAe,GAAE,OAAc,GAAG,IAAI;CAMjD"}

package/dist/three/LensflareV.js

@@ -0,0 +1,79 @@
+import * as THREE from 'three';
+import { skySystemManager } from '../services/SkySystemManager.js';
+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;
+}
+export class LensflareV {
+    parent;
+    sprite;
+    material;
+    config;
+    constructor(parent, options) {
+        this.parent = parent;
+        this.config = options;
+        const texture = createFlareTexture(0);
+        this.material = new THREE.SpriteMaterial({
+            map: texture,
+            transparent: true,
+            blending: THREE.AdditiveBlending,
+            depthWrite: false,
+            depthTest: false,
+        });
+        this.sprite = new THREE.Sprite(this.material);
+        this.sprite.renderOrder = Infinity;
+        this.sprite.visible = options.visible ?? true;
+        parent.add(this.sprite);
+        skySystemManager.setTimeSettings(options.timeSettings);
+    }
+    update(_elapsed, delta = 0.016) {
+        if (!this.sprite.visible)
+            return;
+        const { timeSettings, camera, intensity = 1 } = this.config;
+        if (!timeSettings.enabled)
+            return;
+        const state = skySystemManager.getState();
+        const { sunDirection } = state;
+        const distance = Math.min(camera.far * 0.5, 200);
+        this.sprite.position.copy(camera.position);
+        this.sprite.position.addScaledVector(sunDirection, distance);
+        this.sprite.scale.setScalar(5 * intensity);
+        this.material.opacity = sunDirection.y > 0 ? Math.min(sunDirection.y * 2, 1) : 0;
+    }
+    updateConfig(options) {
+        this.config = options;
+        this.sprite.visible = options.visible ?? true;
+        skySystemManager.setTimeSettings(options.timeSettings);
+    }
+    dispose(removeFromScene = true) {
+        this.material.map?.dispose();
+        this.material.dispose();
+        if (removeFromScene)
+            this.parent.remove(this.sprite);
+    }
+}