@combeenation/3d-viewer 14.0.1-rc1 → 15.0.0

package/dist/lib-cjs/manager/parameter-manager.js

@@ -1,515 +1,574 @@
-"use strict";
-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());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ParameterManager = exports.BuiltInParameter = void 0;
-const index_1 = require("../index");
-const metadata_helper_1 = require("../internal/metadata-helper");
-const paintable_helper_1 = require("../internal/paintable-helper");
-const tags_helper_1 = require("../internal/tags-helper");
-const lodash_es_1 = require("lodash-es");
-/**
- * Parameters with a built in observer implementation
- */
-exports.BuiltInParameter = {
-    Visible: 'visible',
-    Material: 'material',
-    Position: 'position',
-    Rotation: 'rotation',
-    Scaling: 'scaling',
-    Color: 'color',
-    Roughness: 'roughness',
-    Metallic: 'metallic',
-    Paintable: 'paintable',
-};
-const isTagParameterSubject = (subject) => 'tagName' in subject && !!subject.tagName;
-const isNodeParameterSubject = (subject) => 'nodeName' in subject && !!subject.nodeName;
-const isMaterialParameterSubject = (subject) => 'materialName' in subject && !!subject.materialName;
-class ParameterManager {
-    constructor(viewer) {
-        this.viewer = viewer;
-        this._parameterEntries = [];
-        this._parameterObserver = {};
-        this._addBuiltInParameterObservers();
-    }
-    /**
-     * Parses and converts input to a boolean value, valid values are:
-     * - true / false
-     * - 1 / 0
-     */
-    static parseBoolean(value) {
-        if (value.toString() === 'true' || value.toString() === '1') {
-            return true;
-        }
-        else if (value.toString() === 'false' || value.toString() === '0') {
-            return false;
-        }
-        throw new index_1.ViewerError({
-            id: index_1.ViewerErrorIds.InvalidParameterValue,
-            message: `Unable to parse "${value}" to a boolean`,
-        });
-    }
-    /**
-     * Parses and converts input to a number value
-     */
-    static parseNumber(value) {
-        return parseFloat(value.toString());
-    }
-    /**
-     * Parses and converts input to a string value
-     */
-    static parseString(value) {
-        return value.toString();
-    }
-    // TODO WTT: enable setting Vector3 on the input directly
-    /**
-     * Parses a string of format "(x,y,z)"" to a "Vector3".
-     */
-    static parseVector(value) {
-        if (!(0, lodash_es_1.isString)(value)) {
-            throw new index_1.ViewerError({
-                id: index_1.ViewerErrorIds.InvalidParameterValue,
-                message: `Unable to parse "${value}" to a vector: not a string`,
-            });
-        }
-        let cleanedValue = value.split(' ').join('');
-        if (cleanedValue.startsWith('(') && cleanedValue.endsWith(')')) {
-            cleanedValue = cleanedValue.substring(1, cleanedValue.length - 1);
-            const [x, y, z] = cleanedValue.split(',').map(value => parseFloat(value));
-            return new index_1.Vector3(x, y, z);
-        }
-        else {
-            throw new index_1.ViewerError({
-                id: index_1.ViewerErrorIds.InvalidParameterValue,
-                message: `Unable to parse "${value}" to a vector: expected "(x,y,z)"`,
-            });
-        }
-    }
-    // TODO WTT: enable setting Vector3 on the input directly (maybe quaternion as well)
-    /**
-     * Parses a string of format `'(x,y,z)'` with angular degrees to a `Vector3` with rotation information in radians.
-     */
-    static parseRotation(value) {
-        const rotation = ParameterManager.parseVector(value);
-        const deg2rad = (deg) => {
-            return (deg * Math.PI) / 180;
-        };
-        return rotation.set(deg2rad(rotation.x), deg2rad(rotation.y), deg2rad(rotation.z));
-    }
-    // TODO WTT: enable setting Color3 on the input directly
-    /**
-     * Parses a string of format `'#rrggbb'` or `'(r,g,b)'` to a `Color3`.
-     */
-    static parseColor(value) {
-        const cleanedValue = value.toString().split(' ').join('');
-        if (cleanedValue.startsWith('#')) {
-            return index_1.Color3.FromHexString(value.toString());
-        }
-        if (cleanedValue.startsWith('(') && cleanedValue.endsWith(')')) {
-            const rgb = cleanedValue.substring(1, cleanedValue.length - 1);
-            const [r, g, b] = rgb.split(',').map(value => parseFloat(value));
-            return index_1.Color3.FromInts(r, g, b);
-        }
-        const humanReadable = (0, lodash_es_1.capitalize)(cleanedValue);
-        if (Object.prototype.hasOwnProperty.call(index_1.Color3, humanReadable)) {
-            return index_1.Color3[humanReadable]();
-        }
-        throw new index_1.ViewerError({
-            id: index_1.ViewerErrorIds.InvalidParameterValue,
-            message: `Unable to parse "${value}" to a color: expected "#rrggbb", "(r,g,b)" or any human readable (e.g. Red) property implemented in Color3`,
-        });
-    }
-    /**
-     * Set parameter value for a certain node and calls the corresponding observer if the value has changed
-     *
-     * @returns "true" if parameter value has changed
-     */
-    setNodeParameterValue(nodeName, parameterName, value) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const valueChanged = this._addParameterValue({ nodeName }, parameterName, value);
-            if (valueChanged) {
-                yield this._applyParameterValue({ nodeName }, parameterName);
-            }
-            return valueChanged;
-        });
-    }
-    /**
-     * Set parameter value for a certain material and calls the corresponding observer if the value has changed
-     *
-     * @returns "true" if parameter value has changed
-     */
-    setMaterialParameterValue(materialName, parameterName, value) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const valueChanged = this._addParameterValue({ materialName }, parameterName, value);
-            if (valueChanged) {
-                yield this._applyParameterValue({ materialName }, parameterName);
-            }
-            return valueChanged;
-        });
-    }
-    /**
-     * Set parameter value for a certain tag and calls the corresponding observer if the value has changed.\
-     * Setting a parameter value on a tag can affect multiple nodes and tags, depending which of these objects contains
-     * the desired tag.
-     *
-     * @returns "true" if parameter value has changed
-     */
-    setTagParameterValue(tagName, parameterName, value) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const valueChanged = this._addParameterValue({ tagName }, parameterName, value);
-            if (valueChanged) {
-                yield this._applyParameterValue({ tagName }, parameterName);
-            }
-            return valueChanged;
-        });
-    }
-    /**
-     * Set multiple parameter values simultaniously.\
-     * Tag parameters are applied before node and material parameters, node and materials are more specific and should
-     * have priority.
-     *
-     * @returns Array of parameters, which have changed values
-     */
-    setParameterValues(values) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const parameterEntries = values.map(valueEntry => {
-                const subject = isNodeParameterSubject(valueEntry)
-                    ? { nodeName: valueEntry.nodeName }
-                    : isMaterialParameterSubject(valueEntry)
-                        ? { materialName: valueEntry.materialName }
-                        : { tagName: valueEntry.tagName };
-                return { subject, parameterName: valueEntry.parameterName, value: valueEntry.value, oldValue: undefined };
-            });
-            const changedParameterEntries = parameterEntries.filter(paramEntry => this._addParameterValue(paramEntry.subject, paramEntry.parameterName, paramEntry.value));
-            yield this._applyParameterValues(changedParameterEntries);
-            // convert back to original typing
-            const changedParameterValues = changedParameterEntries.map(paramEntry => {
-                return Object.assign(Object.assign({}, paramEntry.subject), { parameterName: paramEntry.parameterName, value: paramEntry.value });
-            });
-            return changedParameterValues;
-        });
-    }
-    /**
-     * @returns desired parameter value or "undefined" if parameter entry is not available.
-     */
-    getParameterValue(subject, parameterName) {
-        const entry = this._getEntry(subject, parameterName);
-        return entry === null || entry === void 0 ? void 0 : entry.value;
-    }
-    /**
-     * Define observer callback for certain parameter.\
-     * There can only be one observer for a certain parameter name.\
-     * Parameter observers can not be overwritten once they are defined, this also includes system observers for
-     * {@link BuiltInParameter}.
-     */
-    setParameterObserver(parameterName, observer) {
-        if (this._parameterObserver[parameterName]) {
-            console.warn(`Observer for parameter "${parameterName}" already set`);
-            return;
-        }
-        this._parameterObserver[parameterName] = observer;
-    }
-    /**
-     * Print all parameter entries in table format into the console
-     */
-    printAllParameters() {
-        const printable = this._parameterEntries.map(entry => (Object.assign(Object.assign({}, entry), { subject: JSON.stringify(entry.subject) })));
-        console.table(printable);
-    }
-    /**
-     * Applies all existing parameter entries to a certain "model", as defined in the {@link ModelManager}.\
-     * This can be usefull when updating the model before showing it in the scene.
-     *
-     * @internal
-     */
-    applyAllParameterValuesToModel(model) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const parameterEntriesToApply = this._parameterEntries;
-            yield this._applyParameterValues(parameterEntriesToApply, model);
-        });
-    }
-    /**
-     * Applies all parameter values which are targeting a material.\
-     * This can be usefull when updating a material definition before creating it.
-     *
-     * @internal
-     */
-    applyParameterValuesToMaterial(material) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const tags = (0, tags_helper_1.getTags)(material);
-            const parameterEntriesToApply = [];
-            tags.forEach(tagName => {
-                const tagParamEntries = this._getEntriesOfSubject({ tagName });
-                parameterEntriesToApply.push(...tagParamEntries);
-            });
-            const materialParamEntries = this._getEntriesOfSubject({ materialName: material.id });
-            parameterEntriesToApply.push(...materialParamEntries);
-            yield this._applyParameterValues(parameterEntriesToApply);
-        });
-    }
-    /**
-     * @returns Desired parameter value of a certain node.
-     * Tags are considered as well but have lower priority than node parameters, as these are more specific.
-     *
-     * @internal
-     */
-    getParameterValueOfNode(node, parameterName) {
-        const nodeParamValue = this.getParameterValue({ nodeName: node.name }, parameterName);
-        if (nodeParamValue !== undefined) {
-            return nodeParamValue;
-        }
-        const tags = (0, tags_helper_1.getTags)(node);
-        const tagParamValue = tags.reduce((accValue, curTag) => {
-            // NOTE: it is possible that values are available for multiple tags
-            // in this case the resulting parameter value is quite "random" as the last tag in the tag string of the node has
-            // priority
-            const tagParamValue = this.getParameterValue({ tagName: curTag }, parameterName);
-            return accValue !== null && accValue !== void 0 ? accValue : tagParamValue;
-        }, undefined);
-        return tagParamValue;
-    }
-    /**
-     * @returns Desired parameter value of a certain material.
-     * Tags are considered as well but have lower priority than material parameters, as these are more specific.
-     * Unused ATM, but added for consistency as counter part for {@link getParameterValueOfNode}
-     *
-     * @internal
-     */
-    getParameterValueOfMaterial(material, parameterName) {
-        const materialParamValue = this.getParameterValue({ materialName: material.name }, parameterName);
-        if (materialParamValue !== undefined) {
-            return materialParamValue;
-        }
-        const tags = (0, tags_helper_1.getTags)(material);
-        const tagParamValue = tags.reduce((accValue, curTag) => {
-            const tagParamValue = this.getParameterValue({ tagName: curTag }, parameterName);
-            return accValue !== null && accValue !== void 0 ? accValue : tagParamValue;
-        }, undefined);
-        return tagParamValue;
-    }
-    /**
-     * Parameter observer implementation of default parameters
-     */
-    _addBuiltInParameterObservers() {
-        this.setParameterObserver(exports.BuiltInParameter.Visible, ({ nodes, newValue }) => __awaiter(this, void 0, void 0, function* () {
-            const visible = ParameterManager.parseBoolean(newValue);
-            for (const node of nodes) {
-                if (visible) {
-                    const deferredMaterial = (0, metadata_helper_1.getInternalMetadataValue)(node, 'deferredMaterial');
-                    if (deferredMaterial) {
-                        yield this.viewer.materialManager.setMaterialOnMesh(deferredMaterial, node);
-                    }
-                    node.setEnabled(true);
-                }
-                else {
-                    node.setEnabled(false);
-                }
-            }
-        }));
-        this.setParameterObserver(exports.BuiltInParameter.Material, ({ nodes, newValue }) => __awaiter(this, void 0, void 0, function* () {
-            const material = ParameterManager.parseString(newValue);
-            for (const node of nodes) {
-                // NOTE: don't use node.isEnabled() as visibility observer is probably called in same cycle but later
-                // however the parameter value is already correct at this stage
-                const rawVisibleValue = this.getParameterValueOfNode(node, exports.BuiltInParameter.Visible);
-                const visible = rawVisibleValue !== undefined ? ParameterManager.parseBoolean(rawVisibleValue) : node.isEnabled();
-                if (visible) {
-                    // TODO WTT: check mesh type and throw error if it doesn't fit
-                    // think of creating a framework with type guards (isMesh, canHaveMaterial, ...) around this
-                    yield this.viewer.materialManager.setMaterialOnMesh(material, node);
-                }
-                else {
-                    (0, metadata_helper_1.setInternalMetadataValue)(node, 'deferredMaterial', material);
-                }
-            }
-        }));
-        this.setParameterObserver(exports.BuiltInParameter.Position, ({ nodes, newValue }) => __awaiter(this, void 0, void 0, function* () {
-            const position = ParameterManager.parseVector(newValue);
-            for (const node of nodes) {
-                node.position = position;
-            }
-        }));
-        this.setParameterObserver(exports.BuiltInParameter.Rotation, ({ nodes, newValue }) => __awaiter(this, void 0, void 0, function* () {
-            const rotation = ParameterManager.parseRotation(newValue);
-            for (const node of nodes) {
-                node.rotation = rotation;
-            }
-        }));
-        this.setParameterObserver(exports.BuiltInParameter.Scaling, ({ nodes, newValue }) => __awaiter(this, void 0, void 0, function* () {
-            const scaling = ParameterManager.parseVector(newValue);
-            for (const node of nodes) {
-                node.scaling = scaling;
-            }
-        }));
-        this.setParameterObserver(exports.BuiltInParameter.Color, ({ materials, newValue }) => __awaiter(this, void 0, void 0, function* () {
-            const color = ParameterManager.parseColor(newValue);
-            for (const material of materials) {
-                const materialCls = material.getClassName();
-                switch (materialCls) {
-                    case 'PBRMaterial':
-                        material.albedoColor = color.toLinearSpace();
-                        break;
-                    case 'StandardMaterial':
-                        material.diffuseColor = color;
-                        break;
-                    default:
-                        throw new Error(`Setting color for material of instance "${materialCls}" not implemented`);
-                }
-            }
-        }));
-        this.setParameterObserver(exports.BuiltInParameter.Roughness, ({ materials, newValue }) => __awaiter(this, void 0, void 0, function* () {
-            const roughness = ParameterManager.parseNumber(newValue);
-            for (const material of materials) {
-                const materialCls = material.getClassName();
-                switch (materialCls) {
-                    case 'PBRMaterial':
-                        material.roughness = roughness;
-                        break;
-                    case 'StandardMaterial':
-                        material.roughness = roughness;
-                        break;
-                    default:
-                        throw new Error(`Setting rougness for material of instance "${materialCls}" not implemented`);
-                }
-            }
-        }));
-        this.setParameterObserver(exports.BuiltInParameter.Metallic, ({ materials, newValue }) => __awaiter(this, void 0, void 0, function* () {
-            const metallic = ParameterManager.parseNumber(newValue);
-            for (const material of materials) {
-                const materialCls = material.getClassName();
-                switch (materialCls) {
-                    case 'PBRMaterial':
-                        material.metallic = metallic;
-                        break;
-                    default:
-                        throw new Error(`Setting metallic for material of instance "${materialCls}" not implemented`);
-                }
-            }
-        }));
-        this.setParameterObserver(exports.BuiltInParameter.Paintable, ({ newValue, materials }) => __awaiter(this, void 0, void 0, function* () {
-            (0, paintable_helper_1.paintableParameterObserver)(newValue, materials, this.viewer.scene);
-        }));
-    }
-    /**
-     * Change parameter value in array of existing parameter entries or create a new entry
-     *
-     * @returns "true" if parameter has changed or wasn't available before
-     */
-    _addParameterValue(subject, parameterName, value) {
-        const existingEntry = this._getEntry(subject, parameterName);
-        if ((existingEntry === null || existingEntry === void 0 ? void 0 : existingEntry.value) === value) {
-            return false;
-        }
-        if (existingEntry) {
-            existingEntry.oldValue = existingEntry.value;
-            existingEntry.value = value;
-        }
-        else {
-            this._parameterEntries.push({ subject, parameterName, value, oldValue: undefined });
-        }
-        return true;
-    }
-    /**
-     * Call parameter observer of desired parameter which usually apply the new values to the scene.
-     *
-     * @param assetContainer Asset container in which to look for the paramter entries subjects (e.g. the nodes and
-     *                       materials to which the parameter values should be applied to).\
-     *                       Defaults to `viewer.scene`.
-     */
-    _applyParameterValues(parameterEntries, assetContainer) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const tagParamEntries = parameterEntries.filter(entry => isTagParameterSubject(entry.subject));
-            const nonTagParamEntries = parameterEntries.filter(entry => !isTagParameterSubject(entry.subject));
-            for (const entry of tagParamEntries) {
-                yield this._applyParameterValue(entry.subject, entry.parameterName, assetContainer);
-            }
-            for (const entry of nonTagParamEntries) {
-                yield this._applyParameterValue(entry.subject, entry.parameterName, assetContainer);
-            }
-        });
-    }
-    /**
-     * Call parameter observer of desired parameter
-     *
-     * @param assetContainer Optionally add an "asset container", which actually represents a model in the
-     * {@link ModelManager}. Viewer scene is used if left empty.
-     */
-    _applyParameterValue(subject, parameterName, assetContainer) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const parameterEntry = this._getEntry(subject, parameterName);
-            const observer = this._parameterObserver[parameterName];
-            if (!parameterEntry || !observer) {
-                return;
-            }
-            const nodes = this._getAffectedNodes(subject, assetContainer);
-            const materials = this._getAffectedMaterials(subject, assetContainer);
-            yield observer({
-                subject,
-                newValue: parameterEntry.value,
-                oldValue: parameterEntry.oldValue,
-                nodes,
-                materials,
-            });
-        });
-    }
-    _getAffectedMaterials(subject, assetContainer) {
-        assetContainer = assetContainer !== null && assetContainer !== void 0 ? assetContainer : this.viewer.scene;
-        let materials = [];
-        // materials have priority over tags
-        if (isMaterialParameterSubject(subject)) {
-            materials = assetContainer.materials.filter(material => material.name === subject.materialName);
-            if (materials.length > 1) {
-                console.warn(`Multiple materials for material name "${subject.materialName}" have been found`);
-            }
-        }
-        else if (isTagParameterSubject(subject)) {
-            materials = assetContainer.materials.filter(material => (0, tags_helper_1.hasTag)(material, subject.tagName));
-        }
-        return materials;
-    }
-    _getAffectedNodes(subject, assetContainer) {
-        assetContainer = assetContainer !== null && assetContainer !== void 0 ? assetContainer : this.viewer.scene;
-        const allNodes = [...assetContainer.meshes, ...assetContainer.transformNodes];
-        let nodes = [];
-        // nodes have priority over tags
-        if (isNodeParameterSubject(subject)) {
-            nodes = allNodes.filter(node => node.name === subject.nodeName);
-            if (nodes.length > 1) {
-                console.warn(`Multiple nodes for node name "${subject.nodeName}" have been found`);
-            }
-        }
-        else if (isTagParameterSubject(subject)) {
-            nodes = allNodes.filter(node => (0, tags_helper_1.hasTag)(node, subject.tagName));
-        }
-        return nodes;
-    }
-    _getEntry(subject, parameterName) {
-        const entriesOfSubject = this._getEntriesOfSubject(subject);
-        const entry = entriesOfSubject.find(entry => entry.parameterName === parameterName);
-        return entry;
-    }
-    _getEntriesOfSubject(subject) {
-        const entries = this._parameterEntries.filter(entry => {
-            const nodeNameMatches = isNodeParameterSubject(entry.subject) &&
-                isNodeParameterSubject(subject) &&
-                entry.subject.nodeName === subject.nodeName;
-            const materialNameMatches = isMaterialParameterSubject(entry.subject) &&
-                isMaterialParameterSubject(subject) &&
-                entry.subject.materialName === subject.materialName;
-            const tagNameMatches = isTagParameterSubject(entry.subject) &&
-                isTagParameterSubject(subject) &&
-                entry.subject.tagName === subject.tagName;
-            return nodeNameMatches || materialNameMatches || tagNameMatches;
-        });
-        return entries;
-    }
-}
-exports.ParameterManager = ParameterManager;
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParameterManager = exports.LegacyParameter = exports.BuiltInParameter = void 0;
+const index_1 = require("../index");
+const metadata_helper_1 = require("../internal/metadata-helper");
+const paintable_helper_1 = require("../internal/paintable-helper");
+const tags_helper_1 = require("../internal/tags-helper");
+const texture_parameter_helper_1 = require("../internal/texture-parameter-helper");
+const lodash_es_1 = require("lodash-es");
+/**
+ * Parameters with a built in observer implementation
+ */
+exports.BuiltInParameter = {
+    Visible: 'visible',
+    Material: 'material',
+    Position: 'position',
+    Rotation: 'rotation',
+    Scaling: 'scaling',
+    Color: 'color',
+    Roughness: 'roughness',
+    Metallic: 'metallic',
+    /**
+     * Texture parameters are always a combination of the channel (e.g. `albedoTexture`) and a sub parameter
+     * (e.g. `uScale`). Use this function to create the parameter accordingly
+     * (e.g. createTextureParameter("albedoTexture", "uScale")).
+     */
+    createTextureParameter: (channel, parameter) => `${channel}.${parameter}`,
+    UseDetailmap: 'useDetailmap',
+};
+/** @ignore @deprected Use "texture parameters" {@link BuiltInParameter}.`createTextureParameter` instead */
+exports.LegacyParameter = {
+    Paintable: 'paintable',
+};
+const isTagParameterSubject = (subject) => 'tagName' in subject && !!subject.tagName;
+const isNodeParameterSubject = (subject) => 'nodeName' in subject && !!subject.nodeName;
+const isMaterialParameterSubject = (subject) => 'materialName' in subject && !!subject.materialName;
+class ParameterManager {
+    constructor(viewer) {
+        this.viewer = viewer;
+        this._parameterEntries = [];
+        this._parameterObserver = {};
+        this._addBuiltInParameterObservers();
+    }
+    /**
+     * Parses and converts input to a boolean value, valid values are:
+     * - true / false
+     * - 1 / 0
+     */
+    static parseBoolean(value) {
+        if (value.toString() === 'true' || value.toString() === '1') {
+            return true;
+        }
+        else if (value.toString() === 'false' || value.toString() === '0') {
+            return false;
+        }
+        throw new index_1.ViewerError({
+            id: index_1.ViewerErrorIds.InvalidParameterValue,
+            message: `Unable to parse "${value}" to a boolean`,
+        });
+    }
+    /**
+     * Parses and converts input to a number value
+     */
+    static parseNumber(value) {
+        return parseFloat(value.toString());
+    }
+    /**
+     * Parses and converts input to a string value
+     */
+    static parseString(value) {
+        return value.toString();
+    }
+    // TODO WTT: enable setting Vector3 on the input directly
+    /**
+     * Parses a string of format "(x,y,z)"" to a "Vector3".
+     */
+    static parseVector(value) {
+        if (!(0, lodash_es_1.isString)(value)) {
+            throw new index_1.ViewerError({
+                id: index_1.ViewerErrorIds.InvalidParameterValue,
+                message: `Unable to parse "${value}" to a vector: not a string`,
+            });
+        }
+        let cleanedValue = value.split(' ').join('');
+        if (cleanedValue.startsWith('(') && cleanedValue.endsWith(')')) {
+            cleanedValue = cleanedValue.substring(1, cleanedValue.length - 1);
+            const [x, y, z] = cleanedValue.split(',').map(value => parseFloat(value));
+            return new index_1.Vector3(x, y, z);
+        }
+        else {
+            throw new index_1.ViewerError({
+                id: index_1.ViewerErrorIds.InvalidParameterValue,
+                message: `Unable to parse "${value}" to a vector: expected "(x,y,z)"`,
+            });
+        }
+    }
+    // TODO WTT: enable setting Vector3 on the input directly (maybe quaternion as well)
+    /**
+     * Parses a string of format `'(x,y,z)'` with angular degrees to a `Vector3` with rotation information in radians.
+     */
+    static parseRotation(value) {
+        const rotation = ParameterManager.parseVector(value);
+        const deg2rad = (deg) => {
+            return (deg * Math.PI) / 180;
+        };
+        return rotation.set(deg2rad(rotation.x), deg2rad(rotation.y), deg2rad(rotation.z));
+    }
+    // TODO WTT: enable setting Color3 on the input directly
+    /**
+     * Parses a string of format `'#rrggbb'` or `'(r,g,b)'` to a `Color3`.
+     */
+    static parseColor(value) {
+        const cleanedValue = value.toString().split(' ').join('');
+        if (cleanedValue.startsWith('#')) {
+            return index_1.Color3.FromHexString(value.toString());
+        }
+        if (cleanedValue.startsWith('(') && cleanedValue.endsWith(')')) {
+            const rgb = cleanedValue.substring(1, cleanedValue.length - 1);
+            const [r, g, b] = rgb.split(',').map(value => parseFloat(value));
+            return index_1.Color3.FromInts(r, g, b);
+        }
+        const humanReadable = (0, lodash_es_1.capitalize)(cleanedValue);
+        if (Object.prototype.hasOwnProperty.call(index_1.Color3, humanReadable)) {
+            return index_1.Color3[humanReadable]();
+        }
+        throw new index_1.ViewerError({
+            id: index_1.ViewerErrorIds.InvalidParameterValue,
+            message: `Unable to parse "${value}" to a color: expected "#rrggbb", "(r,g,b)" or any human readable (e.g. Red) property implemented in Color3`,
+        });
+    }
+    /**
+     * Set parameter value for a certain node and calls the corresponding observer if the value has changed
+     *
+     * @returns "true" if parameter value has changed
+     */
+    setNodeParameterValue(nodeName, parameterName, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const valueChanged = this._addParameterValue({ nodeName }, parameterName, value);
+            if (valueChanged) {
+                yield this._applyParameterValue({ nodeName }, parameterName);
+            }
+            return valueChanged;
+        });
+    }
+    /**
+     * Set parameter value for a certain material and calls the corresponding observer if the value has changed
+     *
+     * @returns "true" if parameter value has changed
+     */
+    setMaterialParameterValue(materialName, parameterName, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const valueChanged = this._addParameterValue({ materialName }, parameterName, value);
+            if (valueChanged) {
+                yield this._applyParameterValue({ materialName }, parameterName);
+            }
+            return valueChanged;
+        });
+    }
+    /**
+     * Set parameter value for a certain tag and calls the corresponding observer if the value has changed.\
+     * Setting a parameter value on a tag can affect multiple nodes and tags, depending which of these objects contains
+     * the desired tag.
+     *
+     * @returns "true" if parameter value has changed
+     */
+    setTagParameterValue(tagName, parameterName, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const valueChanged = this._addParameterValue({ tagName }, parameterName, value);
+            if (valueChanged) {
+                yield this._applyParameterValue({ tagName }, parameterName);
+            }
+            return valueChanged;
+        });
+    }
+    /**
+     * Set multiple parameter values simultaniously.\
+     * Tag parameters are applied before node and material parameters, node and materials are more specific and should
+     * have priority.
+     *
+     * @returns Array of parameters, which have changed values
+     */
+    setParameterValues(values) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const parameterEntries = values.map(valueEntry => {
+                const subject = isNodeParameterSubject(valueEntry)
+                    ? { nodeName: valueEntry.nodeName }
+                    : isMaterialParameterSubject(valueEntry)
+                        ? { materialName: valueEntry.materialName }
+                        : { tagName: valueEntry.tagName };
+                return { subject, parameterName: valueEntry.parameterName, value: valueEntry.value, oldValue: undefined };
+            });
+            const changedParameterEntries = parameterEntries.filter(paramEntry => this._addParameterValue(paramEntry.subject, paramEntry.parameterName, paramEntry.value));
+            yield this._applyParameterValues(changedParameterEntries);
+            // convert back to original typing
+            const changedParameterValues = changedParameterEntries.map(paramEntry => {
+                return Object.assign(Object.assign({}, paramEntry.subject), { parameterName: paramEntry.parameterName, value: paramEntry.value });
+            });
+            return changedParameterValues;
+        });
+    }
+    /**
+     * @returns desired parameter value or "undefined" if parameter entry is not available.
+     */
+    getParameterValue(subject, parameterName) {
+        const entry = this._getEntry(subject, parameterName);
+        return entry === null || entry === void 0 ? void 0 : entry.value;
+    }
+    /**
+     * Define observer callback for certain parameter.\
+     * There can only be one observer for a certain parameter name.\
+     * Parameter observers can not be overwritten once they are defined, this also includes system observers for
+     * {@link BuiltInParameter}.
+     */
+    setParameterObserver(parameterName, observer) {
+        if (this._parameterObserver[parameterName]) {
+            console.warn(`Observer for parameter "${parameterName}" already set`);
+            return;
+        }
+        this._parameterObserver[parameterName] = observer;
+    }
+    /**
+     * Print all parameter entries in table format into the console
+     */
+    printAllParameters() {
+        const printable = this._parameterEntries.map(entry => (Object.assign(Object.assign({}, entry), { subject: JSON.stringify(entry.subject) })));
+        console.table(printable);
+    }
+    /**
+     * Applies all existing parameter entries to a certain "model", as defined in the {@link ModelManager}.\
+     * This can be usefull when updating the model before showing it in the scene.
+     *
+     * @internal
+     */
+    applyAllParameterValuesToModel(model) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const parameterEntriesToApply = this._parameterEntries;
+            yield this._applyParameterValues(parameterEntriesToApply, model);
+        });
+    }
+    /**
+     * Applies all parameter values which are targeting a material.\
+     * This can be usefull when updating a material definition before creating it.
+     *
+     * @internal
+     */
+    applyParameterValuesToMaterial(material) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tags = (0, tags_helper_1.getTags)(material);
+            const parameterEntriesToApply = [];
+            tags.forEach(tagName => {
+                const tagParamEntries = this._getEntriesOfSubject({ tagName });
+                parameterEntriesToApply.push(...tagParamEntries);
+            });
+            const materialParamEntries = this._getEntriesOfSubject({ materialName: material.id });
+            parameterEntriesToApply.push(...materialParamEntries);
+            yield this._applyParameterValues(parameterEntriesToApply);
+        });
+    }
+    /**
+     * Applies subset of texture parameter values which are targeting a certain texture channel in a material.\
+     * This can be useful when updating texture settings (e.g. uScale) before the texture is actually created.
+     *
+     * @internal
+     */
+    applyTextureSettingsParameter(material, channel) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tags = (0, tags_helper_1.getTags)(material);
+            const parameterEntriesToApply = [];
+            tags.forEach(tagName => {
+                const tagParamEntries = this._getEntriesOfSubject({ tagName });
+                parameterEntriesToApply.push(...tagParamEntries);
+            });
+            const materialParamEntries = this._getEntriesOfSubject({ materialName: material.id });
+            parameterEntriesToApply.push(...materialParamEntries);
+            const textureParameterEntriesToApply = parameterEntriesToApply.filter(parameterEntry => {
+                const paramPath = parameterEntry.parameterName.split('.');
+                // find texture parameters of this channel, e.g. "albedoTexture.uScale"
+                // "image" should not be applied here as this is part of the texture initialization anyway
+                const isTextureParamOfChannel = paramPath.length === 2 && paramPath[0] === channel && paramPath[1] !== texture_parameter_helper_1.BuiltInTextureParameter.image;
+                return isTextureParamOfChannel;
+            });
+            yield this._applyParameterValues(textureParameterEntriesToApply);
+        });
+    }
+    /**
+     * @returns Desired parameter value of a certain node.
+     * Tags are considered as well but have lower priority than node parameters, as these are more specific.
+     *
+     * @internal
+     */
+    getParameterValueOfNode(node, parameterName) {
+        const nodeParamValue = this.getParameterValue({ nodeName: node.name }, parameterName);
+        if (nodeParamValue !== undefined) {
+            return nodeParamValue;
+        }
+        const tags = (0, tags_helper_1.getTags)(node);
+        const tagParamValue = tags.reduce((accValue, curTag) => {
+            // NOTE: it is possible that values are available for multiple tags
+            // in this case the resulting parameter value is quite "random" as the last tag in the tag string of the node has
+            // priority
+            const tagParamValue = this.getParameterValue({ tagName: curTag }, parameterName);
+            return accValue !== null && accValue !== void 0 ? accValue : tagParamValue;
+        }, undefined);
+        return tagParamValue;
+    }
+    /**
+     * @returns Desired parameter value of a certain material.
+     * Tags are considered as well but have lower priority than material parameters, as these are more specific.
+     * Unused ATM, but added for consistency as counter part for {@link getParameterValueOfNode}
+     *
+     * @internal
+     */
+    getParameterValueOfMaterial(material, parameterName) {
+        const materialParamValue = this.getParameterValue({ materialName: material.name }, parameterName);
+        if (materialParamValue !== undefined) {
+            return materialParamValue;
+        }
+        const tags = (0, tags_helper_1.getTags)(material);
+        const tagParamValue = tags.reduce((accValue, curTag) => {
+            const tagParamValue = this.getParameterValue({ tagName: curTag }, parameterName);
+            return accValue !== null && accValue !== void 0 ? accValue : tagParamValue;
+        }, undefined);
+        return tagParamValue;
+    }
+    /**
+     * Parameter observer implementation of default parameters
+     */
+    _addBuiltInParameterObservers() {
+        this.setParameterObserver(exports.BuiltInParameter.Visible, ({ nodes, newValue }) => __awaiter(this, void 0, void 0, function* () {
+            const visible = ParameterManager.parseBoolean(newValue);
+            for (const node of nodes) {
+                if (visible) {
+                    // if a mesh gets visible by this operation we have to activate the assigned material which is stored in the
+                    // internal metadata
+                    // => consider child meshes as well (CB-10143)
+                    const activatedNodes = [node, ...node.getChildMeshes(false)];
+                    for (const activatedNode of activatedNodes) {
+                        const deferredMaterial = (0, metadata_helper_1.getInternalMetadataValue)(activatedNode, 'deferredMaterial');
+                        if (deferredMaterial) {
+                            yield this.viewer.materialManager.setMaterialOnMesh(deferredMaterial, 
+                            // this cast is fine, as deferred material can only be set on meshes
+                            activatedNode);
+                        }
+                    }
+                    node.setEnabled(true);
+                }
+                else {
+                    node.setEnabled(false);
+                }
+            }
+        }));
+        this.setParameterObserver(exports.BuiltInParameter.Material, ({ nodes, newValue }) => __awaiter(this, void 0, void 0, function* () {
+            const material = ParameterManager.parseString(newValue);
+            for (const node of nodes) {
+                // NOTE: don't use node.isEnabled() as visibility observer is probably called in same cycle but later
+                // however the parameter value is already correct at this stage
+                // we have to go through all parents as well, because a parent may have been set to false, which also disables
+                // this child node
+                let curNode = node;
+                let visibleByParameter = undefined;
+                while (curNode && visibleByParameter !== false) {
+                    const curNodeVisibleByParameter = this.getParameterValueOfNode(curNode, exports.BuiltInParameter.Visible);
+                    if (curNodeVisibleByParameter !== undefined) {
+                        visibleByParameter = curNodeVisibleByParameter;
+                    }
+                    curNode = curNode.parent;
+                }
+                // parameter visibility has priority, but if the visiblity is not controlled by the parameter use the plain
+                // Babylon.js isEnabled() check
+                const visible = visibleByParameter !== undefined ? ParameterManager.parseBoolean(visibleByParameter) : node.isEnabled();
+                if (visible) {
+                    // TODO WTT: check mesh type and throw error if it doesn't fit
+                    // think of creating a framework with type guards (isMesh, canHaveMaterial, ...) around this
+                    yield this.viewer.materialManager.setMaterialOnMesh(material, node);
+                }
+                else {
+                    (0, metadata_helper_1.setInternalMetadataValue)(node, 'deferredMaterial', material);
+                }
+            }
+        }));
+        this.setParameterObserver(exports.BuiltInParameter.Position, ({ nodes, newValue }) => __awaiter(this, void 0, void 0, function* () {
+            const position = ParameterManager.parseVector(newValue);
+            for (const node of nodes) {
+                node.position = position;
+            }
+        }));
+        this.setParameterObserver(exports.BuiltInParameter.Rotation, ({ nodes, newValue }) => __awaiter(this, void 0, void 0, function* () {
+            const rotation = ParameterManager.parseRotation(newValue);
+            for (const node of nodes) {
+                node.rotation = rotation;
+            }
+        }));
+        this.setParameterObserver(exports.BuiltInParameter.Scaling, ({ nodes, newValue }) => __awaiter(this, void 0, void 0, function* () {
+            const scaling = ParameterManager.parseVector(newValue);
+            for (const node of nodes) {
+                node.scaling = scaling;
+            }
+        }));
+        this.setParameterObserver(exports.BuiltInParameter.Color, ({ materials, newValue }) => __awaiter(this, void 0, void 0, function* () {
+            const color = ParameterManager.parseColor(newValue);
+            for (const material of materials) {
+                const materialCls = material.getClassName();
+                switch (materialCls) {
+                    case 'PBRMaterial':
+                        material.albedoColor = color.toLinearSpace();
+                        break;
+                    case 'StandardMaterial':
+                        material.diffuseColor = color;
+                        break;
+                    default:
+                        throw new Error(`Setting color for material of instance "${materialCls}" not implemented`);
+                }
+            }
+        }));
+        this.setParameterObserver(exports.BuiltInParameter.Roughness, ({ materials, newValue }) => __awaiter(this, void 0, void 0, function* () {
+            const roughness = ParameterManager.parseNumber(newValue);
+            for (const material of materials) {
+                const materialCls = material.getClassName();
+                switch (materialCls) {
+                    case 'PBRMaterial':
+                        material.roughness = roughness;
+                        break;
+                    case 'StandardMaterial':
+                        material.roughness = roughness;
+                        break;
+                    default:
+                        throw new Error(`Setting rougness for material of instance "${materialCls}" not implemented`);
+                }
+            }
+        }));
+        this.setParameterObserver(exports.BuiltInParameter.Metallic, ({ materials, newValue }) => __awaiter(this, void 0, void 0, function* () {
+            const metallic = ParameterManager.parseNumber(newValue);
+            for (const material of materials) {
+                const materialCls = material.getClassName();
+                switch (materialCls) {
+                    case 'PBRMaterial':
+                        material.metallic = metallic;
+                        break;
+                    default:
+                        throw new Error(`Setting metallic for material of instance "${materialCls}" not implemented`);
+                }
+            }
+        }));
+        this.setParameterObserver(exports.LegacyParameter.Paintable, ({ newValue, materials }) => __awaiter(this, void 0, void 0, function* () {
+            (0, paintable_helper_1.paintableParameterObserver)(newValue, materials, this.viewer.scene);
+        }));
+        // texture parameter use a more generic approach (`channel`.`parameter`) and are therefore coded in a dedicated file
+        (0, texture_parameter_helper_1.createBuiltInTextureParameter)(this, this.viewer.scene);
+    }
+    /**
+     * Change parameter value in array of existing parameter entries or create a new entry
+     *
+     * @returns "true" if parameter has changed or wasn't available before
+     */
+    _addParameterValue(subject, parameterName, value) {
+        const existingEntry = this._getEntry(subject, parameterName);
+        if ((existingEntry === null || existingEntry === void 0 ? void 0 : existingEntry.value) === value) {
+            return false;
+        }
+        if (existingEntry) {
+            existingEntry.oldValue = existingEntry.value;
+            existingEntry.value = value;
+        }
+        else {
+            this._parameterEntries.push({ subject, parameterName, value, oldValue: undefined });
+        }
+        return true;
+    }
+    /**
+     * Call parameter observer of desired parameter which usually apply the new values to the scene.
+     *
+     * @param assetContainer Asset container in which to look for the paramter entries subjects (e.g. the nodes and
+     *                       materials to which the parameter values should be applied to).\
+     *                       Defaults to `viewer.scene`.
+     */
+    _applyParameterValues(parameterEntries, assetContainer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tagParamEntries = parameterEntries.filter(entry => isTagParameterSubject(entry.subject));
+            const nonTagParamEntries = parameterEntries.filter(entry => !isTagParameterSubject(entry.subject));
+            for (const entry of tagParamEntries) {
+                yield this._applyParameterValue(entry.subject, entry.parameterName, assetContainer);
+            }
+            for (const entry of nonTagParamEntries) {
+                yield this._applyParameterValue(entry.subject, entry.parameterName, assetContainer);
+            }
+        });
+    }
+    /**
+     * Call parameter observer of desired parameter
+     *
+     * @param assetContainer Optionally add an "asset container", which actually represents a model in the
+     * {@link ModelManager}. Viewer scene is used if left empty.
+     */
+    _applyParameterValue(subject, parameterName, assetContainer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const parameterEntry = this._getEntry(subject, parameterName);
+            const observer = this._parameterObserver[parameterName];
+            if (!parameterEntry || !observer) {
+                return;
+            }
+            const nodes = this._getAffectedNodes(subject, assetContainer);
+            const materials = this._getAffectedMaterials(subject, assetContainer);
+            yield observer({
+                subject,
+                newValue: parameterEntry.value,
+                oldValue: parameterEntry.oldValue,
+                nodes,
+                materials,
+            });
+        });
+    }
+    _getAffectedMaterials(subject, assetContainer) {
+        assetContainer = assetContainer !== null && assetContainer !== void 0 ? assetContainer : this.viewer.scene;
+        let materials = [];
+        // materials have priority over tags
+        if (isMaterialParameterSubject(subject)) {
+            materials = assetContainer.materials.filter(material => material.name === subject.materialName);
+            if (materials.length > 1) {
+                console.warn(`Multiple materials for material name "${subject.materialName}" have been found`);
+            }
+        }
+        else if (isTagParameterSubject(subject)) {
+            materials = assetContainer.materials.filter(material => (0, tags_helper_1.hasTag)(material, subject.tagName));
+        }
+        return materials;
+    }
+    _getAffectedNodes(subject, assetContainer) {
+        assetContainer = assetContainer !== null && assetContainer !== void 0 ? assetContainer : this.viewer.scene;
+        const allNodes = [...assetContainer.meshes, ...assetContainer.transformNodes];
+        let nodes = [];
+        // nodes have priority over tags
+        if (isNodeParameterSubject(subject)) {
+            nodes = allNodes.filter(node => node.name === subject.nodeName);
+            if (nodes.length > 1) {
+                console.warn(`Multiple nodes for node name "${subject.nodeName}" have been found`);
+            }
+        }
+        else if (isTagParameterSubject(subject)) {
+            nodes = allNodes.filter(node => (0, tags_helper_1.hasTag)(node, subject.tagName));
+        }
+        return nodes;
+    }
+    _getEntry(subject, parameterName) {
+        const entriesOfSubject = this._getEntriesOfSubject(subject);
+        const entry = entriesOfSubject.find(entry => entry.parameterName === parameterName);
+        return entry;
+    }
+    _getEntriesOfSubject(subject) {
+        const entries = this._parameterEntries.filter(entry => {
+            const nodeNameMatches = isNodeParameterSubject(entry.subject) &&
+                isNodeParameterSubject(subject) &&
+                entry.subject.nodeName === subject.nodeName;
+            const materialNameMatches = isMaterialParameterSubject(entry.subject) &&
+                isMaterialParameterSubject(subject) &&
+                entry.subject.materialName === subject.materialName;
+            const tagNameMatches = isTagParameterSubject(entry.subject) &&
+                isTagParameterSubject(subject) &&
+                entry.subject.tagName === subject.tagName;
+            return nodeNameMatches || materialNameMatches || tagNameMatches;
+        });
+        return entries;
+    }
+}
+exports.ParameterManager = ParameterManager;
 //# sourceMappingURL=parameter-manager.js.map