@combeenation/3d-viewer 8.0.0 → 9.0.0

package/src/api/manager/tagManager.ts

@@ -4,18 +4,16 @@ import { Parameter } from '../classes/parameter';
 import { Viewer } from '../classes/viewer';
 import {
   assertMeshCapability,
-  cloneTransformNodeMaterial,
-  injectNodeMetadata,
+  drawPaintableOnMaterial,
+  injectMetadata,
   mapTags,
   setMaterial,
-  setMaterialColor,
-  setMaterialMetallness,
-  setMaterialRoughness,
 } from '../util/babylonHelper';
-import { AbstractMesh } from '@babylonjs/core/Meshes/abstractMesh';
+import { createImageFromImgSrc, createImageFromSvg } from '../util/resourceHelper';
 import { TransformNode } from '@babylonjs/core/Meshes/transformNode';
 import { Tags } from '@babylonjs/core/Misc/tags';
-import { clone, get, has, merge, uniq } from 'lodash-es';
+import isSvg from 'is-svg';
+import { clone, get, merge, uniq } from 'lodash-es';
 
 export class TagManager {
   public readonly parameters: TagManagerParameterBag = new FuzzyMap();
@@ -37,7 +35,7 @@ export class TagManager {
     tagName: string,
     parameterName: string,
     value: ParameterValue
-  ): Promise<ParameterObserverResult> {
+  ): Promise<TagManagerParameterObserverResultBag> {
     return await this.handleParameter({ tagName: tagName }, parameterName, value);
   }
 
@@ -49,22 +47,35 @@ export class TagManager {
     nodeName: string,
     parameterName: string,
     value: ParameterValue
-  ): Promise<ParameterObserverResult> {
+  ): Promise<TagManagerParameterObserverResultBag> {
     return await this.handleParameter({ nodeName: nodeName }, parameterName, value);
   }
 
+  /**
+   * Calls the {@link ParameterObserver} for given {@link Parameter} and applies the {@link ParameterValue} on all
+   * materials with given materialName.
+   */
+  public async setMaterialParameterValue(
+    materialName: string,
+    parameterName: string,
+    value: ParameterValue
+  ): Promise<TagManagerParameterObserverResultBag> {
+    return await this.handleParameter({ materialName: materialName }, parameterName, value);
+  }
+
   /**
    * Splits the passed {@link TagManagerParameterValue}s into individual values and calls all {@link ParameterObserver}s
    * of all {@link Parameter}s with the respective {@link TagManagerSubject} and {@link ParameterValue}. The result is a
-   * map of passed {@link TagManagerParameterValue}s and the associated {@link ParameterObserverResult} of the
+   * map of passed {@link TagManagerParameterValue}s and the associated {@link TagManagerParameterObserverResult} of the
    * {@link ParameterObserver}.
    */
   public async setParameterValues(
     values: TagManagerParameterValue[]
-  ): Promise<Map<TagManagerParameterValue, ParameterObserverResult>> {
-    const observerResultMap: Map<TagManagerParameterValue, ParameterObserverResult> = new Map();
-    const tagPromises: Promise<ParameterObserverResult>[] = [];
-    const nodePromises: Promise<ParameterObserverResult>[] = [];
+  ): Promise<Map<TagManagerParameterValue, TagManagerParameterObserverResultBag>> {
+    const observerResultMap: Map<TagManagerParameterValue, TagManagerParameterObserverResultBag> = new Map();
+    const tagPromises: Promise<TagManagerParameterObserverResultBag>[] = [];
+    const nodePromises: Promise<TagManagerParameterObserverResultBag>[] = [];
+    const materialPromises: Promise<TagManagerParameterObserverResultBag>[] = [];
     for (const value of values) {
       const subject: TagManagerSubject = {};
       if (value.tagName) {
@@ -73,6 +84,9 @@ export class TagManager {
       if (value.nodeName) {
         subject.nodeName = value.nodeName;
       }
+      if (value.materialName) {
+        subject.materialName = value.materialName;
+      }
       const observerResultPromise = this.handleParameter(subject, value.parameterName, value.value);
       observerResultPromise.then(result => observerResultMap.set(value, result));
       if (value.tagName) {
@@ -81,32 +95,37 @@ export class TagManager {
       if (value.nodeName) {
         nodePromises.push(observerResultPromise);
       }
+      if (value.materialName) {
+        materialPromises.push(observerResultPromise);
+      }
     }
     await Promise.all(tagPromises);
     await Promise.all(nodePromises);
+    await Promise.all(materialPromises);
     return observerResultMap;
   }
 
   /**
    * Gets a list of {@link TagManagerSubject}s that are present in both the state of the {@link TagManager}'s
-   * {@link parameters} and the given node.
+   * {@link parameters} and the given object.
    */
-  public getSubjectsFor(node: TransformNode): TagManagerSubject[] {
+  public getSubjectsFor(object: TransformNode | Material): TagManagerSubject[] {
     return [...this.parameters.keys()].filter(
       subject =>
-        (subject.tagName && Tags.MatchesQuery(node, subject.tagName)) ||
-        (subject.nodeName && node.name === subject.nodeName)
+        (subject.tagName && Tags.MatchesQuery(object, subject.tagName)) ||
+        (subject.nodeName && object.name === subject.nodeName) ||
+        (subject.materialName && object.name === subject.materialName)
     );
   }
 
   /**
    * Gets a list of {@link TagManagerSubject}s that are present in both the state of the {@link TagManager}'s
-   * {@link parameters} and the given nodes.
+   * {@link parameters} and the given objects.
    */
-  public getApplicableSubjectsFor(nodes: TransformNode[]): TagManagerSubject[] {
+  public getApplicableSubjectsFor(objects: (TransformNode | Material)[]): TagManagerSubject[] {
     let applicableSubjects: TagManagerSubject[] = [];
-    for (const node of nodes) {
-      const subjects = this.getSubjectsFor(node);
+    for (const object of objects) {
+      const subjects = this.getSubjectsFor(object);
       applicableSubjects = [...applicableSubjects, ...subjects];
     }
     return uniq(applicableSubjects);
@@ -117,12 +136,12 @@ export class TagManager {
    */
   public async applyExistingParameterValuesFor(
     subjects: TagManagerSubject[]
-  ): Promise<Map<TagManagerSubject, ParameterObserverResult>> {
-    const observerResultMap: Map<TagManagerSubject, ParameterObserverResult> = new Map();
-    let tagPromises: Promise<ParameterObserverResult>[] = [];
-    let nodePromises: Promise<ParameterObserverResult>[] = [];
+  ): Promise<Map<TagManagerSubject, TagManagerParameterObserverResultBag>> {
+    const observerResultMap: Map<TagManagerSubject, TagManagerParameterObserverResultBag> = new Map();
+    let tagPromises: Promise<TagManagerParameterObserverResultBag>[] = [];
+    let nodePromises: Promise<TagManagerParameterObserverResultBag>[] = [];
+    let materialPromises: Promise<TagManagerParameterObserverResultBag>[] = [];
     for (const subject of subjects) {
-      this.clearAppliedNodeMetadataParameters(this.getNodesBySubject(subject));
       const observerResultPromises = this.handleParameterBag(subject, this.parameters.get(subject)!);
       for (const observerResultPromise of observerResultPromises) {
         observerResultPromise.then(result => observerResultMap.set(subject, result));
@@ -133,9 +152,13 @@ export class TagManager {
       if (subject.nodeName) {
         nodePromises = [...nodePromises, ...observerResultPromises];
       }
+      if (subject.materialName) {
+        materialPromises = [...materialPromises, ...observerResultPromises];
+      }
     }
     await Promise.all(tagPromises);
     await Promise.all(nodePromises);
+    await Promise.all(materialPromises);
     return observerResultMap;
   }
 
@@ -144,15 +167,15 @@ export class TagManager {
    * {@link TagManager}'s {@link parameters} are applied to all given nodes.
    */
   public async applyExistingParameterValuesTo(
-    nodes: TransformNode[]
-  ): Promise<Map<TagManagerSubject, ParameterObserverResult>> {
-    return this.applyExistingParameterValuesFor(this.getApplicableSubjectsFor(nodes));
+    objects: (TransformNode | Material)[]
+  ): Promise<Map<TagManagerSubject, TagManagerParameterObserverResultBag>> {
+    return this.applyExistingParameterValuesFor(this.getApplicableSubjectsFor(objects));
   }
 
   /**
    * Applies all existing states of the {@link TagManager}'s {@link parameters} for all {@link TagManagerSubject}s.
    */
-  public async applyExistingParameterValues(): Promise<Map<TagManagerSubject, ParameterObserverResult>> {
+  public async applyExistingParameterValues(): Promise<Map<TagManagerSubject, TagManagerParameterObserverResultBag>> {
     return this.applyExistingParameterValuesFor([...this.parameters.keys()]);
   }
 
@@ -248,18 +271,46 @@ export class TagManager {
   }
 
   /**
-   * Registers observers that are called on every new node added to the Babylon.js scene. The observers ensure that each
-   * new node gets the state of the {@link TagManager}'s {@link parameters} applied.
+   * Gets all materials for given {@link TagManagerSubject} on the Babylon.js scene.
+   */
+  public getMaterialsBySubject(subject: TagManagerSubject, predicate?: (material: Material) => boolean): Material[] {
+    let materials: Material[] = [];
+    if (subject.tagName) {
+      materials = [...materials, ...this.viewer.scene.getMaterialByTags(subject.tagName, predicate)];
+    }
+    if (subject.materialName) {
+      materials = [...materials, this.viewer.scene.getMaterialByName(subject.materialName)].filter(
+        t => !!t && (!predicate || predicate(t))
+      ) as Material[];
+    }
+    return materials;
+  }
+
+  /**
+   * Registers observers that are called on every new object added to the Babylon.js scene.
+   * The observers ensure that each new object gets the state of the {@link TagManager}'s {@link parameters} applied.
    */
-  public registerNewTransformNodeObservers(scene: Scene) {
+  public registerNewObjectObservers(scene: Scene) {
+    // nodes and meshes
     const onNewTransformNodeAdded = (node: TransformNode) => {
-      if (node.name === Viewer.BOUNDING_BOX_NAME || !this.viewer.variantInstances.areAllDefinitionsCreated) {
-        // Avoid duplicate calls here. The parameter values are already applied when a variant instance has finished
-        // creating (see event listener in viewer for VARIANT_INSTANCE_CREATED). This callback should only trigger when
-        // a consumer "manually" clones a node.
+      /* NOTE:
+         Removed the check for created instances here since it is not guaranteed that all instances
+         created means that there is no scenario where new nodes should get TagManager parameters applied.
+         Instead, we check for the state to be enabled via the `onEnabledStateChangedObservable` below.
+       */
+      //if (node.name === Viewer.BOUNDING_BOX_NAME || !this.viewer.variantInstances.areAllDefinitionsCreated) {
+      if (node.name === Viewer.BOUNDING_BOX_NAME) {
         return;
       }
-      this.applyExistingParameterValuesTo([node]).then();
+      const onEnabledStateChangedObserver = node.onEnabledStateChangedObservable.add(async state => {
+        if (!state) {
+          // if the node is disabled, means ignoring also "ghost nodes"
+          return;
+        }
+        await this.applyExistingParameterValuesTo([node]);
+        node.onEnabledStateChangedObservable.remove(onEnabledStateChangedObserver);
+      });
+      node.onEnabledStateChangedObservable.makeObserverBottomPriority(onEnabledStateChangedObserver!);
     };
     scene.onNewTransformNodeAddedObservable.makeObserverBottomPriority(
       scene.onNewTransformNodeAddedObservable.add(onNewTransformNodeAdded)!
@@ -267,6 +318,21 @@ export class TagManager {
     scene.onNewMeshAddedObservable.makeObserverBottomPriority(
       scene.onNewMeshAddedObservable.add(onNewTransformNodeAdded)!
     );
+    // materials
+    const onNewMaterialAdded = (material: Material) => {
+      /* NOTE:
+				 We have to wait until a material is bound to a Mesh. In all other scenarios, the material
+				 is not "fully ready" or even empty (without working attributes/properties).
+			 */
+      const onMaterialBindObserver = material.onBindObservable.add(async abstractMesh => {
+        await this.applyExistingParameterValuesTo([material]);
+        material.onBindObservable.remove(onMaterialBindObserver);
+      });
+      material.onBindObservable.makeObserverBottomPriority(onMaterialBindObserver!);
+    };
+    scene.onNewMaterialAddedObservable.makeObserverBottomPriority(
+      scene.onNewMaterialAddedObservable.add(onNewMaterialAdded)!
+    );
   }
 
   /**
@@ -275,12 +341,7 @@ export class TagManager {
    */
   protected addParameterObservers(): TagManager {
     this.parameterObservers.set(Parameter.VISIBLE, async payload => {
-      let visible;
-      try {
-        visible = Parameter.parseBoolean(payload.newValue);
-      } catch (e) {
-        return false;
-      }
+      const visible = Parameter.parseBoolean(payload.newValue);
       if (visible === true) {
         for (const node of payload.nodes) {
           node.setEnabled(true);
@@ -317,57 +378,76 @@ export class TagManager {
       }
       return true;
     });
-    this.parameterObservers.set(Parameter.MATERIAL_COLOR, async payload => {
-      const parsedValue = Parameter.parseColor(payload.newValue);
-      for (const node of payload.nodes) {
-        assertMeshCapability(node, Parameter.MATERIAL_COLOR);
-        if (this.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: payload.oldValue } } }, false);
-          }
+    this.parameterObservers.set(Parameter.COLOR, async payload => {
+      const color = Parameter.parseColor(payload.newValue);
+      for (const material of payload.materials) {
+        const materialCls = material.getClassName();
+        switch (materialCls) {
+          case 'PBRMaterial':
+            (material as PBRMaterial).albedoColor = color.toLinearSpace();
+            break;
+          case 'StandardMaterial':
+            (material as StandardMaterial).diffuseColor = color;
+            break;
+          default:
+            throw new Error(`Setting color for material of instance "${materialCls}" not implemented (yet).`);
         }
-        setMaterialColor(node, parsedValue, false);
       }
       return true;
     });
-    this.parameterObservers.set(Parameter.MATERIAL_ROUGHNESS, async payload => {
-      const parsedValue = Parameter.parseNumber(payload.newValue);
-      for (const node of payload.nodes as AbstractMesh[]) {
-        assertMeshCapability(node, Parameter.MATERIAL_ROUGHNESS);
-        if (this.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: { color: payload.oldValue } } }, false);
-          }
+    this.parameterObservers.set(Parameter.ROUGHNESS, async payload => {
+      const roughness = Parameter.parseNumber(payload.newValue);
+      for (const material of payload.materials) {
+        const materialCls = material.getClassName();
+        switch (materialCls) {
+          case 'PBRMaterial':
+            (material as PBRMaterial).roughness = roughness;
+            break;
+          case 'StandardMaterial':
+            (material as StandardMaterial).roughness = roughness;
+            break;
+          default:
+            throw new Error(`Setting roughness for material of instance "${materialCls}" not implemented (yet).`);
         }
-        setMaterialRoughness(node, parsedValue, false);
       }
       return true;
     });
-    this.parameterObservers.set(Parameter.MATERIAL_METALLNESS, async payload => {
-      const parsedValue = Parameter.parseNumber(payload.newValue);
-      for (const node of payload.nodes as AbstractMesh[]) {
-        assertMeshCapability(node, Parameter.MATERIAL_METALLNESS);
-        if (this.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: { color: payload.oldValue } } }, false);
-          }
+    this.parameterObservers.set(Parameter.METALLIC, async payload => {
+      const metallic = Parameter.parseNumber(payload.newValue);
+      for (const material of payload.materials) {
+        const materialCls = material.getClassName();
+        switch (materialCls) {
+          case 'PBRMaterial':
+            (material as PBRMaterial).metallic = metallic;
+            break;
+          default:
+            throw new Error(`Setting metallic for material of instance "${materialCls}" not implemented (yet).`);
         }
-        setMaterialMetallness(node, parsedValue, false);
       }
       return true;
     });
+    this.parameterObservers.set(Parameter.PAINTABLE, async payload => {
+      const paintableValue: PaintableValue = Parameter.parsePaintableValue(payload.newValue);
+
+      // check if value is svg or image source, do the conversion accordingly
+      const srcIsSvg = isSvg(paintableValue.src);
+      if (!srcIsSvg && paintableValue.src.includes('<svg') && paintableValue.src.includes('</svg>')) {
+        // seems like the user tried to use a SVG string, as <svg> tags are used
+        // inform the user that this is not a valid SVG string
+        throw new Error(`Setting paintable value failed: "${paintableValue.src}" is no valid SVG string.`);
+      }
+
+      const imageSource: CanvasImageSource = srcIsSvg
+        ? await createImageFromSvg(paintableValue.src)
+        : await createImageFromImgSrc(paintableValue.src);
+
+      // apply image source on desired material(s)
+      for (const material of payload.materials) {
+        drawPaintableOnMaterial(material, imageSource, this.viewer.scene, paintableValue.options);
+      }
+
+      return true;
+    });
     return this;
   }
 
@@ -379,8 +459,8 @@ export class TagManager {
   protected handleParameterBag(
     subject: TagManagerSubject,
     parameters: ParameterBag
-  ): Promise<ParameterObserverResult>[] {
-    const observerPromises: Promise<ParameterObserverResult>[] = [];
+  ): Promise<TagManagerParameterObserverResultBag>[] {
+    const observerPromises: Promise<TagManagerParameterObserverResultBag>[] = [];
     for (const parameter in parameters) {
       observerPromises.push(this.handleParameter(subject, parameter, parameters[parameter]));
     }
@@ -397,36 +477,61 @@ export class TagManager {
     subject: TagManagerSubject,
     parameter: string,
     parameterValue: ParameterValue
-  ): Promise<ParameterObserverResult> {
+  ): Promise<TagManagerParameterObserverResultBag> {
     Parameter.assertParameter(Parameter.declarations, parameter, parameterValue);
-    if (!this.parameterObservers.has(parameter)) {
-      return Promise.resolve(false);
-    }
     const parameterBag = this.parameters.get(subject) || {};
     const oldValue = parameterBag[parameter];
-    if (oldValue === parameterValue) {
-      return Promise.resolve(false);
+    const parameterObserverResultBag: TagManagerParameterObserverResultBag = {
+      subject: subject,
+      parameter: parameter,
+      nodes: [],
+      materials: [],
+      oldValue: oldValue,
+      newValue: parameterValue,
+      parameterObserverResult: false,
+    };
+    if (!this.parameterObservers.has(parameter)) {
+      return Promise.resolve(parameterObserverResultBag);
     }
     this.parameters.set(subject, parameterBag);
     this.parameters.get(subject)![parameter] = parameterValue;
-    const nodes = this.getNodesBySubject(subject);
-    if (nodes.length === 0) {
-      return Promise.resolve(false);
+    // get objects by subject and filter nodes by state
+    const nodes = this.getNodesBySubject(subject).filter(
+      o => o.metadata?.tagManager?.parameters?.[parameter] !== parameterValue
+    );
+    const materials = this.getMaterialsBySubject(subject).filter(
+      o => o.metadata?.tagManager?.parameters?.[parameter] !== parameterValue
+    );
+    if (nodes.length === 0 && materials.length === 0) {
+      return Promise.resolve(parameterObserverResultBag);
     }
-    const observer = this.parameterObservers.get(parameter)!;
-    const result = await observer({ subject: subject, nodes: nodes, newValue: parameterValue, oldValue: oldValue });
-    if (result === false) {
-      // reset to old value if observer was not successful
-      this.parameters.get(subject)![parameter] = oldValue;
+    // store state in objects
+    for (const object of [...nodes, ...materials]) {
+      injectMetadata(object, { tagManager: { parameters: { [parameter]: parameterValue } } }, false);
     }
-    emitter.emit(Event.TAG_MANAGER_PARAMETER_COMMITTED, {
+
+    const observer = this.parameterObservers.get(parameter)!;
+    const result = await observer({
       subject: subject,
-      parameter: parameter,
       nodes: nodes,
-      oldValue: oldValue,
+      materials: materials,
       newValue: parameterValue,
-      result: result,
+      oldValue: oldValue,
     });
+
+    if (result === false) {
+      // reset to old value if observer was not successful
+      this.parameters.get(subject)![parameter] = oldValue;
+      // store old state in objects
+      for (const object of [...nodes, ...materials]) {
+        injectMetadata(object, { tagManager: { parameters: { [parameter]: oldValue } } }, false);
+      }
+    }
+    parameterObserverResultBag.nodes = nodes;
+    parameterObserverResultBag.materials = materials;
+    parameterObserverResultBag.parameterObserverResult = result;
+    emitter.emit(Event.TAG_MANAGER_PARAMETER_COMMITTED, parameterObserverResultBag);
+    return parameterObserverResultBag;
   }
 
   /**
@@ -441,17 +546,14 @@ export class TagManager {
       if (oldNode) {
         accNodeMapping[oldNode.name] = curNode.name;
       }
-
       return accNodeMapping;
     }, {} as TagMapping);
-
     for (const subject of this.parameters.keys()) {
       const isNode = subject.nodeName;
       const newName = isNode ? nodeMapping[subject.nodeName] : tagMapping[subject.tagName];
       if (!newName) {
         continue;
       }
-
       const newSubject = clone(subject);
       newSubject[isNode ? 'nodeName' : 'tagName'] = newName;
       const parameterBag = clone(this.parameters.get(subject)!);
@@ -459,19 +561,4 @@ export class TagManager {
       this.parameters.set(newSubject, parameterBag);
     }
   }
-
-  /**
-   * Clears the applied {@link ParameterBag} state of the node's metadata to ensure that observers trigger (once again).
-   * This is necessary e.g. after mapping tags when a nodeName subject shall override the parameterValue of a mapped
-   * tag.
-   * @protected
-   */
-  protected clearAppliedNodeMetadataParameters(nodes: TransformNode[]): void {
-    for (const node of nodes) {
-      if (!node.metadata?.tagManager?.parameters) {
-        continue;
-      }
-      node.metadata.tagManager.parameters = {};
-    }
-  }
 }

package/src/api/manager/variantInstanceManager.ts

@@ -120,15 +120,13 @@ export class VariantInstanceManager extends EventBroadcaster {
   public async create(
     dottedPath: DottedPathArgument,
     name?: string,
-    parameters?: ParameterBag,
-    tagManagerParameterValues?: TagManagerParameterValue[]
+    parameters?: ParameterBag
   ): Promise<VariantInstance> {
     const variant = DottedPath.create(dottedPath).path;
     const definition = {
       name: this.ensureUniqueName(name ? name : variant),
       variant: variant,
       parameters: parameters,
-      tagManagerParameterValues: tagManagerParameterValues,
     };
     return await this.createFromDefinition(definition);
   }
@@ -246,7 +244,10 @@ export class VariantInstanceManager extends EventBroadcaster {
     this.variantInstances.set(definition.name, variantInstanceClone);
     reportDuplicateNodeNames(duplicateNodeNames(this.viewer.scene.getNodes(), n => n instanceof TransformNode));
     this.viewer.tagManager.mapNodesAndTags(variantInstanceClone.variant.elementNodesFlat, tagMapping ?? {});
-    await this.viewer.tagManager.applyExistingParameterValuesTo(variantInstanceClone.variant.elementNodesFlat);
+    await this.viewer.tagManager.applyExistingParameterValuesTo([
+      ...variantInstanceClone.variant.elementNodesFlat,
+      ...variantInstanceClone.variant.elementAbstractMeshesFlat.map(n => n.material!).filter(m => !!m),
+    ]);
     variantInstance.broadcastEvent(Event.VARIANT_INSTANCE_CLONED, variantInstanceClone);
     return variantInstanceClone;
   }
@@ -285,10 +286,6 @@ export class VariantInstanceManager extends EventBroadcaster {
     const variant = await this.rootVariant.getDescendant(definition.variant);
     const variantInstance = await VariantInstance.createLiving(variant, definition.name, definition.parameters);
     this.variantInstances.set(definition.name, variantInstance);
-    // set tag manager parameter values if all definitions has been created.
-    if (definition.tagManagerParameterValues && this.areAllDefinitionsCreated) {
-      await this.viewer.tagManager.setParameterValues(definition.tagManagerParameterValues);
-    }
     this.broadcastEvent(Event.VARIANT_INSTANCE_CREATED, variantInstance);
     return variantInstance;
   }