@luminocity/lemonate-engine 15.2.2 → 15.2.3

package/dist/scenegraph/SgItem.js

@@ -1,1427 +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 { Color, MeshPhysicalMaterial, MeshStandardMaterial, MeshBasicMaterial, Object3D, Quaternion, Vector3, Box3, Matrix4, BackSide, DoubleSide, Group, Mesh } from 'three';
-import { E_CANCELED, Mutex } from 'async-mutex';
-import tools from '../Tools.js';
-import { VertexNormalsHelper } from "@/helpers/VertexNormalsHelper";
-import { FaceNormalsHelper } from '@/helpers/FaceNormalsHelper';
-import { BoxHelper } from '@/helpers/BoxHelper';
-import { layerIndexHelper, LayerIndexNormalsHelper } from '@/Renderer';
-import { SgItemScript } from "./SgItemScript";
-import { SgResourceOwner } from "./SgResourceOwner";
-import { Block } from "@luminocity/lemonate-gateway";
-export var SgItemState;
-(function (SgItemState) {
-    SgItemState[SgItemState["Constructed"] = 1] = "Constructed";
-    SgItemState[SgItemState["Created"] = 2] = "Created";
-    SgItemState[SgItemState["ToDestroy"] = 3] = "ToDestroy";
-    SgItemState[SgItemState["Destroyed"] = 4] = "Destroyed";
-})(SgItemState || (SgItemState = {}));
-export class SgItem extends SgResourceOwner {
-    //The block stores the underlying model of the SgItem. It must be set. If it is not passed, an empty one will be created.
-    block;
-    state;
-    fieldMap; // quick lookup of fields by name
-    parent;
-    scene;
-    sceneGraph;
-    engine;
-    renderer;
-    itemRepo;
-    editorMode;
-    selected = false;
-    children = [];
-    itemId;
-    visible = true;
-    autoRecreate = true;
-    recreationMutex = new Mutex();
-    container = new Group();
-    boxHelper;
-    normalsHelpers = [];
-    scripts = [];
-    updateListeners = {};
-    // resources, that might better be stored in SgResourceOwner
-    material;
-    font;
-    ownMaterial;
-    prefabItem;
-    _isPlaying = false;
-    _updateContentHook;
-    constructor(block, parent, scene, engine, position, sceneGraph) {
-        super(engine);
-        tools.assert(sceneGraph, 'Scenegraph to add to needs to be specified');
-        tools.assert(!block || block instanceof Block, "block must be of type Block!");
-        tools.assert(!block || Array.isArray(block.fields), `Field instances for block is not an array! ${block}`);
-        this.block = block || new Block();
-        this.state = SgItemState.Constructed;
-        this.fieldMap = new Map(); // quick lookup of fields by name
-        this.parent = parent;
-        this.scene = scene;
-        this.sceneGraph = sceneGraph;
-        this.engine = engine;
-        this.renderer = engine.renderer;
-        this.itemRepo = engine.itemRepo;
-        this.editorMode = engine.editorMode;
-        this.container.name = `${this.getType()}Container`;
-        this._updateContentHook = (item) => {
-            if (!item) {
-                console.warn("Update content hook called without item.");
-                return;
-            }
-            const updatedItemId = item.getId();
-            const thisItemId = this.getItemId();
-            if (thisItemId && updatedItemId === thisItemId) {
-                this.destroyHelpers();
-                this.createHelpers();
-                this.addHelpersToScene();
-            }
-        };
-        this.updateListeners.block = this.engine.addUpdateListener(this.block.id, (field, value, type, oldValue) => {
-            this.updateEvent(field, value, type, oldValue);
-        });
-        if (this.parent) {
-            this.parent.add(this, position);
-        }
-        // correct old layers entries which contained 10 true/false values
-        const layers = this.getFieldValue("Layers");
-        if (layers && (!Array.isArray(layers) || layers[0] === true || layers[0] === false)) {
-            this.setFieldValue("Layers", [0]);
-        }
-    }
-    getScripts() {
-        return this.scripts;
-    }
-    getSceneGraph() {
-        return this.sceneGraph;
-    }
-    isCreated() {
-        return this.state === SgItemState.Created;
-    }
-    waitForCreated() {
-        return new Promise((resolve, reject) => {
-            // Immediately resolve if the state is already created
-            if (this.state === SgItemState.Created) {
-                resolve(this);
-                return;
-            }
-            // Set up a timeout to reject if the state isn't created in time
-            const timeout = setTimeout(() => {
-                this.$off('sgitem:recreated', onRecreated);
-                reject(new Error('Timeout waiting for created state.'));
-            }, 3000);
-            // Event listener to resolve the promise when the state changes
-            const onRecreated = () => {
-                clearTimeout(timeout);
-                this.$off('sgitem:recreated', onRecreated);
-                resolve(this);
-            };
-            this.$on('sgitem:recreated', onRecreated);
-        });
-    }
-    getParent() {
-        if (this.parent && this.parent.getType() === "Scene") {
-            // if our parent is a scene, check if it is a prefab scene. If so, we go one more step up to get to the prefab.
-            const prefab = this.parent.getParent();
-            if (prefab && prefab.getType() === "Prefab")
-                return prefab;
-        }
-        return this.parent;
-    }
-    getChildren() {
-        return this.children;
-    }
-    // Returns containing sgPrefab. If item is on top level, return item itself
-    getTopLevelItem() {
-        let currNode = this;
-        while (currNode) {
-            const containingPrefab = currNode.sceneGraph.root.parent;
-            if (containingPrefab) {
-                currNode = containingPrefab;
-            }
-            else {
-                return currNode;
-            }
-        }
-        return this;
-    }
-    async createFromThis(fieldOverrides, parent) {
-        parent = parent ?? this.parent;
-        const field = this.sceneGraph.sceneItem.fieldInstances.find(f => f.name === "Scenegraph");
-        const cloneResult = await this.engine.apiClient.serializer.clone(this.block, field, parent.block, this.sceneGraph.getOwnerItem(), {
-            dontCopyScripts: this._isPlaying,
-            fieldOverrides
-        });
-        const newBlock = cloneResult[0];
-        const newBlockDescendants = newBlock.getDescendantBlocks([newBlock]);
-        const itemPromises = newBlockDescendants.map((block) => {
-            return new Promise(async (resolve, reject) => {
-                const result = await this.sceneGraph.findOrWaitForItemByBlockId(block.id);
-                await result.node.waitForCreated();
-                resolve(result.node);
-            });
-        });
-        const newItems = await Promise.all(itemPromises);
-        const newItem = newItems[0];
-        const clonedScripts = this.itemRepo.copyScripts(this.block, newBlock, this._isPlaying);
-        // wait for all new scripts to have been added to the player, if playing
-        if (this._isPlaying) {
-            const player = this.engine.player;
-            await Promise.all(clonedScripts.map(script => player.waitForScriptAdded(script)));
-            // now initialize scripts in a top down, breadth-first order (same as in cloning procedure)
-            for (const scriptMeta of clonedScripts) {
-                const scriptEntry = player.getScriptEntryFromMetaScript(scriptMeta);
-                await player.initializeScript(scriptEntry);
-                scriptMeta.deferInitCall = false;
-            }
-        }
-        return newItem;
-    }
-    async clone(x, y, z, parent) {
-        const oldTransform = this.getFieldValue("Transform");
-        return this.createFromThis({ Transform: {
-                position: {
-                    x: x ?? oldTransform.position.x,
-                    y: y ?? oldTransform.position.y,
-                    z: z ?? oldTransform.position.z
-                },
-                rotation: oldTransform.rotation,
-                scale: oldTransform.scale
-            } }, parent);
-    }
-    moveToParent(parent) {
-        parent = parent || this.block.getRoot();
-        this.block.moveToParent(parent.block.id);
-    }
-    detachFromParent() {
-        if (this.parent)
-            this.itemRepo.removeBlock(this.block, this.parent.block);
-    }
-    getId() {
-        return this.block.id;
-    }
-    getType() {
-        return "Item";
-    }
-    hasTag(tag) {
-        return this.block && this.block.hasTag(tag);
-    }
-    hasOneTag(tags) {
-        return this.block && this.block.hasOneTag(tags);
-    }
-    isInLayer(layer) {
-        const layers = this.getFieldValue("Layers");
-        if (Array.isArray(layers)) {
-            return layers.includes(layer);
-        }
-        return false;
-    }
-    isInOneLayer(layers) {
-        const actualLayers = this.getFieldValue("Layers");
-        if (Array.isArray(actualLayers)) {
-            for (const layer of layers) {
-                if (actualLayers.includes(layer))
-                    return true;
-            }
-        }
-        return false;
-    }
-    play() {
-        this._isPlaying = true;
-    }
-    stop() {
-        this._isPlaying = false;
-        this.autoRecreate = true;
-    }
-    pause() {
-    }
-    resume() {
-    }
-    setActive(active) {
-        if (!active) {
-            try {
-                this.deactivate();
-            }
-            catch (err) {
-                console.error("Error when deactivating: ", err);
-            }
-        }
-        this.show(active);
-        if (active) {
-            try {
-                this.activate();
-            }
-            catch (err) {
-                console.error("Error when deactivating: ", err);
-            }
-        }
-    }
-    activate() {
-        for (const child of this.children) {
-            child.activate();
-        }
-    }
-    deactivate() {
-        for (const child of this.children) {
-            child.deactivate();
-        }
-    }
-    isEnabled() {
-        return this.getFieldValue("Active");
-    }
-    enable() {
-        if (!this.isEnabled())
-            this.setFieldValue("Active", true);
-    }
-    disable() {
-        if (this.isEnabled())
-            this.setFieldValue("Active", false);
-    }
-    getItemId() {
-        if (typeof this.getItem !== 'function')
-            return null;
-        const item = this.getItem();
-        if (!item)
-            return null;
-        return item.getId();
-    }
-    getItem() {
-        return undefined;
-    }
-    isPhysicsItem() {
-        return false;
-    }
-    isParticlesItem() {
-        return this.getType() === "Particles";
-    }
-    isFileContentModified() {
-        const item = this.getItem();
-        if (item && item.isFileContentModified())
-            return true;
-        return this.areScriptsModified();
-    }
-    async saveFileContent() {
-        const promises = [];
-        const item = this.getItem();
-        if (item)
-            promises.push(item.saveFileContent());
-        promises.push(this.saveScriptContent());
-        return Promise.all(promises);
-    }
-    areScriptsModified() {
-        for (const script of this.scripts) {
-            if (script.isFileContentModified())
-                return true;
-        }
-        return false;
-    }
-    async saveScriptContent() {
-        const promises = [];
-        for (const script of this.scripts) {
-            if (script.isFileContentModified())
-                promises.push(script.saveFileContent());
-        }
-        return Promise.all(promises);
-    }
-    isAnimated() {
-        return false;
-    }
-    getAnimations() {
-        return [];
-    }
-    getDisplayName() {
-        const name = this.getFieldValue("Name");
-        if (name)
-            return name;
-        const type = this.getType();
-        const id = this.getId();
-        const truncatedId = id.length > 12 ? `...${id.slice(-12)}` : id;
-        return `<${type} (${truncatedId})>`;
-    }
-    getName() {
-        return this.getFieldValue("Name");
-    }
-    _sceneUpdated() {
-        this.engine.eventBus.$emit('scene:updated', this.scene, this);
-        this.$emit('updated', this);
-    }
-    traverseChildren(func, omitSelf = false) {
-        if (!omitSelf)
-            func(this);
-        for (const child of this.children) {
-            child.traverseChildren(func);
-        }
-    }
-    /**
-     * This function should be overloaded and return any items, the object is using. For example SgMesh should return
-     * its internal mesh and material objects or if not yet loaded, the item dataset or item id
-     * @returns {*[]}
-     */
-    enumerateItemChildren() {
-        return [];
-    }
-    _getChildOrLinkItem(fieldName, linkUsage) {
-        const child = this[fieldName];
-        if (child)
-            return child;
-        const linkItem = this.getFieldValue(linkUsage);
-        if (linkItem)
-            return linkItem;
-        return null;
-    }
-    setContentHookEnabled(value) {
-        if (value)
-            this.engine.eventBus.$on('item:contentUpdated', this._updateContentHook);
-        else
-            this.engine.eventBus.$off('item:contentUpdated', this._updateContentHook);
-    }
-    configure(cfg) {
-        if (!cfg)
-            return;
-        for (const name in cfg) {
-            if (cfg.hasOwnProperty(name)) {
-                this.setFieldValue(name, cfg[name]);
-            }
-        }
-    }
-    async _initScripts() {
-        this.scripts = [];
-        if (Array.isArray(this.block && this.block.scripts)) {
-            for (const scriptMeta of this.block.scripts) {
-                await this.addScript(scriptMeta);
-            }
-        }
-    }
-    async _setScriptsEnabled(value) {
-        const promises = [];
-        for (const script of this.scripts) {
-            promises.push(this.engine.player.setScriptEnabled(script, value));
-        }
-        return Promise.all(promises);
-    }
-    _destroyScripts() {
-        for (const script of this.scripts) {
-            script.destroy();
-        }
-        this.scripts = [];
-    }
-    async addScript(scriptMeta) {
-        const itemScript = new SgItemScript(scriptMeta, this, this.engine, this.sceneGraph);
-        await itemScript.create();
-        this.scripts.push(itemScript);
-    }
-    removeScript(scriptMeta) {
-        const script = this.findScript(scriptMeta.id);
-        if (script) {
-            script.destroy();
-            this.scripts.removeObject(script);
-        }
-    }
-    findScript(scriptId) {
-        for (const script of this.scripts) {
-            if (script.getId() === scriptId)
-                return script;
-        }
-    }
-    setFieldValue(name, value) {
-        const field = this.getField(name);
-        if (field) {
-            field.value = value;
-        }
-        else {
-            console.error(`setFieldValue() : field ${name} not found!`);
-        }
-    }
-    /**
-     * Check if the object is either equal to this node object or if it
-     * is somewhere in its children
-     * @param object
-     * @returns {boolean}
-     */
-    _contains(object, node) {
-        if (node === object) {
-            return true;
-        }
-        for (const child of node.children) {
-            if (child.userData.id === this.block.id) {
-                if (this._contains(object, child))
-                    return true;
-            }
-        }
-        return false;
-    }
-    async _loadMaterial(material, preferredType = "meshPhysical") {
-        let matObject = null;
-        if (material) {
-            if (material instanceof MeshBasicMaterial ||
-                material instanceof MeshStandardMaterial ||
-                material instanceof MeshPhysicalMaterial) {
-                this.material = material;
-                matObject = material;
-            }
-            else if (material.type === "CanvasTexture") {
-                const canvasTexture = await this.engine.loadingManager.get(material._id, this.referenceId);
-                if (canvasTexture)
-                    matObject = canvasTexture.getMaterial(preferredType);
-            }
-            else {
-                this.material = await this.engine.loadingManager.loadMaterial(this.referenceId, material);
-                this.material.$on('item:objectUpdated', this.recreate, this);
-                matObject = this.material.getObject();
-            }
-        }
-        return matObject;
-    }
-    async _loadFont(font) {
-        this.font = await this.engine.loadingManager.loadFont(this.referenceId, font);
-        let fontObject = this.font.getObject();
-        return fontObject;
-    }
-    _destroyMaterial() {
-        if (this.material && typeof (this.material.getInstanceId) === 'function') {
-            this.material.$off('item:objectUpdated', this.recreate, this);
-            this.material = null;
-        }
-        if (this._res?.itemMaterial)
-            this.freeResource("itemMaterial");
-        if (this._res?.threeMaterial)
-            this.freeResource("threeMaterial");
-    }
-    _ensureMaterial(material, hexValue = 0xffffff, vertexColors = false) {
-        if (material)
-            return material;
-        if (this.ownMaterial)
-            this._disposeOwnMaterial();
-        this.ownMaterial = new MeshPhysicalMaterial({
-            color: hexValue,
-            vertexColors: vertexColors,
-            side: DoubleSide,
-            shadowSide: BackSide,
-            map: this.engine.renderer.getDefaultUvTestTexture()
-        });
-        this.renderer.addMaterial(this.ownMaterial);
-        return this.ownMaterial;
-    }
-    _disposeOwnMaterial() {
-        if (this.ownMaterial) {
-            this.renderer.removeMaterial(this.ownMaterial);
-            this.ownMaterial.dispose();
-            this.ownMaterial = undefined;
-        }
-    }
-    getMaterial() {
-        return this.material;
-    }
-    async onDrop(droppedItem) {
-        const targetBlock = this.block;
-        const type = droppedItem.type === "Package" ? droppedItem.packageType : droppedItem.type;
-        // In case we dropped a script, add the dropped script to the item
-        // ----------------------------------------------------------------------------
-        if (type === "Script") {
-            const script = this.itemRepo.createNewScript(targetBlock, undefined, droppedItem);
-            const item = await this.itemRepo.loadItem(droppedItem.id, { recursive: true });
-            if (item) {
-                script.item.value = item;
-                return true;
-            }
-            else {
-                console.error("Script could not be loaded: " + droppedItem.id);
-                return false;
-            }
-        }
-        // Maybe we got dropped a scenegraph item. If so, move it as child of this item
-        // ----------------------------------------------------------------------------
-        if (this.engine.activeSceneGraphCollection) {
-            const sgDroppedItem = this.engine.activeSceneGraphCollection.findItemById(droppedItem.id);
-            const droppedItemIsObject3D = sgDroppedItem && sgDroppedItem.getContainer() instanceof Object3D;
-            // Detach dropped item from old parent and add it as child, if the dropped object is an Object3D
-            // ----------------------------------------------------------------------------
-            if (droppedItemIsObject3D) {
-                // Dont allow a parent to drop on its descendants
-                const droppedItemIsDescendantOfThis = this.isDescendantOf(sgDroppedItem);
-                if (!droppedItemIsDescendantOfThis) {
-                    this.engine.moveTreeItemsToNewParent([droppedItem.id], this.getId());
-                    return true;
-                }
-            }
-        }
-        // Check if this item has a field which takes the dropped type and add it there. There are exceptions however,
-        // we do not want this behaviour for any type of dropped item
-        // ----------------------------------------------------------------------------
-        if (["Image", "Material"].includes(type)) {
-            for (const field of this.block.fields) {
-                if (field.type === "Link" && field.linkableTypes.includes(type)) {
-                    const item = await this.itemRepo.loadItem(droppedItem.id, { recursive: true });
-                    field.value = item;
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
-    isDescendantOf(otherItem) {
-        let currElem = this;
-        while (currElem && currElem.getType() !== "Scene") {
-            if (currElem === otherItem) {
-                return true;
-            }
-            currElem = currElem.parent;
-        }
-        return false;
-    }
-    setSelected(selected) {
-        if (this.selected === selected) {
-            return;
-        }
-        this.selected = selected;
-        this.updateSelection();
-    }
-    setParent(parent) {
-        this.parent = parent;
-    }
-    removeFromParent() {
-        if (this.parent) {
-            this.parent.remove(this);
-        }
-    }
-    add(child, position) {
-        if (!(child instanceof SgItem))
-            throw "Can only add instances of SgItem! Invalid type: " + (typeof child);
-        child.setParent(this);
-        if (Number.isInteger(position))
-            this.children.splice(position, 0, child);
-        else
-            this.children.push(child);
-        const container = child.getContainer();
-        if (container)
-            this.addChild(container);
-    }
-    remove(child) {
-        this.children.removeObject(child);
-    }
-    addChild(child) {
-        const container = this.getContainer();
-        if (container) {
-            // we handle adding the child to the lod, once the threejs object is being added
-            if (this.getType() !== "Lod") {
-                container.add(child);
-            }
-        }
-        else {
-            console.warn("Cannot add object as child. This item has no container!", this.block);
-        }
-    }
-    removeChild(child) {
-        const container = this.getContainer();
-        if (container) {
-            // we handle removing the object to the lod, once the threejs object is being removed
-            if (this.getType() !== "Lod") {
-                container.remove(child);
-            }
-        }
-        else {
-            console.warn("Cannot remove objects. This item has no container!", this.block);
-        }
-    }
-    /**
-     * Check if the object is either equal to this items object or if it
-     * is somewhere in its children
-     * @param object
-     * @returns {boolean}
-     */
-    contains(object) {
-        const obj = this.getObject();
-        if (obj) {
-            return this._contains(object, obj);
-        }
-        return false;
-    }
-    /**
-     * Check if the object is equal to this items object
-     * @param object
-     * @returns {boolean}
-     */
-    is(object) {
-        const obj = this.getObject();
-        return obj === object;
-    }
-    /**
-     * Updates the transform stored in the block information from the
-     * three.js object
-     */
-    updateBlockTransform() {
-        if (!this.getContainer)
-            return;
-        const container = this.getContainer();
-        if (!container)
-            return;
-        const transformField = this.getField("Transform");
-        if (!transformField)
-            return;
-        const containerTransform = {
-            position: container.position,
-            rotation: container.quaternion,
-            scale: container.scale
-        };
-        if (tools.areTransformsEqual(containerTransform, transformField.value))
-            return;
-        transformField.value = {
-            position: {
-                x: container.position.x,
-                y: container.position.y,
-                z: container.position.z
-            },
-            rotation: {
-                x: container.quaternion.x,
-                y: container.quaternion.y,
-                z: container.quaternion.z,
-                w: container.quaternion.w
-            },
-            scale: {
-                x: container.scale.x,
-                y: container.scale.y,
-                z: container.scale.z
-            }
-        };
-    }
-    /**
-     * Make sure the item specified by itemId is in the cache. If not, load it
-     * @param itemId
-     * @returns {Promise<*|string>}
-     */
-    async ensureItemInCache(itemId) {
-        return this.engine.getDownloadUrl(itemId);
-    }
-    /**
-     * Get the value of the specified field
-     * @param name
-     * @param defaultValue
-     * @returns {null|*}
-     */
-    getFieldValue(name, defaultValue) {
-        const field = this.getField(name);
-        const value = field?.value;
-        if (value === undefined)
-            return defaultValue;
-        return value;
-    }
-    /**
-     * Get the field with the specified name
-     * @param name
-     * @returns {null}
-     */
-    getField(name) {
-        let f = this.fieldMap.get(name);
-        if (f) {
-            return f;
-        }
-        for (const field of this.block.fields) {
-            if (field.name === name) {
-                this.fieldMap.set(name, field);
-                return field;
-            }
-        }
-        return null;
-    }
-    /**
-     * Convert RGB color object to a three.js color object
-     * @param col
-     * @returns {Color}
-     */
-    toColorObjRgb(col) {
-        let color = new Color(col.r / 255, col.g / 255, col.b / 255);
-        color.convertSRGBToLinear();
-        return color;
-    }
-    ;
-    updateEvent(field, value, type, oldValue) {
-        switch (field) {
-            case "Active": {
-                this.setActive(value);
-                break;
-            }
-            case "Layers": {
-                this.setLayers(value);
-                break;
-            }
-            case "Name": {
-                this.setName(value);
-                break;
-            }
-            case "Transform": {
-                this.setTransform(value);
-                this.updateHelpers();
-                break;
-            }
-            case "CastShadow": {
-                this.setShadows(value, undefined);
-                break;
-            }
-            case "ReceiveShadow": {
-                this.setShadows(undefined, value);
-                break;
-            }
-            default:
-                return false; // we did not handle the event
-        }
-        // we handled the event
-        return true;
-    }
-    setTransform(transform) {
-        if (!transform)
-            return;
-        const container = this.getContainer();
-        if (!container)
-            return;
-        tools.setTransformOnObject(container, transform);
-        // apply changes to items below this one when this items transform changes
-        this.updateTransformChangesOnDescendants();
-    }
-    updateTransformChangesOnDescendants() {
-        for (const child of this.children) {
-            child.updateTransformChangesOnDescendants();
-        }
-    }
-    /**
-     * A physics item will be added to the physics engine if
-     * 1) It is physicsEnabled
-     * 2) It is active
-     * 3) All its ancestors are active
-     */
-    updatePhysicsFromFields(recursively = false) {
-        const allAncestorsAreActive = this.allAncestorsAreActive();
-        this.setPhysicsFromFields(allAncestorsAreActive, recursively);
-    }
-    setPhysicsFromFields(allAncestorsActive, recursively) {
-        const isActive = this.isEnabled();
-        if (this.isPhysicsItem()) {
-            const pi = this;
-            const isPhysicsEnabled = pi.isPhysicsEnabled();
-            const enablePhysics = allAncestorsActive && isActive && isPhysicsEnabled;
-            pi.setPhysics(enablePhysics);
-        }
-        if (recursively) {
-            for (const child of this.children) {
-                child.setPhysicsFromFields(allAncestorsActive && isActive, recursively);
-            }
-            if (this.getType() === "Prefab" && this.prefabItem) {
-                this.prefabItem.sceneGraph.root?.setPhysicsFromFields?.(allAncestorsActive && isActive, recursively);
-            }
-        }
-    }
-    // Helper function to toggle the particle system preview based on parent active status.
-    updateParticleSystemPreview(recursively) {
-        const allAncestorsActive = this.allAncestorsAreActive();
-        const isActive = this.isEnabled();
-        if (this.isParticlesItem()) {
-            const particles = this;
-            if (particles.system) {
-                const shouldRun = allAncestorsActive && isActive &&
-                    (particles.isRunning || particles.isRunningPreview);
-                if (shouldRun) {
-                    particles.system.isRunning = true;
-                    particles.system.isPaused = false;
-                    particles.system.showParticles();
-                    particles.system.restart();
-                }
-                else {
-                    particles.system.isRunning = false;
-                    particles.system.isPaused = true;
-                    particles.system.hideParticles();
-                }
-            }
-        }
-        if (recursively) {
-            for (const child of this.children) {
-                child.updateParticleSystemPreview?.(recursively);
-            }
-        }
-    }
-    getTransform() {
-        const container = this.getContainer();
-        if (!container)
-            return null;
-        const pos = container.position;
-        const quat = container.quaternion;
-        const scale = container.scale;
-        return {
-            position: {
-                x: pos.x,
-                y: pos.y,
-                z: pos.z
-            },
-            rotation: {
-                x: quat.x,
-                y: quat.y,
-                z: quat.z,
-                w: quat.w
-            },
-            scale: {
-                x: scale.x,
-                y: scale.y,
-                z: scale.z
-            }
-        };
-    }
-    getWorldMatrix() {
-        const container = this.getContainer();
-        if (!container)
-            return null;
-        return container.matrixWorld;
-    }
-    getInverseParentWorldMatrix() {
-        if (!this.parent)
-            return new Matrix4();
-        return this.parent.getInverseWorldMatrix();
-    }
-    getInverseWorldMatrix(container) {
-        container = container || this.getContainer();
-        if (!container)
-            return new Matrix4();
-        let inverseWorldMatrix = container.matrixWorld.clone();
-        inverseWorldMatrix.invert();
-        return inverseWorldMatrix;
-    }
-    getInverseParentWorldTransform() {
-        if (!this.parent) {
-            return {
-                position: {
-                    x: 0,
-                    y: 0,
-                    z: 0
-                },
-                rotation: {
-                    x: 0,
-                    y: 0,
-                    z: 0,
-                    w: 1
-                },
-                scale: {
-                    x: 1,
-                    y: 1,
-                    z: 1
-                }
-            };
-        }
-        return this.parent.getInverseWorldTransform();
-    }
-    getInverseWorldTransform(container) {
-        container = container || this.getContainer();
-        if (!container)
-            return null;
-        const pos = new Vector3();
-        container.getWorldPosition(pos);
-        pos.negate();
-        const quat = new Quaternion();
-        container.getWorldQuaternion(quat);
-        quat.invert();
-        const scale = new Vector3();
-        container.getWorldScale(scale);
-        scale.x = 1.0 / scale.x;
-        scale.y = 1.0 / scale.y;
-        scale.z = 1.0 / scale.z;
-        return {
-            position: {
-                x: pos.x,
-                y: pos.y,
-                z: pos.z
-            },
-            rotation: {
-                x: quat.x,
-                y: quat.y,
-                z: quat.z,
-                w: quat.w
-            },
-            scale: {
-                x: scale.x,
-                y: scale.y,
-                z: scale.z
-            }
-        };
-    }
-    getWorldTransform(obj) {
-        obj = obj || this.getObject() || this.getContainer();
-        if (!obj)
-            return null;
-        const pos = new Vector3();
-        obj.getWorldPosition(pos);
-        const quat = new Quaternion();
-        obj.getWorldQuaternion(quat);
-        const scale = new Vector3();
-        obj.getWorldScale(scale);
-        return {
-            position: {
-                x: pos.x,
-                y: pos.y,
-                z: pos.z
-            },
-            rotation: {
-                x: quat.x,
-                y: quat.y,
-                z: quat.z,
-                w: quat.w
-            },
-            scale: {
-                x: scale.x,
-                y: scale.y,
-                z: scale.z
-            }
-        };
-    }
-    setShadows(castShadow, receiveShadow) {
-        this.traverse(function (child) {
-            if (castShadow !== undefined)
-                child.castShadow = castShadow;
-            if (receiveShadow !== undefined)
-                child.receiveShadow = receiveShadow;
-        });
-    }
-    setName(value) {
-        this.traverse(function (child) {
-            child.userData.name = value;
-        });
-    }
-    getContainer() {
-        return this.container;
-    }
-    setContainer(container) {
-        this.container = container;
-    }
-    getObject() {
-        return null;
-    }
-    setObject(obj) {
-    }
-    // returns the actual mesh (most descendant object, ignoring containers)
-    // if not overloaded, returns getObject()
-    getMesh() {
-        return this.getObject();
-    }
-    setIdAndName() {
-        const obj = this.getObject();
-        const name = this.getFieldValue("Name");
-        if (!obj)
-            return;
-        obj.traverse((child) => {
-            child.userData = {
-                _isSgItem: true,
-                id: this.block.id,
-                name,
-            };
-        });
-    }
-    // Traverse the object and call the function on all children belonging to this sgnode.
-    // Sub-sgnode children will not be traversed, because they have a different userData.id.
-    traverse(func) {
-        const obj = this.getObject();
-        if (!obj || !obj.userData || !obj.userData.id)
-            return;
-        obj.traverse((child) => {
-            if (child.userData.id === obj.userData.id)
-                func(child);
-        });
-    }
-    /**
-     * Cullmode is layers but inverted. We define the layers we do NOT want to have instead of the ones we want
-     * @param cullmode
-     */
-    setCullmode(cullmode) {
-        this.setLayers(cullmode, true);
-    }
-    /**
-     * Set the layers in which the object should be visible. For cameras, use the invert parameters, since
-     * cameras by default see everything unless layers are culled through the cullmode setting.
-     * @param layers
-     * @param invert
-     */
-    setLayers(layers, invert = false) {
-        if (!Array.isArray(layers)) {
-            console.error("Layers must be an array!");
-            return;
-        }
-        // detect old boolean[] format and correct to number[]
-        if (layers.length > 0 && (layers[0] === true || layers[0] === false)) {
-            let newLayers = [];
-            for (const [i, v] of layers.entries()) {
-                if (v)
-                    newLayers.push(i);
-            }
-            layers = newLayers;
-        }
-        this.traverse(function (child) {
-            for (let i = 0; i < 32; i++) {
-                let selected = layers.includes(i);
-                if (invert)
-                    selected = !selected;
-                if (selected)
-                    child.layers.enable(i);
-                else
-                    child.layers.disable(i);
-            }
-        });
-    }
-    createHelpers() {
-        const container = this.getContainer();
-        if (!container)
-            return;
-        // Create box helper
-        // ---------------------------------------------------------
-        try {
-            this.boxHelper = new BoxHelper(container, 0xffff00);
-            this.boxHelper.name = "BoxHelper";
-            this.boxHelper.layers.set(layerIndexHelper);
-        }
-        catch {
-            console.error("Error creating box helper for object.", container);
-            this.boxHelper = undefined;
-        }
-        // Create normals helpers
-        // ---------------------------------------------------------
-        this.normalsHelpers = [];
-        container.traverse((object) => {
-            if (!(object instanceof Mesh))
-                return;
-            try {
-                const vertexNormalsHelper = new VertexNormalsHelper(object, 1.5, 0xff0000);
-                vertexNormalsHelper.layers.set(LayerIndexNormalsHelper);
-                this.normalsHelpers.push(vertexNormalsHelper);
-                const faceNormalsHelper = new FaceNormalsHelper(object, 3.0, 0x0000FF);
-                faceNormalsHelper.layers.set(LayerIndexNormalsHelper);
-                this.normalsHelpers.push(faceNormalsHelper);
-            }
-            catch {
-                console.error("Error creating normals helper for object!", object);
-            }
-        });
-    }
-    addHelpersToScene() {
-        const obj = this.getContainer();
-        if (this.boxHelper && this.selected) {
-            this.renderer.addToScene(this.boxHelper);
-            this.renderer.setTransformControlItems([this]);
-        }
-        if (this.normalsHelpers) {
-            for (const helper of this.normalsHelpers) {
-                obj.add(helper);
-            }
-        }
-        this.updateHelpers();
-    }
-    updateBoxHelper(updateParents = true, updateChildren = true) {
-        if (this.boxHelper) {
-            this.boxHelper.update();
-        }
-        if (this.parent && updateParents)
-            this.parent.updateBoxHelper(true, false);
-        if (!updateChildren) {
-            for (const child of this.children)
-                child.updateBoxHelper(false, true);
-        }
-    }
-    update(deltaTimeMs) {
-    }
-    updateHelpers() {
-        const obj = this.getContainer();
-        if (obj) {
-            obj.updateMatrixWorld();
-        }
-        // only update helpers, if they're actually shown
-        // ---------------------------------------------------------
-        if (!this.engine.renderer.renderOptions.showHelpers)
-            return;
-        // update the items own helpers
-        // ---------------------------------------------------------
-        this.updateBoxHelper();
-        if (this.normalsHelpers) {
-            for (const helper of this.normalsHelpers) {
-                helper.update();
-            }
-        }
-    }
-    updateSelection() {
-        if (!this.boxHelper) {
-            return;
-        }
-        this.updateHelpers();
-        if (this.selected) {
-            this.renderer.addToScene(this.boxHelper);
-        }
-        else {
-            this.renderer.removeFromScene(this.boxHelper);
-        }
-    }
-    showHelpers(value) {
-        if (!value)
-            this.renderer.setTransformControlItems([]);
-        if (this.boxHelper) {
-            this.boxHelper.visible = value;
-        }
-        if (this.normalsHelpers) {
-            for (const helper of this.normalsHelpers) {
-                helper.visible = value;
-            }
-        }
-    }
-    destroyHelpers() {
-        const obj = this.getContainer();
-        if (this.boxHelper) {
-            this.renderer.removeFromScene(this.boxHelper);
-            this.boxHelper = undefined;
-        }
-        if (this.normalsHelpers) {
-            for (const helper of this.normalsHelpers) {
-                obj.remove(helper);
-            }
-            this.normalsHelpers = [];
-        }
-    }
-    setAutoRecreate(value) {
-        this.autoRecreate = value;
-    }
-    getAutoRecreate() {
-        return this.autoRecreate;
-    }
-    recreate = async (force = false) => {
-        if (!this.autoRecreate && !force)
-            return;
-        // We're using a mutex here because it is quite possible that multiple changes will be done on an object
-        // in short time, triggering multiple recreates. If that happens, we need to make sure only once recreation call
-        // is initiated and the next one is done only after the first one has completed. Furthermore we never want to
-        // queue more than one pending call to it since it would just not make any sense and just use the CPU unnecessarily.
-        // Hence we call cancel first, to cancel any pending call before we add this new one.
-        this.recreationMutex.cancel();
-        return this.recreationMutex.runExclusive(() => this.create())
-            .catch((error) => {
-            if (error !== E_CANCELED) {
-                console.error(error);
-            }
-        });
-    };
-    async recreateObject(creationFunc, noHelpers = false, noAddToPhysics = false) {
-        const restartPlayback = this._isPlaying;
-        const savedAutoRecreate = this.autoRecreate;
-        if (restartPlayback)
-            this.stop();
-        this.destroy(false, false, true);
-        this.visible = this.getFieldValue("Active");
-        await creationFunc();
-        const obj = this.getObject();
-        this.addChildrenObjects();
-        if (!noHelpers) {
-            this.destroyHelpers();
-            this.createHelpers();
-        }
-        this.container.visible = this.visible;
-        if (obj) {
-            this.container.add(obj);
-        }
-        if (this.parent)
-            this.parent.addChild(this.container);
-        if (!noHelpers) {
-            this.addHelpersToScene();
-        }
-        await this._initScripts();
-        if (!noAddToPhysics)
-            this.updatePhysicsFromFields();
-        if (restartPlayback) {
-            this.play();
-            this.autoRecreate = savedAutoRecreate;
-        }
-        this._sceneUpdated();
-        this.setContentHookEnabled(true);
-        this.$emit('sgitem:recreated');
-        this.state = SgItemState.Created;
-    }
-    getPivot() {
-        return null;
-    }
-    addChildrenObjects() {
-        for (const child of this.children) {
-            const container = child.getContainer();
-            if (container) {
-                this.addChild(container);
-            }
-        }
-    }
-    destroyChildren() {
-        for (const child of this.children) {
-            child.destroy(false, true);
-        }
-    }
-    destroy(noDispose = false, withChildren = false, noRemoveUpdateListener = false) {
-        // We mark this object as to destroyed
-        // ----------------------------------------------------------------------
-        this.state = SgItemState.ToDestroy;
-        // we're no longer interested in any information about content updates regarding this object
-        // ----------------------------------------------------------------------
-        this.setContentHookEnabled(false);
-        if (!noRemoveUpdateListener && this.updateListeners.block) {
-            this.engine.removeUpdateListener(this.updateListeners.block);
-            this.updateListeners.block = undefined;
-        }
-        // In case we also want to destroy children of this, do it now
-        // ----------------------------------------------------------------------
-        if (withChildren)
-            this.destroyChildren();
-        // Now destroy any helpers of this object
-        // ----------------------------------------------------------------------
-        this.destroyHelpers();
-        // Grab the container of this object and if it has one (it should), remove
-        // it from the parent and also remove the actual object from the container if one exists
-        // ----------------------------------------------------------------------
-        const container = this.getContainer();
-        if (container) {
-            this.engine.activeSceneGraphCollection.removeFromSelectedItems(this);
-            if (this.parent)
-                this.parent.removeChild(container);
-            // only update box helpers if the parent is not to be deleted
-            if (this.parent && this.state === SgItemState.ToDestroy && this.parent.state === SgItemState.Created) {
-                this.parent.updateBoxHelper(true, false);
-            }
-            const obj = this.getObject();
-            if (obj) {
-                container.remove(obj);
-            }
-            this.setObject(undefined);
-        }
-        // Now dispose any of the additional resources that might still exist
-        // ----------------------------------------------------------------------
-        this._disposeOwnMaterial();
-        this._destroyMaterial();
-        this._destroyScripts();
-        this.freeResources();
-        // We're done with it. Mark it as destroyed
-        // ----------------------------------------------------------------------
-        this.state = SgItemState.Destroyed;
-    }
-    destroyAndRemove() {
-        this.destroy(false, true);
-        if (this.parent)
-            this.parent.remove(this);
-    }
-    show(value) {
-        if (this.visible === value)
-            return;
-        this.visible = value;
-        const obj = this.getContainer();
-        if (obj)
-            obj.visible = value;
-        this.updatePhysicsFromFields(true);
-        this.updateParticleSystemPreview(true);
-        return this._setScriptsEnabled(value);
-    }
-    allAncestorsAreActive() {
-        let currNode = this.parent;
-        while (currNode) {
-            const parent = currNode.getParent();
-            const isActive = currNode.isEnabled();
-            if (!isActive) {
-                return false;
-            }
-            if (!parent) {
-                return true;
-            }
-            currNode = parent;
-        }
-        return true;
-    }
-    getLayerIndices() {
-        const layers = this.getFieldValue("Layers");
-        return layers || [];
-    }
-    takeSnapshot(recursive) {
-        const data = this.block.createSnapshot(!recursive);
-        return {
-            data: data,
-            recursive: recursive
-        };
-    }
-    onBeforeRollback(recursive) {
-        if (recursive) {
-            for (const child of this.children) {
-                child.onBeforeRollback(recursive);
-            }
-        }
-    }
-    onPostRollback(recursive) {
-        if (recursive) {
-            for (const child of this.children) {
-                child.onPostRollback(recursive);
-            }
-        }
-    }
-    rollbackSnapshot(snapshot) {
-        this.onBeforeRollback(snapshot.recursive);
-        this.block.rollbackFromSnapshot(snapshot.data, !snapshot.recursive);
-        this.onPostRollback(snapshot.recursive);
-    }
-    getWorldPosition() {
-        const container = this.getContainer();
-        if (!container)
-            return null;
-        return container.getWorldPosition(new Vector3());
-    }
-    getBoundingBox() {
-        const obj = this.getObject();
-        const type = this.getType();
-        const box = new Box3();
-        box.makeEmpty();
-        // Sky is a special case, we should ignore it when creating scene bounding boxes since it
-        // Is not really part of the scene
-        // -------------------------------------------------------
-        if (this.getType() === "Sky")
-            return box;
-        // Get bounding boxes of all children and unify them with our bounding box
-        // -------------------------------------------------------
-        for (const child of this.children) {
-            const childBox = child.getBoundingBox();
-            if (childBox) {
-                box.union(childBox);
-            }
-        }
-        // Now get a bounding box if there is one. Either from item properties or from geometry
-        // -------------------------------------------------------
-        if (type === "Prefab" || type === "Scene") {
-            const sceneItem = this.getItem();
-            if (sceneItem) {
-                const sceneBbox = sceneItem.sceneGraph.getBoundingBox();
-                box.union(sceneBbox);
-            }
-        }
-        else if (obj) {
-            const info = tools.getObject3DInfos(obj);
-            if (!info.isHelper) {
-                if (obj) {
-                    obj.updateMatrixWorld();
-                    box.expandByObject(obj, true);
-                }
-            }
-        }
-        return box;
-    }
-}
-//# sourceMappingURL=SgItem.js.map