@combeenation/3d-viewer 7.1.3 → 8.1.0-alpha1

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

@@ -1,243 +1,326 @@
-"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());
-    });
-};
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GltfExportManager = void 0;
-const viewer_1 = require("../classes/viewer");
-const babylonHelper_1 = require("../util/babylonHelper");
-const structureHelper_1 = require("../util/structureHelper");
-const pbrMaterial_1 = require("@babylonjs/core/Materials/PBR/pbrMaterial");
-const math_color_1 = require("@babylonjs/core/Maths/math.color");
-const abstractMesh_1 = require("@babylonjs/core/Meshes/abstractMesh");
-const mesh_1 = require("@babylonjs/core/Meshes/mesh");
-const _2_0_1 = require("@babylonjs/serializers/glTF/2.0");
-const lodash_es_1 = require("lodash-es");
-class GltfExportManager {
-    /**
-     * Constructor.
-     */
-    constructor(viewer) {
-        this.viewer = viewer;
-    }
-    /**
-     * Creates an {@link GltfExportManager}.
-     */
-    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 exportOptions export options to be merged with default options.\
-     *                      `exportOptions.createUniqueMeshNames` defaults to `true` if not given.
-     * @param excluded optional list of geometry (meshes, elements, variants, variantInstances) to be excluded from export
-     */
-    exportGlb(filename = 'glb-export.glb', _a = {}, excluded) {
-        var { createUniqueMeshNames = true } = _a, exportOptionsRest = __rest(_a, ["createUniqueMeshNames"]);
-        return __awaiter(this, void 0, void 0, function* () {
-            const exportOptions = Object.assign({ createUniqueMeshNames }, exportOptionsRest);
-            this.exportPreProcess(exportOptions);
-            const glbData = yield _2_0_1.GLTF2Export.GLBAsync(this.viewer.scene, 'dummy', this.gltfExportOptions(exportOptions, excluded));
-            this.exportPostProcess();
-            const resBlob = glbData.glTFFiles['dummy.glb']; // should be only one file for 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 separately.
-     * @param filename name of the main (text-based) .GLTF file referring to separate texture files.
-     * @param exportOptions export options to be merged with default options.\
-     *                      `exportOptions.createUniqueMeshNames` defaults to `true` if not given.
-     * @param excluded optional list of geometry (meshes, elements, variants, variantInstances) to be excluded from export
-     */
-    exportGltfToFile(filename, _a = {}, excluded) {
-        var { createUniqueMeshNames = true } = _a, exportOptionsRest = __rest(_a, ["createUniqueMeshNames"]);
-        return __awaiter(this, void 0, void 0, function* () {
-            const exportOptions = Object.assign({ createUniqueMeshNames }, exportOptionsRest);
-            this.exportPreProcess(exportOptions);
-            yield _2_0_1.GLTF2Export.GLTFAsync(this.viewer.scene, filename, this.gltfExportOptions(exportOptions, excluded)).then(glb => {
-                glb.downloadFiles();
-            });
-            this.exportPostProcess();
-        });
-    }
-    /**
-     * Exports selected nodes to GLB. This results in one binary file.
-     * @param filename name of the .GLB file.
-     * @param exportOptions export options to be merged with default options.\
-     *                      `exportOptions.createUniqueMeshNames` defaults to `true` if not given.
-     * @param excluded optional list of geometry (meshes, elements, variants, variantInstances) to be excluded from export
-     */
-    exportGlbToFile(filename, _a = {}, excluded) {
-        var { createUniqueMeshNames = true } = _a, exportOptionsRest = __rest(_a, ["createUniqueMeshNames"]);
-        return __awaiter(this, void 0, void 0, function* () {
-            const exportOptions = Object.assign({ createUniqueMeshNames }, exportOptionsRest);
-            this.exportPreProcess(exportOptions);
-            yield _2_0_1.GLTF2Export.GLBAsync(this.viewer.scene, filename, this.gltfExportOptions(exportOptions, excluded)).then(glb => {
-                glb.downloadFiles();
-            });
-            this.exportPostProcess();
-        });
-    }
-    /**
-     * Gets predefined {@link IExportOptionsExtended } merged with given ones.
-     */
-    gltfExportOptions(mergeWithOptions = {}, excluded) {
-        const defaultOptions = {
-            // includeCoordinateSystemConversionNodes: true,
-            shouldExportNode: function (node) {
-                if (!node.isEnabled()) {
-                    return false;
-                }
-                if (node.name.startsWith(viewer_1.Viewer.BOUNDING_BOX_NAME)) {
-                    return false;
-                }
-                if (excluded && node instanceof mesh_1.Mesh && (0, structureHelper_1.isMeshIncludedInExclusionList)(node, excluded)) {
-                    return false;
-                }
-                return true;
-            },
-        };
-        return (0, lodash_es_1.merge)({}, defaultOptions, mergeWithOptions);
-    }
-    /**
-     * Stuff to be done before exporting to GLTF
-     */
-    exportPreProcess({ createUniqueMeshNames = true }) {
-        this.viewer.pauseRendering();
-        if (createUniqueMeshNames !== null && createUniqueMeshNames !== void 0 ? createUniqueMeshNames : true) {
-            this.setUniqueMeshNames();
-        }
-        this.exchangeRefractionMaterials();
-    }
-    /**
-     * Stuff to be done after the GLTF export
-     */
-    exportPostProcess() {
-        this.restoreRefractionMaterials();
-        this.restoreOriginalMeshNames();
-        this.viewer.resumeRendering();
-    }
-    /**
-     * Materials with refraction set are not exported properly.
-     * Exchange all such (relevant) materials with a more export-friendly version
-     */
-    exchangeRefractionMaterials() {
-        for (const n of this.viewer.scene.getNodes()) {
-            if (!(n instanceof abstractMesh_1.AbstractMesh))
-                continue;
-            if (!(n.material instanceof pbrMaterial_1.PBRMaterial))
-                continue;
-            if (!n.material.subSurface.isRefractionEnabled)
-                continue;
-            if (n.material.transparencyMode !== pbrMaterial_1.PBRMaterial.PBRMATERIAL_OPAQUE)
-                continue;
-            // if we're here, we have a node holding a material with set refraction whose transparencyMode is set to
-            // PBRMATERIAL_OPAQUE
-            n.material = this.createRefractionMaterialReplacement(n.material);
-        }
-    }
-    /**
-     * Restore original materials with set refraction.
-     */
-    restoreRefractionMaterials() {
-        for (const n of this.viewer.scene.getNodes()) {
-            if (!(n instanceof abstractMesh_1.AbstractMesh))
-                continue;
-            if (!(n.material instanceof pbrMaterial_1.PBRMaterial))
-                continue;
-            if (!this.isMaterialClonedForExport(n.material))
-                continue;
-            // at this point we have a pbrmaterial tagged as cloned in its metadata that's set on a mesh
-            // restore and dispose
-            const currMaterial = n.material;
-            const prevMaterial = this.viewer.scene.getMaterialByUniqueID(n.material.metadata.clonedFrom);
-            if (prevMaterial) {
-                n.material = prevMaterial; // restore previous material
-                currMaterial.dispose(false, true); // dispose of clone
-            }
-        }
-    }
-    /**
-     * Create an export-friendly replacement material for a material using refraction.
-     * @param mat Material to be replaced
-     */
-    createRefractionMaterialReplacement(mat) {
-        // if we're dealing with a clone already, return it instead of cloning
-        if (this.isMaterialClonedForExport(mat))
-            return mat;
-        // change material according to https://www.notion.so/combeenation/Glas-materials-don-t-look-glasy-after-export-d5fda2c6515e4420a8772744d3e6b460
-        const clonedMaterial = mat.clone(mat.name); // clone material. clone uses same name
-        clonedMaterial.metadata = Object.assign(Object.assign({}, mat.metadata), { clonedFrom: mat.uniqueId }); // create shallow copy of metadata on clone. see https://forum.babylonjs.com/t/the-metadata-of-the-mesh-cloned-by-the-instantiatemodelstoscene-method-is-a-shallow-copy/21563
-        clonedMaterial.refractionTexture = null;
-        clonedMaterial.metallicReflectanceTexture = null; // is this the correct one for metallic roughness?
-        clonedMaterial.alpha = 0.7;
-        clonedMaterial.albedoColor = new math_color_1.Color3(0.3, 0.3, 0.3);
-        clonedMaterial.transparencyMode = pbrMaterial_1.PBRMaterial.PBRMATERIAL_ALPHABLEND;
-        clonedMaterial.metallic = 0.65;
-        clonedMaterial.roughness = 0.15;
-        return clonedMaterial;
-    }
-    /**
-     * Inspect if a material was temporarily cloned for GLB export
-     * @param mat Material to be inspected
-     */
-    isMaterialClonedForExport(mat) {
-        var _a;
-        return !!((_a = mat.metadata) === null || _a === void 0 ? void 0 : _a.clonedFrom);
-    }
-    /**
-     * Set unique mesh names for GLB export
-     */
-    setUniqueMeshNames() {
-        this.viewer.scene.meshes.forEach(currMesh => {
-            (0, babylonHelper_1.injectNodeMetadata)(currMesh, { [GltfExportManager.UNIQUE_MESH_METADATA_PROPERTY]: currMesh.name }, false);
-            currMesh.name = `${currMesh.name}_${currMesh.uniqueId}`;
-        });
-    }
-    /**
-     * Restore original mesh names for meshes that were
-     * renamed with {@link setUniqueMeshNames()}
-     */
-    restoreOriginalMeshNames() {
-        this.viewer.scene.meshes.forEach(currMesh => {
-            if ((0, lodash_es_1.has)(currMesh.metadata, GltfExportManager.UNIQUE_MESH_METADATA_PROPERTY)) {
-                currMesh.name = currMesh.metadata[GltfExportManager.UNIQUE_MESH_METADATA_PROPERTY];
-                delete currMesh.metadata[GltfExportManager.UNIQUE_MESH_METADATA_PROPERTY];
-            }
-        });
-    }
-}
-exports.GltfExportManager = GltfExportManager;
-GltfExportManager.UNIQUE_MESH_METADATA_PROPERTY = 'originalName';
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GltfExportManager = void 0;
+const viewer_1 = require("../classes/viewer");
+const babylonHelper_1 = require("../util/babylonHelper");
+const structureHelper_1 = require("../util/structureHelper");
+const engine_1 = require("@babylonjs/core/Engines/engine");
+const sceneLoader_1 = require("@babylonjs/core/Loading/sceneLoader");
+const pbrMaterial_1 = require("@babylonjs/core/Materials/PBR/pbrMaterial");
+const math_color_1 = require("@babylonjs/core/Maths/math.color");
+const math_vector_1 = require("@babylonjs/core/Maths/math.vector");
+const abstractMesh_1 = require("@babylonjs/core/Meshes/abstractMesh");
+const mesh_1 = require("@babylonjs/core/Meshes/mesh");
+const transformNode_1 = require("@babylonjs/core/Meshes/transformNode");
+const sceneSerializer_1 = require("@babylonjs/core/Misc/sceneSerializer");
+const _2_0_1 = require("@babylonjs/serializers/glTF/2.0");
+const lodash_es_1 = require("lodash-es");
+class GltfExportManager {
+    /**
+     * Constructor.
+     */
+    constructor(viewer) {
+        this.viewer = viewer;
+    }
+    /**
+     * Creates an {@link GltfExportManager}.
+     */
+    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 exportOptions export options to be merged with default options.\
+     *                      `exportOptions.exchangeRefractionMaterials` defaults to `true` if not given.
+     * @param optimizeForAR adjusts the exported GLB so that known AR issues get fixed automatically
+     * @param excluded optional list of geometry (meshes, elements, variants, variantInstances) to be excluded from export
+     */
+    exportGlb(filename = 'glb-export.glb', _a = {}, optimizeForAR, excluded) {
+        var { exchangeRefractionMaterials = true } = _a, exportOptions = __rest(_a, ["exchangeRefractionMaterials"]);
+        if (optimizeForAR === void 0) { optimizeForAR = false; }
+        return __awaiter(this, void 0, void 0, function* () {
+            const { scene, sceneCopied } = yield this.exportPreProcess(exchangeRefractionMaterials, optimizeForAR);
+            const glbData = yield _2_0_1.GLTF2Export.GLBAsync(scene, 'dummy', this.gltfExportOptions(exportOptions, excluded));
+            this.exportPostProcess(scene, sceneCopied);
+            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 separately.
+     * @param filename name of the main (text-based) .GLTF file referring to separate texture files.
+     * @param exportOptions export options to be merged with default options.\
+     *                      `exportOptions.exchangeRefractionMaterials` defaults to `true` if not given.
+     * @param optimizeForAR adjusts the exported GLB so that known AR issues get fixed automatically
+     * @param excluded optional list of geometry (meshes, elements, variants, variantInstances) to be excluded from export
+     */
+    exportGltfToFile(filename, _a = {}, optimizeForAR, excluded) {
+        var { exchangeRefractionMaterials = true } = _a, exportOptions = __rest(_a, ["exchangeRefractionMaterials"]);
+        if (optimizeForAR === void 0) { optimizeForAR = false; }
+        return __awaiter(this, void 0, void 0, function* () {
+            const { scene, sceneCopied } = yield this.exportPreProcess(exchangeRefractionMaterials, optimizeForAR);
+            const gltf = yield _2_0_1.GLTF2Export.GLTFAsync(scene, filename, this.gltfExportOptions(exportOptions, excluded));
+            gltf.downloadFiles();
+            this.exportPostProcess(scene, sceneCopied);
+        });
+    }
+    /**
+     * Exports selected nodes to GLB. This results in one binary file.
+     * @param filename name of the .GLB file.
+     * @param exportOptions export options to be merged with default options.\
+     *                      `exportOptions.exchangeRefractionMaterials` defaults to `true` if not given.
+     * @param optimizeForAR adjusts the exported GLB so that known AR issues get fixed automatically
+     * @param excluded optional list of geometry (meshes, elements, variants, variantInstances) to be excluded from export
+     */
+    exportGlbToFile(filename, _a = {}, optimizeForAR, excluded) {
+        var { exchangeRefractionMaterials = true } = _a, exportOptions = __rest(_a, ["exchangeRefractionMaterials"]);
+        if (optimizeForAR === void 0) { optimizeForAR = false; }
+        return __awaiter(this, void 0, void 0, function* () {
+            const { scene, sceneCopied } = yield this.exportPreProcess(exchangeRefractionMaterials, optimizeForAR);
+            const glb = yield _2_0_1.GLTF2Export.GLBAsync(scene, filename, this.gltfExportOptions(exportOptions, excluded));
+            glb.downloadFiles();
+            this.exportPostProcess(scene, sceneCopied);
+        });
+    }
+    /**
+     * Gets predefined {@link IExportOptions } merged with given ones.
+     */
+    gltfExportOptions(mergeWithOptions = {}, excluded) {
+        const defaultOptions = {
+            shouldExportNode: function (node) {
+                if (!node.isEnabled()) {
+                    return false;
+                }
+                if (node.name.startsWith(viewer_1.Viewer.BOUNDING_BOX_NAME)) {
+                    return false;
+                }
+                if (excluded && node instanceof transformNode_1.TransformNode && (0, structureHelper_1.isNodeIncludedInExclusionList)(node, excluded)) {
+                    return false;
+                }
+                return true;
+            },
+        };
+        return (0, lodash_es_1.merge)({}, defaultOptions, mergeWithOptions);
+    }
+    /**
+     * Stuff to be done before exporting to GLTF
+     *
+     * @returns Either the original scene if no adjustments have been made or a copied scene (which can be disposed after
+     * the export) if adjustments have been made
+     */
+    exportPreProcess(exchangeRefractionMaterials, optimizeForAR) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!exchangeRefractionMaterials && !optimizeForAR) {
+                // no need to copy the scene if no adjustments have to be made
+                return { scene: this.viewer.scene, sceneCopied: false };
+            }
+            // copy the scene for the GLB export improvements, so that the original viewer scene remains untouched
+            const copiedScene = yield this.copyViewerScene();
+            if (exchangeRefractionMaterials) {
+                this.exchangeRefractionMaterials(copiedScene);
+            }
+            if (optimizeForAR) {
+                this.setUniqueMeshNames(copiedScene);
+                this.bakeTransformations(copiedScene);
+            }
+            return { scene: copiedScene, sceneCopied: true };
+        });
+    }
+    /**
+     * Create a copy of the viewer scene, which can be further processed and optimized for the GLB export.
+     * There is no "scene.clone" function, therefore the scene is serialized and loaded again to achieve this result.
+     */
+    copyViewerScene() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // required by the scene serializer
+            yield Promise.resolve().then(() => __importStar(require(/* webpackChunkName: "physicsenginecomponent" */ '@babylonjs/core/Physics/physicsEngineComponent')));
+            // copy scene function uses scene serializer, which can't handle "complex" data like classes, function or recursive
+            // data structures in metadata
+            // it basically does a `JSON.stringify` on the metadata
+            // therefore the metadata has to be removed from the nodes before the copy process
+            const metadataArr = this.extractMetadataOfAllNodes();
+            // serialize the scene
+            const serializedScene = yield sceneSerializer_1.SceneSerializer.SerializeAsync(this.viewer.scene);
+            // set the cropped metadata back to the viewer scene nodes
+            this.restoreMetadataOfAllNodes(metadataArr);
+            // load the scene into an invisible "dummy" canvas
+            const offscreenCanvas = new OffscreenCanvas(0, 0);
+            const engine = new engine_1.Engine(offscreenCanvas);
+            sceneLoader_1.SceneLoader.ShowLoadingScreen = false;
+            const newScene = yield sceneLoader_1.SceneLoader.LoadAsync('', 'data:' + JSON.stringify(serializedScene), engine);
+            // this is required for offscreen canvas, otherwise the scene dispose code throws when trying to remove the cursor
+            // events
+            newScene.doNotHandleCursors = true;
+            return newScene;
+        });
+    }
+    /**
+     * Stuff to be done after the GLTF export
+     */
+    exportPostProcess(scene, disposeScene) {
+        if (disposeScene) {
+            // copied scene for GLB export is not needed anymore, therefore it can be removed
+            scene.getEngine().dispose();
+        }
+    }
+    /**
+     * Remove all node metadata and return them in a map
+     */
+    extractMetadataOfAllNodes() {
+        return this.viewer.scene.getNodes().reduce((accMetadataObj, curNode) => {
+            const metadata = curNode.metadata;
+            delete curNode.metadata;
+            return Object.assign(Object.assign({}, accMetadataObj), { [curNode.uniqueId.toString()]: metadata });
+        }, {});
+    }
+    /**
+     * Restore node metadata from previously cropped metadata map
+     */
+    restoreMetadataOfAllNodes(metadataMap) {
+        this.viewer.scene.getNodes().forEach(node => {
+            const metadata = metadataMap[node.uniqueId.toString()];
+            if (metadata) {
+                node.metadata = metadata;
+            }
+        });
+    }
+    /**
+     * Materials with refraction set are not exported properly.
+     * Exchange all such (relevant) materials with a more export-friendly version
+     */
+    exchangeRefractionMaterials(scene) {
+        for (const n of scene.getNodes()) {
+            if (!(n instanceof abstractMesh_1.AbstractMesh))
+                continue;
+            if (!(n.material instanceof pbrMaterial_1.PBRMaterial))
+                continue;
+            if (!n.material.subSurface.isRefractionEnabled)
+                continue;
+            if (n.material.transparencyMode !== pbrMaterial_1.PBRMaterial.PBRMATERIAL_OPAQUE)
+                continue;
+            // if we're here, we have a node holding a material with set refraction whose transparencyMode is set to
+            // PBRMATERIAL_OPAQUE
+            n.material = this.createRefractionMaterialReplacement(n.material);
+        }
+    }
+    /**
+     * Create an export-friendly replacement material for a material using refraction.
+     * @param mat Material to be replaced
+     */
+    createRefractionMaterialReplacement(mat) {
+        // if we're dealing with a clone already, return it instead of cloning
+        if (this.isMaterialClonedForExport(mat))
+            return mat;
+        // change material according to https://www.notion.so/combeenation/Glas-materials-don-t-look-glasy-after-export-d5fda2c6515e4420a8772744d3e6b460
+        const clonedMaterial = mat.clone(mat.name); // clone material. clone uses same name
+        clonedMaterial.metadata = Object.assign(Object.assign({}, mat.metadata), { [GltfExportManager._CLONED_FROM_MAT_METADATA_PROPERTY]: mat.uniqueId }); // create shallow copy of metadata on clone. see https://forum.babylonjs.com/t/the-metadata-of-the-mesh-cloned-by-the-instantiatemodelstoscene-method-is-a-shallow-copy/21563
+        clonedMaterial.refractionTexture = null;
+        clonedMaterial.metallicReflectanceTexture = null; // is this the correct one for metallic roughness?
+        clonedMaterial.alpha = 0.7;
+        clonedMaterial.albedoColor = new math_color_1.Color3(0.3, 0.3, 0.3);
+        clonedMaterial.transparencyMode = pbrMaterial_1.PBRMaterial.PBRMATERIAL_ALPHABLEND;
+        clonedMaterial.metallic = 0.65;
+        clonedMaterial.roughness = 0.15;
+        return clonedMaterial;
+    }
+    /**
+     * Inspect if a material was temporarily cloned for GLB export
+     * @param mat Material to be inspected
+     */
+    isMaterialClonedForExport(mat) {
+        return (0, lodash_es_1.has)(mat.metadata, GltfExportManager._CLONED_FROM_MAT_METADATA_PROPERTY);
+    }
+    /**
+     * Set unique mesh names for GLB export.
+     * Duplicate names lead to problems in AR on iOS devices.
+     */
+    setUniqueMeshNames(scene) {
+        const allNodes = scene.getNodes().filter(node => node instanceof transformNode_1.TransformNode);
+        allNodes.forEach(currMesh => {
+            (0, babylonHelper_1.injectNodeMetadata)(currMesh, { [GltfExportManager.NAME_BEFORE_EXPORT_METADATA_PROPERTY]: currMesh.name }, false);
+            currMesh.name = `${currMesh.name}_${currMesh.uniqueId}`;
+        });
+    }
+    /**
+     * Stores the effect of all mesh transformations in their geometry and reset the transformation afterwards.
+     * In this way negative scalings which lead to problems in AR on iOS devices can be eliminated.
+     */
+    bakeTransformations(scene) {
+        scene.meshes.forEach(mesh => {
+            if (mesh instanceof mesh_1.Mesh && mesh.geometry) {
+                // geometries can be shared across multiple meshes, first make them unique to avoid side-effects
+                mesh.makeGeometryUnique();
+                // this is the core functionality for storing the transformation data in the mesh geometry
+                mesh.bakeCurrentTransformIntoVertices();
+            }
+        });
+        // some nodes (mostly transform nodes), are not affected by the baking algorithm since they have no geometry
+        // => reset their transformation manually
+        const allNodes = scene.getNodes().filter(node => node instanceof transformNode_1.TransformNode);
+        allNodes.forEach(node => {
+            node.position = new math_vector_1.Vector3(0, 0, 0);
+            node.rotation = new math_vector_1.Vector3(0, 0, 0);
+            node.scaling = new math_vector_1.Vector3(1, 1, 1);
+        });
+    }
+}
+exports.GltfExportManager = GltfExportManager;
+GltfExportManager._CLONED_FROM_MAT_METADATA_PROPERTY = 'clonedFrom';
+GltfExportManager.NAME_BEFORE_EXPORT_METADATA_PROPERTY = 'nameBeforeExport';
 //# sourceMappingURL=gltfExportManager.js.map