@needle-tools/engine 3.28.6-beta → 3.28.7-beta.1

package/lib/engine/engine_addressables.js

@@ -1,442 +1,442 @@
-import { getParam, resolveUrl } from "../engine/engine_utils.js";
-import { TypeSerializer } from "./engine_serialization_core.js";
-import { Context } from "./engine_setup.js";
-import { Object3D, TextureLoader } from "three";
-import { processNewScripts } from "./engine_mainloop_utils.js";
-import { registerPrefabProvider, syncInstantiate } from "./engine_networking_instantiate.js";
-import { download } from "./engine_web_api.js";
-import { getLoader } from "./engine_gltf.js";
-import { destroy, instantiate, InstantiateOptions, isDestroyed } from "./engine_gameobject.js";
-const debug = getParam("debugaddressables");
-export class Addressables {
-    _context;
-    constructor(context) {
-        this._context = context;
-        this._context.pre_update_callbacks.push(this.preUpdate.bind(this));
-    }
-    preUpdate() {
-    }
-    _assetReferences = {};
-    findAssetReference(key) {
-        return this._assetReferences[key] || null;
-    }
-    registerAssetReference(ref) {
-        if (!ref.uri)
-            return ref;
-        if (!this._assetReferences[ref.uri]) {
-            this._assetReferences[ref.uri] = ref;
-        }
-        else {
-            console.warn("Asset reference already registered", ref);
-        }
-        return ref;
-    }
-    dispose() {
-        for (const key in this._assetReferences) {
-            const ref = this._assetReferences[key];
-            ref?.unload();
-        }
-        this._assetReferences = {};
-    }
-    unregisterAssetReference(ref) {
-        if (!ref.uri)
-            return;
-        delete this._assetReferences[ref.uri];
-    }
-}
-const $assetReference = Symbol("assetReference");
-export class AssetReference {
-    /**
-     * Get an AssetReference for a URL to be easily loaded. AssetReferences are cached so calling this method multiple times with the same arguments will always return the same AssetReference.
-     */
-    static getOrCreate(sourceId, url, context) {
-        if (typeof sourceId === "string") {
-            if (!context) {
-                context = Context.Current;
-                if (!context)
-                    throw new Error("Context is required when sourceId is a string. When you call this method from a component you can call it with \"getOrCreate(this, url)\" where \"this\" is the component.");
-            }
-        }
-        else {
-            context = sourceId.context;
-            sourceId = sourceId.sourceId;
-        }
-        const fullPath = resolveUrl(sourceId, url);
-        if (debug)
-            console.log("GetOrCreate Addressable from", sourceId, url, "FinalPath=", fullPath);
-        const addressables = context.addressables;
-        const existing = addressables.findAssetReference(fullPath);
-        if (existing)
-            return existing;
-        const ref = new AssetReference(fullPath, context.hash);
-        addressables.registerAssetReference(ref);
-        return ref;
-    }
-    static currentlyInstantiating = new Map();
-    get asset() {
-        return this._glbRoot ?? this._asset;
-    }
-    set asset(val) {
-        this._asset = val;
-    }
-    _loading;
-    // TODO: rename to url
-    get uri() {
-        return this._url;
-    }
-    get rawAsset() { return this._asset; }
-    _asset;
-    _glbRoot;
-    _url;
-    _progressListeners = [];
-    _hash;
-    _hashedUri;
-    _isLoadingRawBinary = false;
-    _rawBinary;
-    constructor(uri, hash, asset = null) {
-        this._url = uri;
-        this._hash = hash;
-        if (uri.includes("?v="))
-            this._hashedUri = uri;
-        else
-            this._hashedUri = hash ? uri + "?v=" + hash : uri;
-        if (asset !== null)
-            this.asset = asset;
-        registerPrefabProvider(this._url, this.onResolvePrefab.bind(this));
-    }
-    async onResolvePrefab(url) {
-        if (url === this.uri) {
-            if (this.mustLoad)
-                await this.loadAssetAsync();
-            if (this.asset) {
-                return this.asset;
-            }
-        }
-        return null;
-    }
-    get mustLoad() {
-        return !this.asset || this.asset.__destroyed === true || isDestroyed(this.asset) === true;
-    }
-    isLoaded() { return this._rawBinary || this.asset !== undefined; }
-    unload() {
-        if (this.asset) {
-            if (debug)
-                console.log("Unload", this.asset);
-            // TODO: we need a way to remove objects from the context (including components) without actually "destroying" them
-            if (this.asset.scene)
-                destroy(this.asset.scene, true, true);
-            destroy(this.asset, true, true);
-        }
-        this.asset = null;
-        this._rawBinary = undefined;
-        this._glbRoot = null;
-        this._loading = undefined;
-        if (Context.Current) {
-            Context.Current.addressables.unregisterAssetReference(this);
-        }
-    }
-    async preload() {
-        if (!this.mustLoad)
-            return null;
-        if (this._isLoadingRawBinary)
-            return null;
-        if (this._rawBinary !== undefined)
-            return this._rawBinary;
-        this._isLoadingRawBinary = true;
-        if (debug)
-            console.log("Preload", this._hashedUri);
-        const res = await download(this._hashedUri, p => {
-            this.raiseProgressEvent(p);
-        });
-        this._rawBinary = res?.buffer ?? null;
-        this._isLoadingRawBinary = false;
-        return this._rawBinary;
-    }
-    // TODO: we need a way to abort loading a resource
-    async loadAssetAsync(prog) {
-        if (debug)
-            console.log("loadAssetAsync", this.uri);
-        if (!this.mustLoad)
-            return this.asset;
-        if (prog)
-            this._progressListeners.push(prog);
-        if (this._loading !== undefined) {
-            // console.warn("Wait for other loading thiny");
-            return this._loading.then(_ => this.asset);
-        }
-        const context = Context.Current;
-        // TODO: technically we shouldnt call awake only when the object is added to a scene
-        // addressables now allow loading things without adding them to a scene immediately
-        // we should "address" (LUL) this
-        // console.log("START LOADING");
-        if (this._rawBinary) {
-            this._loading = getLoader().parseSync(context, this._rawBinary, this.uri, null);
-            this.raiseProgressEvent(new ProgressEvent("progress", { loaded: this._rawBinary.byteLength, total: this._rawBinary.byteLength }));
-        }
-        else {
-            if (debug)
-                console.log("Load async", this.uri);
-            this._loading = getLoader().loadSync(context, this._hashedUri, this.uri, null, prog => {
-                this.raiseProgressEvent(prog);
-            });
-        }
-        const res = await this._loading;
-        // clear all progress listeners after download has finished
-        this._progressListeners.length = 0;
-        this._glbRoot = this.tryGetActualGameObjectRoot(res);
-        this._loading = undefined;
-        if (res) {
-            // Make sure the loaded roots all have a reference to this AssetReference
-            // that was originally loading it.
-            // We need this when the loaded asset is being disposed
-            // TODO: we have to prevent disposing resources that are still in use
-            res[$assetReference] = this;
-            if (this._glbRoot)
-                this._glbRoot[$assetReference] = this;
-            if (this.asset)
-                this.asset[$assetReference] = this;
-            // we need to handle the pre_setup callsbacks before instantiating
-            // because that is where deserialization happens
-            processNewScripts(context);
-            if (res.scene !== undefined) {
-                this.asset = res;
-            }
-            return this.asset;
-        }
-    }
-    async instantiate(parent) {
-        return this.onInstantiate(parent, false);
-    }
-    async instantiateSynced(parent, saveOnServer = true) {
-        return this.onInstantiate(parent, true, saveOnServer);
-    }
-    beginListenDownload(evt) {
-        if (this._progressListeners.indexOf(evt) < 0)
-            this._progressListeners.push(evt);
-    }
-    endListenDownload(evt) {
-        const index = this._progressListeners.indexOf(evt);
-        if (index >= 0) {
-            this._progressListeners.splice(index, 1);
-        }
-    }
-    raiseProgressEvent(prog) {
-        for (const list of this._progressListeners) {
-            list(this, prog);
-        }
-    }
-    async onInstantiate(parent, networked = false, saveOnServer) {
-        const context = Context.Current;
-        if (this.mustLoad) {
-            await this.loadAssetAsync();
-        }
-        if (debug)
-            console.log("Instantiate", this.uri, "parent:", parent);
-        if (this.asset) {
-            if (debug)
-                console.log("Add to scene", this.asset);
-            let options = parent instanceof InstantiateOptions ? parent : null;
-            if (!options) {
-                options = new InstantiateOptions();
-            }
-            if (typeof parent === "object") {
-                if (parent instanceof Object3D) {
-                    options.parent = parent;
-                }
-                else {
-                    Object.assign(options, parent);
-                }
-            }
-            if (!options.parent)
-                options.parent = context.scene;
-            let count = AssetReference.currentlyInstantiating.get(this.uri);
-            // allow up to 10000 instantiations of the same prefab in the same frame
-            if (count !== undefined && count >= 10000) {
-                console.error("Recursive or too many instantiations of " + this.uri + " in the same frame (" + count + ")");
-                return null;
-            }
-            try {
-                if (count === undefined)
-                    count = 0;
-                count += 1;
-                AssetReference.currentlyInstantiating.set(this.uri, count);
-                if (networked) {
-                    options.context = context;
-                    const prefab = this.asset;
-                    prefab.guid = this.uri;
-                    const instance = syncInstantiate(prefab, options, undefined, saveOnServer);
-                    if (instance) {
-                        return instance;
-                    }
-                }
-                else {
-                    const instance = instantiate(this.asset, options);
-                    if (instance) {
-                        return instance;
-                    }
-                }
-            }
-            finally {
-                context.post_render_callbacks.push(() => {
-                    if (count === undefined || count < 0)
-                        count = 0;
-                    else
-                        count -= 1;
-                    AssetReference.currentlyInstantiating.set(this.uri, count);
-                });
-            }
-        }
-        else if (debug)
-            console.warn("Failed to load asset", this.uri);
-        return null;
-    }
-    /**
-     * try to ignore the intermediate created object
-     * because it causes trouble if we instantiate an assetreference per player
-     * and call destroy on the player marker root
-     * @returns the scene root object if the asset was a glb/gltf
-     */
-    tryGetActualGameObjectRoot(asset) {
-        if (asset && asset.scene) {
-            // some exporters produce additional root objects
-            const scene = asset.scene;
-            if (scene.isGroup && scene.children.length === 1 && scene.children[0].name + "glb" === scene.name) {
-                const root = scene.children[0];
-                return root;
-            }
-            // ok the scene is the scene, just use that then
-            else
-                return scene;
-        }
-        return null;
-    }
-}
-class AddressableSerializer extends TypeSerializer {
-    constructor() {
-        super([AssetReference]);
-    }
-    onSerialize(data, _context) {
-        if (data && data.uri !== undefined && typeof data.uri === "string") {
-            return data.uri;
-        }
-    }
-    onDeserialize(data, context) {
-        if (typeof data === "string") {
-            if (!context.context) {
-                console.error("Missing context");
-                return null;
-            }
-            if (!context.gltfId) {
-                console.error("Missing source id");
-                return null;
-            }
-            const ref = AssetReference.getOrCreate(context.gltfId, data, context.context);
-            return ref;
-        }
-        else if (data instanceof Object3D) {
-            if (!context.context) {
-                console.error("Missing context");
-                return null;
-            }
-            if (!context.gltfId) {
-                console.error("Missing source id");
-                return null;
-            }
-            const obj = data;
-            const ctx = context.context;
-            const guid = obj["guid"] ?? obj.uuid;
-            const existing = ctx.addressables.findAssetReference(guid);
-            if (existing)
-                return existing;
-            const ref = new AssetReference(guid, undefined, obj);
-            ctx.addressables.registerAssetReference(ref);
-            return ref;
-        }
-        return null;
-    }
-}
-new AddressableSerializer();
-const failedTexturePromise = Promise.resolve(null);
-export class ImageReference {
-    static imageReferences = new Map();
-    static getOrCreate(url) {
-        let ref = ImageReference.imageReferences.get(url);
-        if (!ref) {
-            ref = new ImageReference(url);
-            ImageReference.imageReferences.set(url, ref);
-        }
-        return ref;
-    }
-    constructor(url) {
-        this.url = url;
-    }
-    url;
-    _bitmap;
-    _bitmapObject;
-    dispose() {
-        if (this._bitmapObject) {
-            this._bitmapObject.close();
-        }
-        this._bitmap = undefined;
-    }
-    createHTMLImage() {
-        const img = new Image();
-        img.src = this.url;
-        return img;
-    }
-    loader = null;
-    createTexture() {
-        if (!this.url)
-            return failedTexturePromise;
-        if (!this.loader)
-            this.loader = new TextureLoader();
-        this.loader.setCrossOrigin("anonymous");
-        return this.loader.loadAsync(this.url);
-        // return this.getBitmap().then((bitmap) => {
-        //     if (bitmap) {
-        //         const texture = new Texture(bitmap);
-        //         texture.needsUpdate = true;
-        //         return texture;
-        //     }
-        //     return null;
-        // });
-    }
-    /** Loads the bitmap data of the image */
-    getBitmap() {
-        if (this._bitmap)
-            return this._bitmap;
-        this._bitmap = new Promise((res, _) => {
-            const imageElement = document.createElement("img");
-            imageElement.addEventListener("load", () => {
-                this._bitmap = createImageBitmap(imageElement).then((bitmap) => {
-                    this._bitmapObject = bitmap;
-                    res(bitmap);
-                    return bitmap;
-                });
-            });
-            imageElement.addEventListener("error", err => {
-                console.error("Failed to load image:" + this.url, err);
-                res(null);
-            });
-            imageElement.src = this.url;
-        });
-        return this._bitmap;
-    }
-}
-export class ImageReferenceSerializer extends TypeSerializer {
-    constructor() {
-        super([ImageReference]);
-    }
-    onSerialize(_data, _context) {
-        return null;
-    }
-    onDeserialize(data, _context) {
-        if (typeof data === "string") {
-            const url = resolveUrl(_context.gltfId, data);
-            return ImageReference.getOrCreate(url);
-        }
-        return undefined;
-    }
-}
-new ImageReferenceSerializer();
+import { getParam, resolveUrl } from "../engine/engine_utils.js";
+import { TypeSerializer } from "./engine_serialization_core.js";
+import { Context } from "./engine_setup.js";
+import { Object3D, TextureLoader } from "three";
+import { processNewScripts } from "./engine_mainloop_utils.js";
+import { registerPrefabProvider, syncInstantiate } from "./engine_networking_instantiate.js";
+import { download } from "./engine_web_api.js";
+import { getLoader } from "./engine_gltf.js";
+import { destroy, instantiate, InstantiateOptions, isDestroyed } from "./engine_gameobject.js";
+const debug = getParam("debugaddressables");
+export class Addressables {
+    _context;
+    constructor(context) {
+        this._context = context;
+        this._context.pre_update_callbacks.push(this.preUpdate.bind(this));
+    }
+    preUpdate() {
+    }
+    _assetReferences = {};
+    findAssetReference(key) {
+        return this._assetReferences[key] || null;
+    }
+    registerAssetReference(ref) {
+        if (!ref.uri)
+            return ref;
+        if (!this._assetReferences[ref.uri]) {
+            this._assetReferences[ref.uri] = ref;
+        }
+        else {
+            console.warn("Asset reference already registered", ref);
+        }
+        return ref;
+    }
+    dispose() {
+        for (const key in this._assetReferences) {
+            const ref = this._assetReferences[key];
+            ref?.unload();
+        }
+        this._assetReferences = {};
+    }
+    unregisterAssetReference(ref) {
+        if (!ref.uri)
+            return;
+        delete this._assetReferences[ref.uri];
+    }
+}
+const $assetReference = Symbol("assetReference");
+export class AssetReference {
+    /**
+     * Get an AssetReference for a URL to be easily loaded. AssetReferences are cached so calling this method multiple times with the same arguments will always return the same AssetReference.
+     */
+    static getOrCreate(sourceId, url, context) {
+        if (typeof sourceId === "string") {
+            if (!context) {
+                context = Context.Current;
+                if (!context)
+                    throw new Error("Context is required when sourceId is a string. When you call this method from a component you can call it with \"getOrCreate(this, url)\" where \"this\" is the component.");
+            }
+        }
+        else {
+            context = sourceId.context;
+            sourceId = sourceId.sourceId;
+        }
+        const fullPath = resolveUrl(sourceId, url);
+        if (debug)
+            console.log("GetOrCreate Addressable from", sourceId, url, "FinalPath=", fullPath);
+        const addressables = context.addressables;
+        const existing = addressables.findAssetReference(fullPath);
+        if (existing)
+            return existing;
+        const ref = new AssetReference(fullPath, context.hash);
+        addressables.registerAssetReference(ref);
+        return ref;
+    }
+    static currentlyInstantiating = new Map();
+    get asset() {
+        return this._glbRoot ?? this._asset;
+    }
+    set asset(val) {
+        this._asset = val;
+    }
+    _loading;
+    // TODO: rename to url
+    get uri() {
+        return this._url;
+    }
+    get rawAsset() { return this._asset; }
+    _asset;
+    _glbRoot;
+    _url;
+    _progressListeners = [];
+    _hash;
+    _hashedUri;
+    _isLoadingRawBinary = false;
+    _rawBinary;
+    constructor(uri, hash, asset = null) {
+        this._url = uri;
+        this._hash = hash;
+        if (uri.includes("?v="))
+            this._hashedUri = uri;
+        else
+            this._hashedUri = hash ? uri + "?v=" + hash : uri;
+        if (asset !== null)
+            this.asset = asset;
+        registerPrefabProvider(this._url, this.onResolvePrefab.bind(this));
+    }
+    async onResolvePrefab(url) {
+        if (url === this.uri) {
+            if (this.mustLoad)
+                await this.loadAssetAsync();
+            if (this.asset) {
+                return this.asset;
+            }
+        }
+        return null;
+    }
+    get mustLoad() {
+        return !this.asset || this.asset.__destroyed === true || isDestroyed(this.asset) === true;
+    }
+    isLoaded() { return this._rawBinary || this.asset !== undefined; }
+    unload() {
+        if (this.asset) {
+            if (debug)
+                console.log("Unload", this.asset);
+            // TODO: we need a way to remove objects from the context (including components) without actually "destroying" them
+            if (this.asset.scene)
+                destroy(this.asset.scene, true, true);
+            destroy(this.asset, true, true);
+        }
+        this.asset = null;
+        this._rawBinary = undefined;
+        this._glbRoot = null;
+        this._loading = undefined;
+        if (Context.Current) {
+            Context.Current.addressables.unregisterAssetReference(this);
+        }
+    }
+    async preload() {
+        if (!this.mustLoad)
+            return null;
+        if (this._isLoadingRawBinary)
+            return null;
+        if (this._rawBinary !== undefined)
+            return this._rawBinary;
+        this._isLoadingRawBinary = true;
+        if (debug)
+            console.log("Preload", this._hashedUri);
+        const res = await download(this._hashedUri, p => {
+            this.raiseProgressEvent(p);
+        });
+        this._rawBinary = res?.buffer ?? null;
+        this._isLoadingRawBinary = false;
+        return this._rawBinary;
+    }
+    // TODO: we need a way to abort loading a resource
+    async loadAssetAsync(prog) {
+        if (debug)
+            console.log("loadAssetAsync", this.uri);
+        if (!this.mustLoad)
+            return this.asset;
+        if (prog)
+            this._progressListeners.push(prog);
+        if (this._loading !== undefined) {
+            // console.warn("Wait for other loading thiny");
+            return this._loading.then(_ => this.asset);
+        }
+        const context = Context.Current;
+        // TODO: technically we shouldnt call awake only when the object is added to a scene
+        // addressables now allow loading things without adding them to a scene immediately
+        // we should "address" (LUL) this
+        // console.log("START LOADING");
+        if (this._rawBinary) {
+            this._loading = getLoader().parseSync(context, this._rawBinary, this.uri, null);
+            this.raiseProgressEvent(new ProgressEvent("progress", { loaded: this._rawBinary.byteLength, total: this._rawBinary.byteLength }));
+        }
+        else {
+            if (debug)
+                console.log("Load async", this.uri);
+            this._loading = getLoader().loadSync(context, this._hashedUri, this.uri, null, prog => {
+                this.raiseProgressEvent(prog);
+            });
+        }
+        const res = await this._loading;
+        // clear all progress listeners after download has finished
+        this._progressListeners.length = 0;
+        this._glbRoot = this.tryGetActualGameObjectRoot(res);
+        this._loading = undefined;
+        if (res) {
+            // Make sure the loaded roots all have a reference to this AssetReference
+            // that was originally loading it.
+            // We need this when the loaded asset is being disposed
+            // TODO: we have to prevent disposing resources that are still in use
+            res[$assetReference] = this;
+            if (this._glbRoot)
+                this._glbRoot[$assetReference] = this;
+            if (this.asset)
+                this.asset[$assetReference] = this;
+            // we need to handle the pre_setup callsbacks before instantiating
+            // because that is where deserialization happens
+            processNewScripts(context);
+            if (res.scene !== undefined) {
+                this.asset = res;
+            }
+            return this.asset;
+        }
+    }
+    async instantiate(parent) {
+        return this.onInstantiate(parent, false);
+    }
+    async instantiateSynced(parent, saveOnServer = true) {
+        return this.onInstantiate(parent, true, saveOnServer);
+    }
+    beginListenDownload(evt) {
+        if (this._progressListeners.indexOf(evt) < 0)
+            this._progressListeners.push(evt);
+    }
+    endListenDownload(evt) {
+        const index = this._progressListeners.indexOf(evt);
+        if (index >= 0) {
+            this._progressListeners.splice(index, 1);
+        }
+    }
+    raiseProgressEvent(prog) {
+        for (const list of this._progressListeners) {
+            list(this, prog);
+        }
+    }
+    async onInstantiate(parent, networked = false, saveOnServer) {
+        const context = Context.Current;
+        if (this.mustLoad) {
+            await this.loadAssetAsync();
+        }
+        if (debug)
+            console.log("Instantiate", this.uri, "parent:", parent);
+        if (this.asset) {
+            if (debug)
+                console.log("Add to scene", this.asset);
+            let options = parent instanceof InstantiateOptions ? parent : null;
+            if (!options) {
+                options = new InstantiateOptions();
+            }
+            if (typeof parent === "object") {
+                if (parent instanceof Object3D) {
+                    options.parent = parent;
+                }
+                else {
+                    Object.assign(options, parent);
+                }
+            }
+            if (!options.parent)
+                options.parent = context.scene;
+            let count = AssetReference.currentlyInstantiating.get(this.uri);
+            // allow up to 10000 instantiations of the same prefab in the same frame
+            if (count !== undefined && count >= 10000) {
+                console.error("Recursive or too many instantiations of " + this.uri + " in the same frame (" + count + ")");
+                return null;
+            }
+            try {
+                if (count === undefined)
+                    count = 0;
+                count += 1;
+                AssetReference.currentlyInstantiating.set(this.uri, count);
+                if (networked) {
+                    options.context = context;
+                    const prefab = this.asset;
+                    prefab.guid = this.uri;
+                    const instance = syncInstantiate(prefab, options, undefined, saveOnServer);
+                    if (instance) {
+                        return instance;
+                    }
+                }
+                else {
+                    const instance = instantiate(this.asset, options);
+                    if (instance) {
+                        return instance;
+                    }
+                }
+            }
+            finally {
+                context.post_render_callbacks.push(() => {
+                    if (count === undefined || count < 0)
+                        count = 0;
+                    else
+                        count -= 1;
+                    AssetReference.currentlyInstantiating.set(this.uri, count);
+                });
+            }
+        }
+        else if (debug)
+            console.warn("Failed to load asset", this.uri);
+        return null;
+    }
+    /**
+     * try to ignore the intermediate created object
+     * because it causes trouble if we instantiate an assetreference per player
+     * and call destroy on the player marker root
+     * @returns the scene root object if the asset was a glb/gltf
+     */
+    tryGetActualGameObjectRoot(asset) {
+        if (asset && asset.scene) {
+            // some exporters produce additional root objects
+            const scene = asset.scene;
+            if (scene.isGroup && scene.children.length === 1 && scene.children[0].name + "glb" === scene.name) {
+                const root = scene.children[0];
+                return root;
+            }
+            // ok the scene is the scene, just use that then
+            else
+                return scene;
+        }
+        return null;
+    }
+}
+class AddressableSerializer extends TypeSerializer {
+    constructor() {
+        super([AssetReference]);
+    }
+    onSerialize(data, _context) {
+        if (data && data.uri !== undefined && typeof data.uri === "string") {
+            return data.uri;
+        }
+    }
+    onDeserialize(data, context) {
+        if (typeof data === "string") {
+            if (!context.context) {
+                console.error("Missing context");
+                return null;
+            }
+            if (!context.gltfId) {
+                console.error("Missing source id");
+                return null;
+            }
+            const ref = AssetReference.getOrCreate(context.gltfId, data, context.context);
+            return ref;
+        }
+        else if (data instanceof Object3D) {
+            if (!context.context) {
+                console.error("Missing context");
+                return null;
+            }
+            if (!context.gltfId) {
+                console.error("Missing source id");
+                return null;
+            }
+            const obj = data;
+            const ctx = context.context;
+            const guid = obj["guid"] ?? obj.uuid;
+            const existing = ctx.addressables.findAssetReference(guid);
+            if (existing)
+                return existing;
+            const ref = new AssetReference(guid, undefined, obj);
+            ctx.addressables.registerAssetReference(ref);
+            return ref;
+        }
+        return null;
+    }
+}
+new AddressableSerializer();
+const failedTexturePromise = Promise.resolve(null);
+export class ImageReference {
+    static imageReferences = new Map();
+    static getOrCreate(url) {
+        let ref = ImageReference.imageReferences.get(url);
+        if (!ref) {
+            ref = new ImageReference(url);
+            ImageReference.imageReferences.set(url, ref);
+        }
+        return ref;
+    }
+    constructor(url) {
+        this.url = url;
+    }
+    url;
+    _bitmap;
+    _bitmapObject;
+    dispose() {
+        if (this._bitmapObject) {
+            this._bitmapObject.close();
+        }
+        this._bitmap = undefined;
+    }
+    createHTMLImage() {
+        const img = new Image();
+        img.src = this.url;
+        return img;
+    }
+    loader = null;
+    createTexture() {
+        if (!this.url)
+            return failedTexturePromise;
+        if (!this.loader)
+            this.loader = new TextureLoader();
+        this.loader.setCrossOrigin("anonymous");
+        return this.loader.loadAsync(this.url);
+        // return this.getBitmap().then((bitmap) => {
+        //     if (bitmap) {
+        //         const texture = new Texture(bitmap);
+        //         texture.needsUpdate = true;
+        //         return texture;
+        //     }
+        //     return null;
+        // });
+    }
+    /** Loads the bitmap data of the image */
+    getBitmap() {
+        if (this._bitmap)
+            return this._bitmap;
+        this._bitmap = new Promise((res, _) => {
+            const imageElement = document.createElement("img");
+            imageElement.addEventListener("load", () => {
+                this._bitmap = createImageBitmap(imageElement).then((bitmap) => {
+                    this._bitmapObject = bitmap;
+                    res(bitmap);
+                    return bitmap;
+                });
+            });
+            imageElement.addEventListener("error", err => {
+                console.error("Failed to load image:" + this.url, err);
+                res(null);
+            });
+            imageElement.src = this.url;
+        });
+        return this._bitmap;
+    }
+}
+export class ImageReferenceSerializer extends TypeSerializer {
+    constructor() {
+        super([ImageReference]);
+    }
+    onSerialize(_data, _context) {
+        return null;
+    }
+    onDeserialize(data, _context) {
+        if (typeof data === "string") {
+            const url = resolveUrl(_context.gltfId, data);
+            return ImageReference.getOrCreate(url);
+        }
+        return undefined;
+    }
+}
+new ImageReferenceSerializer();
 //# sourceMappingURL=engine_addressables.js.map