@luminocity/lemonate-engine 15.2.2 → 15.2.3

package/dist/items/ProjectItem.js

@@ -1,857 +0,0 @@
-// -----------------------------------------------------------------------------------------------------------
-//  __         ______     __    __     ______     __   __     ______     ______   ______
-// /\ \       /\  ___\   /\ "-./  \   /\  __ \   /\ "-.\ \   /\  __ \   /\__  _\ /\  ___\
-// \ \ \____  \ \  __\   \ \ \-./\ \  \ \ \/\ \  \ \ \-.  \  \ \  __ \  \/_/\ \/ \ \  __\
-//  \ \_____\  \ \_____\  \ \_\ \ \_\  \ \_____\  \ \_\\"\_\  \ \_\ \_\    \ \_\  \ \_____\
-//   \/_____/   \/_____/   \/_/  \/_/   \/_____/   \/_/ \/_/   \/_/\/_/     \/_/   \/_____/
-//
-//
-// Copyright 2023- Luminocity AG
-//
-// "I am Error." - The Legend of Zelda: Majora’s Mask (2000)
-//
-// 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 { Item, ItemState } from './Item';
-import { ListEntry } from './helpers/ListEntry';
-import { LoadingState } from "@/LoadingState";
-import { Vector3 } from "three";
-import { MaxLayerCount } from "@/Renderer";
-import tools from '../Tools.js';
-import { WaitMode } from "@/Engine";
-export class ProjectData {
-    scenes = new Map();
-    sceneListEntries = new Map();
-    variableSets = new Map();
-    variableSetListEntries = new Map();
-    canvasFonts = new Map();
-    canvasFontListEntries = new Map();
-}
-export class ProjectItem extends Item {
-    project;
-    withinSetPrimaryScene = false;
-    getType() {
-        return "Project";
-    }
-    getObject() {
-        return this.project;
-    }
-    init() {
-        this.project = new ProjectData();
-    }
-    addVariableSet(itemId) {
-        // todo: add variable set to project
-    }
-    getGravity() {
-        return this.getFieldValueVec3("Gravity");
-    }
-    setGravity(value) {
-        this.setFieldValue("Gravity", value);
-        this.engine.physics.setGravity(new Vector3(value.x, value.y, value.z));
-    }
-    getAspectRatio() {
-        const aspectRatio = this.getFieldValue("AspectRatio");
-        switch (aspectRatio) {
-            case "Not defined": return null;
-            case "Standard (4:3)": return 4 / 3;
-            case "Widescreen (16:9)": return 16 / 9;
-            case "Ultrawide (21:9)": return 21 / 9;
-            case "Custom": return this.getFieldValue("CustomAspect");
-        }
-    }
-    getExecutionWaitMode() {
-        const value = this.getFieldValue("StartExecution");
-        switch (value) {
-            case "After loading minimum LOD":
-                return WaitMode.Ready;
-            case "After loading everything":
-                return WaitMode.Finished;
-            case "Right away":
-            default:
-                return WaitMode.None;
-        }
-    }
-    getSceneListEntries() {
-        if (!this.project) {
-            throw new Error("Project not set.");
-        }
-        return this.project.sceneListEntries;
-    }
-    getSceneListEntryByName(name) {
-        if (!this.project) {
-            throw new Error("Project not set.");
-        }
-        for (const entry of this.project.sceneListEntries.values()) {
-            const id = entry.getId();
-            const scene = this.project.scenes.get(id);
-            if (scene && scene.getName() == name)
-                return entry;
-        }
-        return null;
-    }
-    async play() {
-        const physicsEnabled = this.getFieldValue("PhysicsEnabled");
-        if (physicsEnabled) {
-            const gravity = this.getFieldValue("Gravity");
-            this.engine.physics.setGravity(new Vector3(gravity.x, gravity.y, gravity.z));
-            this.engine.physics.start();
-        }
-    }
-    async stop() {
-        const physicsEnabled = this.getFieldValue("PhysicsEnabled");
-        if (physicsEnabled) {
-            this.engine.physics.stop();
-        }
-    }
-    _enumerateChildren() {
-        let itemChildren = [];
-        if (this.project) {
-            //  Enumerate all scenes
-            // ---------------------------------------------------------------------
-            for (const entry of this.project.sceneListEntries.values()) {
-                const load = entry.getFieldValue("Load");
-                if (load) {
-                    const id = entry.getId();
-                    const scene = this.project.scenes.get(id);
-                    if (scene)
-                        itemChildren.push(scene);
-                    else
-                        itemChildren.push({ _id: id, load: true });
-                }
-            }
-            // Enumerate all variable sets
-            // ---------------------------------------------------------------------
-            for (const entry of this.project.variableSetListEntries.values()) {
-                const id = entry.getId();
-                const variableSet = this.project.variableSets.get(id);
-                if (variableSet)
-                    itemChildren.push(variableSet);
-                else
-                    itemChildren.push({ _id: id, load: true });
-            }
-            // Enumerate all fonts
-            // ---------------------------------------------------------------------
-            for (const entry of this.project.canvasFontListEntries.values()) {
-                const id = entry.getId();
-                const font = this.project.canvasFonts.get(id);
-                if (font)
-                    itemChildren.push(font);
-                else
-                    itemChildren.push({ _id: id, load: true });
-            }
-        }
-        return itemChildren;
-    }
-    isReadyForUse() {
-        if (!this.project)
-            return false;
-        for (const entry of this.project.sceneListEntries.values()) {
-            const load = entry.getFieldValue("Load");
-            if (load) {
-                const id = entry.getId();
-                const scene = this.project.scenes.get(id);
-                if (!scene)
-                    return false;
-            }
-        }
-        for (const entry of this.project.variableSetListEntries.values()) {
-            const id = entry.getId();
-            const vs = this.project.variableSets.get(id);
-            if (!vs)
-                return false;
-        }
-        return true;
-    }
-    async create() {
-        await this.destroy();
-        this.state = ItemState.Created;
-        this.init();
-        return this;
-    }
-    async load() {
-        this._loadingManagerProgress(LoadingState.IMPORTING);
-        this.updateLayerNames();
-        this.updateCollisionMatrix();
-        this.updateAutomaticPointerLock();
-        await Promise.all([
-            this._updateScenes(),
-            this._updateVariableSets(),
-            this._updateCanvasFonts()
-        ]);
-        this._loadingManagerProgress(LoadingState.DONE);
-    }
-    updateLayerNames() {
-        const layers = this.getFieldValue("LayerNames");
-        if (layers.length > MaxLayerCount) {
-            layers.splice(MaxLayerCount - 1);
-        }
-        if (layers.length < MaxLayerCount) {
-            while (layers.length < MaxLayerCount) {
-                layers.push("");
-            }
-            this.setFieldValue("LayerNames", layers);
-        }
-        try {
-            this.engine.renderer.setLayers(layers);
-        }
-        catch (err) {
-            console.log(layers);
-            console.error(err);
-        }
-    }
-    updateCollisionMatrix() {
-        const collisionMatrix = this.getFieldValue("CollisionMatrix");
-        this.engine.physics.setCollisionMatrix(collisionMatrix);
-    }
-    updateAutomaticPointerLock() {
-        const automaticPointerLock = this.getFieldValue("AutomaticPointerLock") || false;
-        this.engine.renderer.setAutomaticPointerLock(automaticPointerLock);
-    }
-    _updateState() {
-        if (this.state < ItemState.Finished) {
-            if (this.isReadyForUse())
-                this.state = ItemState.Finished;
-        }
-    }
-    async destroy() {
-        this.project = undefined;
-        this.state = ItemState.Destroyed;
-    }
-    // ------------------------------------------------------------------------------------------------------
-    //  SCENES
-    // ------------------------------------------------------------------------------------------------------
-    async _updateScenes() {
-        if (!this.project) {
-            throw new Error("Project not set.");
-        }
-        const scenes = this.getField("Scenes");
-        if (scenes) {
-            // Create or update any blocks to new list entries
-            // ----------------------------------------------------------------------
-            for (const block of scenes.blocks) {
-                const listEntry = this.project.sceneListEntries.get(block.id);
-                if (!listEntry) {
-                    const entry = new ListEntry(this, block, this.engine);
-                    this.project.sceneListEntries.set(block.id, entry);
-                    entry.$on('listentry:update', (entry, field, value) => {
-                        this._onSceneListEntryUpdate(entry, field, value);
-                    });
-                    await this._processSceneEntry(entry);
-                }
-            }
-            // Check which blocks disappeared
-            // ----------------------------------------------------------------------
-            const deletedEntries = [];
-            for (const id of this.project.sceneListEntries.keys()) {
-                let found = false;
-                for (const block of scenes.blocks) {
-                    if (block.id === id) {
-                        found = true;
-                        break;
-                    }
-                }
-                if (!found) {
-                    deletedEntries.push(id);
-                }
-            }
-            for (const id of deletedEntries) {
-                const listEntry = this.project.sceneListEntries.get(id);
-                if (listEntry)
-                    this._destroySceneEntry(listEntry);
-            }
-        }
-    }
-    _onSceneListEntryUpdate(entry, field, value) {
-        switch (field) {
-            case "Scene": {
-                this._unloadScene(entry);
-                if (typeof value === 'string') {
-                    this._loadSceneItem(entry, value).catch(function (err) {
-                        console.error(err);
-                    });
-                }
-                else if (value) {
-                    this._loadScene(entry).catch(function (err) {
-                        console.error(err);
-                    });
-                }
-                break;
-            }
-            case "Load": {
-                this._processSceneEntry(entry).catch((err) => {
-                    console.error(err);
-                });
-                break;
-            }
-            case "Active": {
-                this._updateSceneActive(entry);
-                break;
-            }
-            case "Transform": {
-                this._updateSceneTransform(entry);
-                break;
-            }
-            case "Primary":
-                this._setPrimaryScene(entry, value);
-                break;
-        }
-    }
-    async _processSceneEntry(entry) {
-        if (!this.project) {
-            throw new Error("Project not set.");
-        }
-        const load = entry.getFieldValue("Load");
-        const sceneItem = entry.getFieldValue("Scene");
-        const id = entry.getId();
-        const scene = this.project.scenes.get(id);
-        if (load && !scene && sceneItem) {
-            if (typeof sceneItem === 'string') {
-                // sceneItem is just a string so the item has not yet been loaded. We need to do that first, the
-                // actual scene loading will then be triggered by an update event once the item is loaded
-                await this._loadSceneItem(entry, sceneItem);
-            }
-            else {
-                // we have the scene item already, directly load the scene
-                await this._loadScene(entry);
-            }
-        }
-        else if (!load && scene) {
-            this._unloadScene(entry);
-        }
-    }
-    _destroySceneEntry(entry) {
-        if (!this.project) {
-            throw new Error("Project not set.");
-        }
-        const id = entry.getId();
-        this._unloadScene(entry);
-        entry.destroy();
-        this.project.sceneListEntries.delete(id);
-    }
-    _ensureSceneIsUnique(sceneItem) {
-        if (!this.project) {
-            throw new Error("Project not set.");
-        }
-        for (const scene of this.project.scenes.values()) {
-            if (scene.getId() === sceneItem._id) {
-                console.warn("Scene is already in use in the project. Cannot load it more than once!");
-                return false;
-            }
-        }
-        return true;
-    }
-    async _loadSceneItem(entry, sceneItemId) {
-        return this.engine.itemRepo.loadItem(sceneItemId, { recursive: true }).then(function (sceneItem) {
-            const sceneField = entry.getField("Scene");
-            if (sceneField)
-                sceneField.value = sceneItem;
-        });
-    }
-    async _loadScene(entry) {
-        if (!this.project) {
-            throw new Error("Project not set.");
-        }
-        const sceneItem = entry.getFieldValue("Scene");
-        if (!this._ensureSceneIsUnique(sceneItem))
-            return;
-        return this.engine.loadingManager.loadScene(this.getId(), sceneItem)
-            .then((sceneItem) => {
-            this.project.scenes.set(entry.getId(), sceneItem);
-            this._updateSceneActive(entry);
-            this._loadingManagerUpdateInfo();
-            this._updateState();
-            this.engine.eventBus.$emit('project:sceneLoaded', sceneItem);
-        }).catch(err => {
-            console.error(`Error loading scene ${sceneItem}: ${err}`);
-        });
-    }
-    _unloadScene(entry) {
-        if (!this.project) {
-            throw new Error("Project not set.");
-        }
-        const sceneItem = this.project.scenes.get(entry.getId());
-        if (sceneItem) {
-            this._deactivateScene(entry);
-            this.engine.loadingManager.unload(this.getId(), sceneItem);
-            this.project.scenes.delete(entry.getId());
-            this.engine.eventBus.$emit('project:sceneUnloaded', sceneItem);
-        }
-    }
-    _isSceneLoaded(entry) {
-        if (!this.project) {
-            throw new Error("Project not set.");
-        }
-        return this.project.scenes.has(entry.getId());
-    }
-    _updateSceneLoaded(entry) {
-        const isLoaded = this._isSceneLoaded(entry);
-        const load = entry.getFieldValue("Load");
-        if (isLoaded && !load)
-            this._unloadScene(entry);
-        else if (!isLoaded && load)
-            this._loadScene(entry);
-    }
-    _updateSceneActive(entry) {
-        const active = entry.getFieldValue("Active");
-        if (active) {
-            this._activateScene(entry);
-        }
-        else {
-            this._deactivateScene(entry);
-        }
-    }
-    _updateSceneTransform(entry) {
-        if (!this.project) {
-            throw new Error("Project not set.");
-        }
-        const transform = entry.getFieldValue("Transform");
-        const scene = this.project.scenes.get(entry.getId());
-        if (scene) {
-            const sceneGraph = scene.getSceneGraph();
-            if (sceneGraph) {
-                this.engine.activeSceneGraphCollection.setSceneGraphTransform(sceneGraph, transform);
-            }
-        }
-    }
-    _activateScene(entry) {
-        if (!this.project) {
-            throw new Error("Project not set.");
-        }
-        const id = entry.getId();
-        const scene = this.project.scenes.get(id);
-        if (scene) {
-            const transform = entry.getFieldValue("Transform");
-            const primary = entry.getFieldValue("Primary");
-            const sceneGraph = this.engine.activeSceneGraphCollection.addSceneItem(scene, true, transform);
-            if (sceneGraph) {
-                sceneGraph.root.setActive(true);
-                this.engine.eventBus.$emit('project:sceneActivated', sceneGraph.getId());
-                if (primary) {
-                    this._setPrimaryScene(entry);
-                }
-            }
-        }
-    }
-    _setPrimaryScene(entry, value) {
-        if (!this.project) {
-            throw new Error("Project not set.");
-        }
-        if (this.withinSetPrimaryScene)
-            return;
-        try {
-            this.withinSetPrimaryScene = true;
-            const id = entry.getId();
-            if (!value) {
-                // instead of disabling this entry, search for another one to enable that is NOT this entry
-                // because we ALWAYS need to have a primary scene. If we cannot find any, we sadly cannot
-                // remove this entry from beeing primary scene.
-                for (const e of this.project.sceneListEntries.values()) {
-                    const scene = this.project.scenes.get(e.getId());
-                    if (scene) {
-                        if (e.getId() !== id) {
-                            entry = e;
-                            break;
-                        }
-                    }
-                }
-            }
-            // Enable the entry as new primary scene and disable all others
-            for (const e of this.project.sceneListEntries.values()) {
-                const scene = this.project.scenes.get(e.getId());
-                if (scene) {
-                    const sceneGraph = scene.getSceneGraph();
-                    if (sceneGraph) {
-                        if (e.getId() === id) {
-                            if (scene.composition)
-                                this.engine.renderer.activeComposition = scene.composition; // set the active composition to the primary scene
-                            // Always listen for future composition updates
-                            this.engine.eventBus.$on('item:contentUpdated', (updatedScene) => {
-                                const primarySceneID = this.engine.activeSceneGraphCollection.getPrimarySceneItem().getId();
-                                if (updatedScene.getId() === primarySceneID) {
-                                    this.engine.renderer.activeComposition = updatedScene.composition;
-                                }
-                            });
-                            this.engine.activeSceneGraphCollection.setPrimarySceneGraph(sceneGraph);
-                            e.setFieldValue("Primary", true);
-                        }
-                        else {
-                            e.setFieldValue("Primary", false);
-                        }
-                    }
-                }
-            }
-        }
-        catch (err) {
-            console.error(err);
-        }
-        finally {
-            this.withinSetPrimaryScene = false;
-        }
-    }
-    _deactivateScene(entry) {
-        if (!this.project) {
-            throw new Error("Project not set.");
-        }
-        const id = entry.getId();
-        const scene = this.project.scenes.get(id);
-        if (scene) {
-            const sceneGraph = scene.getSceneGraph();
-            if (sceneGraph) {
-                sceneGraph.root.setActive(false);
-                this.engine.activeSceneGraphCollection.remove(sceneGraph);
-                this.engine.eventBus.$emit('project:sceneDeactivated', sceneGraph.getId());
-            }
-        }
-    }
-    // ------------------------------------------------------------------------------------------------------
-    //  VARIABLE SETS
-    // ------------------------------------------------------------------------------------------------------
-    async _updateVariableSets() {
-        if (!this.project) {
-            throw new Error("Project not set.");
-        }
-        const variableSets = this.getField("VariableSets");
-        // field does not exist. maybe an old project version
-        if (!variableSets)
-            return;
-        // Create or update any blocks to new list entries
-        // ----------------------------------------------------------------------
-        for (const block of variableSets.blocks) {
-            const listEntry = this.project.variableSetListEntries.get(block.id);
-            if (!listEntry) {
-                const entry = new ListEntry(this, block, this.engine);
-                this.project.variableSetListEntries.set(block.id, entry);
-                entry.$on('listentry:update', (entry, field, value) => {
-                    this._onVariableSetListEntryUpdate(entry, field, value);
-                });
-                await this._processVariableSetEntry(entry);
-            }
-        }
-        // Check which blocks disappeared
-        // ----------------------------------------------------------------------
-        const deletedEntries = [];
-        for (const id of this.project.variableSetListEntries.keys()) {
-            let found = false;
-            for (const block of variableSets.blocks) {
-                if (block.id === id) {
-                    found = true;
-                    break;
-                }
-            }
-            if (!found) {
-                deletedEntries.push(id);
-            }
-        }
-        for (const id of deletedEntries) {
-            const listEntry = this.project.variableSetListEntries.get(id);
-            if (listEntry)
-                this._destroyVariableSetEntry(listEntry);
-        }
-    }
-    _onVariableSetListEntryUpdate(entry, field, value) {
-        switch (field) {
-            case "VariableSet": {
-                if (!value) {
-                    this._unloadVariableSet(entry);
-                }
-                else if (typeof value === 'string') {
-                    this._loadVariableSetItem(entry, value).catch((err) => {
-                        console.error(err);
-                    });
-                }
-                else {
-                    this._loadVariableSet(entry).catch((err) => {
-                        console.error(err);
-                    });
-                }
-                break;
-            }
-            case "Name": {
-                this._renameVariableSet(entry);
-                break;
-            }
-        }
-    }
-    async _processVariableSetEntry(entry) {
-        if (!this.project) {
-            throw new Error("Project not set.");
-        }
-        const variableSetItem = entry.getFieldValue("VariableSet");
-        const id = entry.getId();
-        const variableSet = this.project.variableSets.get(id);
-        if (!variableSet && variableSetItem) {
-            if (typeof variableSetItem === 'string') {
-                // variableSetItem is just a string so the item has not yet been loaded. We need to do that first, the
-                // actual loading will then be triggered by an update event once the item is loaded
-                await this._loadVariableSetItem(entry, variableSetItem);
-            }
-            else {
-                // we have the variable set item already, directly load the variable set
-                await this._loadVariableSet(entry);
-            }
-        }
-        else if (variableSet) {
-            this._unloadVariableSet(entry);
-        }
-    }
-    _destroyVariableSetEntry(entry) {
-        if (!this.project) {
-            throw new Error("Project not set.");
-        }
-        const id = entry.getId();
-        this._unloadVariableSet(entry);
-        entry.destroy();
-        this.project.variableSetListEntries.delete(id);
-    }
-    async _loadVariableSetItem(entry, variableSetItemId) {
-        if (!this.project) {
-            throw new Error("Project not set.");
-        }
-        return this.engine.itemRepo.loadItem(variableSetItemId, { recursive: true }).then((variableSetItem) => {
-            const variableSetField = entry.getField("VariableSet");
-            if (variableSetField)
-                variableSetField.value = variableSetItem;
-        });
-    }
-    async _loadVariableSet(entry) {
-        if (!this.project) {
-            throw new Error("Project not set.");
-        }
-        const variableSetItem = entry.getFieldValue("VariableSet");
-        return this.engine.loadingManager.loadVariableSet(this.getId(), variableSetItem).then((variableSetItem) => {
-            this.project.variableSets.set(entry.getId(), variableSetItem);
-            this._registerVariableSet(entry);
-            this._loadingManagerUpdateInfo();
-            this._updateState();
-        });
-    }
-    _unloadVariableSet(entry) {
-        if (!this.project) {
-            throw new Error("Project not set.");
-        }
-        const variableSetItem = this.project.variableSets.get(entry.getId());
-        if (variableSetItem) {
-            this._unregisterVariableSet(entry);
-            this.engine.loadingManager.unload(this.getId(), variableSetItem);
-            this.project.variableSets.delete(entry.getId());
-        }
-    }
-    _registerVariableSet(entry) {
-        if (!this.project) {
-            throw new Error("Project not set.");
-        }
-        const id = entry.getId();
-        const name = entry.getFieldValue("Name");
-        const variableSet = this.project.variableSets.get(id);
-        if (variableSet) {
-            this.engine.variables.registerVariableSet(name, variableSet);
-            variableSet.$on('item:objectUpdated', this._variableSetItemUpdated);
-        }
-    }
-    _unregisterVariableSet(entry) {
-        if (!this.project) {
-            throw new Error("Project not set.");
-        }
-        const id = entry.getId();
-        const variableSet = this.project.variableSets.get(id);
-        if (variableSet) {
-            variableSet.$off('item:objectUpdated', this._variableSetItemUpdated);
-        }
-        const name = entry.getFieldValue("Name");
-        this.engine.variables.unregisterVariableSet(name);
-    }
-    _variableSetItemUpdated = (variableSet) => {
-        if (!this.project) {
-            throw new Error("Project not set.");
-        }
-        const id = tools.findKeyInMap(this.project.variableSets, variableSet);
-        if (id) {
-            const entry = this.project.variableSetListEntries.get(id);
-            if (entry) {
-                const name = entry.getFieldValue("Name");
-                this.engine.variables.registerVariableSet(name, variableSet);
-            }
-        }
-    };
-    _renameVariableSet(entry) {
-        if (!this.project) {
-            throw new Error("Project not set.");
-        }
-        const id = entry.getId();
-        const name = entry.getFieldValue("Name");
-        const variableSet = this.project.variableSets.get(id);
-        if (variableSet) {
-            this.engine.variables.renameVariableSet(name, variableSet);
-        }
-    }
-    // ------------------------------------------------------------------------------------------------------
-    //  FONTS
-    // ------------------------------------------------------------------------------------------------------
-    async _updateCanvasFonts() {
-        if (!this.project) {
-            throw new Error("Project not set.");
-        }
-        const canvasFonts = this.getField("CanvasFonts");
-        // field does not exist. maybe an old project version
-        if (!canvasFonts)
-            return;
-        // Create or update any blocks to new list entries
-        // ----------------------------------------------------------------------
-        for (const block of canvasFonts.blocks) {
-            const listEntry = this.project.canvasFontListEntries.get(block.id);
-            if (!listEntry) {
-                const entry = new ListEntry(this, block, this.engine);
-                this.project.canvasFontListEntries.set(block.id, entry);
-                entry.$on('listentry:update', (entry, field, value) => {
-                    this._onCanvasFontListEntryUpdate(entry, field, value);
-                });
-                await this._processCanvasFontEntry(entry);
-            }
-        }
-        // Check which blocks disappeared
-        // ----------------------------------------------------------------------
-        const deletedEntries = [];
-        for (const id of this.project.canvasFontListEntries.keys()) {
-            let found = false;
-            for (const block of canvasFonts.blocks) {
-                if (block.id === id) {
-                    found = true;
-                    break;
-                }
-            }
-            if (!found) {
-                deletedEntries.push(id);
-            }
-        }
-        for (const id of deletedEntries) {
-            const listEntry = this.project.canvasFontListEntries.get(id);
-            if (listEntry)
-                this._destroyCanvasFontEntry(listEntry);
-        }
-    }
-    _onCanvasFontListEntryUpdate(entry, field, value) {
-        switch (field) {
-            case "Font": {
-                if (!value) {
-                    this._unloadCanvasFont(entry);
-                }
-                else if (typeof value === 'string') {
-                    this._loadCanvasFontItem(entry, value).catch(function (err) {
-                        console.error(err);
-                    });
-                }
-                else {
-                    this._loadCanvasFont(entry).catch(function (err) {
-                        console.error(err);
-                    });
-                }
-                break;
-            }
-        }
-    }
-    async _processCanvasFontEntry(entry) {
-        if (!this.project) {
-            throw new Error("Project not set.");
-        }
-        const canvasFontItem = entry.getFieldValue("Font");
-        const id = entry.getId();
-        const canvasFont = this.project.canvasFonts.get(id);
-        if (!canvasFont && canvasFontItem) {
-            if (typeof canvasFontItem === 'string') {
-                // canvasFontItem is just a string so the item has not yet been loaded. We need to do that first, the
-                // actual loading will then be triggered by an update event once the item is loaded
-                await this._loadCanvasFontItem(entry, canvasFontItem);
-            }
-            else {
-                // we have the font item already, directly load the font
-                await this._loadCanvasFont(entry);
-            }
-        }
-        else if (canvasFont) {
-            this._unloadCanvasFont(entry);
-        }
-    }
-    _destroyCanvasFontEntry(entry) {
-        if (!this.project) {
-            throw new Error("Project not set.");
-        }
-        const id = entry.getId();
-        this._unloadCanvasFont(entry);
-        entry.destroy();
-        this.project.canvasFontListEntries.delete(id);
-    }
-    async _loadCanvasFontItem(entry, canvasFontItemId) {
-        return this.engine.itemRepo.loadItem(canvasFontItemId, { recursive: true }).then(function (fontItem) {
-            const fontField = entry.getField("Font");
-            if (fontField)
-                fontField.value = fontItem;
-        });
-    }
-    async _loadCanvasFont(entry) {
-        if (!this.project) {
-            throw new Error("Project not set.");
-        }
-        const fontItem = entry.getFieldValue("Font");
-        return this.engine.loadingManager.loadFont(this.getId(), fontItem).then((fontItem) => {
-            this.project.canvasFonts.set(entry.getId(), fontItem);
-            this._loadingManagerUpdateInfo();
-            this._updateState();
-        });
-    }
-    _unloadCanvasFont(entry) {
-        if (!this.project) {
-            throw new Error("Project not set.");
-        }
-        const canvasFontItem = this.project.canvasFonts.get(entry.getId());
-        if (canvasFontItem) {
-            this.engine.loadingManager.unload(this.getId(), canvasFontItem);
-            this.project.canvasFonts.delete(entry.getId());
-        }
-    }
-    updateEvent(field, value, type) {
-        switch (field) {
-            case "Scenes":
-                this._updateScenes().catch(function (err) {
-                    console.error(err);
-                });
-                break;
-            case "VariableSets":
-                this._updateVariableSets().catch(function (err) {
-                    console.error(err);
-                });
-                break;
-            case "CanvasFonts":
-                this._updateCanvasFonts().catch(function (err) {
-                    console.error(err);
-                });
-                break;
-            case "LayerNames":
-                this.updateLayerNames();
-                break;
-            case "CollisionMatrix":
-                this.updateCollisionMatrix();
-                break;
-            case "AutomaticPointerLock":
-                this.updateAutomaticPointerLock();
-                break;
-            case "AspectRatio":
-            case "CustomAspect":
-                this.engine.eventBus.$emit('project:aspectRatioChanged', this);
-                break;
-        }
-    }
-}
-//# sourceMappingURL=ProjectItem.js.map