babylonjs-serializers 8.28.0 → 8.28.2

package/babylonjs.serializers.module.d.ts

@@ -281,6 +281,7 @@ import { BaseTexture } from "babylonjs/Materials/Textures/baseTexture";
 import { GLTFExporter } from "babylonjs-serializers/glTF/2.0/glTFExporter";
 import { StandardMaterial } from "babylonjs/Materials/standardMaterial";
 import { PBRBaseMaterial } from "babylonjs/Materials/PBR/pbrBaseMaterial";
+import { OpenPBRMaterial } from "babylonjs/Materials/PBR/openPbrMaterial";
 /**
  * Computes the metallic factor from specular glossiness values.
  * @param diffuse diffused value
@@ -347,6 +348,12 @@ export class GLTFMaterialExporter {
     private _getMaxComponent;
     /**
      * Convert a PBRMaterial (Metallic/Roughness) to Metallic Roughness factors
+     * @param baseColor Base color of the material
+     * @param metallic Metallic factor of the material
+     * @param roughness Roughness factor of the material
+     * @param albedoTexture Albedo texture of the material
+     * @param metallicTexture Metallic texture of the material
+     * @param roughnessTexture Roughness texture of the material
      * @param babylonPBRMaterial BJS PBR Metallic Roughness Material
      * @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
@@ -365,6 +372,7 @@ export class GLTFMaterialExporter {
     private _convertSpecGlossFactorsToMetallicRoughnessAsync;
     exportPBRMaterialAsync(babylonPBRMaterial: PBRBaseMaterial, hasUVs: boolean): Promise<number>;
     private _setMetallicRoughnessPbrMaterialAsync;
+    exportOpenPBRMaterialAsync(babylonOpenPBRMaterial: OpenPBRMaterial, hasUVs: boolean): Promise<number>;
     exportTextureAsync(babylonTexture: BaseTexture): Promise<Nullable<ITextureInfo>>;
     private _exportTextureImageAsync;
     private _exportImage;
@@ -427,7 +435,7 @@ export interface IGLTFExporterExtensionV2 extends IGLTFExporterExtension, IDispo
      * @param babylonMaterial BabylonJS material
      * @returns List of textures
      */
-    postExportMaterialAdditionalTextures?(context: string, node: IMaterial, babylonMaterial: Material): BaseTexture[];
+    postExportMaterialAdditionalTexturesAsync?(context: string, node: IMaterial, babylonMaterial: Material): Promise<BaseTexture[]>;
     /**
      * Define this method to modify the glTF buffer data before it is finalized and written
      * @param bufferManager Buffer manager
@@ -501,7 +509,14 @@ export class GLTFExporter {
     private _ApplyExtensions;
     _extensionsPostExportNodeAsync(context: string, node: INode, babylonNode: Node, nodeMap: Map<Node, number>, convertToRightHanded: boolean): Promise<Nullable<INode>>;
     _extensionsPostExportMaterialAsync(context: string, material: IMaterial, babylonMaterial: Material): Promise<Nullable<IMaterial>>;
-    _extensionsPostExportMaterialAdditionalTextures(context: string, material: IMaterial, babylonMaterial: Material): BaseTexture[];
+    /**
+     * Get additional textures for a material
+     * @param context The context when loading the asset
+     * @param material The glTF material
+     * @param babylonMaterial The Babylon.js material
+     * @returns List of additional textures
+     */
+    _extensionsPostExportMaterialAdditionalTexturesAsync(context: string, material: IMaterial, babylonMaterial: Material): Promise<BaseTexture[]>;
     _extensionsPostExportTextures(context: string, textureInfo: ITextureInfo, babylonTexture: BaseTexture): void;
     _extensionsPostExportMeshPrimitive(primitive: IMeshPrimitive): void;
     _extensionsPreGenerateBinaryAsync(): Promise<void>;
@@ -870,6 +885,9 @@ export * from "babylonjs-serializers/glTF/2.0/Extensions/KHR_draco_mesh_compress
 export * from "babylonjs-serializers/glTF/2.0/Extensions/KHR_lights_punctual";
 export * from "babylonjs-serializers/glTF/2.0/Extensions/KHR_materials_anisotropy";
 export * from "babylonjs-serializers/glTF/2.0/Extensions/KHR_materials_clearcoat";
+export * from "babylonjs-serializers/glTF/2.0/Extensions/KHR_materials_clearcoat_darkening";
+export * from "babylonjs-serializers/glTF/2.0/Extensions/KHR_materials_clearcoat_color";
+export * from "babylonjs-serializers/glTF/2.0/Extensions/KHR_materials_clearcoat_anisotropy";
 export * from "babylonjs-serializers/glTF/2.0/Extensions/KHR_materials_diffuse_transmission";
 export * from "babylonjs-serializers/glTF/2.0/Extensions/KHR_materials_dispersion";
 export * from "babylonjs-serializers/glTF/2.0/Extensions/KHR_materials_emissive_strength";
@@ -880,7 +898,7 @@ export * from "babylonjs-serializers/glTF/2.0/Extensions/KHR_materials_specular"
 export * from "babylonjs-serializers/glTF/2.0/Extensions/KHR_materials_transmission";
 export * from "babylonjs-serializers/glTF/2.0/Extensions/KHR_materials_unlit";
 export * from "babylonjs-serializers/glTF/2.0/Extensions/KHR_materials_volume";
-export * from "babylonjs-serializers/glTF/2.0/Extensions/EXT_materials_diffuse_roughness";
+export * from "babylonjs-serializers/glTF/2.0/Extensions/KHR_materials_diffuse_roughness";
 export * from "babylonjs-serializers/glTF/2.0/Extensions/KHR_texture_transform";
 export * from "babylonjs-serializers/glTF/2.0/Extensions/KHR_texture_basisu";
 export * from "babylonjs-serializers/glTF/2.0/Extensions/EXT_texture_webp";
@@ -959,7 +977,7 @@ export class KHR_materials_volume implements IGLTFExporterExtensionV2 {
      * @param babylonMaterial corresponding babylon material
      * @returns array of additional textures to export
      */
-    postExportMaterialAdditionalTextures?(context: string, node: IMaterial, babylonMaterial: Material): BaseTexture[];
+    postExportMaterialAdditionalTexturesAsync?(context: string, node: IMaterial, babylonMaterial: Material): Promise<BaseTexture[]>;
     private _isExtensionEnabled;
     private _hasTexturesExtension;
     /**
@@ -1026,7 +1044,7 @@ export class KHR_materials_transmission implements IGLTFExporterExtensionV2 {
      * @param babylonMaterial corresponding babylon material
      * @returns array of additional textures to export
      */
-    postExportMaterialAdditionalTextures?(context: string, node: IMaterial, babylonMaterial: Material): BaseTexture[];
+    postExportMaterialAdditionalTexturesAsync?(context: string, node: IMaterial, babylonMaterial: Material): Promise<BaseTexture[]>;
     private _isExtensionEnabled;
     private _hasTexturesExtension;
     /**
@@ -1070,7 +1088,7 @@ export class KHR_materials_specular implements IGLTFExporterExtensionV2 {
      * @param babylonMaterial corresponding babylon material
      * @returns array of additional textures to export
      */
-    postExportMaterialAdditionalTextures?(context: string, node: IMaterial, babylonMaterial: Material): BaseTexture[];
+    postExportMaterialAdditionalTexturesAsync?(context: string, node: IMaterial, babylonMaterial: Material): Promise<BaseTexture[]>;
     private _isExtensionEnabled;
     private _hasTexturesExtension;
     /**
@@ -1106,7 +1124,7 @@ export class KHR_materials_sheen implements IGLTFExporterExtensionV2 {
     dispose(): void;
     /** @internal */
     get wasUsed(): boolean;
-    postExportMaterialAdditionalTextures(context: string, node: IMaterial, babylonMaterial: Material): BaseTexture[];
+    postExportMaterialAdditionalTexturesAsync(context: string, node: IMaterial, babylonMaterial: Material): Promise<BaseTexture[]>;
     postExportMaterialAsync(context: string, node: IMaterial, babylonMaterial: Material): Promise<IMaterial>;
 }
 
@@ -1133,7 +1151,7 @@ export class KHR_materials_iridescence implements IGLTFExporterExtensionV2 {
     dispose(): void;
     /** @internal */
     get wasUsed(): boolean;
-    postExportMaterialAdditionalTextures?(context: string, node: IMaterial, babylonMaterial: Material): BaseTexture[];
+    postExportMaterialAdditionalTexturesAsync?(context: string, node: IMaterial, babylonMaterial: Material): Promise<BaseTexture[]>;
     postExportMaterialAsync?(context: string, node: IMaterial, babylonMaterial: Material): Promise<IMaterial>;
 }
 
@@ -1264,7 +1282,7 @@ export class KHR_materials_diffuse_transmission implements IGLTFExporterExtensio
      * @param babylonMaterial corresponding babylon material
      * @returns array of additional textures to export
      */
-    postExportMaterialAdditionalTextures?(context: string, node: IMaterial, babylonMaterial: Material): BaseTexture[];
+    postExportMaterialAdditionalTexturesAsync?(context: string, node: IMaterial, babylonMaterial: Material): Promise<BaseTexture[]>;
     private _isExtensionEnabled;
     /**
      * After exporting a material
@@ -1276,6 +1294,122 @@ export class KHR_materials_diffuse_transmission implements IGLTFExporterExtensio
     postExportMaterialAsync?(context: string, node: IMaterial, babylonMaterial: Material): Promise<IMaterial>;
 }
 
+}
+declare module "babylonjs-serializers/glTF/2.0/Extensions/KHR_materials_diffuse_roughness" {
+import { IMaterial } from "babylonjs-gltf2interface";
+import { IGLTFExporterExtensionV2 } from "babylonjs-serializers/glTF/2.0/glTFExporterExtension";
+import { GLTFExporter } from "babylonjs-serializers/glTF/2.0/glTFExporter";
+import { Material } from "babylonjs/Materials/material";
+import { BaseTexture } from "babylonjs/Materials/Textures/baseTexture";
+/**
+ * @internal
+ */
+export class KHR_materials_diffuse_roughness implements IGLTFExporterExtensionV2 {
+    /** Name of this extension */
+    readonly name: string;
+    /** Defines whether this extension is enabled */
+    enabled: boolean;
+    /** Defines whether this extension is required */
+    required: boolean;
+    private _exporter;
+    private _wasUsed;
+    constructor(exporter: GLTFExporter);
+    dispose(): void;
+    /** @internal */
+    get wasUsed(): boolean;
+    postExportMaterialAdditionalTexturesAsync?(context: string, node: IMaterial, babylonMaterial: Material): Promise<BaseTexture[]>;
+    postExportMaterialAsync?(context: string, node: IMaterial, babylonMaterial: Material): Promise<IMaterial>;
+}
+
+}
+declare module "babylonjs-serializers/glTF/2.0/Extensions/KHR_materials_clearcoat_darkening" {
+import { IMaterial } from "babylonjs-gltf2interface";
+import { IGLTFExporterExtensionV2 } from "babylonjs-serializers/glTF/2.0/glTFExporterExtension";
+import { GLTFExporter } from "babylonjs-serializers/glTF/2.0/glTFExporter";
+import { Material } from "babylonjs/Materials/material";
+import { BaseTexture } from "babylonjs/Materials/Textures/baseTexture";
+/**
+ * @internal
+ */
+export class KHR_materials_clearcoat_darkening implements IGLTFExporterExtensionV2 {
+    /** Name of this extension */
+    readonly name: string;
+    /** Defines whether this extension is enabled */
+    enabled: boolean;
+    /** Defines whether this extension is required */
+    required: boolean;
+    private _exporter;
+    private _wasUsed;
+    constructor(exporter: GLTFExporter);
+    dispose(): void;
+    /** @internal */
+    get wasUsed(): boolean;
+    postExportMaterialAdditionalTexturesAsync?(context: string, node: IMaterial, babylonMaterial: Material): Promise<BaseTexture[]>;
+    postExportMaterialAsync?(context: string, node: IMaterial, babylonMaterial: Material): Promise<IMaterial>;
+}
+
+}
+declare module "babylonjs-serializers/glTF/2.0/Extensions/KHR_materials_clearcoat_color" {
+import { IMaterial } from "babylonjs-gltf2interface";
+import { IGLTFExporterExtensionV2 } from "babylonjs-serializers/glTF/2.0/glTFExporterExtension";
+import { GLTFExporter } from "babylonjs-serializers/glTF/2.0/glTFExporter";
+import { Material } from "babylonjs/Materials/material";
+import { BaseTexture } from "babylonjs/Materials/Textures/baseTexture";
+/**
+ * @internal
+ */
+export class KHR_materials_clearcoat_color implements IGLTFExporterExtensionV2 {
+    /** Name of this extension */
+    readonly name: string;
+    /** Defines whether this extension is enabled */
+    enabled: boolean;
+    /** Defines whether this extension is required */
+    required: boolean;
+    private _exporter;
+    private _wasUsed;
+    constructor(exporter: GLTFExporter);
+    dispose(): void;
+    /** @internal */
+    get wasUsed(): boolean;
+    postExportMaterialAdditionalTexturesAsync?(context: string, node: IMaterial, babylonMaterial: Material): Promise<BaseTexture[]>;
+    postExportMaterialAsync?(context: string, node: IMaterial, babylonMaterial: Material): Promise<IMaterial>;
+}
+
+}
+declare module "babylonjs-serializers/glTF/2.0/Extensions/KHR_materials_clearcoat_anisotropy" {
+import { IMaterial } from "babylonjs-gltf2interface";
+import { IGLTFExporterExtensionV2 } from "babylonjs-serializers/glTF/2.0/glTFExporterExtension";
+import { GLTFExporter } from "babylonjs-serializers/glTF/2.0/glTFExporter";
+import { Material } from "babylonjs/Materials/material";
+import { BaseTexture } from "babylonjs/Materials/Textures/baseTexture";
+/**
+ * @internal
+ */
+export class KHR_materials_clearcoat_anisotropy implements IGLTFExporterExtensionV2 {
+    /** Name of this extension */
+    readonly name: string;
+    /** Defines whether this extension is enabled */
+    enabled: boolean;
+    /** Defines whether this extension is required */
+    required: boolean;
+    private _exporter;
+    private _wasUsed;
+    private _anisoTexturesMap;
+    constructor(exporter: GLTFExporter);
+    dispose(): void;
+    /** @internal */
+    get wasUsed(): boolean;
+    /**
+     * After exporting a material, deal with the additional textures
+     * @param context GLTF context of the material
+     * @param node exported GLTF node
+     * @param babylonMaterial corresponding babylon material
+     * @returns array of additional textures to export
+     */
+    postExportMaterialAdditionalTexturesAsync?(context: string, node: IMaterial, babylonMaterial: Material): Promise<BaseTexture[]>;
+    postExportMaterialAsync?(context: string, node: IMaterial, babylonMaterial: Material): Promise<IMaterial>;
+}
+
 }
 declare module "babylonjs-serializers/glTF/2.0/Extensions/KHR_materials_clearcoat" {
 import { IMaterial } from "babylonjs-gltf2interface";
@@ -1299,7 +1433,7 @@ export class KHR_materials_clearcoat implements IGLTFExporterExtensionV2 {
     dispose(): void;
     /** @internal */
     get wasUsed(): boolean;
-    postExportMaterialAdditionalTextures?(context: string, node: IMaterial, babylonMaterial: Material): BaseTexture[];
+    postExportMaterialAdditionalTexturesAsync?(context: string, node: IMaterial, babylonMaterial: Material): Promise<BaseTexture[]>;
     postExportMaterialAsync?(context: string, node: IMaterial, babylonMaterial: Material): Promise<IMaterial>;
 }
 
@@ -1322,11 +1456,19 @@ export class KHR_materials_anisotropy implements IGLTFExporterExtensionV2 {
     required: boolean;
     private _exporter;
     private _wasUsed;
+    private _anisoTexturesMap;
     constructor(exporter: GLTFExporter);
     dispose(): void;
     /** @internal */
     get wasUsed(): boolean;
-    postExportMaterialAdditionalTextures?(context: string, node: IMaterial, babylonMaterial: Material): BaseTexture[];
+    /**
+     * After exporting a material, deal with the additional textures
+     * @param context GLTF context of the material
+     * @param node exported GLTF node
+     * @param babylonMaterial corresponding babylon material
+     * @returns array of additional textures to export
+     */
+    postExportMaterialAdditionalTexturesAsync?(context: string, node: IMaterial, babylonMaterial: Material): Promise<BaseTexture[]>;
     postExportMaterialAsync?(context: string, node: IMaterial, babylonMaterial: Material): Promise<IMaterial>;
 }
 
@@ -1485,33 +1627,6 @@ export class EXT_mesh_gpu_instancing implements IGLTFExporterExtensionV2 {
     private _buildAccessor;
 }
 
-}
-declare module "babylonjs-serializers/glTF/2.0/Extensions/EXT_materials_diffuse_roughness" {
-import { IMaterial } from "babylonjs-gltf2interface";
-import { IGLTFExporterExtensionV2 } from "babylonjs-serializers/glTF/2.0/glTFExporterExtension";
-import { GLTFExporter } from "babylonjs-serializers/glTF/2.0/glTFExporter";
-import { Material } from "babylonjs/Materials/material";
-import { BaseTexture } from "babylonjs/Materials/Textures/baseTexture";
-/**
- * @internal
- */
-export class EXT_materials_diffuse_roughness implements IGLTFExporterExtensionV2 {
-    /** Name of this extension */
-    readonly name: string;
-    /** Defines whether this extension is enabled */
-    enabled: boolean;
-    /** Defines whether this extension is required */
-    required: boolean;
-    private _exporter;
-    private _wasUsed;
-    constructor(exporter: GLTFExporter);
-    dispose(): void;
-    /** @internal */
-    get wasUsed(): boolean;
-    postExportMaterialAdditionalTextures?(context: string, node: IMaterial, babylonMaterial: Material): BaseTexture[];
-    postExportMaterialAsync?(context: string, node: IMaterial, babylonMaterial: Material): Promise<IMaterial>;
-}
-
 }
 declare module "babylonjs-serializers/USDZ/usdzExporter" {
 import { Mesh } from "babylonjs/Meshes/mesh";
@@ -1952,6 +2067,12 @@ declare module BABYLON {
         private _getMaxComponent;
         /**
          * Convert a PBRMaterial (Metallic/Roughness) to Metallic Roughness factors
+         * @param baseColor Base color of the material
+         * @param metallic Metallic factor of the material
+         * @param roughness Roughness factor of the material
+         * @param albedoTexture Albedo texture of the material
+         * @param metallicTexture Metallic texture of the material
+         * @param roughnessTexture Roughness texture of the material
          * @param babylonPBRMaterial BJS PBR Metallic Roughness Material
          * @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
@@ -1970,6 +2091,7 @@ declare module BABYLON {
         private _convertSpecGlossFactorsToMetallicRoughnessAsync;
         exportPBRMaterialAsync(babylonPBRMaterial: PBRBaseMaterial, hasUVs: boolean): Promise<number>;
         private _setMetallicRoughnessPbrMaterialAsync;
+        exportOpenPBRMaterialAsync(babylonOpenPBRMaterial: OpenPBRMaterial, hasUVs: boolean): Promise<number>;
         exportTextureAsync(babylonTexture: BaseTexture): Promise<Nullable<BABYLON.GLTF2.ITextureInfo>>;
         private _exportTextureImageAsync;
         private _exportImage;
@@ -2023,7 +2145,7 @@ declare module BABYLON {
          * @param babylonMaterial BabylonJS material
          * @returns List of textures
          */
-        postExportMaterialAdditionalTextures?(context: string, node: BABYLON.GLTF2.IMaterial, babylonMaterial: Material): BaseTexture[];
+        postExportMaterialAdditionalTexturesAsync?(context: string, node: BABYLON.GLTF2.IMaterial, babylonMaterial: Material): Promise<BaseTexture[]>;
         /**
          * Define this method to modify the glTF buffer data before it is finalized and written
          * @param bufferManager Buffer manager
@@ -2085,7 +2207,14 @@ declare module BABYLON {
         private _ApplyExtensions;
         _extensionsPostExportNodeAsync(context: string, node: BABYLON.GLTF2.INode, babylonNode: Node, nodeMap: Map<Node, number>, convertToRightHanded: boolean): Promise<Nullable<BABYLON.GLTF2.INode>>;
         _extensionsPostExportMaterialAsync(context: string, material: BABYLON.GLTF2.IMaterial, babylonMaterial: Material): Promise<Nullable<BABYLON.GLTF2.IMaterial>>;
-        _extensionsPostExportMaterialAdditionalTextures(context: string, material: BABYLON.GLTF2.IMaterial, babylonMaterial: Material): BaseTexture[];
+        /**
+         * Get additional textures for a material
+         * @param context The context when loading the asset
+         * @param material The glTF material
+         * @param babylonMaterial The Babylon.js material
+         * @returns List of additional textures
+         */
+        _extensionsPostExportMaterialAdditionalTexturesAsync(context: string, material: BABYLON.GLTF2.IMaterial, babylonMaterial: Material): Promise<BaseTexture[]>;
         _extensionsPostExportTextures(context: string, textureInfo: BABYLON.GLTF2.ITextureInfo, babylonTexture: BaseTexture): void;
         _extensionsPostExportMeshPrimitive(primitive: BABYLON.GLTF2.IMeshPrimitive): void;
         _extensionsPreGenerateBinaryAsync(): Promise<void>;
@@ -2494,7 +2623,7 @@ declare module BABYLON {
          * @param babylonMaterial corresponding babylon material
          * @returns array of additional textures to export
          */
-        postExportMaterialAdditionalTextures?(context: string, node: BABYLON.GLTF2.IMaterial, babylonMaterial: Material): BaseTexture[];
+        postExportMaterialAdditionalTexturesAsync?(context: string, node: BABYLON.GLTF2.IMaterial, babylonMaterial: Material): Promise<BaseTexture[]>;
         private _isExtensionEnabled;
         private _hasTexturesExtension;
         /**
@@ -2551,7 +2680,7 @@ declare module BABYLON {
          * @param babylonMaterial corresponding babylon material
          * @returns array of additional textures to export
          */
-        postExportMaterialAdditionalTextures?(context: string, node: BABYLON.GLTF2.IMaterial, babylonMaterial: Material): BaseTexture[];
+        postExportMaterialAdditionalTexturesAsync?(context: string, node: BABYLON.GLTF2.IMaterial, babylonMaterial: Material): Promise<BaseTexture[]>;
         private _isExtensionEnabled;
         private _hasTexturesExtension;
         /**
@@ -2589,7 +2718,7 @@ declare module BABYLON {
          * @param babylonMaterial corresponding babylon material
          * @returns array of additional textures to export
          */
-        postExportMaterialAdditionalTextures?(context: string, node: BABYLON.GLTF2.IMaterial, babylonMaterial: Material): BaseTexture[];
+        postExportMaterialAdditionalTexturesAsync?(context: string, node: BABYLON.GLTF2.IMaterial, babylonMaterial: Material): Promise<BaseTexture[]>;
         private _isExtensionEnabled;
         private _hasTexturesExtension;
         /**
@@ -2619,7 +2748,7 @@ declare module BABYLON {
         dispose(): void;
         /** @internal */
         get wasUsed(): boolean;
-        postExportMaterialAdditionalTextures(context: string, node: BABYLON.GLTF2.IMaterial, babylonMaterial: Material): BaseTexture[];
+        postExportMaterialAdditionalTexturesAsync(context: string, node: BABYLON.GLTF2.IMaterial, babylonMaterial: Material): Promise<BaseTexture[]>;
         postExportMaterialAsync(context: string, node: BABYLON.GLTF2.IMaterial, babylonMaterial: Material): Promise<BABYLON.GLTF2.IMaterial>;
     }
 
@@ -2640,7 +2769,7 @@ declare module BABYLON {
         dispose(): void;
         /** @internal */
         get wasUsed(): boolean;
-        postExportMaterialAdditionalTextures?(context: string, node: BABYLON.GLTF2.IMaterial, babylonMaterial: Material): BaseTexture[];
+        postExportMaterialAdditionalTexturesAsync?(context: string, node: BABYLON.GLTF2.IMaterial, babylonMaterial: Material): Promise<BaseTexture[]>;
         postExportMaterialAsync?(context: string, node: BABYLON.GLTF2.IMaterial, babylonMaterial: Material): Promise<BABYLON.GLTF2.IMaterial>;
     }
 
@@ -2753,7 +2882,7 @@ declare module BABYLON {
          * @param babylonMaterial corresponding babylon material
          * @returns array of additional textures to export
          */
-        postExportMaterialAdditionalTextures?(context: string, node: BABYLON.GLTF2.IMaterial, babylonMaterial: Material): BaseTexture[];
+        postExportMaterialAdditionalTexturesAsync?(context: string, node: BABYLON.GLTF2.IMaterial, babylonMaterial: Material): Promise<BaseTexture[]>;
         private _isExtensionEnabled;
         /**
          * After exporting a material
@@ -2766,6 +2895,98 @@ declare module BABYLON {
     }
 
 
+    /**
+     * @internal
+     */
+    export class KHR_materials_diffuse_roughness implements IGLTFExporterExtensionV2 {
+        /** Name of this extension */
+        readonly name = "KHR_materials_diffuse_roughness";
+        /** Defines whether this extension is enabled */
+        enabled: boolean;
+        /** Defines whether this extension is required */
+        required: boolean;
+        private _exporter;
+        private _wasUsed;
+        constructor(exporter: GLTFExporter);
+        dispose(): void;
+        /** @internal */
+        get wasUsed(): boolean;
+        postExportMaterialAdditionalTexturesAsync?(context: string, node: BABYLON.GLTF2.IMaterial, babylonMaterial: Material): Promise<BaseTexture[]>;
+        postExportMaterialAsync?(context: string, node: BABYLON.GLTF2.IMaterial, babylonMaterial: Material): Promise<BABYLON.GLTF2.IMaterial>;
+    }
+
+
+    /**
+     * @internal
+     */
+    export class KHR_materials_clearcoat_darkening implements IGLTFExporterExtensionV2 {
+        /** Name of this extension */
+        readonly name = "KHR_materials_clearcoat_darkening";
+        /** Defines whether this extension is enabled */
+        enabled: boolean;
+        /** Defines whether this extension is required */
+        required: boolean;
+        private _exporter;
+        private _wasUsed;
+        constructor(exporter: GLTFExporter);
+        dispose(): void;
+        /** @internal */
+        get wasUsed(): boolean;
+        postExportMaterialAdditionalTexturesAsync?(context: string, node: BABYLON.GLTF2.IMaterial, babylonMaterial: Material): Promise<BaseTexture[]>;
+        postExportMaterialAsync?(context: string, node: BABYLON.GLTF2.IMaterial, babylonMaterial: Material): Promise<BABYLON.GLTF2.IMaterial>;
+    }
+
+
+    /**
+     * @internal
+     */
+    export class KHR_materials_clearcoat_color implements IGLTFExporterExtensionV2 {
+        /** Name of this extension */
+        readonly name = "KHR_materials_clearcoat_color";
+        /** Defines whether this extension is enabled */
+        enabled: boolean;
+        /** Defines whether this extension is required */
+        required: boolean;
+        private _exporter;
+        private _wasUsed;
+        constructor(exporter: GLTFExporter);
+        dispose(): void;
+        /** @internal */
+        get wasUsed(): boolean;
+        postExportMaterialAdditionalTexturesAsync?(context: string, node: BABYLON.GLTF2.IMaterial, babylonMaterial: Material): Promise<BaseTexture[]>;
+        postExportMaterialAsync?(context: string, node: BABYLON.GLTF2.IMaterial, babylonMaterial: Material): Promise<BABYLON.GLTF2.IMaterial>;
+    }
+
+
+    /**
+     * @internal
+     */
+    export class KHR_materials_clearcoat_anisotropy implements IGLTFExporterExtensionV2 {
+        /** Name of this extension */
+        readonly name = "KHR_materials_clearcoat_anisotropy";
+        /** Defines whether this extension is enabled */
+        enabled: boolean;
+        /** Defines whether this extension is required */
+        required: boolean;
+        private _exporter;
+        private _wasUsed;
+        private _anisoTexturesMap;
+        constructor(exporter: GLTFExporter);
+        dispose(): void;
+        /** @internal */
+        get wasUsed(): boolean;
+        /**
+         * After exporting a material, deal with the additional textures
+         * @param context GLTF context of the material
+         * @param node exported GLTF node
+         * @param babylonMaterial corresponding babylon material
+         * @returns array of additional textures to export
+         */
+        postExportMaterialAdditionalTexturesAsync?(context: string, node: BABYLON.GLTF2.IMaterial, babylonMaterial: Material): Promise<BaseTexture[]>;
+        postExportMaterialAsync?(context: string, node: BABYLON.GLTF2.IMaterial, babylonMaterial: Material): Promise<BABYLON.GLTF2.IMaterial>;
+    }
+
+
     /**
      * @internal
      */
@@ -2782,7 +3003,7 @@ declare module BABYLON {
         dispose(): void;
         /** @internal */
         get wasUsed(): boolean;
-        postExportMaterialAdditionalTextures?(context: string, node: BABYLON.GLTF2.IMaterial, babylonMaterial: Material): BaseTexture[];
+        postExportMaterialAdditionalTexturesAsync?(context: string, node: BABYLON.GLTF2.IMaterial, babylonMaterial: Material): Promise<BaseTexture[]>;
         postExportMaterialAsync?(context: string, node: BABYLON.GLTF2.IMaterial, babylonMaterial: Material): Promise<BABYLON.GLTF2.IMaterial>;
     }
 
@@ -2799,11 +3020,19 @@ declare module BABYLON {
         required: boolean;
         private _exporter;
         private _wasUsed;
+        private _anisoTexturesMap;
         constructor(exporter: GLTFExporter);
         dispose(): void;
         /** @internal */
         get wasUsed(): boolean;
-        postExportMaterialAdditionalTextures?(context: string, node: BABYLON.GLTF2.IMaterial, babylonMaterial: Material): BaseTexture[];
+        /**
+         * After exporting a material, deal with the additional textures
+         * @param context GLTF context of the material
+         * @param node exported GLTF node
+         * @param babylonMaterial corresponding babylon material
+         * @returns array of additional textures to export
+         */
+        postExportMaterialAdditionalTexturesAsync?(context: string, node: BABYLON.GLTF2.IMaterial, babylonMaterial: Material): Promise<BaseTexture[]>;
         postExportMaterialAsync?(context: string, node: BABYLON.GLTF2.IMaterial, babylonMaterial: Material): Promise<BABYLON.GLTF2.IMaterial>;
     }
 
@@ -2938,27 +3167,6 @@ declare module BABYLON {
     }
 
 
-    /**
-     * @internal
-     */
-    export class EXT_materials_diffuse_roughness implements IGLTFExporterExtensionV2 {
-        /** Name of this extension */
-        readonly name = "EXT_materials_diffuse_roughness";
-        /** Defines whether this extension is enabled */
-        enabled: boolean;
-        /** Defines whether this extension is required */
-        required: boolean;
-        private _exporter;
-        private _wasUsed;
-        constructor(exporter: GLTFExporter);
-        dispose(): void;
-        /** @internal */
-        get wasUsed(): boolean;
-        postExportMaterialAdditionalTextures?(context: string, node: BABYLON.GLTF2.IMaterial, babylonMaterial: Material): BaseTexture[];
-        postExportMaterialAsync?(context: string, node: BABYLON.GLTF2.IMaterial, babylonMaterial: Material): Promise<BABYLON.GLTF2.IMaterial>;
-    }
-
-
     /**
      * Options for the USDZ export
      */

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "babylonjs-serializers",
-    "version": "8.28.0",
+    "version": "8.28.2",
     "main": "babylonjs.serializers.min.js",
     "types": "babylonjs.serializers.module.d.ts",
     "files": [
@@ -15,8 +15,8 @@
         "test:escheck": "es-check es6 ./babylonjs.serializers.js"
     },
     "dependencies": {
-        "babylonjs": "^8.28.0",
-        "babylonjs-gltf2interface": "^8.28.0"
+        "babylonjs": "^8.28.2",
+        "babylonjs-gltf2interface": "^8.28.2"
     },
     "devDependencies": {
         "@dev/build-tools": "1.0.0",