@babylonjs/serializers 5.20.0 → 5.22.1

package/glTF/2.0/glTFMaterialExporter.js

@@ -1,4 +1,3 @@
-import { __awaiter, __generator } from "tslib";
 import { Vector2 } from "@babylonjs/core/Maths/math.vector.js";
 import { Color3 } from "@babylonjs/core/Maths/math.color.js";
 import { Scalar } from "@babylonjs/core/Maths/math.scalar.js";
@@ -11,8 +10,8 @@ import { Constants } from "@babylonjs/core/Engines/constants.js";
  * Utility methods for working with glTF material conversion properties.  This class should only be used internally
  * @hidden
  */
-var _GLTFMaterialExporter = /** @class */ (function () {
-    function _GLTFMaterialExporter(exporter) {
+export class _GLTFMaterialExporter {
+    constructor(exporter) {
         /**
          * Mapping to store textures
          */
@@ -26,47 +25,46 @@ var _GLTFMaterialExporter = /** @class */ (function () {
      * @param color2 second color to compare to
      * @param epsilon threshold value
      */
-    _GLTFMaterialExporter._FuzzyEquals = function (color1, color2, epsilon) {
+    static _FuzzyEquals(color1, color2, epsilon) {
         return Scalar.WithinEpsilon(color1.r, color2.r, epsilon) && Scalar.WithinEpsilon(color1.g, color2.g, epsilon) && Scalar.WithinEpsilon(color1.b, color2.b, epsilon);
-    };
+    }
     /**
      * Gets the materials from a Babylon scene and converts them to glTF materials
      * @param exportMaterials
      * @param mimeType texture mime type
      * @param hasTextureCoords specifies if texture coordinates are present on the material
      */
-    _GLTFMaterialExporter.prototype._convertMaterialsToGLTFAsync = function (exportMaterials, mimeType, hasTextureCoords) {
-        var _this = this;
-        var promises = [];
-        exportMaterials.forEach(function (material) {
+    _convertMaterialsToGLTFAsync(exportMaterials, mimeType, hasTextureCoords) {
+        const promises = [];
+        exportMaterials.forEach((material) => {
             if (material.getClassName() === "StandardMaterial") {
-                promises.push(_this._convertStandardMaterialAsync(material, mimeType, hasTextureCoords));
+                promises.push(this._convertStandardMaterialAsync(material, mimeType, hasTextureCoords));
             }
             else if (material.getClassName().indexOf("PBR") !== -1) {
-                promises.push(_this._convertPBRMaterialAsync(material, mimeType, hasTextureCoords));
+                promises.push(this._convertPBRMaterialAsync(material, mimeType, hasTextureCoords));
             }
             else {
-                Tools.Warn("Unsupported material type: ".concat(material.name));
+                Tools.Warn(`Unsupported material type: ${material.name}`);
             }
         });
-        return Promise.all(promises).then(function () {
+        return Promise.all(promises).then(() => {
             /* do nothing */
         });
-    };
+    }
     /**
      * Makes a copy of the glTF material without the texture parameters
      * @param originalMaterial original glTF material
      * @returns glTF material without texture parameters
      */
-    _GLTFMaterialExporter.prototype._stripTexturesFromMaterial = function (originalMaterial) {
-        var newMaterial = {};
+    _stripTexturesFromMaterial(originalMaterial) {
+        const newMaterial = {};
         if (originalMaterial) {
             newMaterial.name = originalMaterial.name;
             newMaterial.doubleSided = originalMaterial.doubleSided;
             newMaterial.alphaMode = originalMaterial.alphaMode;
             newMaterial.alphaCutoff = originalMaterial.alphaCutoff;
             newMaterial.emissiveFactor = originalMaterial.emissiveFactor;
-            var originalPBRMetallicRoughness = originalMaterial.pbrMetallicRoughness;
+            const originalPBRMetallicRoughness = originalMaterial.pbrMetallicRoughness;
             if (originalPBRMetallicRoughness) {
                 newMaterial.pbrMetallicRoughness = {};
                 newMaterial.pbrMetallicRoughness.baseColorFactor = originalPBRMetallicRoughness.baseColorFactor;
@@ -75,53 +73,52 @@ var _GLTFMaterialExporter = /** @class */ (function () {
             }
         }
         return newMaterial;
-    };
+    }
     /**
      * Specifies if the material has any texture parameters present
      * @param material glTF Material
      * @returns boolean specifying if texture parameters are present
      */
-    _GLTFMaterialExporter.prototype._hasTexturesPresent = function (material) {
-        var _a;
+    _hasTexturesPresent(material) {
         if (material.emissiveTexture || material.normalTexture || material.occlusionTexture) {
             return true;
         }
-        var pbrMat = material.pbrMetallicRoughness;
+        const pbrMat = material.pbrMetallicRoughness;
         if (pbrMat) {
             if (pbrMat.baseColorTexture || pbrMat.metallicRoughnessTexture) {
                 return true;
             }
         }
         if (material.extensions) {
-            for (var extension in material.extensions) {
-                var extensionObject = material.extensions[extension];
+            for (const extension in material.extensions) {
+                const extensionObject = material.extensions[extension];
                 if (extensionObject) {
-                    return (_a = extensionObject.hasTextures) === null || _a === void 0 ? void 0 : _a.call(extensionObject);
+                    return extensionObject.hasTextures?.();
                 }
             }
         }
         return false;
-    };
-    _GLTFMaterialExporter.prototype._getTextureInfo = function (babylonTexture) {
+    }
+    _getTextureInfo(babylonTexture) {
         if (babylonTexture) {
-            var textureUid = babylonTexture.uid;
+            const textureUid = babylonTexture.uid;
             if (textureUid in this._textureMap) {
                 return this._textureMap[textureUid];
             }
         }
         return null;
-    };
+    }
     /**
      * Converts a Babylon StandardMaterial to a glTF Metallic Roughness Material
      * @param babylonStandardMaterial
      * @returns glTF Metallic Roughness Material representation
      */
-    _GLTFMaterialExporter.prototype._convertToGLTFPBRMetallicRoughness = function (babylonStandardMaterial) {
+    _convertToGLTFPBRMetallicRoughness(babylonStandardMaterial) {
         // Defines a cubic bezier curve where x is specular power and y is roughness
-        var P0 = new Vector2(0, 1);
-        var P1 = new Vector2(0, 0.1);
-        var P2 = new Vector2(0, 0.1);
-        var P3 = new Vector2(1300, 0.1);
+        const P0 = new Vector2(0, 1);
+        const P1 = new Vector2(0, 0.1);
+        const P2 = new Vector2(0, 0.1);
+        const P3 = new Vector2(1300, 0.1);
         /**
          * Given the control points, solve for x based on a given t for a cubic bezier curve
          * @param t a value between 0 and 1
@@ -145,20 +142,20 @@ var _GLTFMaterialExporter = /** @class */ (function () {
             // Given P0.x = 0, P1.x = 0, P2.x = 0
             //   x = t * t * t * P3.x
             //   t = (x / P3.x)^(1/3)
-            var t = Math.pow(specularPower / P3.x, 0.333333);
+            const t = Math.pow(specularPower / P3.x, 0.333333);
             return cubicBezierCurve(t, P0.y, P1.y, P2.y, P3.y);
         }
-        var diffuse = babylonStandardMaterial.diffuseColor.toLinearSpace().scale(0.5);
-        var opacity = babylonStandardMaterial.alpha;
-        var specularPower = Scalar.Clamp(babylonStandardMaterial.specularPower, 0, _GLTFMaterialExporter._MaxSpecularPower);
-        var roughness = solveForRoughness(specularPower);
-        var glTFPbrMetallicRoughness = {
+        const diffuse = babylonStandardMaterial.diffuseColor.toLinearSpace().scale(0.5);
+        const opacity = babylonStandardMaterial.alpha;
+        const specularPower = Scalar.Clamp(babylonStandardMaterial.specularPower, 0, _GLTFMaterialExporter._MaxSpecularPower);
+        const roughness = solveForRoughness(specularPower);
+        const glTFPbrMetallicRoughness = {
             baseColorFactor: [diffuse.r, diffuse.g, diffuse.b, opacity],
             metallicFactor: 0,
             roughnessFactor: roughness,
         };
         return glTFPbrMetallicRoughness;
-    };
+    }
     /**
      * Computes the metallic factor
      * @param diffuse diffused value
@@ -166,23 +163,23 @@ var _GLTFMaterialExporter = /** @class */ (function () {
      * @param oneMinusSpecularStrength one minus the specular strength
      * @returns metallic value
      */
-    _GLTFMaterialExporter._SolveMetallic = function (diffuse, specular, oneMinusSpecularStrength) {
+    static _SolveMetallic(diffuse, specular, oneMinusSpecularStrength) {
         if (specular < this._DielectricSpecular.r) {
             this._DielectricSpecular;
             return 0;
         }
-        var a = this._DielectricSpecular.r;
-        var b = (diffuse * oneMinusSpecularStrength) / (1.0 - this._DielectricSpecular.r) + specular - 2.0 * this._DielectricSpecular.r;
-        var c = this._DielectricSpecular.r - specular;
-        var D = b * b - 4.0 * a * c;
+        const a = this._DielectricSpecular.r;
+        const b = (diffuse * oneMinusSpecularStrength) / (1.0 - this._DielectricSpecular.r) + specular - 2.0 * this._DielectricSpecular.r;
+        const c = this._DielectricSpecular.r - specular;
+        const D = b * b - 4.0 * a * c;
         return Scalar.Clamp((-b + Math.sqrt(D)) / (2.0 * a), 0, 1);
-    };
+    }
     /**
      * Sets the glTF alpha mode to a glTF material from the Babylon Material
      * @param glTFMaterial glTF material
      * @param babylonMaterial Babylon material
      */
-    _GLTFMaterialExporter._SetAlphaMode = function (glTFMaterial, babylonMaterial) {
+    static _SetAlphaMode(glTFMaterial, babylonMaterial) {
         if (babylonMaterial.needAlphaBlending()) {
             glTFMaterial.alphaMode = "BLEND" /* BLEND */;
         }
@@ -190,19 +187,19 @@ var _GLTFMaterialExporter = /** @class */ (function () {
             glTFMaterial.alphaMode = "MASK" /* MASK */;
             glTFMaterial.alphaCutoff = babylonMaterial.alphaCutOff;
         }
-    };
+    }
     /**
      * Converts a Babylon Standard Material to a glTF Material
      * @param babylonStandardMaterial BJS Standard Material
      * @param mimeType mime type to use for the textures
      * @param hasTextureCoords specifies if texture coordinates are present on the submesh to determine if textures should be applied
      */
-    _GLTFMaterialExporter.prototype._convertStandardMaterialAsync = function (babylonStandardMaterial, mimeType, hasTextureCoords) {
-        var materialMap = this._exporter._materialMap;
-        var materials = this._exporter._materials;
-        var promises = [];
-        var glTFPbrMetallicRoughness = this._convertToGLTFPBRMetallicRoughness(babylonStandardMaterial);
-        var glTFMaterial = { name: babylonStandardMaterial.name };
+    _convertStandardMaterialAsync(babylonStandardMaterial, mimeType, hasTextureCoords) {
+        const materialMap = this._exporter._materialMap;
+        const materials = this._exporter._materials;
+        const promises = [];
+        const glTFPbrMetallicRoughness = this._convertToGLTFPBRMetallicRoughness(babylonStandardMaterial);
+        const glTFMaterial = { name: babylonStandardMaterial.name };
         if (babylonStandardMaterial.backFaceCulling != null && !babylonStandardMaterial.backFaceCulling) {
             if (!babylonStandardMaterial.twoSidedLighting) {
                 Tools.Warn(babylonStandardMaterial.name + ": Back-face culling disabled and two-sided lighting disabled is not supported in glTF.");
@@ -211,14 +208,14 @@ var _GLTFMaterialExporter = /** @class */ (function () {
         }
         if (hasTextureCoords) {
             if (babylonStandardMaterial.diffuseTexture) {
-                promises.push(this._exportTextureAsync(babylonStandardMaterial.diffuseTexture, mimeType).then(function (glTFTexture) {
+                promises.push(this._exportTextureAsync(babylonStandardMaterial.diffuseTexture, mimeType).then((glTFTexture) => {
                     if (glTFTexture) {
                         glTFPbrMetallicRoughness.baseColorTexture = glTFTexture;
                     }
                 }));
             }
             if (babylonStandardMaterial.bumpTexture) {
-                promises.push(this._exportTextureAsync(babylonStandardMaterial.bumpTexture, mimeType).then(function (glTFTexture) {
+                promises.push(this._exportTextureAsync(babylonStandardMaterial.bumpTexture, mimeType).then((glTFTexture) => {
                     if (glTFTexture) {
                         glTFMaterial.normalTexture = glTFTexture;
                         if (babylonStandardMaterial.bumpTexture != null && babylonStandardMaterial.bumpTexture.level !== 1) {
@@ -229,16 +226,16 @@ var _GLTFMaterialExporter = /** @class */ (function () {
             }
             if (babylonStandardMaterial.emissiveTexture) {
                 glTFMaterial.emissiveFactor = [1.0, 1.0, 1.0];
-                promises.push(this._exportTextureAsync(babylonStandardMaterial.emissiveTexture, mimeType).then(function (glTFEmissiveTexture) {
+                promises.push(this._exportTextureAsync(babylonStandardMaterial.emissiveTexture, mimeType).then((glTFEmissiveTexture) => {
                     if (glTFEmissiveTexture) {
                         glTFMaterial.emissiveTexture = glTFEmissiveTexture;
                     }
                 }));
             }
             if (babylonStandardMaterial.ambientTexture) {
-                promises.push(this._exportTextureAsync(babylonStandardMaterial.ambientTexture, mimeType).then(function (glTFTexture) {
+                promises.push(this._exportTextureAsync(babylonStandardMaterial.ambientTexture, mimeType).then((glTFTexture) => {
                     if (glTFTexture) {
-                        var occlusionTexture = {
+                        const occlusionTexture = {
                             index: glTFTexture.index,
                         };
                         glTFMaterial.occlusionTexture = occlusionTexture;
@@ -263,31 +260,29 @@ var _GLTFMaterialExporter = /** @class */ (function () {
         materials.push(glTFMaterial);
         materialMap[babylonStandardMaterial.uniqueId] = materials.length - 1;
         return this._finishMaterial(promises, glTFMaterial, babylonStandardMaterial, mimeType);
-    };
-    _GLTFMaterialExporter.prototype._finishMaterial = function (promises, glTFMaterial, babylonMaterial, mimeType) {
-        var _this = this;
-        return Promise.all(promises).then(function () {
-            var textures = _this._exporter._extensionsPostExportMaterialAdditionalTextures("exportMaterial", glTFMaterial, babylonMaterial);
-            var tasks = null;
-            for (var _i = 0, textures_1 = textures; _i < textures_1.length; _i++) {
-                var texture = textures_1[_i];
+    }
+    _finishMaterial(promises, glTFMaterial, babylonMaterial, mimeType) {
+        return Promise.all(promises).then(() => {
+            const textures = this._exporter._extensionsPostExportMaterialAdditionalTextures("exportMaterial", glTFMaterial, babylonMaterial);
+            let tasks = null;
+            for (const texture of textures) {
                 if (!tasks) {
                     tasks = [];
                 }
-                tasks.push(_this._exportTextureAsync(texture, mimeType));
+                tasks.push(this._exportTextureAsync(texture, mimeType));
             }
             if (!tasks) {
                 tasks = [Promise.resolve(null)];
             }
-            return Promise.all(tasks).then(function () {
-                var extensionWork = _this._exporter._extensionsPostExportMaterialAsync("exportMaterial", glTFMaterial, babylonMaterial);
+            return Promise.all(tasks).then(() => {
+                const extensionWork = this._exporter._extensionsPostExportMaterialAsync("exportMaterial", glTFMaterial, babylonMaterial);
                 if (!extensionWork) {
                     return glTFMaterial;
                 }
-                return extensionWork.then(function () { return glTFMaterial; });
+                return extensionWork.then(() => glTFMaterial);
             });
         });
-    };
+    }
     /**
      * Converts an image typed array buffer to a base64 image
      * @param buffer typed array buffer
@@ -296,33 +291,20 @@ var _GLTFMaterialExporter = /** @class */ (function () {
      * @param mimeType mimetype of the image
      * @returns base64 image string
      */
-    _GLTFMaterialExporter.prototype._createBase64FromCanvasAsync = function (buffer, width, height, mimeType) {
-        var _this = this;
+    _createBase64FromCanvasAsync(buffer, width, height, mimeType) {
         // eslint-disable-next-line no-async-promise-executor
-        return new Promise(function (resolve) { return __awaiter(_this, void 0, void 0, function () {
-            var textureType, hostingScene, engine, tempTexture, data, base64;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        textureType = Constants.TEXTURETYPE_UNSIGNED_INT;
-                        hostingScene = this._exporter._babylonScene;
-                        engine = hostingScene.getEngine();
-                        tempTexture = engine.createRawTexture(buffer, width, height, Constants.TEXTUREFORMAT_RGBA, false, true, Texture.NEAREST_SAMPLINGMODE, null, textureType);
-                        return [4 /*yield*/, TextureTools.ApplyPostProcess("pass", tempTexture, hostingScene, textureType, Constants.TEXTURE_NEAREST_SAMPLINGMODE, Constants.TEXTUREFORMAT_RGBA)];
-                    case 1:
-                        _a.sent();
-                        return [4 /*yield*/, engine._readTexturePixels(tempTexture, width, height)];
-                    case 2:
-                        data = _a.sent();
-                        return [4 /*yield*/, Tools.DumpDataAsync(width, height, data, mimeType, undefined, true, false)];
-                    case 3:
-                        base64 = _a.sent();
-                        resolve(base64);
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-    };
+        return new Promise(async (resolve) => {
+            const textureType = Constants.TEXTURETYPE_UNSIGNED_INT;
+            const hostingScene = this._exporter._babylonScene;
+            const engine = hostingScene.getEngine();
+            // Create a temporary texture with the texture buffer data
+            const tempTexture = engine.createRawTexture(buffer, width, height, Constants.TEXTUREFORMAT_RGBA, false, true, Texture.NEAREST_SAMPLINGMODE, null, textureType);
+            await TextureTools.ApplyPostProcess("pass", tempTexture, hostingScene, textureType, Constants.TEXTURE_NEAREST_SAMPLINGMODE, Constants.TEXTUREFORMAT_RGBA);
+            const data = await engine._readTexturePixels(tempTexture, width, height);
+            const base64 = await Tools.DumpDataAsync(width, height, data, mimeType, undefined, true, false);
+            resolve(base64);
+        });
+    }
     /**
      * Generates a white texture based on the specified width and height
      * @param width width of the texture in pixels
@@ -330,14 +312,14 @@ var _GLTFMaterialExporter = /** @class */ (function () {
      * @param scene babylonjs scene
      * @returns white texture
      */
-    _GLTFMaterialExporter.prototype._createWhiteTexture = function (width, height, scene) {
-        var data = new Uint8Array(width * height * 4);
-        for (var i = 0; i < data.length; i = i + 4) {
+    _createWhiteTexture(width, height, scene) {
+        const data = new Uint8Array(width * height * 4);
+        for (let i = 0; i < data.length; i = i + 4) {
             data[i] = data[i + 1] = data[i + 2] = data[i + 3] = 0xff;
         }
-        var rawTexture = RawTexture.CreateRGBATexture(data, width, height, scene);
+        const rawTexture = RawTexture.CreateRGBATexture(data, width, height, scene);
         return rawTexture;
-    };
+    }
     /**
      * Resizes the two source textures to the same dimensions.  If a texture is null, a default white texture is generated.  If both textures are null, returns null
      * @param texture1 first texture to resize
@@ -345,11 +327,11 @@ var _GLTFMaterialExporter = /** @class */ (function () {
      * @param scene babylonjs scene
      * @returns resized textures or null
      */
-    _GLTFMaterialExporter.prototype._resizeTexturesToSameDimensions = function (texture1, texture2, scene) {
-        var texture1Size = texture1 ? texture1.getSize() : { width: 0, height: 0 };
-        var texture2Size = texture2 ? texture2.getSize() : { width: 0, height: 0 };
-        var resizedTexture1;
-        var resizedTexture2;
+    _resizeTexturesToSameDimensions(texture1, texture2, scene) {
+        const texture1Size = texture1 ? texture1.getSize() : { width: 0, height: 0 };
+        const texture2Size = texture2 ? texture2.getSize() : { width: 0, height: 0 };
+        let resizedTexture1;
+        let resizedTexture2;
         if (texture1Size.width < texture2Size.width) {
             if (texture1 && texture1 instanceof Texture) {
                 resizedTexture1 = TextureTools.CreateResizedCopy(texture1, texture2Size.width, texture2Size.height, true);
@@ -376,18 +358,18 @@ var _GLTFMaterialExporter = /** @class */ (function () {
             texture1: resizedTexture1,
             texture2: resizedTexture2,
         };
-    };
+    }
     /**
      * Converts an array of pixels to a Float32Array
      * Throws an error if the pixel format is not supported
      * @param pixels - array buffer containing pixel values
      * @returns Float32 of pixels
      */
-    _GLTFMaterialExporter.prototype._convertPixelArrayToFloat32 = function (pixels) {
+    _convertPixelArrayToFloat32(pixels) {
         if (pixels instanceof Uint8Array) {
-            var length_1 = pixels.length;
-            var buffer = new Float32Array(pixels.length);
-            for (var i = 0; i < length_1; ++i) {
+            const length = pixels.length;
+            const buffer = new Float32Array(pixels.length);
+            for (let i = 0; i < length; ++i) {
                 buffer[i] = pixels[i] / 255;
             }
             return buffer;
@@ -398,7 +380,7 @@ var _GLTFMaterialExporter = /** @class */ (function () {
         else {
             throw new Error("Unsupported pixel format!");
         }
-    };
+    }
     /**
      * Convert Specular Glossiness Textures to Metallic Roughness
      * See link below for info on the material conversions from PBR Metallic/Roughness and Specular/Glossiness
@@ -409,174 +391,165 @@ var _GLTFMaterialExporter = /** @class */ (function () {
      * @param mimeType the mime type to use for the texture
      * @returns pbr metallic roughness interface or null
      */
-    _GLTFMaterialExporter.prototype._convertSpecularGlossinessTexturesToMetallicRoughnessAsync = function (diffuseTexture, specularGlossinessTexture, factors, mimeType) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function () {
-            var promises, scene, resizedTextures, diffuseSize, diffuseBuffer, specularGlossinessBuffer, width, height, diffusePixels, specularPixels, byteLength, metallicRoughnessBuffer, baseColorBuffer, strideSize, maxBaseColor, maxMetallic, maxRoughness, h, w, offset, diffuseColor, specularColor, glossiness, specularGlossiness, metallicRoughness, metallicRoughnessFactors_1, writeOutMetallicRoughnessTexture, writeOutBaseColorTexture, h, w, destinationOffset, linearBaseColorPixel, sRGBBaseColorPixel, metallicRoughnessPixel, promise, promise;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        promises = [];
-                        if (!(diffuseTexture || specularGlossinessTexture)) {
-                            return [2 /*return*/, Promise.reject("_ConvertSpecularGlosinessTexturesToMetallicRoughness: diffuse and specular glossiness textures are not defined!")];
-                        }
-                        scene = diffuseTexture ? diffuseTexture.getScene() : specularGlossinessTexture ? specularGlossinessTexture.getScene() : null;
-                        if (!scene) return [3 /*break*/, 3];
-                        resizedTextures = this._resizeTexturesToSameDimensions(diffuseTexture, specularGlossinessTexture, scene);
-                        diffuseSize = (_a = resizedTextures.texture1) === null || _a === void 0 ? void 0 : _a.getSize();
-                        diffuseBuffer = void 0;
-                        specularGlossinessBuffer = void 0;
-                        width = diffuseSize.width;
-                        height = diffuseSize.height;
-                        return [4 /*yield*/, resizedTextures.texture1.readPixels()];
-                    case 1:
-                        diffusePixels = _b.sent();
-                        return [4 /*yield*/, resizedTextures.texture2.readPixels()];
-                    case 2:
-                        specularPixels = _b.sent();
-                        if (diffusePixels) {
-                            diffuseBuffer = this._convertPixelArrayToFloat32(diffusePixels);
-                        }
-                        else {
-                            return [2 /*return*/, Promise.reject("Failed to retrieve pixels from diffuse texture!")];
-                        }
-                        if (specularPixels) {
-                            specularGlossinessBuffer = this._convertPixelArrayToFloat32(specularPixels);
-                        }
-                        else {
-                            return [2 /*return*/, Promise.reject("Failed to retrieve pixels from specular glossiness texture!")];
-                        }
-                        byteLength = specularGlossinessBuffer.byteLength;
-                        metallicRoughnessBuffer = new Uint8Array(byteLength);
-                        baseColorBuffer = new Uint8Array(byteLength);
-                        strideSize = 4;
-                        maxBaseColor = Color3.Black();
-                        maxMetallic = 0;
-                        maxRoughness = 0;
-                        for (h = 0; h < height; ++h) {
-                            for (w = 0; w < width; ++w) {
-                                offset = (width * h + w) * strideSize;
-                                diffuseColor = new Color3(diffuseBuffer[offset], diffuseBuffer[offset + 1], diffuseBuffer[offset + 2]).toLinearSpace().multiply(factors.diffuseColor);
-                                specularColor = new Color3(specularGlossinessBuffer[offset], specularGlossinessBuffer[offset + 1], specularGlossinessBuffer[offset + 2])
-                                    .toLinearSpace()
-                                    .multiply(factors.specularColor);
-                                glossiness = specularGlossinessBuffer[offset + 3] * factors.glossiness;
-                                specularGlossiness = {
-                                    diffuseColor: diffuseColor,
-                                    specularColor: specularColor,
-                                    glossiness: glossiness,
-                                };
-                                metallicRoughness = this._convertSpecularGlossinessToMetallicRoughness(specularGlossiness);
-                                maxBaseColor.r = Math.max(maxBaseColor.r, metallicRoughness.baseColor.r);
-                                maxBaseColor.g = Math.max(maxBaseColor.g, metallicRoughness.baseColor.g);
-                                maxBaseColor.b = Math.max(maxBaseColor.b, metallicRoughness.baseColor.b);
-                                maxMetallic = Math.max(maxMetallic, metallicRoughness.metallic);
-                                maxRoughness = Math.max(maxRoughness, metallicRoughness.roughness);
-                                baseColorBuffer[offset] = metallicRoughness.baseColor.r * 255;
-                                baseColorBuffer[offset + 1] = metallicRoughness.baseColor.g * 255;
-                                baseColorBuffer[offset + 2] = metallicRoughness.baseColor.b * 255;
-                                baseColorBuffer[offset + 3] = resizedTextures.texture1.hasAlpha ? diffuseBuffer[offset + 3] * 255 : 255;
-                                metallicRoughnessBuffer[offset] = 0;
-                                metallicRoughnessBuffer[offset + 1] = metallicRoughness.roughness * 255;
-                                metallicRoughnessBuffer[offset + 2] = metallicRoughness.metallic * 255;
-                                metallicRoughnessBuffer[offset + 3] = 255;
-                            }
-                        }
-                        metallicRoughnessFactors_1 = {
-                            baseColor: maxBaseColor,
-                            metallic: maxMetallic,
-                            roughness: maxRoughness,
-                        };
-                        writeOutMetallicRoughnessTexture = false;
-                        writeOutBaseColorTexture = false;
-                        for (h = 0; h < height; ++h) {
-                            for (w = 0; w < width; ++w) {
-                                destinationOffset = (width * h + w) * strideSize;
-                                baseColorBuffer[destinationOffset] /= metallicRoughnessFactors_1.baseColor.r > _GLTFMaterialExporter._Epsilon ? metallicRoughnessFactors_1.baseColor.r : 1;
-                                baseColorBuffer[destinationOffset + 1] /= metallicRoughnessFactors_1.baseColor.g > _GLTFMaterialExporter._Epsilon ? metallicRoughnessFactors_1.baseColor.g : 1;
-                                baseColorBuffer[destinationOffset + 2] /= metallicRoughnessFactors_1.baseColor.b > _GLTFMaterialExporter._Epsilon ? metallicRoughnessFactors_1.baseColor.b : 1;
-                                linearBaseColorPixel = Color3.FromInts(baseColorBuffer[destinationOffset], baseColorBuffer[destinationOffset + 1], baseColorBuffer[destinationOffset + 2]);
-                                sRGBBaseColorPixel = linearBaseColorPixel.toGammaSpace();
-                                baseColorBuffer[destinationOffset] = sRGBBaseColorPixel.r * 255;
-                                baseColorBuffer[destinationOffset + 1] = sRGBBaseColorPixel.g * 255;
-                                baseColorBuffer[destinationOffset + 2] = sRGBBaseColorPixel.b * 255;
-                                if (!_GLTFMaterialExporter._FuzzyEquals(sRGBBaseColorPixel, Color3.White(), _GLTFMaterialExporter._Epsilon)) {
-                                    writeOutBaseColorTexture = true;
-                                }
-                                metallicRoughnessBuffer[destinationOffset + 1] /=
-                                    metallicRoughnessFactors_1.roughness > _GLTFMaterialExporter._Epsilon ? metallicRoughnessFactors_1.roughness : 1;
-                                metallicRoughnessBuffer[destinationOffset + 2] /= metallicRoughnessFactors_1.metallic > _GLTFMaterialExporter._Epsilon ? metallicRoughnessFactors_1.metallic : 1;
-                                metallicRoughnessPixel = Color3.FromInts(255, metallicRoughnessBuffer[destinationOffset + 1], metallicRoughnessBuffer[destinationOffset + 2]);
-                                if (!_GLTFMaterialExporter._FuzzyEquals(metallicRoughnessPixel, Color3.White(), _GLTFMaterialExporter._Epsilon)) {
-                                    writeOutMetallicRoughnessTexture = true;
-                                }
-                            }
-                        }
-                        if (writeOutMetallicRoughnessTexture) {
-                            promise = this._createBase64FromCanvasAsync(metallicRoughnessBuffer, width, height, mimeType).then(function (metallicRoughnessBase64) {
-                                metallicRoughnessFactors_1.metallicRoughnessTextureBase64 = metallicRoughnessBase64;
-                            });
-                            promises.push(promise);
-                        }
-                        if (writeOutBaseColorTexture) {
-                            promise = this._createBase64FromCanvasAsync(baseColorBuffer, width, height, mimeType).then(function (baseColorBase64) {
-                                metallicRoughnessFactors_1.baseColorTextureBase64 = baseColorBase64;
-                            });
-                            promises.push(promise);
-                        }
-                        return [2 /*return*/, Promise.all(promises).then(function () {
-                                return metallicRoughnessFactors_1;
-                            })];
-                    case 3: return [2 /*return*/, Promise.reject("_ConvertSpecularGlossinessTexturesToMetallicRoughness: Scene from textures is missing!")];
+    async _convertSpecularGlossinessTexturesToMetallicRoughnessAsync(diffuseTexture, specularGlossinessTexture, factors, mimeType) {
+        const promises = [];
+        if (!(diffuseTexture || specularGlossinessTexture)) {
+            return Promise.reject("_ConvertSpecularGlosinessTexturesToMetallicRoughness: diffuse and specular glossiness textures are not defined!");
+        }
+        const scene = diffuseTexture ? diffuseTexture.getScene() : specularGlossinessTexture ? specularGlossinessTexture.getScene() : null;
+        if (scene) {
+            const resizedTextures = this._resizeTexturesToSameDimensions(diffuseTexture, specularGlossinessTexture, scene);
+            const diffuseSize = resizedTextures.texture1?.getSize();
+            let diffuseBuffer;
+            let specularGlossinessBuffer;
+            const width = diffuseSize.width;
+            const height = diffuseSize.height;
+            const diffusePixels = await resizedTextures.texture1.readPixels();
+            const specularPixels = await resizedTextures.texture2.readPixels();
+            if (diffusePixels) {
+                diffuseBuffer = this._convertPixelArrayToFloat32(diffusePixels);
+            }
+            else {
+                return Promise.reject("Failed to retrieve pixels from diffuse texture!");
+            }
+            if (specularPixels) {
+                specularGlossinessBuffer = this._convertPixelArrayToFloat32(specularPixels);
+            }
+            else {
+                return Promise.reject("Failed to retrieve pixels from specular glossiness texture!");
+            }
+            const byteLength = specularGlossinessBuffer.byteLength;
+            const metallicRoughnessBuffer = new Uint8Array(byteLength);
+            const baseColorBuffer = new Uint8Array(byteLength);
+            const strideSize = 4;
+            const maxBaseColor = Color3.Black();
+            let maxMetallic = 0;
+            let maxRoughness = 0;
+            for (let h = 0; h < height; ++h) {
+                for (let w = 0; w < width; ++w) {
+                    const offset = (width * h + w) * strideSize;
+                    const diffuseColor = new Color3(diffuseBuffer[offset], diffuseBuffer[offset + 1], diffuseBuffer[offset + 2]).toLinearSpace().multiply(factors.diffuseColor);
+                    const specularColor = new Color3(specularGlossinessBuffer[offset], specularGlossinessBuffer[offset + 1], specularGlossinessBuffer[offset + 2])
+                        .toLinearSpace()
+                        .multiply(factors.specularColor);
+                    const glossiness = specularGlossinessBuffer[offset + 3] * factors.glossiness;
+                    const specularGlossiness = {
+                        diffuseColor: diffuseColor,
+                        specularColor: specularColor,
+                        glossiness: glossiness,
+                    };
+                    const metallicRoughness = this._convertSpecularGlossinessToMetallicRoughness(specularGlossiness);
+                    maxBaseColor.r = Math.max(maxBaseColor.r, metallicRoughness.baseColor.r);
+                    maxBaseColor.g = Math.max(maxBaseColor.g, metallicRoughness.baseColor.g);
+                    maxBaseColor.b = Math.max(maxBaseColor.b, metallicRoughness.baseColor.b);
+                    maxMetallic = Math.max(maxMetallic, metallicRoughness.metallic);
+                    maxRoughness = Math.max(maxRoughness, metallicRoughness.roughness);
+                    baseColorBuffer[offset] = metallicRoughness.baseColor.r * 255;
+                    baseColorBuffer[offset + 1] = metallicRoughness.baseColor.g * 255;
+                    baseColorBuffer[offset + 2] = metallicRoughness.baseColor.b * 255;
+                    baseColorBuffer[offset + 3] = resizedTextures.texture1.hasAlpha ? diffuseBuffer[offset + 3] * 255 : 255;
+                    metallicRoughnessBuffer[offset] = 0;
+                    metallicRoughnessBuffer[offset + 1] = metallicRoughness.roughness * 255;
+                    metallicRoughnessBuffer[offset + 2] = metallicRoughness.metallic * 255;
+                    metallicRoughnessBuffer[offset + 3] = 255;
                 }
+            }
+            // Retrieves the metallic roughness factors from the maximum texture values.
+            const metallicRoughnessFactors = {
+                baseColor: maxBaseColor,
+                metallic: maxMetallic,
+                roughness: maxRoughness,
+            };
+            let writeOutMetallicRoughnessTexture = false;
+            let writeOutBaseColorTexture = false;
+            for (let h = 0; h < height; ++h) {
+                for (let w = 0; w < width; ++w) {
+                    const destinationOffset = (width * h + w) * strideSize;
+                    baseColorBuffer[destinationOffset] /= metallicRoughnessFactors.baseColor.r > _GLTFMaterialExporter._Epsilon ? metallicRoughnessFactors.baseColor.r : 1;
+                    baseColorBuffer[destinationOffset + 1] /= metallicRoughnessFactors.baseColor.g > _GLTFMaterialExporter._Epsilon ? metallicRoughnessFactors.baseColor.g : 1;
+                    baseColorBuffer[destinationOffset + 2] /= metallicRoughnessFactors.baseColor.b > _GLTFMaterialExporter._Epsilon ? metallicRoughnessFactors.baseColor.b : 1;
+                    const linearBaseColorPixel = Color3.FromInts(baseColorBuffer[destinationOffset], baseColorBuffer[destinationOffset + 1], baseColorBuffer[destinationOffset + 2]);
+                    const sRGBBaseColorPixel = linearBaseColorPixel.toGammaSpace();
+                    baseColorBuffer[destinationOffset] = sRGBBaseColorPixel.r * 255;
+                    baseColorBuffer[destinationOffset + 1] = sRGBBaseColorPixel.g * 255;
+                    baseColorBuffer[destinationOffset + 2] = sRGBBaseColorPixel.b * 255;
+                    if (!_GLTFMaterialExporter._FuzzyEquals(sRGBBaseColorPixel, Color3.White(), _GLTFMaterialExporter._Epsilon)) {
+                        writeOutBaseColorTexture = true;
+                    }
+                    metallicRoughnessBuffer[destinationOffset + 1] /=
+                        metallicRoughnessFactors.roughness > _GLTFMaterialExporter._Epsilon ? metallicRoughnessFactors.roughness : 1;
+                    metallicRoughnessBuffer[destinationOffset + 2] /= metallicRoughnessFactors.metallic > _GLTFMaterialExporter._Epsilon ? metallicRoughnessFactors.metallic : 1;
+                    const metallicRoughnessPixel = Color3.FromInts(255, metallicRoughnessBuffer[destinationOffset + 1], metallicRoughnessBuffer[destinationOffset + 2]);
+                    if (!_GLTFMaterialExporter._FuzzyEquals(metallicRoughnessPixel, Color3.White(), _GLTFMaterialExporter._Epsilon)) {
+                        writeOutMetallicRoughnessTexture = true;
+                    }
+                }
+            }
+            if (writeOutMetallicRoughnessTexture) {
+                const promise = this._createBase64FromCanvasAsync(metallicRoughnessBuffer, width, height, mimeType).then((metallicRoughnessBase64) => {
+                    metallicRoughnessFactors.metallicRoughnessTextureBase64 = metallicRoughnessBase64;
+                });
+                promises.push(promise);
+            }
+            if (writeOutBaseColorTexture) {
+                const promise = this._createBase64FromCanvasAsync(baseColorBuffer, width, height, mimeType).then((baseColorBase64) => {
+                    metallicRoughnessFactors.baseColorTextureBase64 = baseColorBase64;
+                });
+                promises.push(promise);
+            }
+            return Promise.all(promises).then(() => {
+                return metallicRoughnessFactors;
             });
-        });
-    };
+        }
+        else {
+            return Promise.reject("_ConvertSpecularGlossinessTexturesToMetallicRoughness: Scene from textures is missing!");
+        }
+    }
     /**
      * Converts specular glossiness material properties to metallic roughness
      * @param specularGlossiness interface with specular glossiness material properties
      * @returns interface with metallic roughness material properties
      */
-    _GLTFMaterialExporter.prototype._convertSpecularGlossinessToMetallicRoughness = function (specularGlossiness) {
-        var diffusePerceivedBrightness = this._getPerceivedBrightness(specularGlossiness.diffuseColor);
-        var specularPerceivedBrightness = this._getPerceivedBrightness(specularGlossiness.specularColor);
-        var oneMinusSpecularStrength = 1 - this._getMaxComponent(specularGlossiness.specularColor);
-        var metallic = _GLTFMaterialExporter._SolveMetallic(diffusePerceivedBrightness, specularPerceivedBrightness, oneMinusSpecularStrength);
-        var baseColorFromDiffuse = specularGlossiness.diffuseColor.scale(oneMinusSpecularStrength / (1.0 - _GLTFMaterialExporter._DielectricSpecular.r) / Math.max(1 - metallic, _GLTFMaterialExporter._Epsilon));
-        var baseColorFromSpecular = specularGlossiness.specularColor
+    _convertSpecularGlossinessToMetallicRoughness(specularGlossiness) {
+        const diffusePerceivedBrightness = this._getPerceivedBrightness(specularGlossiness.diffuseColor);
+        const specularPerceivedBrightness = this._getPerceivedBrightness(specularGlossiness.specularColor);
+        const oneMinusSpecularStrength = 1 - this._getMaxComponent(specularGlossiness.specularColor);
+        const metallic = _GLTFMaterialExporter._SolveMetallic(diffusePerceivedBrightness, specularPerceivedBrightness, oneMinusSpecularStrength);
+        const baseColorFromDiffuse = specularGlossiness.diffuseColor.scale(oneMinusSpecularStrength / (1.0 - _GLTFMaterialExporter._DielectricSpecular.r) / Math.max(1 - metallic, _GLTFMaterialExporter._Epsilon));
+        const baseColorFromSpecular = specularGlossiness.specularColor
             .subtract(_GLTFMaterialExporter._DielectricSpecular.scale(1 - metallic))
             .scale(1 / Math.max(metallic, _GLTFMaterialExporter._Epsilon));
-        var baseColor = Color3.Lerp(baseColorFromDiffuse, baseColorFromSpecular, metallic * metallic);
+        let baseColor = Color3.Lerp(baseColorFromDiffuse, baseColorFromSpecular, metallic * metallic);
         baseColor = baseColor.clampToRef(0, 1, baseColor);
-        var metallicRoughness = {
+        const metallicRoughness = {
             baseColor: baseColor,
             metallic: metallic,
             roughness: 1 - specularGlossiness.glossiness,
         };
         return metallicRoughness;
-    };
+    }
     /**
      * Calculates the surface reflectance, independent of lighting conditions
      * @param color Color source to calculate brightness from
      * @returns number representing the perceived brightness, or zero if color is undefined
      */
-    _GLTFMaterialExporter.prototype._getPerceivedBrightness = function (color) {
+    _getPerceivedBrightness(color) {
         if (color) {
             return Math.sqrt(0.299 * color.r * color.r + 0.587 * color.g * color.g + 0.114 * color.b * color.b);
         }
         return 0;
-    };
+    }
     /**
      * Returns the maximum color component value
      * @param color
      * @returns maximum color component value, or zero if color is null or undefined
      */
-    _GLTFMaterialExporter.prototype._getMaxComponent = function (color) {
+    _getMaxComponent(color) {
         if (color) {
             return Math.max(color.r, Math.max(color.g, color.b));
         }
         return 0;
-    };
+    }
     /**
      * Convert a PBRMaterial (Metallic/Roughness) to Metallic Roughness factors
      * @param babylonPBRMaterial BJS PBR Metallic Roughness Material
@@ -585,41 +558,41 @@ var _GLTFMaterialExporter = /** @class */ (function () {
      * @param hasTextureCoords specifies if texture coordinates are present on the submesh to determine if textures should be applied
      * @returns glTF PBR Metallic Roughness factors
      */
-    _GLTFMaterialExporter.prototype._convertMetalRoughFactorsToMetallicRoughnessAsync = function (babylonPBRMaterial, mimeType, glTFPbrMetallicRoughness, hasTextureCoords) {
-        var promises = [];
-        var baseColor = babylonPBRMaterial._albedoColor;
-        var metallic = babylonPBRMaterial._metallic;
-        var roughness = babylonPBRMaterial._roughness;
-        var metallicRoughness = {
+    _convertMetalRoughFactorsToMetallicRoughnessAsync(babylonPBRMaterial, mimeType, glTFPbrMetallicRoughness, hasTextureCoords) {
+        const promises = [];
+        const baseColor = babylonPBRMaterial._albedoColor;
+        const metallic = babylonPBRMaterial._metallic;
+        const roughness = babylonPBRMaterial._roughness;
+        const metallicRoughness = {
             baseColor: baseColor,
             metallic: metallic,
             roughness: roughness,
         };
         if (hasTextureCoords) {
-            var albedoTexture = babylonPBRMaterial._albedoTexture;
+            const albedoTexture = babylonPBRMaterial._albedoTexture;
             if (albedoTexture) {
-                promises.push(this._exportTextureAsync(babylonPBRMaterial._albedoTexture, mimeType).then(function (glTFTexture) {
+                promises.push(this._exportTextureAsync(babylonPBRMaterial._albedoTexture, mimeType).then((glTFTexture) => {
                     if (glTFTexture) {
                         glTFPbrMetallicRoughness.baseColorTexture = glTFTexture;
                     }
                 }));
             }
-            var metallicTexture = babylonPBRMaterial._metallicTexture;
+            const metallicTexture = babylonPBRMaterial._metallicTexture;
             if (metallicTexture) {
-                promises.push(this._exportTextureAsync(metallicTexture, mimeType).then(function (glTFTexture) {
+                promises.push(this._exportTextureAsync(metallicTexture, mimeType).then((glTFTexture) => {
                     if (glTFTexture) {
                         glTFPbrMetallicRoughness.metallicRoughnessTexture = glTFTexture;
                     }
                 }));
             }
         }
-        return Promise.all(promises).then(function () {
+        return Promise.all(promises).then(() => {
             return metallicRoughness;
         });
-    };
-    _GLTFMaterialExporter.prototype._getGLTFTextureSampler = function (texture) {
-        var sampler = this._getGLTFTextureWrapModesSampler(texture);
-        var samplingMode = texture instanceof Texture ? texture.samplingMode : null;
+    }
+    _getGLTFTextureSampler(texture) {
+        const sampler = this._getGLTFTextureWrapModesSampler(texture);
+        const samplingMode = texture instanceof Texture ? texture.samplingMode : null;
         if (samplingMode != null) {
             switch (samplingMode) {
                 case Texture.LINEAR_LINEAR: {
@@ -685,8 +658,8 @@ var _GLTFMaterialExporter = /** @class */ (function () {
             }
         }
         return sampler;
-    };
-    _GLTFMaterialExporter.prototype._getGLTFTextureWrapMode = function (wrapMode) {
+    }
+    _getGLTFTextureWrapMode(wrapMode) {
         switch (wrapMode) {
             case Texture.WRAP_ADDRESSMODE: {
                 return 10497 /* REPEAT */;
@@ -698,20 +671,20 @@ var _GLTFMaterialExporter = /** @class */ (function () {
                 return 33648 /* MIRRORED_REPEAT */;
             }
             default: {
-                Tools.Error("Unsupported Texture Wrap Mode ".concat(wrapMode, "!"));
+                Tools.Error(`Unsupported Texture Wrap Mode ${wrapMode}!`);
                 return 10497 /* REPEAT */;
             }
         }
-    };
-    _GLTFMaterialExporter.prototype._getGLTFTextureWrapModesSampler = function (texture) {
-        var wrapS = this._getGLTFTextureWrapMode(texture instanceof Texture ? texture.wrapU : Texture.WRAP_ADDRESSMODE);
-        var wrapT = this._getGLTFTextureWrapMode(texture instanceof Texture ? texture.wrapV : Texture.WRAP_ADDRESSMODE);
+    }
+    _getGLTFTextureWrapModesSampler(texture) {
+        const wrapS = this._getGLTFTextureWrapMode(texture instanceof Texture ? texture.wrapU : Texture.WRAP_ADDRESSMODE);
+        const wrapT = this._getGLTFTextureWrapMode(texture instanceof Texture ? texture.wrapV : Texture.WRAP_ADDRESSMODE);
         if (wrapS === 10497 /* REPEAT */ && wrapT === 10497 /* REPEAT */) {
             // default wrapping mode in glTF, so omitting
             return {};
         }
         return { wrapS: wrapS, wrapT: wrapT };
-    };
+    }
     /**
      * Convert a PBRMaterial (Specular/Glossiness) to Metallic Roughness factors
      * @param babylonPBRMaterial BJS PBR Metallic Roughness Material
@@ -720,43 +693,42 @@ var _GLTFMaterialExporter = /** @class */ (function () {
      * @param hasTextureCoords specifies if texture coordinates are present on the submesh to determine if textures should be applied
      * @returns glTF PBR Metallic Roughness factors
      */
-    _GLTFMaterialExporter.prototype._convertSpecGlossFactorsToMetallicRoughnessAsync = function (babylonPBRMaterial, mimeType, glTFPbrMetallicRoughness, hasTextureCoords) {
-        var _this = this;
-        return Promise.resolve().then(function () {
-            var samplers = _this._exporter._samplers;
-            var textures = _this._exporter._textures;
-            var diffuseColor = babylonPBRMaterial._albedoColor;
-            var specularColor = babylonPBRMaterial._reflectivityColor;
-            var glossiness = babylonPBRMaterial._microSurface;
-            var specGloss = {
+    _convertSpecGlossFactorsToMetallicRoughnessAsync(babylonPBRMaterial, mimeType, glTFPbrMetallicRoughness, hasTextureCoords) {
+        return Promise.resolve().then(() => {
+            const samplers = this._exporter._samplers;
+            const textures = this._exporter._textures;
+            const diffuseColor = babylonPBRMaterial._albedoColor;
+            const specularColor = babylonPBRMaterial._reflectivityColor;
+            const glossiness = babylonPBRMaterial._microSurface;
+            const specGloss = {
                 diffuseColor: diffuseColor,
                 specularColor: specularColor,
                 glossiness: glossiness,
             };
-            var samplerIndex = null;
-            var albedoTexture = babylonPBRMaterial._albedoTexture;
-            var reflectivityTexture = babylonPBRMaterial._reflectivityTexture;
+            let samplerIndex = null;
+            const albedoTexture = babylonPBRMaterial._albedoTexture;
+            const reflectivityTexture = babylonPBRMaterial._reflectivityTexture;
             if (albedoTexture) {
-                var sampler = _this._getGLTFTextureSampler(albedoTexture);
+                const sampler = this._getGLTFTextureSampler(albedoTexture);
                 if (sampler.magFilter != null && sampler.minFilter != null && sampler.wrapS != null && sampler.wrapT != null) {
                     samplers.push(sampler);
                     samplerIndex = samplers.length - 1;
                 }
             }
-            var useMicrosurfaceFromReflectivityMapAlpha = babylonPBRMaterial._useMicroSurfaceFromReflectivityMapAlpha;
+            const useMicrosurfaceFromReflectivityMapAlpha = babylonPBRMaterial._useMicroSurfaceFromReflectivityMapAlpha;
             if (reflectivityTexture && !useMicrosurfaceFromReflectivityMapAlpha) {
                 return Promise.reject("_ConvertPBRMaterial: Glossiness values not included in the reflectivity texture are currently not supported");
             }
             if ((albedoTexture || reflectivityTexture) && hasTextureCoords) {
-                return _this._convertSpecularGlossinessTexturesToMetallicRoughnessAsync(albedoTexture, reflectivityTexture, specGloss, mimeType).then(function (metallicRoughnessFactors) {
+                return this._convertSpecularGlossinessTexturesToMetallicRoughnessAsync(albedoTexture, reflectivityTexture, specGloss, mimeType).then((metallicRoughnessFactors) => {
                     if (metallicRoughnessFactors.baseColorTextureBase64) {
-                        var glTFBaseColorTexture = _this._getTextureInfoFromBase64(metallicRoughnessFactors.baseColorTextureBase64, "bjsBaseColorTexture_" + textures.length + ".png", mimeType, albedoTexture ? albedoTexture.coordinatesIndex : null, samplerIndex);
+                        const glTFBaseColorTexture = this._getTextureInfoFromBase64(metallicRoughnessFactors.baseColorTextureBase64, "bjsBaseColorTexture_" + textures.length + ".png", mimeType, albedoTexture ? albedoTexture.coordinatesIndex : null, samplerIndex);
                         if (glTFBaseColorTexture) {
                             glTFPbrMetallicRoughness.baseColorTexture = glTFBaseColorTexture;
                         }
                     }
                     if (metallicRoughnessFactors.metallicRoughnessTextureBase64) {
-                        var glTFMRColorTexture = _this._getTextureInfoFromBase64(metallicRoughnessFactors.metallicRoughnessTextureBase64, "bjsMetallicRoughnessTexture_" + textures.length + ".png", mimeType, reflectivityTexture ? reflectivityTexture.coordinatesIndex : null, samplerIndex);
+                        const glTFMRColorTexture = this._getTextureInfoFromBase64(metallicRoughnessFactors.metallicRoughnessTextureBase64, "bjsMetallicRoughnessTexture_" + textures.length + ".png", mimeType, reflectivityTexture ? reflectivityTexture.coordinatesIndex : null, samplerIndex);
                         if (glTFMRColorTexture) {
                             glTFPbrMetallicRoughness.metallicRoughnessTexture = glTFMRColorTexture;
                         }
@@ -765,43 +737,42 @@ var _GLTFMaterialExporter = /** @class */ (function () {
                 });
             }
             else {
-                return _this._convertSpecularGlossinessToMetallicRoughness(specGloss);
+                return this._convertSpecularGlossinessToMetallicRoughness(specGloss);
             }
         });
-    };
+    }
     /**
      * Converts a Babylon PBR Base Material to a glTF Material
      * @param babylonPBRMaterial BJS PBR Base Material
      * @param mimeType mime type to use for the textures
      * @param hasTextureCoords specifies if texture coordinates are present on the submesh to determine if textures should be applied
      */
-    _GLTFMaterialExporter.prototype._convertPBRMaterialAsync = function (babylonPBRMaterial, mimeType, hasTextureCoords) {
-        var _this = this;
-        var glTFPbrMetallicRoughness = {};
-        var glTFMaterial = {
+    _convertPBRMaterialAsync(babylonPBRMaterial, mimeType, hasTextureCoords) {
+        const glTFPbrMetallicRoughness = {};
+        const glTFMaterial = {
             name: babylonPBRMaterial.name,
         };
-        var useMetallicRoughness = babylonPBRMaterial.isMetallicWorkflow();
+        const useMetallicRoughness = babylonPBRMaterial.isMetallicWorkflow();
         if (useMetallicRoughness) {
-            var albedoColor = babylonPBRMaterial._albedoColor;
-            var alpha = babylonPBRMaterial.alpha;
+            const albedoColor = babylonPBRMaterial._albedoColor;
+            const alpha = babylonPBRMaterial.alpha;
             if (albedoColor) {
                 glTFPbrMetallicRoughness.baseColorFactor = [albedoColor.r, albedoColor.g, albedoColor.b, alpha];
             }
-            return this._convertMetalRoughFactorsToMetallicRoughnessAsync(babylonPBRMaterial, mimeType, glTFPbrMetallicRoughness, hasTextureCoords).then(function (metallicRoughness) {
-                return _this._setMetallicRoughnessPbrMaterial(metallicRoughness, babylonPBRMaterial, glTFMaterial, glTFPbrMetallicRoughness, mimeType, hasTextureCoords);
+            return this._convertMetalRoughFactorsToMetallicRoughnessAsync(babylonPBRMaterial, mimeType, glTFPbrMetallicRoughness, hasTextureCoords).then((metallicRoughness) => {
+                return this._setMetallicRoughnessPbrMaterial(metallicRoughness, babylonPBRMaterial, glTFMaterial, glTFPbrMetallicRoughness, mimeType, hasTextureCoords);
             });
         }
         else {
-            return this._convertSpecGlossFactorsToMetallicRoughnessAsync(babylonPBRMaterial, mimeType, glTFPbrMetallicRoughness, hasTextureCoords).then(function (metallicRoughness) {
-                return _this._setMetallicRoughnessPbrMaterial(metallicRoughness, babylonPBRMaterial, glTFMaterial, glTFPbrMetallicRoughness, mimeType, hasTextureCoords);
+            return this._convertSpecGlossFactorsToMetallicRoughnessAsync(babylonPBRMaterial, mimeType, glTFPbrMetallicRoughness, hasTextureCoords).then((metallicRoughness) => {
+                return this._setMetallicRoughnessPbrMaterial(metallicRoughness, babylonPBRMaterial, glTFMaterial, glTFPbrMetallicRoughness, mimeType, hasTextureCoords);
             });
         }
-    };
-    _GLTFMaterialExporter.prototype._setMetallicRoughnessPbrMaterial = function (metallicRoughness, babylonPBRMaterial, glTFMaterial, glTFPbrMetallicRoughness, mimeType, hasTextureCoords) {
-        var materialMap = this._exporter._materialMap;
-        var materials = this._exporter._materials;
-        var promises = [];
+    }
+    _setMetallicRoughnessPbrMaterial(metallicRoughness, babylonPBRMaterial, glTFMaterial, glTFPbrMetallicRoughness, mimeType, hasTextureCoords) {
+        const materialMap = this._exporter._materialMap;
+        const materials = this._exporter._materials;
+        const promises = [];
         if (metallicRoughness) {
             _GLTFMaterialExporter._SetAlphaMode(glTFMaterial, babylonPBRMaterial);
             if (!(_GLTFMaterialExporter._FuzzyEquals(metallicRoughness.baseColor, Color3.White(), _GLTFMaterialExporter._Epsilon) &&
@@ -821,28 +792,28 @@ var _GLTFMaterialExporter = /** @class */ (function () {
                 glTFMaterial.doubleSided = true;
             }
             if (hasTextureCoords) {
-                var bumpTexture_1 = babylonPBRMaterial._bumpTexture;
-                if (bumpTexture_1) {
-                    var promise = this._exportTextureAsync(bumpTexture_1, mimeType).then(function (glTFTexture) {
+                const bumpTexture = babylonPBRMaterial._bumpTexture;
+                if (bumpTexture) {
+                    const promise = this._exportTextureAsync(bumpTexture, mimeType).then((glTFTexture) => {
                         if (glTFTexture) {
                             glTFMaterial.normalTexture = glTFTexture;
-                            if (bumpTexture_1.level !== 1) {
-                                glTFMaterial.normalTexture.scale = bumpTexture_1.level;
+                            if (bumpTexture.level !== 1) {
+                                glTFMaterial.normalTexture.scale = bumpTexture.level;
                             }
                         }
                     });
                     promises.push(promise);
                 }
-                var ambientTexture = babylonPBRMaterial._ambientTexture;
+                const ambientTexture = babylonPBRMaterial._ambientTexture;
                 if (ambientTexture) {
-                    var promise = this._exportTextureAsync(ambientTexture, mimeType).then(function (glTFTexture) {
+                    const promise = this._exportTextureAsync(ambientTexture, mimeType).then((glTFTexture) => {
                         if (glTFTexture) {
-                            var occlusionTexture = {
+                            const occlusionTexture = {
                                 index: glTFTexture.index,
                                 texCoord: glTFTexture.texCoord,
                             };
                             glTFMaterial.occlusionTexture = occlusionTexture;
-                            var ambientTextureStrength = babylonPBRMaterial._ambientTextureStrength;
+                            const ambientTextureStrength = babylonPBRMaterial._ambientTextureStrength;
                             if (ambientTextureStrength) {
                                 occlusionTexture.strength = ambientTextureStrength;
                             }
@@ -850,9 +821,9 @@ var _GLTFMaterialExporter = /** @class */ (function () {
                     });
                     promises.push(promise);
                 }
-                var emissiveTexture = babylonPBRMaterial._emissiveTexture;
+                const emissiveTexture = babylonPBRMaterial._emissiveTexture;
                 if (emissiveTexture) {
-                    var promise = this._exportTextureAsync(emissiveTexture, mimeType).then(function (glTFTexture) {
+                    const promise = this._exportTextureAsync(emissiveTexture, mimeType).then((glTFTexture) => {
                         if (glTFTexture) {
                             glTFMaterial.emissiveTexture = glTFTexture;
                         }
@@ -860,7 +831,7 @@ var _GLTFMaterialExporter = /** @class */ (function () {
                     promises.push(promise);
                 }
             }
-            var emissiveColor = babylonPBRMaterial._emissiveColor;
+            const emissiveColor = babylonPBRMaterial._emissiveColor;
             if (!_GLTFMaterialExporter._FuzzyEquals(emissiveColor, Color3.Black(), _GLTFMaterialExporter._Epsilon)) {
                 glTFMaterial.emissiveFactor = emissiveColor.asArray();
             }
@@ -869,91 +840,84 @@ var _GLTFMaterialExporter = /** @class */ (function () {
             materialMap[babylonPBRMaterial.uniqueId] = materials.length - 1;
         }
         return this._finishMaterial(promises, glTFMaterial, babylonPBRMaterial, mimeType);
-    };
-    _GLTFMaterialExporter.prototype._getPixelsFromTexture = function (babylonTexture) {
-        var pixels = babylonTexture.textureType === Constants.TEXTURETYPE_UNSIGNED_INT
+    }
+    _getPixelsFromTexture(babylonTexture) {
+        const pixels = babylonTexture.textureType === Constants.TEXTURETYPE_UNSIGNED_INT
             ? babylonTexture.readPixels()
             : babylonTexture.readPixels();
         return pixels;
-    };
+    }
     /**
      * Extracts a texture from a Babylon texture into file data and glTF data
      * @param babylonTexture Babylon texture to extract
      * @param mimeType Mime Type of the babylonTexture
      * @return glTF texture info, or null if the texture format is not supported
      */
-    _GLTFMaterialExporter.prototype._exportTextureAsync = function (babylonTexture, mimeType) {
-        var _this = this;
-        var extensionPromise = this._exporter._extensionsPreExportTextureAsync("exporter", babylonTexture, mimeType);
+    _exportTextureAsync(babylonTexture, mimeType) {
+        const extensionPromise = this._exporter._extensionsPreExportTextureAsync("exporter", babylonTexture, mimeType);
         if (!extensionPromise) {
             return this._exportTextureInfoAsync(babylonTexture, mimeType);
         }
-        return extensionPromise.then(function (texture) {
+        return extensionPromise.then((texture) => {
             if (!texture) {
-                return _this._exportTextureInfoAsync(babylonTexture, mimeType);
+                return this._exportTextureInfoAsync(babylonTexture, mimeType);
             }
-            return _this._exportTextureInfoAsync(texture, mimeType);
+            return this._exportTextureInfoAsync(texture, mimeType);
         });
-    };
-    _GLTFMaterialExporter.prototype._exportTextureInfoAsync = function (babylonTexture, mimeType) {
-        var _this = this;
-        return Promise.resolve().then(function () { return __awaiter(_this, void 0, void 0, function () {
-            var textureUid, pixels, samplers, sampler, samplerIndex_1, foundSamplerIndex, i, s, size;
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        textureUid = babylonTexture.uid;
-                        if (!(textureUid in this._textureMap)) return [3 /*break*/, 1];
-                        return [2 /*return*/, this._textureMap[textureUid]];
-                    case 1: return [4 /*yield*/, this._getPixelsFromTexture(babylonTexture)];
-                    case 2:
-                        pixels = _a.sent();
-                        if (!pixels) {
-                            return [2 /*return*/, null];
-                        }
-                        samplers = this._exporter._samplers;
-                        sampler = this._getGLTFTextureSampler(babylonTexture);
-                        samplerIndex_1 = null;
-                        foundSamplerIndex = null;
-                        for (i = 0; i < samplers.length; ++i) {
-                            s = samplers[i];
-                            if (s.minFilter === sampler.minFilter && s.magFilter === sampler.magFilter && s.wrapS === sampler.wrapS && s.wrapT === sampler.wrapT) {
-                                foundSamplerIndex = i;
-                                break;
-                            }
-                        }
-                        if (foundSamplerIndex == null) {
-                            samplers.push(sampler);
-                            samplerIndex_1 = samplers.length - 1;
-                        }
-                        else {
-                            samplerIndex_1 = foundSamplerIndex;
-                        }
-                        size = babylonTexture.getSize();
-                        // Preserve texture mime type if defined
-                        if (babylonTexture.mimeType) {
-                            switch (babylonTexture.mimeType) {
-                                case "image/jpeg":
-                                    mimeType = "image/jpeg" /* JPEG */;
-                                    break;
-                                case "image/png":
-                                    mimeType = "image/png" /* PNG */;
-                                    break;
-                            }
-                        }
-                        return [2 /*return*/, this._createBase64FromCanvasAsync(pixels, size.width, size.height, mimeType).then(function (base64Data) {
-                                var textureInfo = _this._getTextureInfoFromBase64(base64Data, babylonTexture.name.replace(/\.\/|\/|\.\\|\\/g, "_"), mimeType, babylonTexture.coordinatesIndex, samplerIndex_1);
-                                if (textureInfo) {
-                                    _this._textureMap[textureUid] = textureInfo;
-                                    _this._exporter._extensionsPostExportTextures("linkTextureInfo", textureInfo, babylonTexture);
-                                }
-                                return textureInfo;
-                            })];
+    }
+    _exportTextureInfoAsync(babylonTexture, mimeType) {
+        return Promise.resolve().then(async () => {
+            const textureUid = babylonTexture.uid;
+            if (textureUid in this._textureMap) {
+                return this._textureMap[textureUid];
+            }
+            else {
+                const pixels = await this._getPixelsFromTexture(babylonTexture);
+                if (!pixels) {
+                    return null;
                 }
-            });
-        }); });
-    };
+                const samplers = this._exporter._samplers;
+                const sampler = this._getGLTFTextureSampler(babylonTexture);
+                let samplerIndex = null;
+                //  if a pre-existing sampler with identical parameters exists, then reuse the previous sampler
+                let foundSamplerIndex = null;
+                for (let i = 0; i < samplers.length; ++i) {
+                    const s = samplers[i];
+                    if (s.minFilter === sampler.minFilter && s.magFilter === sampler.magFilter && s.wrapS === sampler.wrapS && s.wrapT === sampler.wrapT) {
+                        foundSamplerIndex = i;
+                        break;
+                    }
+                }
+                if (foundSamplerIndex == null) {
+                    samplers.push(sampler);
+                    samplerIndex = samplers.length - 1;
+                }
+                else {
+                    samplerIndex = foundSamplerIndex;
+                }
+                const size = babylonTexture.getSize();
+                // Preserve texture mime type if defined
+                if (babylonTexture.mimeType) {
+                    switch (babylonTexture.mimeType) {
+                        case "image/jpeg":
+                            mimeType = "image/jpeg" /* JPEG */;
+                            break;
+                        case "image/png":
+                            mimeType = "image/png" /* PNG */;
+                            break;
+                    }
+                }
+                return this._createBase64FromCanvasAsync(pixels, size.width, size.height, mimeType).then((base64Data) => {
+                    const textureInfo = this._getTextureInfoFromBase64(base64Data, babylonTexture.name.replace(/\.\/|\/|\.\\|\\/g, "_"), mimeType, babylonTexture.coordinatesIndex, samplerIndex);
+                    if (textureInfo) {
+                        this._textureMap[textureUid] = textureInfo;
+                        this._exporter._extensionsPostExportTextures("linkTextureInfo", textureInfo, babylonTexture);
+                    }
+                    return textureInfo;
+                });
+            }
+        });
+    }
     /**
      * Builds a texture from base64 string
      * @param base64Texture base64 texture string
@@ -963,39 +927,39 @@ var _GLTFMaterialExporter = /** @class */ (function () {
      * @param samplerIndex
      * @returns glTF texture info, or null if the texture format is not supported
      */
-    _GLTFMaterialExporter.prototype._getTextureInfoFromBase64 = function (base64Texture, baseTextureName, mimeType, texCoordIndex, samplerIndex) {
-        var textures = this._exporter._textures;
-        var images = this._exporter._images;
-        var imageData = this._exporter._imageData;
-        var textureInfo = null;
-        var glTFTexture = {
+    _getTextureInfoFromBase64(base64Texture, baseTextureName, mimeType, texCoordIndex, samplerIndex) {
+        const textures = this._exporter._textures;
+        const images = this._exporter._images;
+        const imageData = this._exporter._imageData;
+        let textureInfo = null;
+        const glTFTexture = {
             source: images.length,
             name: baseTextureName,
         };
         if (samplerIndex != null) {
             glTFTexture.sampler = samplerIndex;
         }
-        var binStr = atob(base64Texture.split(",")[1]);
-        var arrBuff = new ArrayBuffer(binStr.length);
-        var arr = new Uint8Array(arrBuff);
-        for (var i = 0, length_2 = binStr.length; i < length_2; ++i) {
+        const binStr = atob(base64Texture.split(",")[1]);
+        const arrBuff = new ArrayBuffer(binStr.length);
+        const arr = new Uint8Array(arrBuff);
+        for (let i = 0, length = binStr.length; i < length; ++i) {
             arr[i] = binStr.charCodeAt(i);
         }
-        var imageValues = { data: arr, mimeType: mimeType };
-        var extension = mimeType === "image/jpeg" /* JPEG */ ? ".jpeg" : ".png";
-        var textureName = baseTextureName + extension;
-        var originalTextureName = textureName;
+        const imageValues = { data: arr, mimeType: mimeType };
+        const extension = mimeType === "image/jpeg" /* JPEG */ ? ".jpeg" : ".png";
+        let textureName = baseTextureName + extension;
+        const originalTextureName = textureName;
         if (textureName in imageData) {
-            textureName = "".concat(baseTextureName, "_").concat(Tools.RandomId()).concat(extension);
+            textureName = `${baseTextureName}_${Tools.RandomId()}${extension}`;
         }
         imageData[textureName] = imageValues;
         if (mimeType === "image/jpeg" /* JPEG */ || mimeType === "image/png" /* PNG */) {
-            var glTFImage = {
+            const glTFImage = {
                 name: baseTextureName,
                 uri: textureName,
             };
-            var foundIndex = null;
-            for (var i = 0; i < images.length; ++i) {
+            let foundIndex = null;
+            for (let i = 0; i < images.length; ++i) {
                 if (images[i].uri === originalTextureName) {
                     foundIndex = i;
                     break;
@@ -1017,23 +981,21 @@ var _GLTFMaterialExporter = /** @class */ (function () {
             }
         }
         else {
-            Tools.Error("Unsupported texture mime type ".concat(mimeType));
+            Tools.Error(`Unsupported texture mime type ${mimeType}`);
         }
         return textureInfo;
-    };
-    /**
-     * Represents the dielectric specular values for R, G and B
-     */
-    _GLTFMaterialExporter._DielectricSpecular = new Color3(0.04, 0.04, 0.04);
-    /**
-     * Allows the maximum specular power to be defined for material calculations
-     */
-    _GLTFMaterialExporter._MaxSpecularPower = 1024;
-    /**
-     * Numeric tolerance value
-     */
-    _GLTFMaterialExporter._Epsilon = 1e-6;
-    return _GLTFMaterialExporter;
-}());
-export { _GLTFMaterialExporter };
+    }
+}
+/**
+ * Represents the dielectric specular values for R, G and B
+ */
+_GLTFMaterialExporter._DielectricSpecular = new Color3(0.04, 0.04, 0.04);
+/**
+ * Allows the maximum specular power to be defined for material calculations
+ */
+_GLTFMaterialExporter._MaxSpecularPower = 1024;
+/**
+ * Numeric tolerance value
+ */
+_GLTFMaterialExporter._Epsilon = 1e-6;
 //# sourceMappingURL=glTFMaterialExporter.js.map