@combeenation/3d-viewer 7.1.0 → 7.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@combeenation/3d-viewer",
-  "version": "7.1.0",
+  "version": "7.1.1",
   "description": "Combeenation 3D Viewer",
   "homepage": "https://github.com/Combeenation/3d-viewer#readme",
   "bugs": {

package/src/api/classes/viewer.ts

@@ -34,7 +34,7 @@ import { Mesh } from '@babylonjs/core/Meshes/mesh';
 import { ScreenshotTools } from '@babylonjs/core/Misc/screenshotTools';
 import { WebXRSessionManager } from '@babylonjs/core/XR/webXRSessionManager';
 import { Scene } from '@babylonjs/core/scene';
-import { isString } from 'lodash-es';
+import { isArray, isString } from 'lodash-es';
 
 /**
  * The main exposed object. This is the entry point into the application
@@ -46,6 +46,8 @@ import { isString } from 'lodash-es';
  * The class does nothing on its own and needs to {@link bootstrap}
  */
 export class Viewer extends EventBroadcaster {
+  public static readonly BOUNDING_BOX_NAME = '__bounding_box__';
+
   protected _scene: Scene | null = null;
 
   protected _animationManager: AnimationManager | null = null;
@@ -270,7 +272,7 @@ export class Viewer extends EventBroadcaster {
    * @emits {@link Event.BOOTSTRAP_START}
    * @emits {@link Event.BOOTSTRAP_END}
    */
-  public async bootstrap(tagManagerParameterValues: TagManagerParameterValue[]): Promise<Viewer> {
+  public async bootstrap(tagManagerParameterValues?: TagManagerParameterValue[]): Promise<Viewer> {
     this.broadcastEvent(Event.BOOTSTRAP_START, this);
     let indexJson;
     if (isString(this.structureJson)) {
@@ -299,7 +301,7 @@ export class Viewer extends EventBroadcaster {
         const setupJson = await loadJson<SetupJson>(indexJson.setup);
         indexJson.setup = setupJson;
       }
-      await this.createVariantInstances();
+      await this.createVariantInstances(tagManagerParameterValues);
     }
     this.broadcastEvent(Event.VARIANT_INSTANCES_READY, this);
     // create gltf export manager
@@ -308,10 +310,6 @@ export class Viewer extends EventBroadcaster {
     window.addEventListener('resize', debounce(this.resize.bind(this), 100));
     // wait until scene is completely ready
     await this.scene.whenReadyAsync();
-    // set tag manager values
-    if (tagManagerParameterValues) {
-      await this.tagManager.setParameterValues(tagManagerParameterValues);
-    }
     // event broadcasting
     this.broadcastEvent(Event.BOOTSTRAP_END, this);
     // render loop
@@ -462,13 +460,11 @@ export class Viewer extends EventBroadcaster {
       throw new Error('There are currently no meshes on the scene.');
     }
     this.scene.render(); // CB-6062: workaround for BoundingBox not respecting render loop
-    const bbName = '__bounding_box__';
-
     const { max, min } = this.scene.meshes
       .filter(mesh => {
         const isEnabled = mesh.isEnabled();
         // ignore the existing bounding box mesh for calculating the current one
-        const isNotBBoxMesh = bbName !== mesh.id;
+        const isNotBBoxMesh = Viewer.BOUNDING_BOX_NAME !== mesh.id;
         // ignore meshes with invalid bounding infos
         const hasValidBBoxInfo = mesh.getBoundingInfo().boundingSphere.radius > 0;
         // ignore excluded meshes
@@ -486,9 +482,9 @@ export class Viewer extends EventBroadcaster {
         { max: new Vector3(), min: new Vector3() }
       );
 
-    let boundingBox = this.scene.getMeshByName(bbName) as Mesh;
+    let boundingBox = this.scene.getMeshByName(Viewer.BOUNDING_BOX_NAME) as Mesh;
     if (!boundingBox) {
-      boundingBox = new Mesh(bbName, this.scene);
+      boundingBox = new Mesh(Viewer.BOUNDING_BOX_NAME, this.scene);
     }
     boundingBox.setBoundingInfo(new BoundingInfo(min, max));
     return boundingBox;
@@ -719,10 +715,15 @@ export class Viewer extends EventBroadcaster {
   /**
    * Batch creation of multiple {@link VariantInstance} objects with a {@link SetupJson} object passed
    */
-  protected async createVariantInstances(): Promise<VariantInstance[]> {
+  protected async createVariantInstances(
+    tagManagerParameterValues?: TagManagerParameterValue[]
+  ): Promise<VariantInstance[]> {
     const setupJson = SpecStorage.get<SetupJson>('setup');
     const instances: VariantInstance[] = [];
     for (const instanceDefinition of setupJson.instances) {
+      if (isArray(tagManagerParameterValues)) {
+        instanceDefinition.tagManagerParameterValues = tagManagerParameterValues;
+      }
       // don't create the instance right away if `lazy` is set, register it for later creation (on first usage) instead
       // however if the variant should be `visible` by default, `lazy` loading doesn't make sense and should therefore
       // be overruled by the `visible` flag
@@ -730,13 +731,13 @@ export class Viewer extends EventBroadcaster {
         this.variantInstances.register(instanceDefinition);
         continue;
       }
-      instances.push(
-        await this.variantInstances.create(
-          instanceDefinition.variant,
-          instanceDefinition.name,
-          instanceDefinition.parameters
-        )
+      const instance = await this.variantInstances.create(
+        instanceDefinition.variant,
+        instanceDefinition.name,
+        instanceDefinition.parameters,
+        instanceDefinition.tagManagerParameterValues
       );
+      instances.push(instance);
     }
     return instances;
   }

package/src/api/manager/gltfExportManager.ts

@@ -1,3 +1,4 @@
+import { Viewer } from '../classes/viewer';
 import { injectNodeMetadata } from '../util/babylonHelper';
 import { isMeshIncludedInExclusionList } from '../util/structureHelper';
 import { PBRMaterial } from '@babylonjs/core/Materials/PBR/pbrMaterial';
@@ -113,7 +114,7 @@ export class GltfExportManager {
         if (!node.isEnabled()) {
           return false;
         }
-        if ((node.name as string).startsWith('__bounding_box__')) {
+        if ((node.name as string).startsWith(Viewer.BOUNDING_BOX_NAME)) {
           return false;
         }
         if (excluded && node instanceof Mesh && isMeshIncludedInExclusionList(node, excluded)) {

package/src/api/manager/tagManager.ts

@@ -1,6 +1,7 @@
 import { Event, emitter } from '../classes/event';
 import { FuzzyMap } from '../classes/fuzzyMap';
 import { Parameter } from '../classes/parameter';
+import { Viewer } from '../classes/viewer';
 import {
   assertMeshCapability,
   cloneTransformNodeMaterial,
@@ -236,9 +237,14 @@ export class TagManager {
    * new node gets the state of the {@link TagManager}'s {@link parameters} applied.
    */
   public registerNewTransformNodeObservers(scene: Scene) {
-    const onNewTransformNodeAdded = async (node: TransformNode) => {
-      await this.viewer.scene.whenReadyAsync();
-      await this.applyExistingParameterValuesTo([node]);
+    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.
+        return;
+      }
+      this.applyExistingParameterValuesTo([node]).then();
     };
     scene.onNewTransformNodeAddedObservable.makeObserverBottomPriority(
       scene.onNewTransformNodeAddedObservable.add(onNewTransformNodeAdded)!

package/src/api/manager/variantInstanceManager.ts

@@ -43,18 +43,24 @@ export class VariantInstanceManager extends EventBroadcaster {
    * Gets all instances.
    */
   get all() {
-    const all: VariantInstance[] = [];
-    this.variantInstances.forEach(variantInstance => all.push(variantInstance));
-    return all;
+    return [...this.variantInstances.values()];
   }
 
   /**
    * Gets all instance definitions.
    */
   get allDefinitions() {
-    const all: VariantInstanceDefinition[] = [];
-    this.variantInstanceDefinitions.forEach(definition => all.push(definition));
-    return all;
+    return [...this.variantInstanceDefinitions.values()];
+  }
+
+  /**
+   * Gets whether all definitions have been created.
+   */
+  get areAllDefinitionsCreated(): boolean {
+    const createdDefinitions = this.allDefinitions.filter(
+      definition => this.all.filter(instance => instance.name === definition.name).length > 0
+    );
+    return this.allDefinitions.length === createdDefinitions.length;
   }
 
   /**
@@ -94,15 +100,15 @@ export class VariantInstanceManager extends EventBroadcaster {
     // 3) see if there's a definition of that name, create an instance from it and store the related promise
     if (this.variantInstanceDefinitions.has(name)) {
       const definition = this.variantInstanceDefinitions.get(name)!; // cannot be null
-      const vip = this.createFromDefinition(definition);
-      this.variantInstancePromises.set(name, vip);
+      const variantInstancePromise = this.createFromDefinition(definition);
+      this.variantInstancePromises.set(name, variantInstancePromise);
       // remove promise after it has been finished
-      vip.then(() => this.variantInstancePromises.delete(name));
+      variantInstancePromise.then(() => this.variantInstancePromises.delete(name));
 
-      return vip;
+      return variantInstancePromise;
     }
 
-    //* if we are here, no instance definition of that name exists. throw error.
+    // if we are here, no instance definition of that name exists. throw error.
     throw Error(`VariantInstance with name "${name}" neither created nor configured.`);
   }
 
@@ -114,13 +120,15 @@ export class VariantInstanceManager extends EventBroadcaster {
   public async create(
     dottedPath: DottedPathArgument,
     name?: string,
-    parameters?: ParameterBag
+    parameters?: ParameterBag,
+    tagManagerParameterValues?: TagManagerParameterValue[]
   ): 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);
   }
@@ -277,6 +285,10 @@ 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;
   }

package/src/api/util/globalTypes.ts

@@ -353,6 +353,7 @@ type VariantInstanceDefinition = {
   name?: string;
   variant: DottedPathArgument;
   parameters?: ParameterBag;
+  tagManagerParameterValues?: TagManagerParameterValue[];
   lazy?: boolean;
 };