@3driseai/3drise-core 1.0.1

package/dist/three/AnimatedObjectV.js

@@ -0,0 +1,169 @@
+import * as THREE from 'three';
+import { applyEasing, resolveEasing } from '../utils/easingUtils.js';
+import { smoothPathCorners, createPathSpline } from '../utils/pathUtils.js';
+export class AnimatedObjectV {
+    group;
+    parent;
+    // Step-based transform state
+    fromPos = new THREE.Vector3();
+    fromScale = new THREE.Vector3(1, 1, 1);
+    fromRot = new THREE.Euler();
+    toPos = new THREE.Vector3();
+    toScale = new THREE.Vector3(1, 1, 1);
+    toRot = new THREE.Euler();
+    transProgress = 1;
+    transDuration = 1;
+    transEase = 'linear';
+    transElapsed = 0;
+    transOnComplete = null;
+    // Path animation state
+    pathPoints = [];
+    pathSpline = null;
+    pathProgress = 0;
+    pathDuration = 1;
+    pathSpeed = 1;
+    pathEase = null;
+    pathLoop = false;
+    pathYoyo = false;
+    pathDirection = 1;
+    pathActive = false;
+    pathFaceDir = true;
+    pathApplyRot = true;
+    pathOffset = null;
+    pathOnComplete = null;
+    targetQuat = new THREE.Quaternion();
+    constructor(parent, options = {}) {
+        this.parent = parent;
+        this.group = new THREE.Group();
+        const pos = options.position ?? [0, 0, 0];
+        const sc = options.scale ?? [1, 1, 1];
+        const rot = options.rotation ?? [0, 0, 0];
+        this.group.position.set(...pos);
+        this.group.scale.set(...sc);
+        this.group.rotation.set(...rot);
+        parent.add(this.group);
+    }
+    startTransition(options) {
+        const cur = this.group;
+        this.fromPos.set(options.from?.position?.[0] ?? cur.position.x, options.from?.position?.[1] ?? cur.position.y, options.from?.position?.[2] ?? cur.position.z);
+        this.fromScale.set(options.from?.scale?.[0] ?? cur.scale.x, options.from?.scale?.[1] ?? cur.scale.y, options.from?.scale?.[2] ?? cur.scale.z);
+        this.fromRot.set(options.from?.rotation?.[0] ?? cur.rotation.x, options.from?.rotation?.[1] ?? cur.rotation.y, options.from?.rotation?.[2] ?? cur.rotation.z);
+        this.toPos.set(options.to.position?.[0] ?? cur.position.x, options.to.position?.[1] ?? cur.position.y, options.to.position?.[2] ?? cur.position.z);
+        this.toScale.set(options.to.scale?.[0] ?? cur.scale.x, options.to.scale?.[1] ?? cur.scale.y, options.to.scale?.[2] ?? cur.scale.z);
+        this.toRot.set(options.to.rotation?.[0] ?? cur.rotation.x, options.to.rotation?.[1] ?? cur.rotation.y, options.to.rotation?.[2] ?? cur.rotation.z);
+        this.transDuration = options.duration ?? 1;
+        this.transEase = options.ease ?? 'linear';
+        this.transElapsed = 0;
+        this.transProgress = 0;
+        this.transOnComplete = options.onComplete ?? null;
+    }
+    startPathAnimation(pathConfig, duration, options = {}) {
+        if (pathConfig.points.length < 2)
+            return false;
+        const smooth = pathConfig.smoothCorners ?? 0;
+        const pts = smooth > 0 && pathConfig.points.length >= 3
+            ? smoothPathCorners(pathConfig.points, smooth)
+            : pathConfig.points;
+        this.pathPoints = pts;
+        this.pathSpline = createPathSpline(pts, pathConfig.curve ?? 1);
+        this.pathProgress = 0;
+        this.pathDuration = duration;
+        this.pathSpeed = options.speed ?? 1;
+        this.pathEase = options.ease ?? null;
+        this.pathLoop = options.loop ?? false;
+        this.pathYoyo = options.yoyo ?? false;
+        this.pathDirection = 1;
+        this.pathFaceDir = options.faceDirection ?? true;
+        this.pathApplyRot = options.applyRotation ?? pathConfig.applyRotation ?? true;
+        this.pathOffset = options.offset ?? pathConfig.offset ?? null;
+        this.pathOnComplete = options.onComplete ?? null;
+        this.pathActive = true;
+        return true;
+    }
+    stopAnimation() {
+        this.transProgress = 1;
+        this.pathActive = false;
+    }
+    updateTransition(delta) {
+        if (this.transProgress >= 1)
+            return;
+        this.transElapsed += delta;
+        const linear = Math.min(this.transElapsed / this.transDuration, 1);
+        const p = applyEasing(resolveEasing(this.transEase), linear);
+        this.transProgress = linear;
+        const g = this.group;
+        g.position.lerpVectors(this.fromPos, this.toPos, p);
+        g.scale.lerpVectors(this.fromScale, this.toScale, p);
+        g.rotation.set(this.fromRot.x + (this.toRot.x - this.fromRot.x) * p, this.fromRot.y + (this.toRot.y - this.fromRot.y) * p, this.fromRot.z + (this.toRot.z - this.fromRot.z) * p);
+        if (linear >= 1)
+            this.transOnComplete?.();
+    }
+    updatePath(delta) {
+        if (!this.pathActive)
+            return;
+        this.pathProgress += (delta / this.pathDuration) * this.pathSpeed * this.pathDirection;
+        let p = this.pathProgress;
+        if (p >= 1 || p <= 0) {
+            if (this.pathYoyo) {
+                this.pathDirection *= -1;
+                p = Math.max(0, Math.min(1, p));
+                this.pathProgress = p;
+                if (!this.pathLoop && this.pathDirection === 1 && p <= 0) {
+                    this.pathActive = false;
+                    this.pathOnComplete?.();
+                    return;
+                }
+            }
+            else if (this.pathLoop) {
+                this.pathProgress = ((p % 1) + 1) % 1;
+                p = this.pathProgress;
+            }
+            else {
+                this.pathProgress = Math.max(0, Math.min(1, p));
+                this.pathActive = false;
+                this.pathOnComplete?.();
+                return;
+            }
+        }
+        const eased = this.pathEase ? applyEasing(resolveEasing(this.pathEase), p) : p;
+        const clamped = Math.max(0, Math.min(1, eased));
+        let position;
+        let direction;
+        if (this.pathSpline) {
+            position = this.pathSpline.getPointAt(clamped);
+            direction = this.pathSpline.getTangentAt(clamped).normalize();
+        }
+        else {
+            const pts = this.pathPoints;
+            const segs = pts.length - 1;
+            const idx = Math.min(Math.floor(clamped * segs), segs - 1);
+            const sp = clamped * segs - idx;
+            const a = pts[idx], b = pts[idx + 1];
+            position = new THREE.Vector3(a[0] + (b[0] - a[0]) * sp, a[1] + (b[1] - a[1]) * sp, a[2] + (b[2] - a[2]) * sp);
+            direction = new THREE.Vector3(b[0] - a[0], b[1] - a[1], b[2] - a[2]).normalize();
+        }
+        if (this.pathOffset) {
+            position.x += this.pathOffset[0];
+            position.y += this.pathOffset[1];
+            position.z += this.pathOffset[2];
+        }
+        this.group.position.copy(position);
+        if (this.pathApplyRot && this.pathFaceDir && direction.lengthSq() > 0.0001) {
+            const up = new THREE.Vector3(0, 1, 0);
+            const mat = new THREE.Matrix4();
+            mat.lookAt(position, new THREE.Vector3().copy(position).add(direction), up);
+            this.targetQuat.setFromRotationMatrix(mat);
+            this.targetQuat.multiply(new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), Math.PI));
+            this.group.quaternion.slerp(this.targetQuat, 1);
+        }
+    }
+    update(_elapsed, delta = 0.016) {
+        this.updateTransition(delta);
+        this.updatePath(delta);
+    }
+    dispose(removeFromScene = true) {
+        if (removeFromScene)
+            this.parent.remove(this.group);
+        this.group.clear();
+    }
+}

package/dist/three/CloudsV.d.ts

@@ -0,0 +1,24 @@
+import * as THREE from 'three';
+import type { TimeSettings } from "../types/scene3d";
+export interface CloudsVOptions {
+    timeSettings: TimeSettings;
+    visible?: boolean;
+    scale?: number;
+    height?: number;
+    speed?: number;
+}
+export declare class CloudsV {
+    private parent;
+    private mesh;
+    private material;
+    private config;
+    private animTime;
+    private cloudColor;
+    private targetColor;
+    constructor(parent: THREE.Object3D, options: CloudsVOptions);
+    update(_elapsed: number, delta?: number): void;
+    private applyTimeState;
+    updateConfig(options: CloudsVOptions): void;
+    dispose(removeFromScene?: boolean): void;
+}
+//# sourceMappingURL=CloudsV.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"CloudsV.d.ts","sourceRoot":"","sources":["../../src/three/CloudsV.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,YAAY,EAAE,YAAY,CAAC;IAC3B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;CAClB;AA+CD,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,CAAK;IACrB,OAAO,CAAC,UAAU,CAA4B;IAC9C,OAAO,CAAC,WAAW,CAA4B;gBACnC,MAAM,EAAE,KAAK,CAAC,QAAQ,EAAE,OAAO,EAAE,cAAc;IAyB3D,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,GAAE,MAAc,GAAG,IAAI;IAYrD,OAAO,CAAC,cAAc;IAyBtB,YAAY,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI;IAS3C,OAAO,CAAC,eAAe,GAAE,OAAc,GAAG,IAAI;CAMjD"}

package/dist/three/CloudsV.js

@@ -0,0 +1,132 @@
+import * as THREE from 'three';
+import { skySystemManager } from '../services/SkySystemManager.js';
+const CLOUD_COLORS = {
+    night: new THREE.Color(0.1, 0.1, 0.2),
+    sunrise: new THREE.Color(0.8, 0.4, 0.4),
+    midday: new THREE.Color(1.0, 1.0, 1.0),
+    sunset: new THREE.Color(0.8, 0.3, 0.3),
+};
+const vertexShader = /*glsl*/ `
+  varying vec2 vUv;
+  void main() {
+    vUv = uv;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+  }
+`;
+const fragmentShader = /*glsl*/ `
+  varying vec2 vUv;
+  uniform float u_time;
+  uniform vec3 u_cloudColor;
+
+  float rand(vec2 n) { return fract(sin(dot(n, vec2(12.9898, 4.1414))) * 43758.5453); }
+
+  float noise(vec2 n) {
+    vec2 d = vec2(0.0, 1.0);
+    vec2 b = floor(n);
+    vec2 f = smoothstep(vec2(0.0), vec2(1.0), fract(n));
+    return mix(mix(rand(b), rand(b + d.yx), f.x), mix(rand(b + d.xy), rand(b + d.yy), f.x), f.y);
+  }
+
+  float fbm(vec2 n) {
+    float t = 0.0, s = 1.0;
+    for (int i = 0; i < 5; i++) {
+      t += noise(n) * s;
+      n = n * 2.0 + vec2(0.5);
+      s *= 0.5;
+    }
+    return t;
+  }
+
+  void main() {
+    vec2 uv = vUv * 4.0 + vec2(u_time * 0.02, 0.0);
+    float cloud = fbm(uv);
+    cloud = smoothstep(0.4, 0.9, cloud);
+    gl_FragColor = vec4(u_cloudColor, cloud * 0.8);
+  }
+`;
+export class CloudsV {
+    parent;
+    mesh;
+    material;
+    config;
+    animTime = 0;
+    cloudColor = new THREE.Color(1, 1, 1);
+    targetColor = new THREE.Color(1, 1, 1);
+    constructor(parent, options) {
+        this.parent = parent;
+        this.config = options;
+        this.material = new THREE.ShaderMaterial({
+            vertexShader,
+            fragmentShader,
+            uniforms: {
+                u_time: { value: 0 },
+                u_cloudColor: { value: new THREE.Color(1, 1, 1) },
+            },
+            transparent: true,
+            depthWrite: false,
+            side: THREE.DoubleSide,
+        });
+        const geometry = new THREE.PlaneGeometry(2, 2);
+        this.mesh = new THREE.Mesh(geometry, this.material);
+        this.mesh.position.set(0, options.height ?? 400, 0);
+        this.mesh.rotation.set(Math.PI / 2, 0, 0);
+        this.mesh.scale.setScalar(options.scale ?? 1);
+        this.mesh.renderOrder = -1;
+        this.mesh.frustumCulled = false;
+        this.mesh.visible = options.visible ?? true;
+        parent.add(this.mesh);
+        skySystemManager.setTimeSettings(options.timeSettings);
+    }
+    update(_elapsed, delta = 0.016) {
+        if (!this.mesh.visible)
+            return;
+        const { timeSettings, speed = 1 } = this.config;
+        if (!timeSettings.enabled)
+            return;
+        const state = skySystemManager.getState();
+        this.applyTimeState(state, delta);
+        this.animTime += 0.02 * speed;
+        this.material.uniforms.u_time.value = this.animTime;
+        this.material.uniforms.u_cloudColor.value.copy(this.cloudColor);
+    }
+    applyTimeState(state, delta) {
+        const { normalizedTime, isDaytime } = state;
+        if (isDaytime) {
+            if (normalizedTime <= 0.15) {
+                this.targetColor.lerpColors(CLOUD_COLORS.night, CLOUD_COLORS.sunrise, normalizedTime / 0.15);
+            }
+            else if (normalizedTime <= 0.25) {
+                this.targetColor.lerpColors(CLOUD_COLORS.sunrise, CLOUD_COLORS.midday, (normalizedTime - 0.15) / 0.10);
+            }
+            else if (normalizedTime <= 0.75) {
+                this.targetColor.copy(CLOUD_COLORS.midday);
+            }
+            else if (normalizedTime <= 0.85) {
+                this.targetColor.lerpColors(CLOUD_COLORS.midday, CLOUD_COLORS.sunset, (normalizedTime - 0.75) / 0.10);
+            }
+            else {
+                this.targetColor.lerpColors(CLOUD_COLORS.sunset, CLOUD_COLORS.night, (normalizedTime - 0.85) / 0.15);
+            }
+        }
+        else {
+            this.targetColor.copy(CLOUD_COLORS.night);
+        }
+        const lerpSpeed = Math.min(1, 2.0 * (delta || 0.016));
+        this.cloudColor.lerp(this.targetColor, lerpSpeed);
+    }
+    updateConfig(options) {
+        this.config = options;
+        this.mesh.visible = options.visible ?? true;
+        if (options.scale !== undefined)
+            this.mesh.scale.setScalar(options.scale);
+        if (options.height !== undefined)
+            this.mesh.position.y = options.height;
+        skySystemManager.setTimeSettings(options.timeSettings);
+    }
+    dispose(removeFromScene = true) {
+        this.mesh.geometry.dispose();
+        this.material.dispose();
+        if (removeFromScene)
+            this.parent.remove(this.mesh);
+    }
+}

package/dist/three/EffectsGeneratorV.d.ts

@@ -0,0 +1,14 @@
+import type * as THREE from "three";
+import type { GenerativeEffectSettings } from "../types/generativeEffects";
+export declare class EffectsGeneratorV {
+    private scene;
+    private effect;
+    private settings;
+    private boundingRadius;
+    constructor(scene: THREE.Scene, settings: GenerativeEffectSettings, boundingRadius?: number);
+    private build;
+    update(elapsed: number, delta?: number): void;
+    updateSettings(settings: GenerativeEffectSettings, boundingRadius?: number): void;
+    dispose(): void;
+}
+//# sourceMappingURL=EffectsGeneratorV.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"EffectsGeneratorV.d.ts","sourceRoot":"","sources":["../../src/three/EffectsGeneratorV.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAC;AAmBpC,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AAE3E,qBAAa,iBAAiB;IAC1B,OAAO,CAAC,KAAK,CAAC;IACd,OAAO,CAAC,MAAM,CAAQ;IACtB,OAAO,CAAC,QAAQ,CAAC;IACjB,OAAO,CAAC,cAAc,CAAC;gBACX,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,QAAQ,EAAE,wBAAwB,EAAE,cAAc,GAAE,MAAU;IAO9F,OAAO,CAAC,KAAK;IA8Db,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,GAAE,MAAc,GAAG,IAAI;IAGpD,cAAc,CAAC,QAAQ,EAAE,wBAAwB,EAAE,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI;IASjF,OAAO,IAAI,IAAI;CAIlB"}

package/dist/three/EffectsGeneratorV.js

@@ -0,0 +1,109 @@
+import { AuraEffectV } from './effects/AuraEffectV.js';
+import { OrbEffectV } from './effects/OrbEffectV.js';
+import { SmokePlumeEffectV } from './effects/SmokePlumeEffectV.js';
+import { VolumetricFogEffectV } from './effects/VolumetricFogEffectV.js';
+import { SmokeRingEffectV } from './effects/SmokeRingEffectV.js';
+import { PortalEffectV } from './effects/PortalEffectV.js';
+import { BlackHoleEffectV } from './effects/BlackHoleEffectV.js';
+import { ForcefieldEffectV } from './effects/ForcefieldEffectV.js';
+import { DataStreamEffectV } from './effects/DataStreamEffectV.js';
+import { HologramEffectV } from './effects/HologramEffectV.js';
+import { AuroraEffectV } from './effects/AuroraEffectV.js';
+import { ShockwaveEffectV } from './effects/ShockwaveEffectV.js';
+import { ConstellationEffectV } from './effects/ConstellationEffectV.js';
+import { MoleculesEffectV } from './effects/MoleculesEffectV.js';
+import { DnaHelixEffectV } from './effects/DnaHelixEffectV.js';
+import { IceCrystalsEffectV } from './effects/IceCrystalsEffectV.js';
+import { LightningEffectV } from './effects/LightningEffectV.js';
+import { NeuralNetworkEffectV } from './effects/NeuralNetworkEffectV.js';
+export class EffectsGeneratorV {
+    scene;
+    effect = null;
+    settings;
+    boundingRadius;
+    constructor(scene, settings, boundingRadius = 1) {
+        this.scene = scene;
+        this.settings = settings;
+        this.boundingRadius = boundingRadius;
+        if (settings.enabled)
+            this.build();
+    }
+    build() {
+        const { config } = this.settings;
+        const r = this.boundingRadius;
+        switch (config.type) {
+            case 'aura':
+                this.effect = new AuraEffectV(this.scene, config, r);
+                break;
+            case 'orb':
+                this.effect = new OrbEffectV(this.scene, config, r);
+                break;
+                break;
+            case 'smokePlume':
+                this.effect = new SmokePlumeEffectV(this.scene, config, r);
+                break;
+            case 'volumetricFog':
+                this.effect = new VolumetricFogEffectV(this.scene, config, r);
+                break;
+            case 'smokeRing':
+                this.effect = new SmokeRingEffectV(this.scene, config, r);
+                break;
+            case 'portal':
+                this.effect = new PortalEffectV(this.scene, config, r);
+                break;
+            case 'blackHole':
+                this.effect = new BlackHoleEffectV(this.scene, config, r);
+                break;
+            case 'forcefield':
+                this.effect = new ForcefieldEffectV(this.scene, config, r);
+                break;
+            case 'dataStream':
+                this.effect = new DataStreamEffectV(this.scene, config, r);
+                break;
+            case 'hologram':
+                this.effect = new HologramEffectV(this.scene, config, r);
+                break;
+            case 'aurora':
+                this.effect = new AuroraEffectV(this.scene, config, r);
+                break;
+            case 'shockwave':
+                this.effect = new ShockwaveEffectV(this.scene, config, r);
+                break;
+            case 'constellation':
+                this.effect = new ConstellationEffectV(this.scene, config, r);
+                break;
+            case 'molecules':
+                this.effect = new MoleculesEffectV(this.scene, config, r);
+                break;
+            case 'dnaHelix':
+                this.effect = new DnaHelixEffectV(this.scene, config, r);
+                break;
+            case 'iceCrystals':
+                this.effect = new IceCrystalsEffectV(this.scene, config, r);
+                break;
+            case 'lightning':
+                this.effect = new LightningEffectV(this.scene, config, r);
+                break;
+            case 'neuralNetwork':
+                this.effect = new NeuralNetworkEffectV(this.scene, config, r);
+                break;
+            default: this.effect = null;
+        }
+    }
+    update(elapsed, delta = 0.016) {
+        this.effect?.update(elapsed, delta);
+    }
+    updateSettings(settings, boundingRadius) {
+        if (boundingRadius !== undefined)
+            this.boundingRadius = boundingRadius;
+        this.settings = settings;
+        this.effect?.dispose();
+        this.effect = null;
+        if (settings.enabled)
+            this.build();
+    }
+    dispose() {
+        this.effect?.dispose();
+        this.effect = null;
+    }
+}

package/dist/three/EnvironmentManagerV.d.ts

@@ -0,0 +1,35 @@
+import * as THREE from 'three';
+import type { SkySystemVOptions } from './SkySystemV';
+import type { HdrSettings } from "../types/environment";
+export interface EnvironmentManagerVOptions extends SkySystemVOptions {
+    scene: THREE.Scene;
+    renderer: THREE.WebGLRenderer;
+    hdrSettings?: HdrSettings;
+    cubeCameraResolution?: number;
+    cubeCameraPosition?: THREE.Vector3;
+}
+export declare class EnvironmentManagerV {
+    private parent;
+    private scene;
+    private renderer;
+    private skySystem;
+    private cubeCamera;
+    private config;
+    private elapsedMs;
+    private readonly CUBE_UPDATE_INTERVAL_MS;
+    private loadedHdrUrl;
+    private loadedHdrTexture;
+    private hdrLoadToken;
+    constructor(parent: THREE.Object3D, options: EnvironmentManagerVOptions);
+    private firstUrl;
+    private isSkyActive;
+    private applyHdrState;
+    private loadHdrUrl;
+    private disposeLoadedHdr;
+    private initCubeCamera;
+    updateEnvironment(): void;
+    update(elapsed: number, delta?: number): void;
+    updateConfig(options: EnvironmentManagerVOptions): void;
+    dispose(removeFromScene?: boolean): void;
+}
+//# sourceMappingURL=EnvironmentManagerV.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"EnvironmentManagerV.d.ts","sourceRoot":"","sources":["../../src/three/EnvironmentManagerV.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAEtD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACxD,MAAM,WAAW,0BAA2B,SAAQ,iBAAiB;IACjE,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC;IACnB,QAAQ,EAAE,KAAK,CAAC,aAAa,CAAC;IAC9B,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,kBAAkB,CAAC,EAAE,KAAK,CAAC,OAAO,CAAC;CACtC;AAGD,qBAAa,mBAAmB;IAC5B,OAAO,CAAC,MAAM,CAAC;IACf,OAAO,CAAC,KAAK,CAAC;IACd,OAAO,CAAC,QAAQ,CAAC;IACjB,OAAO,CAAC,SAAS,CAAC;IAClB,OAAO,CAAC,UAAU,CAAQ;IAC1B,OAAO,CAAC,MAAM,CAAC;IACf,OAAO,CAAC,SAAS,CAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,uBAAuB,CAAO;IAC/C,OAAO,CAAC,YAAY,CAAQ;IAC5B,OAAO,CAAC,gBAAgB,CAAQ;IAChC,OAAO,CAAC,YAAY,CAAK;gBACb,MAAM,EAAE,KAAK,CAAC,QAAQ,EAAE,OAAO,EAAE,0BAA0B;IAQvE,OAAO,CAAC,QAAQ;IAKhB,OAAO,CAAC,WAAW;IAInB,OAAO,CAAC,aAAa;YAgCP,UAAU;IAyBxB,OAAO,CAAC,gBAAgB;IAWxB,OAAO,CAAC,cAAc;IAOtB,iBAAiB,IAAI,IAAI;IAMzB,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,GAAE,MAAc,GAAG,IAAI;IAUpD,YAAY,CAAC,OAAO,EAAE,0BAA0B,GAAG,IAAI;IAOvD,OAAO,CAAC,eAAe,GAAE,OAAc,GAAG,IAAI;CASjD"}

package/dist/three/EnvironmentManagerV.js

@@ -0,0 +1,140 @@
+import * as THREE from 'three';
+import { SkySystemV } from './SkySystemV.js';
+import { createCubeCamera, updateCubeCamera, setSceneEnvironment, clearSceneEnvironment, disposeCubeCamera, loadEquirectHdrEnvironment, } from '../utils/environmentUtils.js';
+export class EnvironmentManagerV {
+    parent;
+    scene;
+    renderer;
+    skySystem;
+    cubeCamera = null;
+    config;
+    elapsedMs = 0;
+    CUBE_UPDATE_INTERVAL_MS = 300;
+    loadedHdrUrl = null;
+    loadedHdrTexture = null;
+    hdrLoadToken = 0;
+    constructor(parent, options) {
+        this.parent = parent;
+        this.config = options;
+        this.scene = options.scene;
+        this.renderer = options.renderer;
+        this.skySystem = new SkySystemV(parent, options);
+        this.applyHdrState();
+    }
+    firstUrl(hdr) {
+        if (!hdr || !hdr.visible)
+            return undefined;
+        return hdr.urls && hdr.urls.length > 0 ? hdr.urls[0] : undefined;
+    }
+    isSkyActive() {
+        const o = this.config;
+        return (o.visible !== false) && (o.sunSystemVisible ?? false);
+    }
+    applyHdrState() {
+        const hdr = this.config.hdrSettings;
+        const firstUrl = this.firstUrl(hdr);
+        if (firstUrl) {
+            // Equirect URL takes precedence — dispose procedural camera, load HDR.
+            // Vanilla path always uses the first URL; transitions are React-only.
+            if (this.cubeCamera) {
+                disposeCubeCamera(this.cubeCamera, this.scene);
+                this.cubeCamera = null;
+            }
+            this.loadHdrUrl(firstUrl, hdr.settings?.background !== false);
+            return;
+        }
+        // No url — dispose any loaded HDR texture.
+        this.disposeLoadedHdr();
+        if (hdr?.visible && hdr.name) {
+            // Preset case — vanilla has no preset library; leave scene.environment as-is.
+            // (Procedural cube camera is not started either, to avoid overwriting an
+            // environment a caller may have set externally.)
+            return;
+        }
+        // No HDR active. Fall back to procedural cube camera when sky is active.
+        if (this.isSkyActive()) {
+            if (!this.cubeCamera)
+                this.initCubeCamera();
+        }
+        else if (this.cubeCamera) {
+            disposeCubeCamera(this.cubeCamera, this.scene);
+            this.cubeCamera = null;
+            clearSceneEnvironment(this.scene);
+        }
+    }
+    async loadHdrUrl(url, asBackground) {
+        if (this.loadedHdrUrl === url && this.loadedHdrTexture) {
+            setSceneEnvironment(this.scene, this.loadedHdrTexture);
+            if (!asBackground)
+                this.scene.background = null;
+            return;
+        }
+        const token = ++this.hdrLoadToken;
+        try {
+            const texture = await loadEquirectHdrEnvironment(url, this.renderer);
+            if (token !== this.hdrLoadToken) {
+                // A newer load superseded us — drop this result.
+                texture.dispose();
+                return;
+            }
+            this.disposeLoadedHdr();
+            this.loadedHdrUrl = url;
+            this.loadedHdrTexture = texture;
+            this.scene.environment = texture;
+            this.scene.background = asBackground ? texture : null;
+        }
+        catch (err) {
+            console.error('[EnvironmentManagerV] Failed to load HDR:', url, err);
+        }
+    }
+    disposeLoadedHdr() {
+        if (this.loadedHdrTexture) {
+            this.loadedHdrTexture.dispose();
+            this.loadedHdrTexture = null;
+        }
+        this.loadedHdrUrl = null;
+        if (this.scene.environment)
+            this.scene.environment = null;
+        if (this.scene.background)
+            this.scene.background = null;
+    }
+    initCubeCamera() {
+        const { cubeCameraResolution = 512, cubeCameraPosition = new THREE.Vector3(0, 50, 0) } = this.config;
+        if (this.cubeCamera)
+            disposeCubeCamera(this.cubeCamera, this.scene);
+        this.cubeCamera = createCubeCamera(this.scene, cubeCameraResolution, cubeCameraPosition);
+        this.updateEnvironment();
+    }
+    updateEnvironment() {
+        if (!this.cubeCamera)
+            return;
+        const texture = updateCubeCamera(this.cubeCamera, this.renderer, this.scene);
+        setSceneEnvironment(this.scene, texture);
+    }
+    update(elapsed, delta = 0.016) {
+        this.skySystem.update(elapsed, delta);
+        if (this.cubeCamera && this.config.timeSettings.autoAnimate) {
+            this.elapsedMs += delta * 1000;
+            if (this.elapsedMs >= this.CUBE_UPDATE_INTERVAL_MS) {
+                this.elapsedMs = 0;
+                this.updateEnvironment();
+            }
+        }
+    }
+    updateConfig(options) {
+        this.config = options;
+        this.scene = options.scene;
+        this.renderer = options.renderer;
+        this.applyHdrState();
+        this.skySystem.updateConfig(options);
+    }
+    dispose(removeFromScene = true) {
+        if (this.cubeCamera) {
+            disposeCubeCamera(this.cubeCamera, this.scene);
+            this.cubeCamera = null;
+        }
+        this.disposeLoadedHdr();
+        clearSceneEnvironment(this.scene);
+        this.skySystem.dispose(removeFromScene);
+    }
+}

package/dist/three/FrameV.d.ts

@@ -0,0 +1,24 @@
+import type { Side, Scene } from 'three';
+import type { GalleryLayoutSettings } from "../types/gallery";
+export interface FrameVOptions {
+    url: string;
+    position?: [number, number, number];
+    rotation?: [number, number, number];
+    layoutSettings: Pick<GalleryLayoutSettings, 'width' | 'height' | 'outerFrameScale'>;
+    frameColor?: string;
+    side?: Side;
+    onLoad?: () => void;
+    onClick?: (url: string) => void;
+}
+export declare class FrameV {
+    private group;
+    private frameMesh;
+    private imageMesh;
+    readonly url: string;
+    onClick?: (url: string) => void;
+    constructor(scene: Scene, options: FrameVOptions);
+    setPosition(position: [number, number, number]): void;
+    setHovered(hovered: boolean): void;
+    dispose(): void;
+}
+//# sourceMappingURL=FrameV.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FrameV.d.ts","sourceRoot":"","sources":["../../src/three/FrameV.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC;AACzC,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AAC9D,MAAM,WAAW,aAAa;IAC1B,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,cAAc,EAAE,IAAI,CAAC,qBAAqB,EAAE,OAAO,GAAG,QAAQ,GAAG,iBAAiB,CAAC,CAAC;IACpF,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,IAAI,CAAC,EAAE,IAAI,CAAC;IACZ,MAAM,CAAC,EAAE,MAAM,IAAI,CAAC;IACpB,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;CACnC;AAGD,qBAAa,MAAM;IACf,OAAO,CAAC,KAAK,CAAC;IACd,OAAO,CAAC,SAAS,CAAC;IAClB,OAAO,CAAC,SAAS,CAAC;IAClB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;gBACpB,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,aAAa;IAoBhD,WAAW,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI;IAGrD,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAGlC,OAAO,IAAI,IAAI;CASlB"}