@babylonjs/serializers 5.0.0-beta.8 → 5.0.0-beta.8-snapshot

package/glTF/2.0/glTFMaterialExporter.js

@@ -1,1143 +0,0 @@
-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";
-import { Tools } from "@babylonjs/core/Misc/tools.js";
-import { TextureTools } from "@babylonjs/core/Misc/textureTools.js";
-import { Texture } from "@babylonjs/core/Materials/Textures/texture.js";
-import { RawTexture } from "@babylonjs/core/Materials/Textures/rawTexture.js";
-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) {
-        /**
-         * Mapping to store textures
-         */
-        this._textureMap = {};
-        this._textureMap = {};
-        this._exporter = exporter;
-    }
-    /**
-     * Specifies if two colors are approximately equal in value
-     * @param color1 first color to compare to
-     * @param color2 second color to compare to
-     * @param epsilon threshold value
-     */
-    _GLTFMaterialExporter.FuzzyEquals = function (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 scene babylonjs scene
-     * @param mimeType texture mime type
-     * @param images array of images
-     * @param textures array of textures
-     * @param materials set of materials
-     * @param imageData mapping of texture names to base64 textures
-     * @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) {
-            if (material.getClassName() === "StandardMaterial") {
-                promises.push(_this._convertStandardMaterialAsync(material, mimeType, hasTextureCoords));
-            }
-            else if (material.getClassName().indexOf("PBR") !== -1) {
-                promises.push(_this._convertPBRMaterialAsync(material, mimeType, hasTextureCoords));
-            }
-            else {
-                Tools.Warn("Unsupported material type: ".concat(material.name));
-            }
-        });
-        return Promise.all(promises).then(function () { });
-    };
-    /**
-     * 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 = {};
-        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;
-            if (originalPBRMetallicRoughness) {
-                newMaterial.pbrMetallicRoughness = {};
-                newMaterial.pbrMetallicRoughness.baseColorFactor = originalPBRMetallicRoughness.baseColorFactor;
-                newMaterial.pbrMetallicRoughness.metallicFactor = originalPBRMetallicRoughness.metallicFactor;
-                newMaterial.pbrMetallicRoughness.roughnessFactor = originalPBRMetallicRoughness.roughnessFactor;
-            }
-        }
-        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;
-        if (material.emissiveTexture || material.normalTexture || material.occlusionTexture) {
-            return true;
-        }
-        var 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];
-                if (extensionObject) {
-                    return (_a = extensionObject.hasTextures) === null || _a === void 0 ? void 0 : _a.call(extensionObject);
-                }
-            }
-        }
-        return false;
-    };
-    _GLTFMaterialExporter.prototype._getTextureInfo = function (babylonTexture) {
-        if (babylonTexture) {
-            var 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) {
-        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);
-        /**
-         * 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
-         * @param p0 first control point
-         * @param p1 second control point
-         * @param p2 third control point
-         * @param p3 fourth control point
-         * @returns number result of cubic bezier curve at the specified t
-         */
-        function _cubicBezierCurve(t, p0, p1, p2, p3) {
-            return ((1 - t) * (1 - t) * (1 - t) * p0 +
-                3 * (1 - t) * (1 - t) * t * p1 +
-                3 * (1 - t) * t * t * p2 +
-                t * t * t * p3);
-        }
-        /**
-         * Evaluates a specified specular power value to determine the appropriate roughness value,
-         * based on a pre-defined cubic bezier curve with specular on the abscissa axis (x-axis)
-         * and roughness on the ordinant axis (y-axis)
-         * @param specularPower specular power of standard material
-         * @returns Number representing the roughness value
-         */
-        function _solveForRoughness(specularPower) {
-            var 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 = {
-            baseColorFactor: [
-                diffuse.r,
-                diffuse.g,
-                diffuse.b,
-                opacity
-            ],
-            metallicFactor: 0,
-            roughnessFactor: roughness,
-        };
-        return glTFPbrMetallicRoughness;
-    };
-    /**
-     * Computes the metallic factor
-     * @param diffuse diffused value
-     * @param specular specular value
-     * @param oneMinusSpecularStrength one minus the specular strength
-     * @returns metallic value
-     */
-    _GLTFMaterialExporter._SolveMetallic = function (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;
-        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) {
-        if (babylonMaterial.needAlphaBlending()) {
-            glTFMaterial.alphaMode = "BLEND" /* BLEND */;
-        }
-        else if (babylonMaterial.needAlphaTesting()) {
-            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 images array of glTF image interfaces
-     * @param textures array of glTF texture interfaces
-     * @param materials array of glTF material interfaces
-     * @param imageData map of image file name to data
-     * @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 };
-        if (babylonStandardMaterial.backFaceCulling != null && !babylonStandardMaterial.backFaceCulling) {
-            if (!babylonStandardMaterial.twoSidedLighting) {
-                Tools.Warn(babylonStandardMaterial.name + ": Back-face culling enabled and two-sided lighting disabled is not supported in glTF.");
-            }
-            glTFMaterial.doubleSided = true;
-        }
-        if (hasTextureCoords) {
-            if (babylonStandardMaterial.diffuseTexture) {
-                promises.push(this._exportTextureAsync(babylonStandardMaterial.diffuseTexture, mimeType).then(function (glTFTexture) {
-                    if (glTFTexture) {
-                        glTFPbrMetallicRoughness.baseColorTexture = glTFTexture;
-                    }
-                }));
-            }
-            if (babylonStandardMaterial.bumpTexture) {
-                promises.push(this._exportTextureAsync(babylonStandardMaterial.bumpTexture, mimeType).then(function (glTFTexture) {
-                    if (glTFTexture) {
-                        glTFMaterial.normalTexture = glTFTexture;
-                        if (babylonStandardMaterial.bumpTexture != null && babylonStandardMaterial.bumpTexture.level !== 1) {
-                            glTFMaterial.normalTexture.scale = babylonStandardMaterial.bumpTexture.level;
-                        }
-                    }
-                }));
-            }
-            if (babylonStandardMaterial.emissiveTexture) {
-                glTFMaterial.emissiveFactor = [1.0, 1.0, 1.0];
-                promises.push(this._exportTextureAsync(babylonStandardMaterial.emissiveTexture, mimeType).then(function (glTFEmissiveTexture) {
-                    if (glTFEmissiveTexture) {
-                        glTFMaterial.emissiveTexture = glTFEmissiveTexture;
-                    }
-                }));
-            }
-            if (babylonStandardMaterial.ambientTexture) {
-                promises.push(this._exportTextureAsync(babylonStandardMaterial.ambientTexture, mimeType).then(function (glTFTexture) {
-                    if (glTFTexture) {
-                        var occlusionTexture = {
-                            index: glTFTexture.index
-                        };
-                        glTFMaterial.occlusionTexture = occlusionTexture;
-                        occlusionTexture.strength = 1.0;
-                    }
-                }));
-            }
-        }
-        if (babylonStandardMaterial.alpha < 1.0 || babylonStandardMaterial.opacityTexture) {
-            if (babylonStandardMaterial.alphaMode === Constants.ALPHA_COMBINE) {
-                glTFMaterial.alphaMode = "BLEND" /* BLEND */;
-            }
-            else {
-                Tools.Warn(babylonStandardMaterial.name + ": glTF 2.0 does not support alpha mode: " + babylonStandardMaterial.alphaMode.toString());
-            }
-        }
-        if (babylonStandardMaterial.emissiveColor && !_GLTFMaterialExporter.FuzzyEquals(babylonStandardMaterial.emissiveColor, Color3.Black(), _GLTFMaterialExporter._Epsilon)) {
-            glTFMaterial.emissiveFactor = babylonStandardMaterial.emissiveColor.asArray();
-        }
-        glTFMaterial.pbrMetallicRoughness = glTFPbrMetallicRoughness;
-        _GLTFMaterialExporter._SetAlphaMode(glTFMaterial, babylonStandardMaterial);
-        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];
-                if (!tasks) {
-                    tasks = [];
-                }
-                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);
-                if (!extensionWork) {
-                    return glTFMaterial;
-                }
-                return extensionWork.then(function () { return glTFMaterial; });
-            });
-        });
-    };
-    /**
-     * Converts a Babylon PBR Metallic Roughness Material to a glTF Material
-     * @param babylonPBRMetalRoughMaterial BJS PBR Metallic Roughness Material
-     * @param mimeType mime type to use for the textures
-     * @param images array of glTF image interfaces
-     * @param textures array of glTF texture interfaces
-     * @param materials array of glTF material interfaces
-     * @param imageData map of image file name to data
-     * @param hasTextureCoords specifies if texture coordinates are present on the submesh to determine if textures should be applied
-     */
-    _GLTFMaterialExporter.prototype._convertPBRMetallicRoughnessMaterialAsync = function (babylonPBRMetalRoughMaterial, mimeType, hasTextureCoords) {
-        var materialMap = this._exporter._materialMap;
-        var materials = this._exporter._materials;
-        var promises = [];
-        var glTFPbrMetallicRoughness = {};
-        if (babylonPBRMetalRoughMaterial.baseColor) {
-            glTFPbrMetallicRoughness.baseColorFactor = [
-                babylonPBRMetalRoughMaterial.baseColor.r,
-                babylonPBRMetalRoughMaterial.baseColor.g,
-                babylonPBRMetalRoughMaterial.baseColor.b,
-                babylonPBRMetalRoughMaterial.alpha
-            ];
-        }
-        if (babylonPBRMetalRoughMaterial.metallic != null && babylonPBRMetalRoughMaterial.metallic !== 1) {
-            glTFPbrMetallicRoughness.metallicFactor = babylonPBRMetalRoughMaterial.metallic;
-        }
-        if (babylonPBRMetalRoughMaterial.roughness != null && babylonPBRMetalRoughMaterial.roughness !== 1) {
-            glTFPbrMetallicRoughness.roughnessFactor = babylonPBRMetalRoughMaterial.roughness;
-        }
-        var glTFMaterial = {
-            name: babylonPBRMetalRoughMaterial.name
-        };
-        if (babylonPBRMetalRoughMaterial.doubleSided) {
-            glTFMaterial.doubleSided = babylonPBRMetalRoughMaterial.doubleSided;
-        }
-        _GLTFMaterialExporter._SetAlphaMode(glTFMaterial, babylonPBRMetalRoughMaterial);
-        if (hasTextureCoords) {
-            if (babylonPBRMetalRoughMaterial.baseTexture != null) {
-                promises.push(this._exportTextureAsync(babylonPBRMetalRoughMaterial.baseTexture, mimeType).then(function (glTFTexture) {
-                    if (glTFTexture) {
-                        glTFPbrMetallicRoughness.baseColorTexture = glTFTexture;
-                    }
-                }));
-            }
-            if (babylonPBRMetalRoughMaterial.normalTexture) {
-                promises.push(this._exportTextureAsync(babylonPBRMetalRoughMaterial.normalTexture, mimeType).then(function (glTFTexture) {
-                    if (glTFTexture) {
-                        glTFMaterial.normalTexture = glTFTexture;
-                        if (babylonPBRMetalRoughMaterial.normalTexture.level !== 1) {
-                            glTFMaterial.normalTexture.scale = babylonPBRMetalRoughMaterial.normalTexture.level;
-                        }
-                    }
-                }));
-            }
-            if (babylonPBRMetalRoughMaterial.occlusionTexture) {
-                promises.push(this._exportTextureAsync(babylonPBRMetalRoughMaterial.occlusionTexture, mimeType).then(function (glTFTexture) {
-                    if (glTFTexture) {
-                        glTFMaterial.occlusionTexture = glTFTexture;
-                        if (babylonPBRMetalRoughMaterial.occlusionStrength != null) {
-                            glTFMaterial.occlusionTexture.strength = babylonPBRMetalRoughMaterial.occlusionStrength;
-                        }
-                    }
-                }));
-            }
-            if (babylonPBRMetalRoughMaterial.emissiveTexture) {
-                promises.push(this._exportTextureAsync(babylonPBRMetalRoughMaterial.emissiveTexture, mimeType).then(function (glTFTexture) {
-                    if (glTFTexture) {
-                        glTFMaterial.emissiveTexture = glTFTexture;
-                    }
-                }));
-            }
-        }
-        if (_GLTFMaterialExporter.FuzzyEquals(babylonPBRMetalRoughMaterial.emissiveColor, Color3.Black(), _GLTFMaterialExporter._Epsilon)) {
-            glTFMaterial.emissiveFactor = babylonPBRMetalRoughMaterial.emissiveColor.asArray();
-        }
-        glTFMaterial.pbrMetallicRoughness = glTFPbrMetallicRoughness;
-        materials.push(glTFMaterial);
-        materialMap[babylonPBRMetalRoughMaterial.uniqueId] = materials.length - 1;
-        return this._finishMaterial(promises, glTFMaterial, babylonPBRMetalRoughMaterial, mimeType);
-    };
-    /**
-     * Converts an image typed array buffer to a base64 image
-     * @param buffer typed array buffer
-     * @param width width of the image
-     * @param height height of the image
-     * @param mimeType mimetype of the image
-     * @returns base64 image string
-     */
-    _GLTFMaterialExporter.prototype._createBase64FromCanvasAsync = function (buffer, width, height, mimeType) {
-        var _this = this;
-        return new Promise(function (resolve, reject) { 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*/];
-                }
-            });
-        }); });
-    };
-    /**
-     * Generates a white texture based on the specified width and height
-     * @param width width of the texture in pixels
-     * @param height height of the texture in pixels
-     * @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) {
-            data[i] = data[i + 1] = data[i + 2] = data[i + 3] = 0xFF;
-        }
-        var 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
-     * @param texture2 second texture to resize
-     * @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;
-        if (texture1Size.width < texture2Size.width) {
-            if (texture1 && texture1 instanceof Texture) {
-                resizedTexture1 = TextureTools.CreateResizedCopy(texture1, texture2Size.width, texture2Size.height, true);
-            }
-            else {
-                resizedTexture1 = this._createWhiteTexture(texture2Size.width, texture2Size.height, scene);
-            }
-            resizedTexture2 = texture2;
-        }
-        else if (texture1Size.width > texture2Size.width) {
-            if (texture2 && texture2 instanceof Texture) {
-                resizedTexture2 = TextureTools.CreateResizedCopy(texture2, texture1Size.width, texture1Size.height, true);
-            }
-            else {
-                resizedTexture2 = this._createWhiteTexture(texture1Size.width, texture1Size.height, scene);
-            }
-            resizedTexture1 = texture1;
-        }
-        else {
-            resizedTexture1 = texture1;
-            resizedTexture2 = texture2;
-        }
-        return {
-            "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) {
-        if (pixels instanceof Uint8Array) {
-            var length_1 = pixels.length;
-            var buffer = new Float32Array(pixels.length);
-            for (var i = 0; i < length_1; ++i) {
-                buffer[i] = pixels[i] / 255;
-            }
-            return buffer;
-        }
-        else if (pixels instanceof Float32Array) {
-            return pixels;
-        }
-        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
-     * @link https://github.com/KhronosGroup/glTF/blob/master/extensions/2.0/Khronos/KHR_materials_pbrSpecularGlossiness/examples/convert-between-workflows-bjs/js/babylon.pbrUtilities.js
-     * @param diffuseTexture texture used to store diffuse information
-     * @param specularGlossinessTexture texture used to store specular and glossiness information
-     * @param factors specular glossiness material factors
-     * @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!")];
-                }
-            });
-        });
-    };
-    /**
-     * 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.subtract(_GLTFMaterialExporter._DielectricSpecular.scale(1 - metallic)).scale(1 / Math.max(metallic, _GLTFMaterialExporter._Epsilon));
-        var baseColor = Color3.Lerp(baseColorFromDiffuse, baseColorFromSpecular, metallic * metallic);
-        baseColor = baseColor.clampToRef(0, 1, baseColor);
-        var 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) {
-        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) {
-        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
-     * @param mimeType mime type to use for the textures
-     * @param images array of glTF image interfaces
-     * @param textures array of glTF texture interfaces
-     * @param glTFPbrMetallicRoughness glTF PBR Metallic Roughness interface
-     * @param imageData map of image file name to data
-     * @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 = {
-            baseColor: baseColor,
-            metallic: metallic,
-            roughness: roughness
-        };
-        if (hasTextureCoords) {
-            var albedoTexture = babylonPBRMaterial._albedoTexture;
-            if (albedoTexture) {
-                promises.push(this._exportTextureAsync(babylonPBRMaterial._albedoTexture, mimeType).then(function (glTFTexture) {
-                    if (glTFTexture) {
-                        glTFPbrMetallicRoughness.baseColorTexture = glTFTexture;
-                    }
-                }));
-            }
-            var metallicTexture = babylonPBRMaterial._metallicTexture;
-            if (metallicTexture) {
-                promises.push(this._exportTextureAsync(metallicTexture, mimeType).then(function (glTFTexture) {
-                    if (glTFTexture) {
-                        glTFPbrMetallicRoughness.metallicRoughnessTexture = glTFTexture;
-                    }
-                }));
-            }
-        }
-        return Promise.all(promises).then(function () {
-            return metallicRoughness;
-        });
-    };
-    _GLTFMaterialExporter.prototype._getGLTFTextureSampler = function (texture) {
-        var sampler = this._getGLTFTextureWrapModesSampler(texture);
-        var samplingMode = texture instanceof Texture ? texture.samplingMode : null;
-        if (samplingMode != null) {
-            switch (samplingMode) {
-                case Texture.LINEAR_LINEAR: {
-                    sampler.magFilter = 9729 /* LINEAR */;
-                    sampler.minFilter = 9729 /* LINEAR */;
-                    break;
-                }
-                case Texture.LINEAR_NEAREST: {
-                    sampler.magFilter = 9729 /* LINEAR */;
-                    sampler.minFilter = 9728 /* NEAREST */;
-                    break;
-                }
-                case Texture.NEAREST_LINEAR: {
-                    sampler.magFilter = 9728 /* NEAREST */;
-                    sampler.minFilter = 9729 /* LINEAR */;
-                    break;
-                }
-                case Texture.NEAREST_LINEAR_MIPLINEAR: {
-                    sampler.magFilter = 9728 /* NEAREST */;
-                    sampler.minFilter = 9987 /* LINEAR_MIPMAP_LINEAR */;
-                    break;
-                }
-                case Texture.NEAREST_NEAREST: {
-                    sampler.magFilter = 9728 /* NEAREST */;
-                    sampler.minFilter = 9728 /* NEAREST */;
-                    break;
-                }
-                case Texture.NEAREST_LINEAR_MIPNEAREST: {
-                    sampler.magFilter = 9728 /* NEAREST */;
-                    sampler.minFilter = 9985 /* LINEAR_MIPMAP_NEAREST */;
-                    break;
-                }
-                case Texture.LINEAR_NEAREST_MIPNEAREST: {
-                    sampler.magFilter = 9729 /* LINEAR */;
-                    sampler.minFilter = 9984 /* NEAREST_MIPMAP_NEAREST */;
-                    break;
-                }
-                case Texture.LINEAR_NEAREST_MIPLINEAR: {
-                    sampler.magFilter = 9729 /* LINEAR */;
-                    sampler.minFilter = 9986 /* NEAREST_MIPMAP_LINEAR */;
-                    break;
-                }
-                case Texture.NEAREST_NEAREST_MIPLINEAR: {
-                    sampler.magFilter = 9728 /* NEAREST */;
-                    sampler.minFilter = 9986 /* NEAREST_MIPMAP_LINEAR */;
-                    break;
-                }
-                case Texture.LINEAR_LINEAR_MIPLINEAR: {
-                    sampler.magFilter = 9729 /* LINEAR */;
-                    sampler.minFilter = 9987 /* LINEAR_MIPMAP_LINEAR */;
-                    break;
-                }
-                case Texture.LINEAR_LINEAR_MIPNEAREST: {
-                    sampler.magFilter = 9729 /* LINEAR */;
-                    sampler.minFilter = 9985 /* LINEAR_MIPMAP_NEAREST */;
-                    break;
-                }
-                case Texture.NEAREST_NEAREST_MIPNEAREST: {
-                    sampler.magFilter = 9728 /* NEAREST */;
-                    sampler.minFilter = 9984 /* NEAREST_MIPMAP_NEAREST */;
-                    break;
-                }
-            }
-        }
-        return sampler;
-    };
-    _GLTFMaterialExporter.prototype._getGLTFTextureWrapMode = function (wrapMode) {
-        switch (wrapMode) {
-            case Texture.WRAP_ADDRESSMODE: {
-                return 10497 /* REPEAT */;
-            }
-            case Texture.CLAMP_ADDRESSMODE: {
-                return 33071 /* CLAMP_TO_EDGE */;
-            }
-            case Texture.MIRROR_ADDRESSMODE: {
-                return 33648 /* MIRRORED_REPEAT */;
-            }
-            default: {
-                Tools.Error("Unsupported Texture Wrap Mode ".concat(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);
-        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
-     * @param mimeType mime type to use for the textures
-     * @param images array of glTF image interfaces
-     * @param textures array of glTF texture interfaces
-     * @param glTFPbrMetallicRoughness glTF PBR Metallic Roughness interface
-     * @param imageData map of image file name to data
-     * @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 = {
-                diffuseColor: diffuseColor,
-                specularColor: specularColor,
-                glossiness: glossiness,
-            };
-            var samplerIndex = null;
-            var albedoTexture = babylonPBRMaterial._albedoTexture;
-            var reflectivityTexture = babylonPBRMaterial._reflectivityTexture;
-            if (albedoTexture) {
-                var 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;
-            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) {
-                    if (metallicRoughnessFactors.baseColorTextureBase64) {
-                        var 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);
-                        if (glTFMRColorTexture) {
-                            glTFPbrMetallicRoughness.metallicRoughnessTexture = glTFMRColorTexture;
-                        }
-                    }
-                    return metallicRoughnessFactors;
-                });
-            }
-            else {
-                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 images array of glTF image interfaces
-     * @param textures array of glTF texture interfaces
-     * @param materials array of glTF material interfaces
-     * @param imageData map of image file name to data
-     * @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 = {
-            name: babylonPBRMaterial.name
-        };
-        var useMetallicRoughness = babylonPBRMaterial.isMetallicWorkflow();
-        if (useMetallicRoughness) {
-            var albedoColor = babylonPBRMaterial._albedoColor;
-            var 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);
-            });
-        }
-        else {
-            return this._convertSpecGlossFactorsToMetallicRoughnessAsync(babylonPBRMaterial, mimeType, glTFPbrMetallicRoughness, hasTextureCoords).then(function (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 = [];
-        if (metallicRoughness) {
-            _GLTFMaterialExporter._SetAlphaMode(glTFMaterial, babylonPBRMaterial);
-            if (!(_GLTFMaterialExporter.FuzzyEquals(metallicRoughness.baseColor, Color3.White(), _GLTFMaterialExporter._Epsilon) && babylonPBRMaterial.alpha >= _GLTFMaterialExporter._Epsilon)) {
-                glTFPbrMetallicRoughness.baseColorFactor = [
-                    metallicRoughness.baseColor.r,
-                    metallicRoughness.baseColor.g,
-                    metallicRoughness.baseColor.b,
-                    babylonPBRMaterial.alpha
-                ];
-            }
-            if (metallicRoughness.metallic != null && metallicRoughness.metallic !== 1) {
-                glTFPbrMetallicRoughness.metallicFactor = metallicRoughness.metallic;
-            }
-            if (metallicRoughness.roughness != null && metallicRoughness.roughness !== 1) {
-                glTFPbrMetallicRoughness.roughnessFactor = metallicRoughness.roughness;
-            }
-            if (babylonPBRMaterial.backFaceCulling != null && !babylonPBRMaterial.backFaceCulling) {
-                if (!babylonPBRMaterial._twoSidedLighting) {
-                    Tools.Warn(babylonPBRMaterial.name + ": Back-face culling enabled and two-sided lighting disabled is not supported in glTF.");
-                }
-                glTFMaterial.doubleSided = true;
-            }
-            if (hasTextureCoords) {
-                var bumpTexture_1 = babylonPBRMaterial._bumpTexture;
-                if (bumpTexture_1) {
-                    var promise = this._exportTextureAsync(bumpTexture_1, mimeType).then(function (glTFTexture) {
-                        if (glTFTexture) {
-                            glTFMaterial.normalTexture = glTFTexture;
-                            if (bumpTexture_1.level !== 1) {
-                                glTFMaterial.normalTexture.scale = bumpTexture_1.level;
-                            }
-                        }
-                    });
-                    promises.push(promise);
-                }
-                var ambientTexture = babylonPBRMaterial._ambientTexture;
-                if (ambientTexture) {
-                    var promise = this._exportTextureAsync(ambientTexture, mimeType).then(function (glTFTexture) {
-                        if (glTFTexture) {
-                            var occlusionTexture = {
-                                index: glTFTexture.index,
-                                texCoord: glTFTexture.texCoord
-                            };
-                            glTFMaterial.occlusionTexture = occlusionTexture;
-                            var ambientTextureStrength = babylonPBRMaterial._ambientTextureStrength;
-                            if (ambientTextureStrength) {
-                                occlusionTexture.strength = ambientTextureStrength;
-                            }
-                        }
-                    });
-                    promises.push(promise);
-                }
-                var emissiveTexture = babylonPBRMaterial._emissiveTexture;
-                if (emissiveTexture) {
-                    var promise = this._exportTextureAsync(emissiveTexture, mimeType).then(function (glTFTexture) {
-                        if (glTFTexture) {
-                            glTFMaterial.emissiveTexture = glTFTexture;
-                        }
-                    });
-                    promises.push(promise);
-                }
-            }
-            var emissiveColor = babylonPBRMaterial._emissiveColor;
-            if (!_GLTFMaterialExporter.FuzzyEquals(emissiveColor, Color3.Black(), _GLTFMaterialExporter._Epsilon)) {
-                glTFMaterial.emissiveFactor = emissiveColor.asArray();
-            }
-            glTFMaterial.pbrMetallicRoughness = glTFPbrMetallicRoughness;
-            materials.push(glTFMaterial);
-            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 ? 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);
-        if (!extensionPromise) {
-            return this._exportTextureInfoAsync(babylonTexture, mimeType);
-        }
-        return extensionPromise.then(function (texture) {
-            if (!texture) {
-                return _this._exportTextureInfoAsync(babylonTexture, 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;
-                            })];
-                }
-            });
-        }); });
-    };
-    /**
-     * Builds a texture from base64 string
-     * @param base64Texture base64 texture string
-     * @param baseTextureName Name to use for the texture
-     * @param mimeType image mime type for the texture
-     * @param images array of images
-     * @param textures array of textures
-     * @param imageData map of image data
-     * @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 = {
-            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) {
-            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;
-        if (textureName in imageData) {
-            textureName = "".concat(baseTextureName, "_").concat(Tools.RandomId()).concat(extension);
-        }
-        imageData[textureName] = imageValues;
-        if (mimeType === "image/jpeg" /* JPEG */ || mimeType === "image/png" /* PNG */) {
-            var glTFImage = {
-                name: baseTextureName,
-                uri: textureName
-            };
-            var foundIndex = null;
-            for (var i = 0; i < images.length; ++i) {
-                if (images[i].uri === originalTextureName) {
-                    foundIndex = i;
-                    break;
-                }
-            }
-            if (foundIndex == null) {
-                images.push(glTFImage);
-                glTFTexture.source = images.length - 1;
-            }
-            else {
-                glTFTexture.source = foundIndex;
-            }
-            textures.push(glTFTexture);
-            textureInfo = {
-                index: textures.length - 1
-            };
-            if (texCoordIndex != null) {
-                textureInfo.texCoord = texCoordIndex;
-            }
-        }
-        else {
-            Tools.Error("Unsupported texture mime type ".concat(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 };
-//# sourceMappingURL=glTFMaterialExporter.js.map