@directivegames/genesys.js 3.1.24

package/dist/src/utils/ResourceManager.js

@@ -0,0 +1,703 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import * as THREE from 'three';
+import { TextureLoader } from 'three';
+import { SkeletonUtils } from 'three/examples/jsm/Addons.js';
+import { MeshoptDecoder } from 'three/examples/jsm/libs/meshopt_decoder.module.js';
+import { DRACOLoader } from 'three/examples/jsm/loaders/DRACOLoader.js';
+import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js';
+import { RGBELoader } from 'three/examples/jsm/loaders/RGBELoader.js';
+import { TEXTURE_EXTENSION } from '../const.js';
+import { UrlTexture } from '../render/Texture.js';
+import { projectInfo, resolvePath } from '../storage/projectContext.js';
+import { AssetPath } from '../storage/storageProvider.js';
+import { ClassRegistry } from '../systems/ClassRegistry.js';
+import { Prefix } from '../systems/index.js';
+import { EngineClass } from '../systems/index.js';
+import { WorldSerializer } from '../systems/WorldSerialization.js';
+import { getPropertyMetadata } from './serialization/decorator.js';
+export var ResourceType;
+(function (ResourceType) {
+    ResourceType[ResourceType["Material"] = 1] = "Material";
+    ResourceType[ResourceType["Model"] = 2] = "Model";
+    ResourceType[ResourceType["Texture"] = 4] = "Texture";
+    ResourceType[ResourceType["Sound"] = 8] = "Sound";
+    ResourceType[ResourceType["JsonObject"] = 16] = "JsonObject";
+    ResourceType[ResourceType["Resource"] = 32] = "Resource";
+    ResourceType[ResourceType["All"] = 4294967295] = "All";
+})(ResourceType || (ResourceType = {}));
+let Resource = class Resource {
+};
+Resource = __decorate([
+    EngineClass('Resource')
+], Resource);
+export { Resource };
+/**
+ * Manages the loading and caching of resources.
+ */
+export class ResourceManager {
+    constructor() {
+        Object.defineProperty(this, "cachedMaterials", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        // Models with material overrides applied, may contain the same model as rawCachedModels if it contains no material override
+        Object.defineProperty(this, "cachedModels", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        // Models without material overrides applied
+        Object.defineProperty(this, "rawCachedModels", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "cachedTextures", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "cachedSounds", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "cachedJsonObjects", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "cachedResources", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "textureLoader", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new TextureLoader()
+        });
+        Object.defineProperty(this, "hdrLoader", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new RGBELoader()
+        });
+        Object.defineProperty(this, "gltfLoader", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new GLTFLoader()
+        });
+        Object.defineProperty(this, "audioLoader", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new THREE.AudioLoader()
+        });
+        // Set up Meshopt decoder for compressed GLTF files
+        this.gltfLoader.setMeshoptDecoder(MeshoptDecoder);
+        // Set up DRACO decoder for DRACO-compressed GLTF files
+        const dracoLoader = new DRACOLoader();
+        dracoLoader.setDecoderPath('https://www.gstatic.com/draco/versioned/decoders/1.5.6/');
+        this.gltfLoader.setDRACOLoader(dracoLoader);
+    }
+    /**
+     * Gets the cached materials.
+     * @returns The cached materials.
+     */
+    getCachedMaterials() {
+        return this.cachedMaterials;
+    }
+    /**
+     * Gets the cached models.
+     * @returns The cached models.
+     */
+    getCachedModels() {
+        return this.cachedModels;
+    }
+    /**
+     * Gets the cached textures.
+     * @returns The cached textures.
+     */
+    getCachedTextures() {
+        return this.cachedTextures;
+    }
+    /**
+     * Gets the cached sounds.
+     * @returns The cached sounds.
+     */
+    getCachedSounds() {
+        return this.cachedSounds;
+    }
+    /**
+     * Gets the cached json objects.
+     * @returns The cached json objects.
+     */
+    getCachedJsonObjects() {
+        return this.cachedJsonObjects;
+    }
+    /**
+     * Gets the cached resources.
+     * @returns The cached resources.
+     */
+    getCachedResources() {
+        return this.cachedResources;
+    }
+    /**
+     * Clears the cached resources.
+     */
+    clearCachedResources() {
+        // Clear the promise cache - the actual materials will be garbage collected
+        // when the promises resolve and no references remain
+        this.cachedMaterials = {};
+        this.cachedModels = {};
+        this.rawCachedModels = {};
+        this.cachedTextures = {};
+        this.cachedSounds = {};
+        this.cachedJsonObjects = {};
+        this.cachedResources = {};
+    }
+    /**
+     * Invalidates cached models that may have changed material overrides.
+     * Call this when material overrides have been modified.
+     * @param modelPath - Optional specific model path to invalidate. If not provided, clears all model cache.
+     */
+    invalidateModelCache(modelPath, clearRawCache = true, clearMaterialCache = true) {
+        if (modelPath) {
+            const pathStr = typeof modelPath === 'string' ? modelPath : modelPath.initialPath;
+            if (clearMaterialCache) {
+                delete this.cachedModels[pathStr];
+            }
+            if (clearRawCache) {
+                delete this.rawCachedModels[pathStr];
+            }
+        }
+        else {
+            if (clearMaterialCache) {
+                this.cachedModels = {};
+            }
+            if (clearRawCache) {
+                this.rawCachedModels = {};
+            }
+        }
+    }
+    /**
+     * Invalidates cached resources.
+     * Call this when resources have been modified and need to be reloaded.
+     * @param resourcePath - Optional specific resource path to invalidate. If not provided, clears all resource cache.
+     */
+    invalidateResourceCache(resourcePath) {
+        if (resourcePath) {
+            const pathStr = typeof resourcePath === 'string' ? resourcePath : resourcePath.initialPath;
+            delete this.cachedResources[pathStr];
+        }
+        else {
+            this.cachedResources = {};
+        }
+    }
+    /**
+     * Invalidates cached materials.
+     * Call this when materials have been modified and need to be reloaded.
+     * @param materialPath - Optional specific material path to invalidate. If not provided, clears all material cache.
+     */
+    invalidateMaterialCache(materialPath) {
+        if (materialPath) {
+            const pathStr = typeof materialPath === 'string' ? materialPath : materialPath.initialPath;
+            delete this.cachedMaterials[pathStr];
+        }
+        else {
+            this.cachedMaterials = {};
+        }
+    }
+    /**
+     * Invalidates cached textures.
+     * Call this when textures have been modified and need to be reloaded.
+     * @param texturePath - Optional specific texture path to invalidate. If not provided, clears all texture cache.
+     */
+    invalidateTextureCache(texturePath) {
+        if (texturePath) {
+            const pathStr = typeof texturePath === 'string' ? texturePath : texturePath.initialPath;
+            delete this.cachedTextures[pathStr];
+        }
+        else {
+            this.cachedTextures = {};
+        }
+    }
+    /**
+     * Logs the cached resources.
+     */
+    logCachedResources() {
+        console.log('[ResourceManager] cached materials:', Object.keys(this.cachedMaterials));
+        console.log('[ResourceManager] cached models:', Object.keys(this.cachedModels));
+        console.log('[ResourceManager] raw cached models:', Object.keys(this.rawCachedModels));
+        console.log('[ResourceManager] cached textures:', Object.keys(this.cachedTextures));
+        console.log('[ResourceManager] cached sounds:', Object.keys(this.cachedSounds));
+        console.log('[ResourceManager] cached json objects:', Object.keys(this.cachedJsonObjects));
+        console.log('[ResourceManager] cached resources:', Object.keys(this.cachedResources));
+    }
+    /**
+     * Wait for arbitrary combination of resource types to load
+     * @param resourceTypes - The resource types to wait for.
+     */
+    async waitForResources(resourceTypes) {
+        let numPromises = 0;
+        while (true) {
+            let promises = [];
+            if (resourceTypes & ResourceType.Texture) {
+                promises = promises.concat(Object.values(this.cachedTextures));
+            }
+            if (resourceTypes & ResourceType.Model) {
+                promises = promises.concat(Object.values(this.cachedModels));
+                promises = promises.concat(Object.values(this.rawCachedModels));
+            }
+            if (resourceTypes & ResourceType.Sound) {
+                promises = promises.concat(Object.values(this.cachedSounds));
+            }
+            if (resourceTypes & ResourceType.JsonObject) {
+                promises = promises.concat(Object.values(this.cachedJsonObjects));
+            }
+            if (resourceTypes & ResourceType.Material) {
+                promises = promises.concat(Object.values(this.cachedMaterials));
+            }
+            if (resourceTypes & ResourceType.Resource) {
+                promises = promises.concat(Object.values(this.cachedResources));
+            }
+            // this handles the case where new resources are added to the system while waiting for the current iteration to finish
+            // in that case we'll run the loop again to wait for the new ones, until there's none left
+            if (numPromises === promises.length) {
+                break;
+            }
+            numPromises = promises.length;
+            await Promise.all(promises);
+        }
+    }
+    /**
+     * Loads a texture from a URL.
+     * @param path - The path of the texture to load.
+     * @returns The loaded texture, or null if the texture could not be loaded.
+     */
+    async loadTexture(path) {
+        const rawUrl = path.initialPath;
+        if (rawUrl in this.cachedTextures) {
+            return this.cachedTextures[rawUrl];
+        }
+        console.log(`[ResourceManager] loading texture from ${path} ...`);
+        const loadingPromise = (async () => {
+            try {
+                path = await resolvePath(path);
+                const url = path.getResolvedPath();
+                if (url.endsWith(TEXTURE_EXTENSION)) {
+                    const textureJsonObject = await this.loadJsonObject(path);
+                    const texture = WorldSerializer.importObject(textureJsonObject);
+                    if (texture instanceof UrlTexture) {
+                        // wait for the texture to load, then return it
+                        await texture.loadPromise;
+                        return texture;
+                    }
+                    else {
+                        console.error(`Object loaded from ${path} is not a UrlTexture: ${texture}`);
+                        return null;
+                    }
+                }
+                else {
+                    let texture = null;
+                    if (url.endsWith('.hdr') || url.endsWith('.exr')) {
+                        texture = await this.hdrLoader.loadAsync(url);
+                    }
+                    else {
+                        texture = await this.textureLoader.loadAsync(url);
+                    }
+                    console.log(`[ResourceManager] texture loaded from ${path}`);
+                    return texture;
+                }
+            }
+            catch (error) {
+                console.error(`Failed to load texture from ${path}`, error);
+                return null;
+            }
+        })();
+        this.cachedTextures[rawUrl] = loadingPromise;
+        return loadingPromise;
+    }
+    /**
+     * Extracts material overrides from individual materials in the GLTF.
+     * @param gltf - The loaded GLTF object.
+     * @returns Record of material name to asset path mappings.
+     */
+    getMaterialOverrides(gltf) {
+        const overrides = {};
+        gltf.scene.traverse((object) => {
+            if (object instanceof THREE.Mesh && object.material) {
+                const materials = Array.isArray(object.material) ? object.material : [object.material];
+                materials.forEach((material) => {
+                    if (material.userData?.gltfExtensions?.GENESYS_material_overrides) {
+                        const materialOverride = material.userData.gltfExtensions.GENESYS_material_overrides.materialOverride;
+                        if (materialOverride) {
+                            const materialName = material.name ?? material.uuid;
+                            overrides[materialName] = materialOverride;
+                            console.log(`[ResourceManager] Found material override for "${materialName}": ${materialOverride}`);
+                        }
+                    }
+                });
+            }
+        });
+        return overrides;
+    }
+    /**
+     * Applies material overrides to a loaded GLTF model.
+     * @param gltf - The loaded GLTF object.
+     * @param overrides - Record of material name to asset path mappings.
+     */
+    async applyMaterialOverrides(gltf, overrides) {
+        // Create a map for faster lookup
+        const overrideMap = new Map(Object.entries(overrides));
+        // Load all override materials first (batch loading for performance)
+        const materialPromises = Array.from(overrideMap.values()).map(async (materialPath) => {
+            try {
+                const material = await this.loadMaterial(AssetPath.fromString(materialPath));
+                return { path: materialPath, material };
+            }
+            catch (error) {
+                console.warn(`[ResourceManager] Failed to load override material: ${materialPath}`, error);
+                return { path: materialPath, material: null };
+            }
+        });
+        const loadedMaterials = await Promise.all(materialPromises);
+        const materialCache = new Map(loadedMaterials
+            .filter(result => result.material !== null)
+            .map(result => [result.path, result.material]));
+        // Apply overrides to meshes
+        gltf.scene.traverse((object) => {
+            if (object instanceof THREE.Mesh && object.material) {
+                const materials = Array.isArray(object.material) ? object.material : [object.material];
+                const newMaterials = materials.map((material) => {
+                    const materialName = material.name ?? material.uuid;
+                    const overridePath = overrideMap.get(materialName);
+                    if (overridePath) {
+                        const overrideMaterial = materialCache.get(overridePath);
+                        if (overrideMaterial) {
+                            return overrideMaterial;
+                        }
+                        else {
+                            console.warn(`[ResourceManager] Override material not found for "${materialName}": ${overridePath}`);
+                        }
+                    }
+                    return material; // Return original if no override or override failed
+                });
+                // Update the mesh material(s)
+                object.material = Array.isArray(object.material) ? newMaterials : newMaterials[0];
+            }
+        });
+    }
+    async loadRawModel(path) {
+        const rawUrl = path.initialPath;
+        if (rawUrl in this.rawCachedModels) {
+            return this.rawCachedModels[rawUrl];
+        }
+        const loadingPromise = this.loadModelFromStorageProvider(AssetPath.fromString(rawUrl));
+        this.rawCachedModels[rawUrl] = loadingPromise;
+        return loadingPromise;
+    }
+    async loadModelWithMaterialsApplied(path) {
+        const rawUrl = path.initialPath;
+        if (rawUrl in this.cachedModels) {
+            return this.cachedModels[rawUrl];
+        }
+        // This will load if required, and handle caching for the raw assets.
+        let rawModel = await this.loadRawModel(path);
+        if (rawModel) {
+            const materialOverrides = this.getMaterialOverrides(rawModel);
+            if (Object.keys(materialOverrides).length) {
+                // Deep clone to avoid modifying the raw cached version
+                const clonedModel = this.CloneModel(rawModel);
+                await this.applyMaterialOverrides(clonedModel, materialOverrides);
+                this.cachedModels[rawUrl] = Promise.resolve(clonedModel);
+                return clonedModel;
+            }
+            else {
+                // avoid cloning the raw model unnecessarily
+                this.cachedModels[rawUrl] = Promise.resolve(rawModel);
+                return rawModel;
+            }
+        }
+        return null;
+    }
+    async loadModelFromStorageProvider(path) {
+        return (async () => {
+            try {
+                const storageProvider = projectInfo.storageProvider;
+                if (!storageProvider) {
+                    throw new Error('No storage provider found');
+                }
+                const arrayBuffer = await storageProvider.downloadFileAsBuffer(path);
+                const model = await this.gltfLoader.parseAsync(arrayBuffer, '');
+                return model;
+            }
+            catch (error) {
+                console.error(`Failed to load model from ${path}: ${error}`);
+                return null;
+            }
+        })();
+    }
+    /**
+     * Loads a model from a URL.
+     * @param url - The URL of the model to load.
+     * @param applyMaterialOverrides - Whether to apply material overrides to the model. Defaults to true.
+     * @returns The loaded model, or null if the model could not be loaded.
+     */
+    async loadModel(path, applyMaterialOverrides = true) {
+        await MeshoptDecoder.ready;
+        if (applyMaterialOverrides) {
+            return this.loadModelWithMaterialsApplied(path);
+        }
+        else {
+            return this.loadRawModel(path);
+        }
+    }
+    /**
+     * Deeply clone a GLTF, including its scene graph and animations.
+     *
+     * @param gltf - The original GLTF object from GLTFLoader.
+     * @returns A new GLTF object with independent clones of the scene, scenes, and cameras.
+     */
+    CloneModel(gltf) {
+        const clone = {
+            animations: gltf.animations.map((clip) => clip.clone ? clip.clone() : clip),
+            scene: SkeletonUtils.clone(gltf.scene),
+            scenes: gltf.scenes.map((scene) => SkeletonUtils.clone(scene)),
+            cameras: gltf.cameras ? gltf.cameras.map((cam) => cam.clone()) : [],
+            asset: { ...gltf.asset },
+            parser: gltf.parser,
+            userData: { ...gltf.userData },
+        };
+        return clone;
+    }
+    /**
+     * Loads a generic material from a URL or returns the material if it is already loaded.
+     * @param material - The material to load.
+     * @returns The loaded material, or null if the material could not be loaded.
+     */
+    async loadGenericMaterial(material) {
+        if (typeof material === 'string') {
+            if (!material) {
+                return null;
+            }
+            return this.loadMaterial(AssetPath.fromString(material));
+        }
+        else {
+            return material;
+        }
+    }
+    /**
+     * Loads a material from a URL.
+     * @param url - The URL of the material to load.
+     * @returns The loaded material, or null if the material could not be loaded.
+     */
+    async loadMaterial(path) {
+        const rawUrl = path.initialPath;
+        // Return existing promise if already cached
+        if (rawUrl in this.cachedMaterials) {
+            return this.cachedMaterials[rawUrl];
+        }
+        // Create and cache the loading promise
+        const loadingPromise = (async () => {
+            try {
+                const json = await this.loadJsonObject(path);
+                if (!json) {
+                    console.error(`Failed to download material from ${path}`);
+                    return null;
+                }
+                const loadedObject = WorldSerializer.importObject(json);
+                if (!(loadedObject instanceof THREE.Material)) {
+                    console.error(`Object loaded from ${path} is not a material: ${loadedObject}`);
+                    return null;
+                }
+                return loadedObject;
+            }
+            catch (error) {
+                console.error(`Failed to load material from ${path}: ${error}`);
+                return null;
+            }
+        })();
+        this.cachedMaterials[rawUrl] = loadingPromise;
+        return loadingPromise;
+    }
+    /**
+     * Loads a sound from a URL.
+     * @param path - The path of the sound to load.
+     * @returns The loaded sound buffer, or null if the sound could not be loaded.
+     */
+    async loadSound(path) {
+        const rawUrl = path.initialPath;
+        if (!(rawUrl in this.cachedSounds)) {
+            const loadingPromise = (async () => {
+                try {
+                    path = await resolvePath(path);
+                    let sound = null;
+                    // TODO: This commented out code mirrors the code in loadModel. The reason
+                    // we cannot use it, is because there is no audio loader for a buffer. I don't
+                    // understand what the storageProvider.downloadFileAsBuffer path is for, so I cannot
+                    // say whether we need to use it or not.
+                    // ------------------------------------------------------------------------------------------------
+                    // if (isNode() && pathlib.isAbsolute(rawUrl)) {
+                    //   const storageProvider = projectInfo.storageProvider;
+                    //   if (!storageProvider) {
+                    //     throw new Error('No storage provider found');
+                    //   }
+                    //   const arrayBuffer = await storageProvider.downloadFileAsBuffer(path);
+                    //   sound = await this.audioLoader.loadAsync(arrayBuffer);
+                    // }
+                    // else {
+                    //   sound = await this.audioLoader.loadAsync(path.getResolvedPath());
+                    // }
+                    sound = await this.audioLoader.loadAsync(path.getResolvedPath());
+                    return sound;
+                }
+                catch (error) {
+                    console.error(`Failed to load sound from ${path}: ${error}`);
+                    return null;
+                }
+            })();
+            this.cachedSounds[rawUrl] = loadingPromise;
+        }
+        return this.cachedSounds[rawUrl];
+    }
+    /**
+     * Loads a json object from a URL.
+     * @param path - The path of the json object to load.
+     * @returns The loaded json object, or null if the file could not be loaded.
+     */
+    async loadJsonObject(path) {
+        const rawUrl = path.initialPath;
+        // Return existing promise if already cached
+        if (rawUrl in this.cachedJsonObjects) {
+            return this.cachedJsonObjects[rawUrl];
+        }
+        // Create and cache the loading promise
+        const loadingPromise = (async () => {
+            try {
+                const json = await projectInfo.storageProvider?.downloadFileAsJson(path);
+                if (!json) {
+                    console.error(`Failed to download json object from ${path}`);
+                    return null;
+                }
+                return json;
+            }
+            catch (error) {
+                console.error(`Failed to load json object from ${path}: ${error}`);
+                return null;
+            }
+        })();
+        this.cachedJsonObjects[rawUrl] = loadingPromise;
+        return loadingPromise;
+    }
+    /**
+     * Loads a resource from a .res.json file.
+     * Resolves the class, extracts metadata, and creates an instance with merged properties.
+     * @param path - The path of the resource to load.
+     * @returns The loaded resource data, or null if the resource could not be loaded.
+     */
+    async loadResource(path) {
+        const rawUrl = path.initialPath;
+        if (rawUrl in this.cachedResources) {
+            return this.cachedResources[rawUrl];
+        }
+        const loadingPromise = (async () => {
+            try {
+                const rawFileData = await this.loadJsonObject(path);
+                if (!rawFileData || !rawFileData.class) {
+                    console.error(`Invalid resource file format at ${path}`);
+                    return null;
+                }
+                // Create resource data with defaults
+                const resourceData = this.createResourceData(rawFileData.class);
+                if (!resourceData) {
+                    return null;
+                }
+                // Merge loaded properties into the instance
+                const loadedProperties = rawFileData.properties ?? {};
+                Object.assign(resourceData.instance, loadedProperties);
+                // Update properties object with loaded values
+                Object.assign(resourceData.properties, loadedProperties);
+                return resourceData;
+            }
+            catch (error) {
+                console.error(`Failed to load resource from ${path}: ${error}`);
+                return null;
+            }
+        })();
+        this.cachedResources[rawUrl] = loadingPromise;
+        return loadingPromise;
+    }
+    /**
+     * Create a new resource data structure ready for serialization.
+     * Does not save to disk - returns the data structure that can be serialized and saved.
+     * @param className - The full class name (e.g., ENGINE.MyResource or just MyResource)
+     * @returns The resource data with defaults, or null if creation failed
+     */
+    createResourceData(className) {
+        try {
+            // Resolve class name with proper prefix (reuse loadResource logic)
+            let resolvedClassName = className;
+            let ResourceClass = ClassRegistry.getClass(resolvedClassName);
+            if (!ResourceClass && !resolvedClassName.includes('.')) {
+                resolvedClassName = `${Prefix.ENGINE}.${className}`;
+                ResourceClass = ClassRegistry.getClass(resolvedClassName);
+                if (!ResourceClass) {
+                    resolvedClassName = `${Prefix.GAME}.${className}`;
+                    ResourceClass = ClassRegistry.getClass(resolvedClassName);
+                }
+            }
+            if (!ResourceClass) {
+                console.error(`Resource class ${className} not found in ClassRegistry`);
+                return null;
+            }
+            // Extract metadata
+            const metadata = getPropertyMetadata(ResourceClass);
+            // Create instance with defaults
+            const instance = ClassRegistry.constructObject(resolvedClassName, false);
+            if (!instance) {
+                console.error(`Failed to construct instance of ${resolvedClassName}`);
+                return null;
+            }
+            // Build properties with serialized default values
+            const properties = {};
+            Object.keys(metadata).forEach(propName => {
+                if (propName in instance) {
+                    properties[propName] = WorldSerializer.exportObject(instance[propName], false);
+                }
+            });
+            return {
+                class: resolvedClassName,
+                properties,
+                metadata,
+                instance
+            };
+        }
+        catch (error) {
+            console.error(`Failed to create resource data for ${className}: ${error}`);
+            return null;
+        }
+    }
+}
+export let resourceManager = new ResourceManager();
+export function setResourceManager(newResourceManager) {
+    resourceManager = newResourceManager;
+    console.log('[ResourceManager] set resource manager to', ClassRegistry.getClassOrConstructorName(newResourceManager));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ResourceManager.js","sourceRoot":"","sources":["../../../src/utils/ResourceManager.ts"],"names":[],"mappings":"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"}