@combeenation/3d-viewer 12.4.1 → 12.4.3

package/src/api/manager/gltfExportManager.ts

@@ -1,334 +1,337 @@
-import { Viewer } from '../classes/viewer';
-import { injectMetadata } from '../util/babylonHelper';
-import { getIsScaledDownDevice } from '../util/deviceHelper';
-import { bakeGeometryOfMesh, createMeshFromInstancedMesh, resetTransformation } from '../util/geometryHelper';
-import { isNodeIncludedInExclusionList } from '../util/structureHelper';
-import { PBRMaterial } from '@babylonjs/core/Materials/PBR/pbrMaterial';
-import { DynamicTexture } from '@babylonjs/core/Materials/Textures/dynamicTexture';
-import { RenderTargetTexture } from '@babylonjs/core/Materials/Textures/renderTargetTexture';
-import { Vector3 } from '@babylonjs/core/Maths/math.vector';
-import { InstancedMesh } from '@babylonjs/core/Meshes/instancedMesh';
-import { Mesh } from '@babylonjs/core/Meshes/mesh';
-import { TransformNode } from '@babylonjs/core/Meshes/transformNode';
-import { Node as BjsNode } from '@babylonjs/core/node';
-import '@babylonjs/serializers/glTF/2.0/Extensions/KHR_texture_transform';
-import { GLTF2Export } from '@babylonjs/serializers/glTF/2.0/glTFSerializer';
-
-export class GltfExportManager {
-  protected static readonly _METADATA_PROPS = {
-    exportNode: 'exportNode',
-    deleteAfterExport: 'deleteAfterExport',
-    exchangeMaterialWith: 'exchangeMaterialWith',
-  };
-  protected static readonly _EXPORT_ROOT_NAME = '__export_root__';
-
-  protected _maxTextureSize: number;
-
-  protected 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;
-  }
-
-  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 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) {
-    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) {
-    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) {
-    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();
-    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);
-    injectMetadata(exportRootNode!, {
-      [GltfExportManager._METADATA_PROPS.exportNode]: true,
-      [GltfExportManager._METADATA_PROPS.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 => rootNode.metadata?.[GltfExportManager._METADATA_PROPS.deleteAfterExport])
-      .forEach(rootNode => rootNode.dispose());
-
-    this.viewer.scene.materials
-      .filter(mat => !!mat.metadata?.[GltfExportManager._METADATA_PROPS.deleteAfterExport])
-      .forEach(material => material.dispose(false, false));
-
-    this.viewer.scene.textures
-      .filter(texture => !!texture.metadata?.[GltfExportManager._METADATA_PROPS.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: BjsNode, clonedParent: TransformNode, excluded?: ExcludedGeometryList) {
-    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)!;
-
-    // exchange material
-    if (clonedNode instanceof Mesh) {
-      const exchangeWithMaterial =
-        clonedNode.material?.metadata?.[GltfExportManager._METADATA_PROPS.exchangeMaterialWith];
-      if (exchangeWithMaterial) {
-        clonedNode.material = this.viewer.scene.getMaterialByUniqueID(exchangeWithMaterial);
-      }
-    }
-
-    // signalize that this is a cloned node
-    injectMetadata(clonedNode, {
-      [GltfExportManager._METADATA_PROPS.exportNode]: true,
-      [GltfExportManager._METADATA_PROPS.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) {
-    const nodes: TransformNode[] = [...this.viewer.scene.meshes];
-    if (!meshesOnly) {
-      nodes.push(...this.viewer.scene.transformNodes);
-    }
-
-    const filteredNodes = nodes.filter(
-      node =>
-        !!node.metadata?.[GltfExportManager._METADATA_PROPS.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;
-  }
-
-  /**
-   * 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: BjsNode) {
-        if (optimizeForAR) {
-          // we explicitely marked nodes, that should be exported in AR mode
-          return !!node.metadata?.[GltfExportManager._METADATA_PROPS.exportNode];
-        } 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: BjsNode, excluded?: ExcludedGeometryList): boolean {
-    if (!(node instanceof TransformNode)) {
-      return false;
-    }
-    // TODO: think of adding "BackgroundHelper" and nodes with "infiniteDistance" here as well, at least in AR mode
-    if (!node.isEnabled()) {
-      return false;
-    }
-    if (excluded && isNodeIncludedInExclusionList(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) {
-    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)!;
-    const clonedTextures = clonedMaterial.getActiveTextures();
-
-    // mark all exported textures, so that they will be deleted after the export
-    clonedTextures.forEach(texture =>
-      injectMetadata(texture, { [GltfExportManager._METADATA_PROPS.deleteAfterExport]: true })
-    );
-
-    injectMetadata(material, { [GltfExportManager._METADATA_PROPS.exchangeMaterialWith]: clonedMaterial.uniqueId });
-    injectMetadata(clonedMaterial, { [GltfExportManager._METADATA_PROPS.deleteAfterExport]: true });
-  }
-}
+import { Viewer } from '../classes/viewer';
+import { injectMetadata } from '../util/babylonHelper';
+import { getIsScaledDownDevice } from '../util/deviceHelper';
+import { bakeGeometryOfMesh, createMeshFromInstancedMesh, resetTransformation } from '../util/geometryHelper';
+import { isNodeIncludedInExclusionList } from '../util/structureHelper';
+import type { Animation } from '@babylonjs/core/Animations/animation';
+import { PBRMaterial } from '@babylonjs/core/Materials/PBR/pbrMaterial';
+import { DynamicTexture } from '@babylonjs/core/Materials/Textures/dynamicTexture';
+import { RenderTargetTexture } from '@babylonjs/core/Materials/Textures/renderTargetTexture';
+import { Vector3 } from '@babylonjs/core/Maths/math.vector';
+import { InstancedMesh } from '@babylonjs/core/Meshes/instancedMesh';
+import { Mesh } from '@babylonjs/core/Meshes/mesh';
+import { TransformNode } from '@babylonjs/core/Meshes/transformNode';
+import { Node as BjsNode } from '@babylonjs/core/node';
+import '@babylonjs/serializers/glTF/2.0/Extensions/KHR_texture_transform';
+import { GLTF2Export } from '@babylonjs/serializers/glTF/2.0/glTFSerializer';
+
+export class GltfExportManager {
+  protected static readonly _METADATA_PROPS = {
+    exportNode: 'exportNode',
+    deleteAfterExport: 'deleteAfterExport',
+    exchangeMaterialWith: 'exchangeMaterialWith',
+  };
+  protected static readonly _EXPORT_ROOT_NAME = '__export_root__';
+
+  protected _maxTextureSize: number;
+
+  protected 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;
+  }
+
+  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 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) {
+    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) {
+    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) {
+    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();
+    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);
+    injectMetadata(exportRootNode!, {
+      [GltfExportManager._METADATA_PROPS.exportNode]: true,
+      [GltfExportManager._METADATA_PROPS.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 => rootNode.metadata?.[GltfExportManager._METADATA_PROPS.deleteAfterExport])
+      .forEach(rootNode => rootNode.dispose());
+
+    this.viewer.scene.materials
+      .filter(mat => !!mat.metadata?.[GltfExportManager._METADATA_PROPS.deleteAfterExport])
+      .forEach(material => material.dispose(false, false));
+
+    this.viewer.scene.textures
+      .filter(texture => !!texture.metadata?.[GltfExportManager._METADATA_PROPS.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: BjsNode, clonedParent: TransformNode, excluded?: ExcludedGeometryList) {
+    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)!;
+
+    // exchange material
+    if (clonedNode instanceof Mesh) {
+      const exchangeWithMaterial =
+        clonedNode.material?.metadata?.[GltfExportManager._METADATA_PROPS.exchangeMaterialWith];
+      if (exchangeWithMaterial) {
+        clonedNode.material = this.viewer.scene.getMaterialByUniqueID(exchangeWithMaterial);
+      }
+    }
+
+    // signalize that this is a cloned node
+    injectMetadata(clonedNode, {
+      [GltfExportManager._METADATA_PROPS.exportNode]: true,
+      [GltfExportManager._METADATA_PROPS.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) {
+    const nodes: TransformNode[] = [...this.viewer.scene.meshes];
+    if (!meshesOnly) {
+      nodes.push(...this.viewer.scene.transformNodes);
+    }
+
+    const filteredNodes = nodes.filter(
+      node =>
+        !!node.metadata?.[GltfExportManager._METADATA_PROPS.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;
+  }
+
+  /**
+   * 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: BjsNode) {
+        if (optimizeForAR) {
+          // we explicitely marked nodes, that should be exported in AR mode
+          return !!node.metadata?.[GltfExportManager._METADATA_PROPS.exportNode];
+        } 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: BjsNode, excluded?: ExcludedGeometryList): boolean {
+    if (!(node instanceof TransformNode)) {
+      return false;
+    }
+    // TODO: think of adding "BackgroundHelper" and nodes with "infiniteDistance" here as well, at least in AR mode
+    if (!node.isEnabled()) {
+      return false;
+    }
+    if (excluded && isNodeIncludedInExclusionList(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) {
+    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)!;
+    const clonedTextures = clonedMaterial.getActiveTextures();
+
+    // mark all exported textures, so that they will be deleted after the export
+    clonedTextures.forEach(texture =>
+      injectMetadata(texture, { [GltfExportManager._METADATA_PROPS.deleteAfterExport]: true })
+    );
+
+    injectMetadata(material, { [GltfExportManager._METADATA_PROPS.exchangeMaterialWith]: clonedMaterial.uniqueId });
+    injectMetadata(clonedMaterial, { [GltfExportManager._METADATA_PROPS.deleteAfterExport]: true });
+  }
+}