@3driseai/3drise-core 1.0.1

package/dist/services/SkySystemManager.d.ts

@@ -0,0 +1,57 @@
+import * as THREE from 'three';
+import type { TimeSettings } from "../types/scene3d";
+export type TimeOfDayLabel = 'Sunrise' | 'Midday' | 'Sunset' | 'Nighttime';
+export interface SkyTimeState {
+    timeInHours: number;
+    normalizedTime: number;
+    isDaytime: boolean;
+    timeOfDay: TimeOfDayLabel;
+    sunElevation: number;
+    sunAzimuth: number;
+    sunDirection: THREE.Vector3;
+    delta: number;
+    elapsedTime: number;
+    autoAnimate: boolean;
+}
+export declare class SkySystemManager {
+    private static instance;
+    private timeInHours;
+    private normalizedTime;
+    private isDaytime;
+    private timeOfDay;
+    private elapsedTime;
+    private delta;
+    private sunElevation;
+    private sunAzimuth;
+    private sunDirection;
+    private enabled;
+    private timescale;
+    private autoAnimate;
+    private syncWithRealTime;
+    private lastSyncedMinute;
+    private onTimeSync;
+    constructor();
+    static getInstance(): SkySystemManager;
+    static resetInstance(): void;
+    setTimeSettings(settings: TimeSettings): void;
+    setOnTimeSync(callback: ((timeOfDay: number) => void) | null): void;
+    setTime(hours: number, minutes?: number): void;
+    tick(delta: number): void;
+    getState(): SkyTimeState;
+    getStateByTime(timeOfDay: number): SkyTimeState;
+    getTime(): Date;
+    getTimeOfDay(): TimeOfDayLabel;
+    getSunDirection(): THREE.Vector3;
+    getTimeInHours(): number;
+    isEnabled(): boolean;
+    isAutoAnimating(): boolean;
+    private advanceTime;
+    private syncToRealTime;
+    private recalculateState;
+    private calculateTimeState;
+    private transformAzimuth;
+    private updateSunDirection;
+}
+export declare const skySystemManager: SkySystemManager;
+export default SkySystemManager;
+//# sourceMappingURL=SkySystemManager.d.ts.map

package/dist/services/SkySystemManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SkySystemManager.d.ts","sourceRoot":"","sources":["../../src/services/SkySystemManager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACrD,MAAM,MAAM,cAAc,GAAG,SAAS,GAAG,QAAQ,GAAG,QAAQ,GAAG,WAAW,CAAC;AAE3E,MAAM,WAAW,YAAY;IACzB,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,OAAO,CAAC;IACnB,SAAS,EAAE,cAAc,CAAC;IAC1B,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,KAAK,CAAC,OAAO,CAAC;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,OAAO,CAAC;CACxB;AAMD,qBAAa,gBAAgB;IACzB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAQ;IAC/B,OAAO,CAAC,WAAW,CAAM;IACzB,OAAO,CAAC,cAAc,CAAO;IAC7B,OAAO,CAAC,SAAS,CAAQ;IACzB,OAAO,CAAC,SAAS,CAAY;IAC7B,OAAO,CAAC,WAAW,CAAK;IACxB,OAAO,CAAC,KAAK,CAAK;IAClB,OAAO,CAAC,YAAY,CAAM;IAC1B,OAAO,CAAC,UAAU,CAAO;IACzB,OAAO,CAAC,YAAY,CAA8B;IAClD,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,SAAS,CAAM;IACvB,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,gBAAgB,CAAS;IACjC,OAAO,CAAC,gBAAgB,CAAM;IAC9B,OAAO,CAAC,UAAU,CAAQ;;IAI1B,MAAM,CAAC,WAAW,IAAI,gBAAgB;IAMtC,MAAM,CAAC,aAAa,IAAI,IAAI;IAG5B,eAAe,CAAC,QAAQ,EAAE,YAAY,GAAG,IAAI;IAa7C,aAAa,CAAC,QAAQ,EAAE,CAAC,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC,GAAG,IAAI,GAAG,IAAI;IAGnE,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,GAAE,MAAU,GAAG,IAAI;IAIjD,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAezB,QAAQ,IAAI,YAAY;IAcxB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,YAAY;IAmB/C,OAAO,IAAI,IAAI;IAKf,YAAY,IAAI,cAAc;IAG9B,eAAe,IAAI,KAAK,CAAC,OAAO;IAGhC,cAAc,IAAI,MAAM;IAGxB,SAAS,IAAI,OAAO;IAGpB,eAAe,IAAI,OAAO;IAG1B,OAAO,CAAC,WAAW;IAUnB,OAAO,CAAC,cAAc;IAUtB,OAAO,CAAC,gBAAgB;IASxB,OAAO,CAAC,kBAAkB;IA0B1B,OAAO,CAAC,gBAAgB;IAGxB,OAAO,CAAC,kBAAkB;CAQ7B;AACD,eAAO,MAAM,gBAAgB,EAAE,gBAAiD,CAAC;AACjF,eAAe,gBAAgB,CAAC"}

package/dist/services/SkySystemManager.js

@@ -0,0 +1,190 @@
+import * as THREE from 'three';
+const SUNRISE = 6;
+const SUNSET = 21;
+const MAX_ELEVATION = 42;
+export class SkySystemManager {
+    static instance = null;
+    timeInHours = 12;
+    normalizedTime = 0.5;
+    isDaytime = true;
+    timeOfDay = 'Midday';
+    elapsedTime = 0;
+    delta = 0;
+    sunElevation = 37;
+    sunAzimuth = 270;
+    sunDirection = new THREE.Vector3(0, 1, 0);
+    enabled = false;
+    timescale = 60;
+    autoAnimate = false;
+    syncWithRealTime = false;
+    lastSyncedMinute = -1;
+    onTimeSync = null;
+    constructor() {
+        this.updateSunDirection();
+    }
+    static getInstance() {
+        if (!SkySystemManager.instance) {
+            SkySystemManager.instance = new SkySystemManager();
+        }
+        return SkySystemManager.instance;
+    }
+    static resetInstance() {
+        SkySystemManager.instance = null;
+    }
+    setTimeSettings(settings) {
+        this.enabled = settings.enabled;
+        this.timescale = settings.timescale;
+        this.autoAnimate = settings.autoAnimate;
+        this.syncWithRealTime = settings.syncWithRealTime;
+        if (this.syncWithRealTime) {
+            this.syncToRealTime();
+        }
+        if (Math.abs(this.timeInHours - settings.timeOfDay) > 0.01) {
+            this.timeInHours = settings.timeOfDay;
+            this.recalculateState();
+        }
+    }
+    setOnTimeSync(callback) {
+        this.onTimeSync = callback;
+    }
+    setTime(hours, minutes = 0) {
+        this.timeInHours = hours + minutes / 60;
+        this.recalculateState();
+    }
+    tick(delta) {
+        if (!this.enabled)
+            return;
+        // console.log(delta)
+        // this.delta = delta;
+        this.elapsedTime += delta;
+        if (this.syncWithRealTime) {
+            this.syncToRealTime();
+        }
+        else if (this.autoAnimate && this.timescale > 0) {
+            // console.log(delta)
+            this.advanceTime(delta);
+        }
+        this.recalculateState();
+    }
+    getState() {
+        return {
+            timeInHours: this.timeInHours,
+            normalizedTime: this.normalizedTime,
+            isDaytime: this.isDaytime,
+            timeOfDay: this.timeOfDay,
+            sunElevation: this.sunElevation,
+            sunAzimuth: this.transformAzimuth(this.sunAzimuth),
+            sunDirection: this.sunDirection,
+            delta: this.delta,
+            elapsedTime: this.elapsedTime,
+            autoAnimate: this.autoAnimate,
+        };
+    }
+    getStateByTime(timeOfDay) {
+        const state = this.calculateTimeState(timeOfDay);
+        const el = THREE.MathUtils.degToRad(state.sunElevation);
+        const az = THREE.MathUtils.degToRad(this.transformAzimuth(state.sunAzimuth));
+        const distance = 0.5;
+        const sunDirection = new THREE.Vector3(distance * Math.cos(el) * Math.sin(az), distance * Math.sin(el), distance * Math.cos(el) * Math.cos(az)).normalize();
+        return {
+            timeInHours: timeOfDay,
+            normalizedTime: state.normalizedTime,
+            isDaytime: state.isDaytime,
+            timeOfDay: state.timeOfDay,
+            sunElevation: state.sunElevation,
+            sunAzimuth: this.transformAzimuth(state.sunAzimuth),
+            sunDirection,
+            delta: 0,
+            elapsedTime: this.elapsedTime,
+            autoAnimate: this.autoAnimate,
+        };
+    }
+    getTime() {
+        const date = new Date();
+        date.setHours(Math.floor(this.timeInHours), (this.timeInHours % 1) * 60, 0, 0);
+        return date;
+    }
+    getTimeOfDay() {
+        return this.timeOfDay;
+    }
+    getSunDirection() {
+        return this.sunDirection.clone();
+    }
+    getTimeInHours() {
+        return this.timeInHours;
+    }
+    isEnabled() {
+        return this.enabled;
+    }
+    isAutoAnimating() {
+        return this.autoAnimate;
+    }
+    advanceTime(delta) {
+        const hoursPerSecond = this.timescale / 60;
+        this.timeInHours += hoursPerSecond * delta;
+        if (this.timeInHours >= 24) {
+            this.timeInHours -= 24;
+        }
+        else if (this.timeInHours < 0) {
+            this.timeInHours += 24;
+        }
+    }
+    syncToRealTime() {
+        const now = new Date();
+        const currentMinute = now.getHours() * 60 + now.getMinutes();
+        this.timeInHours =
+            now.getHours() + now.getMinutes() / 60 + now.getSeconds() / 3600;
+        if (currentMinute !== this.lastSyncedMinute) {
+            this.lastSyncedMinute = currentMinute;
+            this.onTimeSync?.(Math.round(this.timeInHours * 100) / 100);
+        }
+    }
+    recalculateState() {
+        const state = this.calculateTimeState(this.timeInHours);
+        this.normalizedTime = state.normalizedTime;
+        this.isDaytime = state.isDaytime;
+        this.timeOfDay = state.timeOfDay;
+        this.sunElevation = state.sunElevation;
+        this.sunAzimuth = state.sunAzimuth;
+        this.updateSunDirection();
+    }
+    calculateTimeState(timeInHours) {
+        const isDaytime = timeInHours >= SUNRISE && timeInHours <= SUNSET;
+        let normalizedTime;
+        if (isDaytime) {
+            normalizedTime = (timeInHours - SUNRISE) / (SUNSET - SUNRISE);
+        }
+        else {
+            const nightHour = timeInHours >= SUNSET ? timeInHours : timeInHours + 24;
+            normalizedTime = (nightHour - SUNSET) / (24 - SUNSET + SUNRISE);
+        }
+        let sunElevation = Math.cos(Math.PI * (normalizedTime - 0.5)) * MAX_ELEVATION - 5;
+        const sunAzimuth = 180 + 180 * normalizedTime;
+        if (!isDaytime) {
+            sunElevation *= 0.5;
+        }
+        let timeOfDay = 'Nighttime';
+        if (isDaytime) {
+            if (normalizedTime <= 0.25)
+                timeOfDay = 'Sunrise';
+            else if (normalizedTime <= 0.75)
+                timeOfDay = 'Midday';
+            else
+                timeOfDay = 'Sunset';
+        }
+        return { normalizedTime, isDaytime, timeOfDay, sunElevation, sunAzimuth };
+    }
+    transformAzimuth(rawAzimuth) {
+        return ((270 - rawAzimuth) % 360) - 180;
+    }
+    updateSunDirection() {
+        const el = THREE.MathUtils.degToRad(this.sunElevation);
+        const az = THREE.MathUtils.degToRad(this.transformAzimuth(this.sunAzimuth));
+        const distance = 0.5;
+        this.sunDirection
+            .set(distance * Math.cos(el) * Math.sin(az), distance * Math.sin(el), distance * Math.cos(el) * Math.cos(az))
+            .normalize();
+    }
+}
+export const skySystemManager = SkySystemManager.getInstance();
+export default SkySystemManager;

package/dist/services/TextureResolver.d.ts

@@ -0,0 +1,51 @@
+import { Texture } from "three";
+declare class TextureResolverService {
+    private cache;
+    /**
+     * Resolve a single texture URL to a Three.js Texture object.
+     * Returns cached texture if the same URL was loaded before.
+     */
+    resolve(url: string): Promise<Texture>;
+    /**
+     * Create a procedural noise texture.
+     */
+    resolveNoise(type?: string): Texture;
+    /**
+     * Resolve ALL texture properties in a settings object based on registry info.
+     *
+     * Uses MaterialRegistryAPI.getTextureProperties(variant) to determine which keys
+     * are texture slots, then resolves any string URLs to Texture objects.
+     *
+     * - String values on texture keys → loaded as Texture via loadTextureAsync
+     * - null values → left as null (no texture)
+     * - Already-Texture values → left as-is
+     * - Non-texture keys → left untouched
+     */
+    resolveSettings(variant: string, settings: Record<string, any>): Promise<Record<string, any>>;
+    /**
+     * Check if a texture URL is already cached.
+     */
+    isCached(url: string): boolean;
+    /**
+     * Get a cached texture without loading. Returns undefined if not cached.
+     */
+    getCached(url: string): Texture | undefined;
+    /**
+     * Clear the texture cache and dispose all cached textures.
+     */
+    clearCache(): void;
+    /**
+     * Remove a specific URL from the cache and dispose its texture.
+     */
+    evict(url: string): void;
+    /**
+     * Get cache statistics.
+     */
+    getStats(): {
+        cacheSize: number;
+        cachedUrls: string[];
+    };
+}
+export declare const textureResolver: TextureResolverService;
+export { TextureResolverService };
+//# sourceMappingURL=TextureResolver.d.ts.map

package/dist/services/TextureResolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TextureResolver.d.ts","sourceRoot":"","sources":["../../src/services/TextureResolver.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAEhC,cAAM,sBAAsB;IAExB,OAAO,CAAC,KAAK,CAAa;IAC1B;;;OAGG;IACG,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAe5C;;OAEG;IACH,YAAY,CAAC,IAAI,GAAE,MAAiB,GAAG,OAAO;IAG9C;;;;;;;;;;OAUG;IACG,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAqCnG;;OAEG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAG9B;;OAEG;IACH,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS;IAG3C;;OAEG;IACH,UAAU,IAAI,IAAI;IAMlB;;OAEG;IACH,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAOxB;;OAEG;IACH,QAAQ,IAAI;QACA,SAAS,EAAE,MAAM,CAAC;QAClB,UAAU,EAAE,MAAM,EAAE,CAAC;KACxB;CAMZ;AAED,eAAO,MAAM,eAAe,EAAE,sBAAqD,CAAC;AAEpF,OAAO,EAAE,sBAAsB,EAAE,CAAC"}

package/dist/services/TextureResolver.js

@@ -0,0 +1,136 @@
+// =============================================================================
+// TEXTURE RESOLVER - Registry-Driven Texture Resolution Service
+// =============================================================================
+//
+// Single source of truth for resolving texture URLs to Three.js Texture objects.
+// Uses MaterialRegistry's textureProperties to know which settings keys are textures,
+// eliminating heuristic guessing scattered across the codebase.
+//
+// Usage:
+//   const resolved = await textureResolver.resolveSettings('Standard', materialSettings);
+//   // All texture URL strings in resolved are now Texture objects
+//
+import { loadTextureAsync } from '../utils/loadingManager.js';
+import { NoiseGenerator } from './NoiseGenerator.js';
+import MaterialRegistryAPI from '../services/MaterialRegistry.js';
+class TextureResolverService {
+    // Cache: URL string → loaded Texture
+    cache = new Map();
+    /**
+     * Resolve a single texture URL to a Three.js Texture object.
+     * Returns cached texture if the same URL was loaded before.
+     */
+    async resolve(url) {
+        // Return cached texture if available
+        const cached = this.cache.get(url);
+        if (cached)
+            return cached;
+        try {
+            const texture = await loadTextureAsync(url);
+            this.cache.set(url, texture);
+            return texture;
+        }
+        catch (error) {
+            console.error(`[TextureResolver] Failed to load texture: ${url}`, error);
+            throw error;
+        }
+    }
+    /**
+     * Create a procedural noise texture.
+     */
+    resolveNoise(type = 'perlin') {
+        return NoiseGenerator.createNoiseTexture(512, 512, type);
+    }
+    /**
+     * Resolve ALL texture properties in a settings object based on registry info.
+     *
+     * Uses MaterialRegistryAPI.getTextureProperties(variant) to determine which keys
+     * are texture slots, then resolves any string URLs to Texture objects.
+     *
+     * - String values on texture keys → loaded as Texture via loadTextureAsync
+     * - null values → left as null (no texture)
+     * - Already-Texture values → left as-is
+     * - Non-texture keys → left untouched
+     */
+    async resolveSettings(variant, settings) {
+        const resolved = { ...settings };
+        // Get texture property names from the registry (single source of truth)
+        const textureKeys = MaterialRegistryAPI.getTextureProperties(variant);
+        // Also detect noise keys from settings (keys containing "noise")
+        const noiseKeys = Object.keys(settings).filter(key => {
+            const lower = key.toLowerCase();
+            return lower.includes('noise') && !lower.includes('texture');
+        });
+        // Resolve texture URLs in parallel
+        const texturePromises = [];
+        for (const key of textureKeys) {
+            const value = settings[key];
+            if (typeof value === 'string' && value !== '' && value !== 'none') {
+                // It's a URL string — resolve to Texture
+                texturePromises.push(this.resolve(value)
+                    .then(texture => {
+                    resolved[key] = texture;
+                })
+                    .catch(error => {
+                    console.warn(`[TextureResolver] Could not resolve texture for "${key}": ${value}`, error);
+                    resolved[key] = null; // Fallback to null on error
+                }));
+            }
+            // If value is null, undefined, or already a Texture — leave as-is
+        }
+        // Resolve noise textures (synchronous)
+        for (const key of noiseKeys) {
+            const value = settings[key];
+            if (typeof value === 'string' && value !== '' && value !== 'none') {
+                resolved[key] = this.resolveNoise(value);
+            }
+        }
+        // Wait for all texture loads to complete
+        await Promise.all(texturePromises);
+        return resolved;
+    }
+    /**
+     * Check if a texture URL is already cached.
+     */
+    isCached(url) {
+        return this.cache.has(url);
+    }
+    /**
+     * Get a cached texture without loading. Returns undefined if not cached.
+     */
+    getCached(url) {
+        return this.cache.get(url);
+    }
+    /**
+     * Clear the texture cache and dispose all cached textures.
+     */
+    clearCache() {
+        for (const texture of this.cache.values()) {
+            texture.dispose();
+        }
+        this.cache.clear();
+    }
+    /**
+     * Remove a specific URL from the cache and dispose its texture.
+     */
+    evict(url) {
+        const texture = this.cache.get(url);
+        if (texture) {
+            texture.dispose();
+            this.cache.delete(url);
+        }
+    }
+    /**
+     * Get cache statistics.
+     */
+    getStats() {
+        return {
+            cacheSize: this.cache.size,
+            cachedUrls: Array.from(this.cache.keys()),
+        };
+    }
+}
+// Export singleton instance
+export const textureResolver = new TextureResolverService();
+// Export class for testing
+export { TextureResolverService };

package/dist/services/TexturesManager.d.ts

@@ -0,0 +1,17 @@
+import type { Texture } from 'three';
+export type TextureType = 'clouds' | 'grass' | 'terrain' | 'grounds' | 'images';
+declare class TexturesManager {
+    private textures;
+    private texturesByType;
+    private loader;
+    constructor();
+    loadTexture(name: string, url: string, type?: TextureType): Promise<Texture>;
+    getTextureByUrl(url: string): Texture | undefined;
+    getTexture(key: string): Texture | undefined;
+    addTexture(key: string, texture: Texture, width: number, height: number, isLandscape: boolean): void;
+    removeTexture(key: string): void;
+    clear(): void;
+}
+declare const texturesManager: TexturesManager;
+export default texturesManager;
+//# sourceMappingURL=TexturesManager.d.ts.map

package/dist/services/TexturesManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TexturesManager.d.ts","sourceRoot":"","sources":["../../src/services/TexturesManager.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AACrC,MAAM,MAAM,WAAW,GAAG,QAAQ,GAAG,OAAO,GAAG,SAAS,GAAG,SAAS,GAAG,QAAQ,CAAC;AAEhF,cAAM,eAAe;IACjB,OAAO,CAAC,QAAQ,CAAa;IAC7B,OAAO,CAAC,cAAc,CAAa;IACnC,OAAO,CAAC,MAAM,CAAC;;IAKT,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC;IAqBlF,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS;IAOjD,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS;IAG5C,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,OAAO,GAAG,IAAI;IAGpG,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAChC,KAAK,IAAI,IAAI;CAChB;AACD,QAAA,MAAM,eAAe,EAAE,eAAuC,CAAC;AAC/D,eAAe,eAAe,CAAC"}

package/dist/services/TexturesManager.js

@@ -0,0 +1,48 @@
+import { TextureLoader } from 'three';
+class TexturesManager {
+    textures = new Map();
+    texturesByType = new Map();
+    loader;
+    constructor() {
+        this.loader = new TextureLoader();
+        ['images', 'clouds', 'grass', 'terrain', 'grounds'].forEach(t => this.texturesByType.set(t, new Map()));
+    }
+    async loadTexture(name, url, type) {
+        if (type && this.texturesByType.get(type)?.has(name)) {
+            return this.texturesByType.get(type).get(name).texture;
+        }
+        const img = await new Promise((resolve, reject) => {
+            const image = new window.Image();
+            image.crossOrigin = 'Anonymous';
+            image.onload = () => resolve(image);
+            image.onerror = reject;
+            image.src = url;
+        });
+        const { width, height } = img;
+        const isLandscape = width > height;
+        return new Promise((resolve, reject) => {
+            this.loader.load(url, (texture) => {
+                if (type)
+                    this.texturesByType.get(type)?.set(name, { texture, width, height, isLandscape });
+                resolve(texture);
+            }, undefined, reject);
+        });
+    }
+    getTextureByUrl(url) {
+        for (const [, value] of this.textures.entries()) {
+            if (value.texture.image?.src === url)
+                return value.texture;
+        }
+        return undefined;
+    }
+    getTexture(key) {
+        return this.textures.get(key)?.texture;
+    }
+    addTexture(key, texture, width, height, isLandscape) {
+        this.textures.set(key, { texture, width, height, isLandscape });
+    }
+    removeTexture(key) { this.textures.delete(key); }
+    clear() { this.textures.clear(); }
+}
+const texturesManager = new TexturesManager();
+export default texturesManager;

package/dist/services/UniformConverter.d.ts

@@ -0,0 +1,33 @@
+import type { Texture } from 'three';
+import type { UniFormSettings } from "../types/materials";
+declare class UniformProcessor {
+}
+export declare class UniformConverter {
+    private processors;
+    private loader;
+    private excludedUniforms;
+    /**
+     * Convert shader uniforms to UI-friendly settings
+     */
+    convertToSettings(uniforms: Record<string, any>): UniFormSettings;
+    /**
+     * Convert UI settings back to shader uniforms
+     */
+    loadTexture(name: string, url: string): Promise<Texture>;
+    convertToUniforms(settings: UniFormSettings): Record<string, any>;
+    /**
+     * Add a custom processor for specific uniform types
+     */
+    addProcessor(processor: UniformProcessor, index?: number): void;
+    /**
+     * Remove excluded uniform keys
+     */
+    addExcludedUniform(uniformKey: string): void;
+    /**
+     * Remove excluded uniform keys
+     */
+    removeExcludedUniform(uniformKey: string): void;
+}
+export declare const uniformConverter: UniformConverter;
+export { UniformProcessor };
+//# sourceMappingURL=UniformConverter.d.ts.map

package/dist/services/UniformConverter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UniformConverter.d.ts","sourceRoot":"","sources":["../../src/services/UniformConverter.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AACrC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAK1D,cAAM,gBAAgB;CACrB;AA8HD,qBAAa,gBAAgB;IACzB,OAAO,CAAC,UAAU,CAOhB;IACF,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,gBAAgB,CAA4D;IACpF;;OAEG;IACH,iBAAiB,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,eAAe;IAejE;;OAEG;IACG,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IA6B9D,iBAAiB,CAAC,QAAQ,EAAE,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAuBjE;;OAEG;IACH,YAAY,CAAC,SAAS,EAAE,gBAAgB,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI;IAS/D;;OAEG;IACH,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAK5C;;OAEG;IACH,qBAAqB,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;CAMlD;AAED,eAAO,MAAM,gBAAgB,EAAE,gBAAyC,CAAC;AAEzE,OAAO,EAAE,gBAAgB,EAAE,CAAC"}