Merge pull request #8429 from Popov72/gltf-export-interfaces

GLTF: export all interfaces

dist/preview release/glTF2Interface/babylon.glTF2Interface.d.ts

@@ -905,4 +905,286 @@ declare module BABYLON.GLTF2 {
         validateBytes: (data: Uint8Array, options?: IGLTFValidationOptions) => Promise<IGLTFValidationResults>;
         validateString: (json: string, options?: IGLTFValidationOptions) => Promise<IGLTFValidationResults>;
     }
+
+    /**
+     * Interfaces from the EXT_lights_image_based extension
+     */
+
+    /** @hidden */
+    interface IEXTLightsImageBased_LightReferenceImageBased {
+        light: number;
+    }
+
+    /** @hidden */
+    interface IEXTLightsImageBased_LightImageBased extends IChildRootProperty {
+        intensity: number;
+        rotation: number[];
+        specularImageSize: number;
+        specularImages: number[][];
+        irradianceCoefficients: number[][];
+    }
+
+    /** @hidden */
+    interface IEXTLightsImageBased {
+        lights: IEXTLightsImageBased_LightImageBased[];
+    }
+
+    /**
+     * Interfaces from the EXT_mesh_gpu_instancing extension
+     * !!! Experimental Extension Subject to Changes !!!
+     */
+
+    /** @hidden */
+    interface IEXTMeshGpuInstancing {
+        mesh?: number;
+        attributes: { [name: string]: number };
+    }
+
+    /**
+     * Interfaces from the KHR_draco_mesh_compression extension
+     */
+
+    /** @hidden */
+    interface IKHRDracoMeshCompression {
+        bufferView: number;
+        attributes: { [name: string]: number };
+    }
+
+    /**
+     * Interfaces from the KHR_lights_punctual extension
+     */
+
+    /** @hidden */
+    const enum IKHRLightsPunctual_LightType {
+        DIRECTIONAL = "directional",
+        POINT = "point",
+        SPOT = "spot"
+    }
+
+    /** @hidden */
+    interface IKHRLightsPunctual_LightReference {
+        light: number;
+    }
+
+    /** @hidden */
+    interface IKHRLightsPunctual_Light extends IChildRootProperty {
+        type: IKHRLightsPunctual_LightType;
+        color?: number[];
+        intensity?: number;
+        range?: number;
+        spot?: {
+            innerConeAngle?: number;
+            outerConeAngle?: number;
+        };
+    }
+
+    /** @hidden */
+    interface IKHRLightsPunctual {
+        lights: IKHRLightsPunctual_Light[];
+    }
+
+    /**
+     * Interfaces from the KHR_materials_clearcoat extension
+     * !!! Experimental Extension Subject to Changes !!!
+     */
+
+    /** @hidden */
+    interface IKHRMaterialsClearcoat {
+        clearcoatFactor: number;
+        clearcoatTexture: ITextureInfo;
+        clearcoatRoughnessFactor: number;
+        clearcoatRoughnessTexture: ITextureInfo;
+        clearcoatNormalTexture: IMaterialNormalTextureInfo;
+    }
+
+    /**
+     * Interfaces from the KHR_materials_ior extension
+     * !!! Experimental Extension Subject to Changes !!!
+     */
+
+    /** @hidden */
+    interface IKHRMaterialsIor {
+        ior: number;
+    }
+
+    /**
+     * Interfaces from the KHR_materials_pbrSpecularGlossiness extension
+     */
+
+    /** @hidden */
+    interface IKHRMaterialsPbrSpecularGlossiness {
+        diffuseFactor: number[];
+        diffuseTexture: ITextureInfo;
+        specularFactor: number[];
+        glossinessFactor: number;
+        specularGlossinessTexture: ITextureInfo;
+    }
+
+    /**
+     * Interfaces from the KHR_materials_sheen extension
+     * !!! Experimental Extension Subject to Changes !!!
+     */
+
+    /** @hidden */
+    interface IKHRMaterialsSheen {
+        sheenColorFactor?: number[];
+        sheenTexture?: ITextureInfo;
+        sheenRoughnessFactor?: number;
+    }
+
+    /**
+     * Interfaces from the KHR_materials_specular extension
+     * !!! Experimental Extension Subject to Changes !!!
+     */
+
+    /** @hidden */
+    interface IKHRMaterialsSpecular {
+        specularFactor: number;
+        specularColorFactor: number[];
+        specularTexture: ITextureInfo;
+    }
+
+    /**
+     * Interfaces from the KHR_materials_transmission extension
+     * !!! Experimental Extension Subject to Changes !!!
+     */
+
+    /** @hidden */
+    interface IKHRMaterialsTransmission {
+        transmissionFactor?: number;
+        transmissionTexture?: ITextureInfo;
+    }
+
+    /**
+     * Interfaces from the KHR_materials_variants extension
+     * !!! Experimental Extension Subject to Changes !!!
+     */
+
+    /** @hidden */
+    interface IKHRMaterialVariants_Mapping {
+        tags: string[];
+        material: number;
+    }
+
+    /** @hidden */
+    interface IKHRMaterialVariants {
+        mapping: IKHRMaterialVariants_Mapping[];
+    }
+
+    /**
+     * Interfaces from the KHR_texture_basisu extension
+     * !!! Experimental Extension Subject to Changes !!!
+     */
+
+    /** @hidden */
+    interface IKHRTextureBasisU {
+        source: number;
+    }
+
+    /**
+     * Interfaces from the KHR_texture_transform extension
+     */
+
+    /** @hidden */
+    interface IKHRTextureTransform {
+        offset?: number[];
+        rotation?: number;
+        scale?: number[];
+        texCoord?: number;
+    }
+
+    /**
+     * Interfaces from the KHR_xmp extension
+     * !!! Experimental Extension Subject to Changes !!!
+     */
+
+    /** @hidden */
+    interface IKHRXmp_Data {
+        [key: string]: unknown;
+    }
+
+    /** @hidden */
+    interface IKHRXmp_Gltf {
+        packets: IKHRXmp_Data[];
+    }
+
+    /** @hidden */
+    interface IKHRXmp_Node {
+        packet: number;
+    }
+
+    /**
+     * Interfaces from the MSFT_audio_emitter extension
+     */
+
+    /** @hidden */
+    interface IMSFTAudioEmitter_ClipReference {
+        clip: number;
+        weight?: number;
+    }
+
+    /** @hidden */
+    interface IMSFTAudioEmitter_EmittersReference {
+        emitters: number[];
+    }
+
+    /** @hidden */
+    const enum IMSFTAudioEmitter_DistanceModel {
+        linear = "linear",
+        inverse = "inverse",
+        exponential = "exponential",
+    }
+
+    /** @hidden */
+    interface IMSFTAudioEmitter_Emitter {
+        name?: string;
+        distanceModel?: IMSFTAudioEmitter_DistanceModel;
+        refDistance?: number;
+        maxDistance?: number;
+        rolloffFactor?: number;
+        innerAngle?: number;
+        outerAngle?: number;
+        loop?: boolean;
+        volume?: number;
+        clips: IMSFTAudioEmitter_ClipReference[];
+    }
+
+    /** @hidden */
+    const enum IMSFTAudioEmitter_AudioMimeType {
+        WAV = "audio/wav",
+    }
+
+    /** @hidden */
+    interface IMSFTAudioEmitter_Clip extends IProperty {
+        uri?: string;
+        bufferView?: number;
+        mimeType?: IMSFTAudioEmitter_AudioMimeType;
+    }
+
+    /** @hidden */
+    const enum IMSFTAudioEmitter_AnimationEventAction {
+        play = "play",
+        pause = "pause",
+        stop = "stop",
+    }
+
+    /** @hidden */
+    interface IMSFTAudioEmitter_AnimationEvent {
+        action: IMSFTAudioEmitter_AnimationEventAction;
+        emitter: number;
+        time: number;
+        startOffset?: number;
+    }
+
+    /**
+     * Interfaces from the MSFT_lod extension
+     */
+
+    /** @hidden */
+    interface IMSFTLOD {
+        ids: number[];
+    }
+
+
+
 }

loaders/src/glTF/2.0/Extensions/EXT_lights_image_based.ts

@@ -5,30 +5,19 @@ import { Quaternion, Matrix } from "babylonjs/Maths/math.vector";
 import { BaseTexture } from "babylonjs/Materials/Textures/baseTexture";
 import { RawCubeTexture } from "babylonjs/Materials/Textures/rawCubeTexture";
 
-import { IChildRootProperty } from "babylonjs-gltf2interface";
+import { IEXTLightsImageBased_LightReferenceImageBased, IEXTLightsImageBased_LightImageBased, IEXTLightsImageBased } from "babylonjs-gltf2interface";
 import { IScene } from "../glTFLoaderInterfaces";
 import { IGLTFLoaderExtension } from "../glTFLoaderExtension";
 import { GLTFLoader, ArrayItem } from "../glTFLoader";
 
 const NAME = "EXT_lights_image_based";
 
-interface ILightReference {
-    light: number;
-}
-
-interface ILight extends IChildRootProperty {
-    intensity: number;
-    rotation: number[];
-    specularImageSize: number;
-    specularImages: number[][];
-    irradianceCoefficients: number[][];
-
-    _babylonTexture?: BaseTexture;
-    _loaded?: Promise<void>;
-}
-
-interface ILights {
-    lights: ILight[];
+declare module "babylonjs-gltf2interface" {
+    /** @hidden */
+    interface IEXTLightsImageBased_LightImageBased {
+        _babylonTexture?: BaseTexture;
+        _loaded?: Promise<void>;
+    }
 }
 
 /**
@@ -46,7 +35,7 @@ export class EXT_lights_image_based implements IGLTFLoaderExtension {
     public enabled: boolean;
 
     private _loader: GLTFLoader;
-    private _lights?: ILight[];
+    private _lights?: IEXTLightsImageBased_LightImageBased[];
 
     /** @hidden */
     constructor(loader: GLTFLoader) {
@@ -64,14 +53,14 @@ export class EXT_lights_image_based implements IGLTFLoaderExtension {
     public onLoading(): void {
         const extensions = this._loader.gltf.extensions;
         if (extensions && extensions[this.name]) {
-            const extension = extensions[this.name] as ILights;
+            const extension = extensions[this.name] as IEXTLightsImageBased;
             this._lights = extension.lights;
         }
     }
 
     /** @hidden */
     public loadSceneAsync(context: string, scene: IScene): Nullable<Promise<void>> {
-        return GLTFLoader.LoadExtensionAsync<ILightReference>(context, scene, this.name, (extensionContext, extension) => {
+        return GLTFLoader.LoadExtensionAsync<IEXTLightsImageBased_LightReferenceImageBased>(context, scene, this.name, (extensionContext, extension) => {
             const promises = new Array<Promise<any>>();
 
             promises.push(this._loader.loadSceneAsync(context, scene));
@@ -89,7 +78,7 @@ export class EXT_lights_image_based implements IGLTFLoaderExtension {
         });
     }
 
-    private _loadLightAsync(context: string, light: ILight): Promise<BaseTexture> {
+    private _loadLightAsync(context: string, light: IEXTLightsImageBased_LightImageBased): Promise<BaseTexture> {
         if (!light._loaded) {
             const promises = new Array<Promise<any>>();
 

loaders/src/glTF/2.0/Extensions/EXT_mesh_gpu_instancing.ts

@@ -6,14 +6,10 @@ import { GLTFLoader, ArrayItem } from "../glTFLoader";
 import { IGLTFLoaderExtension } from "../glTFLoaderExtension";
 import { INode } from "../glTFLoaderInterfaces";
 import { TmpVectors } from 'babylonjs/Maths/math.vector';
+import { IEXTMeshGpuInstancing } from "babylonjs-gltf2interface";
 
 const NAME = "EXT_mesh_gpu_instancing";
 
-interface IEXTMeshGpuInstancing {
-    mesh?: number;
-    attributes: { [name: string]: number };
-}
-
 /**
  * [Proposed Specification](https://github.com/KhronosGroup/glTF/pull/1691)
  * [Playground Sample](https://playground.babylonjs.com/#QFIGLW#9)

loaders/src/glTF/2.0/Extensions/KHR_draco_mesh_compression.ts

@@ -4,18 +4,13 @@ import { VertexBuffer } from "babylonjs/Meshes/buffer";
 import { Geometry } from "babylonjs/Meshes/geometry";
 import { Mesh } from "babylonjs/Meshes/mesh";
 
-import { MeshPrimitiveMode } from "babylonjs-gltf2interface";
-import { IBufferView, IMeshPrimitive } from "../glTFLoaderInterfaces";
+import { MeshPrimitiveMode, IKHRDracoMeshCompression } from "babylonjs-gltf2interface";
+import { IMeshPrimitive, IBufferView } from "../glTFLoaderInterfaces";
 import { IGLTFLoaderExtension } from "../glTFLoaderExtension";
 import { GLTFLoader, ArrayItem } from "../glTFLoader";
 
 const NAME = "KHR_draco_mesh_compression";
 
-interface IKHRDracoMeshCompression {
-    bufferView: number;
-    attributes: { [name: string]: number };
-}
-
 interface IBufferViewDraco extends IBufferView {
     _dracoBabylonGeometry?: Promise<Geometry>;
 }

loaders/src/glTF/2.0/Extensions/KHR_lights_punctual.ts

@@ -7,38 +7,13 @@ import { SpotLight } from "babylonjs/Lights/spotLight";
 import { Light } from "babylonjs/Lights/light";
 import { TransformNode } from "babylonjs/Meshes/transformNode";
 
-import { IChildRootProperty } from "babylonjs-gltf2interface";
+import { IKHRLightsPunctual_LightType, IKHRLightsPunctual_LightReference, IKHRLightsPunctual_Light, IKHRLightsPunctual } from "babylonjs-gltf2interface";
 import { INode } from "../glTFLoaderInterfaces";
 import { IGLTFLoaderExtension } from "../glTFLoaderExtension";
 import { GLTFLoader, ArrayItem } from "../glTFLoader";
 
 const NAME = "KHR_lights_punctual";
 
-enum LightType {
-    DIRECTIONAL = "directional",
-    POINT = "point",
-    SPOT = "spot"
-}
-
-interface ILightReference {
-    light: number;
-}
-
-interface ILight extends IChildRootProperty {
-    type: LightType;
-    color?: number[];
-    intensity?: number;
-    range?: number;
-    spot?: {
-        innerConeAngle?: number;
-        outerConeAngle?: number;
-    };
-}
-
-interface ILights {
-    lights: ILight[];
-}
-
 /**
  * [Specification](https://github.com/KhronosGroup/glTF/blob/master/extensions/2.0/Khronos/KHR_lights_punctual)
  */
@@ -54,7 +29,7 @@ export class KHR_lights implements IGLTFLoaderExtension {
     public enabled: boolean;
 
     private _loader: GLTFLoader;
-    private _lights?: ILight[];
+    private _lights?: IKHRLightsPunctual_Light[];
 
     /** @hidden */
     constructor(loader: GLTFLoader) {
@@ -72,14 +47,14 @@ export class KHR_lights implements IGLTFLoaderExtension {
     public onLoading(): void {
         const extensions = this._loader.gltf.extensions;
         if (extensions && extensions[this.name]) {
-            const extension = extensions[this.name] as ILights;
+            const extension = extensions[this.name] as IKHRLightsPunctual;
             this._lights = extension.lights;
         }
     }
 
     /** @hidden */
     public loadNodeAsync(context: string, node: INode, assign: (babylonTransformNode: TransformNode) => void): Nullable<Promise<TransformNode>> {
-        return GLTFLoader.LoadExtensionAsync<ILightReference, TransformNode>(context, node, this.name, (extensionContext, extension) => {
+        return GLTFLoader.LoadExtensionAsync<IKHRLightsPunctual_LightReference, TransformNode>(context, node, this.name, (extensionContext, extension) => {
             return this._loader.loadNodeAsync(context, node, (babylonMesh) => {
                 let babylonLight: Light;
 
@@ -89,15 +64,15 @@ export class KHR_lights implements IGLTFLoaderExtension {
                 this._loader.babylonScene._blockEntityCollection = this._loader._forAssetContainer;
 
                 switch (light.type) {
-                    case LightType.DIRECTIONAL: {
+                    case IKHRLightsPunctual_LightType.DIRECTIONAL: {
                         babylonLight = new DirectionalLight(name, Vector3.Backward(), this._loader.babylonScene);
                         break;
                     }
-                    case LightType.POINT: {
+                    case IKHRLightsPunctual_LightType.POINT: {
                         babylonLight = new PointLight(name, Vector3.Zero(), this._loader.babylonScene);
                         break;
                     }
-                    case LightType.SPOT: {
+                    case IKHRLightsPunctual_LightType.SPOT: {
                         const babylonSpotLight = new SpotLight(name, Vector3.Zero(), Vector3.Backward(), 0, 1, this._loader.babylonScene);
                         babylonSpotLight.angle = ((light.spot && light.spot.outerConeAngle) || Math.PI / 4) * 2;
                         babylonSpotLight.innerAngle = ((light.spot && light.spot.innerConeAngle) || 0) * 2;

loaders/src/glTF/2.0/Extensions/KHR_materials_clearcoat.ts

@@ -2,21 +2,13 @@ import { Nullable } from "babylonjs/types";
 import { PBRMaterial } from "babylonjs/Materials/PBR/pbrMaterial";
 import { Material } from "babylonjs/Materials/material";
 
-import { ITextureInfo, IMaterial } from "../glTFLoaderInterfaces";
+import { IMaterial } from "../glTFLoaderInterfaces";
 import { IGLTFLoaderExtension } from "../glTFLoaderExtension";
 import { GLTFLoader } from "../glTFLoader";
-import { IMaterialNormalTextureInfo } from 'babylonjs-gltf2interface';
+import { IKHRMaterialsClearcoat } from 'babylonjs-gltf2interface';
 
 const NAME = "KHR_materials_clearcoat";
 
-interface IKHR_materials_clearcoat {
-    clearcoatFactor: number;
-    clearcoatTexture: ITextureInfo;
-    clearcoatRoughnessFactor: number;
-    clearcoatRoughnessTexture: ITextureInfo;
-    clearcoatNormalTexture: IMaterialNormalTextureInfo;
-}
-
 /**
  * [Proposed Specification](https://github.com/KhronosGroup/glTF/pull/1677)
  * [Playground Sample](https://www.babylonjs-playground.com/frame.html#7F7PN6#8)
@@ -53,7 +45,7 @@ export class KHR_materials_clearcoat implements IGLTFLoaderExtension {
 
     /** @hidden */
     public loadMaterialPropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material): Nullable<Promise<void>> {
-        return GLTFLoader.LoadExtensionAsync<IKHR_materials_clearcoat>(context, material, this.name, (extensionContext, extension) => {
+        return GLTFLoader.LoadExtensionAsync<IKHRMaterialsClearcoat>(context, material, this.name, (extensionContext, extension) => {
             const promises = new Array<Promise<any>>();
             promises.push(this._loader.loadMaterialPropertiesAsync(context, material, babylonMaterial));
             promises.push(this._loadClearCoatPropertiesAsync(extensionContext, extension, babylonMaterial));
@@ -61,7 +53,7 @@ export class KHR_materials_clearcoat implements IGLTFLoaderExtension {
         });
     }
 
-    private _loadClearCoatPropertiesAsync(context: string, properties: IKHR_materials_clearcoat, babylonMaterial: Material): Promise<void> {
+    private _loadClearCoatPropertiesAsync(context: string, properties: IKHRMaterialsClearcoat, babylonMaterial: Material): Promise<void> {
         if (!(babylonMaterial instanceof PBRMaterial)) {
             throw new Error(`${context}: Material type not supported`);
         }

loaders/src/glTF/2.0/Extensions/KHR_materials_ior.ts

@@ -5,13 +5,10 @@ import { Material } from "babylonjs/Materials/material";
 import { IMaterial } from "../glTFLoaderInterfaces";
 import { IGLTFLoaderExtension } from "../glTFLoaderExtension";
 import { GLTFLoader } from "../glTFLoader";
+import { IKHRMaterialsIor } from 'babylonjs-gltf2interface';
 
 const NAME = "KHR_materials_ior";
 
-interface IKHR_materials_ior {
-    ior: number;
-}
-
 /**
  * [Proposed Specification](https://github.com/KhronosGroup/glTF/pull/1718)
  * !!! Experimental Extension Subject to Changes !!!
@@ -52,7 +49,7 @@ export class KHR_materials_ior implements IGLTFLoaderExtension {
 
     /** @hidden */
     public loadMaterialPropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material): Nullable<Promise<void>> {
-        return GLTFLoader.LoadExtensionAsync<IKHR_materials_ior>(context, material, this.name, (extensionContext, extension) => {
+        return GLTFLoader.LoadExtensionAsync<IKHRMaterialsIor>(context, material, this.name, (extensionContext, extension) => {
             const promises = new Array<Promise<any>>();
             promises.push(this._loader.loadMaterialPropertiesAsync(context, material, babylonMaterial));
             promises.push(this._loadIorPropertiesAsync(extensionContext, extension, babylonMaterial));
@@ -60,7 +57,7 @@ export class KHR_materials_ior implements IGLTFLoaderExtension {
         });
     }
 
-    private _loadIorPropertiesAsync(context: string, properties: IKHR_materials_ior, babylonMaterial: Material): Promise<void> {
+    private _loadIorPropertiesAsync(context: string, properties: IKHRMaterialsIor, babylonMaterial: Material): Promise<void> {
         if (!(babylonMaterial instanceof PBRMaterial)) {
             throw new Error(`${context}: Material type not supported`);
         }

loaders/src/glTF/2.0/Extensions/KHR_materials_pbrSpecularGlossiness.ts

@@ -3,20 +3,13 @@ import { Color3 } from "babylonjs/Maths/math.color";
 import { PBRMaterial } from "babylonjs/Materials/PBR/pbrMaterial";
 import { Material } from "babylonjs/Materials/material";
 
-import { ITextureInfo, IMaterial } from "../glTFLoaderInterfaces";
+import { IMaterial } from "../glTFLoaderInterfaces";
 import { IGLTFLoaderExtension } from "../glTFLoaderExtension";
 import { GLTFLoader } from "../glTFLoader";
+import { IKHRMaterialsPbrSpecularGlossiness } from 'babylonjs-gltf2interface';
 
 const NAME = "KHR_materials_pbrSpecularGlossiness";
 
-interface IKHRMaterialsPbrSpecularGlossiness {
-    diffuseFactor: number[];
-    diffuseTexture: ITextureInfo;
-    specularFactor: number[];
-    glossinessFactor: number;
-    specularGlossinessTexture: ITextureInfo;
-}
-
 /**
  * [Specification](https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_pbrSpecularGlossiness)
  */

loaders/src/glTF/2.0/Extensions/KHR_materials_sheen.ts

@@ -2,19 +2,14 @@ import { Nullable } from "babylonjs/types";
 import { PBRMaterial } from "babylonjs/Materials/PBR/pbrMaterial";
 import { Material } from "babylonjs/Materials/material";
 
-import { ITextureInfo, IMaterial } from "../glTFLoaderInterfaces";
+import { IMaterial } from "../glTFLoaderInterfaces";
 import { IGLTFLoaderExtension } from "../glTFLoaderExtension";
 import { GLTFLoader } from "../glTFLoader";
 import { Color3 } from 'babylonjs/Maths/math.color';
+import { IKHRMaterialsSheen } from 'babylonjs-gltf2interface';
 
 const NAME = "KHR_materials_sheen";
 
-interface IKHR_materials_sheen {
-    sheenColorFactor: number[];
-    sheenTexture: ITextureInfo;
-    sheenRoughnessFactor: number;
-}
-
 /**
  * [Proposed Specification](https://github.com/KhronosGroup/glTF/pull/1688)
  * [Playground Sample](https://www.babylonjs-playground.com/frame.html#BNIZX6#4)
@@ -51,7 +46,7 @@ export class KHR_materials_sheen implements IGLTFLoaderExtension {
 
     /** @hidden */
     public loadMaterialPropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material): Nullable<Promise<void>> {
-        return GLTFLoader.LoadExtensionAsync<IKHR_materials_sheen>(context, material, this.name, (extensionContext, extension) => {
+        return GLTFLoader.LoadExtensionAsync<IKHRMaterialsSheen>(context, material, this.name, (extensionContext, extension) => {
             const promises = new Array<Promise<any>>();
             promises.push(this._loader.loadMaterialPropertiesAsync(context, material, babylonMaterial));
             promises.push(this._loadSheenPropertiesAsync(extensionContext, extension, babylonMaterial));
@@ -59,7 +54,7 @@ export class KHR_materials_sheen implements IGLTFLoaderExtension {
         });
     }
 
-    private _loadSheenPropertiesAsync(context: string, properties: IKHR_materials_sheen, babylonMaterial: Material): Promise<void> {
+    private _loadSheenPropertiesAsync(context: string, properties: IKHRMaterialsSheen, babylonMaterial: Material): Promise<void> {
         if (!(babylonMaterial instanceof PBRMaterial)) {
             throw new Error(`${context}: Material type not supported`);
         }

loaders/src/glTF/2.0/Extensions/KHR_materials_specular.ts

@@ -2,19 +2,14 @@ import { Nullable } from "babylonjs/types";
 import { PBRMaterial } from "babylonjs/Materials/PBR/pbrMaterial";
 import { Material } from "babylonjs/Materials/material";
 
-import { IMaterial, ITextureInfo } from "../glTFLoaderInterfaces";
+import { IMaterial } from "../glTFLoaderInterfaces";
 import { IGLTFLoaderExtension } from "../glTFLoaderExtension";
 import { GLTFLoader } from "../glTFLoader";
 import { Color3 } from 'babylonjs/Maths/math.color';
+import { IKHRMaterialsSpecular } from 'babylonjs-gltf2interface';
 
 const NAME = "KHR_materials_specular";
 
-interface IKHR_materials_specular {
-    specularFactor: number;
-    specularColorFactor: number[];
-    specularTexture: ITextureInfo;
-}
-
 /**
  * [Proposed Specification](https://github.com/KhronosGroup/glTF/pull/1719)
  * !!! Experimental Extension Subject to Changes !!!
@@ -50,7 +45,7 @@ export class KHR_materials_specular implements IGLTFLoaderExtension {
 
     /** @hidden */
     public loadMaterialPropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material): Nullable<Promise<void>> {
-        return GLTFLoader.LoadExtensionAsync<IKHR_materials_specular>(context, material, this.name, (extensionContext, extension) => {
+        return GLTFLoader.LoadExtensionAsync<IKHRMaterialsSpecular>(context, material, this.name, (extensionContext, extension) => {
             const promises = new Array<Promise<any>>();
             promises.push(this._loader.loadMaterialPropertiesAsync(context, material, babylonMaterial));
             promises.push(this._loadSpecularPropertiesAsync(extensionContext, extension, babylonMaterial));
@@ -58,7 +53,7 @@ export class KHR_materials_specular implements IGLTFLoaderExtension {
         });
     }
 
-    private _loadSpecularPropertiesAsync(context: string, properties: IKHR_materials_specular, babylonMaterial: Material): Promise<void> {
+    private _loadSpecularPropertiesAsync(context: string, properties: IKHRMaterialsSpecular, babylonMaterial: Material): Promise<void> {
         if (!(babylonMaterial instanceof PBRMaterial)) {
             throw new Error(`${context}: Material type not supported`);
         }

loaders/src/glTF/2.0/Extensions/KHR_materials_transmission.ts

@@ -2,17 +2,13 @@ import { Nullable } from "babylonjs/types";
 import { PBRMaterial } from "babylonjs/Materials/PBR/pbrMaterial";
 import { Material } from "babylonjs/Materials/material";
 import { BaseTexture } from "babylonjs/Materials/Textures/baseTexture";
-import { IMaterial, ITextureInfo } from "../glTFLoaderInterfaces";
+import { IMaterial } from "../glTFLoaderInterfaces";
 import { IGLTFLoaderExtension } from "../glTFLoaderExtension";
 import { GLTFLoader } from "../glTFLoader";
+import { IKHRMaterialsTransmission } from 'babylonjs-gltf2interface';
 
 const NAME = "KHR_materials_transmission";
 
-interface IMaterialsTransmission {
-    transmissionFactor?: number;
-    transmissionTexture?: ITextureInfo;
-}
-
 /**
  * [Proposed Specification](https://github.com/KhronosGroup/glTF/pull/1698)
  * !!! Experimental Extension Subject to Changes !!!
@@ -51,7 +47,7 @@ export class KHR_materials_transmission implements IGLTFLoaderExtension {
 
     /** @hidden */
     public loadMaterialPropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material): Nullable<Promise<void>> {
-        return GLTFLoader.LoadExtensionAsync<IMaterialsTransmission>(context, material, this.name, (extensionContext, extension) => {
+        return GLTFLoader.LoadExtensionAsync<IKHRMaterialsTransmission>(context, material, this.name, (extensionContext, extension) => {
             console.log(extensionContext);
             const promises = new Array<Promise<any>>();
             promises.push(this._loader.loadMaterialBasePropertiesAsync(context, material, babylonMaterial));
@@ -61,7 +57,7 @@ export class KHR_materials_transmission implements IGLTFLoaderExtension {
         });
     }
 
-    private _loadTransparentPropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material, extension: IMaterialsTransmission): Promise<void> {
+    private _loadTransparentPropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material, extension: IKHRMaterialsTransmission): Promise<void> {
         if (!(babylonMaterial instanceof PBRMaterial)) {
             throw new Error(`${context}: Material type not supported`);
         }

loaders/src/glTF/2.0/Extensions/KHR_materials_variants.ts

@@ -6,16 +6,12 @@ import { Material } from 'babylonjs/Materials/material';
 import { Mesh } from 'babylonjs/Meshes/mesh';
 import { AbstractMesh } from 'babylonjs/Meshes/abstractMesh';
 import { INode, IMeshPrimitive, IMesh } from '../glTFLoaderInterfaces';
+import { IKHRMaterialVariants } from 'babylonjs-gltf2interface';
 
 const NAME = "KHR_materials_variants";
 
-interface IKHRMaterialVariantsMapping {
-    tags: string[];
-    material: number;
-}
-
-interface IKHRMaterialVariants {
-    mapping: IKHRMaterialVariantsMapping[];
+interface IVariantsMap {
+    [key: string]: Array<{ mesh: AbstractMesh, material: Nullable<Material> }>;
 }
 
 interface IExtensionMetadata {
@@ -24,10 +20,6 @@ interface IExtensionMetadata {
     variants: IVariantsMap;
 }
 
-interface IVariantsMap {
-    [key: string]: Array<{ mesh: AbstractMesh, material: Nullable<Material> }>;
-}
-
 /**
  * [Proposed Specification](https://github.com/KhronosGroup/glTF/pull/1681)
  * !!! Experimental Extension Subject to Changes !!!

loaders/src/glTF/2.0/Extensions/KHR_texture_basisu.ts

@@ -3,13 +3,10 @@ import { GLTFLoader, ArrayItem } from "../glTFLoader";
 import { ITexture } from "../glTFLoaderInterfaces";
 import { BaseTexture } from "babylonjs/Materials/Textures/baseTexture";
 import { Nullable } from "babylonjs/types";
+import { IKHRTextureBasisU } from 'babylonjs-gltf2interface';
 
 const NAME = "KHR_texture_basisu";
 
-interface IKHRTextureBasisU {
-    source: number;
-}
-
 /**
  * [Proposed Specification](https://github.com/KhronosGroup/glTF/pull/1751)
  * !!! Experimental Extension Subject to Changes !!!

loaders/src/glTF/2.0/Extensions/KHR_texture_transform.ts

@@ -5,16 +5,10 @@ import { Texture } from "babylonjs/Materials/Textures/texture";
 import { ITextureInfo } from "../glTFLoaderInterfaces";
 import { IGLTFLoaderExtension } from "../glTFLoaderExtension";
 import { GLTFLoader } from "../glTFLoader";
+import { IKHRTextureTransform } from 'babylonjs-gltf2interface';
 
 const NAME = "KHR_texture_transform";
 
-interface IKHRTextureTransform {
-    offset?: number[];
-    rotation?: number;
-    scale?: number[];
-    texCoord?: number;
-}
-
 /**
  * [Specification](https://github.com/KhronosGroup/glTF/blob/master/extensions/2.0/Khronos/KHR_texture_transform)
  */

loaders/src/glTF/2.0/Extensions/KHR_xmp.ts

@@ -1,20 +1,9 @@
 import { IGLTFLoaderExtension } from "../glTFLoaderExtension";
 import { GLTFLoader } from "../glTFLoader";
+import { IKHRXmp_Gltf, IKHRXmp_Node } from 'babylonjs-gltf2interface';
 
 const NAME = "KHR_xmp";
 
-interface IKHR_xmp_data {
-    [key: string]: unknown;
-}
-
-interface IKHR_xmp_gltf {
-    packets: IKHR_xmp_data[];
-}
-
-interface IKHR_xmp_node {
-    packet: number;
-}
-
 /**
  * [Proposed Specification](https://github.com/KhronosGroup/glTF/pull/1553)
  * !!! Experimental Extension Subject to Changes !!!
@@ -52,8 +41,8 @@ export class KHR_xmp implements IGLTFLoaderExtension {
      * Called after the loader state changes to LOADING.
      */
     public onLoading(): void {
-        const xmp_gltf = (this._loader.gltf.extensions?.KHR_xmp as IKHR_xmp_gltf);
-        const xmp_node = (this._loader.gltf.asset?.extensions?.KHR_xmp as IKHR_xmp_node);
+        const xmp_gltf = (this._loader.gltf.extensions?.KHR_xmp as IKHRXmp_Gltf);
+        const xmp_node = (this._loader.gltf.asset?.extensions?.KHR_xmp as IKHRXmp_Node);
         if (xmp_gltf && xmp_node) {
             const packet = +xmp_node.packet;
             if (xmp_gltf.packets && packet < xmp_gltf.packets.length) {

loaders/src/glTF/2.0/Extensions/MSFT_audio_emitter.ts

@@ -10,53 +10,15 @@ import { WeightedSound } from "babylonjs/Audio/weightedsound";
 import { IArrayItem, IScene, INode, IAnimation } from "../glTFLoaderInterfaces";
 import { IGLTFLoaderExtension } from "../glTFLoaderExtension";
 import { GLTFLoader, ArrayItem } from "../glTFLoader";
-import { IProperty } from 'babylonjs-gltf2interface';
+import { IMSFTAudioEmitter_Clip, IMSFTAudioEmitter_Emitter, IMSFTAudioEmitter_EmittersReference, IMSFTAudioEmitter_AnimationEvent, IMSFTAudioEmitter_AnimationEventAction } from 'babylonjs-gltf2interface';
 
 const NAME = "MSFT_audio_emitter";
 
-interface IClipReference {
-    clip: number;
-    weight?: number;
-}
-
-interface IEmittersReference {
-    emitters: number[];
-}
-
-const enum DistanceModel {
-    linear = "linear",
-    inverse = "inverse",
-    exponential = "exponential",
-}
-
-interface IEmitter {
-    name?: string;
-    distanceModel?: DistanceModel;
-    refDistance?: number;
-    maxDistance?: number;
-    rolloffFactor?: number;
-    innerAngle?: number;
-    outerAngle?: number;
-    loop?: boolean;
-    volume?: number;
-    clips: IClipReference[];
-}
-
-const enum AudioMimeType {
-    WAV = "audio/wav",
-}
-
-interface IClip extends IProperty {
-    uri?: string;
-    bufferView?: number;
-    mimeType?: AudioMimeType;
-}
-
-interface ILoaderClip extends IClip, IArrayItem {
+interface ILoaderClip extends IMSFTAudioEmitter_Clip, IArrayItem {
     _objectURL?: Promise<string>;
 }
 
-interface ILoaderEmitter extends IEmitter, IArrayItem {
+interface ILoaderEmitter extends IMSFTAudioEmitter_Emitter, IArrayItem {
     _babylonData?: {
         sound?: WeightedSound;
         loaded: Promise<void>;
@@ -69,20 +31,7 @@ interface IMSFTAudioEmitter {
     emitters: ILoaderEmitter[];
 }
 
-const enum AnimationEventAction {
-    play = "play",
-    pause = "pause",
-    stop = "stop",
-}
-
-interface IAnimationEvent {
-    action: AnimationEventAction;
-    emitter: number;
-    time: number;
-    startOffset?: number;
-}
-
-interface ILoaderAnimationEvent extends IAnimationEvent, IArrayItem {
+interface ILoaderAnimationEvent extends IMSFTAudioEmitter_AnimationEvent, IArrayItem {
 }
 
 interface ILoaderAnimationEvents {
@@ -136,7 +85,7 @@ export class MSFT_audio_emitter implements IGLTFLoaderExtension {
 
     /** @hidden */
     public loadSceneAsync(context: string, scene: IScene): Nullable<Promise<void>> {
-        return GLTFLoader.LoadExtensionAsync<IEmittersReference>(context, scene, this.name, (extensionContext, extension) => {
+        return GLTFLoader.LoadExtensionAsync<IMSFTAudioEmitter_EmittersReference>(context, scene, this.name, (extensionContext, extension) => {
             const promises = new Array<Promise<any>>();
 
             promises.push(this._loader.loadSceneAsync(context, scene));
@@ -157,7 +106,7 @@ export class MSFT_audio_emitter implements IGLTFLoaderExtension {
 
     /** @hidden */
     public loadNodeAsync(context: string, node: INode, assign: (babylonTransformNode: TransformNode) => void): Nullable<Promise<TransformNode>> {
-        return GLTFLoader.LoadExtensionAsync<IEmittersReference, TransformNode>(context, node, this.name, (extensionContext, extension) => {
+        return GLTFLoader.LoadExtensionAsync<IMSFTAudioEmitter_EmittersReference, TransformNode>(context, node, this.name, (extensionContext, extension) => {
             const promises = new Array<Promise<any>>();
 
             return this._loader.loadNodeAsync(extensionContext, node, (babylonMesh) => {
@@ -266,20 +215,20 @@ export class MSFT_audio_emitter implements IGLTFLoaderExtension {
         return emitter._babylonData.loaded;
     }
 
-    private _getEventAction(context: string, sound: WeightedSound, action: AnimationEventAction, time: number, startOffset?: number): (currentFrame: number) => void {
+    private _getEventAction(context: string, sound: WeightedSound, action: IMSFTAudioEmitter_AnimationEventAction, time: number, startOffset?: number): (currentFrame: number) => void {
         switch (action) {
-            case AnimationEventAction.play: {
+            case IMSFTAudioEmitter_AnimationEventAction.play: {
                 return (currentFrame: number) => {
                     const frameOffset = (startOffset || 0) + (currentFrame - time);
                     sound.play(frameOffset);
                 };
             }
-            case AnimationEventAction.stop: {
+            case IMSFTAudioEmitter_AnimationEventAction.stop: {
                 return (currentFrame: number) => {
                     sound.stop();
                 };
             }
-            case AnimationEventAction.pause: {
+            case IMSFTAudioEmitter_AnimationEventAction.pause: {
                 return (currentFrame: number) => {
                     sound.pause();
                 };

loaders/src/glTF/2.0/Extensions/MSFT_lod.ts

@@ -8,14 +8,10 @@ import { BaseTexture } from 'babylonjs/Materials/Textures/baseTexture';
 import { INode, IMaterial, IBuffer, IScene } from "../glTFLoaderInterfaces";
 import { IGLTFLoaderExtension } from "../glTFLoaderExtension";
 import { GLTFLoader, ArrayItem } from "../glTFLoader";
-import { IProperty } from 'babylonjs-gltf2interface';
+import { IProperty, IMSFTLOD } from 'babylonjs-gltf2interface';
 
 const NAME = "MSFT_lod";
 
-interface IMSFTLOD {
-    ids: number[];
-}
-
 interface IBufferInfo {
     start: number;
     end: number;

serializers/src/glTF/2.0/Extensions/KHR_lights_punctual.ts

@@ -6,40 +6,15 @@ import { Light } from "babylonjs/Lights/light";
 import { DirectionalLight } from "babylonjs/Lights/directionalLight";
 import { Node } from "babylonjs/node";
 import { ShadowLight } from "babylonjs/Lights/shadowLight";
-import { IChildRootProperty } from "babylonjs-gltf2interface";
 import { INode } from "babylonjs-gltf2interface";
 import { IGLTFExporterExtensionV2 } from "../glTFExporterExtension";
 import { _Exporter } from "../glTFExporter";
 import { Logger } from "babylonjs/Misc/logger";
 import { _GLTFUtilities } from "../glTFUtilities";
+import { IKHRLightsPunctual_LightType, IKHRLightsPunctual_LightReference, IKHRLightsPunctual_Light, IKHRLightsPunctual } from "babylonjs-gltf2interface";
 
 const NAME = "KHR_lights_punctual";
 
-enum LightType {
-    DIRECTIONAL = "directional",
-    POINT = "point",
-    SPOT = "spot"
-}
-
-interface ILightReference {
-    light: number;
-}
-
-interface ILight extends IChildRootProperty {
-    type: LightType;
-    color?: number[];
-    intensity?: number;
-    range?: number;
-    spot?: {
-        innerConeAngle?: number;
-        outerConeAngle?: number;
-    };
-}
-
-interface ILights {
-    lights: ILight[];
-}
-
 /**
  * [Specification](https://github.com/KhronosGroup/glTF/blob/master/extensions/2.0/Khronos/KHR_lights_punctual/README.md)
  */
@@ -56,7 +31,7 @@ export class KHR_lights_punctual implements IGLTFExporterExtensionV2 {
     /** Reference to the glTF exporter */
     private _exporter: _Exporter;
 
-    private _lights: ILights;
+    private _lights: IKHRLightsPunctual;
 
     /** @hidden */
     constructor(exporter: _Exporter) {
@@ -89,12 +64,12 @@ export class KHR_lights_punctual implements IGLTFExporterExtensionV2 {
         return new Promise((resolve, reject) => {
             if (node && babylonNode instanceof ShadowLight) {
                 const babylonLight: ShadowLight = babylonNode;
-                let light: ILight;
+                let light: IKHRLightsPunctual_Light;
 
                 const lightType = (
-                    babylonLight.getTypeID() == Light.LIGHTTYPEID_POINTLIGHT ? LightType.POINT : (
-                        babylonLight.getTypeID() == Light.LIGHTTYPEID_DIRECTIONALLIGHT ? LightType.DIRECTIONAL : (
-                            babylonLight.getTypeID() == Light.LIGHTTYPEID_SPOTLIGHT ? LightType.SPOT : null
+                    babylonLight.getTypeID() == Light.LIGHTTYPEID_POINTLIGHT ? IKHRLightsPunctual_LightType.POINT : (
+                        babylonLight.getTypeID() == Light.LIGHTTYPEID_DIRECTIONALLIGHT ? IKHRLightsPunctual_LightType.DIRECTIONAL : (
+                            babylonLight.getTypeID() == Light.LIGHTTYPEID_SPOTLIGHT ? IKHRLightsPunctual_LightType.SPOT : null
                         )));
                 if (lightType == null) {
                     Logger.Warn(`${context}: Light ${babylonLight.name} is not supported in ${NAME}`);
@@ -108,7 +83,7 @@ export class KHR_lights_punctual implements IGLTFExporterExtensionV2 {
                         }
                         node.translation = lightPosition.asArray();
                     }
-                    if (lightType !== LightType.POINT) {
+                    if (lightType !== IKHRLightsPunctual_LightType.POINT) {
                         const localAxis = babylonLight.direction;
                         const yaw = -Math.atan2(localAxis.z * (this._exporter._babylonScene.useRightHandedSystem ? -1 : 1), localAxis.x) + Math.PI / 2;
                         const len = Math.sqrt(localAxis.x * localAxis.x + localAxis.z * localAxis.z);
@@ -138,7 +113,7 @@ export class KHR_lights_punctual implements IGLTFExporterExtensionV2 {
                         light.range = babylonLight.range;
                     }
 
-                    if (lightType === LightType.SPOT) {
+                    if (lightType === IKHRLightsPunctual_LightType.SPOT) {
                         const babylonSpotLight = babylonLight as SpotLight;
                         if (babylonSpotLight.angle !== Math.PI / 2.0) {
                             if (light.spot == null) {
@@ -162,7 +137,7 @@ export class KHR_lights_punctual implements IGLTFExporterExtensionV2 {
 
                     this._lights.lights.push(light);
 
-                    const lightReference: ILightReference = {
+                    const lightReference: IKHRLightsPunctual_LightReference = {
                         light: this._lights.lights.length - 1
                     };
 

serializers/src/glTF/2.0/Extensions/KHR_materials_sheen.ts

@@ -6,15 +6,10 @@ import { PBRMaterial } from 'babylonjs/Materials/PBR/pbrMaterial';
 import { Texture } from 'babylonjs/Materials/Textures/texture';
 import { BaseTexture } from 'babylonjs/Materials/Textures/baseTexture';
 import { Nullable } from 'babylonjs/types';
+import { IKHRMaterialsSheen } from 'babylonjs-gltf2interface';
 
 const NAME = "KHR_materials_sheen";
 
-interface IKHR_materials_sheen {
-    intensityFactor: number;
-    colorFactor: number[];
-    colorIntensityTexture?: ITextureInfo;
-}
-
 /**
  * @hidden
  */
@@ -89,16 +84,16 @@ export class KHR_materials_sheen implements IGLTFExporterExtensionV2 {
                 if (node.extensions == null) {
                     node.extensions = {};
                 }
-                const sheenInfo: IKHR_materials_sheen = {
-                    colorFactor: babylonMaterial.sheen.color.asArray(),
-                    intensityFactor: babylonMaterial.sheen.intensity
+                const sheenInfo: IKHRMaterialsSheen = {
+                    sheenColorFactor: babylonMaterial.sheen.color.asArray(),
+                    sheenRoughnessFactor: babylonMaterial.sheen.roughness ?? 0
                 };
 
                 if (babylonMaterial.sheen.texture) {
                     let textureIndex = this._getTextureIndex(babylonMaterial.sheen.texture);
 
                     if (textureIndex > -1) {
-                        sheenInfo.colorIntensityTexture = this._textureInfos[textureIndex] ;
+                        sheenInfo.sheenTexture = this._textureInfos[textureIndex] ;
                     }
                 }
 

serializers/src/glTF/2.0/Extensions/KHR_texture_transform.ts

@@ -6,23 +6,13 @@ import { Scene } from "babylonjs/scene";
 
 import { IGLTFExporterExtensionV2 } from "../glTFExporterExtension";
 import { _Exporter } from "../glTFExporter";
+import { IKHRTextureTransform } from 'babylonjs-gltf2interface';
 
 const NAME = "KHR_texture_transform";
 
 import "../shaders/textureTransform.fragment";
 
 /**
- * Interface for handling KHR texture transform
- * @hidden
- */
-interface IKHRTextureTransform {
-    offset?: number[];
-    rotation?: number;
-    scale?: number[];
-    texCoord?: number;
-}
-
-/**
  * @hidden
  */
 export class KHR_texture_transform implements IGLTFExporterExtensionV2 {