Rationalize interface names

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

@@ -911,12 +911,12 @@ declare module BABYLON.GLTF2 {
      */
 
     /** @hidden */
-    interface ILightReferenceImageBased {
+    interface IEXTLightsImageBased_LightReferenceImageBased {
         light: number;
     }
 
     /** @hidden */
-    interface ILightImageBased extends IChildRootProperty {
+    interface IEXTLightsImageBased_LightImageBased extends IChildRootProperty {
         intensity: number;
         rotation: number[];
         specularImageSize: number;
@@ -925,8 +925,8 @@ declare module BABYLON.GLTF2 {
     }
 
     /** @hidden */
-    interface ILightsImageBased {
-        lights: ILightImageBased[];
+    interface IEXTLightsImageBased {
+        lights: IEXTLightsImageBased_LightImageBased[];
     }
 
     /**
@@ -955,20 +955,20 @@ declare module BABYLON.GLTF2 {
      */
 
     /** @hidden */
-    enum LightType {
+    enum IKHRLightsPunctual_LightType {
         DIRECTIONAL = "directional",
         POINT = "point",
         SPOT = "spot"
     }
 
     /** @hidden */
-    interface ILightReference {
+    interface IKHRLightsPunctual_LightReference {
         light: number;
     }
 
     /** @hidden */
-    interface ILight extends IChildRootProperty {
-        type: LightType;
+    interface IKHRLightsPunctual_Light extends IChildRootProperty {
+        type: IKHRLightsPunctual_LightType;
         color?: number[];
         intensity?: number;
         range?: number;
@@ -979,8 +979,8 @@ declare module BABYLON.GLTF2 {
     }
 
     /** @hidden */
-    interface ILights {
-        lights: ILight[];
+    interface IKHRLightsPunctual {
+        lights: IKHRLightsPunctual_Light[];
     }
 
     /**
@@ -989,7 +989,7 @@ declare module BABYLON.GLTF2 {
      */
 
     /** @hidden */
-    interface IKHR_materials_clearcoat {
+    interface IKHRMaterialsClearcoat {
         clearcoatFactor: number;
         clearcoatTexture: ITextureInfo;
         clearcoatRoughnessFactor: number;
@@ -1003,7 +1003,7 @@ declare module BABYLON.GLTF2 {
      */
 
     /** @hidden */
-    interface IKHR_materials_ior {
+    interface IKHRMaterialsIor {
         ior: number;
     }
 
@@ -1026,7 +1026,7 @@ declare module BABYLON.GLTF2 {
      */
 
     /** @hidden */
-    interface IKHR_materials_sheen {
+    interface IKHRMaterialsSheen {
         sheenColorFactor?: number[];
         sheenTexture?: ITextureInfo;
         sheenRoughnessFactor?: number;
@@ -1038,7 +1038,7 @@ declare module BABYLON.GLTF2 {
      */
 
     /** @hidden */
-    interface IKHR_materials_specular {
+    interface IKHRMaterialsSpecular {
         specularFactor: number;
         specularColorFactor: number[];
         specularTexture: ITextureInfo;
@@ -1050,7 +1050,7 @@ declare module BABYLON.GLTF2 {
      */
 
     /** @hidden */
-    interface IMaterialsTransmission {
+    interface IKHRMaterialsTransmission {
         transmissionFactor?: number;
         transmissionTexture?: ITextureInfo;
     }
@@ -1061,14 +1061,14 @@ declare module BABYLON.GLTF2 {
      */
 
     /** @hidden */
-    interface IKHRMaterialVariantsMapping {
+    interface IKHRMaterialVariants_Mapping {
         tags: string[];
         material: number;
     }
 
     /** @hidden */
     interface IKHRMaterialVariants {
-        mapping: IKHRMaterialVariantsMapping[];
+        mapping: IKHRMaterialVariants_Mapping[];
     }
 
     /**
@@ -1099,17 +1099,17 @@ declare module BABYLON.GLTF2 {
      */
 
     /** @hidden */
-    interface IKHR_xmp_data {
+    interface IKHRXmp_Data {
         [key: string]: unknown;
     }
 
     /** @hidden */
-    interface IKHR_xmp_gltf {
-        packets: IKHR_xmp_data[];
+    interface IKHRXmp_Gltf {
+        packets: IKHRXmp_Data[];
     }
 
     /** @hidden */
-    interface IKHR_xmp_node {
+    interface IKHRXmp_Node {
         packet: number;
     }
 
@@ -1118,27 +1118,27 @@ declare module BABYLON.GLTF2 {
      */
 
     /** @hidden */
-    interface IClipReference {
+    interface IMSFTAudioEmitter_ClipReference {
         clip: number;
         weight?: number;
     }
 
     /** @hidden */
-    interface IEmittersReference {
+    interface IMSFTAudioEmitter_EmittersReference {
         emitters: number[];
     }
 
     /** @hidden */
-    const enum DistanceModel {
+    const enum IMSFTAudioEmitter_DistanceModel {
         linear = "linear",
         inverse = "inverse",
         exponential = "exponential",
     }
 
     /** @hidden */
-    interface IEmitter {
+    interface IMSFTAudioEmitter_Emitter {
         name?: string;
-        distanceModel?: DistanceModel;
+        distanceModel?: IMSFTAudioEmitter_DistanceModel;
         refDistance?: number;
         maxDistance?: number;
         rolloffFactor?: number;
@@ -1146,31 +1146,31 @@ declare module BABYLON.GLTF2 {
         outerAngle?: number;
         loop?: boolean;
         volume?: number;
-        clips: IClipReference[];
+        clips: IMSFTAudioEmitter_ClipReference[];
     }
 
     /** @hidden */
-    const enum AudioMimeType {
+    const enum IMSFTAudioEmitter_AudioMimeType {
         WAV = "audio/wav",
     }
 
     /** @hidden */
-    interface IClip extends IProperty {
+    interface IMSFTAudioEmitter_Clip extends IProperty {
         uri?: string;
         bufferView?: number;
-        mimeType?: AudioMimeType;
+        mimeType?: IMSFTAudioEmitter_AudioMimeType;
     }
 
     /** @hidden */
-    const enum AnimationEventAction {
+    const enum IMSFTAudioEmitter_AnimationEventAction {
         play = "play",
         pause = "pause",
         stop = "stop",
     }
 
     /** @hidden */
-    interface IAnimationEvent {
-        action: AnimationEventAction;
+    interface IMSFTAudioEmitter_AnimationEvent {
+        action: IMSFTAudioEmitter_AnimationEventAction;
         emitter: number;
         time: number;
         startOffset?: number;

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

@@ -5,7 +5,7 @@ import { Quaternion, Matrix } from "babylonjs/Maths/math.vector";
 import { BaseTexture } from "babylonjs/Materials/Textures/baseTexture";
 import { RawCubeTexture } from "babylonjs/Materials/Textures/rawCubeTexture";
 
-import { ILightReferenceImageBased, ILightImageBased, ILightsImageBased } 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";
@@ -14,7 +14,7 @@ const NAME = "EXT_lights_image_based";
 
 declare module "babylonjs-gltf2interface" {
     /** @hidden */
-    interface ILightImageBased {
+    interface IEXTLightsImageBased_LightImageBased {
         _babylonTexture?: BaseTexture;
         _loaded?: Promise<void>;
     }
@@ -35,7 +35,7 @@ export class EXT_lights_image_based implements IGLTFLoaderExtension {
     public enabled: boolean;
 
     private _loader: GLTFLoader;
-    private _lights?: ILightImageBased[];
+    private _lights?: IEXTLightsImageBased_LightImageBased[];
 
     /** @hidden */
     constructor(loader: GLTFLoader) {
@@ -53,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 ILightsImageBased;
+            const extension = extensions[this.name] as IEXTLightsImageBased;
             this._lights = extension.lights;
         }
     }
 
     /** @hidden */
     public loadSceneAsync(context: string, scene: IScene): Nullable<Promise<void>> {
-        return GLTFLoader.LoadExtensionAsync<ILightReferenceImageBased>(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));
@@ -78,7 +78,7 @@ export class EXT_lights_image_based implements IGLTFLoaderExtension {
         });
     }
 
-    private _loadLightAsync(context: string, light: ILightImageBased): 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/KHR_lights_punctual.ts

@@ -7,7 +7,7 @@ import { SpotLight } from "babylonjs/Lights/spotLight";
 import { Light } from "babylonjs/Lights/light";
 import { TransformNode } from "babylonjs/Meshes/transformNode";
 
-import { LightType, ILightReference, ILight, ILights } 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";
@@ -29,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) {
@@ -47,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;
 
@@ -64,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

@@ -5,7 +5,7 @@ import { Material } from "babylonjs/Materials/material";
 import { IMaterial } from "../glTFLoaderInterfaces";
 import { IGLTFLoaderExtension } from "../glTFLoaderExtension";
 import { GLTFLoader } from "../glTFLoader";
-import { IKHR_materials_clearcoat } from 'babylonjs-gltf2interface';
+import { IKHRMaterialsClearcoat } from 'babylonjs-gltf2interface';
 
 const NAME = "KHR_materials_clearcoat";
 
@@ -45,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));
@@ -53,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,7 +5,7 @@ import { Material } from "babylonjs/Materials/material";
 import { IMaterial } from "../glTFLoaderInterfaces";
 import { IGLTFLoaderExtension } from "../glTFLoaderExtension";
 import { GLTFLoader } from "../glTFLoader";
-import { IKHR_materials_ior } from 'babylonjs-gltf2interface';
+import { IKHRMaterialsIor } from 'babylonjs-gltf2interface';
 
 const NAME = "KHR_materials_ior";
 
@@ -49,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));
@@ -57,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_sheen.ts

@@ -6,7 +6,7 @@ import { IMaterial } from "../glTFLoaderInterfaces";
 import { IGLTFLoaderExtension } from "../glTFLoaderExtension";
 import { GLTFLoader } from "../glTFLoader";
 import { Color3 } from 'babylonjs/Maths/math.color';
-import { IKHR_materials_sheen } from 'babylonjs-gltf2interface';
+import { IKHRMaterialsSheen } from 'babylonjs-gltf2interface';
 
 const NAME = "KHR_materials_sheen";
 
@@ -46,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));
@@ -54,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

@@ -6,7 +6,7 @@ import { IMaterial } from "../glTFLoaderInterfaces";
 import { IGLTFLoaderExtension } from "../glTFLoaderExtension";
 import { GLTFLoader } from "../glTFLoader";
 import { Color3 } from 'babylonjs/Maths/math.color';
-import { IKHR_materials_specular } from 'babylonjs-gltf2interface';
+import { IKHRMaterialsSpecular } from 'babylonjs-gltf2interface';
 
 const NAME = "KHR_materials_specular";
 
@@ -45,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));
@@ -53,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

@@ -5,7 +5,7 @@ import { BaseTexture } from "babylonjs/Materials/Textures/baseTexture";
 import { IMaterial } from "../glTFLoaderInterfaces";
 import { IGLTFLoaderExtension } from "../glTFLoaderExtension";
 import { GLTFLoader } from "../glTFLoader";
-import { IMaterialsTransmission } from 'babylonjs-gltf2interface';
+import { IKHRMaterialsTransmission } from 'babylonjs-gltf2interface';
 
 const NAME = "KHR_materials_transmission";
 
@@ -47,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));
@@ -57,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_xmp.ts

@@ -1,6 +1,6 @@
 import { IGLTFLoaderExtension } from "../glTFLoaderExtension";
 import { GLTFLoader } from "../glTFLoader";
-import { IKHR_xmp_gltf, IKHR_xmp_node } from 'babylonjs-gltf2interface';
+import { IKHRXmp_Gltf, IKHRXmp_Node } from 'babylonjs-gltf2interface';
 
 const NAME = "KHR_xmp";
 
@@ -41,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,15 +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 { IClip, IEmitter, IEmittersReference, IAnimationEvent, AnimationEventAction } from 'babylonjs-gltf2interface';
+import { IMSFTAudioEmitter_Clip, IMSFTAudioEmitter_Emitter, IMSFTAudioEmitter_EmittersReference, IMSFTAudioEmitter_AnimationEvent, IMSFTAudioEmitter_AnimationEventAction } from 'babylonjs-gltf2interface';
 
 const NAME = "MSFT_audio_emitter";
 
-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>;
@@ -31,7 +31,7 @@ interface IMSFTAudioEmitter {
     emitters: ILoaderEmitter[];
 }
 
-interface ILoaderAnimationEvent extends IAnimationEvent, IArrayItem {
+interface ILoaderAnimationEvent extends IMSFTAudioEmitter_AnimationEvent, IArrayItem {
 }
 
 interface ILoaderAnimationEvents {
@@ -85,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));
@@ -106,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) => {
@@ -215,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();
                 };