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

package/dist/lib-cjs/manager/gltf-export-manager.js

@@ -1,279 +1,291 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GltfExportManager = void 0;
-const index_1 = require("../index");
-const device_helper_1 = require("../internal/device-helper");
-const geometry_helper_1 = require("../internal/geometry-helper");
-const geometry_helper_2 = require("../internal/geometry-helper");
-const metadata_helper_1 = require("../internal/metadata-helper");
-/**
- * Manager for gltf export and augmented reality features
- */
-class GltfExportManager {
-    /** @internal */
-    constructor(viewer) {
-        this.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.
-     */
-    static _gltfExportOptions(optimizeForAR, excluded) {
-        return {
-            shouldExportNode: function (node) {
-                if (optimizeForAR) {
-                    // we explicitely marked nodes, that should be exported in AR mode
-                    return (0, metadata_helper_1.getInternalMetadataValue)(node, '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
-     */
-    static _shouldExportNode(node, excluded) {
-        if (!(node instanceof index_1.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 && (0, geometry_helper_2.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
-     */
-    static _exchangeMaterial(material) {
-        const baseTextures = material.getActiveTextures();
-        const hasDynamicTextures = baseTextures.some(texture => texture instanceof index_1.DynamicTexture);
-        const hasRenderTargetTextures = baseTextures.some(texture => texture instanceof index_1.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);
-        (0, metadata_helper_1.cloneInternalMetadata)(material, clonedMaterial);
-        const clonedTextures = clonedMaterial.getActiveTextures();
-        // mark all exported textures, so that they will be deleted after the export
-        clonedTextures.forEach(texture => (0, metadata_helper_1.setInternalMetadataValue)(texture, 'deleteAfterExport', true));
-        (0, metadata_helper_1.setInternalMetadataValue)(material, 'exchangeMaterialWith', clonedMaterial.uniqueId);
-        (0, metadata_helper_1.setInternalMetadataValue)(clonedMaterial, 'deleteAfterExport', true);
-    }
-    /**
-     * 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.
-     */
-    exportGlb(filename = 'glb-export.glb', optimizeForAR = false, excluded) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this._exportPreProcess(optimizeForAR, excluded);
-            const glbData = yield index_1.GLTF2Export.GLBAsync(this.viewer.scene, 'dummy', GltfExportManager._gltfExportOptions(optimizeForAR, excluded));
-            yield 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.
-     */
-    exportGltfToFile(filename, optimizeForAR = false, excluded) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this._exportPreProcess(optimizeForAR, excluded);
-            const gltf = yield index_1.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.
-     */
-    exportGlbToFile(filename, optimizeForAR = false, excluded) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this._exportPreProcess(optimizeForAR, excluded);
-            const glb = yield index_1.GLTF2Export.GLBAsync(this.viewer.scene, filename, GltfExportManager._gltfExportOptions(optimizeForAR, excluded));
-            glb.downloadFiles();
-            yield 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.
-     */
-    _exportPreProcess(optimizeForAR, excluded) {
-        return __awaiter(this, void 0, void 0, function* () {
-            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 = (0, device_helper_1.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 index_1.PBRMaterial)
-                    .forEach(material => GltfExportManager._exchangeMaterial(material));
-            }
-            // 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 index_1.TransformNode(GltfExportManager._EXPORT_ROOT_NAME, this.viewer.scene);
-            exportRootNode.scaling = new index_1.Vector3(-1, 1, 1);
-            (0, metadata_helper_1.setInternalMetadataValue)(exportRootNode, 'exportNode', true);
-            (0, metadata_helper_1.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 => (0, geometry_helper_1.bakeGeometryOfMesh)(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 => (0, geometry_helper_1.resetTransformation)(node));
-        });
-    }
-    /**
-     * Cleans up scene after export
-     */
-    _exportPostProcess(optimizeForAR) {
-        return __awaiter(this, void 0, void 0, function* () {
-            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 => (0, metadata_helper_1.getInternalMetadataValue)(rootNode, 'deleteAfterExport'))
-                .forEach(rootNode => rootNode.dispose());
-            this.viewer.scene.materials
-                .filter(mat => (0, metadata_helper_1.getInternalMetadataValue)(mat, 'deleteAfterExport'))
-                .forEach(material => material.dispose(false, false));
-            this.viewer.scene.textures
-                .filter(texture => (0, metadata_helper_1.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.
-     */
-    _prepareNodeForExport(node, clonedParent, excluded) {
-        if (!GltfExportManager._shouldExportNode(node, excluded)) {
-            return;
-        }
-        // from here on we only have TransformNodes
-        const transformNode = node;
-        // clone original node and create unique name (via uniqueId) for the export
-        const clonedNodeName = `${transformNode.name}_${transformNode.uniqueId}`;
-        const clonedNode = transformNode instanceof index_1.InstancedMesh
-            ? (0, geometry_helper_1.createMeshFromInstancedMesh)(transformNode, clonedNodeName, clonedParent)
-            : transformNode.clone(clonedNodeName, clonedParent, true);
-        (0, metadata_helper_1.cloneInternalMetadata)(transformNode, clonedNode);
-        // exchange material
-        if (clonedNode instanceof index_1.Mesh) {
-            const exchangeWithMaterial = clonedNode.material && (0, metadata_helper_1.getInternalMetadataValue)(clonedNode.material, 'exchangeMaterialWith');
-            if (exchangeWithMaterial) {
-                clonedNode.material = this.viewer.scene.getMaterialByUniqueID(exchangeWithMaterial);
-            }
-        }
-        // signalize that this is a cloned node
-        (0, metadata_helper_1.setInternalMetadataValue)(clonedNode, 'exportNode', true);
-        (0, metadata_helper_1.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
-     */
-    _getNodesMarkedForExport(meshesOnly) {
-        const nodes = [...this.viewer.scene.meshes];
-        if (!meshesOnly) {
-            nodes.push(...this.viewer.scene.transformNodes);
-        }
-        const filteredNodes = nodes.filter(node => (0, metadata_helper_1.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;
-    }
-}
-exports.GltfExportManager = GltfExportManager;
-GltfExportManager._EXPORT_ROOT_NAME = '__export_root__';
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GltfExportManager = void 0;
+const index_1 = require("../index");
+const device_helper_1 = require("../internal/device-helper");
+const geometry_helper_1 = require("../internal/geometry-helper");
+const geometry_helper_2 = require("../internal/geometry-helper");
+const metadata_helper_1 = require("../internal/metadata-helper");
+/**
+ * Manager for gltf export and augmented reality features
+ */
+class GltfExportManager {
+    /** @internal */
+    constructor(viewer) {
+        this.viewer = viewer;
+        /**
+         * 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.
+         */
+        this._animationGroupsToRestore = [];
+        // 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.
+     */
+    static _gltfExportOptions(optimizeForAR, excluded) {
+        return {
+            shouldExportNode: function (node) {
+                if (optimizeForAR) {
+                    // we explicitely marked nodes, that should be exported in AR mode
+                    return (0, metadata_helper_1.getInternalMetadataValue)(node, '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
+     */
+    static _shouldExportNode(node, excluded) {
+        if (!(node instanceof index_1.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 && (0, geometry_helper_2.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
+     */
+    static _exchangeMaterial(material) {
+        const baseTextures = material.getActiveTextures();
+        const hasDynamicTextures = baseTextures.some(texture => texture instanceof index_1.DynamicTexture);
+        const hasRenderTargetTextures = baseTextures.some(texture => texture instanceof index_1.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);
+        (0, metadata_helper_1.cloneInternalMetadata)(material, clonedMaterial);
+        const clonedTextures = clonedMaterial.getActiveTextures();
+        // mark all exported textures, so that they will be deleted after the export
+        clonedTextures.forEach(texture => (0, metadata_helper_1.setInternalMetadataValue)(texture, 'deleteAfterExport', true));
+        (0, metadata_helper_1.setInternalMetadataValue)(material, 'exchangeMaterialWith', clonedMaterial.uniqueId);
+        (0, metadata_helper_1.setInternalMetadataValue)(clonedMaterial, 'deleteAfterExport', true);
+    }
+    /**
+     * 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.
+     */
+    exportGlb(filename = 'glb-export.glb', optimizeForAR = false, excluded) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._exportPreProcess(optimizeForAR, excluded);
+            const glbData = yield index_1.GLTF2Export.GLBAsync(this.viewer.scene, 'dummy', GltfExportManager._gltfExportOptions(optimizeForAR, excluded));
+            yield 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.
+     */
+    exportGltfToFile(filename, optimizeForAR = false, excluded) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._exportPreProcess(optimizeForAR, excluded);
+            const gltf = yield index_1.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.
+     */
+    exportGlbToFile(filename, optimizeForAR = false, excluded) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._exportPreProcess(optimizeForAR, excluded);
+            const glb = yield index_1.GLTF2Export.GLBAsync(this.viewer.scene, filename, GltfExportManager._gltfExportOptions(optimizeForAR, excluded));
+            glb.downloadFiles();
+            yield 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.
+     */
+    _exportPreProcess(optimizeForAR, excluded) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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 = (0, device_helper_1.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 index_1.PBRMaterial)
+                    .forEach(material => GltfExportManager._exchangeMaterial(material));
+            }
+            // 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 index_1.TransformNode(GltfExportManager._EXPORT_ROOT_NAME, this.viewer.scene);
+            exportRootNode.scaling = new index_1.Vector3(-1, 1, 1);
+            (0, metadata_helper_1.setInternalMetadataValue)(exportRootNode, 'exportNode', true);
+            (0, metadata_helper_1.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 => (0, geometry_helper_1.bakeGeometryOfMesh)(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 => (0, geometry_helper_1.resetTransformation)(node));
+        });
+    }
+    /**
+     * Cleans up scene after export
+     */
+    _exportPostProcess(optimizeForAR) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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 => (0, metadata_helper_1.getInternalMetadataValue)(rootNode, 'deleteAfterExport'))
+                .forEach(rootNode => rootNode.dispose());
+            this.viewer.scene.materials
+                .filter(mat => (0, metadata_helper_1.getInternalMetadataValue)(mat, 'deleteAfterExport'))
+                .forEach(material => material.dispose(false, false));
+            this.viewer.scene.textures
+                .filter(texture => (0, metadata_helper_1.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.
+     */
+    _prepareNodeForExport(node, clonedParent, excluded) {
+        if (!GltfExportManager._shouldExportNode(node, excluded)) {
+            return;
+        }
+        // from here on we only have TransformNodes
+        const transformNode = node;
+        // clone original node and create unique name (via uniqueId) for the export
+        const clonedNodeName = `${transformNode.name}_${transformNode.uniqueId}`;
+        const clonedNode = transformNode instanceof index_1.InstancedMesh
+            ? (0, geometry_helper_1.createMeshFromInstancedMesh)(transformNode, clonedNodeName, clonedParent)
+            : transformNode.clone(clonedNodeName, clonedParent, true);
+        (0, metadata_helper_1.cloneInternalMetadata)(transformNode, clonedNode);
+        // exchange material
+        if (clonedNode instanceof index_1.Mesh) {
+            const exchangeWithMaterial = clonedNode.material && (0, metadata_helper_1.getInternalMetadataValue)(clonedNode.material, 'exchangeMaterialWith');
+            if (exchangeWithMaterial) {
+                clonedNode.material = this.viewer.scene.getMaterialByUniqueID(exchangeWithMaterial);
+            }
+        }
+        // signalize that this is a cloned node
+        (0, metadata_helper_1.setInternalMetadataValue)(clonedNode, 'exportNode', true);
+        (0, metadata_helper_1.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
+     */
+    _getNodesMarkedForExport(meshesOnly) {
+        const nodes = [...this.viewer.scene.meshes];
+        if (!meshesOnly) {
+            nodes.push(...this.viewer.scene.transformNodes);
+        }
+        const filteredNodes = nodes.filter(node => (0, metadata_helper_1.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;
+    }
+}
+exports.GltfExportManager = GltfExportManager;
+GltfExportManager._EXPORT_ROOT_NAME = '__export_root__';
 //# sourceMappingURL=gltf-export-manager.js.map