@combeenation/3d-viewer 12.4.1 → 13.0.0

package/src/manager/debugManager.ts

@@ -0,0 +1,245 @@
+import {
+  AxesViewer,
+  BoundingSphere,
+  Color3,
+  DynamicTexture,
+  IInspectorOptions,
+  MeshBuilder,
+  Scene,
+  StandardMaterial,
+  TransformNode,
+  UtilityLayerRenderer,
+  Vector3,
+  Viewer,
+  ViewerEvent,
+} from '../index';
+
+type DebugAxisKeys = 'X' | 'Y' | 'Z';
+type DebugAxisConfig = { color: Color3; position: Vector3 };
+
+/**
+ * Manager for debugging functionalities
+ */
+export class DebugManager {
+  protected static _DEBUG_AXIS_MAP: Record<DebugAxisKeys, DebugAxisConfig> = {
+    X: { color: Color3.Red().scale(0.5), position: new Vector3(1, 0, 0) },
+    Y: { color: Color3.Green().scale(0.5), position: new Vector3(0, 1, 0) },
+    Z: { color: Color3.Blue().scale(0.5), position: new Vector3(0, 0, 1) },
+  };
+  protected static _WORLD_COORD_ROOT_KEY = '__world_coordinates__';
+  protected static _BOUNDING_SPHERE_KEY = '__bounding_sphere__';
+
+  protected _axesViewer: AxesViewer | null = null;
+  protected _showBoundingSphereForAutofocus: boolean = false;
+
+  /** @internal */
+  public constructor(protected viewer: Viewer) {}
+
+  /**
+   * Assign callback for drawing bounding sphere on autofocusing
+   * @internal
+   */
+  public registerAutofocusStartListener(): void {
+    this.viewer.eventManager.addListener(ViewerEvent.AutofocusStart, boundingSphere =>
+      this._drawBoundingSphereForAutofocus(boundingSphere)
+    );
+  }
+
+  /**
+   * Enables the Babylon.js [Inspector](https://doc.babylonjs.com/toolsAndResources/tools/inspector).\
+   * Due to the additional size of the inspector, this function is only available in "development" builds!
+   *
+   * @returns Signalizes if inspector could be loaded
+   */
+  public async showInspector(options?: IInspectorOptions): Promise<boolean> {
+    if (process.env.NODE_ENV === 'development') {
+      const inspModule = await import(/* webpackChunkName: "inspector"*/ '@babylonjs/inspector');
+
+      if (!options && window.Cbn) {
+        // special case for usage in Combeenation configurator:
+        // if no options are set the inspector will be rendered into the parent element of the configurator
+        // in this way the configurator layout itself will not be affected by the inspector
+        const cfgrParentEl = window.Cbn.utils.Viewer3dHelper.getCfgrParentDomElementForInspector();
+        inspModule.Inspector.Show(this.viewer.scene, { globalRoot: cfgrParentEl });
+      } else {
+        inspModule.Inspector.Show(this.viewer.scene, options ?? {});
+      }
+
+      // load additional packages for certain inspector features like "node material editor"
+      // this is done after showing the debug layer to save time
+      await import(/* webpackChunkName: "node-material-editor" */ '@babylonjs/node-editor');
+      await import(/* webpackChunkName: "node-geometry-editor" */ '@babylonjs/node-geometry-editor');
+
+      return true;
+    } else {
+      // inspector not available, set according warning message in console
+      if (window.Cbn) {
+        console.warn(`Inspector not loaded. 
+The inspector can only be used in development builds (e.g. during development with watch mode, in the configurator preview, ...)
+but not in production (e.g. production build of Custom JS, published configurator, ...).`);
+      } else {
+        console.warn(`Inspector not loaded. 
+The inspector can only be used in development builds.`);
+      }
+
+      return false;
+    }
+  }
+
+  public hideInspector(): void {
+    this.viewer.scene.debugLayer?.hide();
+  }
+
+  /**
+   * Show world coordinate system with given dimension.\
+   * This is especially usefull when working on project with tricky positioning. (e.g. clones)
+   */
+  public showWorldCoordinates(dimension: number): void {
+    // make sure to remove already existing debug coordinate systems
+    this.hideWorldCoordinates();
+
+    // draw in utility layer, so that there is no interaction with the actually scene content
+    // (e.g. glb export, autofocus)
+    const utilityLayerScene = UtilityLayerRenderer.DefaultUtilityLayer.utilityLayerScene;
+
+    const worldCoordRoot = new TransformNode(DebugManager._WORLD_COORD_ROOT_KEY, utilityLayerScene);
+    // axes viewer coordinate system is a bit too large
+    // multiply with unify factor to create arrows which exactly match the length of the input dimension
+    const factor = DebugManager._getWorldCoordinatesAxesUnifyFactor();
+    this._axesViewer = new AxesViewer(utilityLayerScene, dimension * factor);
+
+    DebugManager._prepareWorldCoordinateAxis('X', this._axesViewer.xAxis, worldCoordRoot, dimension, utilityLayerScene);
+    DebugManager._prepareWorldCoordinateAxis('Y', this._axesViewer.yAxis, worldCoordRoot, dimension, utilityLayerScene);
+    DebugManager._prepareWorldCoordinateAxis('Z', this._axesViewer.zAxis, worldCoordRoot, dimension, utilityLayerScene);
+  }
+
+  public hideWorldCoordinates(): void {
+    const utilityLayerScene = UtilityLayerRenderer.DefaultUtilityLayer.utilityLayerScene;
+
+    this._axesViewer?.dispose();
+    this._axesViewer = null;
+
+    const worldCoordRoot = utilityLayerScene.getTransformNodeByName(DebugManager._WORLD_COORD_ROOT_KEY);
+    if (worldCoordRoot) {
+      worldCoordRoot.dispose(false, true);
+    }
+  }
+
+  /**
+   * Draws a wireframe bounding sphere on the next call of {@link CameraManager.autofocusActiveCamera}.\
+   * This is usefull for checking which parts of the scene get centered.
+   */
+  public showBoundingSphereForAutofocus(): void {
+    this._showBoundingSphereForAutofocus = true;
+  }
+
+  public hideBoundingSphereForAutofocus(): void {
+    this._showBoundingSphereForAutofocus = false;
+    this._removeBoundingSphereForAutofocus();
+  }
+
+  /**
+   * Adjust and enhance coordinate axes to fulfill our needs.
+   * - moves nodes into common root
+   * - adds text node
+   */
+  protected static _prepareWorldCoordinateAxis(
+    text: 'X' | 'Y' | 'Z',
+    axis: TransformNode,
+    root: TransformNode,
+    dimension: number,
+    utilityLayerScene: Scene
+  ): void {
+    // create unique names
+    axis.name = `${DebugManager._WORLD_COORD_ROOT_KEY}.${text}`;
+    axis.parent = root;
+
+    // create text mesh via dynamic texture
+    const dynamicTexture = new DynamicTexture(
+      `${DebugManager._WORLD_COORD_ROOT_KEY}.${text}`,
+      50,
+      utilityLayerScene,
+      true
+    );
+    dynamicTexture.hasAlpha = true;
+    // 42.5 is a magic offset, so that the text is vertically centered for font size 50px
+    // horizontal centering works well with the standard behaviour of Babylon.js (setting "null" as "width")
+    dynamicTexture.drawText(text, null, 42.5, 'bold 50px Arial', 'white', 'transparent', true);
+
+    const material = new StandardMaterial(`${DebugManager._WORLD_COORD_ROOT_KEY}.${text}`, utilityLayerScene);
+    material.disableLighting = true;
+    material.emissiveColor = DebugManager._DEBUG_AXIS_MAP[text].color;
+    material.diffuseTexture = dynamicTexture;
+
+    const plane = MeshBuilder.CreatePlane(
+      `${DebugManager._WORLD_COORD_ROOT_KEY}.${text}.TextPlane`,
+      { size: dimension / 10 },
+      utilityLayerScene
+    );
+    // make sure that text is located outside of arrow
+    plane.position = DebugManager._DEBUG_AXIS_MAP[text].position.multiplyByFloats(
+      dimension * 1.05,
+      dimension * 1.05,
+      dimension * 1.05
+    );
+    plane.parent = root;
+    plane.material = material;
+    // will be rendered on top of "default" meshes => taken from Babylon.js repo "AxesViewer" implementation
+    plane.renderingGroupId = 2;
+    // setting billboard mode ensures, that the text is always readable
+    plane.billboardMode = TransformNode.BILLBOARDMODE_ALL;
+  }
+
+  /**
+   * Calculate factor for creating world coordinate axes with exactly one unit in length
+   */
+  protected static _getWorldCoordinatesAxesUnifyFactor(): number {
+    // These constants are taken from the Babylon.js repository
+    const coneZPosOffset = 0.3;
+    const coneHeight = 0.075;
+    const baseScaling = 4;
+
+    // cone is moved 0.3 units away from the center
+    // the origin of the cone will be located on 1.2, if combined with the base scaling of 4
+    // invert that offset to get the origin to 1
+    // also consider the cone height to move the tip of the cone to 1 instead the center
+    const factor = 1 / ((coneZPosOffset + coneHeight / 2) * baseScaling);
+
+    return factor;
+  }
+
+  /**
+   * Visualize bounding sphere which is used to zoom in via `autofocusActiveCamera` function
+   */
+  protected _drawBoundingSphereForAutofocus(boundingSphere: BoundingSphere): void {
+    if (!this._showBoundingSphereForAutofocus) {
+      return;
+    }
+
+    this._removeBoundingSphereForAutofocus();
+
+    const utilityLayerScene = UtilityLayerRenderer.DefaultUtilityLayer.utilityLayerScene;
+    let boundingMaterial = utilityLayerScene.getMaterialByName(DebugManager._BOUNDING_SPHERE_KEY);
+    if (!boundingMaterial) {
+      boundingMaterial = new StandardMaterial(DebugManager._BOUNDING_SPHERE_KEY, utilityLayerScene);
+      boundingMaterial.wireframe = true;
+      boundingMaterial.alpha = 0.1;
+      (boundingMaterial as StandardMaterial).emissiveColor = new Color3(1, 1, 1);
+    }
+
+    const sphere = MeshBuilder.CreateSphere(
+      DebugManager._BOUNDING_SPHERE_KEY,
+      { diameter: boundingSphere.radius * 2 },
+      utilityLayerScene
+    );
+    sphere.position = boundingSphere.center;
+    sphere.material = boundingMaterial;
+    sphere.isPickable = false;
+  }
+
+  protected _removeBoundingSphereForAutofocus(): void {
+    const utilityLayerScene = UtilityLayerRenderer.DefaultUtilityLayer.utilityLayerScene;
+    const existingSphere = utilityLayerScene.getMeshByName(DebugManager._BOUNDING_SPHERE_KEY);
+    existingSphere?.dispose();
+  }
+}

package/src/manager/eventManager.ts

@@ -0,0 +1,72 @@
+import { Viewer } from '../index';
+import EventEmitter from 'eventemitter3';
+
+// NOTE: ATM we expose only very few events, due to the following reasons:
+// - Code is generally asynchronous and can be awaited by consumer
+// - We don't want to bloat the code with events that are never used
+
+/**
+ * Events that are fired by the viewer
+ */
+export enum ViewerEvent {
+  /**
+   * Requested material is not available in the scene yet and is about to be created
+   * @param materialId
+   */
+  MaterialCreationStart = 'MaterialCreationStart',
+  /**
+   * Material creation has been finished, that includes:
+   *   - Load definition from Combeenation server
+   *   - Load all textures
+   *   - Compile shader
+   * @param materialId
+   * @param allMaterialsCreated signalizes that no more materials are currently being created
+   */
+  MaterialCreationEnd = 'MaterialCreationEnd',
+  /**
+   * Bounding sphere for autofocusing camera has been calculated.
+   * This is used internally for debugging purposes.
+   * @param boundingSphere
+   */
+  AutofocusStart = 'AutofocusStart',
+}
+
+/**
+ * Manager for eventing system, which ATM is only a slim wrapper about the "eventemitter3" library
+ */
+export class EventManager {
+  protected _eventEmitter: EventEmitter;
+
+  /** @internal */
+  public constructor(protected viewer: Viewer) {
+    this._eventEmitter = new EventEmitter();
+  }
+
+  /**
+   * Used @internal to fire a viewer event
+   */
+  public fireEvent(event: ViewerEvent, ...args: any[]): void {
+    this._eventEmitter.emit(event, ...args);
+  }
+
+  /**
+   * Add listener to certain viewer event
+   */
+  public addListener(event: ViewerEvent, fn: EventEmitter.ListenerFn): void {
+    this._eventEmitter.addListener(event, fn);
+  }
+
+  /**
+   * Remove listener to viewer event
+   */
+  public removeListener(event: ViewerEvent, fn: EventEmitter.ListenerFn): void {
+    this._eventEmitter.removeListener(event, fn);
+  }
+
+  /**
+   * Used @internal to clean eventing sytem before viewer destruction
+   */
+  public removeAllListeners(event?: ViewerEvent): void {
+    this._eventEmitter.removeAllListeners(event);
+  }
+}

package/src/{api/manager → manager}/gltfExportManager.ts

@@ -1,36 +1,113 @@
-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';
-
+import {
+  DynamicTexture,
+  ExcludedGeometryList,
+  GLTF2Export,
+  IExportOptions,
+  InstancedMesh,
+  Material,
+  Mesh,
+  Node,
+  PBRMaterial,
+  RenderTargetTexture,
+  TransformNode,
+  Vector3,
+  Viewer,
+} from '../index';
+import { getIsScaledDownDevice } from '../internal/deviceHelper';
+import { bakeGeometryOfMesh, createMeshFromInstancedMesh, resetTransformation } from '../internal/geometryHelper';
+import { isNodeExcluded } from '../internal/geometryHelper';
+import { cloneInternalMetadata, getInternalMetadataValue, setInternalMetadataValue } from '../internal/metadataHelper';
+
+/**
+ * Manager for gltf export and augmented reality features
+ */
 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;
+  /**
+   * 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);
   }
 
-  public static async create(viewer: Viewer): Promise<GltfExportManager> {
-    return new GltfExportManager(viewer);
+  /** @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;
   }
 
   /**
@@ -40,7 +117,11 @@ export class GltfExportManager {
    *                      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) {
+  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(
@@ -71,7 +152,11 @@ export class GltfExportManager {
    *                      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) {
+  public async exportGltfToFile(
+    filename: string,
+    optimizeForAR: boolean = false,
+    excluded?: ExcludedGeometryList
+  ): Promise<void> {
     await this._exportPreProcess(optimizeForAR, excluded);
 
     const gltf = await GLTF2Export.GLTFAsync(
@@ -91,7 +176,11 @@ export class GltfExportManager {
    *                      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) {
+  public async exportGlbToFile(
+    filename: string,
+    optimizeForAR: boolean = false,
+    excluded?: ExcludedGeometryList
+  ): Promise<void> {
     await this._exportPreProcess(optimizeForAR, excluded);
 
     const glb = await GLTF2Export.GLBAsync(
@@ -125,7 +214,7 @@ export class GltfExportManager {
     // 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();
+    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
@@ -147,10 +236,8 @@ export class GltfExportManager {
     // 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,
-    });
+    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
@@ -178,15 +265,15 @@ export class GltfExportManager {
 
     // 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])
+      .filter(rootNode => getInternalMetadataValue(rootNode, 'deleteAfterExport'))
       .forEach(rootNode => rootNode.dispose());
 
     this.viewer.scene.materials
-      .filter(mat => !!mat.metadata?.[GltfExportManager._METADATA_PROPS.deleteAfterExport])
+      .filter(mat => getInternalMetadataValue(mat, 'deleteAfterExport'))
       .forEach(material => material.dispose(false, false));
 
     this.viewer.scene.textures
-      .filter(texture => !!texture.metadata?.[GltfExportManager._METADATA_PROPS.deleteAfterExport])
+      .filter(texture => getInternalMetadataValue(texture, 'deleteAfterExport'))
       .forEach(texture => texture.dispose());
 
     // reset engines max texture size and resume rendering
@@ -198,7 +285,7 @@ export class GltfExportManager {
    * 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) {
+  protected _prepareNodeForExport(node: Node, clonedParent: TransformNode, excluded?: ExcludedGeometryList): void {
     if (!GltfExportManager._shouldExportNode(node, excluded)) {
       return;
     }
@@ -212,21 +299,20 @@ export class GltfExportManager {
       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?.metadata?.[GltfExportManager._METADATA_PROPS.exchangeMaterialWith];
+        clonedNode.material && getInternalMetadataValue(clonedNode.material, 'exchangeMaterialWith');
       if (exchangeWithMaterial) {
-        clonedNode.material = this.viewer.scene.getMaterialByUniqueID(exchangeWithMaterial);
+        clonedNode.material = this.viewer.scene.getMaterialByUniqueID(exchangeWithMaterial as number);
       }
     }
 
     // signalize that this is a cloned node
-    injectMetadata(clonedNode, {
-      [GltfExportManager._METADATA_PROPS.exportNode]: true,
-      [GltfExportManager._METADATA_PROPS.deleteAfterExport]: true,
-    });
+    setInternalMetadataValue(clonedNode, 'exportNode', true);
+    setInternalMetadataValue(clonedNode, 'deleteAfterExport', true);
 
     // handle children
     const childs = transformNode.getChildTransformNodes(true);
@@ -236,7 +322,7 @@ export class GltfExportManager {
   /**
    * Help function for receiving all nodes that are marked for the export
    */
-  protected _getNodesMarkedForExport(meshesOnly?: boolean) {
+  protected _getNodesMarkedForExport(meshesOnly?: boolean): TransformNode[] {
     const nodes: TransformNode[] = [...this.viewer.scene.meshes];
     if (!meshesOnly) {
       nodes.push(...this.viewer.scene.transformNodes);
@@ -244,7 +330,7 @@ export class GltfExportManager {
 
     const filteredNodes = nodes.filter(
       node =>
-        !!node.metadata?.[GltfExportManager._METADATA_PROPS.exportNode] &&
+        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
@@ -252,83 +338,4 @@ export class GltfExportManager {
 
     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 });
-  }
 }