@luminocity/lemonate-engine 15.2.2 → 15.2.3

package/dist/LoadingManager.js

@@ -1,1195 +0,0 @@
-// -----------------------------------------------------------------------------------------------------------
-//  __         ______     __    __     ______     __   __     ______     ______   ______
-// /\ \       /\  ___\   /\ "-./  \   /\  __ \   /\ "-.\ \   /\  __ \   /\__  _\ /\  ___\
-// \ \ \____  \ \  __\   \ \ \-./\ \  \ \ \/\ \  \ \ \-.  \  \ \  __ \  \/_/\ \/ \ \  __\
-//  \ \_____\  \ \_____\  \ \_\ \ \_\  \ \_____\  \ \_\\"\_\  \ \_\ \_\    \ \_\  \ \_____\
-//   \/_____/   \/_____/   \/_/  \/_/   \/_____/   \/_/ \/_/   \/_/\/_/     \/_/   \/_____/
-//
-//
-// Copyright 2023- Luminocity AG
-//
-// "The cake is a lie." - Portal (2007)
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy of this software
-// and associated documentation files (the “Software”), to deal in the Software without restriction,
-// including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
-// and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
-// subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all copies or substantial
-// portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
-// LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-// SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-// -----------------------------------------------------------------------------------------------------------
-import lodash from 'lodash';
-import { AudioItem } from "./items/AudioItem";
-import { AudioCollectionItem } from './items/AudioCollectionItem';
-import { BackgroundShaderItem } from "./items/BackgroundShaderItem";
-import { CanvasTextureItem } from "./items/CanvasTextureItem";
-import { CompositionItem } from './items/CompositionItem';
-import { FontItem } from "./items/FontItem";
-import { GaussianSplatsItem } from './items/GaussianSplatsItem';
-import { GridMapItem } from "./items/GridMapItem";
-import { MaterialItem } from "./items/MaterialItem";
-import { MaterialCollectionItem } from "./items/MaterialCollectionItem";
-import { MeshItem } from "./items/MeshItem";
-import { MeshCollectionItem } from "./items/MeshCollectionItem";
-import { ParticlesItem } from "./items/ParticlesItem";
-import { PixelShaderItem } from "./items/PixelShaderItem";
-import { PointsItem } from "./items/PointsItem";
-import { PrefabItem } from "./items/PrefabItem";
-import { ProjectItem } from './items/ProjectItem';
-import { SceneItem } from "./items/SceneItem";
-import { ScriptItem } from "./items/ScriptItem";
-import { ImageItem } from "./items/ImageItem";
-import { VariableSetItem } from './items/VariableSetItem';
-import { VertexShaderItem } from "./items/VertexShaderItem";
-import { VideoItem } from "./items/VideoItem";
-import { ItemState, itemStateToString } from "./items/Item";
-import tools from "./Tools.js";
-import { LoadingState } from "./LoadingState.js";
-// Once all references to an object are removed, it can be destroyed and removed from memory. In many cases it
-// is more than possible that it will be instanced again within short period of time. So define a period of time
-// where deleted objects will be kept until garbage collected
-const DELETION_GRACE_PERIOD_MS = 10000;
-// This is the maximum time we accept a create() method to take before we output a warning. anything time consuming
-// like loading resources should be done in load() not in create()
-const MAX_ACCEPTABLE_CREATE_TIME_MS = 10;
-export class LoadingManager {
-    gpuRamQuota;
-    renderer;
-    engine;
-    debugMode;
-    deletionGracePeriodMs = DELETION_GRACE_PERIOD_MS;
-    startTime = new Date();
-    endTime;
-    totalTime;
-    // Ready defines the moment, the scene is fully renderable in at least the lowest LOD
-    readyTime;
-    secondsToReady;
-    // Finished defines the moment all resources of the scene are fully ready and we can render in full quality
-    finishedTime;
-    secondsToFinished;
-    active = true;
-    // This map keeps track of what state changes should resolve which Promises.
-    waitForStateMap = new Map();
-    itemsToLoad = [];
-    itemsMap = new Map();
-    itemsTypeMap = new Map();
-    itemsByTypeMap = new Map();
-    _removeEvents;
-    _intervalHandle;
-    _clearIntervalHandle;
-    constructor(renderer, engine, debugMode, gpuRamQuota) {
-        gpuRamQuota = gpuRamQuota === undefined ? 512 : gpuRamQuota;
-        tools.assert(renderer, "LoadingManager: renderer must be set in NkLoadingManager");
-        tools.assert(engine, "LoadingManager: engine must be set in NkLoadingManager");
-        this.debugMode = debugMode || false;
-        this.renderer = renderer;
-        this.engine = engine;
-        this.gpuRamQuota = gpuRamQuota * 1024 * 1024;
-        this.reset();
-        const _refreshReadyState = lodash.debounce(() => {
-            function printState(arr, level) {
-                const padding = "".padEnd(level, " ");
-                for (const info of arr) {
-                    console.log(padding, info.item.item.name, "TYPE:" + info.item.item.type, "OWN:" + itemStateToString(info.ownState), "ACU:" + itemStateToString(info.state));
-                    printState(info.children, ++level);
-                }
-            }
-            const info = [];
-            const state = this.engine.getReadyState(info);
-            if (this.debugMode) {
-                console.log("Loading manager debug output --------------------------------------------------");
-                console.log("Final state: " + itemStateToString(state));
-                printState(info, 0);
-                console.log("-------------------------------------------------------------------------------");
-            }
-            if (state === ItemState.Alive) {
-                this._ready();
-            }
-            else if (state === ItemState.Finished) {
-                this._finished();
-            }
-        }, 10);
-        this.engine.eventBus.$on('item:stateChanged', _refreshReadyState);
-        this.engine.eventBus.$on('item:contentUpdated', _refreshReadyState);
-        this.engine.eventBus.$on('item:rename', (data) => this._handleRename(data), this);
-        this.engine.eventBus.$on('item:stateChanged', (data) => {
-            const itemID = data.item.item._id;
-            // If this item just finished loading and there are promises waiting for it, resolve them.
-            const funcs = this.waitForStateMap.get(itemID);
-            if (funcs && data.item.state === ItemState.Finished) {
-                for (const resolveFunc of funcs) {
-                    resolveFunc();
-                }
-                this.waitForStateMap.delete(itemID);
-            }
-        });
-        this._removeEvents = () => {
-            this.engine.eventBus.$off('item:stateChanged', _refreshReadyState);
-            this.engine.eventBus.$off('item:contentUpdated', _refreshReadyState);
-            this.engine.eventBus.$offByOwner('item:rename', this);
-        };
-    }
-    setDeletionGracePeriod(ms) {
-        tools.assert(ms >= 0, "Deletion grace period needs to be >= 0");
-        this.deletionGracePeriodMs = ms;
-    }
-    dispose() {
-        if (this._intervalHandle) {
-            clearInterval(this._intervalHandle);
-            this._intervalHandle = null;
-        }
-        if (this._clearIntervalHandle) {
-            clearInterval(this._clearIntervalHandle);
-            this._clearIntervalHandle = null;
-        }
-        this._removeEvents();
-    }
-    run() {
-        const _this = this;
-        this._intervalHandle = setInterval(function () {
-            _this._run();
-        }, 50);
-        this._clearIntervalHandle = setInterval(function () {
-            _this._clearUnusedItemInstances();
-        }, 1000);
-    }
-    getItems() {
-        return this.itemsToLoad;
-    }
-    /**
-     * Returns a list of item instances if they have a render method and also are referenced
-     * @return {*[]}
-     */
-    getRenderableItemInstances() {
-        const result = [];
-        for (const entry of this.itemsToLoad) {
-            if (entry.references.size && entry.itemInstance && typeof entry.itemInstance.render === 'function') {
-                result.push(entry.itemInstance);
-            }
-        }
-        return result;
-    }
-    /**
-     * Checks if an item instance exists and if so, returns it and adds a reference
-     * @param itemId
-     * @param referenceId
-     * @returns {null|*}
-     * @private
-     */
-    _getItemInstance(itemId, referenceId) {
-        tools.assert(typeof referenceId === 'string' && referenceId !== "", "LoadingManager: Cannot request a resource from loading manager without a valid reference ID");
-        let entry = this.itemsMap.get(itemId);
-        if (!entry)
-            return undefined;
-        if (referenceId) {
-            entry.references.set(referenceId, true);
-            entry.unusedSince = undefined;
-            this.engine.eventBus.$emit('loadingManager:updated');
-        }
-        return entry.itemInstance;
-    }
-    /**
-     * Sets an item instance and adds its first reference
-     * @param id
-     * @param itemInstance
-     * @param referenceId
-     * @param isPrivate a private reference of an item is owned by exactly a single owner and cannot be shared.
-     * @private
-     */
-    _setItemInstance(id, itemInstance, referenceId, isPrivate = false) {
-        let entry = this.itemsMap.get(id);
-        if (entry) {
-            if (!isPrivate) {
-                if (referenceId)
-                    entry.references.set(referenceId, true);
-                if (entry.itemInstance) {
-                    console.error("Setting item instance reference although one is set already!", id);
-                }
-                entry.itemInstance = itemInstance;
-            }
-            else {
-                if (entry.itemPrivateInstances.has(referenceId)) {
-                    console.error("For this reference ID we already have an item instance. Cannot have two!");
-                }
-                entry.itemPrivateInstances.set(referenceId, itemInstance);
-            }
-            // In case the item was a composition, we need to update the editor output options.
-            if (itemInstance instanceof CompositionItem)
-                this.engine.renderer.updateEditorOutputOptions();
-            this.engine.eventBus.$emit('loadingManager:updated');
-        }
-    }
-    /**
-     * Unload a resource. If it has more references, only the reference is removed, otherwise it is
-     * destroyed for everyone
-     * @param referenceId
-     * @param itemInstance
-     */
-    unload(referenceId, itemInstance) {
-        tools.assert(itemInstance, "LoadingManager: Item instance not passed to method.");
-        tools.assert(typeof referenceId === 'string' && referenceId !== "", "LoadingManager: Cannot unload a resource from loading manager without a valid reference ID");
-        const id = itemInstance.getId();
-        let entry = this.itemsMap.get(id);
-        if (!entry)
-            return;
-        if (entry.references.has(referenceId)) {
-            entry.references.delete(referenceId);
-        }
-        else if (entry.itemPrivateInstances.has(referenceId)) {
-            const itemInstance = entry.itemPrivateInstances.get(referenceId);
-            try {
-                const p = itemInstance.destroy(false, true);
-                if (p && p.then) {
-                    p.catch((err) => {
-                        console.error(`LoadingManager: Error while destroying private item instance of ${id}`, err);
-                    });
-                }
-            }
-            catch (err) {
-                console.error(`LoadingManager: Error while destroying private item instance of ${id}`, err);
-            }
-            entry.itemPrivateInstances.delete(referenceId);
-        }
-        else {
-            console.warn(`LoadingManager: Object with ID ${referenceId} tried to remove reference from item ${id} but does not have one.`);
-        }
-        if (!entry.references.size && !entry.itemPrivateInstances.size) {
-            entry.unusedSince = new Date();
-        }
-        this.engine.eventBus.$emit('loadingManager:updated');
-    }
-    typeNameToType(name) {
-        switch (name) {
-            case "Texture": return ImageItem;
-            case "Material": return MaterialItem;
-            case "CanvasTexture": return CanvasTextureItem;
-            case "Mesh": return MeshItem;
-            default:
-                throw new Error("Item type not known: " + name);
-        }
-    }
-    async create(referenceId, typeName, attributes = {}) {
-        attributes = attributes || {};
-        const ItemType = this.typeNameToType(typeName);
-        const item = {
-            _id: tools.createGeneratedItemId(),
-            name: `Generated ${typeName}`,
-            type: typeName,
-            attributes: attributes,
-            links: [],
-            fields: [],
-            fieldInstances: [],
-            userFieldInstances: []
-        };
-        return this.load(referenceId, item, ItemType, null, attributes);
-    }
-    get(id, referenceId) {
-        return this._getItemInstance(id, referenceId);
-    }
-    /**
-     * This function returns an item instance by item ID but will not add a new reference to it.
-     * This means that this item reference could become invalid at any time without notice and should
-     * only be used to retrieve an item for immediate use and then toss the reference as it might not
-     * survive long.
-     * @param itemId
-     * @returns {null|*|null}
-     */
-    getWeakItemInstance(itemId) {
-        let entry = this.itemsMap.get(itemId);
-        if (!entry)
-            return null;
-        return entry.itemInstance;
-    }
-    async load(referenceId, item, ItemType, options, attributes) {
-        options = options || {};
-        // in case the item is a package, use its contents, not the item itself
-        if (item.type === "Package") {
-            item = item.packageContent;
-        }
-        // If the item should be recreated, don't return an already existing instance.
-        if (!options.recreate) {
-            const instance = this._getItemInstance(item._id, referenceId);
-            // Because add the item instance is set before creating the item,
-            // we need to also check if the item has already
-            // been created before returning its instance.
-            if (instance && instance.state !== ItemState.None) {
-                if (options.waitUntilFinished && instance.state !== ItemState.Finished) {
-                    await this._waitFor(instance, item._id);
-                }
-                return instance;
-            }
-        }
-        else {
-            // We want the item instance recreated. But for that to work and to be a true
-            // independant object of its own, the item model below has to be cloned, otherwise
-            // both will work on the same fields, blocks, etc.
-            item = this.engine.itemRepo.createNewItemInstance(item._id);
-        }
-        // add the item to the maps
-        this.addItem(item);
-        // create the new item instance
-        let itemObject;
-        if (Array.isArray(ItemType)) {
-            for (const Type of ItemType) {
-                if (item.type === Type.name) {
-                    itemObject = new Type.type(item, this.engine, this.renderer, options.lodMode);
-                }
-            }
-            if (!itemObject)
-                throw "Fitting item type not found!";
-        }
-        else {
-            // @ts-ignore
-            itemObject = new ItemType(item, this.engine, this.renderer, options.lodMode);
-        }
-        // make sure it is filled with all required field instances and make sure the default are set if something is missing
-        itemObject.setFieldInstanceDefaults();
-        if (attributes) {
-            itemObject.setFieldAndLinkValues(attributes);
-        }
-        // store the item instance
-        const isPrivate = options.recreate; // if we force recreate the item, this is now a privately owned instance.
-        this._setItemInstance(item._id, itemObject, referenceId, isPrivate);
-        // Create the item and time it. It should not take too long, anything expensive has to be done
-        // in load() not in create() so execution is not blocked unnecessarily
-        const startTime = Date.now();
-        const instance = await itemObject.create(options);
-        const endTime = Date.now();
-        const duration = Math.floor(endTime - startTime);
-        if (this.debugMode) {
-            if (duration > MAX_ACCEPTABLE_CREATE_TIME_MS) {
-                console.warn(`Creating ${itemObject.getType()} ${itemObject.getName()} took too long: ${duration}ms`);
-            }
-            else {
-                console.log(`Creating ${itemObject.getType()} ${itemObject.getName()} took: ${duration}ms`);
-            }
-        }
-        // Now load the item (if needed) asynchronously, we do not want to wait for it except in the case below
-        itemObject.load(options).catch(function (error) {
-            console.error(error);
-            console.error(`Error loading ${ItemType.constructor.name} ${item._id}`);
-        });
-        if (options.waitUntilFinished) {
-            // When the waitUntilFinished option is set, we additionally wait
-            // until the items state changes to Finished before returning.
-            await this._waitFor(instance, item._id);
-        }
-        return instance;
-    }
-    /**
-     * Wait for the instance to be finished loading.
-     * @param instance Item instance
-     * @param itemId Item ID
-     * @return {Promise<void>}
-     * @private
-     */
-    async _waitFor(instance, itemId) {
-        if (instance.state === ItemState.Finished)
-            return;
-        const waitingPromises = this.waitForStateMap.get(itemId) || [];
-        const promise = new Promise((resolve) => waitingPromises.push(resolve));
-        // Add this promise to the list of promises that should be resolved
-        // when the item is finished.
-        this.waitForStateMap.set(itemId, waitingPromises);
-        await promise;
-    }
-    /**
-     * Load a texture. If the texture is an environment map, enable the param. the noCache parameter will cause
-     * the texture to be recreated in any case and not used from the resources and also loading manager will
-     * not store the resulting item. This should only be used if the intention is to modify the texture after loading
-     * because then it should be treated separately and not be reused.
-     * @param referenceId the reference id of the item that wants to load this
-     * @param item
-     * @param options
-     * @returns {Promise<ImageItem|*>}
-     */
-    async loadTexture(referenceId, item, options) {
-        //@ts-ignore
-        return this.load(referenceId, item, ImageItem, options);
-    }
-    /**
-     * Load a texture or composition.
-     * @param referenceId
-     * @param item
-     * @param options
-     * @return {Promise<*>}
-     */
-    async loadTextureOrComposition(referenceId, item, options = {}) {
-        options.renderToTexture = true;
-        const loadableTypes = [
-            { name: "Image", type: ImageItem },
-            { name: "Composition", type: CompositionItem }
-        ];
-        //@ts-ignore
-        return this.load(referenceId, item, loadableTypes, options);
-    }
-    /**
-     * Load a texture, composition or video.
-     * @param referenceId
-     * @param item
-     * @param options
-     * @return {Promise<*>}
-     */
-    async loadTextureCompositionOrVideo(referenceId, item, options = {}) {
-        options.renderToTexture = true;
-        const loadableTypes = [
-            { name: "Image", type: ImageItem },
-            { name: "Composition", type: CompositionItem },
-            { name: "Video", type: VideoItem }
-        ];
-        //@ts-ignore
-        return this.load(referenceId, item, loadableTypes, options);
-    }
-    /**
-     * Load a shader and store it in the loading manager
-     * @param referenceId the reference id of the item that wants to load this
-     * @param item
-     * @returns {Promise<Backgroundshader|*>}
-     */
-    async loadBackgroundShader(referenceId, item, options = {}) {
-        //@ts-ignore
-        return this.load(referenceId, item, BackgroundShaderItem, options);
-    }
-    /**
-     * Load a shader and store it in the loading manager
-     * @param referenceId the reference id of the item that wants to load this
-     * @param item
-     * @returns {Promise<Backgroundshader|*>}
-     */
-    async loadPixelShader(referenceId, item, options = {}) {
-        //@ts-ignore
-        return this.load(referenceId, item, PixelShaderItem, options);
-    }
-    /**
-     * Load a shader and store it in the loading manager
-     * @param referenceId the reference id of the item that wants to load this
-     * @param item
-     * @returns {Promise<Backgroundshader|*>}
-     */
-    async loadVertexShader(referenceId, item, options = {}) {
-        //@ts-ignore
-        return this.load(referenceId, item, VertexShaderItem, options);
-    }
-    /**
-     * Load a composition item and store it in the loading manager
-     * @param referenceId the reference id of the item that wants to load this
-     * @param item
-     * @returns {Promise<PostFX|*>}
-     */
-    async loadComposition(referenceId, item, options = {}) {
-        //@ts-ignore
-        return this.load(referenceId, item, CompositionItem, options);
-    }
-    /**
-     * Load a material and store it in the loading manager
-     * @param referenceId the reference id of the item that wants to load this
-     * @param item
-     * @returns {Promise<Material|*>}
-     */
-    async loadMaterial(referenceId, item, options = {}) {
-        //@ts-ignore
-        return this.load(referenceId, item, MaterialItem, options);
-    }
-    /**
-     * Load a material collection and store it in the loading manager
-     * @param referenceId the reference id of the item that wants to load this
-     * @param item
-     * @returns {Promise<Material|*>}
-     */
-    async loadMaterialCollection(referenceId, item, options = {}) {
-        //@ts-ignore
-        return this.load(referenceId, item, MaterialCollectionItem, options);
-    }
-    /**
-     * Load a mesh and store it in the loading manager
-     * @param referenceId the reference id of the item that wants to load this
-     * @param item
-     * @param options
-     * @returns {Promise<MeshItem|*>}
-     */
-    async loadMesh(referenceId, item, options = {}) {
-        //@ts-ignore
-        return this.load(referenceId, item, MeshItem, options);
-    }
-    ;
-    /**
-     * Load a mesh collection and store it in the loading manager
-     * @param referenceId
-     * @param item
-     * @param options
-     * @returns {Promise<void>}
-     */
-    async loadMeshCollection(referenceId, item, options = {}) {
-        //@ts-ignore
-        return this.load(referenceId, item, MeshCollectionItem, options);
-    }
-    /**
-     * Load a gridmap and store it in the loading manager
-     * @param referenceId the reference id of the item that wants to load this
-     * @param item
-     * @param options
-     * @returns {Promise<MeshItem|*>}
-     */
-    async loadGridMap(referenceId, item, options = {}) {
-        //@ts-ignore
-        return this.load(referenceId, item, GridMapItem, options);
-    }
-    ;
-    /**
-     * Load a gaussian splats item and store it in the loading manager
-     * @param referenceId the reference id of the item that wants to load this
-     * @param item
-     * @return {Promise<void>}
-     */
-    async loadGaussianSplats(referenceId, item, options = {}) {
-        //@ts-ignore
-        return this.load(referenceId, item, GaussianSplatsItem, options);
-    }
-    /**
-    * Load a Font and store it in the loading manager
-    * @param referenceId the reference id of the item that wants to load this
-    * @param item
-    * @returns {Promise<FontItem|*>}
-    */
-    async loadFont(referenceId, item, options = {}) {
-        //@ts-ignore
-        return this.load(referenceId, item, FontItem, options);
-    }
-    ;
-    /**
-     * Load a Font and store it in the loading manager
-     * @param referenceId the reference id of the item that wants to load this
-     * @param item
-     * @returns {Promise<FontItem|*>}
-     */
-    async loadParticles(referenceId, item, options = {}) {
-        //@ts-ignore
-        return this.load(referenceId, item, ParticlesItem, options);
-    }
-    ;
-    /**
-     * Load a point cloud and store it in the loading manager
-     * @param referenceId the reference id of the item that wants to load this
-     * @param item
-     * @param options
-     * @returns {Promise<PointsItem|*>}
-     */
-    async loadPoints(referenceId, item, options = {}) {
-        //@ts-ignore
-        return this.load(referenceId, item, PointsItem, options);
-    }
-    ;
-    /**
-     * Load a scene and store it in the loading manager
-     * @param referenceId the reference id of the item that wants to load this
-     * @param item
-     * @param options
-     * @returns {Promise<SceneItem|*>}
-     */
-    async loadScene(referenceId, item, options = {}) {
-        //@ts-ignore
-        return this.load(referenceId, item, SceneItem, options);
-    }
-    ;
-    /**
-     * Load a prefab and store it in the loading manager
-     * @param referenceId the reference id of the item that wants to load this
-     * @param item
-     * @param options
-     * @returns {Promise<SceneItem|*>}
-     */
-    async loadPrefab(referenceId, item, options = {}) {
-        //@ts-ignore
-        return this.load(referenceId, item, PrefabItem, options);
-    }
-    ;
-    /**
-     * Load a scene or a prefab
-     * @param referenceId
-     * @param item
-     * @param options
-     * @return {Promise<*>}
-     */
-    async loadSceneOrPrefab(referenceId, item, options = {}) {
-        const loadableTypes = [
-            { name: "Prefab", type: PrefabItem },
-            { name: "Scene", type: SceneItem }
-        ];
-        //@ts-ignore
-        return this.load(referenceId, item, loadableTypes, options);
-    }
-    /**
-     * Load a project and store it in the loading manager
-     * @param referenceId the reference id of the item that wants to load this
-     * @param item
-     * @param options
-     * @returns {Promise<SceneItem|*>}
-     */
-    async loadProject(referenceId, item, options = {}) {
-        //@ts-ignore
-        return this.load(referenceId, item, ProjectItem, options);
-    }
-    ;
-    /**
-     * Load an audio file and store it in the loading manager
-     * @param referenceId
-     * @param item
-     * @returns {Promise<void>}
-     */
-    async loadAudio(referenceId, item, options = {}) {
-        //@ts-ignore
-        return this.load(referenceId, item, AudioItem, options);
-    }
-    /**
-     * Load an audio collection and store it in the loading manager
-     * @param referenceId
-     * @param item
-     * @returns {Promise<void>}
-     */
-    async loadAudioCollection(referenceId, item, options = {}) {
-        //@ts-ignore
-        return this.load(referenceId, item, AudioCollectionItem, options);
-    }
-    /**
-     * Load a script and store it in the loading manager
-     * @param referenceId
-     * @param item
-     * @return {Promise<void>}
-     */
-    async loadScript(referenceId, item, options = {}) {
-        //@ts-ignore
-        return this.load(referenceId, item, ScriptItem, options);
-    }
-    /**
-     * Load a variable set and store it in the loading manager
-     * @param referenceId the reference id of the item that wants to load this
-     * @param item
-     * @returns {Promise<SceneItem|*>}
-     */
-    async loadVariableSet(referenceId, item, options = {}) {
-        //@ts-ignore
-        return this.load(referenceId, item, VariableSetItem, options);
-    }
-    ;
-    /**
-     * Load a package and store it in the loading manager. Returns the created scenegraph with the package at the root.
-     * @param referenceId the reference id of the item that wants to load this
-     * @param packageItem
-     * @returns {Promise<SceneGraph>}
-     */
-    /*async loadPackage(referenceId: string, packageItem: PreparedItem) {
-        let item = packageItem.packageContent!;
-
-        const instance = this._getItemInstance(packageItem._id, referenceId);
-        if (instance)
-            return instance;
-
-        this.addItem(item);
-
-        if (packageItem.packageType === "Scene") {
-            // Create a new scene from the package and return its scenegraph.
-            const scene = new Scene(item, this.engine, this.renderer);
-            this._setItemInstance(item._id, scene, referenceId);
-            const s = await scene.create(false);
-            return s.getSceneGraph();
-        } else if (packageItem.packageType === "Mesh") {
-            // Create a new scenegraph and a mesh item.
-            await this.engine.createSceneGraph(item);
-            const mesh = new Mesh(item, this.engine, this.renderer);
-            this._setItemInstance(item._id, mesh, referenceId);
-
-            // Add the mesh to the scenegraph.
-            const meshItem = await mesh.create();
-            this.engine.scene.add(meshItem.getObject());
-
-            return this.engine.sceneGraph;
-        } else {
-            throw new Error("Unsupported package type.");
-        }
-    }*/
-    setGpuRamQuota(value) {
-        this.gpuRamQuota = value;
-    }
-    done() {
-        this.active = false;
-        this.printReport();
-    }
-    isActive() {
-        return this.active;
-    }
-    reset() {
-        this.itemsToLoad = [];
-        this.itemsMap = new Map();
-        this.itemsByTypeMap = new Map();
-        this.itemsTypeMap = new Map();
-        this.startTime = new Date();
-    }
-    async play() {
-        const promises = [];
-        for (const entry of this.itemsMap.values()) {
-            if (entry.itemInstance) {
-                promises.push(entry.itemInstance.play());
-            }
-        }
-        await Promise.all(promises).catch(function (err) {
-            console.error(err);
-        });
-    }
-    async stop() {
-        const promises = [];
-        for (const entry of this.itemsMap.values()) {
-            if (entry.itemInstance) {
-                promises.push(entry.itemInstance.stop());
-            }
-        }
-        await Promise.all(promises).catch(function (err) {
-            console.error(err);
-        });
-    }
-    getItemInstance(itemId, itemType) {
-        const entry = this.itemsMap.get(itemId);
-        if (!entry)
-            return null;
-        if (itemType !== undefined) {
-            if (entry.item.type !== itemType)
-                return null;
-        }
-        return entry.itemInstance;
-    }
-    getAllItemInstances() {
-        const arr = [];
-        for (const entry of this.itemsMap.values()) {
-            if (entry.itemInstance)
-                arr.push(entry.itemInstance);
-        }
-        return arr;
-    }
-    getItemsOfType(type) {
-        const map = this._getItemMapForType(type);
-        return Array.from(map.values());
-    }
-    getItemInstancesOfType(type) {
-        const map = this._getItemMapForType(type);
-        const arr = [];
-        for (const entry of map.values()) {
-            if (entry.itemInstance)
-                arr.push(entry.itemInstance);
-        }
-        return arr;
-    }
-    getGpuRamQuotaLeft() {
-        return this.gpuRamQuota - this.getTotalGpuRamUsage();
-    }
-    getSecondsToReady() {
-        return this.secondsToReady;
-    }
-    getSecondsToFinished() {
-        return this.secondsToFinished;
-    }
-    getProgressPercent() {
-        let total = 0;
-        for (const entry of this.itemsToLoad) {
-            total += entry.progressPercent;
-        }
-        return total / this.itemsToLoad.length;
-    }
-    getProgressBytes() {
-        let total = 0;
-        let loaded = 0;
-        for (const entry of this.itemsToLoad) {
-            total += entry.bytesTotal;
-            loaded += entry.bytesLoaded;
-        }
-        //console.log(`[DOWNLOAD] manager: ${loaded} of ${total}`);
-        return {
-            total, loaded
-        };
-    }
-    initFromItem(item) {
-        this._initFromItem(item);
-        this.itemsToLoad.sort(function (a, b) {
-            return a.item.name.localeCompare(b.item.name);
-        });
-        this.run();
-    }
-    _initFromItem(item) {
-        this.addItem(item);
-        this._initFromFields(item.fieldInstances);
-    }
-    _initFromFields(fields) {
-        if (Array.isArray(fields)) {
-            for (const field of fields) {
-                if (field.type === "Link" && field.value && typeof field.value === 'object' && field.loadingManagerRule !== "ignore") {
-                    this._initFromItem(field.value);
-                }
-                if (field.blocks && field.blocks.length) {
-                    this._initFromBlocks(field.blocks);
-                }
-            }
-        }
-    }
-    _initFromBlocks(blocks) {
-        if (Array.isArray(blocks)) {
-            for (const block of blocks) {
-                if (block.fields && block.fields.length) {
-                    this._initFromFields(block.fields);
-                }
-                if (block.blocks && block.blocks.length) {
-                    this._initFromBlocks(block.blocks);
-                }
-            }
-        }
-    }
-    removeItem(id) {
-        if (!this.itemsMap.has(id)) {
-            console.warn(`LoadingManager: Tried to remove item ${id} but it is not in map.`);
-            return;
-        }
-        // Get the type of the item and remove that type from the list
-        const type = this.itemsTypeMap.get(id);
-        this.itemsTypeMap.delete(id);
-        // Get the item from the item type map and delete it
-        const arr = this._getItemMapForType(type);
-        arr.delete(id);
-        // Now delete from the main map and remove from the items to load
-        this.itemsMap.delete(id);
-        this.itemsToLoad.removeByFilterFunc(x => x.id === id);
-    }
-    addItem(item, alternateItemId) {
-        const id = alternateItemId || item._id;
-        if (this.itemsMap.has(id))
-            return;
-        const entry = {
-            id: id,
-            url: undefined,
-            objectUrl: undefined,
-            item: item,
-            itemInstance: undefined,
-            itemPrivateInstances: new Map(), // instances owned by a single reference, like prefabs or scenes.
-            progressPercent: 0,
-            bytesTotal: item.filesize || 0,
-            bytesLoaded: 0,
-            state: 0,
-            gpuRamUsage: 0,
-            projectedGpuRamUsage: 0,
-            readyForUse: false,
-            readyForLodIncrease: false,
-            references: new Map(),
-            unusedSince: undefined
-        };
-        this.itemsToLoad.push(entry);
-        this.itemsMap.set(id, entry);
-        this.itemsTypeMap.set(id, item.type);
-        const typeMap = this._getItemMapForType(item.type);
-        typeMap.set(id, entry);
-    }
-    _clearUnusedItemInstances() {
-        const entriesToClear = [];
-        const now = new Date();
-        for (const entry of this.itemsMap.values()) {
-            if (entry.unusedSince) {
-                const diff = now.valueOf() - entry.unusedSince.valueOf();
-                if (diff > this.deletionGracePeriodMs) {
-                    entriesToClear.push(entry);
-                }
-            }
-        }
-        let refreshEditorOutputOptions = false;
-        for (const entry of entriesToClear) {
-            // In case the item was a composition, we need to update the editor output options.
-            if (entry.itemInstance instanceof CompositionItem)
-                refreshEditorOutputOptions = true;
-            if (entry.itemInstance) {
-                try {
-                    const p = entry.itemInstance.destroy(false, true);
-                    if (p && p.catch) {
-                        p.catch((err) => {
-                            console.error(`LoadingManager: Error while destroying item instance of ${entry.id}`, err);
-                        });
-                    }
-                }
-                catch (err) {
-                    console.error(`LoadingManager: Error while destroying item instance of ${entry.id}`, err);
-                }
-            }
-            entry.itemInstance = undefined;
-            this.removeItem(entry.id);
-        }
-        if (refreshEditorOutputOptions)
-            this.engine.renderer.updateEditorOutputOptions();
-        if (entriesToClear.length)
-            this.engine.eventBus.$emit('loadingManager:updated');
-    }
-    _getItemMapForType(type) {
-        let map = this.itemsByTypeMap.get(type);
-        if (map)
-            return map;
-        map = new Map();
-        this.itemsByTypeMap.set(type, map);
-        return map;
-    }
-    discard(id) {
-        if (this.itemsMap.has(id)) {
-            this.itemsMap.delete(id);
-            for (let i = 0; i < this.itemsToLoad.length; i++) {
-                if (this.itemsToLoad[i].id === id) {
-                    this.itemsToLoad.splice(i, 1);
-                    return;
-                }
-            }
-        }
-    }
-    getItemCountToLoad() {
-        let count = 0;
-        for (const entry of this.itemsToLoad) {
-            if (entry.state !== LoadingState.DONE)
-                count++;
-        }
-        return count;
-    }
-    getIdByUrl(url) {
-        for (const entry of this.itemsToLoad) {
-            if (entry.url === url)
-                return entry.id;
-        }
-        return null;
-    }
-    getIdByObjectUrl(objectUrl) {
-        for (const entry of this.itemsToLoad) {
-            if (entry.objectUrl === objectUrl)
-                return entry.id;
-        }
-        return null;
-    }
-    setUrl(id, url) {
-        let entry = this.itemsMap.get(id);
-        if (entry) {
-            entry.url = url;
-        }
-    }
-    setObjectReady(id) {
-        let entry = this.itemsMap.get(id);
-        if (entry && entry.itemInstance) {
-            entry.readyForLodIncrease = entry.itemInstance.hasMoreLodLevels();
-            if (!entry.readyForLodIncrease)
-                entry.itemInstance.markFinished();
-        }
-    }
-    setObjectUrl(id, objectUrl) {
-        let entry = this.itemsMap.get(id);
-        if (entry) {
-            entry.objectUrl = objectUrl;
-        }
-    }
-    isAllReadyForUse() {
-        return this.secondsToReady !== undefined;
-    }
-    isAllFinishedForUse() {
-        return this.secondsToFinished !== undefined;
-    }
-    getGpuRamQuota() {
-        return this.gpuRamQuota;
-    }
-    getTotalGpuRamUsage() {
-        let sum = 0;
-        for (const entry of this.itemsToLoad) {
-            if (entry.projectedGpuRamUsage)
-                sum += entry.projectedGpuRamUsage;
-            else if (entry.gpuRamUsage)
-                sum += entry.gpuRamUsage;
-        }
-        return sum;
-    }
-    getTotalFilesize() {
-        let sum = 0;
-        for (const entry of this.itemsToLoad) {
-            sum += entry.item.filesize ? entry.item.filesize : 0;
-        }
-        return sum;
-    }
-    updateInfo(id) {
-        let entry = this.itemsMap.get(id);
-        if (entry && entry.itemInstance) {
-            entry.gpuRamUsage = entry.itemInstance.getGpuMemUsage();
-            entry.readyForUse = entry.itemInstance.isReadyForUse();
-            if (entry.projectedGpuRamUsage < entry.gpuRamUsage)
-                entry.projectedGpuRamUsage = entry.gpuRamUsage;
-        }
-    }
-    setProgress(id, state, progress) {
-        let entry = this.itemsMap.get(id);
-        if (entry) {
-            const stateChanged = entry.state !== state;
-            let gpuMemUsage = 0;
-            let isReadyForUse = true;
-            let instances = [entry.itemInstance, ...entry.itemPrivateInstances.values()];
-            for (const instance of instances) {
-                if (instance) {
-                    gpuMemUsage += instance.getGpuMemUsage();
-                    if (!instance.isReadyForUse())
-                        isReadyForUse = false;
-                }
-            }
-            entry.state = state;
-            entry.gpuRamUsage = gpuMemUsage;
-            entry.readyForUse = isReadyForUse;
-            switch (state) {
-                case LoadingState.NONE:
-                    entry.progressPercent = 0;
-                    break;
-                case LoadingState.LOADING:
-                    entry.progressPercent = progress || 0;
-                    entry.bytesLoaded = entry.progressPercent / 100 * entry.bytesTotal;
-                    if (stateChanged)
-                        entry.startedLoading = new Date();
-                    break;
-                case LoadingState.LOADED:
-                    entry.progressPercent = 100;
-                    entry.bytesLoaded = entry.bytesTotal;
-                    if (stateChanged) {
-                        entry.startedLoading = entry.startedLoading || new Date();
-                        entry.finishedLoading = new Date();
-                        entry.loadingTimeMs = entry.finishedLoading.valueOf() - entry.startedLoading.valueOf();
-                    }
-                    break;
-                case LoadingState.IMPORTING:
-                    entry.progressPercent = 100;
-                    entry.bytesLoaded = entry.bytesTotal;
-                    if (stateChanged)
-                        entry.startedImporting = new Date();
-                    break;
-                case LoadingState.DONE:
-                    entry.progressPercent = 100;
-                    entry.bytesLoaded = entry.bytesTotal;
-                    if (stateChanged) {
-                        entry.startedImporting = entry.startedImporting || new Date();
-                        entry.finishedImporting = new Date();
-                        entry.importTimeMs = entry.finishedImporting.valueOf() - entry.startedImporting.valueOf();
-                    }
-                    break;
-            }
-            const countRemaining = this.getItemCountToLoad();
-            const stateString = this.getStateString(state);
-            if (this.debugMode)
-                console.log(entry.item.name + "(" + entry.item.type + "): " + stateString + " - Remaining: " + countRemaining);
-        }
-        else {
-            console.error("Trying to set progress on unknown item!", id, state, progress);
-        }
-    }
-    getStateString(state) {
-        switch (state) {
-            case LoadingState.NONE: return "NONE";
-            case LoadingState.LOADING: return "LOADING";
-            case LoadingState.LOADED: return "LOADED";
-            case LoadingState.IMPORTING: return "IMPORTING";
-            case LoadingState.DONE: return "DONE";
-        }
-        return `unknown(${state})`;
-    }
-    printReport() {
-        this.endTime = new Date();
-        this.totalTime = this.endTime.valueOf() - this.startTime.valueOf();
-        const itemCountToLoad = this.getItemCountToLoad();
-        console.log("Loading manager report:");
-        console.log("------------------------------------");
-        let loadedSize = 0;
-        let accumulatedTime = 0;
-        for (const entry of this.itemsToLoad) {
-            const state = this.getStateString(entry.state);
-            loadedSize += entry.item.filesize || 0;
-            const time = (entry.loadingTimeMs || 0) + (entry.importTimeMs || 0);
-            accumulatedTime += time;
-            console.log(`${entry.item.name} (${entry.item.type}) of size ${entry.item.filesize}: ${state} (time: ${time}ms)`);
-        }
-        const mb = Math.floor(loadedSize * 100 / 1024 / 1024) / 100;
-        console.log("------------------------------------");
-        console.log("Items in list           :" + this.itemsToLoad.length);
-        console.log("Items remaining to load :" + itemCountToLoad);
-        console.log("Total filesize          :" + mb + " MiB");
-        console.log("Accumulated time        :" + accumulatedTime + " ms");
-        console.log("Total time              :" + this.totalTime + " ms");
-        console.log("------------------------------------");
-    }
-    _handleRename({ id, newName }) {
-        for (const entry of this.itemsToLoad) {
-            if (entry.id === id) {
-                entry.item.name = newName;
-                this.engine.eventBus.$emit('loadingManager:updated');
-                return;
-            }
-        }
-    }
-    _markAllReadyItemsAsFinished() {
-        for (const entry of this.itemsToLoad) {
-            if (entry.itemInstance && entry.readyForLodIncrease) {
-                entry.readyForLodIncrease = false;
-                entry.itemInstance.markFinished();
-            }
-        }
-    }
-    _run() {
-        this._increaseLods();
-    }
-    _increaseLods() {
-        // We will not increase any LOD levels unless all objects are at least loaded in their lowest LOD
-        if (!this.readyTime)
-            return;
-        let gpuMemQuotaLeft = this.getGpuRamQuotaLeft();
-        if (gpuMemQuotaLeft <= 0) {
-            this._markAllReadyItemsAsFinished();
-            return;
-        }
-        for (const entry of this.itemsToLoad) {
-            if (entry.itemInstance && entry.readyForLodIncrease) {
-                try {
-                    const memUsage = entry.itemInstance.getNextLodLevelGpuMemUsage();
-                    if (gpuMemQuotaLeft >= memUsage) {
-                        if (this.debugMode)
-                            console.log(`Increasing LOD of ${entry.item.name} to ${entry.itemInstance.activeLodLevel}`);
-                        gpuMemQuotaLeft -= memUsage;
-                        entry.projectedGpuRamUsage = memUsage;
-                        entry.readyForLodIncrease = false;
-                        entry.itemInstance.increaseLodLevel();
-                    }
-                    else {
-                        entry.readyForLodIncrease = false;
-                        entry.itemInstance.markFinished();
-                    }
-                }
-                catch (err) {
-                    console.error(err);
-                }
-            }
-        }
-    }
-    _ready() {
-        if (!this.readyTime) {
-            this.readyTime = new Date();
-            this.secondsToReady = (this.readyTime.valueOf() - this.startTime.valueOf()) / 1000;
-            console.log("[TIMING] Seconds to ready: " + this.secondsToReady);
-            this.engine.eventBus.$emit('loadingManager:readyForUse');
-        }
-    }
-    _finished() {
-        this._ready();
-        if (!this.finishedTime) {
-            if (!this.readyTime) {
-                this.readyTime = new Date();
-                this.secondsToReady = (this.readyTime.valueOf() - this.startTime.valueOf()) / 1000;
-            }
-            this.finishedTime = new Date();
-            this.secondsToFinished = (this.finishedTime.valueOf() - this.startTime.valueOf()) / 1000;
-            console.log("[TIMING] Seconds to finished: " + this.secondsToFinished);
-            this.engine.eventBus.$emit('loadingManager:finishedForUse');
-        }
-    }
-}
-//# sourceMappingURL=LoadingManager.js.map