@combeenation/3d-viewer 19.1.0 → 20.0.0-alpha1

package/dist/lib-cjs/manager/parameter-manager.d.ts

@@ -1,5 +1,5 @@
 import { Color3, IAssetContainer, Material, PBRMaterial, TransformNode, Vector3, Viewer } from '../index';
-import { BuiltInTextureParameterKeys, ParameterTextureChannelsKeys } from '../internal/texture-parameter-helper';
+import { BuiltInTextureParameterKeys, ParameterTextureChannelsKeys } from '../internal/parameter/texture-parameter-helper';
 /**
  * Parameters with a built in observer implementation
  */
@@ -25,12 +25,13 @@ export declare const BuiltInParameter: {
 export declare const LegacyParameter: {
     Paintable: string;
 };
+export declare type ParameterName = string;
 export declare type MorphTargetParameterValue = {
     name: string;
     value: number;
 };
-export declare type ParameterName = string;
-export declare type ParameterValue = string | number | boolean | Vector3 | Color3 | MorphTargetParameterValue;
+export declare type ParameterValue = string | number | boolean | Vector3 | Color3 | MorphTargetParameterValue[];
+export declare type InputParameterValue = Exclude<ParameterValue, MorphTargetParameterValue[]> | MorphTargetParameterValue;
 export declare type TagParameterSubject = {
     tagName: string;
     nodeName?: never;
@@ -65,8 +66,12 @@ export declare type ParameterSubject = TagParameterSubject | NodeParameterSubjec
  */
 export declare type ParameterValues = (ParameterSubject & {
     parameterName: ParameterName;
-    value: ParameterValue;
+    value: InputParameterValue;
+    options?: ParameterOptions;
 })[];
+export declare type ParameterOptions = {
+    animationTimeMs?: number;
+};
 /**
  * Definition of callback function for parameter change
  */
@@ -81,15 +86,18 @@ export declare type ParameterObserverPayload = {
     materials: Material[];
     newValue: ParameterValue;
     oldValue: ParameterValue | undefined;
+    options?: ParameterOptions;
 };
 declare type ParameterEntry = {
     subject: ParameterSubject;
     parameterName: ParameterName;
     value: ParameterValue;
     oldValue: ParameterValue | undefined;
+    options?: ParameterOptions;
 };
 export declare class ParameterManager {
     protected viewer: Viewer;
+    static readonly PARAMETER_ANIMATION_NAME = "$parameterAnimation";
     /**
      * Parses and converts input to a boolean value, valid values are:
      * - true / false
@@ -119,7 +127,7 @@ export declare class ParameterManager {
      * Passing a Color3 object directly is also valid.
      */
     static parseColor(value: ParameterValue): Color3;
-    static parseMorphTarget(value: ParameterValue): MorphTargetParameterValue;
+    static parseMorphTargets(value: ParameterValue): MorphTargetParameterValue[];
     protected _parameterEntries: ParameterEntry[];
     protected _parameterObserver: {
         [parameterName: ParameterName]: ParameterObserver;
@@ -131,13 +139,13 @@ export declare class ParameterManager {
      *
      * @returns "true" if parameter value has changed
      */
-    setNodeParameterValue(nodeName: string, parameterName: ParameterName, value: ParameterValue): Promise<boolean>;
+    setNodeParameterValue(nodeName: string, parameterName: ParameterName, value: InputParameterValue, options?: ParameterOptions): Promise<boolean>;
     /**
      * 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: string, parameterName: ParameterName, value: ParameterValue): Promise<boolean>;
+    setMaterialParameterValue(materialName: string, parameterName: ParameterName, value: InputParameterValue, options?: ParameterOptions): Promise<boolean>;
     /**
      * 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
@@ -145,7 +153,7 @@ export declare class ParameterManager {
      *
      * @returns "true" if parameter value has changed
      */
-    setTagParameterValue(tagName: string, parameterName: ParameterName, value: ParameterValue): Promise<boolean>;
+    setTagParameterValue(tagName: string, parameterName: ParameterName, value: InputParameterValue, options?: ParameterOptions): Promise<boolean>;
     /**
      * Set multiple parameter values simultaniously.\
      * Tag parameters are applied before node and material parameters, node and materials are more specific and should
@@ -190,6 +198,21 @@ export declare class ParameterManager {
      * @internal
      */
     applyTextureSettingsParameter(material: PBRMaterial, channel: ParameterTextureChannelsKeys): Promise<void>;
+    /**
+     * @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: TransformNode, parameterName: string): ParameterValue | undefined;
+    /**
+     * @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: Material, parameterName: string): ParameterValue | undefined;
     /**
      * Retrieves visibility state of node, considering pending parameter values and node hierarchy.\
      * `node.isEnabled()` alone is insufficient here, as visibility observers for the desired node or one of it's parents
@@ -198,6 +221,11 @@ export declare class ParameterManager {
      * @internal
      */
     getNestedVisibilityParameterValueOfNode(node: TransformNode): boolean;
+    /**
+     * Converts the input parameter value type to the actual internally used parameter type.\
+     * ATM this is required for making morph target parameters of a specific node mergeable.
+     */
+    protected _prepareInputValue(inputValue: InputParameterValue): ParameterValue;
     /**
      * Parameter observer implementation of default parameters
      */
@@ -207,7 +235,7 @@ export declare class ParameterManager {
      *
      * @returns "true" if parameter has changed or wasn't available before
      */
-    protected _addParameterValue(subject: ParameterSubject, parameterName: ParameterName, value: ParameterValue): boolean;
+    protected _addParameterValue(subject: ParameterSubject, parameterName: ParameterName, value: ParameterValue, options?: ParameterOptions): boolean;
     /**
      * Call parameter observer of desired parameter which usually apply the new values to the scene.
      *
@@ -227,16 +255,5 @@ export declare class ParameterManager {
     protected _getAffectedNodes(subject: ParameterSubject, assetContainer?: IAssetContainer): TransformNode[];
     protected _getEntry(subject: ParameterSubject, parameterName: ParameterName): ParameterEntry | undefined;
     protected _getEntriesOfSubject(subject: ParameterSubject): ParameterEntry[];
-    /**
-     * @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.
-     */
-    protected _getParameterValueOfNode(node: TransformNode, parameterName: string): ParameterValue | undefined;
-    /**
-     * @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}
-     */
-    protected _getParameterValueOfMaterial(material: Material, parameterName: string): ParameterValue | undefined;
 }
 export {};

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

@@ -11,10 +11,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 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 paintable_parameter_helper_1 = require("../internal/parameter/paintable-parameter-helper");
+const parameter_helper_1 = require("../internal/parameter/parameter-helper");
+const texture_parameter_helper_1 = require("../internal/parameter/texture-parameter-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
@@ -41,6 +41,8 @@ exports.BuiltInParameter = {
 exports.LegacyParameter = {
     Paintable: 'paintable',
 };
+const isMorphTargetParameterValue = (value) => (0, lodash_es_1.isObject)(value) && 'name' in value && (0, lodash_es_1.isString)(value.name) && 'value' in value && (0, lodash_es_1.isNumber)(value.value);
+const isMorphTargetsParameterValue = (value) => (0, lodash_es_1.isArray)(value) && value.every(mT => isMorphTargetParameterValue(mT));
 const isTagParameterSubject = (subject) => 'tagName' in subject && !!subject.tagName;
 const isNodeParameterSubject = (subject) => 'nodeName' in subject && !!subject.nodeName;
 const isMaterialParameterSubject = (subject) => 'materialName' in subject && !!subject.materialName;
@@ -157,7 +159,7 @@ class ParameterManager {
             message: `Unable to parse "${value}" to a color: expected "#rrggbb", "(r,g,b)" or any human readable (e.g. Red) property implemented in Color3`,
         });
     }
-    static parseMorphTarget(value) {
+    static parseMorphTargets(value) {
         let objValue;
         if ((0, lodash_es_1.isString)(value)) {
             try {
@@ -173,8 +175,8 @@ class ParameterManager {
         else {
             objValue = value;
         }
-        if ((0, lodash_es_1.isString)(objValue.name) && (0, lodash_es_1.isNumber)(objValue.value)) {
-            return { name: objValue.name, value: objValue.value };
+        if (isMorphTargetsParameterValue(objValue)) {
+            return objValue.map(mT => ({ name: mT.name, value: mT.value }));
         }
         else {
             throw new index_1.ViewerError({
@@ -188,9 +190,10 @@ class ParameterManager {
      *
      * @returns "true" if parameter value has changed
      */
-    setNodeParameterValue(nodeName, parameterName, value) {
+    setNodeParameterValue(nodeName, parameterName, value, options) {
         return __awaiter(this, void 0, void 0, function* () {
-            const valueChanged = this._addParameterValue({ nodeName }, parameterName, value);
+            const internalValue = this._prepareInputValue(value);
+            const valueChanged = this._addParameterValue({ nodeName }, parameterName, internalValue, options);
             if (valueChanged) {
                 yield this._applyParameterValue({ nodeName }, parameterName);
             }
@@ -202,9 +205,10 @@ class ParameterManager {
      *
      * @returns "true" if parameter value has changed
      */
-    setMaterialParameterValue(materialName, parameterName, value) {
+    setMaterialParameterValue(materialName, parameterName, value, options) {
         return __awaiter(this, void 0, void 0, function* () {
-            const valueChanged = this._addParameterValue({ materialName }, parameterName, value);
+            const internalValue = this._prepareInputValue(value);
+            const valueChanged = this._addParameterValue({ materialName }, parameterName, internalValue, options);
             if (valueChanged) {
                 yield this._applyParameterValue({ materialName }, parameterName);
             }
@@ -218,9 +222,10 @@ class ParameterManager {
      *
      * @returns "true" if parameter value has changed
      */
-    setTagParameterValue(tagName, parameterName, value) {
+    setTagParameterValue(tagName, parameterName, value, options) {
         return __awaiter(this, void 0, void 0, function* () {
-            const valueChanged = this._addParameterValue({ tagName }, parameterName, value);
+            const internalValue = this._prepareInputValue(value);
+            const valueChanged = this._addParameterValue({ tagName }, parameterName, internalValue, options);
             if (valueChanged) {
                 yield this._applyParameterValue({ tagName }, parameterName);
             }
@@ -242,13 +247,24 @@ class ParameterManager {
                     : isMaterialParameterSubject(valueEntry)
                         ? { materialName: valueEntry.materialName }
                         : { tagName: valueEntry.tagName };
-                return { subject, parameterName: valueEntry.parameterName, value: valueEntry.value, oldValue: undefined };
+                const value = this._prepareInputValue(valueEntry.value);
+                return {
+                    subject,
+                    parameterName: valueEntry.parameterName,
+                    value,
+                    oldValue: undefined,
+                    options: valueEntry.options,
+                };
             });
-            const changedParameterEntries = parameterEntries.filter(paramEntry => this._addParameterValue(paramEntry.subject, paramEntry.parameterName, paramEntry.value));
+            const changedParameterEntries = parameterEntries.filter(({ subject, parameterName, value, options }) => this._addParameterValue(subject, parameterName, value, options));
             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 });
+                const value = isMorphTargetsParameterValue(paramEntry.value)
+                    ? // we can be sure that only one morph target was given on the input
+                        paramEntry.value[0]
+                    : paramEntry.value;
+                return Object.assign(Object.assign({}, paramEntry.subject), { parameterName: paramEntry.parameterName, value });
             });
             return changedParameterValues;
         });
@@ -340,6 +356,46 @@ class ParameterManager {
             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.getTagsAsStrArr)(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.getTagsAsStrArr)(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;
+    }
     /**
      * Retrieves visibility state of node, considering pending parameter values and node hierarchy.\
      * `node.isEnabled()` alone is insufficient here, as visibility observers for the desired node or one of it's parents
@@ -351,7 +407,7 @@ class ParameterManager {
         let curNode = node;
         let visibleByParameter = undefined;
         while (curNode && visibleByParameter !== false) {
-            const curNodeVisibleByParameter = this._getParameterValueOfNode(curNode, exports.BuiltInParameter.Visible);
+            const curNodeVisibleByParameter = this.getParameterValueOfNode(curNode, exports.BuiltInParameter.Visible);
             if (curNodeVisibleByParameter !== undefined) {
                 visibleByParameter = curNodeVisibleByParameter;
             }
@@ -362,175 +418,58 @@ class ParameterManager {
         return visible;
     }
     /**
-     * Parameter observer implementation of default parameters
+     * Converts the input parameter value type to the actual internally used parameter type.\
+     * ATM this is required for making morph target parameters of a specific node mergeable.
      */
-    _addBuiltInParameterObservers() {
-        this.setParameterObserver(exports.BuiltInParameter.Visible, ({ nodes, newValue }) => __awaiter(this, void 0, void 0, function* () {
-            const visible = ParameterManager.parseBoolean(newValue);
-            const observerProms = nodes.map((node) => __awaiter(this, void 0, void 0, function* () {
-                const visibleNested = this.getNestedVisibilityParameterValueOfNode(node);
-                if (visibleNested) {
-                    // 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)];
-                    const setMaterialProms = activatedNodes.map((an) => __awaiter(this, void 0, void 0, function* () {
-                        const anVisibleNested = this.getNestedVisibilityParameterValueOfNode(an);
-                        const anDeferredMaterial = (0, metadata_helper_1.getInternalMetadataValue)(an, 'deferredMaterial');
-                        const anMaterialParamValue = this._getParameterValueOfNode(an, exports.BuiltInParameter.Material);
-                        // get latest requested material, either from (new) parameter value or from deferred material
-                        const anRequestedMaterial = anMaterialParamValue !== null && anMaterialParamValue !== void 0 ? anMaterialParamValue : anDeferredMaterial;
-                        // material observer might have been executed before visibility observer
-                        // => skip the material application in this case, as if it would be done twice
-                        const anMaterialToBeSet = (0, metadata_helper_1.getInternalMetadataValue)(an, 'materialToBeSet');
-                        if (anVisibleNested && anRequestedMaterial && !anMaterialToBeSet) {
-                            yield this.viewer.materialManager.setMaterialOnMesh(anRequestedMaterial, 
-                            // this cast is fine, as deferred material can only be set on meshes
-                            an);
-                        }
-                    }));
-                    yield Promise.all(setMaterialProms);
-                }
-                // set enabled state anyway
-                node.setEnabled(visible);
-            }));
-            yield Promise.all(observerProms);
-        }));
-        this.setParameterObserver(exports.BuiltInParameter.Material, ({ nodes, newValue }) => __awaiter(this, void 0, void 0, function* () {
-            const material = ParameterManager.parseString(newValue);
-            const observerProms = nodes.map((node) => __awaiter(this, void 0, void 0, function* () {
-                if (!(node instanceof index_1.AbstractMesh)) {
-                    throw new index_1.ViewerError({
-                        id: index_1.ViewerErrorIds.InvalidParameterSubject,
-                        message: `Material can't be set, as the target node "${node.name}" is not a mesh`,
-                    });
-                }
-                // only set material if the mesh is visible, or gets visible by the parameter update
-                const visible = this.getNestedVisibilityParameterValueOfNode(node);
-                if (visible) {
-                    // visibility observer might have been executed before material observer
-                    // => skip the material application in this case, as if it would be done twice
-                    const anMaterialToBeSet = (0, metadata_helper_1.getInternalMetadataValue)(node, 'materialToBeSet');
-                    if (!anMaterialToBeSet) {
-                        yield this.viewer.materialManager.setMaterialOnMesh(material, node);
-                    }
-                }
-                else {
-                    (0, metadata_helper_1.setInternalMetadataValue)(node, 'deferredMaterial', material);
-                }
-            }));
-            yield Promise.all(observerProms);
-        }));
-        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 index_1.ViewerError({
-                            id: index_1.ViewerErrorIds.InvalidParameterSubject,
-                            message: `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 index_1.ViewerError({
-                            id: index_1.ViewerErrorIds.InvalidParameterSubject,
-                            message: `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 index_1.ViewerError({
-                            id: index_1.ViewerErrorIds.InvalidParameterSubject,
-                            message: `Setting metallic for material of instance "${materialCls}" not implemented`,
-                        });
-                }
-            }
-        }));
-        this.setParameterObserver(exports.BuiltInParameter.Influence, ({ nodes, newValue }) => __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const morphTargetValue = ParameterManager.parseMorphTarget(newValue);
-            for (const node of nodes) {
-                const target = node instanceof index_1.AbstractMesh && ((_a = node.morphTargetManager) === null || _a === void 0 ? void 0 : _a.getTargetByName(morphTargetValue.name));
-                if (target) {
-                    target.influence = morphTargetValue.value;
-                }
-                else {
-                    throw new index_1.ViewerError({
-                        id: index_1.ViewerErrorIds.InvalidParameterSubject,
-                        message: `Morph target couldn't be found, node: ${node.name} / morph target: ${morphTargetValue.name}`,
-                    });
+    _prepareInputValue(inputValue) {
+        if (isMorphTargetParameterValue(inputValue)) {
+            return [inputValue];
+        }
+        else if ((0, lodash_es_1.isString)(inputValue)) {
+            try {
+                const objValue = JSON.parse(inputValue);
+                if (isMorphTargetParameterValue(objValue)) {
+                    return [objValue];
                 }
             }
-        }));
-        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
+            catch (e) { }
+        }
+        return inputValue;
+    }
+    /**
+     * Parameter observer implementation of default parameters
+     */
+    _addBuiltInParameterObservers() {
+        (0, parameter_helper_1.createBuiltInParameter)(this, this.viewer.materialManager);
         (0, texture_parameter_helper_1.createBuiltInTextureParameter)(this, this.viewer.scene);
+        (0, paintable_parameter_helper_1.createPaintableParameter)(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) {
+    _addParameterValue(subject, parameterName, value, options) {
         const existingEntry = this._getEntry(subject, parameterName);
-        if ((existingEntry === null || existingEntry === void 0 ? void 0 : existingEntry.value) === value) {
+        let mergedValue = value;
+        if (existingEntry && isMorphTargetsParameterValue(existingEntry.value) && isMorphTargetsParameterValue(value)) {
+            // morph target values have to be merged instead of completely replaced
+            const map = new Map(existingEntry.value.map(e => [e.name, e]));
+            for (const item of value) {
+                map.set(item.name, item);
+            }
+            mergedValue = Array.from(map.values());
+        }
+        if (JSON.stringify(existingEntry === null || existingEntry === void 0 ? void 0 : existingEntry.value) === JSON.stringify(mergedValue)) {
             return false;
         }
         if (existingEntry) {
             existingEntry.oldValue = existingEntry.value;
-            existingEntry.value = value;
+            existingEntry.value = mergedValue;
+            existingEntry.options = options;
         }
         else {
-            this._parameterEntries.push({ subject, parameterName, value, oldValue: undefined });
+            this._parameterEntries.push({ subject, parameterName, value: mergedValue, oldValue: undefined, options });
         }
         return true;
     }
@@ -572,6 +511,7 @@ class ParameterManager {
                 oldValue: parameterEntry.oldValue,
                 nodes,
                 materials,
+                options: parameterEntry.options,
             });
         });
     }
@@ -626,42 +566,7 @@ class ParameterManager {
         });
         return entries;
     }
-    /**
-     * @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.
-     */
-    _getParameterValueOfNode(node, parameterName) {
-        const nodeParamValue = this.getParameterValue({ nodeName: node.name }, parameterName);
-        if (nodeParamValue !== undefined) {
-            return nodeParamValue;
-        }
-        const tags = (0, tags_helper_1.getTagsAsStrArr)(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}
-     */
-    _getParameterValueOfMaterial(material, parameterName) {
-        const materialParamValue = this.getParameterValue({ materialName: material.name }, parameterName);
-        if (materialParamValue !== undefined) {
-            return materialParamValue;
-        }
-        const tags = (0, tags_helper_1.getTagsAsStrArr)(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;
-    }
 }
 exports.ParameterManager = ParameterManager;
+ParameterManager.PARAMETER_ANIMATION_NAME = '$parameterAnimation';
 //# sourceMappingURL=parameter-manager.js.map