@combeenation/3d-viewer 5.1.2 → 5.2.0-alpha4

package/dist/lib-es6/api/classes/element.js

@@ -1,821 +1,665 @@
-import { __awaiter, __extends, __generator, __spreadArrays } from "tslib";
-import { PBRMaterial } from '@babylonjs/core/Materials/PBR/pbrMaterial';
-import { HighlightLayer } from '@babylonjs/core/Layers/highlightLayer';
-import { Material } from '@babylonjs/core/Materials/material';
-import { DynamicTexture } from '@babylonjs/core/Materials/Textures/dynamicTexture';
-import { Color3 } from '@babylonjs/core/Maths/math.color';
-import { AbstractMesh } from '@babylonjs/core/Meshes/abstractMesh';
-import { InstancedMesh } from '@babylonjs/core/Meshes/instancedMesh';
-import { Mesh } from '@babylonjs/core/Meshes/mesh';
-import { TransformNode } from '@babylonjs/core/Meshes/transformNode';
-import { has, isArray, isNumber, isPlainObject, merge, union } from 'lodash-es';
-import { activateTransformNode as activate, addToHighlightLayer, addToShadowGenerator, assertTransformNode, cloneTransformNode, cloneTransformNodeMaterial, deactivateTransformNode as deactivate, getClientRectFromMesh, injectNodeMetadata, mapToDottedNodes, removeFromHighlightLayer, removeFromShadowGenerator, setMaterial, setMaterialColor, setMaterialMetallness, setMaterialRoughness, setMaterialTexture, setReceiveShadows, transformTransformNode, } from '../util/babylonHelper';
-import { createImageFromImgSrc, createImageFromSvg } from '../util/resourceHelper';
-import { VariantParameterizable } from './../classes/variantParameterizable';
-import { DottedPath } from './dottedPath';
-import { Parameter } from './parameter';
-import { addMissingMaterialObserver } from '../util/sceneLoaderHelper';
-/**
- * An {@link Element} of a {@link Variant}. Acts as a container for diverse definitions. Lives only in the context of a
- * {@link Variant}.
- *
- * When used in typings, refer to via its alias {@link VariantElement} to prevent name clashes with the web APIs
- * [Element](https://developer.mozilla.org/en-US/docs/Web/API/Element) class
- */
-var Element = /** @class */ (function (_super) {
-    __extends(Element, _super);
-    /**
-     * Constructor.
-     */
-    function Element(variant, name) {
-        var _a;
-        var _this = _super.call(this, variant, name) || this;
-        _this.variant = variant;
-        _this.name = name;
-        _this.nodes = [];
-        _this._dottedNodes = new Map();
-        if ((_a = process.env.NODE_ENV) === null || _a === void 0 ? void 0 : _a.toLowerCase().includes('dev')) {
-            _this.assertPathDefinitions();
-        }
-        var nodes = _this.variant.inheritedNodes.map(function (node) { return cloneTransformNode(node, _this.filterNode.bind(_this)); });
-        _this.nodes = nodes.filter(function (node) { return !!node; });
-        _this._dottedNodes = mapToDottedNodes(_this.nodes, function (node) { return node instanceof TransformNode; });
-        _this.addMissingMaterialObservers();
-        _this.addParameterObservers();
-        return _this;
-    }
-    /**
-     * Creates an {@link Element} with given name.
-     */
-    Element.create = function (variant, name) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, new Element(variant, name)];
-            });
-        });
-    };
-    Object.defineProperty(Element.prototype, "dottedPath", {
-        /**
-         * The {@link DottedPath} in the built tree of {@link Element}s.
-         * E.g. "_.top-1.sub-2.sub-sub-3.el-1"
-         */
-        get: function () {
-            return DottedPath.create(this.variant.dottedPath).addPart(this.name);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Element.prototype, "id", {
-        /**
-         * The id representing a {@link DottedPath}.
-         */
-        get: function () {
-            var dottedPath = DottedPath.create(this.dottedPath);
-            dottedPath.shiftPart(); // remove root
-            return dottedPath.path;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Element.prototype, "definition", {
-        /**
-         * The {@link ElementDefinition} of the {@link Element}.
-         */
-        get: function () {
-            var definition = this.variant.structureJson.elements[this.name];
-            if (isArray(definition)) {
-                return {
-                    paths: {
-                        include: definition,
-                    },
-                };
-            }
-            return definition;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Element.prototype, "pathDefinitions", {
-        /**
-         * The {@link PathDefinitions} of the {@link Element}.
-         */
-        get: function () {
-            return this.definition.paths;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Element.prototype, "traceableDefinitions", {
-        /**
-         * The {@link TraceableDefinitions} of the {@link Element}.
-         */
-        get: function () {
-            return this.definition.traceables || {};
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Element.prototype, "paintableDefinitions", {
-        /**
-         * The {@link PaintableDefinition} of the {@link Element}.
-         */
-        get: function () {
-            return this.definition.paintables || {};
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Element.prototype, "inheritedParameters", {
-        /**
-         * The inherited {@link ParameterBag}.
-         * Merges the {@link Variant}'s parameters and those from the {@link Element}.
-         */
-        get: function () {
-            return merge({}, this.variant.inheritedParameters, this.parameters);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Element.prototype, "meshesFlat", {
-        /**
-         * The actual {@link Mesh}es that make up this {@link Element}.
-         * Handy for e.g. creating a bounding box around an entire element.
-         */
-        get: function () {
-            var flatMeshes = this.nodes.reduce(function (accFlatMeshes, curNode) {
-                var currMeshes = curNode.getChildMeshes(false, function (n) { return n instanceof Mesh; });
-                return __spreadArrays(accFlatMeshes, currMeshes);
-            }, []);
-            return flatMeshes;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Element.prototype, "abstractMeshesFlat", {
-        /**
-         * The actual {@link AbstractMesh}es that make up this {@link Element}.
-         * I.e. (real) Meshes as well as InstancedMeshes.
-         */
-        get: function () {
-            var allAbstractMeshes = this.nodes.reduce(function (acc, currNode) {
-                var currAbstractMeshes = currNode.getChildMeshes(false, function (n) { return n instanceof AbstractMesh; });
-                if (currNode instanceof AbstractMesh) {
-                    currAbstractMeshes.unshift(currNode);
-                }
-                return __spreadArrays(acc, currAbstractMeshes);
-            }, []); // initial accumulator value
-            return allAbstractMeshes;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Element.prototype, "meshes", {
-        /**
-         * The meshes of this {@link Element}.
-         */
-        get: function () {
-            return this.nodes.filter(function (node) { return node instanceof Mesh; });
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Element.prototype, "highlightLayer", {
-        get: function () {
-            return this._highlightLayer;
-        },
-        /**
-         * @protected
-         */
-        set: function (layer) {
-            this._highlightLayer = layer;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    /**
-     * Destroys this {@link Element} and dispose all nodes.
-     */
-    Element.prototype.destroy = function () {
-        this.nodes.forEach(function (node) {
-            node.dispose();
-        });
-        return this;
-    };
-    /**
-     * Gets a node by its {@link DottedPath}.
-     */
-    Element.prototype.getNode = function (dottedPath) {
-        var _dottedPath = DottedPath.create(dottedPath);
-        var keys = Array.from(this._dottedNodes.keys()).map(function (dp) { return dp.path; });
-        var values = Array.from(this._dottedNodes.values());
-        var node = values[keys.indexOf(_dottedPath.path)];
-        if (!node) {
-            throw new Error("Node with path \"" + _dottedPath.path + "\" does not exist for element \"" + this.id + "\".");
-        }
-        return node;
-    };
-    /**
-     * Gets a mesh by its {@link DottedPath}.
-     */
-    Element.prototype.getMesh = function (dottedPath) {
-        return __awaiter(this, void 0, void 0, function () {
-            var node;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getNode(dottedPath)];
-                    case 1:
-                        node = _a.sent();
-                        if (node instanceof Mesh) {
-                            return [2 /*return*/, node];
-                        }
-                        return [2 /*return*/, null];
-                }
-            });
-        });
-    };
-    /**
-     * Gets a {@link PaintableDefinition} by its name.
-     */
-    Element.prototype.getPaintableDefinition = function (name) {
-        if (!this.paintableDefinitions || !this.paintableDefinitions[name]) {
-            throw new Error("No paintable \"" + name + "\" defined for element \"" + this.id + "\".");
-        }
-        return this.paintableDefinitions[name];
-    };
-    /**
-     * Gets a {@link TraceableDefinition} by its name.
-     */
-    Element.prototype.getTraceableDefinition = function (name) {
-        if (!this.traceableDefinitions || !this.traceableDefinitions[name]) {
-            throw new Error("No traceable \"" + name + "\" defined to add observer in element \"" + this.id + "\".");
-        }
-        return this.traceableDefinitions[name];
-    };
-    /**
-     * Gets the paintable Node by its name.
-     */
-    Element.prototype.getPaintableNode = function (name) {
-        return this.getNode(this.getPaintableDefinition(name).path);
-    };
-    /**
-     * Gets the traceable Node by its name.
-     */
-    Element.prototype.getTraceableNode = function (name) {
-        return this.getNode(this.getTraceableDefinition(name).path);
-    };
-    /**
-     * @see {@link VariantParameterizable.commitParameters}
-     * @emit {@link Event.ELEMENT_PARAMETER_COMMITTED}
-     */
-    Element.prototype.commitParameters = function (parameters) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, _super.prototype.commitParameters.call(this, parameters)];
-            });
-        });
-    };
-    /**
-     * Adds an observer function for camera matrix changes.
-     * The `observer` gets 2 parameters: the `AbstractMesh` and a `ClientRect` object.
-     */
-    Element.prototype.addTraceableObserver = function (traceable, observer, payload) {
-        var _this = this;
-        if (payload && !(payload instanceof HTMLElement)) {
-            throw new Error("Payload for camera observer must be an instance of \"HTMLElement\" in element \"" + this.id + "\".");
-        }
-        if (!this.traceableDefinitions || !this.traceableDefinitions[traceable]) {
-            throw new Error("No traceable \"" + traceable + "\" defined to add observer in element \"" + this.id + "\".");
-        }
-        var node = this.getTraceableNode(traceable);
-        if (!(node instanceof AbstractMesh)) {
-            throw new Error("The path must be an instance of \"AbstractMesh\" for camera observer in element \"" + this.id + "\".");
-        }
-        this.variant.viewer.sceneManager.activeCamera.onViewMatrixChangedObservable.add(function (eventData, eventState) {
-            var position = getClientRectFromMesh(node, _this.variant.viewer.scene, _this.variant.viewer.canvas);
-            if (payload) {
-                payload.style.top = position.top + "px";
-                payload.style.left = position.left + "px";
-            }
-            observer(node, position);
-        });
-        return this;
-    };
-    /**
-     * Draws a `ImageBitmap` or `OffscreenCanvas` onto a `paintable` defined via {@link PaintableDefinition}.
-     */
-    Element.prototype.drawPaintable = function (paintable, imageSource) {
-        // node and material checks and preperation
-        var node = this.getPaintableNode(paintable);
-        if (!(node instanceof AbstractMesh)) {
-            throw new Error("The path must be an instance of \"AbstractMesh\" for paintable \"" + paintable + "\" " + ("in element \"" + this.id + "\"."));
-        }
-        if (node.material && this.variant.viewer.cloneMaterialsOnMutation) {
-            if (node.material && !has(node.metadata, 'dirty.material')) {
-                cloneTransformNodeMaterial(node);
-            }
-            if (!has(node.metadata, 'dirty.material.texture')) {
-                // inject initial value and mark as dirty
-                injectNodeMetadata(node, { dirty: { material: { texture: true } } });
-            }
-        }
-        else if (!node.material) {
-            // paintables should also work if no material is assigned to the node per default
-            // in this case a certain fallback material with fitting default values is defined
-            var pbrMat = new PBRMaterial(this.id + "." + paintable + ".material", this.variant.viewer.scene);
-            pbrMat.roughness = 1.0;
-            pbrMat.metallic = 1.0;
-            node.material = pbrMat;
-        }
-        // TODO: Not sure if this really should be overwritten every time the paintable is redrawn.
-        // Maybe the 3D artist had something in mind when setting a certain transparency mode, which would get overwritten in this case.
-        // Applying it as a default if no material is set is fine though (see roughness/metallic some lines above).
-        // Removing this line will most likely break existing configurators, so be cautios!
-        node.material.transparencyMode = Material.MATERIAL_ALPHATESTANDBLEND;
-        // consider width and height of the paintable
-        var widthAndHeight = {
-            width: imageSource.width,
-            height: imageSource.height,
-        };
-        var paintableDefinition = this.getPaintableDefinition(paintable);
-        if (isNumber(paintableDefinition.textureOptions)) {
-            widthAndHeight.width = paintableDefinition.textureOptions;
-            widthAndHeight.height = paintableDefinition.textureOptions;
-        }
-        else if (isPlainObject(paintableDefinition.textureOptions)) {
-            widthAndHeight.width = paintableDefinition.textureOptions.width;
-            widthAndHeight.height = paintableDefinition.textureOptions.height;
-        }
-        // create dynamic texture on which the image can be drawn
-        var texture = new DynamicTexture(this.id + "." + paintable + ".texture", widthAndHeight, this.variant.viewer.scene, false);
-        // draw image on texture
-        var ctx = texture.getContext();
-        ctx.drawImage(imageSource, 0, 0);
-        texture.update(false);
-        // finally apply the texture on the desired node material
-        setMaterialTexture(node, texture, false);
-        return this;
-    };
-    /**
-     * Draws a SVG string onto a `paintable` defined via {@link PaintableDefinition}.
-     */
-    Element.prototype.drawPaintableFromSvg = function (paintable, svgSource) {
-        return __awaiter(this, void 0, void 0, function () {
-            var image;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, createImageFromSvg(svgSource)];
-                    case 1:
-                        image = _a.sent();
-                        return [2 /*return*/, this.drawPaintable(paintable, image)];
-                }
-            });
-        });
-    };
-    /**
-     * Draws an Image from source (URL/URI) onto a `paintable` defined via {@link PaintableDefinition}.
-     */
-    Element.prototype.drawPaintableFromImgSrc = function (paintable, imgSource) {
-        return __awaiter(this, void 0, void 0, function () {
-            var image;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, createImageFromImgSrc(imgSource)];
-                    case 1:
-                        image = _a.sent();
-                        return [2 /*return*/, this.drawPaintable(paintable, image)];
-                }
-            });
-        });
-    };
-    /**
-     * Adds observers for loading missing materials where needed
-     */
-    Element.prototype.addMissingMaterialObservers = function () {
-        for (var _i = 0, _a = this.abstractMeshesFlat; _i < _a.length; _i++) {
-            var abstractMesh = _a[_i];
-            addMissingMaterialObserver(abstractMesh);
-        }
-    };
-    /**
-     * Adds the default {@link ParameterObserver}s which are called every time {@link commitParameters} is called.
-     */
-    Element.prototype.addParameterObservers = function () {
-        var _this = this;
-        this._parameterObservers.set(Parameter.VISIBLE, [
-            function (element, oldValue, newValue) { return __awaiter(_this, void 0, void 0, function () {
-                var visible;
-                return __generator(this, function (_a) {
-                    try {
-                        visible = Parameter.parseBoolean(newValue);
-                    }
-                    catch (e) {
-                        return [2 /*return*/];
-                    }
-                    if (visible === true) {
-                        element.nodes.forEach(function (node) {
-                            injectNodeMetadata(node, { visibility: node.isEnabled() });
-                            activate(node);
-                        });
-                    }
-                    else if (visible === false) {
-                        element.nodes.forEach(function (node) {
-                            injectNodeMetadata(node, { visibility: node.isEnabled() });
-                            deactivate(node);
-                        });
-                    }
-                    return [2 /*return*/];
-                });
-            }); },
-        ]);
-        this._parameterObservers.set(Parameter.SCALING, [
-            function (element, oldValue, newValue) { return __awaiter(_this, void 0, void 0, function () {
-                return __generator(this, function (_a) {
-                    // we have to deal just with root nodes here due to relative impacts in a node tree
-                    element.nodes.forEach(function (node) {
-                        return transformTransformNode(node, {
-                            scaling: Parameter.parseVector(newValue),
-                            position: Parameter.parseVector(element.inheritedParameters[Parameter.POSITION] || '(0, 0, 0)'),
-                            rotation: Parameter.parseRotation(element.inheritedParameters[Parameter.ROTATION] || '(0, 0, 0)'),
-                        });
-                    });
-                    return [2 /*return*/];
-                });
-            }); },
-        ]);
-        this._parameterObservers.set(Parameter.POSITION, [
-            function (element, oldValue, newValue) { return __awaiter(_this, void 0, void 0, function () {
-                return __generator(this, function (_a) {
-                    // we have to deal just with root nodes here due to relative impacts in a node tree
-                    element.nodes.forEach(function (node) {
-                        return transformTransformNode(node, {
-                            scaling: Parameter.parseVector(element.inheritedParameters[Parameter.SCALING] || '(1, 1, 1)'),
-                            position: Parameter.parseVector(newValue),
-                            rotation: Parameter.parseRotation(element.inheritedParameters[Parameter.ROTATION] || '(0, 0, 0)'),
-                        });
-                    });
-                    return [2 /*return*/];
-                });
-            }); },
-        ]);
-        this._parameterObservers.set(Parameter.ROTATION, [
-            function (element, oldValue, newValue) { return __awaiter(_this, void 0, void 0, function () {
-                return __generator(this, function (_a) {
-                    // we have to deal just with root nodes here due to relative impacts in a node tree
-                    element.nodes.forEach(function (node) {
-                        return transformTransformNode(node, {
-                            scaling: Parameter.parseVector(element.inheritedParameters[Parameter.SCALING] || '(1, 1, 1)'),
-                            position: Parameter.parseVector(element.inheritedParameters[Parameter.POSITION] || '(0, 0, 0)'),
-                            rotation: Parameter.parseRotation(newValue),
-                        });
-                    });
-                    return [2 /*return*/];
-                });
-            }); },
-        ]);
-        this._parameterObservers.set(Parameter.MATERIAL, [
-            function (element, oldValue, newValue) { return __awaiter(_this, void 0, void 0, function () {
-                var materialName;
-                return __generator(this, function (_a) {
-                    materialName = newValue.toString();
-                    element.nodes.forEach(function (node) {
-                        assertTransformNode(node, function (node) {
-                            if (node instanceof InstancedMesh) {
-                                throw new Error("Changing parameter \"" + Parameter.MATERIAL + "\" " +
-                                    "of an InstancedMesh is not supported. " +
-                                    ("Tried to change node \"" + node.id + "\" on element \"" + element.id + "\"."));
-                            }
-                        });
-                        setMaterial(element.variant, node, materialName);
-                    });
-                    return [2 /*return*/];
-                });
-            }); },
-        ]);
-        this._parameterObservers.set(Parameter.MATERIAL_COLOR, [
-            function (element, oldValue, newValue) { return __awaiter(_this, void 0, void 0, function () {
-                var color;
-                var _this = this;
-                return __generator(this, function (_a) {
-                    color = Parameter.parseColor(newValue);
-                    element.nodes.forEach(function (node) {
-                        assertTransformNode(node, function (node) {
-                            if (node instanceof InstancedMesh) {
-                                throw new Error("Changing parameter \"" + Parameter.MATERIAL_COLOR + "\" " +
-                                    "of an InstancedMesh is not supported. " +
-                                    ("Tried to change node \"" + node.id + "\" on element \"" + element.id + "\"."));
-                            }
-                        });
-                        if (_this.variant.viewer.cloneMaterialsOnMutation) {
-                            if (!has(node.metadata, 'dirty.material')) {
-                                cloneTransformNodeMaterial(node);
-                            }
-                            if (!has(node.metadata, 'dirty.material.color')) {
-                                // inject initial value and mark as dirty
-                                injectNodeMetadata(node, { dirty: { material: { color: oldValue } } });
-                            }
-                        }
-                        setMaterialColor(node, color);
-                    });
-                    return [2 /*return*/];
-                });
-            }); },
-        ]);
-        this._parameterObservers.set(Parameter.MATERIAL_METALLNESS, [
-            function (element, oldValue, newValue) { return __awaiter(_this, void 0, void 0, function () {
-                var metallness;
-                var _this = this;
-                return __generator(this, function (_a) {
-                    metallness = Parameter.parseNumber(newValue);
-                    element.nodes.forEach(function (node) {
-                        assertTransformNode(node, function (node) {
-                            if (node instanceof InstancedMesh) {
-                                throw new Error("Changing parameter \"" + Parameter.MATERIAL_METALLNESS + "\" " +
-                                    "of an InstancedMesh is not supported. " +
-                                    ("Tried to change node \"" + node.id + "\" on element \"" + element.id + "\"."));
-                            }
-                        });
-                        if (_this.variant.viewer.cloneMaterialsOnMutation) {
-                            if (!has(node.metadata, 'dirty.material')) {
-                                cloneTransformNodeMaterial(node);
-                            }
-                            if (!has(node.metadata, 'dirty.material.metallness')) {
-                                // inject initial value and mark as dirty
-                                injectNodeMetadata(node, { dirty: { material: { metallness: oldValue } } });
-                            }
-                        }
-                        setMaterialMetallness(node, metallness);
-                    });
-                    return [2 /*return*/];
-                });
-            }); },
-        ]);
-        this._parameterObservers.set(Parameter.MATERIAL_ROUGHNESS, [
-            function (element, oldValue, newValue) { return __awaiter(_this, void 0, void 0, function () {
-                var roughness;
-                var _this = this;
-                return __generator(this, function (_a) {
-                    roughness = Parameter.parseNumber(newValue);
-                    element.nodes.forEach(function (node) {
-                        assertTransformNode(node, function (node) {
-                            if (node instanceof InstancedMesh) {
-                                throw new Error("Changing parameter \"" + Parameter.MATERIAL_ROUGHNESS + "\" " +
-                                    "of an InstancedMesh is not supported. " +
-                                    ("Tried to change node \"" + node.id + "\" on element \"" + element.id + "\"."));
-                            }
-                        });
-                        if (_this.variant.viewer.cloneMaterialsOnMutation) {
-                            if (!has(node.metadata, 'dirty.material')) {
-                                cloneTransformNodeMaterial(node);
-                            }
-                            if (!has(node.metadata, 'dirty.material.roughness')) {
-                                // inject initial value and mark as dirty
-                                injectNodeMetadata(node, { dirty: { material: { roughness: oldValue } } });
-                            }
-                        }
-                        setMaterialRoughness(node, roughness);
-                    });
-                    return [2 /*return*/];
-                });
-            }); },
-        ]);
-        this._parameterObservers.set(Parameter.HIGHLIGHT_COLOR, [
-            function (element, oldValue, newValue) { return __awaiter(_this, void 0, void 0, function () {
-                var _a;
-                return __generator(this, function (_b) {
-                    // trigger Parameter.HIGHLIGHTED observers
-                    (_a = this._parameterObservers.get(Parameter.HIGHLIGHTED)) === null || _a === void 0 ? void 0 : _a.forEach(function (observer) {
-                        observer(element, !!element.highlighted, !!element.highlighted);
-                    });
-                    return [2 /*return*/];
-                });
-            }); },
-        ]);
-        this._parameterObservers.set(Parameter.HIGHLIGHT_ENABLED, [
-            function (element, oldValue, newValue) { return __awaiter(_this, void 0, void 0, function () {
-                var curr;
-                var _a;
-                return __generator(this, function (_b) {
-                    try {
-                        curr = Parameter.parseBoolean(newValue);
-                    }
-                    catch (e) {
-                        return [2 /*return*/];
-                    }
-                    switch (curr) {
-                        case true:
-                            if (element._highlightLayer) {
-                                break;
-                            }
-                            element.highlightLayer = new HighlightLayer(DottedPath.create(element.id).addPart('highlight').path, element.variant.viewer.scene);
-                            break;
-                        case false:
-                            (_a = element.highlightLayer) === null || _a === void 0 ? void 0 : _a.dispose();
-                            break;
-                    }
-                    return [2 /*return*/];
-                });
-            }); },
-        ]);
-        this._parameterObservers.set(Parameter.HIGHLIGHTED, [
-            function (element, oldValue, newValue) { return __awaiter(_this, void 0, void 0, function () {
-                var highlighted;
-                var _this = this;
-                var _a;
-                return __generator(this, function (_b) {
-                    if (!element.inheritedParameters[Parameter.HIGHLIGHT_ENABLED]) {
-                        return [2 /*return*/];
-                    }
-                    // trigger Parameter.HIGHLIGHT_ENABLED observers to ensure HighlightLayer
-                    (_a = this._parameterObservers.get(Parameter.HIGHLIGHT_ENABLED)) === null || _a === void 0 ? void 0 : _a.forEach(function (observer) {
-                        observer(element, _this.parameters[Parameter.HIGHLIGHT_ENABLED], true);
-                    });
-                    try {
-                        highlighted = Parameter.parseBoolean(newValue);
-                    }
-                    catch (e) {
-                        return [2 /*return*/];
-                    }
-                    // Add/Remove meshes to previously created highlight layers.
-                    if (highlighted === true) {
-                        element.nodes.forEach(function (node) {
-                            assertTransformNode(node, function (node) {
-                                if (node instanceof InstancedMesh) {
-                                    throw new Error("Changing parameter \"" + Parameter.HIGHLIGHTED + "\" " +
-                                        "of an InstancedMesh is not supported. " +
-                                        ("Tried to change node \"" + node.id + "\" on element \"" + element.id + "\"."));
-                                }
-                            });
-                            var color = Color3.Green();
-                            if (element.inheritedParameters[Parameter.HIGHLIGHT_COLOR]) {
-                                color = Parameter.parseColor(element.inheritedParameters[Parameter.HIGHLIGHT_COLOR]);
-                            }
-                            if (typeof element._highlightLayer !== 'undefined') {
-                                addToHighlightLayer(element._highlightLayer, color, node);
-                            }
-                        });
-                    }
-                    else if (highlighted === false) {
-                        element.nodes.forEach(function (node) {
-                            if (typeof element._highlightLayer !== 'undefined') {
-                                removeFromHighlightLayer(element._highlightLayer, node);
-                            }
-                        });
-                    }
-                    return [2 /*return*/];
-                });
-            }); },
-        ]);
-        this._parameterObservers.set(Parameter.CAST_SHADOW, [
-            function (element, oldValue, newValue) { return __awaiter(_this, void 0, void 0, function () {
-                var castShadow, lightCsl;
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0:
-                            try {
-                                castShadow = Parameter.parseBoolean(newValue);
-                            }
-                            catch (e) {
-                                return [2 /*return*/];
-                            }
-                            lightCsl = element.inheritedParameters[Parameter.CAST_SHADOW_FROM_LIGHTS];
-                            if (!lightCsl) {
-                                lightCsl = element.variant.inheritedViewerLights.map(function (l) { return l.name; }).join(',');
-                            }
-                            if (!(castShadow === true)) return [3 /*break*/, 2];
-                            return [4 /*yield*/, this.castShadowValueHandler(lightCsl, addToShadowGenerator)];
-                        case 1:
-                            _a.sent();
-                            _a.label = 2;
-                        case 2:
-                            if (!(castShadow === false)) return [3 /*break*/, 4];
-                            return [4 /*yield*/, this.castShadowValueHandler(lightCsl, removeFromShadowGenerator)];
-                        case 3:
-                            _a.sent();
-                            _a.label = 4;
-                        case 4: return [2 /*return*/];
-                    }
-                });
-            }); },
-        ]);
-        this._parameterObservers.set(Parameter.CAST_SHADOW_FROM_LIGHTS, [
-            function (element, oldValue, newValue) { return __awaiter(_this, void 0, void 0, function () {
-                var lightCsl;
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0:
-                            lightCsl = element.variant.inheritedViewerLights.map(function (l) { return l.name; }).join(',');
-                            // cleanup all shadow generators
-                            return [4 /*yield*/, this.castShadowValueHandler(lightCsl, removeFromShadowGenerator)];
-                        case 1:
-                            // cleanup all shadow generators
-                            _a.sent();
-                            if (!(element.castShadow === true)) return [3 /*break*/, 3];
-                            // if newValue is undefined or '' then set newValue to lightCsl (use all lights)
-                            if (!newValue) {
-                                newValue = lightCsl;
-                            }
-                            return [4 /*yield*/, this.castShadowValueHandler(newValue, addToShadowGenerator)];
-                        case 2:
-                            _a.sent();
-                            _a.label = 3;
-                        case 3: return [2 /*return*/];
-                    }
-                });
-            }); },
-        ]);
-        this._parameterObservers.set(Parameter.RECEIVE_SHADOWS, [
-            function (element, oldValue, newValue) { return __awaiter(_this, void 0, void 0, function () {
-                return __generator(this, function (_a) {
-                    element.nodes.forEach(function (node) { return setReceiveShadows(node, Parameter.parseBoolean(newValue)); });
-                    return [2 /*return*/];
-                });
-            }); },
-        ]);
-        return this;
-    };
-    /**
-     * Filter for nodes that are not defined or excluded in the `pathDefinitions`.
-     */
-    Element.prototype.filterNode = function (node) {
-        var _this = this;
-        var includeTokens = [];
-        this.pathDefinitions.include.forEach(function (dottedPath) {
-            includeTokens = union(includeTokens, DottedPath.create(dottedPath).leafTokens);
-        });
-        var shallKeep = function (dp) {
-            var isDirectlyIncluded = !!includeTokens.find(function (_dp) { return _dp === dp.path; });
-            var isSubOfIncluded = !!_this.pathDefinitions.include.find(function (_dp) {
-                return dp.path.startsWith("" + _dp + DottedPath.DELIMITER);
-            });
-            return isDirectlyIncluded || isSubOfIncluded;
-        };
-        var shallExclude = function (dp) {
-            if (!_this.pathDefinitions.exclude) {
-                return false;
-            }
-            return !!_this.pathDefinitions.exclude.find(function (_dp) { return dp.path === _dp; });
-        };
-        return shallKeep(node.metadata.dottedPath) && !shallExclude(node.metadata.dottedPath);
-    };
-    /**
-     * Asserts whether all {@link pathDefinitions} link to a valid `Node` path.
-     * @protected
-     */
-    Element.prototype.assertPathDefinitions = function () {
-        var _this = this;
-        var _a;
-        var dottedNodes = this.variant.inheritedDottedNodes;
-        if (dottedNodes.size === 0) {
-            throw new Error("There are no mapped nodes for element \"" + this.id + "\".");
-        }
-        var include = this.pathDefinitions.include.map(function (path) { return DottedPath.create(path).path; });
-        var exclude = (_a = this.pathDefinitions.exclude) === null || _a === void 0 ? void 0 : _a.map(function (path) { return DottedPath.create(path).path; });
-        var keys = Array.from(dottedNodes.keys()).map(function (dottedPath) { return dottedPath.path; });
-        union(include, exclude).forEach(function (path) {
-            if (keys.indexOf(path) === -1) {
-                throw new Error("Node with path \"" + path + "\" does not exist for element \"" + _this.id + "\".");
-            }
-        });
-    };
-    /**
-     * Handles callback for given light parameter.
-     */
-    Element.prototype.castShadowValueHandler = function (lightCsl, mutator) {
-        return __awaiter(this, void 0, void 0, function () {
-            var lights, _i, _a, lightName, viewerLight, shadowGenerators;
-            var _this = this;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        lights = [];
-                        _i = 0, _a = Parameter.parseCommaSeparatedList(lightCsl);
-                        _b.label = 1;
-                    case 1:
-                        if (!(_i < _a.length)) return [3 /*break*/, 4];
-                        lightName = _a[_i];
-                        return [4 /*yield*/, this.variant.getViewerLight(lightName)];
-                    case 2:
-                        viewerLight = _b.sent();
-                        if (viewerLight) {
-                            lights.push(viewerLight.light);
-                        }
-                        _b.label = 3;
-                    case 3:
-                        _i++;
-                        return [3 /*break*/, 1];
-                    case 4:
-                        shadowGenerators = lights.map(function (light) { return light === null || light === void 0 ? void 0 : light.getShadowGenerator(); }).filter(Boolean);
-                        shadowGenerators.forEach(function (generator) {
-                            _this.nodes.forEach(function (node) {
-                                mutator(generator, node);
-                            });
-                        });
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
-    return Element;
-}(VariantParameterizable));
-export { Element };
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { activateTransformNode as activate, addToHighlightLayer, addToShadowGenerator, assertTransformNode, cloneTransformNode, cloneTransformNodeMaterial, deactivateTransformNode as deactivate, getClientRectFromMesh, injectNodeMetadata, mapToDottedNodes, removeFromHighlightLayer, removeFromShadowGenerator, setMaterial, setMaterialColor, setMaterialMetallness, setMaterialRoughness, setMaterialTexture, setReceiveShadows, transformTransformNode, } from '../util/babylonHelper';
+import { createImageFromImgSrc, createImageFromSvg } from '../util/resourceHelper';
+import { addMissingMaterialObserver } from '../util/sceneLoaderHelper';
+import { VariantParameterizable } from './../classes/variantParameterizable';
+import { DottedPath } from './dottedPath';
+import { Parameter } from './parameter';
+import { HighlightLayer } from '@babylonjs/core/Layers/highlightLayer';
+import { PBRMaterial } from '@babylonjs/core/Materials/PBR/pbrMaterial';
+import { DynamicTexture } from '@babylonjs/core/Materials/Textures/dynamicTexture';
+import { Material } from '@babylonjs/core/Materials/material';
+import { Color3 } from '@babylonjs/core/Maths/math.color';
+import { AbstractMesh } from '@babylonjs/core/Meshes/abstractMesh';
+import { InstancedMesh } from '@babylonjs/core/Meshes/instancedMesh';
+import { Mesh } from '@babylonjs/core/Meshes/mesh';
+import { TransformNode } from '@babylonjs/core/Meshes/transformNode';
+import { has, isArray, isNumber, isPlainObject, merge, union } from 'lodash-es';
+/**
+ * An {@link Element} of a {@link Variant}. Acts as a container for diverse definitions. Lives only in the context of a
+ * {@link Variant}.
+ *
+ * When used in typings, refer to via its alias {@link VariantElement} to prevent name clashes with the web APIs
+ * [Element](https://developer.mozilla.org/en-US/docs/Web/API/Element) class
+ */
+export class Element extends VariantParameterizable {
+    /**
+     * Constructor.
+     */
+    constructor(variant, name) {
+        var _a;
+        super(variant, name);
+        this.variant = variant;
+        this.name = name;
+        this.nodes = [];
+        this._dottedNodes = new Map();
+        if ((_a = process.env.NODE_ENV) === null || _a === void 0 ? void 0 : _a.toLowerCase().includes('dev')) {
+            this.assertPathDefinitions();
+        }
+        const nodes = this.variant.inheritedNodes.map(node => cloneTransformNode(node, this.filterNode.bind(this)));
+        this.nodes = nodes.filter(node => !!node);
+        this._dottedNodes = mapToDottedNodes(this.nodes, node => node instanceof TransformNode);
+        this.addMissingMaterialObservers();
+        this.addParameterObservers();
+    }
+    /**
+     * Creates an {@link Element} with given name.
+     */
+    static create(variant, name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Element(variant, name);
+        });
+    }
+    /**
+     * The {@link DottedPath} in the built tree of {@link Element}s.
+     * E.g. "_.top-1.sub-2.sub-sub-3.el-1"
+     */
+    get dottedPath() {
+        return DottedPath.create(this.variant.dottedPath).addPart(this.name);
+    }
+    /**
+     * The id representing a {@link DottedPath}.
+     */
+    get id() {
+        const dottedPath = DottedPath.create(this.dottedPath);
+        dottedPath.shiftPart(); // remove root
+        return dottedPath.path;
+    }
+    /**
+     * The {@link ElementDefinition} of the {@link Element}.
+     */
+    get definition() {
+        const definition = this.variant.structureJson.elements[this.name];
+        if (isArray(definition)) {
+            return {
+                paths: {
+                    include: definition,
+                },
+            };
+        }
+        return definition;
+    }
+    /**
+     * The {@link PathDefinitions} of the {@link Element}.
+     */
+    get pathDefinitions() {
+        return this.definition.paths;
+    }
+    /**
+     * The {@link TraceableDefinitions} of the {@link Element}.
+     */
+    get traceableDefinitions() {
+        return this.definition.traceables || {};
+    }
+    /**
+     * The {@link PaintableDefinition} of the {@link Element}.
+     */
+    get paintableDefinitions() {
+        return this.definition.paintables || {};
+    }
+    /**
+     * The inherited {@link ParameterBag}.
+     * Merges the {@link Variant}'s parameters and those from the {@link Element}.
+     */
+    get inheritedParameters() {
+        return merge({}, this.variant.inheritedParameters, this.parameters);
+    }
+    /**
+     * The actual {@link Mesh}es that make up this {@link Element}.
+     * Handy for e.g. creating a bounding box around an entire element.
+     */
+    get meshesFlat() {
+        const flatMeshes = this.nodes.reduce((accFlatMeshes, curNode) => {
+            const currMeshes = curNode.getChildMeshes(false, n => n instanceof Mesh);
+            return [...accFlatMeshes, ...currMeshes];
+        }, []);
+        return flatMeshes;
+    }
+    /**
+     * The actual {@link AbstractMesh}es that make up this {@link Element}.
+     * I.e. (real) Meshes as well as InstancedMeshes.
+     */
+    get abstractMeshesFlat() {
+        const allAbstractMeshes = this.nodes.reduce((acc, currNode) => {
+            const currAbstractMeshes = currNode.getChildMeshes(false, n => n instanceof AbstractMesh);
+            if (currNode instanceof AbstractMesh) {
+                currAbstractMeshes.unshift(currNode);
+            }
+            return [...acc, ...currAbstractMeshes];
+        }, []); // initial accumulator value
+        return allAbstractMeshes;
+    }
+    /**
+     * The meshes of this {@link Element}.
+     */
+    get meshes() {
+        return this.nodes.filter(node => node instanceof Mesh);
+    }
+    /**
+     * @protected
+     */
+    set highlightLayer(layer) {
+        this._highlightLayer = layer;
+    }
+    get highlightLayer() {
+        return this._highlightLayer;
+    }
+    /**
+     * Destroys this {@link Element} and dispose all nodes.
+     */
+    destroy() {
+        this.nodes.forEach(node => {
+            node.dispose();
+        });
+        return this;
+    }
+    /**
+     * Gets a node by its {@link DottedPath}.
+     */
+    getNode(dottedPath) {
+        const _dottedPath = DottedPath.create(dottedPath);
+        const keys = Array.from(this._dottedNodes.keys()).map(dp => dp.path);
+        const values = Array.from(this._dottedNodes.values());
+        const node = values[keys.indexOf(_dottedPath.path)];
+        if (!node) {
+            throw new Error(`Node with path "${_dottedPath.path}" does not exist for element "${this.id}".`);
+        }
+        return node;
+    }
+    /**
+     * Gets a mesh by its {@link DottedPath}.
+     */
+    getMesh(dottedPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const node = yield this.getNode(dottedPath);
+            if (node instanceof Mesh) {
+                return node;
+            }
+            return null;
+        });
+    }
+    /**
+     * Gets a {@link PaintableDefinition} by its name.
+     */
+    getPaintableDefinition(name) {
+        if (!this.paintableDefinitions || !this.paintableDefinitions[name]) {
+            throw new Error(`No paintable "${name}" defined for element "${this.id}".`);
+        }
+        return this.paintableDefinitions[name];
+    }
+    /**
+     * Gets a {@link TraceableDefinition} by its name.
+     */
+    getTraceableDefinition(name) {
+        if (!this.traceableDefinitions || !this.traceableDefinitions[name]) {
+            throw new Error(`No traceable "${name}" defined to add observer in element "${this.id}".`);
+        }
+        return this.traceableDefinitions[name];
+    }
+    /**
+     * Gets the paintable Node by its name.
+     */
+    getPaintableNode(name) {
+        return this.getNode(this.getPaintableDefinition(name).path);
+    }
+    /**
+     * Gets the traceable Node by its name.
+     */
+    getTraceableNode(name) {
+        return this.getNode(this.getTraceableDefinition(name).path);
+    }
+    /**
+     * @see {@link VariantParameterizable.commitParameters}
+     * @emit {@link Event.ELEMENT_PARAMETER_COMMITTED}
+     */
+    commitParameters(parameters) {
+        const _super = Object.create(null, {
+            commitParameters: { get: () => super.commitParameters }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super.commitParameters.call(this, parameters);
+        });
+    }
+    /**
+     * Adds an observer function for camera matrix changes.
+     * The `observer` gets 2 parameters: the `AbstractMesh` and a `ClientRect` object.
+     */
+    addTraceableObserver(traceable, observer, payload) {
+        if (payload && !(payload instanceof HTMLElement)) {
+            throw new Error(`Payload for camera observer must be an instance of "HTMLElement" in element "${this.id}".`);
+        }
+        if (!this.traceableDefinitions || !this.traceableDefinitions[traceable]) {
+            throw new Error(`No traceable "${traceable}" defined to add observer in element "${this.id}".`);
+        }
+        const node = this.getTraceableNode(traceable);
+        if (!(node instanceof AbstractMesh)) {
+            throw new Error(`The path must be an instance of "AbstractMesh" for camera observer in element "${this.id}".`);
+        }
+        this.variant.viewer.sceneManager.activeCamera.onViewMatrixChangedObservable.add((eventData, eventState) => {
+            const position = getClientRectFromMesh(node, this.variant.viewer.scene, this.variant.viewer.canvas);
+            if (payload) {
+                payload.style.top = `${position.top}px`;
+                payload.style.left = `${position.left}px`;
+            }
+            observer(node, position);
+        });
+        return this;
+    }
+    /**
+     * Draws a `ImageBitmap` or `OffscreenCanvas` onto a `paintable` defined via {@link PaintableDefinition}.
+     */
+    drawPaintable(paintable, imageSource) {
+        // node and material checks and preperation
+        const node = this.getPaintableNode(paintable);
+        if (!(node instanceof AbstractMesh)) {
+            throw new Error(`The path must be an instance of "AbstractMesh" for paintable "${paintable}" ` + `in element "${this.id}".`);
+        }
+        if (node.material && this.variant.viewer.cloneMaterialsOnMutation) {
+            if (node.material && !has(node.metadata, 'dirty.material')) {
+                cloneTransformNodeMaterial(node);
+            }
+            if (!has(node.metadata, 'dirty.material.texture')) {
+                // inject initial value and mark as dirty
+                injectNodeMetadata(node, { dirty: { material: { texture: true } } });
+            }
+        }
+        else if (!node.material) {
+            // paintables should also work if no material is assigned to the node per default
+            // in this case a certain fallback material with fitting default values is defined
+            const pbrMat = new PBRMaterial(`${this.id}.${paintable}.material`, this.variant.viewer.scene);
+            pbrMat.roughness = 1.0;
+            pbrMat.metallic = 1.0;
+            node.material = pbrMat;
+        }
+        // TODO: Not sure if this really should be overwritten every time the paintable is redrawn.
+        // Maybe the 3D artist had something in mind when setting a certain transparency mode, which would get overwritten in this case.
+        // Applying it as a default if no material is set is fine though (see roughness/metallic some lines above).
+        // Removing this line will most likely break existing configurators, so be cautios!
+        node.material.transparencyMode = Material.MATERIAL_ALPHATESTANDBLEND;
+        // consider width and height of the paintable
+        const widthAndHeight = {
+            width: imageSource.width,
+            height: imageSource.height,
+        };
+        const paintableDefinition = this.getPaintableDefinition(paintable);
+        if (isNumber(paintableDefinition.textureOptions)) {
+            widthAndHeight.width = paintableDefinition.textureOptions;
+            widthAndHeight.height = paintableDefinition.textureOptions;
+        }
+        else if (isPlainObject(paintableDefinition.textureOptions)) {
+            widthAndHeight.width = paintableDefinition.textureOptions.width;
+            widthAndHeight.height = paintableDefinition.textureOptions.height;
+        }
+        // create dynamic texture on which the image can be drawn
+        const texture = new DynamicTexture(`${this.id}.${paintable}.texture`, widthAndHeight, this.variant.viewer.scene, false);
+        // draw image on texture
+        const ctx = texture.getContext();
+        ctx.drawImage(imageSource, 0, 0);
+        texture.update(false);
+        // finally apply the texture on the desired node material
+        setMaterialTexture(node, texture, false);
+        return this;
+    }
+    /**
+     * Draws a SVG string onto a `paintable` defined via {@link PaintableDefinition}.
+     */
+    drawPaintableFromSvg(paintable, svgSource) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const image = yield createImageFromSvg(svgSource);
+            return this.drawPaintable(paintable, image);
+        });
+    }
+    /**
+     * Draws an Image from source (URL/URI) onto a `paintable` defined via {@link PaintableDefinition}.
+     */
+    drawPaintableFromImgSrc(paintable, imgSource) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const image = yield createImageFromImgSrc(imgSource);
+            return this.drawPaintable(paintable, image);
+        });
+    }
+    /**
+     * Adds observers for loading missing materials where needed
+     */
+    addMissingMaterialObservers() {
+        for (const abstractMesh of this.abstractMeshesFlat) {
+            addMissingMaterialObserver(abstractMesh);
+        }
+    }
+    /**
+     * Adds the default {@link ParameterObserver}s which are called every time {@link commitParameters} is called.
+     */
+    addParameterObservers() {
+        this._parameterObservers.set(Parameter.VISIBLE, [
+            (element, oldValue, newValue) => __awaiter(this, void 0, void 0, function* () {
+                let visible;
+                try {
+                    visible = Parameter.parseBoolean(newValue);
+                }
+                catch (e) {
+                    return;
+                }
+                if (visible === true) {
+                    element.nodes.forEach(node => {
+                        injectNodeMetadata(node, { visibility: node.isEnabled() });
+                        activate(node);
+                    });
+                }
+                else if (visible === false) {
+                    element.nodes.forEach(node => {
+                        injectNodeMetadata(node, { visibility: node.isEnabled() });
+                        deactivate(node);
+                    });
+                }
+            }),
+        ]);
+        this._parameterObservers.set(Parameter.SCALING, [
+            (element, oldValue, newValue) => __awaiter(this, void 0, void 0, function* () {
+                // we have to deal just with root nodes here due to relative impacts in a node tree
+                element.nodes.forEach(node => transformTransformNode(node, {
+                    scaling: Parameter.parseVector(newValue),
+                    position: Parameter.parseVector(element.inheritedParameters[Parameter.POSITION] || '(0, 0, 0)'),
+                    rotation: Parameter.parseRotation(element.inheritedParameters[Parameter.ROTATION] || '(0, 0, 0)'),
+                }));
+            }),
+        ]);
+        this._parameterObservers.set(Parameter.POSITION, [
+            (element, oldValue, newValue) => __awaiter(this, void 0, void 0, function* () {
+                // we have to deal just with root nodes here due to relative impacts in a node tree
+                element.nodes.forEach(node => transformTransformNode(node, {
+                    scaling: Parameter.parseVector(element.inheritedParameters[Parameter.SCALING] || '(1, 1, 1)'),
+                    position: Parameter.parseVector(newValue),
+                    rotation: Parameter.parseRotation(element.inheritedParameters[Parameter.ROTATION] || '(0, 0, 0)'),
+                }));
+            }),
+        ]);
+        this._parameterObservers.set(Parameter.ROTATION, [
+            (element, oldValue, newValue) => __awaiter(this, void 0, void 0, function* () {
+                // we have to deal just with root nodes here due to relative impacts in a node tree
+                element.nodes.forEach(node => transformTransformNode(node, {
+                    scaling: Parameter.parseVector(element.inheritedParameters[Parameter.SCALING] || '(1, 1, 1)'),
+                    position: Parameter.parseVector(element.inheritedParameters[Parameter.POSITION] || '(0, 0, 0)'),
+                    rotation: Parameter.parseRotation(newValue),
+                }));
+            }),
+        ]);
+        this._parameterObservers.set(Parameter.MATERIAL, [
+            (element, oldValue, newValue) => __awaiter(this, void 0, void 0, function* () {
+                const materialName = newValue.toString();
+                element.nodes.forEach(node => {
+                    assertTransformNode(node, (node) => {
+                        if (node instanceof InstancedMesh) {
+                            throw new Error(`Changing parameter "${Parameter.MATERIAL}" ` +
+                                `of an InstancedMesh is not supported. ` +
+                                `Tried to change node "${node.id}" on element "${element.id}".`);
+                        }
+                    });
+                    setMaterial(element.variant, node, materialName);
+                });
+            }),
+        ]);
+        this._parameterObservers.set(Parameter.MATERIAL_COLOR, [
+            (element, oldValue, newValue) => __awaiter(this, void 0, void 0, function* () {
+                const color = Parameter.parseColor(newValue);
+                element.nodes.forEach(node => {
+                    assertTransformNode(node, (node) => {
+                        if (node instanceof InstancedMesh) {
+                            throw new Error(`Changing parameter "${Parameter.MATERIAL_COLOR}" ` +
+                                `of an InstancedMesh is not supported. ` +
+                                `Tried to change node "${node.id}" on element "${element.id}".`);
+                        }
+                    });
+                    if (this.variant.viewer.cloneMaterialsOnMutation) {
+                        if (!has(node.metadata, 'dirty.material')) {
+                            cloneTransformNodeMaterial(node);
+                        }
+                        if (!has(node.metadata, 'dirty.material.color')) {
+                            // inject initial value and mark as dirty
+                            injectNodeMetadata(node, { dirty: { material: { color: oldValue } } });
+                        }
+                    }
+                    setMaterialColor(node, color);
+                });
+            }),
+        ]);
+        this._parameterObservers.set(Parameter.MATERIAL_METALLNESS, [
+            (element, oldValue, newValue) => __awaiter(this, void 0, void 0, function* () {
+                const metallness = Parameter.parseNumber(newValue);
+                element.nodes.forEach(node => {
+                    assertTransformNode(node, (node) => {
+                        if (node instanceof InstancedMesh) {
+                            throw new Error(`Changing parameter "${Parameter.MATERIAL_METALLNESS}" ` +
+                                `of an InstancedMesh is not supported. ` +
+                                `Tried to change node "${node.id}" on element "${element.id}".`);
+                        }
+                    });
+                    if (this.variant.viewer.cloneMaterialsOnMutation) {
+                        if (!has(node.metadata, 'dirty.material')) {
+                            cloneTransformNodeMaterial(node);
+                        }
+                        if (!has(node.metadata, 'dirty.material.metallness')) {
+                            // inject initial value and mark as dirty
+                            injectNodeMetadata(node, { dirty: { material: { metallness: oldValue } } });
+                        }
+                    }
+                    setMaterialMetallness(node, metallness);
+                });
+            }),
+        ]);
+        this._parameterObservers.set(Parameter.MATERIAL_ROUGHNESS, [
+            (element, oldValue, newValue) => __awaiter(this, void 0, void 0, function* () {
+                const roughness = Parameter.parseNumber(newValue);
+                element.nodes.forEach(node => {
+                    assertTransformNode(node, (node) => {
+                        if (node instanceof InstancedMesh) {
+                            throw new Error(`Changing parameter "${Parameter.MATERIAL_ROUGHNESS}" ` +
+                                `of an InstancedMesh is not supported. ` +
+                                `Tried to change node "${node.id}" on element "${element.id}".`);
+                        }
+                    });
+                    if (this.variant.viewer.cloneMaterialsOnMutation) {
+                        if (!has(node.metadata, 'dirty.material')) {
+                            cloneTransformNodeMaterial(node);
+                        }
+                        if (!has(node.metadata, 'dirty.material.roughness')) {
+                            // inject initial value and mark as dirty
+                            injectNodeMetadata(node, { dirty: { material: { roughness: oldValue } } });
+                        }
+                    }
+                    setMaterialRoughness(node, roughness);
+                });
+            }),
+        ]);
+        this._parameterObservers.set(Parameter.HIGHLIGHT_COLOR, [
+            (element, oldValue, newValue) => __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                // trigger Parameter.HIGHLIGHTED observers
+                (_a = this._parameterObservers.get(Parameter.HIGHLIGHTED)) === null || _a === void 0 ? void 0 : _a.forEach(observer => {
+                    observer(element, !!element.highlighted, !!element.highlighted);
+                });
+            }),
+        ]);
+        this._parameterObservers.set(Parameter.HIGHLIGHT_ENABLED, [
+            (element, oldValue, newValue) => __awaiter(this, void 0, void 0, function* () {
+                var _b;
+                let curr;
+                try {
+                    curr = Parameter.parseBoolean(newValue);
+                }
+                catch (e) {
+                    return;
+                }
+                switch (curr) {
+                    case true:
+                        if (element._highlightLayer) {
+                            break;
+                        }
+                        element.highlightLayer = new HighlightLayer(DottedPath.create(element.id).addPart('highlight').path, element.variant.viewer.scene);
+                        break;
+                    case false:
+                        (_b = element.highlightLayer) === null || _b === void 0 ? void 0 : _b.dispose();
+                        break;
+                }
+            }),
+        ]);
+        this._parameterObservers.set(Parameter.HIGHLIGHTED, [
+            (element, oldValue, newValue) => __awaiter(this, void 0, void 0, function* () {
+                var _c;
+                if (!element.inheritedParameters[Parameter.HIGHLIGHT_ENABLED]) {
+                    return;
+                }
+                // trigger Parameter.HIGHLIGHT_ENABLED observers to ensure HighlightLayer
+                (_c = this._parameterObservers.get(Parameter.HIGHLIGHT_ENABLED)) === null || _c === void 0 ? void 0 : _c.forEach(observer => {
+                    observer(element, this.parameters[Parameter.HIGHLIGHT_ENABLED], true);
+                });
+                let highlighted;
+                try {
+                    highlighted = Parameter.parseBoolean(newValue);
+                }
+                catch (e) {
+                    return;
+                }
+                // Add/Remove meshes to previously created highlight layers.
+                if (highlighted === true) {
+                    element.nodes.forEach(node => {
+                        assertTransformNode(node, (node) => {
+                            if (node instanceof InstancedMesh) {
+                                throw new Error(`Changing parameter "${Parameter.HIGHLIGHTED}" ` +
+                                    `of an InstancedMesh is not supported. ` +
+                                    `Tried to change node "${node.id}" on element "${element.id}".`);
+                            }
+                        });
+                        let color = Color3.Green();
+                        if (element.inheritedParameters[Parameter.HIGHLIGHT_COLOR]) {
+                            color = Parameter.parseColor(element.inheritedParameters[Parameter.HIGHLIGHT_COLOR]);
+                        }
+                        if (typeof element._highlightLayer !== 'undefined') {
+                            addToHighlightLayer(element._highlightLayer, color, node);
+                        }
+                    });
+                }
+                else if (highlighted === false) {
+                    element.nodes.forEach(node => {
+                        if (typeof element._highlightLayer !== 'undefined') {
+                            removeFromHighlightLayer(element._highlightLayer, node);
+                        }
+                    });
+                }
+            }),
+        ]);
+        this._parameterObservers.set(Parameter.CAST_SHADOW, [
+            (element, oldValue, newValue) => __awaiter(this, void 0, void 0, function* () {
+                let castShadow;
+                try {
+                    castShadow = Parameter.parseBoolean(newValue);
+                }
+                catch (e) {
+                    return;
+                }
+                let lightCsl = element.inheritedParameters[Parameter.CAST_SHADOW_FROM_LIGHTS];
+                if (!lightCsl) {
+                    lightCsl = element.variant.inheritedViewerLights.map(l => l.name).join(',');
+                }
+                if (castShadow === true) {
+                    yield this.castShadowValueHandler(lightCsl, addToShadowGenerator);
+                }
+                if (castShadow === false) {
+                    yield this.castShadowValueHandler(lightCsl, removeFromShadowGenerator);
+                }
+            }),
+        ]);
+        this._parameterObservers.set(Parameter.CAST_SHADOW_FROM_LIGHTS, [
+            (element, oldValue, newValue) => __awaiter(this, void 0, void 0, function* () {
+                // TODO: Possible performance issue in combination with CAST_SHADOW, since both observers are initially called
+                //       when CAST_SHADOW and CAST_SHADOW_FROM_LIGHTS are defined in the spec.
+                const lightCsl = element.variant.inheritedViewerLights.map(l => l.name).join(',');
+                // cleanup all shadow generators
+                yield this.castShadowValueHandler(lightCsl, removeFromShadowGenerator);
+                if (element.castShadow === true) {
+                    // if newValue is undefined or '' then set newValue to lightCsl (use all lights)
+                    if (!newValue) {
+                        newValue = lightCsl;
+                    }
+                    yield this.castShadowValueHandler(newValue, addToShadowGenerator);
+                }
+            }),
+        ]);
+        this._parameterObservers.set(Parameter.RECEIVE_SHADOWS, [
+            (element, oldValue, newValue) => __awaiter(this, void 0, void 0, function* () {
+                element.nodes.forEach(node => setReceiveShadows(node, Parameter.parseBoolean(newValue)));
+            }),
+        ]);
+        return this;
+    }
+    /**
+     * Filter for nodes that are not defined or excluded in the `pathDefinitions`.
+     */
+    filterNode(node) {
+        let includeTokens = [];
+        this.pathDefinitions.include.forEach(dottedPath => {
+            includeTokens = union(includeTokens, DottedPath.create(dottedPath).leafTokens);
+        });
+        const shallKeep = (dp) => {
+            const isDirectlyIncluded = !!includeTokens.find(_dp => _dp === dp.path);
+            const isSubOfIncluded = !!this.pathDefinitions.include.find(_dp => {
+                return dp.path.startsWith(`${_dp}${DottedPath.DELIMITER}`);
+            });
+            return isDirectlyIncluded || isSubOfIncluded;
+        };
+        const shallExclude = (dp) => {
+            if (!this.pathDefinitions.exclude) {
+                return false;
+            }
+            return !!this.pathDefinitions.exclude.find(_dp => dp.path === _dp);
+        };
+        return shallKeep(node.metadata.dottedPath) && !shallExclude(node.metadata.dottedPath);
+    }
+    /**
+     * Asserts whether all {@link pathDefinitions} link to a valid `Node` path.
+     * @protected
+     */
+    assertPathDefinitions() {
+        var _a;
+        const dottedNodes = this.variant.inheritedDottedNodes;
+        if (dottedNodes.size === 0) {
+            throw new Error(`There are no mapped nodes for element "${this.id}".`);
+        }
+        const include = this.pathDefinitions.include.map(path => DottedPath.create(path).path);
+        const exclude = (_a = this.pathDefinitions.exclude) === null || _a === void 0 ? void 0 : _a.map(path => DottedPath.create(path).path);
+        const keys = Array.from(dottedNodes.keys()).map(dottedPath => dottedPath.path);
+        union(include, exclude).forEach(path => {
+            if (keys.indexOf(path) === -1) {
+                throw new Error(`Node with path "${path}" does not exist for element "${this.id}".`);
+            }
+        });
+    }
+    /**
+     * Handles callback for given light parameter.
+     */
+    castShadowValueHandler(lightCsl, mutator) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let lights = [];
+            for (const lightName of Parameter.parseCommaSeparatedList(lightCsl)) {
+                const viewerLight = yield this.variant.getViewerLight(lightName);
+                if (viewerLight) {
+                    lights.push(viewerLight.light);
+                }
+            }
+            const shadowGenerators = lights.map(light => light === null || light === void 0 ? void 0 : light.getShadowGenerator()).filter(Boolean);
+            shadowGenerators.forEach(generator => {
+                this.nodes.forEach(node => {
+                    mutator(generator, node);
+                });
+            });
+        });
+    }
+}
 //# sourceMappingURL=element.js.map