@combeenation/3d-viewer 14.0.1-rc1 → 15.0.0

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

@@ -1,357 +1,356 @@
-import {
-  DynamicTexture,
-  ExcludedGeometryList,
-  GLTF2Export,
-  IExportOptions,
-  InstancedMesh,
-  Material,
-  Mesh,
-  Node,
-  PBRMaterial,
-  RenderTargetTexture,
-  TransformNode,
-  Vector3,
-  Viewer,
-} from '../index';
-import { getIsScaledDownDevice } from '../internal/device-helper';
-import { bakeGeometryOfMesh, createMeshFromInstancedMesh, resetTransformation } from '../internal/geometry-helper';
-import { isNodeExcluded } from '../internal/geometry-helper';
-import { cloneInternalMetadata, getInternalMetadataValue, setInternalMetadataValue } from '../internal/metadata-helper';
-import type { AnimationGroup } from '@babylonjs/core/Animations/animationGroup';
-
-/**
- * Manager for gltf export and augmented reality features
- */
-export class GltfExportManager {
-  protected static readonly _EXPORT_ROOT_NAME = '__export_root__';
-
-  protected _maxTextureSize: number;
-
-  /**
-   * Animation groups which have been removed from the scene before export for AR and which need to be re-added
-   * afterwards.
-   *
-   * AR does not work on Android (i.e. the modelviewer) when animation groups are present in the scene.
-   * See CB-10055 for more details.
-   */
-  protected _animationGroupsToRestore: AnimationGroup[] = [];
-
-  /**
-   * Defines options for the export.
-   * We don't allow the user to overwrite certain settings, since we rely on properties like `removeNoopRootNodes` to
-   * stay `true` in order to make the AR export work.
-   * We could theoretically allow it if AR optimization is not desired, but this may confuse the user.
-   */
-  protected static _gltfExportOptions(optimizeForAR: boolean, excluded?: ExcludedGeometryList): IExportOptions {
-    return {
-      shouldExportNode: function (node: Node): boolean {
-        if (optimizeForAR) {
-          // we explicitely marked nodes, that should be exported in AR mode
-          return getInternalMetadataValue(node, 'exportNode') as boolean;
-        } else {
-          // use the default export node check (enabled state, exclusion list, etc...)
-          return GltfExportManager._shouldExportNode(node, excluded);
-        }
-      },
-    };
-  }
-
-  /**
-   * Checks if a node should be available in the export
-   */
-  protected static _shouldExportNode(node: Node, excluded?: ExcludedGeometryList): boolean {
-    if (!(node instanceof TransformNode)) {
-      return false;
-    }
-    // TODO WTT: think of adding "BackgroundHelper" and nodes with "infiniteDistance" here as well, at least in AR mode
-    if (!node.isEnabled()) {
-      return false;
-    }
-    if (excluded && isNodeExcluded(node, excluded)) {
-      return false;
-    }
-
-    return true;
-  }
-
-  /**
-   * 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
-    this._maxTextureSize = viewer.engine.getCaps().maxTextureSize;
-  }
-
-  /**
-   * Exports selected nodes to a 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 excluded Optional list of geometry (meshes, elements, variants,...) to be excluded from the export.
-   */
-  public async exportGlb(
-    filename = 'glb-export.glb',
-    optimizeForAR: boolean = false,
-    excluded?: ExcludedGeometryList
-  ): Promise<File | undefined> {
-    await this._exportPreProcess(optimizeForAR, excluded);
-
-    const glbData = await GLTF2Export.GLBAsync(
-      this.viewer.scene,
-      'dummy',
-      GltfExportManager._gltfExportOptions(optimizeForAR, excluded)
-    );
-
-    await this._exportPostProcess(optimizeForAR);
-
-    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);
-    } else {
-      // result was not a valid blob
-      return undefined;
-    }
-  }
-
-  /**
-   * Exports selected nodes to GLTF. This may result in more than one file, since textures are exported seperately.
-   * @param filename Name of the main (text-based) .GLTF file referring to separate texture files.
-   * @param optimizeForAR Adjusts the exported GLB so that known issues get automatically fixed, this
-   *                      is mostly targeting Apples .usdz format.
-   * @param excluded Optional list of geometry (meshes, elements, variants,...) to be excluded from the export.
-   */
-  public async exportGltfToFile(
-    filename: string,
-    optimizeForAR: boolean = false,
-    excluded?: ExcludedGeometryList
-  ): Promise<void> {
-    await this._exportPreProcess(optimizeForAR, excluded);
-
-    const gltf = await GLTF2Export.GLTFAsync(
-      this.viewer.scene,
-      filename,
-      GltfExportManager._gltfExportOptions(optimizeForAR, excluded)
-    );
-    gltf.downloadFiles();
-
-    this._exportPostProcess(optimizeForAR);
-  }
-
-  /**
-   * 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 optimizeForAR Adjusts the exported GLB so that known issues get automatically fixed, this
-   *                      is mostly targeting Apples .usdz format.
-   * @param excluded Optional list of geometry (meshes, elements, variants,...) to be excluded from the export.
-   */
-  public async exportGlbToFile(
-    filename: string,
-    optimizeForAR: boolean = false,
-    excluded?: ExcludedGeometryList
-  ): Promise<void> {
-    await this._exportPreProcess(optimizeForAR, excluded);
-
-    const glb = await GLTF2Export.GLBAsync(
-      this.viewer.scene,
-      filename,
-      GltfExportManager._gltfExportOptions(optimizeForAR, excluded)
-    );
-    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, excluded?: ExcludedGeometryList): 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();
-
-    this._animationGroupsToRestore = [...this.viewer.scene.animationGroups];
-    this._animationGroupsToRestore.forEach(x => this.viewer.scene.removeAnimationGroup(x));
-
-    // 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));
-    }
-
-    // since Babylon.js v6 the conversion to right handed GLB coordinate system is done differently
-    // previously the geometry itself has been altered, now they negate the scaling of all root nodes
-    // this is an issue for us, since we will receive this negated scalings in the exported GLB, which leads to issues
-    // on iOS devices
-    // we fix that by adding a top level root node with a negative scaling as well
-    // the exporter just removes this node as he detects a "noop root node" (implementation details of Babylon.js)
-    // everything beneath this node remains untouched
-    // TODO BJS Update: Test AR export on iPhones as well and double check if we still need this special logic
-    const exportRootNode = new TransformNode(GltfExportManager._EXPORT_ROOT_NAME, this.viewer.scene);
-    exportRootNode.scaling = new Vector3(-1, 1, 1);
-    setInternalMetadataValue(exportRootNode, 'exportNode', true);
-    setInternalMetadataValue(exportRootNode, 'deleteAfterExport', true);
-
-    // 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, exportRootNode, 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._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;
-    }
-
-    this._animationGroupsToRestore.forEach(x => this.viewer.scene.addAnimationGroup(x));
-    this._animationGroupsToRestore = [];
-
-    // 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(mat => getInternalMetadataValue(mat, 'deleteAfterExport'))
-      .forEach(material => material.dispose(false, false));
-
-    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, excluded?: ExcludedGeometryList): void {
-    if (!GltfExportManager._shouldExportNode(node, excluded)) {
-      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, excluded));
-  }
-
-  /**
-   * 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') &&
-        // in the desired use cases we want to exclude the export root node
-        // maybe add a parameter if we have to include it in certain scenarios in the future
-        node.name !== GltfExportManager._EXPORT_ROOT_NAME
-    );
-
-    return filteredNodes;
-  }
-}
+import {
+  Animation,
+  DynamicTexture,
+  ExcludedGeometryList,
+  GLTF2Export,
+  IExportOptions,
+  InstancedMesh,
+  Material,
+  Mesh,
+  Node,
+  PBRMaterial,
+  RenderTargetTexture,
+  TransformNode,
+  Vector3,
+  Viewer,
+} from '../index';
+import { getIsScaledDownDevice } from '../internal/device-helper';
+import { bakeGeometryOfMesh, createMeshFromInstancedMesh, resetTransformation } from '../internal/geometry-helper';
+import { isNodeExcluded } from '../internal/geometry-helper';
+import {
+  clearInternalMetadataValue,
+  getInternalMetadataValue,
+  setInternalMetadataValue,
+} from '../internal/metadata-helper';
+
+/**
+ * Manager for gltf export and augmented reality features
+ */
+export class GltfExportManager {
+  protected static readonly _EXPORT_ROOT_NAME = '__export_root__';
+
+  protected _maxTextureSize: number;
+
+  /**
+   * Defines options for the export.
+   * We don't allow the user to overwrite certain settings, since we rely on properties like `removeNoopRootNodes` to
+   * stay `true` in order to make the AR export work.
+   * We could theoretically allow it if AR optimization is not desired, but this may confuse the user.
+   */
+  protected static _gltfExportOptions(optimizeForAR: boolean, excluded?: ExcludedGeometryList): IExportOptions {
+    return {
+      shouldExportNode: function (node: Node): boolean {
+        if (optimizeForAR) {
+          // we explicitely marked nodes, that should be exported in AR mode
+          return getInternalMetadataValue(node, 'exportNode') as boolean;
+        } else {
+          // use the default export node check (enabled state, exclusion list, etc...)
+          return GltfExportManager._shouldExportNode(node, excluded);
+        }
+      },
+
+      shouldExportAnimation: (animation: Animation) => !optimizeForAR,
+    };
+  }
+
+  /**
+   * Checks if a node should be available in the export
+   */
+  protected static _shouldExportNode(node: Node, excluded?: ExcludedGeometryList): boolean {
+    if (!(node instanceof TransformNode)) {
+      return false;
+    }
+    // TODO WTT: think of adding "BackgroundHelper" and nodes with "infiniteDistance" here as well, at least in AR mode
+    if (!node.isEnabled()) {
+      return false;
+    }
+    if (excluded && isNodeExcluded(node, excluded)) {
+      return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * 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)!;
+    // internal metadata may contain large data which slows down the export (CB-10094)
+    // it wasn't an issue for materials yet, but still this is safer than to make a deep clone
+    clonedMaterial._internalMetadata = null;
+    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
+    this._maxTextureSize = viewer.engine.getCaps().maxTextureSize;
+  }
+
+  /**
+   * Exports selected nodes to a 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 excluded Optional list of geometry (meshes, elements, variants,...) to be excluded from the export.
+   */
+  public async exportGlb(
+    filename = 'glb-export.glb',
+    optimizeForAR: boolean = false,
+    excluded?: ExcludedGeometryList
+  ): Promise<File | undefined> {
+    await this._exportPreProcess(optimizeForAR, excluded);
+
+    const glbData = await GLTF2Export.GLBAsync(
+      this.viewer.scene,
+      'dummy',
+      GltfExportManager._gltfExportOptions(optimizeForAR, excluded)
+    );
+
+    await this._exportPostProcess(optimizeForAR);
+
+    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);
+    } else {
+      // result was not a valid blob
+      return undefined;
+    }
+  }
+
+  /**
+   * Exports selected nodes to GLTF. This may result in more than one file, since textures are exported seperately.
+   * @param filename Name of the main (text-based) .GLTF file referring to separate texture files.
+   * @param optimizeForAR Adjusts the exported GLB so that known issues get automatically fixed, this
+   *                      is mostly targeting Apples .usdz format.
+   * @param excluded Optional list of geometry (meshes, elements, variants,...) to be excluded from the export.
+   */
+  public async exportGltfToFile(
+    filename: string,
+    optimizeForAR: boolean = false,
+    excluded?: ExcludedGeometryList
+  ): Promise<void> {
+    await this._exportPreProcess(optimizeForAR, excluded);
+
+    const gltf = await GLTF2Export.GLTFAsync(
+      this.viewer.scene,
+      filename,
+      GltfExportManager._gltfExportOptions(optimizeForAR, excluded)
+    );
+    gltf.downloadFiles();
+
+    this._exportPostProcess(optimizeForAR);
+  }
+
+  /**
+   * 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 optimizeForAR Adjusts the exported GLB so that known issues get automatically fixed, this
+   *                      is mostly targeting Apples .usdz format.
+   * @param excluded Optional list of geometry (meshes, elements, variants,...) to be excluded from the export.
+   */
+  public async exportGlbToFile(
+    filename: string,
+    optimizeForAR: boolean = false,
+    excluded?: ExcludedGeometryList
+  ): Promise<void> {
+    await this._exportPreProcess(optimizeForAR, excluded);
+
+    const glb = await GLTF2Export.GLBAsync(
+      this.viewer.scene,
+      filename,
+      GltfExportManager._gltfExportOptions(optimizeForAR, excluded)
+    );
+    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, excluded?: ExcludedGeometryList): 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));
+    }
+
+    // since Babylon.js v6 the conversion to right handed GLB coordinate system is done differently
+    // previously the geometry itself has been altered, now they negate the scaling of all root nodes
+    // this is an issue for us, since we will receive this negated scalings in the exported GLB, which leads to issues
+    // on iOS devices
+    // we fix that by adding a top level root node with a negative scaling as well
+    // the exporter just removes this node as he detects a "noop root node" (implementation details of Babylon.js)
+    // everything beneath this node remains untouched
+    // TODO BJS Update: Test AR export on iPhones as well and double check if we still need this special logic
+    const exportRootNode = new TransformNode(GltfExportManager._EXPORT_ROOT_NAME, this.viewer.scene);
+    exportRootNode.scaling = new Vector3(-1, 1, 1);
+    setInternalMetadataValue(exportRootNode, 'exportNode', true);
+    setInternalMetadataValue(exportRootNode, 'deleteAfterExport', true);
+
+    // 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, exportRootNode, 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._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, excluded?: ExcludedGeometryList): void {
+    if (!GltfExportManager._shouldExportNode(node, excluded)) {
+      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)!;
+
+    // nodes with node geometry have very large internal metadata, this leads to long export times (CB-10094)
+    // existing internal metadata is not required for the export so we can just delete it
+    // internal metadata will be set some lines beyond!
+    clonedNode._internalMetadata = null;
+
+    // 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, excluded));
+  }
+
+  /**
+   * 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') &&
+        // in the desired use cases we want to exclude the export root node
+        // maybe add a parameter if we have to include it in certain scenarios in the future
+        node.name !== GltfExportManager._EXPORT_ROOT_NAME
+    );
+
+    return filteredNodes;
+  }
+}