@babylonjs/serializers 8.23.1 → 8.24.0

package/glTF/2.0/glTFExporterExtension.js.map

@@ -1 +1 @@
-{"version":3,"file":"glTFExporterExtension.js","sourceRoot":"","sources":["../../../../../dev/serializers/src/glTF/2.0/glTFExporterExtension.ts"],"names":[],"mappings":"AAYA,gBAAgB;AAChB,wEAAwE;AACxE,MAAM,CAAC,IAAI,0BAA0B,GAAG,CAAC,CAAC,CAAC,uCAAuC","sourcesContent":["import type { ImageMimeType, IMeshPrimitive, INode, IMaterial, ITextureInfo, IAccessor } from \"babylonjs-gltf2interface\";\r\nimport type { Node } from \"core/node\";\r\nimport type { Nullable } from \"core/types\";\r\n\r\nimport type { Texture } from \"core/Materials/Textures/texture\";\r\nimport type { IDisposable } from \"core/scene\";\r\n\r\nimport type { IGLTFExporterExtension } from \"../glTFFileExporter\";\r\nimport type { Material } from \"core/Materials/material\";\r\nimport type { BaseTexture } from \"core/Materials/Textures/baseTexture\";\r\nimport type { BufferManager } from \"./bufferManager\";\r\n\r\n/** @internal */\r\n// eslint-disable-next-line no-var, @typescript-eslint/naming-convention\r\nexport var __IGLTFExporterExtensionV2 = 0; // I am here to allow dts to be created\r\n\r\n/**\r\n * Interface for a glTF exporter extension\r\n * @internal\r\n */\r\nexport interface IGLTFExporterExtensionV2 extends IGLTFExporterExtension, IDisposable {\r\n    /**\r\n     * Define this method to modify the default behavior before exporting a texture\r\n     * @param context The context when loading the asset\r\n     * @param babylonTexture The Babylon.js texture\r\n     * @param mimeType The mime-type of the generated image\r\n     * @returns A promise that resolves with the exported texture\r\n     */\r\n    preExportTextureAsync?(context: string, babylonTexture: Texture, mimeType: ImageMimeType): Promise<Nullable<Texture>>;\r\n\r\n    /**\r\n     * Define this method to get notified when a texture info is created\r\n     * @param context The context when loading the asset\r\n     * @param textureInfo The glTF texture info\r\n     * @param babylonTexture The Babylon.js texture\r\n     */\r\n    postExportTexture?(context: string, textureInfo: ITextureInfo, babylonTexture: BaseTexture): void;\r\n\r\n    /**\r\n     * Define this method to get notified when a primitive is created\r\n     * @param primitive glTF mesh primitive\r\n     * @param bufferManager Buffer manager\r\n     * @param accessors List of glTF accessors\r\n     */\r\n    postExportMeshPrimitive?(primitive: IMeshPrimitive, bufferManager: BufferManager, accessors: IAccessor[]): void;\r\n\r\n    /**\r\n     * Define this method to modify the default behavior when exporting a node\r\n     * @param context The context when exporting the node\r\n     * @param node glTF node\r\n     * @param babylonNode BabylonJS node\r\n     * @param nodeMap Current node mapping of babylon node to glTF node index. Useful for combining nodes together.\r\n     * @param convertToRightHanded Flag indicating whether to convert values to right-handed\r\n     * @param bufferManager Buffer manager\r\n     * @returns nullable INode promise\r\n     */\r\n    postExportNodeAsync?(\r\n        context: string,\r\n        node: INode,\r\n        babylonNode: Node,\r\n        nodeMap: Map<Node, number>,\r\n        convertToRightHanded: boolean,\r\n        bufferManager: BufferManager\r\n    ): Promise<Nullable<INode>>;\r\n\r\n    /**\r\n     * Define this method to modify the default behavior when exporting a material\r\n     * @param material glTF material\r\n     * @param babylonMaterial BabylonJS material\r\n     * @returns nullable IMaterial promise\r\n     */\r\n    postExportMaterialAsync?(context: string, node: IMaterial, babylonMaterial: Material): Promise<IMaterial>;\r\n\r\n    /**\r\n     * Define this method to return additional textures to export from a material\r\n     * @param material glTF material\r\n     * @param babylonMaterial BabylonJS material\r\n     * @returns List of textures\r\n     */\r\n    postExportMaterialAdditionalTextures?(context: string, node: IMaterial, babylonMaterial: Material): BaseTexture[];\r\n\r\n    /**\r\n     * Define this method to modify the glTF buffer data before it is finalized and written\r\n     * @param bufferManager Buffer manager\r\n     */\r\n    preGenerateBinaryAsync?(bufferManager: BufferManager): Promise<void>;\r\n\r\n    /** Gets a boolean indicating that this extension was used */\r\n    wasUsed: boolean;\r\n\r\n    /** Gets a boolean indicating that this extension is required for the file to work */\r\n    required: boolean;\r\n\r\n    /**\r\n     * Called after the exporter state changes to EXPORTING\r\n     */\r\n    onExporting?(): void;\r\n}\r\n"]}
+{"version":3,"file":"glTFExporterExtension.js","sourceRoot":"","sources":["../../../../../dev/serializers/src/glTF/2.0/glTFExporterExtension.ts"],"names":[],"mappings":"AAWA,gBAAgB;AAChB,wEAAwE;AACxE,MAAM,CAAC,IAAI,0BAA0B,GAAG,CAAC,CAAC,CAAC,uCAAuC","sourcesContent":["import type { IMeshPrimitive, INode, IMaterial, ITextureInfo, IAccessor } from \"babylonjs-gltf2interface\";\r\nimport type { Node } from \"core/node\";\r\nimport type { Nullable } from \"core/types\";\r\n\r\nimport type { IDisposable } from \"core/scene\";\r\n\r\nimport type { IGLTFExporterExtension } from \"../glTFFileExporter\";\r\nimport type { Material } from \"core/Materials/material\";\r\nimport type { BaseTexture } from \"core/Materials/Textures/baseTexture\";\r\nimport type { BufferManager } from \"./bufferManager\";\r\n\r\n/** @internal */\r\n// eslint-disable-next-line no-var, @typescript-eslint/naming-convention\r\nexport var __IGLTFExporterExtensionV2 = 0; // I am here to allow dts to be created\r\n\r\n/**\r\n * Interface for a glTF exporter extension\r\n * @internal\r\n */\r\nexport interface IGLTFExporterExtensionV2 extends IGLTFExporterExtension, IDisposable {\r\n    /**\r\n     * Define this method to get notified when a texture info is created\r\n     * @param context The context when loading the asset\r\n     * @param textureInfo The glTF texture info\r\n     * @param babylonTexture The Babylon.js texture\r\n     */\r\n    postExportTexture?(context: string, textureInfo: ITextureInfo, babylonTexture: BaseTexture): void;\r\n\r\n    /**\r\n     * Define this method to get notified when a primitive is created\r\n     * @param primitive glTF mesh primitive\r\n     * @param bufferManager Buffer manager\r\n     * @param accessors List of glTF accessors\r\n     */\r\n    postExportMeshPrimitive?(primitive: IMeshPrimitive, bufferManager: BufferManager, accessors: IAccessor[]): void;\r\n\r\n    /**\r\n     * Define this method to modify the default behavior when exporting a node\r\n     * @param context The context when exporting the node\r\n     * @param node glTF node\r\n     * @param babylonNode BabylonJS node\r\n     * @param nodeMap Current node mapping of babylon node to glTF node index. Useful for combining nodes together.\r\n     * @param convertToRightHanded Flag indicating whether to convert values to right-handed\r\n     * @param bufferManager Buffer manager\r\n     * @returns nullable INode promise\r\n     */\r\n    postExportNodeAsync?(\r\n        context: string,\r\n        node: INode,\r\n        babylonNode: Node,\r\n        nodeMap: Map<Node, number>,\r\n        convertToRightHanded: boolean,\r\n        bufferManager: BufferManager\r\n    ): Promise<Nullable<INode>>;\r\n\r\n    /**\r\n     * Define this method to modify the default behavior when exporting a material\r\n     * @param material glTF material\r\n     * @param babylonMaterial BabylonJS material\r\n     * @returns nullable IMaterial promise\r\n     */\r\n    postExportMaterialAsync?(context: string, node: IMaterial, babylonMaterial: Material): Promise<IMaterial>;\r\n\r\n    /**\r\n     * Define this method to return additional textures to export from a material\r\n     * @param material glTF material\r\n     * @param babylonMaterial BabylonJS material\r\n     * @returns List of textures\r\n     */\r\n    postExportMaterialAdditionalTextures?(context: string, node: IMaterial, babylonMaterial: Material): BaseTexture[];\r\n\r\n    /**\r\n     * Define this method to modify the glTF buffer data before it is finalized and written\r\n     * @param bufferManager Buffer manager\r\n     */\r\n    preGenerateBinaryAsync?(bufferManager: BufferManager): Promise<void>;\r\n\r\n    /** Gets a boolean indicating that this extension was used */\r\n    wasUsed: boolean;\r\n\r\n    /** Gets a boolean indicating that this extension is required for the file to work */\r\n    required: boolean;\r\n\r\n    /**\r\n     * Called after the exporter state changes to EXPORTING\r\n     */\r\n    onExporting?(): void;\r\n}\r\n"]}

package/glTF/2.0/glTFMaterialExporter.d.ts

@@ -1,5 +1,4 @@
 import type { ITextureInfo, IMaterialPbrMetallicRoughness } from "babylonjs-gltf2interface";
-import { ImageMimeType } from "babylonjs-gltf2interface";
 import type { Nullable } from "@babylonjs/core/types.js";
 import type { BaseTexture } from "@babylonjs/core/Materials/Textures/baseTexture.js";
 import type { GLTFExporter } from "./glTFExporter.js";
@@ -29,7 +28,7 @@ export declare class GLTFMaterialExporter {
     private _internalTextureToImage;
     constructor(_exporter: GLTFExporter);
     getTextureInfo(babylonTexture: Nullable<BaseTexture>): Nullable<ITextureInfo>;
-    exportStandardMaterialAsync(babylonStandardMaterial: StandardMaterial, mimeType: ImageMimeType, hasUVs: boolean): Promise<number>;
+    exportStandardMaterialAsync(babylonStandardMaterial: StandardMaterial, hasUVs: boolean): Promise<number>;
     private _finishMaterialAsync;
     private _getImageDataAsync;
     /**
@@ -72,7 +71,6 @@ export declare class GLTFMaterialExporter {
     /**
      * 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 glTFPbrMetallicRoughness glTF PBR Metallic Roughness interface
      * @param hasUVs specifies if texture coordinates are present on the submesh to determine if textures should be applied
      * @returns glTF PBR Metallic Roughness factors
@@ -83,16 +81,15 @@ export declare class GLTFMaterialExporter {
     /**
      * 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 pbrMetallicRoughness glTF PBR Metallic Roughness interface
      * @param hasUVs specifies if texture coordinates are present on the submesh to determine if textures should be applied
      * @returns glTF PBR Metallic Roughness factors
      */
     private _convertSpecGlossFactorsToMetallicRoughnessAsync;
-    exportPBRMaterialAsync(babylonPBRMaterial: PBRBaseMaterial, mimeType: ImageMimeType, hasUVs: boolean): Promise<number>;
+    exportPBRMaterialAsync(babylonPBRMaterial: PBRBaseMaterial, hasUVs: boolean): Promise<number>;
     private _setMetallicRoughnessPbrMaterialAsync;
-    exportTextureAsync(babylonTexture: BaseTexture, mimeType: ImageMimeType): Promise<Nullable<ITextureInfo>>;
-    private _exportTextureInfoAsync;
+    exportTextureAsync(babylonTexture: BaseTexture): Promise<Nullable<ITextureInfo>>;
+    private _exportTextureImageAsync;
     private _exportImage;
     private _exportTextureInfo;
     private _exportTextureSampler;

package/glTF/2.0/glTFMaterialExporter.js

@@ -10,6 +10,7 @@ import { RawTexture } from "@babylonjs/core/Materials/Textures/rawTexture.js";
 import { Constants } from "@babylonjs/core/Engines/constants.js";
 import { DumpTools } from "@babylonjs/core/Misc/dumpTools.js";
 import { SpecularPowerToRoughness } from "@babylonjs/core/Helpers/materialConversionHelper.js";
+import { GetMimeType } from "@babylonjs/core/Misc/fileTools.js";
 const Epsilon = 1e-6;
 const DielectricSpecular = new Color3(0.04, 0.04, 0.04);
 const MaxSpecularPower = 1024;
@@ -27,6 +28,49 @@ function GetFileExtensionFromMimeType(mimeType) {
             return ".avif";
     }
 }
+/**
+ * Gets cached image from a texture, if available.
+ * @param babylonTexture texture to check for cached image
+ * @returns image data if found and directly usable; null otherwise
+ */
+async function GetCachedImageAsync(babylonTexture) {
+    const internalTexture = babylonTexture.getInternalTexture();
+    if (!internalTexture || internalTexture.source !== 1 /* InternalTextureSource.Url */) {
+        return null;
+    }
+    if (internalTexture.invertY) {
+        return null;
+    }
+    const buffer = internalTexture._buffer;
+    let data;
+    let mimeType = babylonTexture.mimeType;
+    if (!buffer) {
+        data = await Tools.LoadFileAsync(internalTexture.url);
+        mimeType = GetMimeType(internalTexture.url) || mimeType;
+    }
+    else if (typeof buffer === "string") {
+        data = await Tools.LoadFileAsync(buffer);
+        mimeType = GetMimeType(buffer) || mimeType;
+    }
+    else if (buffer instanceof HTMLImageElement) {
+        data = await Tools.LoadFileAsync(buffer.src);
+        mimeType = GetMimeType(buffer.src) || mimeType;
+    }
+    else if (buffer instanceof Blob) {
+        data = await buffer.arrayBuffer();
+        mimeType = buffer.type || mimeType;
+    }
+    else if (ArrayBuffer.isView(buffer)) {
+        data = buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+    }
+    else if (buffer instanceof ArrayBuffer) {
+        data = buffer;
+    }
+    if (data && mimeType) {
+        return { data, mimeType };
+    }
+    return null;
+}
 /**
  * Computes the metallic factor from specular glossiness values.
  * @param diffuse diffused value
@@ -115,7 +159,7 @@ export class GLTFMaterialExporter {
     getTextureInfo(babylonTexture) {
         return babylonTexture ? (this._textureMap.get(babylonTexture) ?? null) : null;
     }
-    async exportStandardMaterialAsync(babylonStandardMaterial, mimeType, hasUVs) {
+    async exportStandardMaterialAsync(babylonStandardMaterial, hasUVs) {
         const pbrMetallicRoughness = _ConvertToGLTFPBRMetallicRoughness(babylonStandardMaterial);
         const material = { name: babylonStandardMaterial.name };
         if (babylonStandardMaterial.backFaceCulling != null && !babylonStandardMaterial.backFaceCulling) {
@@ -128,7 +172,7 @@ export class GLTFMaterialExporter {
             const promises = [];
             const diffuseTexture = babylonStandardMaterial.diffuseTexture;
             if (diffuseTexture) {
-                promises.push(this.exportTextureAsync(diffuseTexture, mimeType).then((textureInfo) => {
+                promises.push(this.exportTextureAsync(diffuseTexture).then((textureInfo) => {
                     if (textureInfo) {
                         pbrMetallicRoughness.baseColorTexture = textureInfo;
                     }
@@ -136,7 +180,7 @@ export class GLTFMaterialExporter {
             }
             const bumpTexture = babylonStandardMaterial.bumpTexture;
             if (bumpTexture) {
-                promises.push(this.exportTextureAsync(bumpTexture, mimeType).then((textureInfo) => {
+                promises.push(this.exportTextureAsync(bumpTexture).then((textureInfo) => {
                     if (textureInfo) {
                         material.normalTexture = textureInfo;
                         if (bumpTexture.level !== 1) {
@@ -148,7 +192,7 @@ export class GLTFMaterialExporter {
             const emissiveTexture = babylonStandardMaterial.emissiveTexture;
             if (emissiveTexture) {
                 material.emissiveFactor = [1.0, 1.0, 1.0];
-                promises.push(this.exportTextureAsync(emissiveTexture, mimeType).then((textureInfo) => {
+                promises.push(this.exportTextureAsync(emissiveTexture).then((textureInfo) => {
                     if (textureInfo) {
                         material.emissiveTexture = textureInfo;
                     }
@@ -156,7 +200,7 @@ export class GLTFMaterialExporter {
             }
             const ambientTexture = babylonStandardMaterial.ambientTexture;
             if (ambientTexture) {
-                promises.push(this.exportTextureAsync(ambientTexture, mimeType).then((textureInfo) => {
+                promises.push(this.exportTextureAsync(ambientTexture).then((textureInfo) => {
                     if (textureInfo) {
                         const occlusionTexture = {
                             index: textureInfo.index,
@@ -183,16 +227,16 @@ export class GLTFMaterialExporter {
         }
         material.pbrMetallicRoughness = pbrMetallicRoughness;
         SetAlphaMode(material, babylonStandardMaterial);
-        await this._finishMaterialAsync(material, babylonStandardMaterial, mimeType);
+        await this._finishMaterialAsync(material, babylonStandardMaterial);
         const materials = this._exporter._materials;
         materials.push(material);
         return materials.length - 1;
     }
-    async _finishMaterialAsync(glTFMaterial, babylonMaterial, mimeType) {
+    async _finishMaterialAsync(glTFMaterial, babylonMaterial) {
         const textures = this._exporter._extensionsPostExportMaterialAdditionalTextures("exportMaterial", glTFMaterial, babylonMaterial);
         const promises = [];
         for (const texture of textures) {
-            promises.push(this.exportTextureAsync(texture, mimeType));
+            promises.push(this.exportTextureAsync(texture));
         }
         await Promise.all(promises);
         await this._exporter._extensionsPostExportMaterialAsync("exportMaterial", glTFMaterial, babylonMaterial);
@@ -408,12 +452,11 @@ export class GLTFMaterialExporter {
     /**
      * 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 glTFPbrMetallicRoughness glTF PBR Metallic Roughness interface
      * @param hasUVs specifies if texture coordinates are present on the submesh to determine if textures should be applied
      * @returns glTF PBR Metallic Roughness factors
      */
-    async _convertMetalRoughFactorsToMetallicRoughnessAsync(babylonPBRMaterial, mimeType, glTFPbrMetallicRoughness, hasUVs) {
+    async _convertMetalRoughFactorsToMetallicRoughnessAsync(babylonPBRMaterial, glTFPbrMetallicRoughness, hasUVs) {
         const promises = [];
         const metallicRoughness = {
             baseColor: babylonPBRMaterial._albedoColor,
@@ -423,7 +466,7 @@ export class GLTFMaterialExporter {
         if (hasUVs) {
             const albedoTexture = babylonPBRMaterial._albedoTexture;
             if (albedoTexture) {
-                promises.push(this.exportTextureAsync(babylonPBRMaterial._albedoTexture, mimeType).then((glTFTexture) => {
+                promises.push(this.exportTextureAsync(albedoTexture).then((glTFTexture) => {
                     if (glTFTexture) {
                         glTFPbrMetallicRoughness.baseColorTexture = glTFTexture;
                     }
@@ -431,7 +474,7 @@ export class GLTFMaterialExporter {
             }
             const metallicTexture = babylonPBRMaterial._metallicTexture;
             if (metallicTexture) {
-                promises.push(this.exportTextureAsync(metallicTexture, mimeType).then((glTFTexture) => {
+                promises.push(this.exportTextureAsync(metallicTexture).then((glTFTexture) => {
                     if (glTFTexture) {
                         glTFPbrMetallicRoughness.metallicRoughnessTexture = glTFTexture;
                     }
@@ -541,12 +584,12 @@ export class GLTFMaterialExporter {
     /**
      * 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 pbrMetallicRoughness glTF PBR Metallic Roughness interface
      * @param hasUVs specifies if texture coordinates are present on the submesh to determine if textures should be applied
      * @returns glTF PBR Metallic Roughness factors
      */
-    async _convertSpecGlossFactorsToMetallicRoughnessAsync(babylonPBRMaterial, mimeType, pbrMetallicRoughness, hasUVs) {
+    async _convertSpecGlossFactorsToMetallicRoughnessAsync(babylonPBRMaterial, pbrMetallicRoughness, hasUVs) {
+        const mimeType = "image/png" /* ImageMimeType.PNG */;
         const specGloss = {
             diffuseColor: babylonPBRMaterial._albedoColor,
             specularColor: babylonPBRMaterial._reflectivityColor,
@@ -577,7 +620,7 @@ export class GLTFMaterialExporter {
             return this._convertSpecularGlossinessToMetallicRoughness(specGloss);
         }
     }
-    async exportPBRMaterialAsync(babylonPBRMaterial, mimeType, hasUVs) {
+    async exportPBRMaterialAsync(babylonPBRMaterial, hasUVs) {
         const glTFPbrMetallicRoughness = {};
         const glTFMaterial = {
             name: babylonPBRMaterial.name,
@@ -591,15 +634,15 @@ export class GLTFMaterialExporter {
             }
         }
         const metallicRoughness = useMetallicRoughness
-            ? await this._convertMetalRoughFactorsToMetallicRoughnessAsync(babylonPBRMaterial, mimeType, glTFPbrMetallicRoughness, hasUVs)
-            : await this._convertSpecGlossFactorsToMetallicRoughnessAsync(babylonPBRMaterial, mimeType, glTFPbrMetallicRoughness, hasUVs);
-        await this._setMetallicRoughnessPbrMaterialAsync(metallicRoughness, babylonPBRMaterial, glTFMaterial, glTFPbrMetallicRoughness, mimeType, hasUVs);
-        await this._finishMaterialAsync(glTFMaterial, babylonPBRMaterial, mimeType);
+            ? await this._convertMetalRoughFactorsToMetallicRoughnessAsync(babylonPBRMaterial, glTFPbrMetallicRoughness, hasUVs)
+            : await this._convertSpecGlossFactorsToMetallicRoughnessAsync(babylonPBRMaterial, glTFPbrMetallicRoughness, hasUVs);
+        await this._setMetallicRoughnessPbrMaterialAsync(metallicRoughness, babylonPBRMaterial, glTFMaterial, glTFPbrMetallicRoughness, hasUVs);
+        await this._finishMaterialAsync(glTFMaterial, babylonPBRMaterial);
         const materials = this._exporter._materials;
         materials.push(glTFMaterial);
         return materials.length - 1;
     }
-    async _setMetallicRoughnessPbrMaterialAsync(metallicRoughness, babylonPBRMaterial, glTFMaterial, glTFPbrMetallicRoughness, mimeType, hasUVs) {
+    async _setMetallicRoughnessPbrMaterialAsync(metallicRoughness, babylonPBRMaterial, glTFMaterial, glTFPbrMetallicRoughness, hasUVs) {
         SetAlphaMode(glTFMaterial, babylonPBRMaterial);
         if (!metallicRoughness.baseColor.equalsWithEpsilon(White, Epsilon) || !Scalar.WithinEpsilon(babylonPBRMaterial.alpha, 1, Epsilon)) {
             glTFPbrMetallicRoughness.baseColorFactor = [metallicRoughness.baseColor.r, metallicRoughness.baseColor.g, metallicRoughness.baseColor.b, babylonPBRMaterial.alpha];
@@ -620,7 +663,7 @@ export class GLTFMaterialExporter {
             const promises = [];
             const bumpTexture = babylonPBRMaterial._bumpTexture;
             if (bumpTexture) {
-                promises.push(this.exportTextureAsync(bumpTexture, mimeType).then((glTFTexture) => {
+                promises.push(this.exportTextureAsync(bumpTexture).then((glTFTexture) => {
                     if (glTFTexture) {
                         glTFMaterial.normalTexture = glTFTexture;
                         if (bumpTexture.level !== 1) {
@@ -631,7 +674,7 @@ export class GLTFMaterialExporter {
             }
             const ambientTexture = babylonPBRMaterial._ambientTexture;
             if (ambientTexture) {
-                promises.push(this.exportTextureAsync(ambientTexture, mimeType).then((glTFTexture) => {
+                promises.push(this.exportTextureAsync(ambientTexture).then((glTFTexture) => {
                     if (glTFTexture) {
                         const occlusionTexture = {
                             index: glTFTexture.index,
@@ -648,7 +691,7 @@ export class GLTFMaterialExporter {
             }
             const emissiveTexture = babylonPBRMaterial._emissiveTexture;
             if (emissiveTexture) {
-                promises.push(this.exportTextureAsync(emissiveTexture, mimeType).then((glTFTexture) => {
+                promises.push(this.exportTextureAsync(emissiveTexture).then((glTFTexture) => {
                     if (glTFTexture) {
                         glTFMaterial.emissiveTexture = glTFTexture;
                     }
@@ -665,58 +708,55 @@ export class GLTFMaterialExporter {
         }
         glTFMaterial.pbrMetallicRoughness = glTFPbrMetallicRoughness;
     }
-    async exportTextureAsync(babylonTexture, mimeType) {
-        const extensionPromise = this._exporter._extensionsPreExportTextureAsync("exporter", babylonTexture, mimeType);
-        if (!extensionPromise) {
-            return await this._exportTextureInfoAsync(babylonTexture, mimeType);
-        }
-        return await extensionPromise.then(async (texture) => {
-            if (!texture) {
-                return await this._exportTextureInfoAsync(babylonTexture, mimeType);
-            }
-            return await this._exportTextureInfoAsync(texture, mimeType);
-        });
-    }
-    async _exportTextureInfoAsync(babylonTexture, mimeType) {
+    async exportTextureAsync(babylonTexture) {
         let textureInfo = this._textureMap.get(babylonTexture);
-        if (!textureInfo) {
-            const pixels = await GetTextureDataAsync(babylonTexture).catch(() => null);
-            if (!pixels) {
-                return null;
-            }
-            const samplerIndex = this._exportTextureSampler(babylonTexture);
-            // Preserve texture mime type if defined
-            const textureMimeType = babylonTexture.mimeType;
-            if (textureMimeType) {
-                switch (textureMimeType) {
-                    case "image/jpeg":
-                    case "image/png":
-                    case "image/webp":
-                        mimeType = textureMimeType;
-                        break;
-                    default:
-                        Tools.Warn(`Unsupported media type: ${textureMimeType}. Exporting texture as PNG.`);
-                        // Will later fallback to default mime type, image/png, from Canvas API
-                        break;
+        if (textureInfo) {
+            return textureInfo;
+        }
+        const samplerIndex = this._exportTextureSampler(babylonTexture);
+        const imageIndex = await this._exportTextureImageAsync(babylonTexture);
+        textureInfo = this._exportTextureInfo(imageIndex, samplerIndex, babylonTexture.coordinatesIndex);
+        this._textureMap.set(babylonTexture, textureInfo);
+        this._exporter._extensionsPostExportTextures("exporter", textureInfo, babylonTexture);
+        return textureInfo;
+    }
+    async _exportTextureImageAsync(babylonTexture) {
+        const requestedMimeType = babylonTexture.mimeType ?? "none";
+        // TODO: Add an official way for users to export using a different mime type
+        // than the one they loaded with (which is denoted by Texture.mimeType)
+        const internalTextureToImage = this._internalTextureToImage;
+        const internalTextureUniqueId = babylonTexture.getInternalTexture().uniqueId;
+        internalTextureToImage[internalTextureUniqueId] = internalTextureToImage[internalTextureUniqueId] || {};
+        let imageIndexPromise = internalTextureToImage[internalTextureUniqueId][requestedMimeType];
+        if (imageIndexPromise === undefined) {
+            imageIndexPromise = (async () => {
+                // Try to get the image from memory first, if applicable
+                const cache = await GetCachedImageAsync(babylonTexture);
+                if (cache && (requestedMimeType === "none" || cache.mimeType === requestedMimeType)) {
+                    return this._exportImage(babylonTexture.name, cache.mimeType, cache.data);
+                }
+                // Preserve texture mime type if defined
+                let mimeType = "image/png" /* ImageMimeType.PNG */;
+                if (requestedMimeType !== "none") {
+                    switch (requestedMimeType) {
+                        case "image/jpeg" /* ImageMimeType.JPEG */:
+                        case "image/png" /* ImageMimeType.PNG */:
+                        case "image/webp" /* ImageMimeType.WEBP */:
+                            mimeType = requestedMimeType;
+                            break;
+                        default:
+                            Tools.Warn(`Unsupported media type: ${requestedMimeType}. Exporting texture as PNG.`);
+                            break;
+                    }
                 }
-            }
-            const internalTextureToImage = this._internalTextureToImage;
-            const internalTextureUniqueId = babylonTexture.getInternalTexture().uniqueId;
-            internalTextureToImage[internalTextureUniqueId] || (internalTextureToImage[internalTextureUniqueId] = {});
-            let imageIndexPromise = internalTextureToImage[internalTextureUniqueId][mimeType];
-            if (imageIndexPromise === undefined) {
                 const size = babylonTexture.getSize();
-                imageIndexPromise = (async () => {
-                    const data = await this._getImageDataAsync(pixels, size.width, size.height, mimeType);
-                    return this._exportImage(babylonTexture.name, mimeType, data);
-                })();
-                internalTextureToImage[internalTextureUniqueId][mimeType] = imageIndexPromise;
-            }
-            textureInfo = this._exportTextureInfo(await imageIndexPromise, samplerIndex, babylonTexture.coordinatesIndex);
-            this._textureMap.set(babylonTexture, textureInfo);
-            this._exporter._extensionsPostExportTextures("exporter", textureInfo, babylonTexture);
+                const pixels = await GetTextureDataAsync(babylonTexture);
+                const data = await this._getImageDataAsync(pixels, size.width, size.height, mimeType);
+                return this._exportImage(babylonTexture.name, mimeType, data);
+            })();
+            internalTextureToImage[internalTextureUniqueId][requestedMimeType] = imageIndexPromise;
         }
-        return textureInfo;
+        return await imageIndexPromise;
     }
     _exportImage(name, mimeType, data) {
         const images = this._exporter._images;