@3driseai/3drise-core 1.0.1

package/dist/three/SkyboxV.js

@@ -0,0 +1,160 @@
+import * as THREE from 'three';
+import { skySystemManager } from '../services/SkySystemManager.js';
+const COLORS = {
+    white: new THREE.Color(0xffffff),
+    orange: new THREE.Color(0xff4500),
+    yellow: new THREE.Color(0xffd700),
+    red: new THREE.Color(0xff6347),
+    darkRed: new THREE.Color(0xd32f2f),
+    skyBlue: new THREE.Color(0x87ceeb),
+    darkSky: new THREE.Color(0x0d1321),
+    nightSky: new THREE.Color(0x1c2331),
+    moon: new THREE.Color(0xe6e8fa),
+};
+const MOON_GLOW = COLORS.moon.clone().multiplyScalar(1.8);
+const SKY_KEYFRAMES = [
+    { t: 0, horizon: COLORS.darkSky, high: COLORS.nightSky, sun: MOON_GLOW },
+    { t: 5, horizon: COLORS.darkSky, high: COLORS.nightSky, sun: MOON_GLOW },
+    { t: 5.7, horizon: COLORS.darkRed, high: COLORS.darkSky, sun: COLORS.orange },
+    { t: 6.3, horizon: COLORS.red, high: COLORS.darkSky, sun: COLORS.orange },
+    { t: 6.8, horizon: COLORS.yellow, high: COLORS.darkSky, sun: COLORS.yellow },
+    { t: 8, horizon: COLORS.skyBlue, high: COLORS.skyBlue, sun: COLORS.white },
+    { t: 12, horizon: COLORS.skyBlue, high: COLORS.darkSky, sun: COLORS.white },
+    { t: 16, horizon: COLORS.skyBlue, high: COLORS.skyBlue, sun: COLORS.white },
+    { t: 19, horizon: COLORS.yellow, high: COLORS.skyBlue, sun: COLORS.yellow },
+    { t: 20, horizon: COLORS.red, high: COLORS.darkRed, sun: COLORS.orange },
+    { t: 20.7, horizon: COLORS.darkRed, high: COLORS.darkSky, sun: COLORS.orange },
+    { t: 22, horizon: COLORS.darkSky, high: COLORS.nightSky, sun: MOON_GLOW },
+    { t: 24, horizon: COLORS.darkSky, high: COLORS.nightSky, sun: MOON_GLOW },
+];
+function sampleSkyKeyframes(timeInHours, outHorizon, outHigh, outSun) {
+    const wrapped = ((timeInHours % 24) + 24) % 24;
+    for (let i = 0; i < SKY_KEYFRAMES.length - 1; i++) {
+        const k0 = SKY_KEYFRAMES[i];
+        const k1 = SKY_KEYFRAMES[i + 1];
+        if (wrapped <= k1.t) {
+            const span = k1.t - k0.t;
+            const t = span === 0 ? 0 : (wrapped - k0.t) / span;
+            outHorizon.lerpColors(k0.horizon, k1.horizon, t);
+            outHigh.lerpColors(k0.high, k1.high, t);
+            outSun.lerpColors(k0.sun, k1.sun, t);
+            return;
+        }
+    }
+    const last = SKY_KEYFRAMES[SKY_KEYFRAMES.length - 1];
+    outHorizon.copy(last.horizon);
+    outHigh.copy(last.high);
+    outSun.copy(last.sun);
+}
+export class SkyboxV {
+    parent;
+    mesh;
+    material;
+    config;
+    sunColor = new THREE.Color(0xffe5b0);
+    skyColorLow = new THREE.Color(0x6fa2ef);
+    skyColorHigh = new THREE.Color(0x2053ff);
+    targetSunColor = new THREE.Color(0xffe5b0);
+    targetSkyColorLow = new THREE.Color(0x6fa2ef);
+    targetSkyColorHigh = new THREE.Color(0x2053ff);
+    static vertexShader = /*glsl*/ `
+    varying vec3 vWorldPosition;
+    void main() {
+      vec4 worldPosition = modelMatrix * vec4(position, 1.0);
+      vWorldPosition = worldPosition.xyz;
+      vec4 pos = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+      gl_Position = pos.xyww;
+    }
+  `;
+    static fragmentShader = /*glsl*/ `
+    precision mediump float;
+    varying vec3 vWorldPosition;
+    uniform float uSunAzimuth;
+    uniform float uSunElevation;
+    uniform vec3 uSunColor;
+    uniform vec3 uSkyColorLow;
+    uniform vec3 uSkyColorHigh;
+    uniform float uSunSize;
+
+    void main() {
+      vec3 direction = normalize(vWorldPosition);
+      vec3 skyColor = mix(uSkyColorLow, uSkyColorHigh, clamp(direction.y * 0.5 + 0.5, 0.0, 1.0));
+      float azimuth = radians(uSunAzimuth);
+      float elevation = radians(uSunElevation);
+      vec3 sunDirection = normalize(vec3(
+        cos(elevation) * sin(azimuth),
+        sin(elevation),
+        cos(elevation) * cos(azimuth)
+      ));
+      float sunIntensity = pow(max(dot(direction, sunDirection), 0.0), 1000.0 / uSunSize);
+      vec3 sunColor = uSunColor * sunIntensity;
+      gl_FragColor = vec4(skyColor + sunColor, 1.0);
+    }
+  `;
+    constructor(parent, options) {
+        this.parent = parent;
+        this.config = options;
+        this.material = new THREE.ShaderMaterial({
+            vertexShader: SkyboxV.vertexShader,
+            fragmentShader: SkyboxV.fragmentShader,
+            uniforms: {
+                uSunAzimuth: { value: 216 },
+                uSunElevation: { value: 24.68698059628387 },
+                uSunColor: { value: new THREE.Color(0xffe5b0) },
+                uSkyColorLow: { value: new THREE.Color(0x6fa2ef) },
+                uSkyColorHigh: { value: new THREE.Color(0x2053ff) },
+                uSunSize: { value: 1 },
+            },
+            side: THREE.BackSide,
+            depthWrite: false,
+            fog: false,
+        });
+        const scale = options.scale ?? 100000;
+        const geometry = new THREE.BoxGeometry(1, 1, 1);
+        this.mesh = new THREE.Mesh(geometry, this.material);
+        this.mesh.scale.setScalar(scale);
+        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 } = this.config;
+        if (!timeSettings.enabled)
+            return;
+        const state = skySystemManager.getState();
+        this.applyTimeState(state, delta);
+    }
+    applyTimeState(state, delta) {
+        const { timeInHours, isDaytime, sunElevation, sunAzimuth } = state;
+        const sunSize = this.config.sunSize ?? 1;
+        const moonSize = this.config.moonSize ?? 1;
+        sampleSkyKeyframes(timeInHours, this.targetSkyColorLow, this.targetSkyColorHigh, this.targetSunColor);
+        const colorLerpSpeed = Math.min(1, 2.0 * (delta !== 0 ? delta : 1));
+        this.sunColor.lerp(this.targetSunColor, colorLerpSpeed);
+        this.skyColorLow.lerp(this.targetSkyColorLow, colorLerpSpeed);
+        this.skyColorHigh.lerp(this.targetSkyColorHigh, colorLerpSpeed);
+        const uniforms = this.material.uniforms;
+        uniforms.uSunAzimuth.value = sunAzimuth;
+        uniforms.uSunElevation.value = sunElevation;
+        uniforms.uSunColor.value.copy(this.sunColor);
+        uniforms.uSkyColorLow.value.copy(this.skyColorLow);
+        uniforms.uSkyColorHigh.value.copy(this.skyColorHigh);
+        uniforms.uSunSize.value = isDaytime ? sunSize : moonSize;
+    }
+    updateConfig(options) {
+        this.config = options;
+        this.mesh.visible = options.visible ?? true;
+        if (options.scale !== undefined) {
+            this.mesh.scale.setScalar(options.scale);
+        }
+        skySystemManager.setTimeSettings(options.timeSettings);
+    }
+    dispose(removeFromScene = true) {
+        this.mesh.geometry.dispose();
+        this.material.dispose();
+        if (removeFromScene)
+            this.parent.remove(this.mesh);
+    }
+}

package/dist/three/StarsV.d.ts

@@ -0,0 +1,24 @@
+import * as THREE from 'three';
+import type { TimeSettings } from "../types/scene3d";
+import type { StarsSettings } from "../types/environment";
+export interface StarsVOptions {
+    settings: StarsSettings;
+    timeSettings?: TimeSettings;
+    sunSystemEnabled?: boolean;
+}
+export declare class StarsV {
+    private parent;
+    private points;
+    private material;
+    private geometry;
+    private config;
+    private elapsed;
+    private opacity;
+    private targetOpacity;
+    constructor(parent: THREE.Object3D, options: StarsVOptions);
+    update(_elapsed: number, delta?: number): void;
+    private applyTimeState;
+    updateConfig(options: StarsVOptions): void;
+    dispose(removeFromScene?: boolean): void;
+}
+//# sourceMappingURL=StarsV.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"StarsV.d.ts","sourceRoot":"","sources":["../../src/three/StarsV.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAC1D,MAAM,WAAW,aAAa;IAC1B,QAAQ,EAAE,aAAa,CAAC;IACxB,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC9B;AA6FD,qBAAa,MAAM;IACf,OAAO,CAAC,MAAM,CAAC;IACf,OAAO,CAAC,MAAM,CAAC;IACf,OAAO,CAAC,QAAQ,CAAC;IACjB,OAAO,CAAC,QAAQ,CAAC;IACjB,OAAO,CAAC,MAAM,CAAC;IACf,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,aAAa,CAAK;gBACd,MAAM,EAAE,KAAK,CAAC,QAAQ,EAAE,OAAO,EAAE,aAAa;IA6B1D,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,GAAE,MAAc,GAAG,IAAI;IAYrD,OAAO,CAAC,cAAc;IAyBtB,YAAY,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI;IAK1C,OAAO,CAAC,eAAe,GAAE,OAAc,GAAG,IAAI;CAMjD"}

package/dist/three/StarsV.js

@@ -0,0 +1,179 @@
+import * as THREE from 'three';
+import { skySystemManager } from '../services/SkySystemManager.js';
+const vertexShader = /*glsl*/ `
+  attribute float size;
+  attribute vec3 color;
+  attribute float phase;
+  attribute float freq;
+
+  varying vec3 vColor;
+
+  uniform float time;
+
+  void main() {
+    vColor = color;
+    vec4 mvPosition = modelViewMatrix * vec4(position, 1.0);
+    float twinkle = sin(time * freq + phase) * 0.2 + 0.8;
+    gl_PointSize = size * twinkle;
+    vec4 pos = projectionMatrix * mvPosition;
+    pos.z = pos.w * 0.999999;
+    gl_Position = pos;
+  }
+`;
+const fragmentShader = /*glsl*/ `
+  varying vec3 vColor;
+  uniform float opacity;
+  uniform vec3 uColor;
+  uniform vec3 targetColor;
+  uniform float colorMix;
+
+  void main() {
+    vec2 center = gl_PointCoord - vec2(0.5);
+    float dist = length(center) * 2.0;
+    float core = (1.0 - smoothstep(0.0, 0.2, dist)) * 0.8;
+    float glow = (1.0 - smoothstep(0.2, 0.5, dist)) * 0.1;
+    float brightness = core + glow;
+    vec3 transitionColor = mix(uColor, targetColor, colorMix);
+    vec3 finalColor = mix(vec3(1.0), transitionColor * vColor, 0.8) * 0.6;
+    gl_FragColor = vec4(finalColor, brightness * opacity);
+  }
+`;
+function buildGeometry(count) {
+    const halfCount = Math.floor(count / 2);
+    const geometry = new THREE.BufferGeometry();
+    const topPositions = new Float32Array(halfCount * 3);
+    for (let i = 0; i < halfCount; i++) {
+        const u = Math.random();
+        const v = Math.random() * 0.5 + 0.5;
+        const theta = 2 * Math.PI * u;
+        const phi = Math.acos(2 * v - 1);
+        topPositions.set([Math.sin(phi) * Math.cos(theta), Math.cos(phi), Math.sin(phi) * Math.sin(theta)], i * 3);
+    }
+    const positions = new Float32Array(halfCount * 6);
+    positions.set(topPositions, 0);
+    for (let i = 0; i < halfCount; i++) {
+        positions.set([topPositions[i * 3], -topPositions[i * 3 + 1], topPositions[i * 3 + 2]], (i + halfCount) * 3);
+    }
+    const colors = new Float32Array(halfCount * 3);
+    for (let i = 0; i < halfCount; i++) {
+        const vv = Math.random();
+        const c = vv < 0.15 ? [0.8, 0.85, 1.0] : vv < 0.3 ? [1.0, 0.95, 0.8] : [1.0, 1.0, 1.0];
+        colors.set(c, i * 3);
+    }
+    const mc = new Float32Array(halfCount * 6);
+    mc.set(colors, 0);
+    mc.set(colors, colors.length);
+    const sizes = new Float32Array(halfCount);
+    for (let i = 0; i < halfCount; i++) {
+        const vv = Math.random();
+        sizes[i] = vv < 0.01 ? 40 + Math.random() * 20 : vv < 0.05 ? 25 + Math.random() * 15 : vv < 0.2 ? 15 + Math.random() * 10 : 5 + Math.random() * 5;
+    }
+    const ms = new Float32Array(halfCount * 2);
+    ms.set(sizes, 0);
+    ms.set(sizes, sizes.length);
+    const phases = new Float32Array(halfCount);
+    for (let i = 0; i < halfCount; i++)
+        phases[i] = Math.random() * Math.PI * 2;
+    const mp = new Float32Array(halfCount * 2);
+    mp.set(phases, 0);
+    mp.set(phases, phases.length);
+    const freqs = new Float32Array(halfCount);
+    for (let i = 0; i < halfCount; i++)
+        freqs[i] = 1.0 + Math.random() * 2.0;
+    const mf = new Float32Array(halfCount * 2);
+    mf.set(freqs, 0);
+    mf.set(freqs, freqs.length);
+    geometry.setAttribute('position', new THREE.BufferAttribute(positions, 3));
+    geometry.setAttribute('color', new THREE.BufferAttribute(mc, 3));
+    geometry.setAttribute('size', new THREE.BufferAttribute(ms, 1));
+    geometry.setAttribute('phase', new THREE.BufferAttribute(mp, 1));
+    geometry.setAttribute('freq', new THREE.BufferAttribute(mf, 1));
+    return geometry;
+}
+export class StarsV {
+    parent;
+    points;
+    material;
+    geometry;
+    config;
+    elapsed = 0;
+    opacity = 1;
+    targetOpacity = 1;
+    constructor(parent, options) {
+        this.parent = parent;
+        this.config = options;
+        const { settings } = options;
+        this.geometry = buildGeometry(settings.config.count);
+        this.material = new THREE.ShaderMaterial({
+            vertexShader,
+            fragmentShader,
+            uniforms: {
+                time: { value: 0 },
+                opacity: { value: 1 },
+                uColor: { value: new THREE.Color(settings.config.color) },
+                targetColor: { value: new THREE.Color(settings.config.color) },
+                colorMix: { value: 0 },
+            },
+            transparent: true,
+            depthWrite: false,
+            blending: THREE.AdditiveBlending,
+        });
+        this.points = new THREE.Points(this.geometry, this.material);
+        this.points.visible = settings.meshSettings.visible;
+        this.points.renderOrder = -1;
+        this.points.frustumCulled = false;
+        const s = typeof settings.meshSettings.scale === 'number' ? settings.meshSettings.scale : settings.meshSettings.scale[0];
+        this.points.scale.setScalar(s);
+        parent.add(this.points);
+        if (options.timeSettings)
+            skySystemManager.setTimeSettings(options.timeSettings);
+    }
+    update(_elapsed, delta = 0.016) {
+        if (!this.points.visible)
+            return;
+        const { settings, timeSettings, sunSystemEnabled } = this.config;
+        this.elapsed += delta;
+        this.points.rotation.y += settings.config.rotateSpeed * 0.01;
+        this.material.uniforms.time.value = this.elapsed;
+        if (timeSettings?.enabled && sunSystemEnabled) {
+            const state = skySystemManager.getState();
+            this.applyTimeState(state, delta);
+        }
+    }
+    applyTimeState(state, delta) {
+        const { normalizedTime, isDaytime, autoAnimate } = state;
+        if (!autoAnimate)
+            return;
+        if (!isDaytime) {
+            this.targetOpacity = 1;
+        }
+        else {
+            const sunriseEnd = 0.15;
+            const sunsetStart = 0.85;
+            if (normalizedTime <= sunriseEnd) {
+                this.targetOpacity = 1 - normalizedTime / sunriseEnd;
+            }
+            else if (normalizedTime >= sunsetStart) {
+                this.targetOpacity = (normalizedTime - sunsetStart) / (1 - sunsetStart);
+            }
+            else {
+                this.targetOpacity = 0;
+            }
+        }
+        const lerpSpeed = Math.min(1, 1.5 * (delta || 1));
+        this.opacity += (this.targetOpacity - this.opacity) * lerpSpeed;
+        this.material.uniforms.opacity.value = this.opacity;
+        this.points.visible = this.opacity > 0.01;
+    }
+    updateConfig(options) {
+        this.config = options;
+        if (options.timeSettings)
+            skySystemManager.setTimeSettings(options.timeSettings);
+    }
+    dispose(removeFromScene = true) {
+        this.geometry.dispose();
+        this.material.dispose();
+        if (removeFromScene)
+            this.parent.remove(this.points);
+    }
+}

package/dist/three/SunLightV.d.ts

@@ -0,0 +1,26 @@
+import * as THREE from 'three';
+import type { TimeSettings } from "../types/scene3d";
+export interface SunLightVOptions {
+    timeSettings: TimeSettings;
+    visible?: boolean;
+    targetPosition?: [number, number, number];
+    shadowDistance?: number;
+    intensity?: number;
+    castShadow?: boolean;
+    shadowMapSize?: number;
+}
+export declare class SunLightV {
+    private parent;
+    private light;
+    private config;
+    private colorRef;
+    private targetColor;
+    private intensityVal;
+    private targetIntensity;
+    constructor(parent: THREE.Object3D, options: SunLightVOptions);
+    update(_elapsed: number, delta?: number): void;
+    private applyTimeState;
+    updateConfig(options: SunLightVOptions): void;
+    dispose(removeFromScene?: boolean): void;
+}
+//# sourceMappingURL=SunLightV.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SunLightV.d.ts","sourceRoot":"","sources":["../../src/three/SunLightV.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACrD,MAAM,WAAW,gBAAgB;IAC7B,YAAY,EAAE,YAAY,CAAC;IAC3B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,cAAc,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1C,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,CAAC;CAC1B;AAaD,qBAAa,SAAS;IAClB,OAAO,CAAC,MAAM,CAAC;IACf,OAAO,CAAC,KAAK,CAAC;IACd,OAAO,CAAC,MAAM,CAAC;IACf,OAAO,CAAC,QAAQ,CAA6B;IAC7C,OAAO,CAAC,WAAW,CAA6B;IAChD,OAAO,CAAC,YAAY,CAAK;IACzB,OAAO,CAAC,eAAe,CAAK;gBAChB,MAAM,EAAE,KAAK,CAAC,QAAQ,EAAE,OAAO,EAAE,gBAAgB;IAqB7D,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,GAAE,MAAc,GAAG,IAAI;IASrD,OAAO,CAAC,cAAc;IA4BtB,YAAY,CAAC,OAAO,EAAE,gBAAgB,GAAG,IAAI;IAK7C,OAAO,CAAC,eAAe,GAAE,OAAc,GAAG,IAAI;CAMjD"}

package/dist/three/SunLightV.js

@@ -0,0 +1,90 @@
+import * as THREE from 'three';
+import { skySystemManager } from '../services/SkySystemManager.js';
+const COLORS = {
+    white: new THREE.Color(0xffffff),
+    orange: new THREE.Color(0xff4500),
+    moon: new THREE.Color(0xe6e8fa),
+};
+const MAX_ELEVATION = 42;
+const SUNRISE = 6;
+const SUNSET = 21;
+const DARKNESS_START = 20.42;
+const DARKNESS_END = 6.58;
+export class SunLightV {
+    parent;
+    light;
+    config;
+    colorRef = new THREE.Color(0xffe5b0);
+    targetColor = new THREE.Color(0xffe5b0);
+    intensityVal = 1;
+    targetIntensity = 1;
+    constructor(parent, options) {
+        this.parent = parent;
+        this.config = options;
+        const shadowMapSize = options.shadowMapSize ?? 2048;
+        this.light = new THREE.DirectionalLight(0xffe5b0, 1);
+        this.light.castShadow = options.castShadow ?? true;
+        this.light.shadow.mapSize.set(shadowMapSize, shadowMapSize);
+        this.light.shadow.camera.left = -50;
+        this.light.shadow.camera.right = 50;
+        this.light.shadow.camera.top = 50;
+        this.light.shadow.camera.bottom = -50;
+        this.light.shadow.camera.near = 0.5;
+        this.light.shadow.camera.far = 1000;
+        this.light.shadow.normalBias = 0.02;
+        this.light.shadow.bias = 0.000002;
+        this.light.shadow.radius = 2;
+        this.light.visible = options.visible ?? true;
+        parent.add(this.light);
+        parent.add(this.light.target);
+        skySystemManager.setTimeSettings(options.timeSettings);
+    }
+    update(_elapsed, delta = 0.016) {
+        if (!this.light.visible)
+            return;
+        const { timeSettings } = this.config;
+        if (!timeSettings.enabled)
+            return;
+        const state = skySystemManager.getState();
+        this.applyTimeState(state, delta);
+    }
+    applyTimeState(state, delta) {
+        const { timeInHours, normalizedTime, isDaytime, sunDirection, sunElevation } = state;
+        const targetPos = this.config.targetPosition ?? [0, 0, 0];
+        const shadowDistance = this.config.shadowDistance ?? 300;
+        const intensityMultiplier = this.config.intensity ?? 1;
+        const isInDarkTransition = (timeInHours >= DARKNESS_START && timeInHours <= SUNSET) ||
+            (timeInHours >= SUNRISE && timeInHours <= DARKNESS_END);
+        if (isDaytime) {
+            const normalizedElevation = Math.min(sunElevation / MAX_ELEVATION, 1);
+            const t = Math.pow(1 - normalizedElevation, 3);
+            this.targetColor.lerpColors(COLORS.white, COLORS.orange, t);
+            this.targetIntensity = isInDarkTransition
+                ? 0.1
+                : Math.min(40, Math.pow(normalizedElevation, 1.2) * 4);
+        }
+        else {
+            this.targetColor.copy(COLORS.moon).multiplyScalar(1.8);
+            this.targetIntensity = 0.5;
+        }
+        const lerpSpeed = Math.min(1, 2.0 * (delta || 1));
+        this.colorRef.lerp(this.targetColor, lerpSpeed);
+        this.intensityVal += (this.targetIntensity - this.intensityVal) * lerpSpeed;
+        this.light.position.set(targetPos[0] + sunDirection.x * shadowDistance, targetPos[1] + sunDirection.y * shadowDistance, targetPos[2] + sunDirection.z * shadowDistance);
+        this.light.target.position.set(targetPos[0], targetPos[1], targetPos[2]);
+        this.light.target.updateMatrixWorld();
+        this.light.intensity = this.intensityVal * intensityMultiplier;
+        this.light.color.copy(this.colorRef);
+    }
+    updateConfig(options) {
+        this.config = options;
+        this.light.visible = options.visible ?? true;
+        skySystemManager.setTimeSettings(options.timeSettings);
+    }
+    dispose(removeFromScene = true) {
+        if (removeFromScene) {
+            this.parent.remove(this.light);
+            this.parent.remove(this.light.target);
+        }
+    }
+}

package/dist/three/Text2DV.d.ts

@@ -0,0 +1,25 @@
+import * as THREE from 'three';
+import type { Text2DConfig } from "../types/text";
+export interface Text2DVOptions {
+    text: string;
+    config?: Partial<Text2DConfig>;
+    color?: string;
+    opacity?: number;
+    position?: [number, number, number];
+    rotation?: [number, number, number];
+    canvasWidth?: number;
+    canvasHeight?: number;
+}
+export declare class Text2DV {
+    private parent;
+    private group;
+    private mesh;
+    private texture;
+    private options;
+    constructor(parent: THREE.Object3D, options: Text2DVOptions);
+    private build;
+    update(_elapsed: number, _delta?: number): void;
+    updateConfig(options: Text2DVOptions): void;
+    dispose(removeFromScene?: boolean): void;
+}
+//# sourceMappingURL=Text2DV.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Text2DV.d.ts","sourceRoot":"","sources":["../../src/three/Text2DV.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAClD,MAAM,WAAW,cAAc;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,OAAO,CAAC,YAAY,CAAC,CAAC;IAC/B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;CACzB;AAGD,qBAAa,OAAO;IAChB,OAAO,CAAC,MAAM,CAAC;IACf,OAAO,CAAC,KAAK,CAAC;IACd,OAAO,CAAC,IAAI,CAAQ;IACpB,OAAO,CAAC,OAAO,CAAQ;IACvB,OAAO,CAAC,OAAO,CAAC;gBACJ,MAAM,EAAE,KAAK,CAAC,QAAQ,EAAE,OAAO,EAAE,cAAc;IAW3D,OAAO,CAAC,KAAK;IA6Bb,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI;IAC/C,YAAY,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI;IAK3C,OAAO,CAAC,eAAe,GAAE,OAAc,GAAG,IAAI;CAYjD"}

package/dist/three/Text2DV.js

@@ -0,0 +1,66 @@
+import * as THREE from 'three';
+export class Text2DV {
+    parent;
+    group;
+    mesh = null;
+    texture = null;
+    options;
+    constructor(parent, options) {
+        this.parent = parent;
+        this.options = options;
+        this.group = new THREE.Group();
+        if (options.position)
+            this.group.position.set(...options.position);
+        if (options.rotation)
+            this.group.rotation.set(...options.rotation);
+        parent.add(this.group);
+        this.build();
+    }
+    build() {
+        const { text, config = {}, color = '#ffffff', opacity = 1, canvasWidth = 512, canvasHeight = 128, } = this.options;
+        const canvas = document.createElement('canvas');
+        canvas.width = canvasWidth;
+        canvas.height = canvasHeight;
+        const ctx = canvas.getContext('2d');
+        const pxSize = Math.round(canvasHeight * 0.5);
+        ctx.font = `${pxSize}px sans-serif`;
+        ctx.textAlign = config.textAlign ?? 'center';
+        ctx.textBaseline = 'middle';
+        ctx.clearRect(0, 0, canvasWidth, canvasHeight);
+        ctx.fillStyle = color;
+        ctx.globalAlpha = opacity;
+        ctx.fillText(text, canvasWidth / 2, canvasHeight / 2);
+        this.texture = new THREE.CanvasTexture(canvas);
+        const fontSize = config.fontSize ?? 0.5;
+        const aspect = canvasWidth / canvasHeight;
+        const planeH = fontSize * 2;
+        const planeW = planeH * aspect;
+        const geo = new THREE.PlaneGeometry(planeW, planeH);
+        const mat = new THREE.MeshBasicMaterial({
+            map: this.texture,
+            transparent: true,
+            side: THREE.DoubleSide,
+            depthWrite: false,
+        });
+        this.mesh = new THREE.Mesh(geo, mat);
+        this.group.add(this.mesh);
+    }
+    update(_elapsed, _delta) { }
+    updateConfig(options) {
+        this.dispose(false);
+        this.options = options;
+        this.build();
+    }
+    dispose(removeFromScene = true) {
+        this.texture?.dispose();
+        if (this.mesh) {
+            this.mesh.geometry.dispose();
+            this.mesh.material.dispose();
+        }
+        this.group.clear();
+        if (removeFromScene)
+            this.parent.remove(this.group);
+        this.mesh = null;
+        this.texture = null;
+    }
+}

package/dist/three/Text3DV.d.ts

@@ -0,0 +1,22 @@
+import * as THREE from 'three';
+import type { Text3DConfig } from "../types/text";
+export interface Text3DVOptions {
+    text: string;
+    config: Text3DConfig;
+    color?: string;
+    opacity?: number;
+    position?: [number, number, number];
+    rotation?: [number, number, number];
+}
+export declare class Text3DV {
+    private parent;
+    private group;
+    private letters;
+    private options;
+    constructor(parent: THREE.Object3D, options: Text3DVOptions);
+    private build;
+    update(_elapsed: number, _delta?: number): void;
+    updateConfig(options: Text3DVOptions): void;
+    dispose(removeFromScene?: boolean): void;
+}
+//# sourceMappingURL=Text3DV.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Text3DV.d.ts","sourceRoot":"","sources":["../../src/three/Text3DV.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAClD,MAAM,WAAW,cAAc;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,YAAY,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;CACvC;AAGD,qBAAa,OAAO;IAChB,OAAO,CAAC,MAAM,CAAC;IACf,OAAO,CAAC,KAAK,CAAC;IACd,OAAO,CAAC,OAAO,CAAM;IACrB,OAAO,CAAC,OAAO,CAAC;gBACJ,MAAM,EAAE,KAAK,CAAC,QAAQ,EAAE,OAAO,EAAE,cAAc;IAW3D,OAAO,CAAC,KAAK;IAWb,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI;IAC/C,YAAY,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI;IAK3C,OAAO,CAAC,eAAe,GAAE,OAAc,GAAG,IAAI;CAOjD"}

package/dist/three/Text3DV.js

@@ -0,0 +1,43 @@
+import * as THREE from 'three';
+import { LetterV } from './LetterV.js';
+export class Text3DV {
+    parent;
+    group;
+    letters = [];
+    options;
+    constructor(parent, options) {
+        this.parent = parent;
+        this.options = options;
+        this.group = new THREE.Group();
+        if (options.position)
+            this.group.position.set(...options.position);
+        if (options.rotation)
+            this.group.rotation.set(...options.rotation);
+        parent.add(this.group);
+        this.build();
+    }
+    build() {
+        const { text, config, color = '#ffffff', opacity = 1 } = this.options;
+        const size = config.size ?? 1;
+        const spacing = size * (0.6 + (config.letterSpacing ?? 0));
+        const totalWidth = (text.length - 1) * spacing;
+        text.split('').forEach((char, i) => {
+            const x = i * spacing - totalWidth / 2;
+            const lv = new LetterV(this.group, { char, config, color, opacity, position: [x, 0, 0] });
+            this.letters.push(lv);
+        });
+    }
+    update(_elapsed, _delta) { }
+    updateConfig(options) {
+        this.dispose(false);
+        this.options = options;
+        this.build();
+    }
+    dispose(removeFromScene = true) {
+        this.letters.forEach(l => l.dispose());
+        this.letters = [];
+        this.group.clear();
+        if (removeFromScene)
+            this.parent.remove(this.group);
+    }
+}

package/dist/three/effects/AuraEffectV.d.ts

@@ -0,0 +1,15 @@
+import * as THREE from 'three';
+import type { AuraConfig } from "../../types/generativeEffects";
+export declare class AuraEffectV {
+    private scene;
+    private group;
+    private materials;
+    private config;
+    private boundingRadius;
+    constructor(scene: THREE.Scene, config: AuraConfig, boundingRadius?: number);
+    private build;
+    update(elapsed: number, _delta?: number): void;
+    updateConfig(config: AuraConfig, boundingRadius?: number): void;
+    dispose(removeFromScene?: boolean): void;
+}
+//# sourceMappingURL=AuraEffectV.d.ts.map

package/dist/three/effects/AuraEffectV.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AuraEffectV.d.ts","sourceRoot":"","sources":["../../../src/three/effects/AuraEffectV.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AA+EhE,qBAAa,WAAW;IACpB,OAAO,CAAC,KAAK,CAAC;IACd,OAAO,CAAC,KAAK,CAAC;IACd,OAAO,CAAC,SAAS,CAAM;IACvB,OAAO,CAAC,MAAM,CAAC;IACf,OAAO,CAAC,cAAc,CAAC;gBACX,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,cAAc,GAAE,MAAU;IAQ9E,OAAO,CAAC,KAAK;IAkCb,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,GAAE,MAAc,GAAG,IAAI;IAIrD,YAAY,CAAC,MAAM,EAAE,UAAU,EAAE,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI;IAO/D,OAAO,CAAC,eAAe,GAAE,OAAc,GAAG,IAAI;CAYjD"}