@combeenation/3d-viewer 11.0.0 → 12.0.0-alpha2

package/package.json

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

package/src/api/manager/gltfExportManager.ts

@@ -1,58 +1,31 @@
-import { bakeGeometryOfAllMeshes } from '..//util/geometryHelper';
+import { Node as BjsNode, Color3, InstancedMesh, PBRMaterial } from '../../index';
 import { Viewer } from '../classes/viewer';
 import { injectMetadata } from '../util/babylonHelper';
+import { bakeGeometryOfMesh, createMeshFromInstancedMesh, resetTransformation } from '../util/geometryHelper';
 import { isNodeIncludedInExclusionList } from '../util/structureHelper';
-import { Engine } from '@babylonjs/core/Engines/engine';
-import { EngineStore } from '@babylonjs/core/Engines/engineStore';
-import { SceneLoader } from '@babylonjs/core/Loading/sceneLoader';
-import { PBRMaterial } from '@babylonjs/core/Materials/PBR/pbrMaterial';
-import { Color3 } from '@babylonjs/core/Maths/math.color';
-import { AbstractMesh } from '@babylonjs/core/Meshes/abstractMesh';
+import { Mesh } from '@babylonjs/core/Meshes/mesh';
 import { TransformNode } from '@babylonjs/core/Meshes/transformNode';
-import { SceneSerializer } from '@babylonjs/core/Misc/sceneSerializer';
-import { Scene } from '@babylonjs/core/scene';
-import { GLTF2Export, IExportOptions } from '@babylonjs/serializers/glTF/2.0';
-import { has, merge } from 'lodash-es';
+import { GLTF2Export } from '@babylonjs/serializers/glTF/2.0/glTFSerializer';
 
-type MetadataMap = { [key: string]: any };
 export class GltfExportManager {
-  protected static readonly _CLONED_FROM_MAT_METADATA_PROPERTY = 'clonedFrom';
-  public static readonly NAME_BEFORE_EXPORT_METADATA_PROPERTY = 'nameBeforeExport';
+  protected static readonly _METADATA_PROPS = {
+    exportNode: 'exportNode',
+    deleteAfterExport: 'deleteAfterExport',
+    exchangeMaterialWith: 'exchangeMaterialWith',
+  };
 
-  /**
-   * Constructor.
-   */
   protected constructor(protected viewer: Viewer) {}
 
-  /**
-   * Creates an {@link GltfExportManager}.
-   */
   public static async create(viewer: Viewer): Promise<GltfExportManager> {
     return new GltfExportManager(viewer);
   }
 
-  /**
-   * Exports selected nodes to a file.
-   * @param filename optional name of the exported .GLB file.
-   * @param exportOptions export options to be merged with default options.\
-   *                      `exportOptions.exchangeRefractionMaterials` and `exportOptions.limitTextureSize`
-   *                      default to `true` if not given.
-   * @param optimizeForAR adjusts the exported GLB so that known AR issues get fixed automatically
-   * @param excluded optional list of geometry (meshes, elements, variants, variantInstances) to be excluded from export
-   */
-  public async exportGlb(
-    filename = 'glb-export.glb',
-    { exchangeRefractionMaterials = true, limitTextureSize = true, ...exportOptions }: IExportOptionsExtended = {},
-    optimizeForAR: boolean = false,
-    excluded?: ExcludedGeometryList
-  ): Promise<File | undefined> {
-    const { scene, sceneCopied } = await this.exportPreProcess(
-      exchangeRefractionMaterials,
-      limitTextureSize,
-      optimizeForAR
-    );
-    const glbData = await GLTF2Export.GLBAsync(scene, 'dummy', this.gltfExportOptions(exportOptions, excluded));
-    this.exportPostProcess(scene, sceneCopied);
+  public async exportGlb(filename = 'glb-export.glb', excluded?: ExcludedGeometryList) {
+    await this._exportPreProcess(excluded);
+
+    const glbData = await GLTF2Export.GLBAsync(this.viewer.scene, 'dummy', this._gltfExportOptions());
+
+    await this._exportPostProcess();
 
     const resBlob = glbData.glTFFiles['dummy.glb'];
     // check if result is valid, according to the typings this could also be a string
@@ -67,218 +40,146 @@ export class GltfExportManager {
     }
   }
 
-  /**
-   * Exports selected nodes to GLTF. This may result in more than one file, since textures are exported separately.
-   * @param filename name of the main (text-based) .GLTF file referring to separate texture files.
-   * @param exportOptions export options to be merged with default options.\
-   *                      `exportOptions.exchangeRefractionMaterials` and `exportOptions.limitTextureSize`
-   *                      default to `true` if not given.
-   * @param optimizeForAR adjusts the exported GLB so that known AR issues get fixed automatically
-   * @param excluded optional list of geometry (meshes, elements, variants, variantInstances) to be excluded from export
-   */
-  public async exportGltfToFile(
-    filename: string,
-    { exchangeRefractionMaterials = true, limitTextureSize = true, ...exportOptions }: IExportOptionsExtended = {},
-    optimizeForAR: boolean = false,
-    excluded?: ExcludedGeometryList
-  ) {
-    const { scene, sceneCopied } = await this.exportPreProcess(
-      exchangeRefractionMaterials,
-      limitTextureSize,
-      optimizeForAR
-    );
-    const gltf = await GLTF2Export.GLTFAsync(scene, filename, this.gltfExportOptions(exportOptions, excluded));
+  public async exportGltfToFile(filename: string, excluded?: ExcludedGeometryList) {
+    await this._exportPreProcess(excluded);
+
+    const gltf = await GLTF2Export.GLTFAsync(this.viewer.scene, filename, this._gltfExportOptions());
     gltf.downloadFiles();
-    this.exportPostProcess(scene, sceneCopied);
+
+    this._exportPostProcess();
   }
 
-  /**
-   * Exports selected nodes to GLB. This results in one binary file.
-   * @param filename name of the .GLB file.
-   * @param exportOptions export options to be merged with default options.\
-   *                      `exportOptions.exchangeRefractionMaterials` and `exportOptions.limitTextureSize`
-   *                      default to `true` if not given.
-   * @param optimizeForAR adjusts the exported GLB so that known AR issues get fixed automatically
-   * @param excluded optional list of geometry (meshes, elements, variants, variantInstances) to be excluded from export
-   */
-  public async exportGlbToFile(
-    filename: string,
-    { exchangeRefractionMaterials = true, limitTextureSize = true, ...exportOptions }: IExportOptionsExtended = {},
-    optimizeForAR: boolean = false,
-    excluded?: ExcludedGeometryList
-  ) {
-    const { scene, sceneCopied } = await this.exportPreProcess(
-      exchangeRefractionMaterials,
-      limitTextureSize,
-      optimizeForAR
-    );
-    const glb = await GLTF2Export.GLBAsync(scene, filename, this.gltfExportOptions(exportOptions, excluded));
+  public async exportGlbToFile(filename: string, excluded?: ExcludedGeometryList) {
+    await this._exportPreProcess(excluded);
+
+    const glb = await GLTF2Export.GLBAsync(this.viewer.scene, filename, this._gltfExportOptions());
     glb.downloadFiles();
-    this.exportPostProcess(scene, sceneCopied);
-  }
 
-  /**
-   * Gets predefined {@link IExportOptions } merged with given ones.
-   */
-  protected gltfExportOptions(mergeWithOptions: IExportOptions = {}, excluded?: ExcludedGeometryList): IExportOptions {
-    const defaultOptions: IExportOptions = {
-      shouldExportNode: function (node: any) {
-        if (!node.isEnabled()) {
-          return false;
-        }
-        if ((node.name as string).startsWith(Viewer.BOUNDING_BOX_NAME)) {
-          return false;
-        }
-        if (excluded && node instanceof TransformNode && isNodeIncludedInExclusionList(node, excluded)) {
-          return false;
-        }
-        return true;
-      },
-    };
-    return merge({}, defaultOptions, mergeWithOptions);
+    await this._exportPostProcess();
   }
 
-  /**
-   * Stuff to be done before exporting to GLTF
-   *
-   * @returns Either the original scene if no adjustments have been made or a copied scene (which can be disposed after
-   * the export) if adjustments have been made
-   */
-  protected async exportPreProcess(
-    exchangeRefractionMaterials: boolean,
-    limitTextureSize: boolean,
-    optimizeForAR: boolean
-  ): Promise<{ scene: Scene; sceneCopied: boolean }> {
-    if (!exchangeRefractionMaterials && !optimizeForAR && !limitTextureSize) {
-      // no need to copy the scene if no adjustments have to be made
-      return { scene: this.viewer.scene, sceneCopied: false };
-    }
-
-    // copy the scene for the GLB export improvements, so that the original viewer scene remains untouched
-    const copiedScene = await this.copyViewerScene(limitTextureSize);
+  protected async _exportPreProcess(excluded?: ExcludedGeometryList): Promise<void> {
+    // handle materials
+    this.viewer.scene.materials
+      .filter(material => this._shouldReplaceMaterial(material))
+      .forEach(material => this._createRefractionMaterialReplacement(material as PBRMaterial));
+
+    // handle nodes
+    this.viewer.scene.rootNodes.forEach(rootNode => this._prepareNodeForExport(rootNode, null, excluded));
+
+    // bake transformation of all meshes, so that no negative scalings are left
+    // it's important that this is done AFTER instanced meshes have been converted (_prepareNodeForExport)
+    this.viewer.scene.meshes
+      .filter(mesh => !!mesh.metadata?.[GltfExportManager._METADATA_PROPS.exportNode])
+      .forEach(mesh => bakeGeometryOfMesh(mesh as Mesh));
+
+    // reset transformation of all "TransformNodes", which couldn't be handled by the geometry baking algorithm
+    // it's important that this is done AFTER all geometries have been baked
+    this.viewer.scene.transformNodes
+      .filter(node => !!node.metadata?.[GltfExportManager._METADATA_PROPS.exportNode])
+      .forEach(node => resetTransformation(node as TransformNode));
+  }
 
-    if (exchangeRefractionMaterials) {
-      this.exchangeRefractionMaterials(copiedScene);
-    }
+  protected async _exportPostProcess(): Promise<void> {
+    // dispose all nodes and materials that have only been created for the export
+    this.viewer.scene.rootNodes
+      .filter(rootNode => rootNode.metadata?.[GltfExportManager._METADATA_PROPS.deleteAfterExport])
+      .forEach(rootNode => rootNode.dispose());
 
-    if (optimizeForAR) {
-      this.setUniqueMeshNames(copiedScene);
-      // get rid of negative scalings and morph targets, since iOS can't handle it in the QuickLook app
-      bakeGeometryOfAllMeshes(copiedScene);
-      // certain devices can't load models with skeletons, just remove them since animations are not supported in the AR
-      // scene anyway
-      while (copiedScene.skeletons.length) {
-        const skeleton = copiedScene.skeletons.pop();
-        skeleton!.dispose();
-      }
-    }
+    this.viewer.scene.materials
+      .filter(mat => !!mat.metadata?.[GltfExportManager._METADATA_PROPS.deleteAfterExport])
+      .forEach(material => material.dispose(false, false));
+  }
 
-    return { scene: copiedScene, sceneCopied: true };
+  protected _gltfExportOptions(): IExportOptions {
+    return {
+      shouldExportNode: function (node: BjsNode) {
+        return !!node.metadata?.[GltfExportManager._METADATA_PROPS.exportNode];
+      },
+      // keep root node(s)
+      // this seems to be important due to the geometry baking and transformation resetting stuff
+      // => root node would have no transformation anymore, which seems to be problematic for the import
+      removeNoopRootNodes: false,
+    };
   }
 
-  /**
-   * Create a copy of the viewer scene, which can be further processed and optimized for the GLB export.
-   * There is no "scene.clone" function, therefore the scene is serialized and loaded again to achieve this result.
-   */
-  protected async copyViewerScene(limitTextureSize: boolean): Promise<Scene> {
-    // required by the scene serializer
-    await import(/* webpackChunkName: "physicsenginecomponent" */ '@babylonjs/core/Physics/physicsEngineComponent');
-
-    // copy scene function uses scene serializer, which can't handle "complex" data like classes, function or recursive
-    // data structures in metadata
-    // it basically does a `JSON.stringify` on the metadata
-    // therefore the metadata has to be removed from the nodes before the copy process
-    const metadataArr = this.extractMetadataOfAllNodes();
-
-    // serialize the scene
-    const serializedScene = await SceneSerializer.SerializeAsync(this.viewer.scene);
-
-    // set the cropped metadata back to the viewer scene nodes
-    this.restoreMetadataOfAllNodes(metadataArr);
-
-    // load the scene into an invisible "dummy" canvas
-    const dummyCanvas = document.createElement('canvas');
-    const engine = new Engine(dummyCanvas);
-
-    if (limitTextureSize) {
-      // according to some tests iOS devices break when exporting a scene with textures above 1024
-      // this only affects the scene clone for the export
-      engine.getCaps().maxTextureSize = 1024;
+  protected _prepareNodeForExport(
+    node: BjsNode,
+    clonedParent: Nullable<TransformNode>,
+    excluded?: ExcludedGeometryList
+  ) {
+    if (!this._shouldExportNode(node, excluded)) {
+      return;
     }
 
-    // overwritting _LastCreatedScene to fix issue: https://combeenation.youtrack.cloud/issue/CB-8972
-    // In short: dummy scene erroneously interacts with original viewer scene
-    // setting viewer scene as fallback again (`_LastCreatedScene`) resolves that issue
-    const curLastScene = EngineStore._LastCreatedScene;
-    const newScene = new Scene(engine);
-    EngineStore._LastCreatedScene = curLastScene;
+    // from here on we only have TransformNodes
+    const transformNode = node as TransformNode;
+
+    // clone original node and create unique name (via uniqueId)
+    const newNodeName = `${transformNode.name}_${transformNode.uniqueId}`;
+    const clonedNode =
+      transformNode instanceof InstancedMesh
+        ? createMeshFromInstancedMesh(transformNode, newNodeName, clonedParent)
+        : transformNode.clone(newNodeName, clonedParent, true)!;
+
+    // exchange material
+    if (clonedNode instanceof Mesh) {
+      const exchangeWithMaterial =
+        clonedNode.material?.metadata?.[GltfExportManager._METADATA_PROPS.exchangeMaterialWith];
+      if (exchangeWithMaterial) {
+        clonedNode.material = this.viewer.scene.getMaterialByName(exchangeWithMaterial);
+      }
+    }
 
-    SceneLoader.ShowLoadingScreen = false;
-    await SceneLoader.AppendAsync('', 'data:' + JSON.stringify(serializedScene), newScene, undefined, '.babylon');
+    // signalize that this is a cloned node
+    injectMetadata(clonedNode!, {
+      [GltfExportManager._METADATA_PROPS.exportNode]: true,
+      [GltfExportManager._METADATA_PROPS.deleteAfterExport]: true,
+    });
 
-    return newScene;
+    // handle children
+    const childs = transformNode.getChildTransformNodes(true);
+    childs.forEach(child => this._prepareNodeForExport(child, clonedNode, excluded));
   }
 
-  /**
-   * Stuff to be done after the GLTF export
-   */
-  protected exportPostProcess(scene: Scene, disposeScene: boolean) {
-    if (disposeScene) {
-      // copied scene for GLB export is not needed anymore, therefore it can be removed
-      scene.getEngine().dispose();
+  protected _shouldExportNode(node: BjsNode, excluded?: ExcludedGeometryList): boolean {
+    if (!(node instanceof TransformNode)) {
+      return false;
+    }
+    if (node.name === Viewer.BOUNDING_BOX_NAME) {
+      return false;
+    }
+    if (!node.isEnabled()) {
+      return false;
+    }
+    if (excluded && isNodeIncludedInExclusionList(node, excluded)) {
+      return false;
     }
-  }
-
-  /**
-   * Remove all node metadata and return them in a map
-   */
-  protected extractMetadataOfAllNodes(): MetadataMap {
-    return this.viewer.scene.getNodes().reduce((accMetadataObj, curNode) => {
-      const metadata = curNode.metadata;
-      delete curNode.metadata;
-      return { ...accMetadataObj, [curNode.uniqueId.toString()]: metadata };
-    }, {});
-  }
 
-  /**
-   * Restore node metadata from previously cropped metadata map
-   */
-  protected restoreMetadataOfAllNodes(metadataMap: MetadataMap) {
-    this.viewer.scene.getNodes().forEach(node => {
-      const metadata = metadataMap[node.uniqueId.toString()];
-      if (metadata) {
-        node.metadata = metadata;
-      }
-    });
+    return true;
   }
 
-  /**
-   * Materials with refraction set are not exported properly.
-   * Exchange all such (relevant) materials with a more export-friendly version
-   */
-  protected exchangeRefractionMaterials(scene: Scene) {
-    for (const n of scene.getNodes()) {
-      if (!(n instanceof AbstractMesh)) continue;
-      if (!(n.material instanceof PBRMaterial)) continue;
-      if (!(n.material as PBRMaterial).subSurface.isRefractionEnabled) continue;
-      if ((n.material as PBRMaterial).transparencyMode !== PBRMaterial.PBRMATERIAL_OPAQUE) continue;
-      // if we're here, we have a node holding a material with set refraction whose transparencyMode is set to
-      // PBRMATERIAL_OPAQUE
-      n.material = this.createRefractionMaterialReplacement(n.material);
+  protected _shouldReplaceMaterial(material: Material): boolean {
+    if (!(material instanceof PBRMaterial)) {
+      return false;
+    }
+    if (!material.subSurface.isRefractionEnabled) {
+      return false;
     }
+    if (material.transparencyMode !== PBRMaterial.PBRMATERIAL_OPAQUE) {
+      return false;
+    }
+
+    return true;
   }
 
   /**
    * Create an export-friendly replacement material for a material using refraction.
-   * @param mat Material to be replaced
    */
-  protected createRefractionMaterialReplacement(mat: PBRMaterial): PBRMaterial {
-    // if we're dealing with a clone already, return it instead of cloning
-    if (this.isMaterialClonedForExport(mat)) return mat;
-
+  protected _createRefractionMaterialReplacement(material: PBRMaterial): PBRMaterial {
+    const newName = `${material.name}_clone`;
     // change material according to https://www.notion.so/combeenation/Glas-materials-don-t-look-glasy-after-export-d5fda2c6515e4420a8772744d3e6b460
-    const clonedMaterial = mat.clone(mat.name); // clone material. clone uses same name
-    clonedMaterial.metadata = { ...mat.metadata, [GltfExportManager._CLONED_FROM_MAT_METADATA_PROPERTY]: mat.uniqueId }; // create shallow copy of metadata on clone. see https://forum.babylonjs.com/t/the-metadata-of-the-mesh-cloned-by-the-instantiatemodelstoscene-method-is-a-shallow-copy/21563
+    const clonedMaterial = material.clone(newName); // clone material
     clonedMaterial.refractionTexture = null;
     clonedMaterial.metallicReflectanceTexture = null; // is this the correct one for metallic roughness?
     clonedMaterial.alpha = 0.7;
@@ -287,26 +188,9 @@ export class GltfExportManager {
     clonedMaterial.metallic = 0.65;
     clonedMaterial.roughness = 0.15;
 
-    return clonedMaterial;
-  }
-
-  /**
-   * Inspect if a material was temporarily cloned for GLB export
-   * @param mat Material to be inspected
-   */
-  protected isMaterialClonedForExport(mat: PBRMaterial): boolean {
-    return has(mat.metadata, GltfExportManager._CLONED_FROM_MAT_METADATA_PROPERTY);
-  }
+    injectMetadata(material, { [GltfExportManager._METADATA_PROPS.exchangeMaterialWith]: newName });
+    injectMetadata(clonedMaterial, { [GltfExportManager._METADATA_PROPS.deleteAfterExport]: true });
 
-  /**
-   * Set unique mesh names for GLB export.
-   * Duplicate names lead to problems in AR on iOS devices.
-   */
-  protected setUniqueMeshNames(scene: Scene): void {
-    const allNodes = scene.getNodes().filter(node => node instanceof TransformNode) as TransformNode[];
-    allNodes.forEach(currMesh => {
-      injectMetadata(currMesh, { [GltfExportManager.NAME_BEFORE_EXPORT_METADATA_PROPERTY]: currMesh.name }, false);
-      currMesh.name = `${currMesh.name}_${currMesh.uniqueId}`;
-    });
+    return clonedMaterial;
   }
 }

package/src/api/util/geometryHelper.ts

@@ -1,57 +1,35 @@
-import { MorphTargetManager } from '@babylonjs/core';
 import { VertexBuffer } from '@babylonjs/core/Buffers/buffer';
 import { Vector3 } from '@babylonjs/core/Maths/math.vector';
-import type { Geometry } from '@babylonjs/core/Meshes';
+import { type Geometry } from '@babylonjs/core/Meshes';
 import { InstancedMesh } from '@babylonjs/core/Meshes/instancedMesh';
 import { Mesh } from '@babylonjs/core/Meshes/mesh';
 import { TransformNode } from '@babylonjs/core/Meshes/transformNode';
 import type { MorphTarget } from '@babylonjs/core/Morph';
+import { MorphTargetManager } from '@babylonjs/core/Morph/morphTargetManager';
 import type { FloatArray } from '@babylonjs/core/types';
 
-/**
- * Removes morph targets and sets transformation values back to their default values.
- * The effects from morph targets and tranformation values will be "baked" in the geometry, so that the final appearance
- * of the meshes stay the same.
- */
-const bakeGeometryOfAllMeshes = function (scene: Scene) {
-  // instanced meshes have to be converted, since they share the geometry of the source mesh, which would lead to issues
-  // when baking the transformation values
-  scene.meshes.forEach(mesh => {
-    if (mesh instanceof InstancedMesh) {
-      convertInstancedMeshToMesh(mesh);
-    }
-  });
-
-  // do the geometry baking for all meshes in the scene
-  scene.meshes.forEach(mesh => {
-    if (mesh instanceof Mesh) {
-      bakeGeometryOfMesh(mesh);
-    }
-  });
-
-  // some nodes (mostly transform nodes), are not affected by the baking algorithm since they have no geometry
-  // => reset their transformation manually
-  const allNodes = scene.getNodes().filter(node => node instanceof TransformNode) as TransformNode[];
-  allNodes.forEach(node => {
-    resetTransformation(node);
-  });
-};
-
-const convertInstancedMeshToMesh = function (instancedMesh: InstancedMesh) {
+const createMeshFromInstancedMesh = function (
+  instancedMesh: InstancedMesh,
+  newName: string,
+  clonedParent: Nullable<TransformNode>
+) {
   // first create a clone of the source mesh
-  const newMesh = instancedMesh.sourceMesh.clone(`${instancedMesh.name}`, instancedMesh.parent);
-  // apply the transformation data
-  newMesh.position = instancedMesh.position;
-  newMesh.rotation = instancedMesh.rotation;
-  newMesh.rotationQuaternion = instancedMesh.rotationQuaternion;
-  newMesh.scaling = instancedMesh.scaling;
+  const newMesh = instancedMesh.sourceMesh.clone(newName, clonedParent, true);
+  // apply the transformation data, it's important to create clones of the transformations to not touch the original
+  // transformation when applying changes (eg: geometry baking)
+  newMesh.position = instancedMesh.position.clone();
+  newMesh.rotation = instancedMesh.rotation.clone();
+  newMesh.scaling = instancedMesh.scaling.clone();
+
+  // rotation quaternion is optional
+  if (instancedMesh.rotationQuaternion) {
+    newMesh.rotationQuaternion = instancedMesh.rotationQuaternion.clone();
+  }
+
   // also sync the enabled state from the original instanced mesh
   newMesh.setEnabled(instancedMesh.isEnabled(false));
 
-  // re-assign children of the original mesh, since that one won't be used anymore
-  instancedMesh.getChildren(undefined).forEach(childNode => (childNode.parent = newMesh));
-  // finally delete the original instanced mesh
-  instancedMesh.dispose();
+  return newMesh;
 };
 
 const bakeGeometryOfMesh = function (mesh: Mesh) {
@@ -69,10 +47,10 @@ const bakeGeometryOfMesh = function (mesh: Mesh) {
   if (morphTargetManager?.numTargets) {
     // apply morph target vertices data to mesh geometry
     // mostly only the "PositionKind" is implemented
-    bakeMorphTargetManagerIntoVertices(VertexBuffer.PositionKind, morphTargetManager, geometry);
-    bakeMorphTargetManagerIntoVertices(VertexBuffer.NormalKind, morphTargetManager, geometry);
-    bakeMorphTargetManagerIntoVertices(VertexBuffer.TangentKind, morphTargetManager, geometry);
-    bakeMorphTargetManagerIntoVertices(VertexBuffer.UVKind, morphTargetManager, geometry);
+    _bakeMorphTargetManagerIntoVertices(VertexBuffer.PositionKind, morphTargetManager, geometry);
+    _bakeMorphTargetManagerIntoVertices(VertexBuffer.NormalKind, morphTargetManager, geometry);
+    _bakeMorphTargetManagerIntoVertices(VertexBuffer.TangentKind, morphTargetManager, geometry);
+    _bakeMorphTargetManagerIntoVertices(VertexBuffer.UVKind, morphTargetManager, geometry);
 
     // remove morph target manager with all it's morph targets
     mesh.morphTargetManager = null;
@@ -86,7 +64,7 @@ const bakeGeometryOfMesh = function (mesh: Mesh) {
  * @param kind morph targets can affect various vertices kinds, whereas "position" is the most common one
  * still other kinds (like normals or tangents) can be affected as well and can be provided on this input
  */
-const bakeMorphTargetManagerIntoVertices = function (
+const _bakeMorphTargetManagerIntoVertices = function (
   kind: string,
   morphTargetManager: MorphTargetManager,
   geometry: Geometry
@@ -100,7 +78,7 @@ const bakeMorphTargetManagerIntoVertices = function (
   let verticesData = [...origVerticesData];
   for (let i = 0; i < morphTargetManager.numTargets; i++) {
     const target = morphTargetManager.getTarget(i);
-    const targetVerticesData = getVerticesDataFromMorphTarget(kind, target);
+    const targetVerticesData = _getVerticesDataFromMorphTarget(kind, target);
     if (targetVerticesData) {
       // vertices data of this kind are implemented on the morph target
       // add the influence of this morph target to the vertices data
@@ -115,7 +93,7 @@ const bakeMorphTargetManagerIntoVertices = function (
   geometry.setVerticesData(kind, verticesData);
 };
 
-const getVerticesDataFromMorphTarget = function (kind: string, morphTarget: MorphTarget): Nullable<FloatArray> {
+const _getVerticesDataFromMorphTarget = function (kind: string, morphTarget: MorphTarget): Nullable<FloatArray> {
   switch (kind) {
     case VertexBuffer.PositionKind:
       return morphTarget.getPositions();
@@ -137,4 +115,4 @@ const resetTransformation = function (node: TransformNode) {
   node.scaling = new Vector3(1, 1, 1);
 };
 
-export { bakeGeometryOfAllMeshes };
+export { createMeshFromInstancedMesh, bakeGeometryOfMesh, resetTransformation };

package/src/api/util/structureHelper.ts

@@ -1,7 +1,6 @@
 import { Element } from '../classes/element';
 import { Variant } from '../classes/variant';
 import { VariantInstance } from '../classes/variantInstance';
-import { GltfExportManager } from '../manager/gltfExportManager';
 import { TransformNode } from '@babylonjs/core/Meshes/transformNode';
 import { Tags } from '@babylonjs/core/Misc/tags';
 
@@ -13,10 +12,7 @@ import { Tags } from '@babylonjs/core/Misc/tags';
  */
 const isNodeIncludedInExclusionList = function (node: TransformNode, list: ExcludedGeometryList): boolean {
   const checkNode = (inputNode: TransformNode, nodeToCheck: TransformNode) => {
-    // check name instead of unique id, since the unique id changes when copying the scene, which is the case in the
-    // GLB export
-    const nodeName = nodeToCheck.metadata?.[GltfExportManager.NAME_BEFORE_EXPORT_METADATA_PROPERTY] ?? nodeToCheck.name;
-    return inputNode.name === nodeName;
+    return inputNode.name === nodeToCheck.name;
   };
   const checkElement = (inputEl: Element, nodeToCheck: TransformNode) => {
     return inputEl.nodesFlat.some(m => checkNode(m, nodeToCheck));
@@ -28,8 +24,7 @@ const isNodeIncludedInExclusionList = function (node: TransformNode, list: Exclu
     return inputVarInst.variant.elements.some(el => checkElement(el, nodeToCheck));
   };
   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 nameMatches = inputSubject.nodeName && inputSubject.nodeName === nodeToCheck.name;
     const tagMatches = inputSubject.tagName && Tags.MatchesQuery(nodeToCheck, inputSubject.tagName);
     return nameMatches || tagMatches;
   };