@combeenation/3d-viewer 8.0.0 → 8.1.0-alpha1

package/src/api/util/structureHelper.ts

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