Master

dist/preview release/babylon.max.js

@@ -12092,7 +12092,7 @@ var BABYLON;
              * Returns the current version of the framework
              */
             get: function () {
-                return "3.3.0-alpha.6";
+                return "3.3.0-alpha.7";
             },
             enumerable: true,
             configurable: true
@@ -91363,7 +91363,7 @@ var BABYLON;
                 if (_this.rightController && _this.rightController._activePointer) {
                     _this._castRayAndSelectObject(_this.rightController);
                 }
-                if (!(_this.leftController && _this.leftController._activePointer) && !(_this.rightController && _this.rightController._activePointer)) {
+                if (_this._noControllerIsActive) {
                     _this._castRayAndSelectObject(_this._cameraGazer);
                 }
                 else {
@@ -92000,6 +92000,13 @@ var BABYLON;
                 this._interactionsEnabled = true;
             }
         };
+        Object.defineProperty(VRExperienceHelper.prototype, "_noControllerIsActive", {
+            get: function () {
+                return !(this.leftController && this.leftController._activePointer) && !(this.rightController && this.rightController._activePointer);
+            },
+            enumerable: true,
+            configurable: true
+        });
         VRExperienceHelper.prototype._isTeleportationFloor = function (mesh) {
             for (var i = 0; i < this._floorMeshesCollection.length; i++) {
                 if (this._floorMeshesCollection[i].id === mesh.id) {
@@ -92096,13 +92103,17 @@ var BABYLON;
                     });
                 }
                 controller.webVRController.onTriggerStateChangedObservable.add(function (stateObject) {
-                    if (!controller._pointerDownOnMeshAsked) {
+                    var gazer = controller;
+                    if (_this._noControllerIsActive) {
+                        gazer = _this._cameraGazer;
+                    }
+                    if (!gazer._pointerDownOnMeshAsked) {
                         if (stateObject.value > _this._padSensibilityUp) {
-                            controller._selectionPointerDown();
+                            gazer._selectionPointerDown();
                         }
                     }
                     else if (stateObject.value < _this._padSensibilityDown) {
-                        controller._selectionPointerUp();
+                        gazer._selectionPointerUp();
                     }
                 });
             }

dist/preview release/babylon.no-module.max.js

@@ -12059,7 +12059,7 @@ var BABYLON;
              * Returns the current version of the framework
              */
             get: function () {
-                return "3.3.0-alpha.6";
+                return "3.3.0-alpha.7";
             },
             enumerable: true,
             configurable: true
@@ -91330,7 +91330,7 @@ var BABYLON;
                 if (_this.rightController && _this.rightController._activePointer) {
                     _this._castRayAndSelectObject(_this.rightController);
                 }
-                if (!(_this.leftController && _this.leftController._activePointer) && !(_this.rightController && _this.rightController._activePointer)) {
+                if (_this._noControllerIsActive) {
                     _this._castRayAndSelectObject(_this._cameraGazer);
                 }
                 else {
@@ -91967,6 +91967,13 @@ var BABYLON;
                 this._interactionsEnabled = true;
             }
         };
+        Object.defineProperty(VRExperienceHelper.prototype, "_noControllerIsActive", {
+            get: function () {
+                return !(this.leftController && this.leftController._activePointer) && !(this.rightController && this.rightController._activePointer);
+            },
+            enumerable: true,
+            configurable: true
+        });
         VRExperienceHelper.prototype._isTeleportationFloor = function (mesh) {
             for (var i = 0; i < this._floorMeshesCollection.length; i++) {
                 if (this._floorMeshesCollection[i].id === mesh.id) {
@@ -92063,13 +92070,17 @@ var BABYLON;
                     });
                 }
                 controller.webVRController.onTriggerStateChangedObservable.add(function (stateObject) {
-                    if (!controller._pointerDownOnMeshAsked) {
+                    var gazer = controller;
+                    if (_this._noControllerIsActive) {
+                        gazer = _this._cameraGazer;
+                    }
+                    if (!gazer._pointerDownOnMeshAsked) {
                         if (stateObject.value > _this._padSensibilityUp) {
-                            controller._selectionPointerDown();
+                            gazer._selectionPointerDown();
                         }
                     }
                     else if (stateObject.value < _this._padSensibilityDown) {
-                        controller._selectionPointerUp();
+                        gazer._selectionPointerUp();
                     }
                 });
             }

dist/preview release/es6.js

@@ -12059,7 +12059,7 @@ var BABYLON;
              * Returns the current version of the framework
              */
             get: function () {
-                return "3.3.0-alpha.6";
+                return "3.3.0-alpha.7";
             },
             enumerable: true,
             configurable: true
@@ -91330,7 +91330,7 @@ var BABYLON;
                 if (_this.rightController && _this.rightController._activePointer) {
                     _this._castRayAndSelectObject(_this.rightController);
                 }
-                if (!(_this.leftController && _this.leftController._activePointer) && !(_this.rightController && _this.rightController._activePointer)) {
+                if (_this._noControllerIsActive) {
                     _this._castRayAndSelectObject(_this._cameraGazer);
                 }
                 else {
@@ -91967,6 +91967,13 @@ var BABYLON;
                 this._interactionsEnabled = true;
             }
         };
+        Object.defineProperty(VRExperienceHelper.prototype, "_noControllerIsActive", {
+            get: function () {
+                return !(this.leftController && this.leftController._activePointer) && !(this.rightController && this.rightController._activePointer);
+            },
+            enumerable: true,
+            configurable: true
+        });
         VRExperienceHelper.prototype._isTeleportationFloor = function (mesh) {
             for (var i = 0; i < this._floorMeshesCollection.length; i++) {
                 if (this._floorMeshesCollection[i].id === mesh.id) {
@@ -92063,13 +92070,17 @@ var BABYLON;
                     });
                 }
                 controller.webVRController.onTriggerStateChangedObservable.add(function (stateObject) {
-                    if (!controller._pointerDownOnMeshAsked) {
+                    var gazer = controller;
+                    if (_this._noControllerIsActive) {
+                        gazer = _this._cameraGazer;
+                    }
+                    if (!gazer._pointerDownOnMeshAsked) {
                         if (stateObject.value > _this._padSensibilityUp) {
-                            controller._selectionPointerDown();
+                            gazer._selectionPointerDown();
                         }
                     }
                     else if (stateObject.value < _this._padSensibilityDown) {
-                        controller._selectionPointerUp();
+                        gazer._selectionPointerUp();
                     }
                 });
             }

dist/preview release/glTF2Interface/package.json

@@ -1,7 +1,7 @@
 {
     "name": "babylonjs-gltf2interface",
     "description": "A typescript declaration of babylon's gltf2 inteface.",
-    "version": "3.3.0-alpha.6",
+    "version": "3.3.0-alpha.7",
     "repository": {
         "type": "git",
         "url": "https://github.com/BabylonJS/Babylon.js.git"

dist/preview release/gui/package.json

@@ -4,7 +4,7 @@
     },
     "name": "babylonjs-gui",
     "description": "The Babylon.js GUI library is an extension you can use to generate interactive user interface. It is build on top of the DynamicTexture.",
-    "version": "3.3.0-alpha.6",
+    "version": "3.3.0-alpha.7",
     "repository": {
         "type": "git",
         "url": "https://github.com/BabylonJS/Babylon.js.git"

dist/preview release/inspector/package.json

@@ -4,7 +4,7 @@
     },
     "name": "babylonjs-inspector",
     "description": "The Babylon.js inspector.",
-    "version": "3.3.0-alpha.6",
+    "version": "3.3.0-alpha.7",
     "repository": {
         "type": "git",
         "url": "https://github.com/BabylonJS/Babylon.js.git"

dist/preview release/loaders/babylon.glTF2FileLoader.d.ts

@@ -512,6 +512,7 @@ declare module BABYLON.GLTF2 {
         private _getDefaultMaterial(drawMode);
         private _loadMaterialMetallicRoughnessPropertiesAsync(context, material, babylonMaterial);
         _loadMaterialAsync(context: string, material: _ILoaderMaterial, mesh: _ILoaderMesh, babylonMesh: Mesh, babylonDrawMode: number, assign: (babylonMaterial: Material) => void): Promise<void>;
+        _loadMaterialPropertiesAsync(context: string, material: _ILoaderMaterial, babylonMaterial: Material): Promise<void>;
         _createMaterial(name: string, drawMode: number): PBRMaterial;
         _loadMaterialBasePropertiesAsync(context: string, material: _ILoaderMaterial, babylonMaterial: PBRMaterial): Promise<void>;
         _loadMaterialAlphaProperties(context: string, material: _ILoaderMaterial, babylonMaterial: PBRMaterial): void;
@@ -578,6 +579,11 @@ declare module BABYLON.GLTF2 {
          */
         protected _loadMaterialAsync(context: string, material: _ILoaderMaterial, mesh: _ILoaderMesh, babylonMesh: Mesh, babylonDrawMode: number, assign: (babylonMaterial: Material) => void): Nullable<Promise<void>>;
         /**
+         * Override this method to modify the default behavior for loading material properties.
+         * @hidden
+         */
+        protected _loadMaterialPropertiesAsync(context: string, material: _ILoaderMaterial, babylonMaterial: Material): Nullable<Promise<void>>;
+        /**
          * Override this method to modify the default behavior for loading textures.
          * @hidden
          */
@@ -618,6 +624,11 @@ declare module BABYLON.GLTF2 {
          */
         static _LoadMaterialAsync(loader: GLTFLoader, context: string, material: _ILoaderMaterial, mesh: _ILoaderMesh, babylonMesh: Mesh, babylonDrawMode: number, assign: (babylonMaterial: Material) => void): Nullable<Promise<void>>;
         /**
+         * Helper method called by the loader to allow extensions to override loading material properties.
+         * @hidden
+         */
+        static _LoadMaterialPropertiesAsync(loader: GLTFLoader, context: string, material: _ILoaderMaterial, babylonMaterial: Material): Nullable<Promise<void>>;
+        /**
          * Helper method called by the loader to allow extensions to override loading textures.
          * @hidden
          */
@@ -673,6 +684,7 @@ declare module BABYLON.GLTF2.Extensions {
          * Gets an array of LOD properties from lowest to highest.
          */
         private _getLODs<T>(context, property, array, ids);
+        private _disposeUnusedMaterials();
     }
 }
 
@@ -715,7 +727,7 @@ declare module BABYLON.GLTF2.Extensions {
      */
     class KHR_materials_pbrSpecularGlossiness extends GLTFLoaderExtension {
         readonly name: string;
-        protected _loadMaterialAsync(context: string, material: _ILoaderMaterial, mesh: _ILoaderMesh, babylonMesh: Mesh, babylonDrawMode: number, assign: (babylonMaterial: Material) => void): Nullable<Promise<void>>;
+        protected _loadMaterialPropertiesAsync(context: string, material: _ILoaderMaterial, babylonMaterial: Material): Nullable<Promise<void>>;
         private _loadSpecularGlossinessPropertiesAsync(context, material, properties, babylonMaterial);
     }
 }
@@ -727,7 +739,7 @@ declare module BABYLON.GLTF2.Extensions {
      */
     class KHR_materials_unlit extends GLTFLoaderExtension {
         readonly name: string;
-        protected _loadMaterialAsync(context: string, material: _ILoaderMaterial, mesh: _ILoaderMesh, babylonMesh: Mesh, babylonDrawMode: number, assign: (babylonMaterial: Material) => void): Nullable<Promise<void>>;
+        protected _loadMaterialPropertiesAsync(context: string, material: _ILoaderMaterial, babylonMaterial: Material): Nullable<Promise<void>>;
         private _loadUnlitPropertiesAsync(context, material, babylonMaterial);
     }
 }

dist/preview release/loaders/babylon.glTF2FileLoader.js

@@ -1771,25 +1771,38 @@ var BABYLON;
                 material._babylonData = material._babylonData || {};
                 var babylonData = material._babylonData[babylonDrawMode];
                 if (!babylonData) {
-                    var promises = new Array();
                     this._parent._logOpen(context + " " + (material.name || ""));
-                    var name_4 = material.name || "material_" + material._index;
+                    var name_4 = material.name || "material" + material._index;
                     var babylonMaterial = this._createMaterial(name_4, babylonDrawMode);
-                    promises.push(this._loadMaterialBasePropertiesAsync(context, material, babylonMaterial));
-                    promises.push(this._loadMaterialMetallicRoughnessPropertiesAsync(context, material, babylonMaterial));
-                    this._parent.onMaterialLoadedObservable.notifyObservers(babylonMaterial);
                     babylonData = {
                         material: babylonMaterial,
                         meshes: [],
-                        loaded: Promise.all(promises).then(function () { })
+                        loaded: this._loadMaterialPropertiesAsync(context, material, babylonMaterial)
                     };
                     material._babylonData[babylonDrawMode] = babylonData;
+                    this._parent.onMaterialLoadedObservable.notifyObservers(babylonMaterial);
                     this._parent._logClose();
                 }
                 babylonData.meshes.push(babylonMesh);
+                babylonMesh.onDisposeObservable.addOnce(function () {
+                    var index = babylonData.meshes.indexOf(babylonMesh);
+                    if (index !== -1) {
+                        babylonData.meshes.splice(index, 1);
+                    }
+                });
                 assign(babylonData.material);
                 return babylonData.loaded;
             };
+            GLTFLoader.prototype._loadMaterialPropertiesAsync = function (context, material, babylonMaterial) {
+                var promise = GLTF2.GLTFLoaderExtension._LoadMaterialPropertiesAsync(this, context, material, babylonMaterial);
+                if (promise) {
+                    return promise;
+                }
+                var promises = new Array();
+                promises.push(this._loadMaterialBasePropertiesAsync(context, material, babylonMaterial));
+                promises.push(this._loadMaterialMetallicRoughnessPropertiesAsync(context, material, babylonMaterial));
+                return Promise.all(promises).then(function () { });
+            };
             GLTFLoader.prototype._createMaterial = function (name, drawMode) {
                 var babylonMaterial = new BABYLON.PBRMaterial(name, this._babylonScene);
                 babylonMaterial.sideOrientation = this._babylonScene.useRightHandedSystem ? BABYLON.Material.CounterClockWiseSideOrientation : BABYLON.Material.ClockWiseSideOrientation;
@@ -2213,6 +2226,11 @@ var BABYLON;
              */
             GLTFLoaderExtension.prototype._loadMaterialAsync = function (context, material, mesh, babylonMesh, babylonDrawMode, assign) { return null; };
             /**
+             * Override this method to modify the default behavior for loading material properties.
+             * @hidden
+             */
+            GLTFLoaderExtension.prototype._loadMaterialPropertiesAsync = function (context, material, babylonMaterial) { return null; };
+            /**
              * Override this method to modify the default behavior for loading textures.
              * @hidden
              */
@@ -2298,6 +2316,13 @@ var BABYLON;
                 return loader._applyExtensions(function (extension) { return extension._loadMaterialAsync(context, material, mesh, babylonMesh, babylonDrawMode, assign); });
             };
             /**
+             * Helper method called by the loader to allow extensions to override loading material properties.
+             * @hidden
+             */
+            GLTFLoaderExtension._LoadMaterialPropertiesAsync = function (loader, context, material, babylonMaterial) {
+                return loader._applyExtensions(function (extension) { return extension._loadMaterialPropertiesAsync(context, material, babylonMaterial); });
+            };
+            /**
              * Helper method called by the loader to allow extensions to override loading textures.
              * @hidden
              */
@@ -2432,8 +2457,9 @@ var BABYLON;
                                 if (indexLOD !== 0) {
                                     var previousNodeLOD = nodeLODs[indexLOD - 1];
                                     if (previousNodeLOD._babylonMesh) {
-                                        previousNodeLOD._babylonMesh.dispose(false, true);
+                                        previousNodeLOD._babylonMesh.dispose();
                                         delete previousNodeLOD._babylonMesh;
+                                        _this._disposeUnusedMaterials();
                                     }
                                 }
                             });
@@ -2533,6 +2559,23 @@ var BABYLON;
                     properties.push(property);
                     return properties;
                 };
+                MSFT_lod.prototype._disposeUnusedMaterials = function () {
+                    var materials = this._loader._gltf.materials;
+                    if (materials) {
+                        for (var _i = 0, materials_1 = materials; _i < materials_1.length; _i++) {
+                            var material = materials_1[_i];
+                            if (material._babylonData) {
+                                for (var drawMode in material._babylonData) {
+                                    var babylonData = material._babylonData[drawMode];
+                                    if (babylonData.meshes.length === 0) {
+                                        babylonData.material.dispose(false, true);
+                                        delete material._babylonData[drawMode];
+                                    }
+                                }
+                            }
+                        }
+                    }
+                };
                 return MSFT_lod;
             }(GLTF2.GLTFLoaderExtension));
             Extensions.MSFT_lod = MSFT_lod;
@@ -2777,28 +2820,13 @@ var BABYLON;
                     _this.name = NAME;
                     return _this;
                 }
-                KHR_materials_pbrSpecularGlossiness.prototype._loadMaterialAsync = function (context, material, mesh, babylonMesh, babylonDrawMode, assign) {
+                KHR_materials_pbrSpecularGlossiness.prototype._loadMaterialPropertiesAsync = function (context, material, babylonMaterial) {
                     var _this = this;
                     return this._loadExtensionAsync(context, material, function (extensionContext, extension) {
-                        material._babylonData = material._babylonData || {};
-                        var babylonData = material._babylonData[babylonDrawMode];
-                        if (!babylonData) {
-                            var promises = new Array();
-                            var name_1 = material.name || "materialSG_" + material._index;
-                            var babylonMaterial = _this._loader._createMaterial(name_1, babylonDrawMode);
-                            promises.push(_this._loader._loadMaterialBasePropertiesAsync(context, material, babylonMaterial));
-                            promises.push(_this._loadSpecularGlossinessPropertiesAsync(extensionContext, material, extension, babylonMaterial));
-                            _this._loader._parent.onMaterialLoadedObservable.notifyObservers(babylonMaterial);
-                            babylonData = {
-                                material: babylonMaterial,
-                                meshes: [],
-                                loaded: Promise.all(promises).then(function () { })
-                            };
-                            material._babylonData[babylonDrawMode] = babylonData;
-                        }
-                        babylonData.meshes.push(babylonMesh);
-                        assign(babylonData.material);
-                        return babylonData.loaded;
+                        var promises = new Array();
+                        promises.push(_this._loader._loadMaterialBasePropertiesAsync(context, material, babylonMaterial));
+                        promises.push(_this._loadSpecularGlossinessPropertiesAsync(extensionContext, material, extension, babylonMaterial));
+                        return Promise.all(promises).then(function () { });
                     });
                 };
                 KHR_materials_pbrSpecularGlossiness.prototype._loadSpecularGlossinessPropertiesAsync = function (context, material, properties, babylonMaterial) {
@@ -2865,31 +2893,15 @@ var BABYLON;
                     _this.name = NAME;
                     return _this;
                 }
-                KHR_materials_unlit.prototype._loadMaterialAsync = function (context, material, mesh, babylonMesh, babylonDrawMode, assign) {
+                KHR_materials_unlit.prototype._loadMaterialPropertiesAsync = function (context, material, babylonMaterial) {
                     var _this = this;
                     return this._loadExtensionAsync(context, material, function () {
-                        material._babylonData = material._babylonData || {};
-                        var babylonData = material._babylonData[babylonDrawMode];
-                        if (!babylonData) {
-                            var name_1 = material.name || "materialUnlit_" + material._index;
-                            var babylonMaterial = _this._loader._createMaterial(name_1, babylonDrawMode);
-                            babylonMaterial.unlit = true;
-                            var promise = _this._loadUnlitPropertiesAsync(context, material, babylonMaterial);
-                            _this._loader._parent.onMaterialLoadedObservable.notifyObservers(babylonMaterial);
-                            babylonData = {
-                                material: babylonMaterial,
-                                meshes: [],
-                                loaded: promise
-                            };
-                            material._babylonData[babylonDrawMode] = babylonData;
-                        }
-                        babylonData.meshes.push(babylonMesh);
-                        assign(babylonData.material);
-                        return babylonData.loaded;
+                        return _this._loadUnlitPropertiesAsync(context, material, babylonMaterial);
                     });
                 };
                 KHR_materials_unlit.prototype._loadUnlitPropertiesAsync = function (context, material, babylonMaterial) {
                     var promises = new Array();
+                    babylonMaterial.unlit = true;
                     // Ensure metallic workflow
                     babylonMaterial.metallic = 1;
                     babylonMaterial.roughness = 1;

dist/preview release/loaders/babylon.glTFFileLoader.d.ts

@@ -1074,6 +1074,7 @@ declare module BABYLON.GLTF2 {
         private _getDefaultMaterial(drawMode);
         private _loadMaterialMetallicRoughnessPropertiesAsync(context, material, babylonMaterial);
         _loadMaterialAsync(context: string, material: _ILoaderMaterial, mesh: _ILoaderMesh, babylonMesh: Mesh, babylonDrawMode: number, assign: (babylonMaterial: Material) => void): Promise<void>;
+        _loadMaterialPropertiesAsync(context: string, material: _ILoaderMaterial, babylonMaterial: Material): Promise<void>;
         _createMaterial(name: string, drawMode: number): PBRMaterial;
         _loadMaterialBasePropertiesAsync(context: string, material: _ILoaderMaterial, babylonMaterial: PBRMaterial): Promise<void>;
         _loadMaterialAlphaProperties(context: string, material: _ILoaderMaterial, babylonMaterial: PBRMaterial): void;
@@ -1140,6 +1141,11 @@ declare module BABYLON.GLTF2 {
          */
         protected _loadMaterialAsync(context: string, material: _ILoaderMaterial, mesh: _ILoaderMesh, babylonMesh: Mesh, babylonDrawMode: number, assign: (babylonMaterial: Material) => void): Nullable<Promise<void>>;
         /**
+         * Override this method to modify the default behavior for loading material properties.
+         * @hidden
+         */
+        protected _loadMaterialPropertiesAsync(context: string, material: _ILoaderMaterial, babylonMaterial: Material): Nullable<Promise<void>>;
+        /**
          * Override this method to modify the default behavior for loading textures.
          * @hidden
          */
@@ -1180,6 +1186,11 @@ declare module BABYLON.GLTF2 {
          */
         static _LoadMaterialAsync(loader: GLTFLoader, context: string, material: _ILoaderMaterial, mesh: _ILoaderMesh, babylonMesh: Mesh, babylonDrawMode: number, assign: (babylonMaterial: Material) => void): Nullable<Promise<void>>;
         /**
+         * Helper method called by the loader to allow extensions to override loading material properties.
+         * @hidden
+         */
+        static _LoadMaterialPropertiesAsync(loader: GLTFLoader, context: string, material: _ILoaderMaterial, babylonMaterial: Material): Nullable<Promise<void>>;
+        /**
          * Helper method called by the loader to allow extensions to override loading textures.
          * @hidden
          */
@@ -1235,6 +1246,7 @@ declare module BABYLON.GLTF2.Extensions {
          * Gets an array of LOD properties from lowest to highest.
          */
         private _getLODs<T>(context, property, array, ids);
+        private _disposeUnusedMaterials();
     }
 }
 
@@ -1277,7 +1289,7 @@ declare module BABYLON.GLTF2.Extensions {
      */
     class KHR_materials_pbrSpecularGlossiness extends GLTFLoaderExtension {
         readonly name: string;
-        protected _loadMaterialAsync(context: string, material: _ILoaderMaterial, mesh: _ILoaderMesh, babylonMesh: Mesh, babylonDrawMode: number, assign: (babylonMaterial: Material) => void): Nullable<Promise<void>>;
+        protected _loadMaterialPropertiesAsync(context: string, material: _ILoaderMaterial, babylonMaterial: Material): Nullable<Promise<void>>;
         private _loadSpecularGlossinessPropertiesAsync(context, material, properties, babylonMaterial);
     }
 }
@@ -1289,7 +1301,7 @@ declare module BABYLON.GLTF2.Extensions {
      */
     class KHR_materials_unlit extends GLTFLoaderExtension {
         readonly name: string;
-        protected _loadMaterialAsync(context: string, material: _ILoaderMaterial, mesh: _ILoaderMesh, babylonMesh: Mesh, babylonDrawMode: number, assign: (babylonMaterial: Material) => void): Nullable<Promise<void>>;
+        protected _loadMaterialPropertiesAsync(context: string, material: _ILoaderMaterial, babylonMaterial: Material): Nullable<Promise<void>>;
         private _loadUnlitPropertiesAsync(context, material, babylonMaterial);
     }
 }

dist/preview release/loaders/babylon.glTFFileLoader.js

@@ -3972,25 +3972,38 @@ var BABYLON;
                 material._babylonData = material._babylonData || {};
                 var babylonData = material._babylonData[babylonDrawMode];
                 if (!babylonData) {
-                    var promises = new Array();
                     this._parent._logOpen(context + " " + (material.name || ""));
-                    var name_4 = material.name || "material_" + material._index;
+                    var name_4 = material.name || "material" + material._index;
                     var babylonMaterial = this._createMaterial(name_4, babylonDrawMode);
-                    promises.push(this._loadMaterialBasePropertiesAsync(context, material, babylonMaterial));
-                    promises.push(this._loadMaterialMetallicRoughnessPropertiesAsync(context, material, babylonMaterial));
-                    this._parent.onMaterialLoadedObservable.notifyObservers(babylonMaterial);
                     babylonData = {
                         material: babylonMaterial,
                         meshes: [],
-                        loaded: Promise.all(promises).then(function () { })
+                        loaded: this._loadMaterialPropertiesAsync(context, material, babylonMaterial)
                     };
                     material._babylonData[babylonDrawMode] = babylonData;
+                    this._parent.onMaterialLoadedObservable.notifyObservers(babylonMaterial);
                     this._parent._logClose();
                 }
                 babylonData.meshes.push(babylonMesh);
+                babylonMesh.onDisposeObservable.addOnce(function () {
+                    var index = babylonData.meshes.indexOf(babylonMesh);
+                    if (index !== -1) {
+                        babylonData.meshes.splice(index, 1);
+                    }
+                });
                 assign(babylonData.material);
                 return babylonData.loaded;
             };
+            GLTFLoader.prototype._loadMaterialPropertiesAsync = function (context, material, babylonMaterial) {
+                var promise = GLTF2.GLTFLoaderExtension._LoadMaterialPropertiesAsync(this, context, material, babylonMaterial);
+                if (promise) {
+                    return promise;
+                }
+                var promises = new Array();
+                promises.push(this._loadMaterialBasePropertiesAsync(context, material, babylonMaterial));
+                promises.push(this._loadMaterialMetallicRoughnessPropertiesAsync(context, material, babylonMaterial));
+                return Promise.all(promises).then(function () { });
+            };
             GLTFLoader.prototype._createMaterial = function (name, drawMode) {
                 var babylonMaterial = new BABYLON.PBRMaterial(name, this._babylonScene);
                 babylonMaterial.sideOrientation = this._babylonScene.useRightHandedSystem ? BABYLON.Material.CounterClockWiseSideOrientation : BABYLON.Material.ClockWiseSideOrientation;
@@ -4414,6 +4427,11 @@ var BABYLON;
              */
             GLTFLoaderExtension.prototype._loadMaterialAsync = function (context, material, mesh, babylonMesh, babylonDrawMode, assign) { return null; };
             /**
+             * Override this method to modify the default behavior for loading material properties.
+             * @hidden
+             */
+            GLTFLoaderExtension.prototype._loadMaterialPropertiesAsync = function (context, material, babylonMaterial) { return null; };
+            /**
              * Override this method to modify the default behavior for loading textures.
              * @hidden
              */
@@ -4499,6 +4517,13 @@ var BABYLON;
                 return loader._applyExtensions(function (extension) { return extension._loadMaterialAsync(context, material, mesh, babylonMesh, babylonDrawMode, assign); });
             };
             /**
+             * Helper method called by the loader to allow extensions to override loading material properties.
+             * @hidden
+             */
+            GLTFLoaderExtension._LoadMaterialPropertiesAsync = function (loader, context, material, babylonMaterial) {
+                return loader._applyExtensions(function (extension) { return extension._loadMaterialPropertiesAsync(context, material, babylonMaterial); });
+            };
+            /**
              * Helper method called by the loader to allow extensions to override loading textures.
              * @hidden
              */
@@ -4633,8 +4658,9 @@ var BABYLON;
                                 if (indexLOD !== 0) {
                                     var previousNodeLOD = nodeLODs[indexLOD - 1];
                                     if (previousNodeLOD._babylonMesh) {
-                                        previousNodeLOD._babylonMesh.dispose(false, true);
+                                        previousNodeLOD._babylonMesh.dispose();
                                         delete previousNodeLOD._babylonMesh;
+                                        _this._disposeUnusedMaterials();
                                     }
                                 }
                             });
@@ -4734,6 +4760,23 @@ var BABYLON;
                     properties.push(property);
                     return properties;
                 };
+                MSFT_lod.prototype._disposeUnusedMaterials = function () {
+                    var materials = this._loader._gltf.materials;
+                    if (materials) {
+                        for (var _i = 0, materials_1 = materials; _i < materials_1.length; _i++) {
+                            var material = materials_1[_i];
+                            if (material._babylonData) {
+                                for (var drawMode in material._babylonData) {
+                                    var babylonData = material._babylonData[drawMode];
+                                    if (babylonData.meshes.length === 0) {
+                                        babylonData.material.dispose(false, true);
+                                        delete material._babylonData[drawMode];
+                                    }
+                                }
+                            }
+                        }
+                    }
+                };
                 return MSFT_lod;
             }(GLTF2.GLTFLoaderExtension));
             Extensions.MSFT_lod = MSFT_lod;
@@ -4978,28 +5021,13 @@ var BABYLON;
                     _this.name = NAME;
                     return _this;
                 }
-                KHR_materials_pbrSpecularGlossiness.prototype._loadMaterialAsync = function (context, material, mesh, babylonMesh, babylonDrawMode, assign) {
+                KHR_materials_pbrSpecularGlossiness.prototype._loadMaterialPropertiesAsync = function (context, material, babylonMaterial) {
                     var _this = this;
                     return this._loadExtensionAsync(context, material, function (extensionContext, extension) {
-                        material._babylonData = material._babylonData || {};
-                        var babylonData = material._babylonData[babylonDrawMode];
-                        if (!babylonData) {
-                            var promises = new Array();
-                            var name_1 = material.name || "materialSG_" + material._index;
-                            var babylonMaterial = _this._loader._createMaterial(name_1, babylonDrawMode);
-                            promises.push(_this._loader._loadMaterialBasePropertiesAsync(context, material, babylonMaterial));
-                            promises.push(_this._loadSpecularGlossinessPropertiesAsync(extensionContext, material, extension, babylonMaterial));
-                            _this._loader._parent.onMaterialLoadedObservable.notifyObservers(babylonMaterial);
-                            babylonData = {
-                                material: babylonMaterial,
-                                meshes: [],
-                                loaded: Promise.all(promises).then(function () { })
-                            };
-                            material._babylonData[babylonDrawMode] = babylonData;
-                        }
-                        babylonData.meshes.push(babylonMesh);
-                        assign(babylonData.material);
-                        return babylonData.loaded;
+                        var promises = new Array();
+                        promises.push(_this._loader._loadMaterialBasePropertiesAsync(context, material, babylonMaterial));
+                        promises.push(_this._loadSpecularGlossinessPropertiesAsync(extensionContext, material, extension, babylonMaterial));
+                        return Promise.all(promises).then(function () { });
                     });
                 };
                 KHR_materials_pbrSpecularGlossiness.prototype._loadSpecularGlossinessPropertiesAsync = function (context, material, properties, babylonMaterial) {
@@ -5066,31 +5094,15 @@ var BABYLON;
                     _this.name = NAME;
                     return _this;
                 }
-                KHR_materials_unlit.prototype._loadMaterialAsync = function (context, material, mesh, babylonMesh, babylonDrawMode, assign) {
+                KHR_materials_unlit.prototype._loadMaterialPropertiesAsync = function (context, material, babylonMaterial) {
                     var _this = this;
                     return this._loadExtensionAsync(context, material, function () {
-                        material._babylonData = material._babylonData || {};
-                        var babylonData = material._babylonData[babylonDrawMode];
-                        if (!babylonData) {
-                            var name_1 = material.name || "materialUnlit_" + material._index;
-                            var babylonMaterial = _this._loader._createMaterial(name_1, babylonDrawMode);
-                            babylonMaterial.unlit = true;
-                            var promise = _this._loadUnlitPropertiesAsync(context, material, babylonMaterial);
-                            _this._loader._parent.onMaterialLoadedObservable.notifyObservers(babylonMaterial);
-                            babylonData = {
-                                material: babylonMaterial,
-                                meshes: [],
-                                loaded: promise
-                            };
-                            material._babylonData[babylonDrawMode] = babylonData;
-                        }
-                        babylonData.meshes.push(babylonMesh);
-                        assign(babylonData.material);
-                        return babylonData.loaded;
+                        return _this._loadUnlitPropertiesAsync(context, material, babylonMaterial);
                     });
                 };
                 KHR_materials_unlit.prototype._loadUnlitPropertiesAsync = function (context, material, babylonMaterial) {
                     var promises = new Array();
+                    babylonMaterial.unlit = true;
                     // Ensure metallic workflow
                     babylonMaterial.metallic = 1;
                     babylonMaterial.roughness = 1;

dist/preview release/loaders/babylonjs.loaders.d.ts

@@ -1170,6 +1170,7 @@ declare module BABYLON.GLTF2 {
         private _getDefaultMaterial(drawMode);
         private _loadMaterialMetallicRoughnessPropertiesAsync(context, material, babylonMaterial);
         _loadMaterialAsync(context: string, material: _ILoaderMaterial, mesh: _ILoaderMesh, babylonMesh: Mesh, babylonDrawMode: number, assign: (babylonMaterial: Material) => void): Promise<void>;
+        _loadMaterialPropertiesAsync(context: string, material: _ILoaderMaterial, babylonMaterial: Material): Promise<void>;
         _createMaterial(name: string, drawMode: number): PBRMaterial;
         _loadMaterialBasePropertiesAsync(context: string, material: _ILoaderMaterial, babylonMaterial: PBRMaterial): Promise<void>;
         _loadMaterialAlphaProperties(context: string, material: _ILoaderMaterial, babylonMaterial: PBRMaterial): void;
@@ -1236,6 +1237,11 @@ declare module BABYLON.GLTF2 {
          */
         protected _loadMaterialAsync(context: string, material: _ILoaderMaterial, mesh: _ILoaderMesh, babylonMesh: Mesh, babylonDrawMode: number, assign: (babylonMaterial: Material) => void): Nullable<Promise<void>>;
         /**
+         * Override this method to modify the default behavior for loading material properties.
+         * @hidden
+         */
+        protected _loadMaterialPropertiesAsync(context: string, material: _ILoaderMaterial, babylonMaterial: Material): Nullable<Promise<void>>;
+        /**
          * Override this method to modify the default behavior for loading textures.
          * @hidden
          */
@@ -1276,6 +1282,11 @@ declare module BABYLON.GLTF2 {
          */
         static _LoadMaterialAsync(loader: GLTFLoader, context: string, material: _ILoaderMaterial, mesh: _ILoaderMesh, babylonMesh: Mesh, babylonDrawMode: number, assign: (babylonMaterial: Material) => void): Nullable<Promise<void>>;
         /**
+         * Helper method called by the loader to allow extensions to override loading material properties.
+         * @hidden
+         */
+        static _LoadMaterialPropertiesAsync(loader: GLTFLoader, context: string, material: _ILoaderMaterial, babylonMaterial: Material): Nullable<Promise<void>>;
+        /**
          * Helper method called by the loader to allow extensions to override loading textures.
          * @hidden
          */
@@ -1331,6 +1342,7 @@ declare module BABYLON.GLTF2.Extensions {
          * Gets an array of LOD properties from lowest to highest.
          */
         private _getLODs<T>(context, property, array, ids);
+        private _disposeUnusedMaterials();
     }
 }
 
@@ -1373,7 +1385,7 @@ declare module BABYLON.GLTF2.Extensions {
      */
     class KHR_materials_pbrSpecularGlossiness extends GLTFLoaderExtension {
         readonly name: string;
-        protected _loadMaterialAsync(context: string, material: _ILoaderMaterial, mesh: _ILoaderMesh, babylonMesh: Mesh, babylonDrawMode: number, assign: (babylonMaterial: Material) => void): Nullable<Promise<void>>;
+        protected _loadMaterialPropertiesAsync(context: string, material: _ILoaderMaterial, babylonMaterial: Material): Nullable<Promise<void>>;
         private _loadSpecularGlossinessPropertiesAsync(context, material, properties, babylonMaterial);
     }
 }
@@ -1385,7 +1397,7 @@ declare module BABYLON.GLTF2.Extensions {
      */
     class KHR_materials_unlit extends GLTFLoaderExtension {
         readonly name: string;
-        protected _loadMaterialAsync(context: string, material: _ILoaderMaterial, mesh: _ILoaderMesh, babylonMesh: Mesh, babylonDrawMode: number, assign: (babylonMaterial: Material) => void): Nullable<Promise<void>>;
+        protected _loadMaterialPropertiesAsync(context: string, material: _ILoaderMaterial, babylonMaterial: Material): Nullable<Promise<void>>;
         private _loadUnlitPropertiesAsync(context, material, babylonMaterial);
     }
 }

dist/preview release/loaders/babylonjs.loaders.js

@@ -4957,25 +4957,38 @@ var BABYLON;
                 material._babylonData = material._babylonData || {};
                 var babylonData = material._babylonData[babylonDrawMode];
                 if (!babylonData) {
-                    var promises = new Array();
                     this._parent._logOpen(context + " " + (material.name || ""));
-                    var name_4 = material.name || "material_" + material._index;
+                    var name_4 = material.name || "material" + material._index;
                     var babylonMaterial = this._createMaterial(name_4, babylonDrawMode);
-                    promises.push(this._loadMaterialBasePropertiesAsync(context, material, babylonMaterial));
-                    promises.push(this._loadMaterialMetallicRoughnessPropertiesAsync(context, material, babylonMaterial));
-                    this._parent.onMaterialLoadedObservable.notifyObservers(babylonMaterial);
                     babylonData = {
                         material: babylonMaterial,
                         meshes: [],
-                        loaded: Promise.all(promises).then(function () { })
+                        loaded: this._loadMaterialPropertiesAsync(context, material, babylonMaterial)
                     };
                     material._babylonData[babylonDrawMode] = babylonData;
+                    this._parent.onMaterialLoadedObservable.notifyObservers(babylonMaterial);
                     this._parent._logClose();
                 }
                 babylonData.meshes.push(babylonMesh);
+                babylonMesh.onDisposeObservable.addOnce(function () {
+                    var index = babylonData.meshes.indexOf(babylonMesh);
+                    if (index !== -1) {
+                        babylonData.meshes.splice(index, 1);
+                    }
+                });
                 assign(babylonData.material);
                 return babylonData.loaded;
             };
+            GLTFLoader.prototype._loadMaterialPropertiesAsync = function (context, material, babylonMaterial) {
+                var promise = GLTF2.GLTFLoaderExtension._LoadMaterialPropertiesAsync(this, context, material, babylonMaterial);
+                if (promise) {
+                    return promise;
+                }
+                var promises = new Array();
+                promises.push(this._loadMaterialBasePropertiesAsync(context, material, babylonMaterial));
+                promises.push(this._loadMaterialMetallicRoughnessPropertiesAsync(context, material, babylonMaterial));
+                return Promise.all(promises).then(function () { });
+            };
             GLTFLoader.prototype._createMaterial = function (name, drawMode) {
                 var babylonMaterial = new BABYLON.PBRMaterial(name, this._babylonScene);
                 babylonMaterial.sideOrientation = this._babylonScene.useRightHandedSystem ? BABYLON.Material.CounterClockWiseSideOrientation : BABYLON.Material.ClockWiseSideOrientation;
@@ -5399,6 +5412,11 @@ var BABYLON;
              */
             GLTFLoaderExtension.prototype._loadMaterialAsync = function (context, material, mesh, babylonMesh, babylonDrawMode, assign) { return null; };
             /**
+             * Override this method to modify the default behavior for loading material properties.
+             * @hidden
+             */
+            GLTFLoaderExtension.prototype._loadMaterialPropertiesAsync = function (context, material, babylonMaterial) { return null; };
+            /**
              * Override this method to modify the default behavior for loading textures.
              * @hidden
              */
@@ -5484,6 +5502,13 @@ var BABYLON;
                 return loader._applyExtensions(function (extension) { return extension._loadMaterialAsync(context, material, mesh, babylonMesh, babylonDrawMode, assign); });
             };
             /**
+             * Helper method called by the loader to allow extensions to override loading material properties.
+             * @hidden
+             */
+            GLTFLoaderExtension._LoadMaterialPropertiesAsync = function (loader, context, material, babylonMaterial) {
+                return loader._applyExtensions(function (extension) { return extension._loadMaterialPropertiesAsync(context, material, babylonMaterial); });
+            };
+            /**
              * Helper method called by the loader to allow extensions to override loading textures.
              * @hidden
              */
@@ -5609,8 +5634,9 @@ var BABYLON;
                                 if (indexLOD !== 0) {
                                     var previousNodeLOD = nodeLODs[indexLOD - 1];
                                     if (previousNodeLOD._babylonMesh) {
-                                        previousNodeLOD._babylonMesh.dispose(false, true);
+                                        previousNodeLOD._babylonMesh.dispose();
                                         delete previousNodeLOD._babylonMesh;
+                                        _this._disposeUnusedMaterials();
                                     }
                                 }
                             });
@@ -5710,6 +5736,23 @@ var BABYLON;
                     properties.push(property);
                     return properties;
                 };
+                MSFT_lod.prototype._disposeUnusedMaterials = function () {
+                    var materials = this._loader._gltf.materials;
+                    if (materials) {
+                        for (var _i = 0, materials_1 = materials; _i < materials_1.length; _i++) {
+                            var material = materials_1[_i];
+                            if (material._babylonData) {
+                                for (var drawMode in material._babylonData) {
+                                    var babylonData = material._babylonData[drawMode];
+                                    if (babylonData.meshes.length === 0) {
+                                        babylonData.material.dispose(false, true);
+                                        delete material._babylonData[drawMode];
+                                    }
+                                }
+                            }
+                        }
+                    }
+                };
                 return MSFT_lod;
             }(GLTF2.GLTFLoaderExtension));
             Extensions.MSFT_lod = MSFT_lod;
@@ -5918,28 +5961,13 @@ var BABYLON;
                     _this.name = NAME;
                     return _this;
                 }
-                KHR_materials_pbrSpecularGlossiness.prototype._loadMaterialAsync = function (context, material, mesh, babylonMesh, babylonDrawMode, assign) {
+                KHR_materials_pbrSpecularGlossiness.prototype._loadMaterialPropertiesAsync = function (context, material, babylonMaterial) {
                     var _this = this;
                     return this._loadExtensionAsync(context, material, function (extensionContext, extension) {
-                        material._babylonData = material._babylonData || {};
-                        var babylonData = material._babylonData[babylonDrawMode];
-                        if (!babylonData) {
-                            var promises = new Array();
-                            var name_1 = material.name || "materialSG_" + material._index;
-                            var babylonMaterial = _this._loader._createMaterial(name_1, babylonDrawMode);
-                            promises.push(_this._loader._loadMaterialBasePropertiesAsync(context, material, babylonMaterial));
-                            promises.push(_this._loadSpecularGlossinessPropertiesAsync(extensionContext, material, extension, babylonMaterial));
-                            _this._loader._parent.onMaterialLoadedObservable.notifyObservers(babylonMaterial);
-                            babylonData = {
-                                material: babylonMaterial,
-                                meshes: [],
-                                loaded: Promise.all(promises).then(function () { })
-                            };
-                            material._babylonData[babylonDrawMode] = babylonData;
-                        }
-                        babylonData.meshes.push(babylonMesh);
-                        assign(babylonData.material);
-                        return babylonData.loaded;
+                        var promises = new Array();
+                        promises.push(_this._loader._loadMaterialBasePropertiesAsync(context, material, babylonMaterial));
+                        promises.push(_this._loadSpecularGlossinessPropertiesAsync(extensionContext, material, extension, babylonMaterial));
+                        return Promise.all(promises).then(function () { });
                     });
                 };
                 KHR_materials_pbrSpecularGlossiness.prototype._loadSpecularGlossinessPropertiesAsync = function (context, material, properties, babylonMaterial) {
@@ -5997,31 +6025,15 @@ var BABYLON;
                     _this.name = NAME;
                     return _this;
                 }
-                KHR_materials_unlit.prototype._loadMaterialAsync = function (context, material, mesh, babylonMesh, babylonDrawMode, assign) {
+                KHR_materials_unlit.prototype._loadMaterialPropertiesAsync = function (context, material, babylonMaterial) {
                     var _this = this;
                     return this._loadExtensionAsync(context, material, function () {
-                        material._babylonData = material._babylonData || {};
-                        var babylonData = material._babylonData[babylonDrawMode];
-                        if (!babylonData) {
-                            var name_1 = material.name || "materialUnlit_" + material._index;
-                            var babylonMaterial = _this._loader._createMaterial(name_1, babylonDrawMode);
-                            babylonMaterial.unlit = true;
-                            var promise = _this._loadUnlitPropertiesAsync(context, material, babylonMaterial);
-                            _this._loader._parent.onMaterialLoadedObservable.notifyObservers(babylonMaterial);
-                            babylonData = {
-                                material: babylonMaterial,
-                                meshes: [],
-                                loaded: promise
-                            };
-                            material._babylonData[babylonDrawMode] = babylonData;
-                        }
-                        babylonData.meshes.push(babylonMesh);
-                        assign(babylonData.material);
-                        return babylonData.loaded;
+                        return _this._loadUnlitPropertiesAsync(context, material, babylonMaterial);
                     });
                 };
                 KHR_materials_unlit.prototype._loadUnlitPropertiesAsync = function (context, material, babylonMaterial) {
                     var promises = new Array();
+                    babylonMaterial.unlit = true;
                     // Ensure metallic workflow
                     babylonMaterial.metallic = 1;
                     babylonMaterial.roughness = 1;

dist/preview release/loaders/babylonjs.loaders.module.d.ts

@@ -1177,6 +1177,7 @@ declare module BABYLON.GLTF2 {
         private _getDefaultMaterial(drawMode);
         private _loadMaterialMetallicRoughnessPropertiesAsync(context, material, babylonMaterial);
         _loadMaterialAsync(context: string, material: _ILoaderMaterial, mesh: _ILoaderMesh, babylonMesh: Mesh, babylonDrawMode: number, assign: (babylonMaterial: Material) => void): Promise<void>;
+        _loadMaterialPropertiesAsync(context: string, material: _ILoaderMaterial, babylonMaterial: Material): Promise<void>;
         _createMaterial(name: string, drawMode: number): PBRMaterial;
         _loadMaterialBasePropertiesAsync(context: string, material: _ILoaderMaterial, babylonMaterial: PBRMaterial): Promise<void>;
         _loadMaterialAlphaProperties(context: string, material: _ILoaderMaterial, babylonMaterial: PBRMaterial): void;
@@ -1243,6 +1244,11 @@ declare module BABYLON.GLTF2 {
          */
         protected _loadMaterialAsync(context: string, material: _ILoaderMaterial, mesh: _ILoaderMesh, babylonMesh: Mesh, babylonDrawMode: number, assign: (babylonMaterial: Material) => void): Nullable<Promise<void>>;
         /**
+         * Override this method to modify the default behavior for loading material properties.
+         * @hidden
+         */
+        protected _loadMaterialPropertiesAsync(context: string, material: _ILoaderMaterial, babylonMaterial: Material): Nullable<Promise<void>>;
+        /**
          * Override this method to modify the default behavior for loading textures.
          * @hidden
          */
@@ -1283,6 +1289,11 @@ declare module BABYLON.GLTF2 {
          */
         static _LoadMaterialAsync(loader: GLTFLoader, context: string, material: _ILoaderMaterial, mesh: _ILoaderMesh, babylonMesh: Mesh, babylonDrawMode: number, assign: (babylonMaterial: Material) => void): Nullable<Promise<void>>;
         /**
+         * Helper method called by the loader to allow extensions to override loading material properties.
+         * @hidden
+         */
+        static _LoadMaterialPropertiesAsync(loader: GLTFLoader, context: string, material: _ILoaderMaterial, babylonMaterial: Material): Nullable<Promise<void>>;
+        /**
          * Helper method called by the loader to allow extensions to override loading textures.
          * @hidden
          */
@@ -1338,6 +1349,7 @@ declare module BABYLON.GLTF2.Extensions {
          * Gets an array of LOD properties from lowest to highest.
          */
         private _getLODs<T>(context, property, array, ids);
+        private _disposeUnusedMaterials();
     }
 }
 
@@ -1380,7 +1392,7 @@ declare module BABYLON.GLTF2.Extensions {
      */
     class KHR_materials_pbrSpecularGlossiness extends GLTFLoaderExtension {
         readonly name: string;
-        protected _loadMaterialAsync(context: string, material: _ILoaderMaterial, mesh: _ILoaderMesh, babylonMesh: Mesh, babylonDrawMode: number, assign: (babylonMaterial: Material) => void): Nullable<Promise<void>>;
+        protected _loadMaterialPropertiesAsync(context: string, material: _ILoaderMaterial, babylonMaterial: Material): Nullable<Promise<void>>;
         private _loadSpecularGlossinessPropertiesAsync(context, material, properties, babylonMaterial);
     }
 }
@@ -1392,7 +1404,7 @@ declare module BABYLON.GLTF2.Extensions {
      */
     class KHR_materials_unlit extends GLTFLoaderExtension {
         readonly name: string;
-        protected _loadMaterialAsync(context: string, material: _ILoaderMaterial, mesh: _ILoaderMesh, babylonMesh: Mesh, babylonDrawMode: number, assign: (babylonMaterial: Material) => void): Nullable<Promise<void>>;
+        protected _loadMaterialPropertiesAsync(context: string, material: _ILoaderMaterial, babylonMaterial: Material): Nullable<Promise<void>>;
         private _loadUnlitPropertiesAsync(context, material, babylonMaterial);
     }
 }

dist/preview release/loaders/package.json

@@ -4,7 +4,7 @@
     },
     "name": "babylonjs-loaders",
     "description": "The Babylon.js file loaders library is an extension you can use to load different 3D file types into a Babylon scene.",
-    "version": "3.3.0-alpha.6",
+    "version": "3.3.0-alpha.7",
     "repository": {
         "type": "git",
         "url": "https://github.com/BabylonJS/Babylon.js.git"
@@ -27,7 +27,7 @@
     ],
     "license": "Apache-2.0",
     "dependencies": {
-        "babylonjs-gltf2interface": "3.3.0-alpha.6"
+        "babylonjs-gltf2interface": "3.3.0-alpha.7"
     },
     "peerDependencies": {
         "babylonjs": ">=3.2.0-alpha"

dist/preview release/materialsLibrary/package.json

@@ -4,7 +4,7 @@
     },
     "name": "babylonjs-materials",
     "description": "The Babylon.js materials library is a collection of advanced materials to be used in a Babylon.js scene.",
-    "version": "3.3.0-alpha.6",
+    "version": "3.3.0-alpha.7",
     "repository": {
         "type": "git",
         "url": "https://github.com/BabylonJS/Babylon.js.git"

dist/preview release/postProcessesLibrary/package.json

@@ -4,7 +4,7 @@
     },
     "name": "babylonjs-post-process",
     "description": "The Babylon.js materials library is a collection of advanced materials to be used in a Babylon.js scene.",
-    "version": "3.3.0-alpha.6",
+    "version": "3.3.0-alpha.7",
     "repository": {
         "type": "git",
         "url": "https://github.com/BabylonJS/Babylon.js.git"

dist/preview release/proceduralTexturesLibrary/package.json

@@ -4,7 +4,7 @@
     },
     "name": "babylonjs-procedural-textures",
     "description": "The Babylon.js materials library is a collection of advanced materials to be used in a Babylon.js scene.",
-    "version": "3.3.0-alpha.6",
+    "version": "3.3.0-alpha.7",
     "repository": {
         "type": "git",
         "url": "https://github.com/BabylonJS/Babylon.js.git"

dist/preview release/serializers/package.json

@@ -4,7 +4,7 @@
     },
     "name": "babylonjs-serializers",
     "description": "The Babylon.js serializers library is an extension you can use to serialize Babylon scenes.",
-    "version": "3.3.0-alpha.6",
+    "version": "3.3.0-alpha.7",
     "repository": {
         "type": "git",
         "url": "https://github.com/BabylonJS/Babylon.js.git"
@@ -27,7 +27,7 @@
     ],
     "license": "Apache-2.0",
     "dependencies": {
-        "babylonjs-gltf2interface": "3.3.0-alpha.6"
+        "babylonjs-gltf2interface": "3.3.0-alpha.7"
     },
     "peerDependencies": {
         "babylonjs": ">=3.2.0-alpha"

dist/preview release/what's new.md

@@ -66,6 +66,7 @@
 - RawTexture.CreateAlphaTexture no longer fails to create a usable texture ([TrevorDev](https://github.com/TrevorDev))
 - SceneSerializer.SerializeMesh now serializes all materials kinds (not only StandardMaterial) ([julien-moreau](https://github.com/julien-moreau))
 - WindowsMotionController's trackpad field will be updated prior to it's onTrackpadChangedObservable event ([TrevorDev](https://github.com/TrevorDev))
+- VR experience helper's controllers will not fire pointer events when laser's are disabled, instead the camera ray pointer event will be used ([TrevorDev](https://github.com/TrevorDev))
 
 ### Core Engine
 

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

@@ -189,10 +189,6 @@ module BABYLON.GLTF2 {
                 resultPromise.then(() => {
                     this._parent._endPerformanceCounter("Loading => Ready");
 
-                    if (this._rootBabylonMesh) {
-                        this._rootBabylonMesh.setEnabled(true);
-                    }
-
                     Tools.SetImmediate(() => {
                         if (!this._disposed) {
                             Promise.all(this._completePromises).then(() => {
@@ -299,7 +295,6 @@ module BABYLON.GLTF2 {
 
         private _createRootNode(): _ILoaderNode {
             this._rootBabylonMesh = new Mesh("__root__", this._babylonScene);
-            this._rootBabylonMesh.setEnabled(false);
 
             const rootNode = { _babylonMesh: this._rootBabylonMesh } as _ILoaderNode;
             switch (this._parent.coordinateSystemMode) {
@@ -457,6 +452,7 @@ module BABYLON.GLTF2 {
             const babylonMesh = new Mesh(node.name || `node${node._index}`, this._babylonScene, node._parent ? node._parent._babylonMesh : null);
             node._babylonMesh = babylonMesh;
 
+            babylonMesh.setEnabled(false);
             GLTFLoader._LoadTransform(node, babylonMesh);
 
             if (node.mesh != undefined) {
@@ -480,7 +476,9 @@ module BABYLON.GLTF2 {
 
             this._parent._logClose();
 
-            return Promise.all(promises).then(() => {});
+            return Promise.all(promises).then(() => {
+                babylonMesh.setEnabled(true);
+            });
         }
 
         private _loadMeshAsync(context: string, node: _ILoaderNode, mesh: _ILoaderMesh, babylonMesh: Mesh): Promise<void> {

package.json

@@ -9,7 +9,7 @@
     ],
     "name": "babylonjs",
     "description": "Babylon.js is a JavaScript 3D engine based on webgl.",
-    "version": "3.3.0-alpha.6",
+    "version": "3.3.0-alpha.7",
     "repository": {
         "type": "git",
         "url": "https://github.com/BabylonJS/Babylon.js.git"

src/Cameras/VR/babylon.vrExperienceHelper.ts

@@ -937,6 +937,10 @@ module BABYLON {
             }
         }
 
+        private get _noControllerIsActive(){
+            return !(this.leftController && this.leftController._activePointer) && !(this.rightController && this.rightController._activePointer)
+        }
+
         private beforeRender = () => {
             if(this.leftController && this.leftController._activePointer){
                 this._castRayAndSelectObject(this.leftController);
@@ -946,7 +950,7 @@ module BABYLON {
                 this._castRayAndSelectObject(this.rightController);
             }
 
-            if(!(this.leftController && this.leftController._activePointer) && !(this.rightController && this.rightController._activePointer)){
+            if(this._noControllerIsActive){
                 this._castRayAndSelectObject(this._cameraGazer);
             }else{
                 this._cameraGazer._gazeTracker.isVisible = false;
@@ -1139,12 +1143,16 @@ module BABYLON {
                     });
                 }
                 controller.webVRController.onTriggerStateChangedObservable.add((stateObject) => {
-                    if (!controller._pointerDownOnMeshAsked) {
+                    var gazer:VRExperienceHelperGazer = controller;
+                    if(this._noControllerIsActive){
+                        gazer = this._cameraGazer;
+                    }
+                    if (!gazer._pointerDownOnMeshAsked) {
                         if (stateObject.value > this._padSensibilityUp) {
-                            controller._selectionPointerDown();
+                            gazer._selectionPointerDown();
                         }
                     } else if (stateObject.value < this._padSensibilityDown) {
-                        controller._selectionPointerUp();
+                        gazer._selectionPointerUp();
                     }
                 });
             }

src/Engine/babylon.engine.ts

@@ -710,7 +710,7 @@
          * Returns the current version of the framework
          */
         public static get Version(): string {
-            return "3.3.0-alpha.6";
+            return "3.3.0-alpha.7";
         }
 
         // Updatable statics so stick with vars here

tests/unit/babylon/src/Loading/babylon.sceneLoader.tests.ts

@@ -161,28 +161,25 @@ describe('Babylon Scene Loader', function () {
             return Promise.race(promises);
         });
 
-        it('Load BoomBox with rootMesh.isEnabled check', () => {
+        it('Load BoomBox with mesh.isEnabled check', () => {
             const scene = new BABYLON.Scene(subject);
-            let rootMesh: BABYLON.AbstractMesh;
 
             subject.runRenderLoop(() => {
-                if (!rootMesh) {
-                    for (const mesh of scene.meshes) {
-                        if (!mesh.parent) {
-                            rootMesh = mesh;
-                            break;
-                        }
+                for (const mesh of scene.meshes) {
+                    if (mesh.getTotalVertices() !== 0) {
+                        expect(mesh.isEnabled(), "mesh.isEnabled").to.be.false;
                     }
                 }
-
-                if (rootMesh) {
-                    expect(rootMesh.isEnabled(), "rootMesh.isEnabled").to.be.false;
-                }
             });
 
             return BABYLON.SceneLoader.AppendAsync("/Playground/scenes/BoomBox/", "BoomBox.gltf", scene).then(scene => {
-                expect(rootMesh.isEnabled(), "rootMesh.isEnabled").to.be.true;
                 subject.stopRenderLoop();
+
+                for (const mesh of scene.meshes) {
+                    if (mesh.getTotalVertices() !== 0) {
+                        expect(mesh.isEnabled(), "mesh.isEnabled").to.be.true;
+                    }
+                }
             });
         });