@combeenation/3d-viewer 18.2.0 → 18.3.0

package/src/manager/gltf-export-manager.ts

@@ -1,27 +1,25 @@
+import { Animation, GLTF2Export, IExportOptions, Node, NodeDescription, Viewer } from '../index';
 import {
-  Animation,
-  DynamicTexture,
-  GLTF2Export,
-  IExportOptions,
-  InstancedMesh,
-  Material,
-  Mesh,
-  Node,
-  NodeDescription,
-  PBRMaterial,
-  RenderTargetTexture,
-  TransformNode,
-  Viewer,
-} from '../index';
-import { getIsScaledDownDevice } from '../internal/device-helper';
-import { bakeGeometryOfMesh, createMeshFromInstancedMesh, resetTransformation } from '../internal/geometry-helper';
-import {
-  clearInternalMetadataValue,
-  cloneInternalMetadata,
-  getInternalMetadataValue,
-  setInternalMetadataValue,
-} from '../internal/metadata-helper';
-import { nodeMatchesAnyCriteria } from '../internal/node-helper';
+  exportPostProcess,
+  exportPreProcess,
+  isExportableTransformNode,
+  normalizeFileName,
+} from '../internal/export-helper';
+import { getInternalMetadataValue } from '../internal/metadata-helper';
+
+/**
+ * Interface TODOS
+ * ===============
+ * - create settings object instead of individual input parameters (optimizeForAR, excludeNodes, fileName)
+ *   - see `DxfExportManager`
+ *   - much more flexible when adding new parameters
+ * - rename functions to create/download, instead of suffixing "ToFile"
+ *   - also see `DxfExportManager`
+ *
+ * Viewer control is directly accessing these functions, so introducing breaking changes here is really annoying, as we
+ * have to add another version switch in the source code of the viewer control.
+ * Maybe there is a chance to update the interface when re-creating the viewer control in the new cfgr editor.
+ */
 
 /**
  * Manager for gltf export and augmented reality features
@@ -43,7 +41,7 @@ export class GltfExportManager {
           return !!getInternalMetadataValue(node, 'exportNode');
         } else {
           // use the default export node check (enabled state, exclusion list, etc...)
-          return GltfExportManager._shouldExportNode(node, excludeNodes);
+          return isExportableTransformNode(node, excludeNodes);
         }
       },
 
@@ -51,64 +49,6 @@ export class GltfExportManager {
     };
   }
 
-  /**
-   * Checks if a node should be available in the export
-   */
-  protected static _shouldExportNode(node: Node, excludeNodes?: NodeDescription[]): boolean {
-    if (!(node instanceof TransformNode)) {
-      return false;
-    }
-
-    // maybe add some other criterias like "hasInfiniteDistance" and "isGeneratedBackgroundMesh" here as well
-    const isExcluded = nodeMatchesAnyCriteria(node, {
-      isInList: excludeNodes,
-      isDisabled: true,
-      isHtmlAnchorMesh: true,
-    });
-
-    return !isExcluded;
-  }
-
-  /**
-   * Creates a clone of the material which should be used for the export.
-   * This is mostly required for recreating textures with lower sizes.
-   * CAUTION: Material exchanging is not supported for materials that contain certain texture types:
-   * - Dynamic textures (Paintables): Cloning dynamic textures doesn't clone the canvas context
-   *   => so the clone is just empty
-   * - Render target textures: Disposing the clone will leave the scene in a "not ready" state
-   *   => this scenario is not fully analyzed yet, but it's not really worth the effort right now, since this kind of
-   *      of texture is not really used ATM
-   */
-  protected static _exchangeMaterial(material: Material): void {
-    const baseTextures = material.getActiveTextures();
-    const hasDynamicTextures = baseTextures.some(texture => texture instanceof DynamicTexture);
-    const hasRenderTargetTextures = baseTextures.some(texture => texture instanceof RenderTargetTexture);
-    if (hasDynamicTextures || hasRenderTargetTextures) {
-      const textureTypesString = [
-        hasDynamicTextures ? 'Dynamic Textures' : '',
-        hasRenderTargetTextures ? 'Render Target Textures' : '',
-      ]
-        .filter(Boolean)
-        .join();
-      console.warn(
-        `Couldn't exchange material "${material.name}" in GLB export, as it contains unsupported texture type(s) (${textureTypesString}). The export will still work, but the textures of this material will keep their original size.`
-      );
-
-      return;
-    }
-
-    const newName = `${material.name}_clone`;
-    const clonedMaterial = material.clone(newName)!;
-    cloneInternalMetadata(material, clonedMaterial);
-    const clonedTextures = clonedMaterial.getActiveTextures();
-
-    // mark all exported textures, so that they will be deleted after the export
-    clonedTextures.forEach(texture => setInternalMetadataValue(texture, 'deleteAfterExport', true));
-
-    setInternalMetadataValue(material, 'exchangeMaterialWith', clonedMaterial.uniqueId);
-    setInternalMetadataValue(clonedMaterial, 'deleteAfterExport', true);
-  }
-
   /** @internal */
   public constructor(protected viewer: Viewer) {
     // store initial max texture size, so that we can restore it in the post processing
@@ -117,17 +57,17 @@ export class GltfExportManager {
 
   /**
    * Exports selected nodes to a file.
-   * @param filename Optional name of the exported .GLB file.
+   * @param fileName Optional name of the exported .GLB file.
    * @param optimizeForAR Adjusts the exported GLB so that known issues get automatically fixed, this
    *                      is mostly targeting Apples .usdz format.
    * @param excludeNodes Optional list of nodes to be excluded from the export.
    */
   public async exportGlb(
-    filename = 'glb-export.glb',
+    fileName?: string,
     optimizeForAR: boolean = false,
     excludeNodes?: NodeDescription[]
   ): Promise<File | undefined> {
-    await this._exportPreProcess(optimizeForAR, excludeNodes);
+    if (optimizeForAR) await exportPreProcess(this.viewer, { excludeNodes, scaleDownTextures: true });
 
     const glbData = await GLTF2Export.GLBAsync(
       this.viewer.scene,
@@ -135,15 +75,13 @@ export class GltfExportManager {
       GltfExportManager._gltfExportOptions(optimizeForAR, excludeNodes)
     );
 
-    await this._exportPostProcess(optimizeForAR);
+    if (optimizeForAR) await exportPostProcess(this.viewer);
 
     const resBlob = glbData.glTFFiles['dummy.glb'];
     // check if result is valid, according to the typings this could also be a string
     if (resBlob instanceof Blob) {
-      if (!filename.endsWith('.glb')) {
-        filename += '.glb';
-      }
-      return new File([resBlob], filename);
+      const normalizedFileName = normalizeFileName(fileName, 'glb', 'glb-export');
+      return new File([resBlob], normalizedFileName);
     } else {
       // result was not a valid blob
       return undefined;
@@ -158,175 +96,44 @@ export class GltfExportManager {
    * @param excludeNodes Optional list of nodes to be excluded from the export.
    */
   public async exportGltfToFile(
-    filename: string,
+    fileName: string,
     optimizeForAR: boolean = false,
     excludeNodes?: NodeDescription[]
   ): Promise<void> {
-    await this._exportPreProcess(optimizeForAR, excludeNodes);
+    if (optimizeForAR) await exportPreProcess(this.viewer, { excludeNodes, scaleDownTextures: true });
 
     const gltf = await GLTF2Export.GLTFAsync(
       this.viewer.scene,
-      filename,
+      // no need to add .glb, as Babylon.js does that internally
+      fileName,
       GltfExportManager._gltfExportOptions(optimizeForAR, excludeNodes)
     );
     gltf.downloadFiles();
 
-    this._exportPostProcess(optimizeForAR);
+    if (optimizeForAR) await exportPostProcess(this.viewer);
   }
 
   /**
    * Exports selected nodes to GLB. This results in one binary file.
-   * @param filename Name of the main (text-based) .GLTF file referring to seperate texture files.
+   * @param fileName Name of the main (text-based) .GLTF file referring to seperate texture files.
    * @param optimizeForAR Adjusts the exported GLB so that known issues get automatically fixed, this
    *                      is mostly targeting Apples .usdz format.
    * @param excludeNodes Optional list of nodes to be excluded from the export.
    */
   public async exportGlbToFile(
-    filename: string,
+    fileName: string,
     optimizeForAR: boolean = false,
     excludeNodes?: NodeDescription[]
   ): Promise<void> {
-    await this._exportPreProcess(optimizeForAR, excludeNodes);
+    if (optimizeForAR) await exportPreProcess(this.viewer, { excludeNodes, scaleDownTextures: true });
 
     const glb = await GLTF2Export.GLBAsync(
       this.viewer.scene,
-      filename,
+      fileName,
       GltfExportManager._gltfExportOptions(optimizeForAR, excludeNodes)
     );
     glb.downloadFiles();
 
-    await this._exportPostProcess(optimizeForAR);
-  }
-
-  /**
-   * Prepares scene for GLB export.
-   * This is very important for AR exports, since we have to do a lot of conversions to satisfy Apples .usdz format.
-   */
-  protected async _exportPreProcess(optimizeForAR: boolean, excludeNodes?: NodeDescription[]): Promise<void> {
-    if (!optimizeForAR) {
-      // actually nothing to do if AR optimization is not required
-      return;
-    }
-
-    // pause rendering, since we are altering the active scene, which should not be visible to the user
-    this.viewer.pauseRendering();
-
-    // exchange materials if required
-    // the AR export should never contain textures larger than 1024 px:
-    // - iOS devices will crash most likely when trying to access AR endpoints with such files
-    // - file size will be reduced, which leads to faster loading times
-    // - textures > 1024 px shouldn't make a difference on mobiles anyway
-    // we don't have to rescale anything if are already on a downscaled device, since the textures are already <= 1024
-    // also we have to be very cautios with copying textures on these devices, since we are potentially very limited
-    // with the available memory
-    const isScaledDownDevice = getIsScaledDownDevice(this.viewer.viewerSettings.limitTextureSize);
-    if (!isScaledDownDevice) {
-      // the idea is to re-create all textures with a smaller texture size
-      // we have to exchange all materials for this to work
-      this.viewer.engine.clearInternalTexturesCache();
-      this.viewer.engine.getCaps().maxTextureSize = 1024;
-
-      this.viewer.scene.materials
-        .filter(material => material instanceof PBRMaterial)
-        .forEach(material => GltfExportManager._exchangeMaterial(material as PBRMaterial));
-    }
-
-    // create clones of each node (recursively), optionally exchange with cloned materials and mark these nodes for the
-    // export
-    this.viewer.scene.rootNodes
-      // .filter(rootNode => rootNode.name !== GltfExportManager._EXPORT_ROOT_NAME)
-      .forEach(rootNode => this._prepareNodeForExport(rootNode, null, excludeNodes));
-
-    // 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._getNodesMarkedForExport(true).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._getNodesMarkedForExport().forEach(node => resetTransformation(node as TransformNode));
-  }
-
-  /**
-   * Cleans up scene after export
-   */
-  protected async _exportPostProcess(optimizeForAR: boolean): Promise<void> {
-    if (!optimizeForAR) {
-      // nothing to do, since no changes have been made without AR optimizations
-      return;
-    }
-
-    // dispose all nodes, materials and textures that have only been created for the export
-    this.viewer.scene.rootNodes
-      .filter(rootNode => getInternalMetadataValue(rootNode, 'deleteAfterExport'))
-      .forEach(rootNode => rootNode.dispose());
-
-    this.viewer.scene.materials
-      .filter(material => getInternalMetadataValue(material, 'deleteAfterExport'))
-      .forEach(material => material.dispose(false, false));
-    // clean up temporary material exchange key for the rest of materials
-    this.viewer.scene.materials.forEach(material => clearInternalMetadataValue(material, 'exchangeMaterialWith'));
-
-    this.viewer.scene.textures
-      .filter(texture => getInternalMetadataValue(texture, 'deleteAfterExport'))
-      .forEach(texture => texture.dispose());
-
-    // reset engines max texture size and resume rendering
-    this.viewer.engine.getCaps().maxTextureSize = this._maxTextureSize;
-    this.viewer.resumeRendering();
-  }
-
-  /**
-   * Creates a clone of the node which should be used for the export.
-   * Also switches to the cloned material if required.
-   */
-  protected _prepareNodeForExport(
-    node: Node,
-    clonedParent: TransformNode | null,
-    excludeNodes?: NodeDescription[]
-  ): void {
-    if (!GltfExportManager._shouldExportNode(node, excludeNodes)) {
-      return;
-    }
-
-    // from here on we only have TransformNodes
-    const transformNode = node as TransformNode;
-
-    // clone original node and create unique name (via uniqueId) for the export
-    const clonedNodeName = `${transformNode.name}_${transformNode.uniqueId}`;
-    const clonedNode =
-      transformNode instanceof InstancedMesh
-        ? createMeshFromInstancedMesh(transformNode, clonedNodeName, clonedParent)
-        : transformNode.clone(clonedNodeName, clonedParent, true)!;
-    cloneInternalMetadata(transformNode, clonedNode);
-
-    // exchange material
-    if (clonedNode instanceof Mesh) {
-      const exchangeWithMaterial =
-        clonedNode.material && getInternalMetadataValue(clonedNode.material, 'exchangeMaterialWith');
-      if (exchangeWithMaterial) {
-        clonedNode.material = this.viewer.scene.getMaterialByUniqueID(exchangeWithMaterial as number);
-      }
-    }
-
-    // signalize that this is a cloned node
-    setInternalMetadataValue(clonedNode, 'exportNode', true);
-    setInternalMetadataValue(clonedNode, 'deleteAfterExport', true);
-
-    // handle children
-    const childs = transformNode.getChildTransformNodes(true);
-    childs.forEach(child => this._prepareNodeForExport(child, clonedNode, excludeNodes));
-  }
-
-  /**
-   * Help function for receiving all nodes that are marked for the export
-   */
-  protected _getNodesMarkedForExport(meshesOnly?: boolean): TransformNode[] {
-    const nodes: TransformNode[] = [...this.viewer.scene.meshes];
-    if (!meshesOnly) {
-      nodes.push(...this.viewer.scene.transformNodes);
-    }
-
-    const filteredNodes = nodes.filter(node => getInternalMetadataValue(node, 'exportNode'));
-    return filteredNodes;
+    if (optimizeForAR) await exportPostProcess(this.viewer);
   }
 }

package/src/viewer.ts

@@ -6,6 +6,7 @@ import {
   DebugManager,
   DefaultSceneSettings,
   DimensionLineManager,
+  DxfExportManager,
   Engine,
   EngineOptions,
   EventManager,
@@ -84,6 +85,7 @@ export class Viewer {
   protected _cameraManager!: CameraManager;
   protected _debugManager!: DebugManager;
   protected _dimensionLineManager!: DimensionLineManager;
+  protected _dxfExportManager!: DxfExportManager;
   protected _eventManager!: EventManager;
   protected _gltfExportManager!: GltfExportManager;
   protected _htmlAnchorManager!: HtmlAnchorManager;
@@ -127,6 +129,9 @@ export class Viewer {
   get dimensionLineManager(): DimensionLineManager {
     return this._dimensionLineManager;
   }
+  get dxfExportManager(): DxfExportManager {
+    return this._dxfExportManager;
+  }
   get eventManager(): EventManager {
     return this._eventManager;
   }
@@ -249,6 +254,7 @@ export class Viewer {
     this._cameraManager = new CameraManager(this);
     this._debugManager = new DebugManager(this);
     this._dimensionLineManager = new DimensionLineManager(this);
+    this._dxfExportManager = new DxfExportManager(this);
     this._eventManager = new EventManager(this);
     this._gltfExportManager = new GltfExportManager(this);
     this._htmlAnchorManager = new HtmlAnchorManager(this);

package/dist/lib-cjs/internal/geometry-helper.d.ts

@@ -1,14 +0,0 @@
-import { InstancedMesh, Mesh, TransformNode } from '../index';
-/**
- * Creates a "standard" mesh from an instanced mesh, by cloning the source mesh and applying transformation data
- */
-export declare function createMeshFromInstancedMesh(instancedMesh: InstancedMesh, newName: string, clonedParent: TransformNode | null): Mesh;
-/**
- * Removes transformation data from the mesh and stores it in the geometry, which is called "baking".
- * Also considers the geometry change from morph targets.
- */
-export declare function bakeGeometryOfMesh(mesh: Mesh): void;
-/**
- * Resets transformation to initial state
- */
-export declare function resetTransformation(node: TransformNode): void;

package/dist/lib-cjs/internal/geometry-helper.js

@@ -1,114 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resetTransformation = exports.bakeGeometryOfMesh = exports.createMeshFromInstancedMesh = void 0;
-const index_1 = require("../index");
-const metadata_helper_1 = require("./metadata-helper");
-/**
- * Creates a "standard" mesh from an instanced mesh, by cloning the source mesh and applying transformation data
- */
-function createMeshFromInstancedMesh(instancedMesh, newName, clonedParent) {
-    // first create a clone of the source mesh
-    const newMesh = instancedMesh.sourceMesh.clone(newName, clonedParent, true);
-    (0, metadata_helper_1.cloneInternalMetadata)(instancedMesh.sourceMesh, newMesh);
-    // 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));
-    return newMesh;
-}
-exports.createMeshFromInstancedMesh = createMeshFromInstancedMesh;
-/**
- * Removes transformation data from the mesh and stores it in the geometry, which is called "baking".
- * Also considers the geometry change from morph targets.
- */
-function bakeGeometryOfMesh(mesh) {
-    if (!mesh.geometry) {
-        // no geometry available, nothing to do
-        return;
-    }
-    // geometries can be shared across multiple meshes, first make them unique to avoid side-effects
-    mesh.makeGeometryUnique();
-    // Babylon.js already provides a function for baking the current skeleton changes into the geometry
-    if (mesh.skeleton) {
-        mesh.applySkeleton(mesh.skeleton);
-        mesh.skeleton = null;
-    }
-    // NOTE: in difference to skeletons and transformations there is no baking function for morph targets (yet)
-    // however another approach could be to re-apply the position and normals data, as there are nice functions for it
-    // - `getPositionData(applySkeleton: boolean = false, applyMorph: boolean = false)`
-    // - `getNormalsData(applySkeleton: boolean = false, applyMorph: boolean = false)`
-    // you can decide if skeletons and morph targets can be added, which is exactly what we want
-    // I'm still hesitant to use it because "tangent" and "UV" kinds are not supported, whereas I'm not sure if it's
-    // required
-    // => try it out when there is enough time for detailed regression tests!
-    const morphTargetManager = mesh.morphTargetManager;
-    const geometry = mesh.geometry;
-    if (morphTargetManager === null || morphTargetManager === void 0 ? void 0 : morphTargetManager.numTargets) {
-        // apply morph target vertices data to mesh geometry
-        // mostly only the "PositionKind" is implemented
-        _bakeMorphTargetManagerIntoVertices(index_1.VertexBuffer.PositionKind, morphTargetManager, geometry);
-        _bakeMorphTargetManagerIntoVertices(index_1.VertexBuffer.NormalKind, morphTargetManager, geometry);
-        _bakeMorphTargetManagerIntoVertices(index_1.VertexBuffer.TangentKind, morphTargetManager, geometry);
-        _bakeMorphTargetManagerIntoVertices(index_1.VertexBuffer.UVKind, morphTargetManager, geometry);
-        // remove morph target manager with all it's morph targets
-        mesh.morphTargetManager = null;
-    }
-    // bake the transformation data in the mesh geometry, fortunately there is already a help function from Babylon.js
-    mesh.bakeCurrentTransformIntoVertices();
-}
-exports.bakeGeometryOfMesh = bakeGeometryOfMesh;
-/**
- * Resets transformation to initial state
- */
-function resetTransformation(node) {
-    node.position = new index_1.Vector3(0, 0, 0);
-    node.rotation = new index_1.Vector3(0, 0, 0);
-    node.rotationQuaternion = null;
-    node.scaling = new index_1.Vector3(1, 1, 1);
-}
-exports.resetTransformation = resetTransformation;
-/**
- * @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
- */
-function _bakeMorphTargetManagerIntoVertices(kind, morphTargetManager, geometry) {
-    const origVerticesData = geometry.getVerticesData(kind);
-    if (!origVerticesData) {
-        // no vertices data for this kind availabe on the mesh geometry
-        return;
-    }
-    let verticesData = [...origVerticesData];
-    for (let i = 0; i < morphTargetManager.numTargets; i++) {
-        const target = morphTargetManager.getTarget(i);
-        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
-            // formula is taken from: https://doc.babylonjs.com/features/featuresDeepDive/mesh/morphTargets#basics
-            verticesData = verticesData.map((oldVal, idx) => oldVal + (targetVerticesData[idx] - origVerticesData[idx]) * target.influence);
-        }
-    }
-    // apply the updated vertices data
-    geometry.setVerticesData(kind, verticesData);
-}
-function _getVerticesDataFromMorphTarget(kind, morphTarget) {
-    switch (kind) {
-        case index_1.VertexBuffer.PositionKind:
-            return morphTarget.getPositions();
-        case index_1.VertexBuffer.NormalKind:
-            return morphTarget.getNormals();
-        case index_1.VertexBuffer.TangentKind:
-            return morphTarget.getTangents();
-        case index_1.VertexBuffer.UVKind:
-            return morphTarget.getUVs();
-    }
-    return null;
-}
-//# sourceMappingURL=geometry-helper.js.map

package/dist/lib-cjs/internal/geometry-helper.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"geometry-helper.js","sourceRoot":"","sources":["../../../src/internal/geometry-helper.ts"],"names":[],"mappings":"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"}

package/src/internal/geometry-helper.ts

@@ -1,144 +0,0 @@
-import {
-  FloatArray,
-  Geometry,
-  InstancedMesh,
-  Mesh,
-  MorphTarget,
-  MorphTargetManager,
-  TransformNode,
-  Vector3,
-  VertexBuffer,
-} from '../index';
-import { cloneInternalMetadata } from './metadata-helper';
-
-/**
- * Creates a "standard" mesh from an instanced mesh, by cloning the source mesh and applying transformation data
- */
-export function createMeshFromInstancedMesh(
-  instancedMesh: InstancedMesh,
-  newName: string,
-  clonedParent: TransformNode | null
-): Mesh {
-  // first create a clone of the source mesh
-  const newMesh = instancedMesh.sourceMesh.clone(newName, clonedParent, true);
-  cloneInternalMetadata(instancedMesh.sourceMesh, newMesh);
-  // 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));
-
-  return newMesh;
-}
-
-/**
- * Removes transformation data from the mesh and stores it in the geometry, which is called "baking".
- * Also considers the geometry change from morph targets.
- */
-export function bakeGeometryOfMesh(mesh: Mesh): void {
-  if (!mesh.geometry) {
-    // no geometry available, nothing to do
-    return;
-  }
-
-  // geometries can be shared across multiple meshes, first make them unique to avoid side-effects
-  mesh.makeGeometryUnique();
-
-  // Babylon.js already provides a function for baking the current skeleton changes into the geometry
-  if (mesh.skeleton) {
-    mesh.applySkeleton(mesh.skeleton);
-    mesh.skeleton = null;
-  }
-
-  // NOTE: in difference to skeletons and transformations there is no baking function for morph targets (yet)
-  // however another approach could be to re-apply the position and normals data, as there are nice functions for it
-  // - `getPositionData(applySkeleton: boolean = false, applyMorph: boolean = false)`
-  // - `getNormalsData(applySkeleton: boolean = false, applyMorph: boolean = false)`
-  // you can decide if skeletons and morph targets can be added, which is exactly what we want
-  // I'm still hesitant to use it because "tangent" and "UV" kinds are not supported, whereas I'm not sure if it's
-  // required
-  // => try it out when there is enough time for detailed regression tests!
-  const morphTargetManager = mesh.morphTargetManager;
-  const geometry = mesh.geometry;
-
-  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);
-
-    // remove morph target manager with all it's morph targets
-    mesh.morphTargetManager = null;
-  }
-
-  // bake the transformation data in the mesh geometry, fortunately there is already a help function from Babylon.js
-  mesh.bakeCurrentTransformIntoVertices();
-}
-
-/**
- * Resets transformation to initial state
- */
-export function resetTransformation(node: TransformNode): void {
-  node.position = new Vector3(0, 0, 0);
-  node.rotation = new Vector3(0, 0, 0);
-  node.rotationQuaternion = null;
-  node.scaling = new Vector3(1, 1, 1);
-}
-
-/**
- * @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
- */
-function _bakeMorphTargetManagerIntoVertices(
-  kind: string,
-  morphTargetManager: MorphTargetManager,
-  geometry: Geometry
-): void {
-  const origVerticesData = geometry.getVerticesData(kind);
-  if (!origVerticesData) {
-    // no vertices data for this kind availabe on the mesh geometry
-    return;
-  }
-
-  let verticesData = [...origVerticesData];
-  for (let i = 0; i < morphTargetManager.numTargets; i++) {
-    const target = morphTargetManager.getTarget(i);
-    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
-      // formula is taken from: https://doc.babylonjs.com/features/featuresDeepDive/mesh/morphTargets#basics
-      verticesData = verticesData.map(
-        (oldVal, idx) => oldVal + (targetVerticesData[idx] - origVerticesData[idx]) * target.influence
-      );
-    }
-  }
-
-  // apply the updated vertices data
-  geometry.setVerticesData(kind, verticesData);
-}
-
-function _getVerticesDataFromMorphTarget(kind: string, morphTarget: MorphTarget): FloatArray | null {
-  switch (kind) {
-    case VertexBuffer.PositionKind:
-      return morphTarget.getPositions();
-    case VertexBuffer.NormalKind:
-      return morphTarget.getNormals();
-    case VertexBuffer.TangentKind:
-      return morphTarget.getTangents();
-    case VertexBuffer.UVKind:
-      return morphTarget.getUVs();
-  }
-
-  return null;
-}