Allow loaders without scene loader and add events to glTF loader

loaders/src/OBJ/babylon.objFileLoader.ts

@@ -867,6 +867,9 @@ module BABYLON {
         }
 
     }
-    //Add this loader into the register plugin
-    BABYLON.SceneLoader.RegisterPlugin(new OBJFileLoader());
+
+    if (BABYLON.SceneLoader) {
+        //Add this loader into the register plugin
+        BABYLON.SceneLoader.RegisterPlugin(new OBJFileLoader());
+    }
 }

loaders/src/STL/babylon.stlFileLoader.ts

@@ -191,5 +191,7 @@ module BABYLON {
         }
     }
 
-    BABYLON.SceneLoader.RegisterPlugin(new STLFileLoader());
+    if (BABYLON.SceneLoader) {
+        BABYLON.SceneLoader.RegisterPlugin(new STLFileLoader());
+    }
 }

loaders/src/glTF/1.0/babylon.glTFLoader.ts

@@ -1731,5 +1731,5 @@ module BABYLON.GLTF1 {
         }
     };
 
-    BABYLON.GLTFFileLoader.GLTFLoaderV1 = new GLTFLoader();
+    BABYLON.GLTFFileLoader.CreateGLTFLoaderV1 = () => new GLTFLoader();
 }

loaders/src/glTF/2.0/babylon.glTFLoader.ts

@@ -2,6 +2,7 @@
 
 module BABYLON.GLTF2 {
     export class GLTFLoader implements IGLTFLoader {
+        private _parent: GLTFFileLoader;
         private _gltf: IGLTF;
         private _errors: string[];
         private _babylonScene: Scene;
@@ -40,6 +41,10 @@ module BABYLON.GLTF2 {
             return this._babylonScene;
         }
 
+        public constructor(parent: GLTFFileLoader) {
+            this._parent = parent;
+        }
+
         public importMeshAsync(meshesNames: any, scene: Scene, data: IGLTFLoaderData, rootUrl: string, onSuccess: (meshes: AbstractMesh[], particleSystems: ParticleSystem[], skeletons: Skeleton[]) => void, onError: () => void): void {
             this._loadAsync(meshesNames, scene, data, rootUrl, () => {
                 var meshes = [];
@@ -106,6 +111,8 @@ module BABYLON.GLTF2 {
             this._errors.forEach(error => Tools.Error(error));
             this._errors = [];
             this._clear();
+
+            this._parent.onComplete();
         }
 
         private _loadData(data: IGLTFLoaderData): void {
@@ -346,10 +353,12 @@ module BABYLON.GLTF2 {
                             if (this._renderReady) {
                                 babylonSubMaterial.forceCompilation(babylonMesh, babylonSubMaterial => {
                                     babylonMultiMaterial.subMaterials[i] = babylonSubMaterial;
+                                    this._parent.onMaterialLoaded(babylonSubMaterial);
                                 });
                             }
                             else {
                                 babylonMultiMaterial.subMaterials[i] = babylonSubMaterial;
+                                this._parent.onMaterialLoaded(babylonSubMaterial);
                             }
                         });
                     }
@@ -360,7 +369,8 @@ module BABYLON.GLTF2 {
                         // TODO: optimize this so that sub meshes can be created without being overwritten after setting vertex data.
                         // Sub meshes must be cleared and created after setting vertex data because of mesh._createGlobalSubMesh.
                         babylonMesh.subMeshes = [];
-                        subMeshInfos.forEach(info => new SubMesh(info.materialIndex, info.verticesStart, info.verticesCount, info.indicesStart, info.indicesCount, babylonMesh));                    }
+                        subMeshInfos.forEach(info => new SubMesh(info.materialIndex, info.verticesStart, info.verticesCount, info.indicesStart, info.indicesCount, babylonMesh));
+                    }
                 });
             }
         }
@@ -977,15 +987,16 @@ module BABYLON.GLTF2 {
             babylonTexture.coordinatesIndex = texCoord;
             babylonTexture.wrapU = GLTFUtils.GetWrapMode(sampler.wrapS);
             babylonTexture.wrapV = GLTFUtils.GetWrapMode(sampler.wrapT);
-            babylonTexture.name = texture.name;
+            babylonTexture.name = texture.name || "texture" + textureInfo.index;
 
             // Cache the texture
             texture.babylonTextures = texture.babylonTextures || [];
             texture.babylonTextures[texCoord] = babylonTexture;
 
+            this._parent.onTextureLoaded(babylonTexture);
             return babylonTexture;
         }
     }
 
-    BABYLON.GLTFFileLoader.GLTFLoaderV2 = new GLTFLoader();
+    BABYLON.GLTFFileLoader.CreateGLTFLoaderV2 = parent => new GLTFLoader(parent);
 }

loaders/src/glTF/babylon.glTFFileLoader.ts

@@ -7,17 +7,23 @@ module BABYLON {
     }
 
     export interface IGLTFLoader {
-        importMeshAsync: (meshesNames: any, scene: Scene, data: IGLTFLoaderData, rootUrl: string, onsuccess: (meshes: AbstractMesh[], particleSystems: ParticleSystem[], skeletons: Skeleton[]) => void, onerror: () => void) => void;
-        loadAsync: (scene: Scene, data: IGLTFLoaderData, rootUrl: string, onsuccess: () => void, onerror: () => void) => void;
+        importMeshAsync: (meshesNames: any, scene: Scene, data: IGLTFLoaderData, rootUrl: string, onSuccess: (meshes: AbstractMesh[], particleSystems: ParticleSystem[], skeletons: Skeleton[]) => void, onError: () => void) => void;
+        loadAsync: (scene: Scene, data: IGLTFLoaderData, rootUrl: string, onSuccess: () => void, onError: () => void) => void;
     }
 
     export class GLTFFileLoader implements ISceneLoaderPluginAsync {
-        public static GLTFLoaderV1: IGLTFLoader = null;
-        public static GLTFLoaderV2: IGLTFLoader = null;
+        public static CreateGLTFLoaderV1: (parent: GLTFFileLoader) => IGLTFLoader;
+        public static CreateGLTFLoaderV2: (parent: GLTFFileLoader) => IGLTFLoader;
 
+        // V1 options
         public static HomogeneousCoordinates: boolean = false;
         public static IncrementalLoading: boolean = true;
 
+        // V2 options
+        public onTextureLoaded: (texture: BaseTexture) => void;
+        public onMaterialLoaded: (material: Material) => void;
+        public onComplete: () => void;
+
         public extensions: ISceneLoaderPluginExtensions = {
             ".gltf": { isBinary: false },
             ".glb": { isBinary: true }
@@ -79,19 +85,14 @@ module BABYLON {
                 }
             }
 
-            var loaders = {
-                1: GLTFFileLoader.GLTFLoaderV1,
-                2: GLTFFileLoader.GLTFLoaderV2
+            var createLoader = {
+                1: GLTFFileLoader.CreateGLTFLoaderV1,
+                2: GLTFFileLoader.CreateGLTFLoaderV2
             };
 
-            var loader = loaders[version.major];
-            if (loader === undefined) {
-                Tools.Error("Unsupported version");
-                return null;
-            }
-
+            var loader = createLoader[version.major](this);
             if (loader === null) {
-                Tools.Error("v" + version.major + " loader is not available");
+                Tools.Error("Unsupported version");
                 return null;
             }
 
@@ -279,5 +280,7 @@ module BABYLON {
         }
     }
 
-    BABYLON.SceneLoader.RegisterPlugin(new GLTFFileLoader());
+    if (BABYLON.SceneLoader) {
+        BABYLON.SceneLoader.RegisterPlugin(new GLTFFileLoader());
+    }
 }