@combeenation/3d-viewer 5.0.0-ar2 → 5.0.0

package/src/api/manager/variantInstanceManager.ts

@@ -11,6 +11,8 @@ import { VariantInstance } from '../classes/variantInstance';
  * {@link Viewer} instance via its {@link Viewer.variantInstances}
  */
 export class VariantInstanceManager extends EventBroadcaster {
+  protected variantInstancePromises: Map<string, Promise<VariantInstance>> = new Map();
+
   protected variantInstances: Map<string, VariantInstance> = new Map();
 
   protected variantInstanceDefinitions: Map<string, VariantInstanceDefinition> = new Map();
@@ -61,19 +63,35 @@ export class VariantInstanceManager extends EventBroadcaster {
   /**
    * Retrieves a {@link VariantInstance}.
    * If the instance has been created, the created instance will be returned.
-   * If the instance is registered, the instance will be created.
+   * If the instance is registered, the instance will be created and returned.
+   * if the instance has already been requested and is currently pending, the dedicated promise will be returned.
    * If none of these apply, an Error is thrown.
    *
    * @emits {@link Event.VARIANT_INSTANCE_CREATED}
    */
   public async get(name: string): Promise<VariantInstance> {
+    // 1) see if we have an instance of that name already and return it if found
     if (this.variantInstances.has(name)) {
-      return this.variantInstances.get(name)!;
+      return this.variantInstances.get(name)!; // cannot be null, hence the exclamation mark
+    }
+
+    // 2) try to get promise from list of requested instances and return it if found
+    if (this.variantInstancePromises.has(name)) {
+      return this.variantInstancePromises.get(name)!;
     }
+
+    // 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)!;
-      return await this.createFromDefinition(definition);
+      const definition = this.variantInstanceDefinitions.get(name)!; // cannot be null
+      const vip = this.createFromDefinition(definition);
+      this.variantInstancePromises.set(name, vip);
+      // remove promise after it has been finished
+      vip.then(() => this.variantInstancePromises.delete(name));
+
+      return vip;
     }
+
+    //* if we are here, no instance definition of that name exists. throw error.
     throw Error(`VariantInstance with name "${name}" neither created nor configured.`);
   }
 

package/src/api/util/globalTypes.ts

@@ -232,6 +232,11 @@ type ScreenshotSettings = {
   renderSprites?: boolean;
 };
 
+/**
+ * Use this to define geometry to be excluded from autofocus, GLB export, etc.
+ */
+type ExcludedGeometry = (Mesh | VariantInstance | Variant | VariantElement)[];
+
 type AutofocusSettings = {
   /**
    * Can be used to customize the margins shown around the 3d model when calling {@link autofocusActiveCamera}.\
@@ -247,6 +252,8 @@ type AutofocusSettings = {
   beta?: number;
   /** Optional animation for the focusing camera movement */
   animation?: string | AnimationDefinition;
+  /** Optional list of geometry to be excluded from consideration */
+  exclude?: ExcludedGeometry;
 };
 
 type LightDefinitions = {

package/src/api/util/structureHelper.ts

@@ -0,0 +1,43 @@
+import { Mesh } from '@babylonjs/core/Meshes/mesh';
+import { Variant } from '../classes/variant';
+import { VariantInstance } from '../classes/variantInstance';
+import { Element } from '../classes/element';
+
+/**
+ * Find out if a mesh is part of a list of excluded geometry
+ * @param mesh BJS mesh
+ * @param list list of excluded geometry
+ * @returns boolean based on whether mesh was found in list
+ */
+const isMeshIncludedInExclusionList = function (mesh: Mesh, list: ExcludedGeometry): boolean {
+  const checkMesh = (inputMesh: Mesh, meshToCheck: Mesh) => {
+    return inputMesh.uniqueId === meshToCheck.uniqueId;
+  };
+  const checkElement = (inputEl: Element, meshToCheck: Mesh) => {
+    return inputEl.meshesFlat.some(m => checkMesh(m, meshToCheck));
+  };
+  const checkVariant = (inputVariant: Variant, meshToCheck: Mesh) => {
+    return inputVariant.elements.some(el => checkElement(el, meshToCheck));
+  };
+  const checkVariantInstance = (inputVarInst: VariantInstance, meshToCheck: Mesh) => {
+    return inputVarInst.variant.elements.some(el => checkElement(el, meshToCheck));
+  };
+  const isExcluded = list.some(geometryToExclude => {
+    if (geometryToExclude instanceof VariantInstance) {
+      return checkVariantInstance(geometryToExclude, mesh);
+    }
+    if (geometryToExclude instanceof Variant) {
+      return checkVariant(geometryToExclude, mesh);
+    }
+    if (geometryToExclude instanceof Element) {
+      return checkElement(geometryToExclude, mesh);
+    }
+    if (geometryToExclude instanceof Mesh) {
+      return checkMesh(geometryToExclude, mesh);
+    }
+    return false;
+  });
+  return isExcluded;
+};
+
+export { isMeshIncludedInExclusionList };

package/src/pagesconfig.json

@@ -26,6 +26,10 @@
             {
               "title": "Version 4.3.0",
               "source": "./doc/release-notes/version-details/4-3-0.md"
+            },
+            {
+              "title": "Version 5.0.0",
+              "source": "./doc/release-notes/version-details/5-0-0.md"
             }
           ]
         }