@combeenation/3d-viewer 12.4.3 → 12.4.4

package/src/api/util/structureHelper.ts

@@ -1,62 +1,62 @@
-import { Element } from '../classes/element';
-import { Variant } from '../classes/variant';
-import { VariantInstance } from '../classes/variantInstance';
-import { TransformNode } from '@babylonjs/core/Meshes/transformNode';
-import { Tags } from '@babylonjs/core/Misc/tags';
-
-/**
- * Find out if a node is part of a list of excluded geometry
- * @param node BJS node
- * @param list list of excluded geometry
- * @returns boolean based on whether node (or one of its parents) was found in list
- */
-const isNodeIncludedInExclusionList = function (
-  node: TransformNode,
-  list: ExcludedGeometryList,
-  skipParentCheck?: boolean
-): boolean {
-  const checkNode = (inputNode: TransformNode, nodeToCheck: TransformNode) => {
-    return inputNode.name === nodeToCheck.name;
-  };
-  const checkElement = (inputEl: Element, nodeToCheck: TransformNode) => {
-    return inputEl.nodesFlat.some(m => checkNode(m, nodeToCheck));
-  };
-  const checkVariant = (inputVariant: Variant, nodeToCheck: TransformNode) => {
-    return inputVariant.elements.some(el => checkElement(el, nodeToCheck));
-  };
-  const checkVariantInstance = (inputVarInst: VariantInstance, nodeToCheck: TransformNode) => {
-    return inputVarInst.variant.elements.some(el => checkElement(el, nodeToCheck));
-  };
-  const checkTagManagerSubject = (inputSubject: TagManagerSubject, nodeToCheck: TransformNode) => {
-    const nameMatches = inputSubject.nodeName && inputSubject.nodeName === nodeToCheck.name;
-    const tagMatches = inputSubject.tagName && Tags.MatchesQuery(nodeToCheck, inputSubject.tagName);
-    return nameMatches || tagMatches;
-  };
-  const check = (geometryToExclude: ExcludedGeometry, node: TransformNode) => {
-    if (geometryToExclude instanceof VariantInstance) {
-      return checkVariantInstance(geometryToExclude, node);
-    }
-    if (geometryToExclude instanceof Variant) {
-      return checkVariant(geometryToExclude, node);
-    }
-    if (geometryToExclude instanceof Element) {
-      return checkElement(geometryToExclude, node);
-    }
-    if (geometryToExclude instanceof TransformNode) {
-      return checkNode(geometryToExclude, node);
-    }
-    if ((geometryToExclude as TagManagerSubject).tagName || (geometryToExclude as TagManagerSubject).nodeName) {
-      return checkTagManagerSubject(geometryToExclude as TagManagerSubject, node);
-    }
-    return false;
-  };
-
-  let isExcluded = list.some(geometryToExclude => check(geometryToExclude, node));
-  if (!isExcluded && !skipParentCheck && node.parent instanceof TransformNode) {
-    isExcluded = isNodeIncludedInExclusionList(node.parent, list);
-  }
-
-  return isExcluded;
-};
-
-export { isNodeIncludedInExclusionList };
+import { Element } from '../classes/element';
+import { Variant } from '../classes/variant';
+import { VariantInstance } from '../classes/variantInstance';
+import { TransformNode } from '@babylonjs/core/Meshes/transformNode';
+import { Tags } from '@babylonjs/core/Misc/tags';
+
+/**
+ * Find out if a node is part of a list of excluded geometry
+ * @param node BJS node
+ * @param list list of excluded geometry
+ * @returns boolean based on whether node (or one of its parents) was found in list
+ */
+const isNodeIncludedInExclusionList = function (
+  node: TransformNode,
+  list: ExcludedGeometryList,
+  skipParentCheck?: boolean
+): boolean {
+  const checkNode = (inputNode: TransformNode, nodeToCheck: TransformNode) => {
+    return inputNode.name === nodeToCheck.name;
+  };
+  const checkElement = (inputEl: Element, nodeToCheck: TransformNode) => {
+    return inputEl.nodesFlat.some(m => checkNode(m, nodeToCheck));
+  };
+  const checkVariant = (inputVariant: Variant, nodeToCheck: TransformNode) => {
+    return inputVariant.elements.some(el => checkElement(el, nodeToCheck));
+  };
+  const checkVariantInstance = (inputVarInst: VariantInstance, nodeToCheck: TransformNode) => {
+    return inputVarInst.variant.elements.some(el => checkElement(el, nodeToCheck));
+  };
+  const checkTagManagerSubject = (inputSubject: TagManagerSubject, nodeToCheck: TransformNode) => {
+    const nameMatches = inputSubject.nodeName && inputSubject.nodeName === nodeToCheck.name;
+    const tagMatches = inputSubject.tagName && Tags.MatchesQuery(nodeToCheck, inputSubject.tagName);
+    return nameMatches || tagMatches;
+  };
+  const check = (geometryToExclude: ExcludedGeometry, node: TransformNode) => {
+    if (geometryToExclude instanceof VariantInstance) {
+      return checkVariantInstance(geometryToExclude, node);
+    }
+    if (geometryToExclude instanceof Variant) {
+      return checkVariant(geometryToExclude, node);
+    }
+    if (geometryToExclude instanceof Element) {
+      return checkElement(geometryToExclude, node);
+    }
+    if (geometryToExclude instanceof TransformNode) {
+      return checkNode(geometryToExclude, node);
+    }
+    if ((geometryToExclude as TagManagerSubject).tagName || (geometryToExclude as TagManagerSubject).nodeName) {
+      return checkTagManagerSubject(geometryToExclude as TagManagerSubject, node);
+    }
+    return false;
+  };
+
+  let isExcluded = list.some(geometryToExclude => check(geometryToExclude, node));
+  if (!isExcluded && !skipParentCheck && node.parent instanceof TransformNode) {
+    isExcluded = isNodeIncludedInExclusionList(node.parent, list);
+  }
+
+  return isExcluded;
+};
+
+export { isNodeIncludedInExclusionList };

package/src/buildinfo.json

@@ -1,3 +1,3 @@
-{
-  "version": "@VERSION@"
-}
+{
+  "version": "@VERSION@"
+}

package/src/dev.ts

@@ -1,70 +1,70 @@
-import { Emitter, Event, Viewer } from '.';
-import {
-  afterBootstrap,
-  beforeBootstrap,
-  createSpec,
-  createTagManagerParameterValues,
-  createUIelements,
-  getMaterial,
-  mockMaterials,
-} from '../assets/index';
-import { set } from 'lodash-es';
-
-const loadingElement = document.getElementById('loading') as HTMLDivElement;
-
-Emitter.on(Event.BOOTSTRAP_START, () => {
-  loadingElement!.style.display = 'block';
-});
-Emitter.on(Event.BOOTSTRAP_END, () => {
-  loadingElement!.style.display = 'none';
-});
-
-document.addEventListener('DOMContentLoaded', main);
-
-window.Cbn = {
-  Assets: {
-    async getMaterial(materialId: string) {
-      //! this creates a new function on the object that uses the imported function of the same name..
-      const material = await getMaterial(materialId);
-      if (material) return material;
-
-      // Fallback to random mock material
-      return mockMaterials[Math.floor(Math.random() * mockMaterials.length)];
-    },
-    assertMaterialExists(materialId: string): boolean {
-      return true;
-    },
-    reportDuplicateNodeName(nodeNameOrArrayOfNodeNames: string | string[]): void {},
-  },
-  utils: {
-    Viewer3dHelper: {
-      getCfgrParentDomElementForInspector() {
-        // render in parent of viewer
-        return document.querySelector<HTMLElement>('display-container') ?? undefined;
-      },
-    },
-  },
-};
-
-async function main() {
-  const viewer = await bootstrapViewer();
-  // "Export" for console testing...
-  set(window, 'viewer', viewer);
-}
-
-async function bootstrapViewer() {
-  const canvas = document.getElementById('babylon-canvas') as HTMLCanvasElement;
-  if (!canvas) {
-    throw new Error('Missing "canvas" element');
-  }
-  const viewer = new Viewer(canvas, createSpec());
-  await beforeBootstrap(viewer);
-  try {
-    await viewer.bootstrap(createTagManagerParameterValues(viewer));
-  } catch (e) {
-    console.error(e);
-  }
-  await afterBootstrap(viewer);
-  await createUIelements(viewer);
-  return viewer;
-}
+import { Emitter, Event, Viewer } from '.';
+import {
+  afterBootstrap,
+  beforeBootstrap,
+  createSpec,
+  createTagManagerParameterValues,
+  createUIelements,
+  getMaterial,
+  mockMaterials,
+} from '../assets/index';
+import { set } from 'lodash-es';
+
+const loadingElement = document.getElementById('loading') as HTMLDivElement;
+
+Emitter.on(Event.BOOTSTRAP_START, () => {
+  loadingElement!.style.display = 'block';
+});
+Emitter.on(Event.BOOTSTRAP_END, () => {
+  loadingElement!.style.display = 'none';
+});
+
+document.addEventListener('DOMContentLoaded', main);
+
+window.Cbn = {
+  Assets: {
+    async getMaterial(materialId: string) {
+      //! this creates a new function on the object that uses the imported function of the same name..
+      const material = await getMaterial(materialId);
+      if (material) return material;
+
+      // Fallback to random mock material
+      return mockMaterials[Math.floor(Math.random() * mockMaterials.length)];
+    },
+    assertMaterialExists(materialId: string): boolean {
+      return true;
+    },
+    reportDuplicateNodeName(nodeNameOrArrayOfNodeNames: string | string[]): void {},
+  },
+  utils: {
+    Viewer3dHelper: {
+      getCfgrParentDomElementForInspector() {
+        // render in parent of viewer
+        return document.querySelector<HTMLElement>('display-container') ?? undefined;
+      },
+    },
+  },
+};
+
+async function main() {
+  const viewer = await bootstrapViewer();
+  // "Export" for console testing...
+  set(window, 'viewer', viewer);
+}
+
+async function bootstrapViewer() {
+  const canvas = document.getElementById('babylon-canvas') as HTMLCanvasElement;
+  if (!canvas) {
+    throw new Error('Missing "canvas" element');
+  }
+  const viewer = new Viewer(canvas, createSpec());
+  await beforeBootstrap(viewer);
+  try {
+    await viewer.bootstrap(createTagManagerParameterValues(viewer));
+  } catch (e) {
+    console.error(e);
+  }
+  await afterBootstrap(viewer);
+  await createUIelements(viewer);
+  return viewer;
+}

package/src/index.ts

@@ -1,116 +1,116 @@
-/// <reference path="api/util/globalTypes.ts" />
-/// <reference path="types.d.ts" />
-/// <reference types="gsap" />
-import { AnimationInterface } from './api/classes/animationInterface';
-import { Element } from './api/classes/element';
-import { Event, emitter } from './api/classes/event';
-import { EventBroadcaster } from './api/classes/eventBroadcaster';
-import { Parameter } from './api/classes/parameter';
-import { ParameterObservable } from './api/classes/parameterObservable';
-import { Parameterizable } from './api/classes/parameterizable';
-import { PlacementAnimation } from './api/classes/placementAnimation';
-import { Variant } from './api/classes/variant';
-import { VariantInstance } from './api/classes/variantInstance';
-import { VariantParameterizable } from './api/classes/variantParameterizable';
-import { Viewer } from './api/classes/viewer';
-import { ViewerError, ViewerErrorIds } from './api/classes/viewerError';
-import { ViewerLight } from './api/classes/viewerLight';
-import { AnimationManager } from './api/manager/animationManager';
-import { GltfExportManager } from './api/manager/gltfExportManager';
-import { SceneManager } from './api/manager/sceneManager';
-import { TagManager } from './api/manager/tagManager';
-import { VariantInstanceManager } from './api/manager/variantInstanceManager';
-import { SpecStorage } from './api/store/specStorage';
-import * as BabylonHelper from './api/util/babylonHelper';
-import { Animation as BabylonAnimation } from '@babylonjs/core/Animations/animation';
-import { ArcRotateCamera } from '@babylonjs/core/Cameras/arcRotateCamera';
-import { Engine } from '@babylonjs/core/Engines/engine';
-import { DirectionalLight } from '@babylonjs/core/Lights/directionalLight';
-import { HemisphericLight } from '@babylonjs/core/Lights/hemisphericLight';
-import { BackgroundMaterial } from '@babylonjs/core/Materials/Background/backgroundMaterial';
-import { NodeMaterial } from '@babylonjs/core/Materials/Node';
-
-/**
- * Importing from .../PBR covers all PBR material types, also the deprecated ones like `PBRMetallicRoughnessMaterial`.
- * In this way we can also load models which contain these PBR materials.
- * Still we only actively use `PBRMaterial` in the viewer code base and we also only want to expose this one to the
- * consumer.
- */
-import { PBRMaterial } from '@babylonjs/core/Materials/PBR';
-
-/**
- * Same story as for PBR materials, we want to support also textures but only want to expose a few of them
- */
-import { CubeTexture, DynamicTexture, Texture } from '@babylonjs/core/Materials/Textures';
-import { Material } from '@babylonjs/core/Materials/material';
-import { StandardMaterial } from '@babylonjs/core/Materials/standardMaterial';
-import { Color3, Color4 } from '@babylonjs/core/Maths/math.color';
-import { Vector3 } from '@babylonjs/core/Maths/math.vector';
-import { AbstractMesh } from '@babylonjs/core/Meshes/abstractMesh';
-import { InstancedMesh } from '@babylonjs/core/Meshes/instancedMesh';
-import { Mesh } from '@babylonjs/core/Meshes/mesh';
-import { MeshBuilder } from '@babylonjs/core/Meshes/meshBuilder';
-import { TransformNode } from '@babylonjs/core/Meshes/transformNode';
-
-/**
- * Without explicitly importing the "BoundingBoxRenderer", we're getting "scene.getBoundingBoxRenderer is undefined"
- * errors when creating HighlightLayer instances. Not sure why but those errors only happen when using the built
- * version of the viewer (e.g. when pulling it from NPM etc.)...
- */
-import '@babylonjs/core/Rendering/boundingBoxRenderer';
-import { Node } from '@babylonjs/core/node';
-import { Scene } from '@babylonjs/core/scene';
-import { EventEmitter } from 'eventemitter3';
-
-/**
- * Expose some frequently used babylon modules by our consumers.
- */
-export {
-  AnimationManager,
-  AnimationInterface,
-  Variant,
-  VariantInstanceManager,
-  Viewer,
-  ParameterObservable,
-  Parameterizable,
-  VariantParameterizable,
-  ViewerLight,
-  emitter as Emitter,
-  EventEmitter,
-  Event,
-  Parameter,
-  VariantInstance,
-  Color3,
-  Color4,
-  Vector3,
-  AbstractMesh,
-  InstancedMesh,
-  Mesh,
-  TransformNode,
-  Node,
-  Material,
-  PBRMaterial,
-  StandardMaterial,
-  NodeMaterial,
-  BackgroundMaterial,
-  Scene,
-  Engine,
-  ArcRotateCamera,
-  DynamicTexture,
-  CubeTexture,
-  MeshBuilder,
-  Texture,
-  BabylonAnimation,
-  HemisphericLight,
-  DirectionalLight,
-  Element,
-  EventBroadcaster,
-  SceneManager,
-  PlacementAnimation,
-  BabylonHelper,
-  GltfExportManager,
-  SpecStorage,
-  TagManager,
-  ViewerError,
-  ViewerErrorIds,
-};
+/// <reference path="api/util/globalTypes.ts" />
+/// <reference path="types.d.ts" />
+/// <reference types="gsap" />
+import { AnimationInterface } from './api/classes/animationInterface';
+import { Element } from './api/classes/element';
+import { Event, emitter } from './api/classes/event';
+import { EventBroadcaster } from './api/classes/eventBroadcaster';
+import { Parameter } from './api/classes/parameter';
+import { ParameterObservable } from './api/classes/parameterObservable';
+import { Parameterizable } from './api/classes/parameterizable';
+import { PlacementAnimation } from './api/classes/placementAnimation';
+import { Variant } from './api/classes/variant';
+import { VariantInstance } from './api/classes/variantInstance';
+import { VariantParameterizable } from './api/classes/variantParameterizable';
+import { Viewer } from './api/classes/viewer';
+import { ViewerError, ViewerErrorIds } from './api/classes/viewerError';
+import { ViewerLight } from './api/classes/viewerLight';
+import { AnimationManager } from './api/manager/animationManager';
+import { GltfExportManager } from './api/manager/gltfExportManager';
+import { SceneManager } from './api/manager/sceneManager';
+import { TagManager } from './api/manager/tagManager';
+import { VariantInstanceManager } from './api/manager/variantInstanceManager';
+import { SpecStorage } from './api/store/specStorage';
+import * as BabylonHelper from './api/util/babylonHelper';
+import { Animation as BabylonAnimation } from '@babylonjs/core/Animations/animation';
+import { ArcRotateCamera } from '@babylonjs/core/Cameras/arcRotateCamera';
+import { Engine } from '@babylonjs/core/Engines/engine';
+import { DirectionalLight } from '@babylonjs/core/Lights/directionalLight';
+import { HemisphericLight } from '@babylonjs/core/Lights/hemisphericLight';
+import { BackgroundMaterial } from '@babylonjs/core/Materials/Background/backgroundMaterial';
+import { NodeMaterial } from '@babylonjs/core/Materials/Node';
+
+/**
+ * Importing from .../PBR covers all PBR material types, also the deprecated ones like `PBRMetallicRoughnessMaterial`.
+ * In this way we can also load models which contain these PBR materials.
+ * Still we only actively use `PBRMaterial` in the viewer code base and we also only want to expose this one to the
+ * consumer.
+ */
+import { PBRMaterial } from '@babylonjs/core/Materials/PBR';
+
+/**
+ * Same story as for PBR materials, we want to support also textures but only want to expose a few of them
+ */
+import { CubeTexture, DynamicTexture, Texture } from '@babylonjs/core/Materials/Textures';
+import { Material } from '@babylonjs/core/Materials/material';
+import { StandardMaterial } from '@babylonjs/core/Materials/standardMaterial';
+import { Color3, Color4 } from '@babylonjs/core/Maths/math.color';
+import { Vector3 } from '@babylonjs/core/Maths/math.vector';
+import { AbstractMesh } from '@babylonjs/core/Meshes/abstractMesh';
+import { InstancedMesh } from '@babylonjs/core/Meshes/instancedMesh';
+import { Mesh } from '@babylonjs/core/Meshes/mesh';
+import { MeshBuilder } from '@babylonjs/core/Meshes/meshBuilder';
+import { TransformNode } from '@babylonjs/core/Meshes/transformNode';
+
+/**
+ * Without explicitly importing the "BoundingBoxRenderer", we're getting "scene.getBoundingBoxRenderer is undefined"
+ * errors when creating HighlightLayer instances. Not sure why but those errors only happen when using the built
+ * version of the viewer (e.g. when pulling it from NPM etc.)...
+ */
+import '@babylonjs/core/Rendering/boundingBoxRenderer';
+import { Node } from '@babylonjs/core/node';
+import { Scene } from '@babylonjs/core/scene';
+import { EventEmitter } from 'eventemitter3';
+
+/**
+ * Expose some frequently used babylon modules by our consumers.
+ */
+export {
+  AnimationManager,
+  AnimationInterface,
+  Variant,
+  VariantInstanceManager,
+  Viewer,
+  ParameterObservable,
+  Parameterizable,
+  VariantParameterizable,
+  ViewerLight,
+  emitter as Emitter,
+  EventEmitter,
+  Event,
+  Parameter,
+  VariantInstance,
+  Color3,
+  Color4,
+  Vector3,
+  AbstractMesh,
+  InstancedMesh,
+  Mesh,
+  TransformNode,
+  Node,
+  Material,
+  PBRMaterial,
+  StandardMaterial,
+  NodeMaterial,
+  BackgroundMaterial,
+  Scene,
+  Engine,
+  ArcRotateCamera,
+  DynamicTexture,
+  CubeTexture,
+  MeshBuilder,
+  Texture,
+  BabylonAnimation,
+  HemisphericLight,
+  DirectionalLight,
+  Element,
+  EventBroadcaster,
+  SceneManager,
+  PlacementAnimation,
+  BabylonHelper,
+  GltfExportManager,
+  SpecStorage,
+  TagManager,
+  ViewerError,
+  ViewerErrorIds,
+};

package/src/types.d.ts

@@ -1,49 +1,49 @@
-/** @ignore **/
-declare let IS_PRODUCTION: boolean;
-declare let VERSION_INFORMATION: string;
-
-interface Window {
-  Cbn:
-    | undefined /* window.Cbn is only available when viewer runs inside Combeenation configurator */
-    | {
-        Assets: {
-          /**
-           * Retrieve material definition from configurator\
-           * Implementation depends on the Combeenation environment the viewer is used in
-           * - Configurator: Access pre-fetched material JSON objects from Cbn client => synchronous
-           * - Asset Editor: Load content from material asset on demand => asynchronous!
-           *
-           * @param materialId
-           *
-           * @return Undefined if no definition for the given material name exists, otherwise an "JSON object" which can
-           *         be passed to `BABYLON.Material.Parse` to create a runtime material object.
-           */
-          getMaterial(materialId: string): Promise<object | undefined>;
-
-          /**
-           * Checks if a definition for a given material name exists in the configurator and issues a warning if not.
-           *
-           * @param materialId
-           */
-          assertMaterialExists(materialId: string): boolean;
-
-          /**
-           * Warns user about duplicate nodeNames on scene.
-           *
-           * @param nodeNameOrArrayOfNodeNames
-           */
-          reportDuplicateNodeName(nodeNameOrArrayOfNodeNames: string | string[]): void;
-        };
-        utils: {
-          Viewer3dHelper: {
-            /**
-             * Returns parent DOM element of a Combeenation configurator, which can be used as root for the inspector.
-             * Also adjusts styling of some configurator parent sub elements to fix the inspector layout.
-             *
-             * @return
-             */
-            getCfgrParentDomElementForInspector(): HTMLElement | undefined;
-          };
-        };
-      };
-}
+/** @ignore **/
+declare let IS_PRODUCTION: boolean;
+declare let VERSION_INFORMATION: string;
+
+interface Window {
+  Cbn:
+    | undefined /* window.Cbn is only available when viewer runs inside Combeenation configurator */
+    | {
+        Assets: {
+          /**
+           * Retrieve material definition from configurator\
+           * Implementation depends on the Combeenation environment the viewer is used in
+           * - Configurator: Access pre-fetched material JSON objects from Cbn client => synchronous
+           * - Asset Editor: Load content from material asset on demand => asynchronous!
+           *
+           * @param materialId
+           *
+           * @return Undefined if no definition for the given material name exists, otherwise an "JSON object" which can
+           *         be passed to `BABYLON.Material.Parse` to create a runtime material object.
+           */
+          getMaterial(materialId: string): Promise<object | undefined>;
+
+          /**
+           * Checks if a definition for a given material name exists in the configurator and issues a warning if not.
+           *
+           * @param materialId
+           */
+          assertMaterialExists(materialId: string): boolean;
+
+          /**
+           * Warns user about duplicate nodeNames on scene.
+           *
+           * @param nodeNameOrArrayOfNodeNames
+           */
+          reportDuplicateNodeName(nodeNameOrArrayOfNodeNames: string | string[]): void;
+        };
+        utils: {
+          Viewer3dHelper: {
+            /**
+             * Returns parent DOM element of a Combeenation configurator, which can be used as root for the inspector.
+             * Also adjusts styling of some configurator parent sub elements to fix the inspector layout.
+             *
+             * @return
+             */
+            getCfgrParentDomElementForInspector(): HTMLElement | undefined;
+          };
+        };
+      };
+}