@combeenation/3d-viewer 12.4.1 → 12.4.3

package/dist/lib-cjs/api/manager/gltfExportManager.js

@@ -1,300 +1,301 @@
-"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 babylonHelper_1 = require("../util/babylonHelper");
-const deviceHelper_1 = require("../util/deviceHelper");
-const geometryHelper_1 = require("../util/geometryHelper");
-const structureHelper_1 = require("../util/structureHelper");
-const pbrMaterial_1 = require("@babylonjs/core/Materials/PBR/pbrMaterial");
-const dynamicTexture_1 = require("@babylonjs/core/Materials/Textures/dynamicTexture");
-const renderTargetTexture_1 = require("@babylonjs/core/Materials/Textures/renderTargetTexture");
-const math_vector_1 = require("@babylonjs/core/Maths/math.vector");
-const instancedMesh_1 = require("@babylonjs/core/Meshes/instancedMesh");
-const mesh_1 = require("@babylonjs/core/Meshes/mesh");
-const transformNode_1 = require("@babylonjs/core/Meshes/transformNode");
-require("@babylonjs/serializers/glTF/2.0/Extensions/KHR_texture_transform");
-const glTFSerializer_1 = require("@babylonjs/serializers/glTF/2.0/glTFSerializer");
-class GltfExportManager {
-    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;
-    }
-    static create(viewer) {
-        return __awaiter(this, void 0, void 0, function* () {
-            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.
-     */
-    exportGlb(filename = 'glb-export.glb', optimizeForAR = false, excluded) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this._exportPreProcess(optimizeForAR, excluded);
-            const glbData = yield glTFSerializer_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 glTFSerializer_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 glTFSerializer_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, deviceHelper_1.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_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 transformNode_1.TransformNode(GltfExportManager._EXPORT_ROOT_NAME, this.viewer.scene);
-            exportRootNode.scaling = new math_vector_1.Vector3(-1, 1, 1);
-            (0, babylonHelper_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 => (0, geometryHelper_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, geometryHelper_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 => { var _a; return (_a = rootNode.metadata) === null || _a === void 0 ? void 0 : _a[GltfExportManager._METADATA_PROPS.deleteAfterExport]; })
-                .forEach(rootNode => rootNode.dispose());
-            this.viewer.scene.materials
-                .filter(mat => { var _a; return !!((_a = mat.metadata) === null || _a === void 0 ? void 0 : _a[GltfExportManager._METADATA_PROPS.deleteAfterExport]); })
-                .forEach(material => material.dispose(false, false));
-            this.viewer.scene.textures
-                .filter(texture => { var _a; return !!((_a = texture.metadata) === null || _a === void 0 ? void 0 : _a[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.
-     */
-    _prepareNodeForExport(node, clonedParent, excluded) {
-        var _a, _b;
-        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 instancedMesh_1.InstancedMesh
-            ? (0, geometryHelper_1.createMeshFromInstancedMesh)(transformNode, clonedNodeName, clonedParent)
-            : transformNode.clone(clonedNodeName, clonedParent, true);
-        // exchange material
-        if (clonedNode instanceof mesh_1.Mesh) {
-            const exchangeWithMaterial = (_b = (_a = clonedNode.material) === null || _a === void 0 ? void 0 : _a.metadata) === null || _b === void 0 ? void 0 : _b[GltfExportManager._METADATA_PROPS.exchangeMaterialWith];
-            if (exchangeWithMaterial) {
-                clonedNode.material = this.viewer.scene.getMaterialByUniqueID(exchangeWithMaterial);
-            }
-        }
-        // signalize that this is a cloned node
-        (0, babylonHelper_1.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
-     */
-    _getNodesMarkedForExport(meshesOnly) {
-        const nodes = [...this.viewer.scene.meshes];
-        if (!meshesOnly) {
-            nodes.push(...this.viewer.scene.transformNodes);
-        }
-        const filteredNodes = nodes.filter(node => {
-            var _a;
-            return !!((_a = node.metadata) === null || _a === void 0 ? void 0 : _a[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.
-     */
-    static _gltfExportOptions(optimizeForAR, excluded) {
-        return {
-            shouldExportNode: function (node) {
-                var _a;
-                if (optimizeForAR) {
-                    // we explicitely marked nodes, that should be exported in AR mode
-                    return !!((_a = node.metadata) === null || _a === void 0 ? void 0 : _a[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
-     */
-    static _shouldExportNode(node, excluded) {
-        if (!(node instanceof transformNode_1.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 && (0, structureHelper_1.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
-     */
-    static _exchangeMaterial(material) {
-        const baseTextures = material.getActiveTextures();
-        const hasDynamicTextures = baseTextures.some(texture => texture instanceof dynamicTexture_1.DynamicTexture);
-        const hasRenderTargetTextures = baseTextures.some(texture => texture instanceof renderTargetTexture_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);
-        const clonedTextures = clonedMaterial.getActiveTextures();
-        // mark all exported textures, so that they will be deleted after the export
-        clonedTextures.forEach(texture => (0, babylonHelper_1.injectMetadata)(texture, { [GltfExportManager._METADATA_PROPS.deleteAfterExport]: true }));
-        (0, babylonHelper_1.injectMetadata)(material, { [GltfExportManager._METADATA_PROPS.exchangeMaterialWith]: clonedMaterial.uniqueId });
-        (0, babylonHelper_1.injectMetadata)(clonedMaterial, { [GltfExportManager._METADATA_PROPS.deleteAfterExport]: true });
-    }
-}
-exports.GltfExportManager = GltfExportManager;
-GltfExportManager._METADATA_PROPS = {
-    exportNode: 'exportNode',
-    deleteAfterExport: 'deleteAfterExport',
-    exchangeMaterialWith: 'exchangeMaterialWith',
-};
-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 babylonHelper_1 = require("../util/babylonHelper");
+const deviceHelper_1 = require("../util/deviceHelper");
+const geometryHelper_1 = require("../util/geometryHelper");
+const structureHelper_1 = require("../util/structureHelper");
+const pbrMaterial_1 = require("@babylonjs/core/Materials/PBR/pbrMaterial");
+const dynamicTexture_1 = require("@babylonjs/core/Materials/Textures/dynamicTexture");
+const renderTargetTexture_1 = require("@babylonjs/core/Materials/Textures/renderTargetTexture");
+const math_vector_1 = require("@babylonjs/core/Maths/math.vector");
+const instancedMesh_1 = require("@babylonjs/core/Meshes/instancedMesh");
+const mesh_1 = require("@babylonjs/core/Meshes/mesh");
+const transformNode_1 = require("@babylonjs/core/Meshes/transformNode");
+require("@babylonjs/serializers/glTF/2.0/Extensions/KHR_texture_transform");
+const glTFSerializer_1 = require("@babylonjs/serializers/glTF/2.0/glTFSerializer");
+class GltfExportManager {
+    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;
+    }
+    static create(viewer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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.
+     */
+    exportGlb(filename = 'glb-export.glb', optimizeForAR = false, excluded) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._exportPreProcess(optimizeForAR, excluded);
+            const glbData = yield glTFSerializer_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 glTFSerializer_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 glTFSerializer_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, deviceHelper_1.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_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 transformNode_1.TransformNode(GltfExportManager._EXPORT_ROOT_NAME, this.viewer.scene);
+            exportRootNode.scaling = new math_vector_1.Vector3(-1, 1, 1);
+            (0, babylonHelper_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 => (0, geometryHelper_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, geometryHelper_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 => { var _a; return (_a = rootNode.metadata) === null || _a === void 0 ? void 0 : _a[GltfExportManager._METADATA_PROPS.deleteAfterExport]; })
+                .forEach(rootNode => rootNode.dispose());
+            this.viewer.scene.materials
+                .filter(mat => { var _a; return !!((_a = mat.metadata) === null || _a === void 0 ? void 0 : _a[GltfExportManager._METADATA_PROPS.deleteAfterExport]); })
+                .forEach(material => material.dispose(false, false));
+            this.viewer.scene.textures
+                .filter(texture => { var _a; return !!((_a = texture.metadata) === null || _a === void 0 ? void 0 : _a[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.
+     */
+    _prepareNodeForExport(node, clonedParent, excluded) {
+        var _a, _b;
+        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 instancedMesh_1.InstancedMesh
+            ? (0, geometryHelper_1.createMeshFromInstancedMesh)(transformNode, clonedNodeName, clonedParent)
+            : transformNode.clone(clonedNodeName, clonedParent, true);
+        // exchange material
+        if (clonedNode instanceof mesh_1.Mesh) {
+            const exchangeWithMaterial = (_b = (_a = clonedNode.material) === null || _a === void 0 ? void 0 : _a.metadata) === null || _b === void 0 ? void 0 : _b[GltfExportManager._METADATA_PROPS.exchangeMaterialWith];
+            if (exchangeWithMaterial) {
+                clonedNode.material = this.viewer.scene.getMaterialByUniqueID(exchangeWithMaterial);
+            }
+        }
+        // signalize that this is a cloned node
+        (0, babylonHelper_1.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
+     */
+    _getNodesMarkedForExport(meshesOnly) {
+        const nodes = [...this.viewer.scene.meshes];
+        if (!meshesOnly) {
+            nodes.push(...this.viewer.scene.transformNodes);
+        }
+        const filteredNodes = nodes.filter(node => {
+            var _a;
+            return !!((_a = node.metadata) === null || _a === void 0 ? void 0 : _a[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.
+     */
+    static _gltfExportOptions(optimizeForAR, excluded) {
+        return {
+            shouldExportNode: function (node) {
+                var _a;
+                if (optimizeForAR) {
+                    // we explicitely marked nodes, that should be exported in AR mode
+                    return !!((_a = node.metadata) === null || _a === void 0 ? void 0 : _a[GltfExportManager._METADATA_PROPS.exportNode]);
+                }
+                else {
+                    // use the default export node check (enabled state, exclusion list, etc...)
+                    return GltfExportManager._shouldExportNode(node, excluded);
+                }
+            },
+            shouldExportAnimation: (animation) => !optimizeForAR,
+        };
+    }
+    /**
+     * Checks if a node should be available in the export
+     */
+    static _shouldExportNode(node, excluded) {
+        if (!(node instanceof transformNode_1.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 && (0, structureHelper_1.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
+     */
+    static _exchangeMaterial(material) {
+        const baseTextures = material.getActiveTextures();
+        const hasDynamicTextures = baseTextures.some(texture => texture instanceof dynamicTexture_1.DynamicTexture);
+        const hasRenderTargetTextures = baseTextures.some(texture => texture instanceof renderTargetTexture_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);
+        const clonedTextures = clonedMaterial.getActiveTextures();
+        // mark all exported textures, so that they will be deleted after the export
+        clonedTextures.forEach(texture => (0, babylonHelper_1.injectMetadata)(texture, { [GltfExportManager._METADATA_PROPS.deleteAfterExport]: true }));
+        (0, babylonHelper_1.injectMetadata)(material, { [GltfExportManager._METADATA_PROPS.exchangeMaterialWith]: clonedMaterial.uniqueId });
+        (0, babylonHelper_1.injectMetadata)(clonedMaterial, { [GltfExportManager._METADATA_PROPS.deleteAfterExport]: true });
+    }
+}
+exports.GltfExportManager = GltfExportManager;
+GltfExportManager._METADATA_PROPS = {
+    exportNode: 'exportNode',
+    deleteAfterExport: 'deleteAfterExport',
+    exchangeMaterialWith: 'exchangeMaterialWith',
+};
+GltfExportManager._EXPORT_ROOT_NAME = '__export_root__';
 //# sourceMappingURL=gltfExportManager.js.map