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

package/lib/engine/extensions/NEEDLE_progressive.js

@@ -1,367 +1,367 @@
-import { RawShaderMaterial, Texture, TextureLoader } from "three";
-import { GLTFLoader } from "three/examples/jsm/loaders/GLTFLoader.js";
-import { addDracoAndKTX2Loaders } from "../engine_loaders.js";
-import { PromiseAllWithErrors, delay, getParam, resolveUrl } from "../engine_utils.js";
-export const EXTENSION_NAME = "NEEDLE_progressive";
-const debug = getParam("debugprogressive");
-const $progressiveTextureExtension = Symbol("needle-progressive-texture");
-const debug_toggle_maps = new Map();
-let show_lod0 = false;
-if (debug) {
-    window.addEventListener("keyup", evt => {
-        if (evt.key === "p") {
-            debug_toggle_maps.forEach((map, material) => {
-                Object.entries(map).forEach(([key, value]) => {
-                    if (show_lod0) {
-                        material[key] = value.lod0;
-                    }
-                    else {
-                        material[key] = value.original;
-                    }
-                    material.needsUpdate = true;
-                });
-            });
-            show_lod0 = !show_lod0;
-        }
-    });
-}
-export class NEEDLE_progressive {
-    get name() {
-        return EXTENSION_NAME;
-    }
-    static assignTextureLOD(context, source, material, level = 0) {
-        if (!material)
-            return Promise.resolve(null);
-        const promises = [];
-        if (material instanceof RawShaderMaterial) {
-            // iterate uniforms of custom shaders
-            for (const slot of Object.keys(material.uniforms)) {
-                const val = material.uniforms[slot].value;
-                if (val instanceof Texture) {
-                    const task = this.assignTextureLODForSlot(context, source, material, level, slot, val);
-                    promises.push(task);
-                }
-            }
-        }
-        else {
-            for (const slot of Object.keys(material)) {
-                const val = material[slot];
-                if (val instanceof Texture) {
-                    const task = this.assignTextureLODForSlot(context, source, material, level, slot, val);
-                    promises.push(task);
-                }
-            }
-        }
-        return PromiseAllWithErrors(promises);
-    }
-    static assignTextureLODForSlot(context, source, material, level, slot, val) {
-        if (val?.isTexture !== true)
-            return Promise.resolve(null);
-        if (debug)
-            console.log("-----------\n", "FIND", material.name, slot, val?.name, val?.userData, val, material);
-        return NEEDLE_progressive.getOrLoadTexture(context, source, material, slot, val, level).then(t => {
-            if (t?.isTexture === true) {
-                if (debug)
-                    console.warn("Assign LOD", material.name, slot, t.name, t["guid"], material, "Prev:", val, "Now:", t, "\n--------------");
-                material[slot] = t;
-                t.needsUpdate = true;
-                material.needsUpdate = true;
-                if (debug) {
-                    let debug_map = debug_toggle_maps.get(material);
-                    if (!debug_map) {
-                        debug_map = {};
-                        debug_toggle_maps.set(material, debug_map);
-                    }
-                    let entry = debug_map[slot];
-                    if (!entry) {
-                        entry = debug_map[slot] = { original: val, lod0: t };
-                    }
-                    entry.lod0 = t;
-                }
-                return t;
-            }
-            return null;
-        });
-    }
-    parser;
-    sourceId;
-    context;
-    constructor(parser, sourceId, context) {
-        this.parser = parser;
-        this.sourceId = sourceId;
-        this.context = context;
-    }
-    afterRoot(gltf) {
-        if (debug)
-            console.log("AFTER", this.sourceId, gltf);
-        this.parser.json.textures?.forEach((textureInfo, index) => {
-            if (textureInfo?.extensions) {
-                const ext = textureInfo?.extensions[EXTENSION_NAME];
-                if (ext) {
-                    const prom = this.parser.getDependency("texture", index);
-                    prom.then(t => {
-                        if (debug)
-                            console.log("> Progressive: register", t.name, t.uuid, ext);
-                        // Put the extension info into the source (seems like tiled textures are cloned and the userdata etc is not properly copied BUT the source of course is not cloned)
-                        // see https://github.com/needle-tools/needle-engine-support/issues/133
-                        if (t.source)
-                            t.source[$progressiveTextureExtension] = ext;
-                        NEEDLE_progressive.cache.set(t.uuid, ext);
-                    });
-                }
-            }
-        });
-        return null;
-    }
-    static cache = new Map();
-    static resolved = {};
-    static currentlyLoading = {};
-    static async getOrLoadTexture(context, source, material, slot, current, _level) {
-        const key = current.uuid;
-        let progressiveInfo;
-        // See https://github.com/needle-tools/needle-engine-support/issues/133
-        if (current.source && current.source[$progressiveTextureExtension])
-            progressiveInfo = current.source[$progressiveTextureExtension];
-        if (!progressiveInfo)
-            progressiveInfo = NEEDLE_progressive.cache.get(key);
-        if (progressiveInfo) {
-            if (debug)
-                console.log(key, progressiveInfo.uri, progressiveInfo.guid);
-            const uri = resolveUrl(source, progressiveInfo.uri);
-            if (uri.endsWith(".glb") || uri.endsWith(".gltf")) {
-                if (!progressiveInfo.guid) {
-                    console.warn("missing pointer for glb/gltf texture", progressiveInfo);
-                    return null;
-                }
-                const resolveKey = uri + "_" + progressiveInfo.guid;
-                if (this.resolved[resolveKey]) {
-                    let res = this.resolved[resolveKey];
-                    // check if the texture has been disposed or not
-                    if (res.image?.data || res.source?.data) {
-                        if (debug)
-                            console.log("Texture has already been loaded: " + resolveKey, material.name, slot, current.name, res);
-                        res = this.copySettings(current, res);
-                        return res;
-                    }
-                    else if (res) {
-                        if (debug)
-                            console.warn("Texture has been disposed, will load again: " + resolveKey, material.name, slot, current.name, res.source.data);
-                    }
-                }
-                const info = this.onProgressiveLoadStart(context, source, uri, material, slot);
-                try {
-                    if (this.currentlyLoading[resolveKey] !== undefined) {
-                        if (debug)
-                            console.log("Already loading:", material.name + "." + slot, resolveKey);
-                        let res = await this.currentlyLoading[resolveKey];
-                        if (res)
-                            res = this.copySettings(current, res);
-                        return res;
-                    }
-                    const ext = progressiveInfo;
-                    const request = new Promise(async (resolve, _) => {
-                        const loader = new GLTFLoader();
-                        addDracoAndKTX2Loaders(loader, context);
-                        if (debug)
-                            console.warn("Start loading " + uri, material.name, slot, ext.guid);
-                        if (debug) {
-                            await delay(Math.random() * 1000);
-                        }
-                        const gltf = await loader.loadAsync(uri);
-                        const parser = gltf.parser;
-                        if (debug)
-                            console.log("Loading finished " + uri, material.name, slot, ext.guid);
-                        let index = -1;
-                        let found = false;
-                        if (!gltf.parser.json?.textures) {
-                            if (debug)
-                                console.warn("No textures in glTF " + uri + " - may be a bug", material.name, slot, ext.guid);
-                            return resolve(null);
-                        }
-                        for (const tex of gltf.parser.json.textures) {
-                            index++;
-                            if (tex?.extensions) {
-                                const other = tex?.extensions[EXTENSION_NAME];
-                                if (other?.guid) {
-                                    if (other.guid === ext.guid) {
-                                        found = true;
-                                        break;
-                                    }
-                                }
-                            }
-                        }
-                        if (!found)
-                            return resolve(null);
-                        let tex = await parser.getDependency("texture", index);
-                        tex = this.copySettings(current, tex);
-                        if (tex) {
-                            tex.guid = ext.guid;
-                        }
-                        this.resolved[resolveKey] = tex;
-                        if (debug)
-                            console.log(material.name, slot, "change \"" + current.name + "\" → \"" + tex.name + "\"", uri, index, tex, material, resolveKey);
-                        resolve(tex);
-                    });
-                    this.currentlyLoading[resolveKey] = request;
-                    const tex = await request;
-                    return tex;
-                }
-                finally {
-                    delete this.currentlyLoading[resolveKey];
-                    this.onProgressiveLoadEnd(info);
-                }
-            }
-            else {
-                const info = this.onProgressiveLoadStart(context, source, uri, material, slot);
-                try {
-                    if (debug)
-                        console.log("Load texture from uri: " + uri);
-                    const loader = new TextureLoader();
-                    const tex = await loader.loadAsync(uri);
-                    if (tex) {
-                        tex.guid = progressiveInfo.guid;
-                        tex.flipY = false;
-                        tex.needsUpdate = true;
-                        tex.colorSpace = current.colorSpace;
-                        if (debug)
-                            console.log(progressiveInfo, tex);
-                    }
-                    else if (debug)
-                        console.warn("failed loading", uri);
-                    return tex;
-                }
-                finally {
-                    this.onProgressiveLoadEnd(info);
-                }
-            }
-            // loader.then((h: Texture) => {
-            //     // console.log(t, h);
-            //     // t.image = h.image;
-            //     // // this.context.renderer.copyTextureToTexture(new Vector2(0, 0), h, t);
-            //     // // console.log(h);
-            //     // // t.source = h.source;
-            //     // // t.version++;
-            //     // t.width = h.width;
-            //     // t.height = h.height;
-            //     // t.needsUpdate = true;
-            // });
-        }
-        else {
-            if (debug)
-                console.warn("unknown texture", current.name, current.uuid, current);
-        }
-        return null;
-    }
-    static copySettings(source, target) {
-        // We need to clone e.g. when the same texture is used multiple times (but with e.g. different wrap settings)
-        // This is relatively cheap since it only stores settings
-        const res = source.clone();
-        const src = target.source;
-        const mips = target.mipmaps;
-        res.copy(source);
-        res.source = src;
-        res.mipmaps = mips;
-        return res;
-    }
-    /** subscribe to events whenever a loading event starts, invoked for every single loading process that starts */
-    static beginListenStart(context, evt) {
-        if (!this._progressiveEventListeners.has(context)) {
-            this._progressiveEventListeners.set(context, new ProgressiveLoadingEventHandler());
-        }
-        this._progressiveEventListeners.get(context).start.push(evt);
-    }
-    static stopListenStart(context, evt) {
-        if (!this._progressiveEventListeners.has(context)) {
-            return;
-        }
-        const listeners = this._progressiveEventListeners.get(context).start;
-        const index = listeners.indexOf(evt);
-        if (index >= 0) {
-            listeners.splice(index, 1);
-        }
-    }
-    /** subscribe to loading event ended event */
-    static beginListenEnd(context, evt) {
-        if (!this._progressiveEventListeners.has(context)) {
-            this._progressiveEventListeners.set(context, new ProgressiveLoadingEventHandler());
-        }
-        this._progressiveEventListeners.get(context).end.push(evt);
-    }
-    static stopListenEnd(context, evt) {
-        if (!this._progressiveEventListeners.has(context)) {
-            return;
-        }
-        const listeners = this._progressiveEventListeners.get(context).end;
-        const index = listeners.indexOf(evt);
-        if (index >= 0) {
-            listeners.splice(index, 1);
-        }
-    }
-    /** event listeners per context */
-    static _progressiveEventListeners = new Map();
-    //** loading info per context, contains an array of urls that are currently being loaded */
-    static _currentProgressiveLoadingInfo = new Map();
-    // called whenever a progressive loading event starts
-    static onProgressiveLoadStart(context, source, uri, material, slot) {
-        if (!this._currentProgressiveLoadingInfo.has(context)) {
-            this._currentProgressiveLoadingInfo.set(context, []);
-        }
-        const info = new ProgressiveLoadingInfo(context, source, uri, material, slot);
-        const current = this._currentProgressiveLoadingInfo.get(context);
-        const listener = this._progressiveEventListeners.get(context);
-        if (listener)
-            listener.onStart(info);
-        current.push(info);
-        return info;
-    }
-    static onProgressiveLoadEnd(info) {
-        if (!info)
-            return;
-        const context = info.context;
-        if (!this._currentProgressiveLoadingInfo.has(context)) {
-            return;
-        }
-        const current = this._currentProgressiveLoadingInfo.get(context);
-        const index = current.indexOf(info);
-        if (index < 0) {
-            return;
-        }
-        current.splice(index, 1);
-        const listener = this._progressiveEventListeners.get(context);
-        if (listener)
-            listener.onEnd(info);
-    }
-}
-/** info object that holds information about a file that is currently being loaded */
-export class ProgressiveLoadingInfo {
-    context;
-    source;
-    uri;
-    material;
-    slot;
-    // TODO: can contain information if the event is a background process / preloading or if the object is currently visible
-    constructor(context, source, uri, material, slot) {
-        this.context = context;
-        this.source = source;
-        this.uri = uri;
-        this.material = material;
-        this.slot = slot;
-    }
-}
-;
-/** progressive loading event handler implementation */
-class ProgressiveLoadingEventHandler {
-    start = [];
-    end = [];
-    onStart(listener) {
-        for (const l of this.start) {
-            l(listener);
-        }
-    }
-    onEnd(listener) {
-        for (const l of this.end) {
-            l(listener);
-        }
-    }
-}
+import { RawShaderMaterial, Texture, TextureLoader } from "three";
+import { GLTFLoader } from "three/examples/jsm/loaders/GLTFLoader.js";
+import { addDracoAndKTX2Loaders } from "../engine_loaders.js";
+import { PromiseAllWithErrors, delay, getParam, resolveUrl } from "../engine_utils.js";
+export const EXTENSION_NAME = "NEEDLE_progressive";
+const debug = getParam("debugprogressive");
+const $progressiveTextureExtension = Symbol("needle-progressive-texture");
+const debug_toggle_maps = new Map();
+let show_lod0 = false;
+if (debug) {
+    window.addEventListener("keyup", evt => {
+        if (evt.key === "p") {
+            debug_toggle_maps.forEach((map, material) => {
+                Object.entries(map).forEach(([key, value]) => {
+                    if (show_lod0) {
+                        material[key] = value.lod0;
+                    }
+                    else {
+                        material[key] = value.original;
+                    }
+                    material.needsUpdate = true;
+                });
+            });
+            show_lod0 = !show_lod0;
+        }
+    });
+}
+export class NEEDLE_progressive {
+    get name() {
+        return EXTENSION_NAME;
+    }
+    static assignTextureLOD(context, source, material, level = 0) {
+        if (!material)
+            return Promise.resolve(null);
+        const promises = [];
+        if (material instanceof RawShaderMaterial) {
+            // iterate uniforms of custom shaders
+            for (const slot of Object.keys(material.uniforms)) {
+                const val = material.uniforms[slot].value;
+                if (val instanceof Texture) {
+                    const task = this.assignTextureLODForSlot(context, source, material, level, slot, val);
+                    promises.push(task);
+                }
+            }
+        }
+        else {
+            for (const slot of Object.keys(material)) {
+                const val = material[slot];
+                if (val instanceof Texture) {
+                    const task = this.assignTextureLODForSlot(context, source, material, level, slot, val);
+                    promises.push(task);
+                }
+            }
+        }
+        return PromiseAllWithErrors(promises);
+    }
+    static assignTextureLODForSlot(context, source, material, level, slot, val) {
+        if (val?.isTexture !== true)
+            return Promise.resolve(null);
+        if (debug)
+            console.log("-----------\n", "FIND", material.name, slot, val?.name, val?.userData, val, material);
+        return NEEDLE_progressive.getOrLoadTexture(context, source, material, slot, val, level).then(t => {
+            if (t?.isTexture === true) {
+                if (debug)
+                    console.warn("Assign LOD", material.name, slot, t.name, t["guid"], material, "Prev:", val, "Now:", t, "\n--------------");
+                material[slot] = t;
+                t.needsUpdate = true;
+                material.needsUpdate = true;
+                if (debug) {
+                    let debug_map = debug_toggle_maps.get(material);
+                    if (!debug_map) {
+                        debug_map = {};
+                        debug_toggle_maps.set(material, debug_map);
+                    }
+                    let entry = debug_map[slot];
+                    if (!entry) {
+                        entry = debug_map[slot] = { original: val, lod0: t };
+                    }
+                    entry.lod0 = t;
+                }
+                return t;
+            }
+            return null;
+        });
+    }
+    parser;
+    sourceId;
+    context;
+    constructor(parser, sourceId, context) {
+        this.parser = parser;
+        this.sourceId = sourceId;
+        this.context = context;
+    }
+    afterRoot(gltf) {
+        if (debug)
+            console.log("AFTER", this.sourceId, gltf);
+        this.parser.json.textures?.forEach((textureInfo, index) => {
+            if (textureInfo?.extensions) {
+                const ext = textureInfo?.extensions[EXTENSION_NAME];
+                if (ext) {
+                    const prom = this.parser.getDependency("texture", index);
+                    prom.then(t => {
+                        if (debug)
+                            console.log("> Progressive: register", t.name, t.uuid, ext);
+                        // Put the extension info into the source (seems like tiled textures are cloned and the userdata etc is not properly copied BUT the source of course is not cloned)
+                        // see https://github.com/needle-tools/needle-engine-support/issues/133
+                        if (t.source)
+                            t.source[$progressiveTextureExtension] = ext;
+                        NEEDLE_progressive.cache.set(t.uuid, ext);
+                    });
+                }
+            }
+        });
+        return null;
+    }
+    static cache = new Map();
+    static resolved = {};
+    static currentlyLoading = {};
+    static async getOrLoadTexture(context, source, material, slot, current, _level) {
+        const key = current.uuid;
+        let progressiveInfo;
+        // See https://github.com/needle-tools/needle-engine-support/issues/133
+        if (current.source && current.source[$progressiveTextureExtension])
+            progressiveInfo = current.source[$progressiveTextureExtension];
+        if (!progressiveInfo)
+            progressiveInfo = NEEDLE_progressive.cache.get(key);
+        if (progressiveInfo) {
+            if (debug)
+                console.log(key, progressiveInfo.uri, progressiveInfo.guid);
+            const uri = resolveUrl(source, progressiveInfo.uri);
+            if (uri.endsWith(".glb") || uri.endsWith(".gltf")) {
+                if (!progressiveInfo.guid) {
+                    console.warn("missing pointer for glb/gltf texture", progressiveInfo);
+                    return null;
+                }
+                const resolveKey = uri + "_" + progressiveInfo.guid;
+                if (this.resolved[resolveKey]) {
+                    let res = this.resolved[resolveKey];
+                    // check if the texture has been disposed or not
+                    if (res.image?.data || res.source?.data) {
+                        if (debug)
+                            console.log("Texture has already been loaded: " + resolveKey, material.name, slot, current.name, res);
+                        res = this.copySettings(current, res);
+                        return res;
+                    }
+                    else if (res) {
+                        if (debug)
+                            console.warn("Texture has been disposed, will load again: " + resolveKey, material.name, slot, current.name, res.source.data);
+                    }
+                }
+                const info = this.onProgressiveLoadStart(context, source, uri, material, slot);
+                try {
+                    if (this.currentlyLoading[resolveKey] !== undefined) {
+                        if (debug)
+                            console.log("Already loading:", material.name + "." + slot, resolveKey);
+                        let res = await this.currentlyLoading[resolveKey];
+                        if (res)
+                            res = this.copySettings(current, res);
+                        return res;
+                    }
+                    const ext = progressiveInfo;
+                    const request = new Promise(async (resolve, _) => {
+                        const loader = new GLTFLoader();
+                        addDracoAndKTX2Loaders(loader, context);
+                        if (debug)
+                            console.warn("Start loading " + uri, material.name, slot, ext.guid);
+                        if (debug) {
+                            await delay(Math.random() * 1000);
+                        }
+                        const gltf = await loader.loadAsync(uri);
+                        const parser = gltf.parser;
+                        if (debug)
+                            console.log("Loading finished " + uri, material.name, slot, ext.guid);
+                        let index = -1;
+                        let found = false;
+                        if (!gltf.parser.json?.textures) {
+                            if (debug)
+                                console.warn("No textures in glTF " + uri + " - may be a bug", material.name, slot, ext.guid);
+                            return resolve(null);
+                        }
+                        for (const tex of gltf.parser.json.textures) {
+                            index++;
+                            if (tex?.extensions) {
+                                const other = tex?.extensions[EXTENSION_NAME];
+                                if (other?.guid) {
+                                    if (other.guid === ext.guid) {
+                                        found = true;
+                                        break;
+                                    }
+                                }
+                            }
+                        }
+                        if (!found)
+                            return resolve(null);
+                        let tex = await parser.getDependency("texture", index);
+                        tex = this.copySettings(current, tex);
+                        if (tex) {
+                            tex.guid = ext.guid;
+                        }
+                        this.resolved[resolveKey] = tex;
+                        if (debug)
+                            console.log(material.name, slot, "change \"" + current.name + "\" → \"" + tex.name + "\"", uri, index, tex, material, resolveKey);
+                        resolve(tex);
+                    });
+                    this.currentlyLoading[resolveKey] = request;
+                    const tex = await request;
+                    return tex;
+                }
+                finally {
+                    delete this.currentlyLoading[resolveKey];
+                    this.onProgressiveLoadEnd(info);
+                }
+            }
+            else {
+                const info = this.onProgressiveLoadStart(context, source, uri, material, slot);
+                try {
+                    if (debug)
+                        console.log("Load texture from uri: " + uri);
+                    const loader = new TextureLoader();
+                    const tex = await loader.loadAsync(uri);
+                    if (tex) {
+                        tex.guid = progressiveInfo.guid;
+                        tex.flipY = false;
+                        tex.needsUpdate = true;
+                        tex.colorSpace = current.colorSpace;
+                        if (debug)
+                            console.log(progressiveInfo, tex);
+                    }
+                    else if (debug)
+                        console.warn("failed loading", uri);
+                    return tex;
+                }
+                finally {
+                    this.onProgressiveLoadEnd(info);
+                }
+            }
+            // loader.then((h: Texture) => {
+            //     // console.log(t, h);
+            //     // t.image = h.image;
+            //     // // this.context.renderer.copyTextureToTexture(new Vector2(0, 0), h, t);
+            //     // // console.log(h);
+            //     // // t.source = h.source;
+            //     // // t.version++;
+            //     // t.width = h.width;
+            //     // t.height = h.height;
+            //     // t.needsUpdate = true;
+            // });
+        }
+        else {
+            if (debug)
+                console.warn("unknown texture", current.name, current.uuid, current);
+        }
+        return null;
+    }
+    static copySettings(source, target) {
+        // We need to clone e.g. when the same texture is used multiple times (but with e.g. different wrap settings)
+        // This is relatively cheap since it only stores settings
+        const res = source.clone();
+        const src = target.source;
+        const mips = target.mipmaps;
+        res.copy(source);
+        res.source = src;
+        res.mipmaps = mips;
+        return res;
+    }
+    /** subscribe to events whenever a loading event starts, invoked for every single loading process that starts */
+    static beginListenStart(context, evt) {
+        if (!this._progressiveEventListeners.has(context)) {
+            this._progressiveEventListeners.set(context, new ProgressiveLoadingEventHandler());
+        }
+        this._progressiveEventListeners.get(context).start.push(evt);
+    }
+    static stopListenStart(context, evt) {
+        if (!this._progressiveEventListeners.has(context)) {
+            return;
+        }
+        const listeners = this._progressiveEventListeners.get(context).start;
+        const index = listeners.indexOf(evt);
+        if (index >= 0) {
+            listeners.splice(index, 1);
+        }
+    }
+    /** subscribe to loading event ended event */
+    static beginListenEnd(context, evt) {
+        if (!this._progressiveEventListeners.has(context)) {
+            this._progressiveEventListeners.set(context, new ProgressiveLoadingEventHandler());
+        }
+        this._progressiveEventListeners.get(context).end.push(evt);
+    }
+    static stopListenEnd(context, evt) {
+        if (!this._progressiveEventListeners.has(context)) {
+            return;
+        }
+        const listeners = this._progressiveEventListeners.get(context).end;
+        const index = listeners.indexOf(evt);
+        if (index >= 0) {
+            listeners.splice(index, 1);
+        }
+    }
+    /** event listeners per context */
+    static _progressiveEventListeners = new Map();
+    //** loading info per context, contains an array of urls that are currently being loaded */
+    static _currentProgressiveLoadingInfo = new Map();
+    // called whenever a progressive loading event starts
+    static onProgressiveLoadStart(context, source, uri, material, slot) {
+        if (!this._currentProgressiveLoadingInfo.has(context)) {
+            this._currentProgressiveLoadingInfo.set(context, []);
+        }
+        const info = new ProgressiveLoadingInfo(context, source, uri, material, slot);
+        const current = this._currentProgressiveLoadingInfo.get(context);
+        const listener = this._progressiveEventListeners.get(context);
+        if (listener)
+            listener.onStart(info);
+        current.push(info);
+        return info;
+    }
+    static onProgressiveLoadEnd(info) {
+        if (!info)
+            return;
+        const context = info.context;
+        if (!this._currentProgressiveLoadingInfo.has(context)) {
+            return;
+        }
+        const current = this._currentProgressiveLoadingInfo.get(context);
+        const index = current.indexOf(info);
+        if (index < 0) {
+            return;
+        }
+        current.splice(index, 1);
+        const listener = this._progressiveEventListeners.get(context);
+        if (listener)
+            listener.onEnd(info);
+    }
+}
+/** info object that holds information about a file that is currently being loaded */
+export class ProgressiveLoadingInfo {
+    context;
+    source;
+    uri;
+    material;
+    slot;
+    // TODO: can contain information if the event is a background process / preloading or if the object is currently visible
+    constructor(context, source, uri, material, slot) {
+        this.context = context;
+        this.source = source;
+        this.uri = uri;
+        this.material = material;
+        this.slot = slot;
+    }
+}
+;
+/** progressive loading event handler implementation */
+class ProgressiveLoadingEventHandler {
+    start = [];
+    end = [];
+    onStart(listener) {
+        for (const l of this.start) {
+            l(listener);
+        }
+    }
+    onEnd(listener) {
+        for (const l of this.end) {
+            l(listener);
+        }
+    }
+}
 //# sourceMappingURL=NEEDLE_progressive.js.map