merge

Tools/Gulp/config.json

@@ -46,6 +46,7 @@
         {
             "files":[
                 "../../src/Math/babylon.math.js",
+                "../../src/Math/babylon.math.scalar.js",
                 "../../src/babylon.mixins.js",
                 "../../src/Tools/babylon.decorators.js",
                 "../../src/Tools/babylon.observable.js",

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

@@ -155,6 +155,7 @@ declare module BABYLON.GUI {
         private _dummyVector2;
         private _downCount;
         private _enterCount;
+        private _doNotRender;
         isHitTestVisible: boolean;
         isPointerBlocker: boolean;
         protected _linkOffsetX: ValueAndUnit;
@@ -204,6 +205,7 @@ declare module BABYLON.GUI {
         fontSize: string | number;
         color: string;
         zIndex: number;
+        notRenderable: boolean;
         isVisible: boolean;
         readonly isDirty: boolean;
         paddingLeft: string | number;

dist/preview release/gui/babylon.gui.js

@@ -201,10 +201,10 @@ var BABYLON;
                         var position = mesh.getBoundingInfo().boundingSphere.center;
                         var projectedPosition = BABYLON.Vector3.Project(position, mesh.getWorldMatrix(), scene.getTransformMatrix(), globalViewport);
                         if (projectedPosition.z < 0 || projectedPosition.z > 1) {
-                            control.isVisible = false;
+                            control.notRenderable = true;
                             continue;
                         }
-                        control.isVisible = true;
+                        control.notRenderable = false;
                         control._moveToProjectedPosition(projectedPosition);
                     }
                 }
@@ -675,6 +675,7 @@ var BABYLON;
                 this._dummyVector2 = BABYLON.Vector2.Zero();
                 this._downCount = 0;
                 this._enterCount = 0;
+                this._doNotRender = false;
                 this.isHitTestVisible = true;
                 this.isPointerBlocker = false;
                 this._linkOffsetX = new GUI.ValueAndUnit(0);
@@ -926,6 +927,20 @@ var BABYLON;
                 enumerable: true,
                 configurable: true
             });
+            Object.defineProperty(Control.prototype, "notRenderable", {
+                get: function () {
+                    return this._doNotRender;
+                },
+                set: function (value) {
+                    if (this._doNotRender === value) {
+                        return;
+                    }
+                    this._doNotRender = value;
+                    this._markAsDirty();
+                },
+                enumerable: true,
+                configurable: true
+            });
             Object.defineProperty(Control.prototype, "isVisible", {
                 get: function () {
                     return this._isVisible;
@@ -1082,10 +1097,10 @@ var BABYLON;
                 var projectedPosition = BABYLON.Vector3.Project(position, BABYLON.Matrix.Identity(), scene.getTransformMatrix(), globalViewport);
                 this._moveToProjectedPosition(projectedPosition);
                 if (projectedPosition.z < 0 || projectedPosition.z > 1) {
-                    this.isVisible = false;
+                    this.notRenderable = true;
                     return;
                 }
-                this.isVisible = true;
+                this.notRenderable = false;
             };
             Control.prototype.linkWithMesh = function (mesh) {
                 if (!this._host || this._root !== this._host._rootContainer) {
@@ -1334,7 +1349,7 @@ var BABYLON;
                 return true;
             };
             Control.prototype._processPicking = function (x, y, type) {
-                if (!this.isHitTestVisible || !this.isVisible) {
+                if (!this.isHitTestVisible || !this.isVisible || this._doNotRender) {
                     return false;
                 }
                 if (!this.contains(x, y)) {
@@ -1666,7 +1681,7 @@ var BABYLON;
                 }
             };
             Container.prototype._draw = function (parentMeasure, context) {
-                if (!this.isVisible) {
+                if (!this.isVisible || this.notRenderable) {
                     return;
                 }
                 context.save();
@@ -1676,7 +1691,7 @@ var BABYLON;
                     this._clipForChildren(context);
                     for (var _i = 0, _a = this._children; _i < _a.length; _i++) {
                         var child = _a[_i];
-                        if (child.isVisible) {
+                        if (child.isVisible && !child.notRenderable) {
                             child._draw(this._measureForChildren, context);
                         }
                     }
@@ -1684,7 +1699,7 @@ var BABYLON;
                 context.restore();
             };
             Container.prototype._processPicking = function (x, y, type) {
-                if (!this.isHitTestVisible || !this.isVisible) {
+                if (!this.isHitTestVisible || !this.isVisible || this.notRenderable) {
                     return false;
                 }
                 if (!_super.prototype.contains.call(this, x, y)) {
@@ -3177,7 +3192,7 @@ var BABYLON;
             };
             // While being a container, the button behaves like a control.
             Button.prototype._processPicking = function (x, y, type) {
-                if (!this.isHitTestVisible || !this.isVisible) {
+                if (!this.isHitTestVisible || !this.isVisible || this.notRenderable) {
                     return false;
                 }
                 if (!_super.prototype.contains.call(this, x, y)) {

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

@@ -113,6 +113,12 @@ declare module INSPECTOR {
         'BaseTexture': {
             type: typeof BABYLON.BaseTexture;
         };
+        'CubeTexture': {
+            type: typeof BABYLON.CubeTexture;
+        };
+        'HDRCubeTexture': {
+            type: typeof BABYLON.HDRCubeTexture;
+        };
         'FontTexture': {
             type: typeof BABYLON.FontTexture;
         };
@@ -969,6 +975,7 @@ declare module INSPECTOR {
         constructor(tabbar: TabBar, insp: Inspector);
         /** Overrides super.dispose */
         dispose(): void;
+        active(b: boolean): void;
         private _message(type, message, caller);
         private _addConsoleLog(...params);
         private _addConsoleWarn(...params);
@@ -993,6 +1000,7 @@ declare module INSPECTOR {
         /** Update each properties of the stats panel */
         private _update();
         dispose(): void;
+        active(b: boolean): void;
     }
 }
 

dist/preview release/inspector/babylon.inspector.js

@@ -403,6 +403,12 @@ var INSPECTOR;
         'BaseTexture': {
             type: BABYLON.BaseTexture
         },
+        'CubeTexture': {
+            type: BABYLON.CubeTexture
+        },
+        'HDRCubeTexture': {
+            type: BABYLON.HDRCubeTexture
+        },
         'FontTexture': {
             type: BABYLON.FontTexture
         },
@@ -2479,7 +2485,7 @@ var INSPECTOR;
          */
         Helpers.GET_TYPE = function (obj) {
             if (obj != null && obj != undefined) {
-                var classname = BABYLON.Tools.getClassName(obj);
+                var classname = BABYLON.Tools.GetClassName(obj);
                 if (!classname || classname === 'object') {
                     classname = obj.constructor.name;
                     // classname is undefined in IE11
@@ -3147,12 +3153,13 @@ var INSPECTOR;
             INSPECTOR.Helpers.CleanDiv(this._imagePanel);
             // Get the texture object
             var texture = item.adapter.object;
+            var imgs = [];
             var img = INSPECTOR.Helpers.CreateElement('img', 'texture-image', this._imagePanel);
-            var img1 = INSPECTOR.Helpers.CreateElement('img', 'texture-image', this._imagePanel);
-            var img2 = INSPECTOR.Helpers.CreateElement('img', 'texture-image', this._imagePanel);
-            var img3 = INSPECTOR.Helpers.CreateElement('img', 'texture-image', this._imagePanel);
-            var img4 = INSPECTOR.Helpers.CreateElement('img', 'texture-image', this._imagePanel);
-            var img5 = INSPECTOR.Helpers.CreateElement('img', 'texture-image', this._imagePanel);
+            imgs.push(img);
+            //Create five other images elements
+            for (var i = 0; i < 5; i++) {
+                imgs.push(INSPECTOR.Helpers.CreateElement('img', 'texture-image', this._imagePanel));
+            }
             if (texture instanceof BABYLON.MapTexture) {
                 // instance of Map texture
                 texture.bindTextureForPosSize(new BABYLON.Vector2(0, 0), new BABYLON.Size(texture.getSize().width, texture.getSize().height), false);
@@ -3172,31 +3179,7 @@ var INSPECTOR;
                 screenShotTexture.onBeforeRenderObservable = texture.onBeforeRenderObservable;
                 // To display the texture after rendering
                 screenShotTexture.onAfterRenderObservable.add(function (faceIndex) {
-                    var targetImg;
-                    switch (faceIndex) {
-                        case 0:
-                            targetImg = img;
-                            break;
-                        case 1:
-                            targetImg = img1;
-                            break;
-                        case 2:
-                            targetImg = img2;
-                            break;
-                        case 3:
-                            targetImg = img3;
-                            break;
-                        case 4:
-                            targetImg = img4;
-                            break;
-                        case 5:
-                            targetImg = img5;
-                            break;
-                        default:
-                            targetImg = img;
-                            break;
-                    }
-                    BABYLON.Tools.DumpFramebuffer(size_1.width, size_1.height, engine_1, function (data) { return targetImg.src = data; }, "image/png");
+                    BABYLON.Tools.DumpFramebuffer(size_1.width, size_1.height, engine_1, function (data) { return imgs[faceIndex].src = data; }, "image/png");
                 });
                 // Render the texture
                 scene.incrementRenderId();
@@ -3204,6 +3187,15 @@ var INSPECTOR;
                 screenShotTexture.render();
                 screenShotTexture.dispose();
             }
+            else if (texture instanceof BABYLON.CubeTexture) {
+                // Display all textures of the CubeTexture
+                var i = 0;
+                for (var _i = 0, _a = texture['_files']; _i < _a.length; _i++) {
+                    var filename = _a[_i];
+                    imgs[i].src = filename;
+                    i++;
+                }
+            }
             else if (texture.url) {
                 // If an url is present, the texture is an image
                 img.src = texture.url;
@@ -3745,13 +3737,6 @@ var INSPECTOR;
             // Contents
             _this._consolePanelContent = INSPECTOR.Helpers.CreateDiv('console-panel-content', consolePanel);
             _this._bjsPanelContent = INSPECTOR.Helpers.CreateDiv('console-panel-content', bjsPanel);
-            // save old console.log
-            _this._oldConsoleLog = console.log;
-            _this._oldConsoleWarn = console.warn;
-            _this._oldConsoleError = console.error;
-            console.log = _this._addConsoleLog.bind(_this);
-            console.warn = _this._addConsoleWarn.bind(_this);
-            console.error = _this._addConsoleError.bind(_this);
             // Bjs logs
             _this._bjsPanelContent.innerHTML = BABYLON.Tools.LogCache;
             BABYLON.Tools.OnNewCacheEntry = function (entry) {
@@ -3775,6 +3760,18 @@ var INSPECTOR;
             console.warn = this._oldConsoleWarn;
             console.error = this._oldConsoleError;
         };
+        ConsoleTab.prototype.active = function (b) {
+            _super.prototype.active.call(this, b);
+            if (b) {
+                // save old console.log
+                this._oldConsoleLog = console.log;
+                this._oldConsoleWarn = console.warn;
+                this._oldConsoleError = console.error;
+                console.log = this._addConsoleLog.bind(this);
+                console.warn = this._addConsoleWarn.bind(this);
+                console.error = this._addConsoleError.bind(this);
+            }
+        };
         ConsoleTab.prototype._message = function (type, message, caller) {
             var callerLine = INSPECTOR.Helpers.CreateDiv('caller', this._consolePanelContent);
             callerLine.textContent = caller;
@@ -4089,8 +4086,6 @@ var INSPECTOR;
                     updateFct: function () { return "WebGL v" + _this._engine.webGLVersion + " - " + _this._glInfo.version + " - " + _this._glInfo.renderer; }
                 });
             }
-            // Register the update loop
-            _this._scene.registerAfterRender(_this._updateLoopHandler);
             return _this;
         }
         StatsTab.prototype._createStatLabel = function (content, parent) {
@@ -4108,6 +4103,12 @@ var INSPECTOR;
         StatsTab.prototype.dispose = function () {
             this._scene.unregisterAfterRender(this._updateLoopHandler);
         };
+        StatsTab.prototype.active = function (b) {
+            _super.prototype.active.call(this, b);
+            if (b) {
+                this._scene.registerAfterRender(this._updateLoopHandler);
+            }
+        };
         return StatsTab;
     }(INSPECTOR.Tab));
     INSPECTOR.StatsTab = StatsTab;
@@ -4160,7 +4161,6 @@ var INSPECTOR;
             //Check initialTab is defined and between tabs bounds
             if (!initialTab || initialTab < 0 || initialTab >= _this._tabs.length) {
                 initialTab = 0;
-                console.warn('');
             }
             _this._tabs[initialTab].active(true);
             // set all tab as visible

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

@@ -318,7 +318,6 @@ declare module BABYLON.GLTF2 {
         private _createBone(node, skin);
         private _loadMesh(node);
         private _loadMeshData(node, mesh, babylonMesh);
-        private _assignMaterial(multiMaterial, index, subMaterial);
         private _loadVertexDataAsync(primitive, onSuccess);
         private _createMorphTargets(node, mesh, primitive, babylonMesh);
         private _loadMorphTargetsData(mesh, primitive, vertexData, babylonMesh);
@@ -337,7 +336,7 @@ declare module BABYLON.GLTF2 {
         removeLoaderPendingData(data: any): void;
         private _getDefaultMaterial();
         private _loadMaterialMetallicRoughnessProperties(material);
-        loadMaterial(index: number, assign: (material: Material) => void): void;
+        loadMaterial(index: number, assign: (babylonMaterial: Material, isNew: boolean) => void): void;
         createPbrMaterial(material: IGLTFMaterial): void;
         loadMaterialBaseProperties(material: IGLTFMaterial): void;
         loadMaterialAlphaProperties(material: IGLTFMaterial, colorFactor?: number[]): void;
@@ -377,9 +376,9 @@ declare module BABYLON.GLTF2 {
     abstract class GLTFLoaderExtension {
         enabled: boolean;
         readonly abstract name: string;
-        protected loadMaterial(loader: GLTFLoader, material: IGLTFMaterial, assign: (material: Material) => void): boolean;
+        protected loadMaterial(loader: GLTFLoader, material: IGLTFMaterial, assign: (babylonMaterial: Material, isNew: boolean) => void): boolean;
         static _Extensions: GLTFLoaderExtension[];
-        static LoadMaterial(loader: GLTFLoader, material: IGLTFMaterial, assign: (material: Material) => void): boolean;
+        static LoadMaterial(loader: GLTFLoader, material: IGLTFMaterial, assign: (babylonMaterial: Material, isNew: boolean) => void): boolean;
         private static _ApplyExtensions(action);
     }
 }
@@ -388,7 +387,7 @@ declare module BABYLON.GLTF2 {
 declare module BABYLON.GLTF2.Extensions {
     class MSFTLOD extends GLTFLoaderExtension {
         readonly name: string;
-        protected loadMaterial(loader: GLTFLoader, material: IGLTFMaterial, assign: (material: Material) => void): boolean;
+        protected loadMaterial(loader: GLTFLoader, material: IGLTFMaterial, assign: (babylonMaterial: Material, isNew: boolean) => void): boolean;
         private loadMaterialLOD(loader, material, materialLODs, lod, assign);
     }
 }
@@ -397,7 +396,7 @@ declare module BABYLON.GLTF2.Extensions {
 declare module BABYLON.GLTF2.Extensions {
     class KHRMaterialsPbrSpecularGlossiness extends GLTFLoaderExtension {
         readonly name: string;
-        protected loadMaterial(loader: GLTFLoader, material: IGLTFMaterial, assign: (material: Material) => void): boolean;
+        protected loadMaterial(loader: GLTFLoader, material: IGLTFMaterial, assign: (babylonMaterial: Material, isNew: boolean) => void): boolean;
         private _loadSpecularGlossinessProperties(loader, material, properties);
     }
 }

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

@@ -417,8 +417,8 @@ var BABYLON;
                 this.removePendingData(this);
             };
             GLTFLoader.prototype._onError = function (message) {
-                this.dispose();
                 this._errorCallback(message);
+                this.dispose();
             };
             GLTFLoader.prototype._onProgress = function (event) {
                 this._progressCallback(event);
@@ -632,14 +632,17 @@ var BABYLON;
                             babylonMultiMaterial.subMaterials[i] = _this._getDefaultMaterial();
                         }
                         else {
-                            _this.loadMaterial(primitive.material, function (babylonSubMaterial) {
+                            _this.loadMaterial(primitive.material, function (babylonMaterial, isNew) {
+                                if (isNew && _this._parent.onMaterialLoaded) {
+                                    _this._parent.onMaterialLoaded(babylonMaterial);
+                                }
                                 if (_this._renderReady) {
-                                    babylonSubMaterial.forceCompilation(babylonMesh, function (babylonSubMaterial) {
-                                        _this._assignMaterial(babylonMultiMaterial, i, babylonSubMaterial);
+                                    babylonMaterial.forceCompilation(babylonMesh, function (babylonSubMaterial) {
+                                        babylonMultiMaterial.subMaterials[i] = babylonSubMaterial;
                                     });
                                 }
                                 else {
-                                    _this._assignMaterial(babylonMultiMaterial, i, babylonSubMaterial);
+                                    babylonMultiMaterial.subMaterials[i] = babylonMaterial;
                                 }
                             });
                         }
@@ -657,12 +660,6 @@ var BABYLON;
                     _loop_1(i);
                 }
             };
-            GLTFLoader.prototype._assignMaterial = function (multiMaterial, index, subMaterial) {
-                multiMaterial.subMaterials[index] = subMaterial;
-                if (this._parent.onMaterialLoaded) {
-                    this._parent.onMaterialLoaded(subMaterial);
-                }
-            };
             GLTFLoader.prototype._loadVertexDataAsync = function (primitive, onSuccess) {
                 var _this = this;
                 var attributes = primitive.attributes;
@@ -1119,7 +1116,7 @@ var BABYLON;
                 var material = this._gltf.materials[index];
                 material.index = index;
                 if (material.babylonMaterial) {
-                    assign(material.babylonMaterial);
+                    assign(material.babylonMaterial, false);
                     return;
                 }
                 if (GLTF2.GLTFLoaderExtension.LoadMaterial(this, material, assign)) {
@@ -1128,7 +1125,7 @@ var BABYLON;
                 this.createPbrMaterial(material);
                 this.loadMaterialBaseProperties(material);
                 this._loadMaterialMetallicRoughnessProperties(material);
-                assign(material.babylonMaterial);
+                assign(material.babylonMaterial, true);
             };
             GLTFLoader.prototype.createPbrMaterial = function (material) {
                 var babylonMaterial = new BABYLON.PBRMaterial(material.name || "mat" + material.index, this._babylonScene);
@@ -1452,8 +1449,8 @@ var BABYLON;
                 };
                 MSFTLOD.prototype.loadMaterialLOD = function (loader, material, materialLODs, lod, assign) {
                     var _this = this;
-                    loader.loadMaterial(materialLODs[lod], function (babylonMaterial) {
-                        assign(babylonMaterial);
+                    loader.loadMaterial(materialLODs[lod], function (babylonMaterial, isNew) {
+                        assign(babylonMaterial, isNew);
                         // Loading is complete if this is the highest quality LOD.
                         if (lod === 0) {
                             loader.removeLoaderPendingData(material);
@@ -1518,7 +1515,7 @@ var BABYLON;
                     loader.createPbrMaterial(material);
                     loader.loadMaterialBaseProperties(material);
                     this._loadSpecularGlossinessProperties(loader, material, properties);
-                    assign(material.babylonMaterial);
+                    assign(material.babylonMaterial, true);
                     return true;
                 };
                 KHRMaterialsPbrSpecularGlossiness.prototype._loadSpecularGlossinessProperties = function (loader, material, properties) {
@@ -1532,6 +1529,7 @@ var BABYLON;
                     }
                     if (properties.specularGlossinessTexture) {
                         babylonMaterial.reflectivityTexture = loader.loadTexture(properties.specularGlossinessTexture);
+                        babylonMaterial.reflectivityTexture.hasAlpha = true;
                         babylonMaterial.useMicroSurfaceFromReflectivityMapAlpha = true;
                     }
                     loader.loadMaterialAlphaProperties(material, properties.diffuseFactor);

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

@@ -813,7 +813,6 @@ declare module BABYLON.GLTF2 {
         private _createBone(node, skin);
         private _loadMesh(node);
         private _loadMeshData(node, mesh, babylonMesh);
-        private _assignMaterial(multiMaterial, index, subMaterial);
         private _loadVertexDataAsync(primitive, onSuccess);
         private _createMorphTargets(node, mesh, primitive, babylonMesh);
         private _loadMorphTargetsData(mesh, primitive, vertexData, babylonMesh);
@@ -832,7 +831,7 @@ declare module BABYLON.GLTF2 {
         removeLoaderPendingData(data: any): void;
         private _getDefaultMaterial();
         private _loadMaterialMetallicRoughnessProperties(material);
-        loadMaterial(index: number, assign: (material: Material) => void): void;
+        loadMaterial(index: number, assign: (babylonMaterial: Material, isNew: boolean) => void): void;
         createPbrMaterial(material: IGLTFMaterial): void;
         loadMaterialBaseProperties(material: IGLTFMaterial): void;
         loadMaterialAlphaProperties(material: IGLTFMaterial, colorFactor?: number[]): void;
@@ -872,9 +871,9 @@ declare module BABYLON.GLTF2 {
     abstract class GLTFLoaderExtension {
         enabled: boolean;
         readonly abstract name: string;
-        protected loadMaterial(loader: GLTFLoader, material: IGLTFMaterial, assign: (material: Material) => void): boolean;
+        protected loadMaterial(loader: GLTFLoader, material: IGLTFMaterial, assign: (babylonMaterial: Material, isNew: boolean) => void): boolean;
         static _Extensions: GLTFLoaderExtension[];
-        static LoadMaterial(loader: GLTFLoader, material: IGLTFMaterial, assign: (material: Material) => void): boolean;
+        static LoadMaterial(loader: GLTFLoader, material: IGLTFMaterial, assign: (babylonMaterial: Material, isNew: boolean) => void): boolean;
         private static _ApplyExtensions(action);
     }
 }
@@ -883,7 +882,7 @@ declare module BABYLON.GLTF2 {
 declare module BABYLON.GLTF2.Extensions {
     class MSFTLOD extends GLTFLoaderExtension {
         readonly name: string;
-        protected loadMaterial(loader: GLTFLoader, material: IGLTFMaterial, assign: (material: Material) => void): boolean;
+        protected loadMaterial(loader: GLTFLoader, material: IGLTFMaterial, assign: (babylonMaterial: Material, isNew: boolean) => void): boolean;
         private loadMaterialLOD(loader, material, materialLODs, lod, assign);
     }
 }
@@ -892,7 +891,7 @@ declare module BABYLON.GLTF2.Extensions {
 declare module BABYLON.GLTF2.Extensions {
     class KHRMaterialsPbrSpecularGlossiness extends GLTFLoaderExtension {
         readonly name: string;
-        protected loadMaterial(loader: GLTFLoader, material: IGLTFMaterial, assign: (material: Material) => void): boolean;
+        protected loadMaterial(loader: GLTFLoader, material: IGLTFMaterial, assign: (babylonMaterial: Material, isNew: boolean) => void): boolean;
         private _loadSpecularGlossinessProperties(loader, material, properties);
     }
 }

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

@@ -2575,8 +2575,8 @@ var BABYLON;
                 this.removePendingData(this);
             };
             GLTFLoader.prototype._onError = function (message) {
-                this.dispose();
                 this._errorCallback(message);
+                this.dispose();
             };
             GLTFLoader.prototype._onProgress = function (event) {
                 this._progressCallback(event);
@@ -2790,14 +2790,17 @@ var BABYLON;
                             babylonMultiMaterial.subMaterials[i] = _this._getDefaultMaterial();
                         }
                         else {
-                            _this.loadMaterial(primitive.material, function (babylonSubMaterial) {
+                            _this.loadMaterial(primitive.material, function (babylonMaterial, isNew) {
+                                if (isNew && _this._parent.onMaterialLoaded) {
+                                    _this._parent.onMaterialLoaded(babylonMaterial);
+                                }
                                 if (_this._renderReady) {
-                                    babylonSubMaterial.forceCompilation(babylonMesh, function (babylonSubMaterial) {
-                                        _this._assignMaterial(babylonMultiMaterial, i, babylonSubMaterial);
+                                    babylonMaterial.forceCompilation(babylonMesh, function (babylonSubMaterial) {
+                                        babylonMultiMaterial.subMaterials[i] = babylonSubMaterial;
                                     });
                                 }
                                 else {
-                                    _this._assignMaterial(babylonMultiMaterial, i, babylonSubMaterial);
+                                    babylonMultiMaterial.subMaterials[i] = babylonMaterial;
                                 }
                             });
                         }
@@ -2815,12 +2818,6 @@ var BABYLON;
                     _loop_1(i);
                 }
             };
-            GLTFLoader.prototype._assignMaterial = function (multiMaterial, index, subMaterial) {
-                multiMaterial.subMaterials[index] = subMaterial;
-                if (this._parent.onMaterialLoaded) {
-                    this._parent.onMaterialLoaded(subMaterial);
-                }
-            };
             GLTFLoader.prototype._loadVertexDataAsync = function (primitive, onSuccess) {
                 var _this = this;
                 var attributes = primitive.attributes;
@@ -3277,7 +3274,7 @@ var BABYLON;
                 var material = this._gltf.materials[index];
                 material.index = index;
                 if (material.babylonMaterial) {
-                    assign(material.babylonMaterial);
+                    assign(material.babylonMaterial, false);
                     return;
                 }
                 if (GLTF2.GLTFLoaderExtension.LoadMaterial(this, material, assign)) {
@@ -3286,7 +3283,7 @@ var BABYLON;
                 this.createPbrMaterial(material);
                 this.loadMaterialBaseProperties(material);
                 this._loadMaterialMetallicRoughnessProperties(material);
-                assign(material.babylonMaterial);
+                assign(material.babylonMaterial, true);
             };
             GLTFLoader.prototype.createPbrMaterial = function (material) {
                 var babylonMaterial = new BABYLON.PBRMaterial(material.name || "mat" + material.index, this._babylonScene);
@@ -3610,8 +3607,8 @@ var BABYLON;
                 };
                 MSFTLOD.prototype.loadMaterialLOD = function (loader, material, materialLODs, lod, assign) {
                     var _this = this;
-                    loader.loadMaterial(materialLODs[lod], function (babylonMaterial) {
-                        assign(babylonMaterial);
+                    loader.loadMaterial(materialLODs[lod], function (babylonMaterial, isNew) {
+                        assign(babylonMaterial, isNew);
                         // Loading is complete if this is the highest quality LOD.
                         if (lod === 0) {
                             loader.removeLoaderPendingData(material);
@@ -3676,7 +3673,7 @@ var BABYLON;
                     loader.createPbrMaterial(material);
                     loader.loadMaterialBaseProperties(material);
                     this._loadSpecularGlossinessProperties(loader, material, properties);
-                    assign(material.babylonMaterial);
+                    assign(material.babylonMaterial, true);
                     return true;
                 };
                 KHRMaterialsPbrSpecularGlossiness.prototype._loadSpecularGlossinessProperties = function (loader, material, properties) {
@@ -3690,6 +3687,7 @@ var BABYLON;
                     }
                     if (properties.specularGlossinessTexture) {
                         babylonMaterial.reflectivityTexture = loader.loadTexture(properties.specularGlossinessTexture);
+                        babylonMaterial.reflectivityTexture.hasAlpha = true;
                         babylonMaterial.useMicroSurfaceFromReflectivityMapAlpha = true;
                     }
                     loader.loadMaterialAlphaProperties(material, properties.diffuseFactor);

dist/preview release/materialsLibrary/babylon.cellMaterial.d.ts

@@ -23,6 +23,7 @@ declare module BABYLON {
         getActiveTextures(): BaseTexture[];
         hasTexture(texture: BaseTexture): boolean;
         dispose(forceDisposeEffect?: boolean): void;
+        getClassName(): string;
         clone(name: string): CellMaterial;
         serialize(): any;
         static Parse(source: any, scene: Scene, rootUrl: string): CellMaterial;

dist/preview release/materialsLibrary/babylon.cellMaterial.js

@@ -239,6 +239,9 @@ var BABYLON;
             }
             _super.prototype.dispose.call(this, forceDisposeEffect);
         };
+        CellMaterial.prototype.getClassName = function () {
+            return "CellMaterial";
+        };
         CellMaterial.prototype.clone = function (name) {
             var _this = this;
             return BABYLON.SerializationHelper.Clone(function () { return new CellMaterial(name, _this.getScene()); }, this);

dist/preview release/materialsLibrary/babylon.fireMaterial.d.ts

@@ -21,6 +21,7 @@ declare module BABYLON {
         getAnimatables(): IAnimatable[];
         getActiveTextures(): BaseTexture[];
         hasTexture(texture: BaseTexture): boolean;
+        getClassName(): string;
         dispose(forceDisposeEffect?: boolean): void;
         clone(name: string): FireMaterial;
         serialize(): any;

dist/preview release/materialsLibrary/babylon.fireMaterial.js

@@ -237,6 +237,9 @@ var BABYLON;
             }
             return false;
         };
+        FireMaterial.prototype.getClassName = function () {
+            return "FireMaterial";
+        };
         FireMaterial.prototype.dispose = function (forceDisposeEffect) {
             if (this._diffuseTexture) {
                 this._diffuseTexture.dispose();

dist/preview release/materialsLibrary/babylon.furMaterial.d.ts

@@ -38,6 +38,7 @@ declare module BABYLON {
         dispose(forceDisposeEffect?: boolean): void;
         clone(name: string): FurMaterial;
         serialize(): any;
+        getClassName(): string;
         static Parse(source: any, scene: Scene, rootUrl: string): FurMaterial;
         static GenerateTexture(name: string, scene: Scene): DynamicTexture;
         static FurifyMesh(sourceMesh: Mesh, quality: number): Mesh[];

dist/preview release/materialsLibrary/babylon.furMaterial.js

@@ -332,6 +332,9 @@ var BABYLON;
             }
             return serializationObject;
         };
+        FurMaterial.prototype.getClassName = function () {
+            return "FurMaterial";
+        };
         // Statics
         FurMaterial.Parse = function (source, scene, rootUrl) {
             var material = BABYLON.SerializationHelper.Parse(function () { return new FurMaterial(source.name, scene); }, source, scene, rootUrl);

dist/preview release/materialsLibrary/babylon.gradientMaterial.d.ts

@@ -23,6 +23,7 @@ declare module BABYLON {
         dispose(forceDisposeEffect?: boolean): void;
         clone(name: string): GradientMaterial;
         serialize(): any;
+        getClassName(): string;
         static Parse(source: any, scene: Scene, rootUrl: string): GradientMaterial;
     }
 }

dist/preview release/materialsLibrary/babylon.gradientMaterial.js

@@ -244,6 +244,9 @@ var BABYLON;
             serializationObject.customType = "BABYLON.GradientMaterial";
             return serializationObject;
         };
+        GradientMaterial.prototype.getClassName = function () {
+            return "GradientMaterial";
+        };
         // Statics
         GradientMaterial.Parse = function (source, scene, rootUrl) {
             return BABYLON.SerializationHelper.Parse(function () { return new GradientMaterial(source.name, scene); }, source, scene, rootUrl);

dist/preview release/materialsLibrary/babylon.gridMaterial.d.ts

@@ -50,6 +50,7 @@ declare module BABYLON {
         dispose(forceDisposeEffect?: boolean): void;
         clone(name: string): GridMaterial;
         serialize(): any;
+        getClassName(): string;
         static Parse(source: any, scene: Scene, rootUrl: string): GridMaterial;
     }
 }

dist/preview release/materialsLibrary/babylon.gridMaterial.js

@@ -161,6 +161,9 @@ var BABYLON;
             serializationObject.customType = "BABYLON.GridMaterial";
             return serializationObject;
         };
+        GridMaterial.prototype.getClassName = function () {
+            return "GridMaterial";
+        };
         GridMaterial.Parse = function (source, scene, rootUrl) {
             return BABYLON.SerializationHelper.Parse(function () { return new GridMaterial(source.name, scene); }, source, scene, rootUrl);
         };

dist/preview release/materialsLibrary/babylon.lavaMaterial.d.ts

@@ -30,6 +30,7 @@ declare module BABYLON {
         dispose(forceDisposeEffect?: boolean): void;
         clone(name: string): LavaMaterial;
         serialize(): any;
+        getClassName(): string;
         static Parse(source: any, scene: Scene, rootUrl: string): LavaMaterial;
     }
 }

dist/preview release/materialsLibrary/babylon.lavaMaterial.js

@@ -305,6 +305,9 @@ var BABYLON;
             serializationObject.customType = "BABYLON.LavaMaterial";
             return serializationObject;
         };
+        LavaMaterial.prototype.getClassName = function () {
+            return "LavaMaterial";
+        };
         // Statics
         LavaMaterial.Parse = function (source, scene, rootUrl) {
             return BABYLON.SerializationHelper.Parse(function () { return new LavaMaterial(source.name, scene); }, source, scene, rootUrl);

dist/preview release/materialsLibrary/babylon.normalMaterial.d.ts

@@ -23,6 +23,7 @@ declare module BABYLON {
         dispose(forceDisposeEffect?: boolean): void;
         clone(name: string): NormalMaterial;
         serialize(): any;
+        getClassName(): string;
         static Parse(source: any, scene: Scene, rootUrl: string): NormalMaterial;
     }
 }

dist/preview release/materialsLibrary/babylon.normalMaterial.js

@@ -278,6 +278,9 @@ var BABYLON;
             serializationObject.customType = "BABYLON.NormalMaterial";
             return serializationObject;
         };
+        NormalMaterial.prototype.getClassName = function () {
+            return "NormalMaterial";
+        };
         // Statics
         NormalMaterial.Parse = function (source, scene, rootUrl) {
             return BABYLON.SerializationHelper.Parse(function () { return new NormalMaterial(source.name, scene); }, source, scene, rootUrl);

dist/preview release/materialsLibrary/babylon.shadowOnlyMaterial.d.ts

@@ -12,6 +12,7 @@ declare module BABYLON {
         bindForSubMesh(world: Matrix, mesh: Mesh, subMesh: SubMesh): void;
         clone(name: string): ShadowOnlyMaterial;
         serialize(): any;
+        getClassName(): string;
         static Parse(source: any, scene: Scene, rootUrl: string): ShadowOnlyMaterial;
     }
 }

dist/preview release/materialsLibrary/babylon.shadowOnlyMaterial.js

@@ -172,6 +172,9 @@ var BABYLON;
             serializationObject.customType = "BABYLON.ShadowOnlyMaterial";
             return serializationObject;
         };
+        ShadowOnlyMaterial.prototype.getClassName = function () {
+            return "ShadowOnlyMaterial";
+        };
         // Statics
         ShadowOnlyMaterial.Parse = function (source, scene, rootUrl) {
             return BABYLON.SerializationHelper.Parse(function () { return new ShadowOnlyMaterial(source.name, scene); }, source, scene, rootUrl);

dist/preview release/materialsLibrary/babylon.simpleMaterial.d.ts

@@ -23,6 +23,7 @@ declare module BABYLON {
         dispose(forceDisposeEffect?: boolean): void;
         clone(name: string): SimpleMaterial;
         serialize(): any;
+        getClassName(): string;
         static Parse(source: any, scene: Scene, rootUrl: string): SimpleMaterial;
     }
 }

dist/preview release/materialsLibrary/babylon.simpleMaterial.js

@@ -245,6 +245,9 @@ var BABYLON;
             serializationObject.customType = "BABYLON.SimpleMaterial";
             return serializationObject;
         };
+        SimpleMaterial.prototype.getClassName = function () {
+            return "SimpleMaterial";
+        };
         // Statics
         SimpleMaterial.Parse = function (source, scene, rootUrl) {
             return BABYLON.SerializationHelper.Parse(function () { return new SimpleMaterial(source.name, scene); }, source, scene, rootUrl);

dist/preview release/materialsLibrary/babylon.skyMaterial.d.ts

@@ -23,6 +23,7 @@ declare module BABYLON {
         dispose(forceDisposeEffect?: boolean): void;
         clone(name: string): SkyMaterial;
         serialize(): any;
+        getClassName(): string;
         static Parse(source: any, scene: Scene, rootUrl: string): SkyMaterial;
     }
 }

dist/preview release/materialsLibrary/babylon.skyMaterial.js

@@ -179,6 +179,9 @@ var BABYLON;
             serializationObject.customType = "BABYLON.SkyMaterial";
             return serializationObject;
         };
+        SkyMaterial.prototype.getClassName = function () {
+            return "SkyMaterial";
+        };
         // Statics
         SkyMaterial.Parse = function (source, scene, rootUrl) {
             return BABYLON.SerializationHelper.Parse(function () { return new SkyMaterial(source.name, scene); }, source, scene, rootUrl);

dist/preview release/materialsLibrary/babylon.terrainMaterial.d.ts

@@ -36,6 +36,7 @@ declare module BABYLON {
         dispose(forceDisposeEffect?: boolean): void;
         clone(name: string): TerrainMaterial;
         serialize(): any;
+        getClassName(): string;
         static Parse(source: any, scene: Scene, rootUrl: string): TerrainMaterial;
     }
 }

dist/preview release/materialsLibrary/babylon.terrainMaterial.js

@@ -317,6 +317,9 @@ var BABYLON;
             serializationObject.customType = "BABYLON.TerrainMaterial";
             return serializationObject;
         };
+        TerrainMaterial.prototype.getClassName = function () {
+            return "TerrainMaterial";
+        };
         // Statics
         TerrainMaterial.Parse = function (source, scene, rootUrl) {
             return BABYLON.SerializationHelper.Parse(function () { return new TerrainMaterial(source.name, scene); }, source, scene, rootUrl);

dist/preview release/materialsLibrary/babylon.triPlanarMaterial.d.ts

@@ -36,6 +36,7 @@ declare module BABYLON {
         dispose(forceDisposeEffect?: boolean): void;
         clone(name: string): TriPlanarMaterial;
         serialize(): any;
+        getClassName(): string;
         static Parse(source: any, scene: Scene, rootUrl: string): TriPlanarMaterial;
     }
 }

dist/preview release/materialsLibrary/babylon.triPlanarMaterial.js

@@ -312,6 +312,9 @@ var BABYLON;
             serializationObject.customType = "BABYLON.TriPlanarMaterial";
             return serializationObject;
         };
+        TriPlanarMaterial.prototype.getClassName = function () {
+            return "TriPlanarMaterial";
+        };
         // Statics
         TriPlanarMaterial.Parse = function (source, scene, rootUrl) {
             return BABYLON.SerializationHelper.Parse(function () { return new TriPlanarMaterial(source.name, scene); }, source, scene, rootUrl);

dist/preview release/materialsLibrary/babylon.waterMaterial.d.ts

@@ -98,6 +98,7 @@ declare module BABYLON {
         dispose(forceDisposeEffect?: boolean): void;
         clone(name: string): WaterMaterial;
         serialize(): any;
+        getClassName(): string;
         static Parse(source: any, scene: Scene, rootUrl: string): WaterMaterial;
         static CreateDefaultMesh(name: string, scene: Scene): Mesh;
     }

dist/preview release/materialsLibrary/babylon.waterMaterial.js

@@ -498,6 +498,9 @@ var BABYLON;
             serializationObject.refractionTexture.isRenderTarget = true;
             return serializationObject;
         };
+        WaterMaterial.prototype.getClassName = function () {
+            return "WaterMaterial";
+        };
         // Statics
         WaterMaterial.Parse = function (source, scene, rootUrl) {
             return BABYLON.SerializationHelper.Parse(function () { return new WaterMaterial(source.name, scene); }, source, scene, rootUrl);

dist/preview release/what's new.md

@@ -5,6 +5,7 @@
 - Engine can now be initialized with an existing webgl context ([deltakosh](https://github.com/deltakosh))
 
 ## Updates
+- Better serialization support ([deltakosh](https://github.com/deltakosh))
 - Introduced `performanceMonitor` class to get better FPS analysis ([deltakosh](https://github.com/deltakosh))
 - GUI: Added support for pointer move events on projected UI ([deltakosh](https://github.com/deltakosh))
 - Normals are generated automatically by StandardMaterial if meshes do not have normals ([deltakosh](https://github.com/deltakosh))

gui/package.json

@@ -0,0 +1,37 @@
+{
+  "author": {
+    "name": "David CATUHE"
+  },
+  "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.1.0-alpha1.1",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/BabylonJS/Babylon.js.git"
+  },
+  "main": "../dist/preview release/gui/babylon.gui.js",
+  "files": [
+    "../dist/preview release/gui/babylon.gui.js",
+    "../dist/preview release/gui/babylon.gui.min.js",
+    "../dist/preview release/gui/babylon.gui.d.ts",
+
+    "package.json"
+  ],
+  "typings": "../dist/preview release/gui/babylon.gui.d.ts",
+  "keywords": [
+    "3D",
+    "javascript",
+    "html5",
+    "webgl",
+    "gui"
+  ],
+  "license": "Apache-2.0",
+  "dependencies": {
+    "babylonjs": "3.1.0-alpha1"
+  },
+  "engines": {
+    "node": "*"
+  },
+  "_id": "babylonjs-gui@3.1.0-alpha1",
+  "_from": "babylonjs-gui@"
+}

gui/src/advancedDynamicTexture.ts

@@ -217,10 +217,10 @@ module BABYLON.GUI {
                     var projectedPosition = Vector3.Project(position, mesh.getWorldMatrix(), scene.getTransformMatrix(), globalViewport);
 
                     if (projectedPosition.z < 0 || projectedPosition.z > 1) {
-                        control.isVisible = false;
+                        control.notRenderable = true;
                         continue;
                     }
-                    control.isVisible = true;
+                    control.notRenderable = false;
                     control._moveToProjectedPosition(projectedPosition);
                 }
             }

gui/src/controls/button.ts

@@ -38,7 +38,7 @@ module BABYLON.GUI {
 
         // While being a container, the button behaves like a control.
         public _processPicking(x: number, y: number, type: number): boolean {
-            if (!this.isHitTestVisible || !this.isVisible) {
+            if (!this.isHitTestVisible || !this.isVisible || this.notRenderable) {
                 return false;
             }
 

gui/src/controls/container.ts

@@ -127,7 +127,7 @@ module BABYLON.GUI {
         }
 
         public _draw(parentMeasure: Measure, context: CanvasRenderingContext2D): void {      
-            if (!this.isVisible) {
+            if (!this.isVisible || this.notRenderable) {
                 return;
             }
             context.save();
@@ -139,7 +139,7 @@ module BABYLON.GUI {
 
                 this._clipForChildren(context);
                 for (var child of this._children) {
-                    if (child.isVisible) {
+                    if (child.isVisible && !child.notRenderable) {
                         child._draw(this._measureForChildren, context);
                     }
                 }
@@ -148,7 +148,7 @@ module BABYLON.GUI {
         }
 
         public _processPicking(x: number, y: number, type: number): boolean {
-            if (!this.isHitTestVisible || !this.isVisible) {
+            if (!this.isHitTestVisible || !this.isVisible || this.notRenderable) {
                 return false;
             }
 

gui/src/controls/control.ts

@@ -43,6 +43,7 @@ module BABYLON.GUI {
         private _dummyVector2 = Vector2.Zero();
         private _downCount = 0;
         private _enterCount = 0;
+        private _doNotRender = false;
 
         public isHitTestVisible = true;
         public isPointerBlocker = false;
@@ -286,6 +287,19 @@ module BABYLON.GUI {
             }
         }
 
+        public get notRenderable(): boolean {
+            return this._doNotRender;
+        }
+
+        public set notRenderable(value: boolean) {
+            if (this._doNotRender === value) {
+                return;
+            }
+
+            this._doNotRender = value;
+            this._markAsDirty();
+        }
+
         public get isVisible(): boolean {
             return this._isVisible;
         }
@@ -429,10 +443,10 @@ module BABYLON.GUI {
             this._moveToProjectedPosition(projectedPosition);
 
             if (projectedPosition.z < 0 || projectedPosition.z > 1) {
-                this.isVisible = false;
+                this.notRenderable = true;
                 return;
             }
-            this.isVisible = true;
+            this.notRenderable = false;
         }
 
         public linkWithMesh(mesh: AbstractMesh): void {
@@ -736,7 +750,7 @@ module BABYLON.GUI {
         }
 
         public _processPicking(x: number, y: number, type: number): boolean {
-            if (!this.isHitTestVisible || !this.isVisible) {
+            if (!this.isHitTestVisible || !this.isVisible || this._doNotRender) {
                 return false;
             }
 

inspector/src/helpers/Helpers.ts

@@ -8,7 +8,7 @@ module INSPECTOR {
          */
         public static GET_TYPE(obj: any): string {
             if (obj != null && obj != undefined) {
-                let classname = BABYLON.Tools.getClassName(obj);
+                let classname = BABYLON.Tools.GetClassName(obj);
                 if (!classname || classname === 'object') {
                     classname = obj.constructor.name;
                     // classname is undefined in IE11

inspector/src/properties.ts

@@ -71,6 +71,12 @@ module INSPECTOR {
         'BaseTexture': {
             type: BABYLON.BaseTexture
         },
+        'CubeTexture': {
+            type: BABYLON.CubeTexture
+        },
+        'HDRCubeTexture': {
+            type: BABYLON.HDRCubeTexture
+        },
         'FontTexture': {
             type: BABYLON.FontTexture
         },

inspector/src/tabs/ConsoleTab.ts

@@ -47,15 +47,6 @@ module INSPECTOR {
             this._consolePanelContent = Helpers.CreateDiv('console-panel-content', consolePanel) as HTMLDivElement;
             this._bjsPanelContent     = Helpers.CreateDiv('console-panel-content', bjsPanel) as HTMLDivElement;
 
-            // save old console.log
-            this._oldConsoleLog       = console.log;
-            this._oldConsoleWarn      = console.warn;
-            this._oldConsoleError     = console.error;
-
-            console.log               = this._addConsoleLog.bind(this);
-            console.warn              = this._addConsoleWarn.bind(this);
-            console.error             = this._addConsoleError.bind(this);
-
             // Bjs logs
             this._bjsPanelContent.innerHTML = BABYLON.Tools.LogCache;
             BABYLON.Tools.OnNewCacheEntry = (entry: string) => {
@@ -83,6 +74,20 @@ module INSPECTOR {
             console.error = this._oldConsoleError;
 
         }
+        
+        public active(b: boolean){
+            super.active(b);
+            if(b){
+                // save old console.log
+                this._oldConsoleLog       = console.log;
+                this._oldConsoleWarn      = console.warn;
+                this._oldConsoleError     = console.error;
+
+                console.log               = this._addConsoleLog.bind(this);
+                console.warn              = this._addConsoleWarn.bind(this);
+                console.error             = this._addConsoleError.bind(this);
+            }
+        }
 
         private _message(type:string, message:any, caller:string) {
             let callerLine = Helpers.CreateDiv('caller', this._consolePanelContent);

inspector/src/tabs/StatsTab.ts

@@ -267,11 +267,8 @@ module INSPECTOR {
                     updateFct:() => { return "WebGL v" + this._engine.webGLVersion + " - " + this._glInfo.version + " - "+this._glInfo.renderer}
                 });
             }
-
-
-            // Register the update loop
-            this._scene.registerAfterRender(this._updateLoopHandler);
         }
+        
         private _createStatLabel(content:string, parent: HTMLElement) : HTMLElement {
             let elem = Helpers.CreateDiv('stat-label', parent);
             elem.textContent = content;
@@ -288,5 +285,12 @@ module INSPECTOR {
         public dispose() {
             this._scene.unregisterAfterRender(this._updateLoopHandler);
         }
+
+        public active(b: boolean){
+            super.active(b);
+            if(b){
+                this._scene.registerAfterRender(this._updateLoopHandler);
+            }
+        }
     }
 }

inspector/src/tabs/TabBar.ts

@@ -47,7 +47,6 @@ module INSPECTOR {
             //Check initialTab is defined and between tabs bounds
             if (!initialTab || initialTab < 0 || initialTab >= this._tabs.length) {
                 initialTab = 0;
-                console.warn('');
             }
 
             this._tabs[initialTab].active(true);

inspector/src/tabs/TextureTab.ts

@@ -79,12 +79,14 @@ module INSPECTOR {
             // Get the texture object
             let texture = item.adapter.object;
 
+            let imgs: HTMLImageElement[] = [];
             let img = Helpers.CreateElement('img', 'texture-image', this._imagePanel) as HTMLImageElement;
-            let img1 = Helpers.CreateElement('img', 'texture-image', this._imagePanel) as HTMLImageElement;
-            let img2 = Helpers.CreateElement('img', 'texture-image', this._imagePanel) as HTMLImageElement;
-            let img3 = Helpers.CreateElement('img', 'texture-image', this._imagePanel) as HTMLImageElement;
-            let img4 = Helpers.CreateElement('img', 'texture-image', this._imagePanel) as HTMLImageElement;
-            let img5 = Helpers.CreateElement('img', 'texture-image', this._imagePanel) as HTMLImageElement;
+            imgs.push(img);
+            
+            //Create five other images elements
+            for(let i = 0; i<5; i++){
+                imgs.push(Helpers.CreateElement('img', 'texture-image', this._imagePanel) as HTMLImageElement);
+            }
 
             if (texture instanceof BABYLON.MapTexture) {
                 // instance of Map texture
@@ -108,31 +110,8 @@ module INSPECTOR {
                 
                 // To display the texture after rendering
                 screenShotTexture.onAfterRenderObservable.add((faceIndex: number) => {
-                    let targetImg: HTMLImageElement;
-                    switch(faceIndex){
-                        case 0:
-                            targetImg = img;
-                            break;
-                        case 1:
-                            targetImg = img1;
-                            break;
-                        case 2:
-                            targetImg = img2;
-                            break;
-                        case 3:
-                            targetImg = img3;
-                            break;
-                        case 4:
-                            targetImg = img4;
-                            break;
-                        case 5:
-                            targetImg = img5;
-                            break;
-                        default:
-                            targetImg = img;
-                            break;
-                    }
-                    BABYLON.Tools.DumpFramebuffer(size.width, size.height, engine,  (data) => targetImg.src = data, "image/png");
+                    BABYLON.Tools.DumpFramebuffer(size.width, size.height, engine,  
+                        (data) => imgs[faceIndex].src = data, "image/png");
                 });
 
                 // Render the texture
@@ -140,7 +119,15 @@ module INSPECTOR {
                 scene.resetCachedMaterial();
                 screenShotTexture.render();
                 screenShotTexture.dispose();
-            } else if (texture.url) {
+            }else if(texture instanceof BABYLON.CubeTexture){
+                // Display all textures of the CubeTexture
+                let i: number = 0;
+                for(let filename of (texture as BABYLON.CubeTexture)['_files']){
+                    imgs[i].src = filename;
+                    i++;
+                }
+            }
+             else if (texture.url) {
                 // If an url is present, the texture is an image
                 img.src = texture.url;
 
@@ -148,9 +135,7 @@ module INSPECTOR {
                 // Dynamic texture
                 let base64Image = texture['_canvas'].toDataURL("image/png");
                 img.src = base64Image;
-
-            }
-
+            } 
 
         }
 

inspector/test/index.js

@@ -66,6 +66,17 @@ var Test = (function () {
             }
         });
 
+        // Skybox
+        var skybox = BABYLON.Mesh.CreateBox("skyBox", 500.0, scene);
+        var skyboxMaterial = new BABYLON.StandardMaterial("skyBox", scene);
+        skyboxMaterial.backFaceCulling = false;
+        skyboxMaterial.reflectionTexture = new BABYLON.CubeTexture("/assets/textures/skybox/TropicalSunnyDay", scene);
+        skyboxMaterial.reflectionTexture.coordinatesMode = BABYLON.Texture.SKYBOX_MODE;
+        skyboxMaterial.diffuseColor = new BABYLON.Color3(0, 0, 0);
+        skyboxMaterial.specularColor = new BABYLON.Color3(0, 0, 0);
+        skyboxMaterial.disableLighting = true;
+        skybox.material = skyboxMaterial;
+
         var sphere1 = BABYLON.Mesh.CreateSphere("Sphere1", 10.0, 9.0, scene);
         var sphere2 = BABYLON.Mesh.CreateSphere("Sphere2", 2.0, 9.0, scene);//Only two segments
         var sphere3 = BABYLON.Mesh.CreateSphere("Sphere3", 10.0, 9.0, scene);
@@ -249,7 +260,7 @@ var Test = (function () {
         sphere_3.parent = assets_mesh;
 
         for (var i=0; i<10 ; i++){
-            var inst = sphere_1.clone("C_" + i + "clone");
+            var inst = sphere_1.createInstance("C_" + i + "clone");
             inst.isVisible = true;
             inst.setEnabled = true;
             inst.parent = scene_mesh;
@@ -317,9 +328,8 @@ var Test = (function () {
         advancedTexture.addControl(checkbox);    
         advancedTexture.addControl(slider);    
         advancedTexture.addControl(line);    
-        advancedTexture.addControl(checkbox);    
-
-
+        advancedTexture.addControl(checkbox);  
+        
         this.scene = scene;
     };
     return Test;

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

@@ -14,7 +14,7 @@ module BABYLON.GLTF2.Extensions {
             return "KHR_materials_pbrSpecularGlossiness";
         }
 
-        protected loadMaterial(loader: GLTFLoader, material: IGLTFMaterial, assign: (material: Material) => void): boolean {
+        protected loadMaterial(loader: GLTFLoader, material: IGLTFMaterial, assign: (babylonMaterial: Material, isNew: boolean) => void): boolean {
             if (!material.extensions) {
                 return false;
             }
@@ -27,7 +27,7 @@ module BABYLON.GLTF2.Extensions {
             loader.createPbrMaterial(material);
             loader.loadMaterialBaseProperties(material);
             this._loadSpecularGlossinessProperties(loader, material, properties);
-            assign(material.babylonMaterial);
+            assign(material.babylonMaterial, true);
             return true;
         }
 
@@ -45,6 +45,7 @@ module BABYLON.GLTF2.Extensions {
 
             if (properties.specularGlossinessTexture) {
                 babylonMaterial.reflectivityTexture = loader.loadTexture(properties.specularGlossinessTexture);
+                babylonMaterial.reflectivityTexture.hasAlpha = true;
                 babylonMaterial.useMicroSurfaceFromReflectivityMapAlpha = true;
             }
 
@@ -53,4 +54,4 @@ module BABYLON.GLTF2.Extensions {
     }
 
     GLTFLoader.RegisterExtension(new KHRMaterialsPbrSpecularGlossiness());
-}
+}

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

@@ -10,7 +10,7 @@ module BABYLON.GLTF2.Extensions {
             return "MSFT_lod";
         }
 
-        protected loadMaterial(loader: GLTFLoader, material: IGLTFMaterial, assign: (material: Material) => void): boolean {
+        protected loadMaterial(loader: GLTFLoader, material: IGLTFMaterial, assign: (babylonMaterial: Material, isNew: boolean) => void): boolean {
             if (!material.extensions) {
                 return false;
             }
@@ -33,9 +33,9 @@ module BABYLON.GLTF2.Extensions {
             return true;
         }
 
-        private loadMaterialLOD(loader: GLTFLoader, material: IGLTFMaterial, materialLODs: number[], lod: number, assign: (material: Material) => void): void {
-            loader.loadMaterial(materialLODs[lod], babylonMaterial => {
-                assign(babylonMaterial);
+        private loadMaterialLOD(loader: GLTFLoader, material: IGLTFMaterial, materialLODs: number[], lod: number, assign: (material: Material, isNew: boolean) => void): void {
+            loader.loadMaterial(materialLODs[lod], (babylonMaterial, isNew) => {
+                assign(babylonMaterial, isNew);
 
                 // Loading is complete if this is the highest quality LOD.
                 if (lod === 0) {
@@ -56,4 +56,4 @@ module BABYLON.GLTF2.Extensions {
     }
 
     GLTFLoader.RegisterExtension(new MSFTLOD());
-}
+}

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

@@ -127,8 +127,8 @@ module BABYLON.GLTF2 {
         }
 
         private _onError(message: string): void {
-            this.dispose();
             this._errorCallback(message);
+            this.dispose();
         }
 
         private _onProgress(event: ProgressEvent): void {
@@ -392,14 +392,18 @@ module BABYLON.GLTF2 {
                         babylonMultiMaterial.subMaterials[i] = this._getDefaultMaterial();
                     }
                     else {
-                        this.loadMaterial(primitive.material, (babylonSubMaterial: Material) => {
+                        this.loadMaterial(primitive.material, (babylonMaterial, isNew) => {
+                            if (isNew && this._parent.onMaterialLoaded) {
+                                this._parent.onMaterialLoaded(babylonMaterial);
+                            }
+
                             if (this._renderReady) {
-                                babylonSubMaterial.forceCompilation(babylonMesh, babylonSubMaterial => {
-                                    this._assignMaterial(babylonMultiMaterial, i, babylonSubMaterial);
+                                babylonMaterial.forceCompilation(babylonMesh, babylonSubMaterial => {
+                                    babylonMultiMaterial.subMaterials[i] = babylonSubMaterial;
                                 });
                             }
                             else {
-                                this._assignMaterial(babylonMultiMaterial, i, babylonSubMaterial);
+                                babylonMultiMaterial.subMaterials[i] = babylonMaterial;
                             }
                         });
                     }
@@ -416,14 +420,6 @@ module BABYLON.GLTF2 {
             }
         }
 
-        private _assignMaterial(multiMaterial: MultiMaterial, index: number, subMaterial: Material): void {
-            multiMaterial.subMaterials[index] = subMaterial;
-
-            if (this._parent.onMaterialLoaded) {
-                this._parent.onMaterialLoaded(subMaterial);
-            }
-        }
-
         private _loadVertexDataAsync(primitive: IGLTFMeshPrimitive, onSuccess: (vertexData: VertexData) => void): void {
             var attributes = primitive.attributes;
             if (!attributes) {
@@ -920,12 +916,12 @@ module BABYLON.GLTF2 {
             this.loadMaterialAlphaProperties(material, properties.baseColorFactor);
         }
 
-        public loadMaterial(index: number, assign: (material: Material) => void): void {
+        public loadMaterial(index: number, assign: (babylonMaterial: Material, isNew: boolean) => void): void {
             var material = this._gltf.materials[index];
             material.index = index;
 
             if (material.babylonMaterial) {
-                assign(material.babylonMaterial);
+                assign(material.babylonMaterial, false);
                 return;
             }
 
@@ -936,7 +932,7 @@ module BABYLON.GLTF2 {
             this.createPbrMaterial(material);
             this.loadMaterialBaseProperties(material);
             this._loadMaterialMetallicRoughnessProperties(material);
-            assign(material.babylonMaterial);
+            assign(material.babylonMaterial, true);
         }
 
         public createPbrMaterial(material: IGLTFMaterial): void {

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

@@ -6,7 +6,7 @@ module BABYLON.GLTF2 {
 
         public abstract get name(): string;
 
-        protected loadMaterial(loader: GLTFLoader, material: IGLTFMaterial, assign: (material: Material) => void): boolean { return false; }
+        protected loadMaterial(loader: GLTFLoader, material: IGLTFMaterial, assign: (babylonMaterial: Material, isNew: boolean) => void): boolean { return false; }
 
         //
         // Utilities
@@ -14,7 +14,7 @@ module BABYLON.GLTF2 {
 
         public static _Extensions: GLTFLoaderExtension[] = [];
 
-        public static LoadMaterial(loader: GLTFLoader, material: IGLTFMaterial, assign: (material: Material) => void): boolean {
+        public static LoadMaterial(loader: GLTFLoader, material: IGLTFMaterial, assign: (babylonMaterial: Material, isNew: boolean) => void): boolean {
             return this._ApplyExtensions(extension => extension.loadMaterial(loader, material, assign));
         }
 

materialsLibrary/src/cell/babylon.cellMaterial.ts

@@ -296,6 +296,10 @@ module BABYLON {
             super.dispose(forceDisposeEffect);
         }
 
+        public getClassName(): string {
+            return "CellMaterial";
+        }
+
         public clone(name: string): CellMaterial {
             return SerializationHelper.Clone<CellMaterial>(() => new CellMaterial(name, this.getScene()), this);
         }

materialsLibrary/src/fire/babylon.fireMaterial.ts

@@ -296,6 +296,10 @@ module BABYLON {
             return false;    
         }         
 
+        public getClassName(): string {
+            return "FireMaterial";
+        }        
+
         public dispose(forceDisposeEffect?: boolean): void {
             if (this._diffuseTexture) {
                 this._diffuseTexture.dispose();

materialsLibrary/src/fur/babylon.furMaterial.ts

@@ -430,6 +430,10 @@ module BABYLON {
             return serializationObject;
         }
 
+        public getClassName(): string {
+            return "FurMaterial";
+        }          
+
         // Statics
         public static Parse(source: any, scene: Scene, rootUrl: string): FurMaterial {
             var material = SerializationHelper.Parse(() => new FurMaterial(source.name, scene), source, scene, rootUrl);

materialsLibrary/src/gradient/babylon.gradientMaterial.ts

@@ -296,6 +296,10 @@ module BABYLON {
             return serializationObject;
         }
 
+        public getClassName(): string {
+            return "GradientMaterial";
+        }              
+
         // Statics
         public static Parse(source: any, scene: Scene, rootUrl: string): GradientMaterial {
             return SerializationHelper.Parse(() => new GradientMaterial(source.name, scene), source, scene, rootUrl);

materialsLibrary/src/grid/babylon.gridmaterial.ts

@@ -192,6 +192,10 @@ module BABYLON {
             return serializationObject;
         }
 
+        public getClassName(): string {
+            return "GridMaterial";
+        }             
+
         public static Parse(source: any, scene: Scene, rootUrl: string): GridMaterial {
             return SerializationHelper.Parse(() => new GridMaterial(source.name, scene), source, scene, rootUrl);
         }

materialsLibrary/src/lava/babylon.lavaMaterial.ts

@@ -382,6 +382,10 @@ module BABYLON {
             return serializationObject;
         }
 
+        public getClassName(): string {
+            return "LavaMaterial";
+        }
+
         // Statics
         public static Parse(source: any, scene: Scene, rootUrl: string): LavaMaterial {
             return SerializationHelper.Parse(() => new LavaMaterial(source.name, scene), source, scene, rootUrl);

materialsLibrary/src/normal/babylon.normalMaterial.ts

@@ -333,6 +333,10 @@ module BABYLON {
             return serializationObject;
         }
 
+        public getClassName(): string {
+            return "NormalMaterial";
+        }        
+
         // Statics
         public static Parse(source: any, scene: Scene, rootUrl: string): NormalMaterial {
             return SerializationHelper.Parse(() => new NormalMaterial(source.name, scene), source, scene, rootUrl);

materialsLibrary/src/shadowOnly/babylon.shadowOnlyMaterial.ts

@@ -198,6 +198,10 @@ module BABYLON {
             return serializationObject;
         }
 
+        public getClassName(): string {
+            return "ShadowOnlyMaterial";
+        }               
+
         // Statics
         public static Parse(source: any, scene: Scene, rootUrl: string): ShadowOnlyMaterial {
             return SerializationHelper.Parse(() => new ShadowOnlyMaterial(source.name, scene), source, scene, rootUrl);

materialsLibrary/src/simple/babylon.simpleMaterial.ts

@@ -299,6 +299,10 @@ module BABYLON {
             return serializationObject;
         }
 
+        public getClassName(): string {
+            return "SimpleMaterial";
+        }               
+        
         // Statics
         public static Parse(source: any, scene: Scene, rootUrl: string): SimpleMaterial {
             return SerializationHelper.Parse(() => new SimpleMaterial(source.name, scene), source, scene, rootUrl);

materialsLibrary/src/sky/babylon.skyMaterial.ts

@@ -226,6 +226,10 @@ module BABYLON {
             return serializationObject;
         }
 
+        public getClassName(): string {
+            return "SkyMaterial";
+        }            
+
         // Statics
         public static Parse(source: any, scene: Scene, rootUrl: string): SkyMaterial {
             return SerializationHelper.Parse(() => new SkyMaterial(source.name, scene), source, scene, rootUrl);

materialsLibrary/src/terrain/babylon.terrainMaterial.ts

@@ -420,6 +420,10 @@ module BABYLON {
             return serializationObject;
         }
 
+        public getClassName(): string {
+            return "TerrainMaterial";
+        }
+
         // Statics
         public static Parse(source: any, scene: Scene, rootUrl: string): TerrainMaterial {
             return SerializationHelper.Parse(() => new TerrainMaterial(source.name, scene), source, scene, rootUrl);

materialsLibrary/src/triPlanar/babylon.triPlanarMaterial.ts

@@ -411,6 +411,10 @@ module BABYLON {
             return serializationObject;
         }
 
+        public getClassName(): string {
+            return "TriPlanarMaterial";
+        }
+
         // Statics
         public static Parse(source: any, scene: Scene, rootUrl: string): TriPlanarMaterial {
             return SerializationHelper.Parse(() => new TriPlanarMaterial(source.name, scene), source, scene, rootUrl);

materialsLibrary/src/water/babylon.waterMaterial.ts

@@ -614,6 +614,10 @@ module BABYLON {
             return serializationObject;
         }
 
+        public getClassName(): string {
+            return "WaterMaterial";
+        }        
+
         // Statics
         public static Parse(source: any, scene: Scene, rootUrl: string): WaterMaterial {
             return SerializationHelper.Parse(() => new WaterMaterial(source.name, scene), source, scene, rootUrl);

package.json

@@ -8,7 +8,7 @@
   ],
   "name": "babylonjs",
   "description": "Babylon.js is a JavaScript 3D engine based on webgl.",
-  "version": "3.1.0-alpha0",
+  "version": "3.1.0-alpha1",
   "repository": {
     "type": "git",
     "url": "https://github.com/BabylonJS/Babylon.js.git"
@@ -21,10 +21,6 @@
     "dist/preview release/babylon.max.js",
     "dist/preview release/babylon.worker.js",
 
-    "dist/preview release/gui/babylon.gui.js",
-    "dist/preview release/gui/babylon.gui.min.js",
-    "dist/preview release/gui/babylon.gui.d.ts",
-
     "dist/preview release/loaders/babylon.glTFFileLoader.min.js",
     "dist/preview release/loaders/babylon.objFileLoader.min.js",
     "dist/preview release/loaders/babylon.stlFileLoader.min.js",
@@ -74,6 +70,6 @@
   },
   "readme": "Babylon.js is a 3D engine based on webgl and javascript",
   "readmeFilename": "README.md",
-  "_id": "babylonjs@3.1.0-alpha0",
+  "_id": "babylonjs@3.1.0-alpha1",
   "_from": "babylonjs@"
 }

src/Audio/babylon.sound.ts

@@ -124,6 +124,9 @@ module BABYLON {
                                 if (url.indexOf(".wav", url.length - 4) !== -1) {
                                     codecSupportedFound = true;
                                 }
+                                if (url.indexOf("blob:") !== -1) {
+                                    codecSupportedFound = true;
+                                }
                                 if (codecSupportedFound) {
                                     // Loading sound using XHR2
                                     if (!this._streaming) {

src/Cameras/Inputs/babylon.arcRotateCameraGamepadInput.ts

@@ -63,13 +63,13 @@ module BABYLON {
             }
         }
 
-        getTypeName(): string {
+        getClassName(): string {
             return "ArcRotateCameraGamepadInput";
         }
 
         getSimpleName() {
             return "gamepad";
-        }
+        }        
     }
 
     CameraInputTypes["ArcRotateCameraGamepadInput"] = ArcRotateCameraGamepadInput;

src/Cameras/Inputs/babylon.arcRotateCameraKeyboardMoveInput.ts

@@ -108,7 +108,7 @@ module BABYLON {
             }
         }
 
-        getTypeName(): string {
+        getClassName(): string {
             return "ArcRotateCameraKeyboardMoveInput";
         }
         

src/Cameras/Inputs/babylon.arcRotateCameraMouseWheelInput.ts

@@ -41,7 +41,7 @@ module BABYLON {
             }
         }
 
-        getTypeName(): string {
+        getClassName(): string {
             return "ArcRotateCameraMouseWheelInput";
         }
 

src/Cameras/Inputs/babylon.arcRotateCameraPointersInput.ts

@@ -231,7 +231,7 @@ module BABYLON {
             ]);
         }
 
-        getTypeName(): string {
+        getClassName(): string {
             return "ArcRotateCameraPointersInput";
         }
 

src/Cameras/Inputs/babylon.arcRotateCameraVRDeviceOrientationInput.ts

@@ -48,7 +48,7 @@ module BABYLON {
             window.removeEventListener("deviceorientation", this._deviceOrientationHandler);
         }
 
-        getTypeName(): string {
+        getClassName(): string {
             return "ArcRotateCameraVRDeviceOrientationInput";
         }
 

src/Cameras/Inputs/babylon.freeCameraDeviceOrientationInput.ts

@@ -62,7 +62,7 @@ module BABYLON {
             this._camera.rotationQuaternion.w *= -1;
         }
 
-        getTypeName(): string {
+        getClassName(): string {
             return "FreeCameraDeviceOrientationInput";
         }
 

src/Cameras/Inputs/babylon.freeCameraGamepadInput.ts

@@ -74,7 +74,7 @@ module BABYLON {
             }
         }
 
-        getTypeName(): string {
+        getClassName(): string {
             return "FreeCameraGamepadInput";
         }
 

src/Cameras/Inputs/babylon.freeCameraKeyboardMoveInput.ts

@@ -105,7 +105,7 @@ module BABYLON {
             }
         }
 
-        getTypeName(): string {
+        getClassName(): string {
             return "FreeCameraKeyboardMoveInput";
         }
 

src/Cameras/Inputs/babylon.freeCameraMouseInput.ts

@@ -15,7 +15,7 @@ module BABYLON {
         private previousPosition: { x: number, y: number };
 
         constructor(public touchEnabled = true) {
-        }
+        }           
 
         attachControl(element: HTMLElement, noPreventDefault?: boolean) {
             var engine = this.camera.getEngine();
@@ -129,13 +129,13 @@ module BABYLON {
             }
         }
 
-        getTypeName(): string {
+        getClassName(): string {
             return "FreeCameraMouseInput";
         }
 
         getSimpleName() {
             return "mouse";
-        }
+        }      
     }
 
     CameraInputTypes["FreeCameraMouseInput"] = FreeCameraMouseInput;

src/Cameras/Inputs/babylon.freeCameraTouchInput.ts

@@ -128,7 +128,7 @@ module BABYLON {
             }
         }
 
-        getTypeName(): string {
+        getClassName(): string {
             return "FreeCameraTouchInput";
         }
 

src/Cameras/Inputs/babylon.freeCameraVirtualJoystickInput.ts

@@ -49,7 +49,7 @@ module BABYLON {
             this._rightjoystick.releaseCanvas();
         }
 
-        getTypeName(): string {
+        getClassName(): string {
             return "FreeCameraVirtualJoystickInput";
         }
         

src/Cameras/babylon.cameraInputsManager.ts

@@ -3,7 +3,7 @@ module BABYLON {
 
     export interface ICameraInput<TCamera extends BABYLON.Camera> {
         camera: TCamera;
-        getTypeName(): string;
+        getClassName(): string;
         getSimpleName(): string;
         attachControl: (element: HTMLElement, noPreventDefault?: boolean) => void;
         detachControl: (element: HTMLElement) => void;
@@ -64,7 +64,7 @@ module BABYLON {
         public removeByType(inputType: string) {
             for (var cam in this.attached) {
                 var input = this.attached[cam];
-                if (input.getTypeName() === inputType) {
+                if (input.getClassName() === inputType) {
                     input.detachControl(this.attachedElement);
                     delete this.attached[cam];
                     this.rebuildInputCheck();
@@ -137,7 +137,7 @@ module BABYLON {
             for (var cam in this.attached) {
                 var input = this.attached[cam];
                 var res = SerializationHelper.Serialize(input);
-                inputs[input.getTypeName()] = res;
+                inputs[input.getClassName()] = res;
             }
 
             serializedCamera.inputsmgr = inputs;
@@ -159,7 +159,7 @@ module BABYLON {
             } else { 
                 //2016-03-08 this part is for managing backward compatibility
                 for (var n in this.attached) {
-                    var construct = CameraInputTypes[this.attached[n].getTypeName()];
+                    var construct = CameraInputTypes[this.attached[n].getClassName()];
                     if (construct) {
                         var input = SerializationHelper.Parse(() => { return new construct() }, parsedCamera, null);
                         this.remove(this.attached[n]);

src/Materials/PBR/babylon.pbrBaseMaterial.ts

@@ -472,7 +472,9 @@
             this._environmentBRDFTexture = TextureTools.GetEnvironmentBRDFTexture(scene);
         }
 
-        public abstract getClassName(): string;
+        public getClassName(): string {
+            return "PBRBaseMaterial";
+        }  
 
         @serialize()
         public get useLogarithmicDepth(): boolean {

src/Materials/PBR/babylon.pbrBaseSimpleMaterial.ts

@@ -198,5 +198,9 @@
 
             this._useAmbientInGrayScale = true;
         }
+
+        public getClassName(): string {
+            return "PBRBaseSimpleMaterial";
+        }        
     }
 }

src/Materials/PBR/babylon.pbrMaterial.ts

@@ -227,6 +227,20 @@
         @serialize()
         @expandToProperty("_markAllSubMeshesAsTexturesDirty")
         public useAlphaFromAlbedoTexture = false;
+
+        /**
+         * Enforces alpha test in opaque or blend mode in order to improve the performances of some situations.
+         */
+        @serialize()
+        @expandToProperty("_markAllSubMeshesAsTexturesDirty")
+        public forceAlphaTest = false;
+
+        /**
+         * Defines the alpha limits in alpha test mode.
+         */
+        @serialize()
+        @expandToProperty("_markAllSubMeshesAsTexturesDirty")
+        public alphaCutOff = 0.4;
         
         /**
          * Specifies that the material will keeps the specular highlights over a transparent surface (only the most limunous ones).

src/Materials/Textures/babylon.baseTexture.ts

@@ -81,6 +81,10 @@
             return this.name;
         }
 
+        public getClassName(): string {
+            return "BaseTexture";
+        }             
+
         public animations = new Array<Animation>();
 
         /**
@@ -328,28 +332,32 @@
             return serializationObject;
         }
 
-        public static WhenAllReady(textures: BaseTexture[], onLoad: () => void): void {
-            var numReady = 0;
+        public static WhenAllReady(textures: BaseTexture[], callback: () => void): void {
+            let numRemaining = textures.length;
+            if (numRemaining === 0) {
+                callback();
+                return;
+            }
 
             for (var i = 0; i < textures.length; i++) {
                 var texture = textures[i];
 
                 if (texture.isReady()) {
-                    if (++numReady === textures.length) {
-                        onLoad();
+                    if (--numRemaining === 0) {
+                        callback();
                     }
                 }
                 else {
-                    var observable = (texture as any).onLoadObservable as Observable<Texture>;
+                    var onLoadObservable = (texture as any).onLoadObservable as Observable<Texture>;
 
-                    let callback = () => {
-                        observable.removeCallback(callback);
-                        if (++numReady === textures.length) {
-                            onLoad();
+                    let onLoadCallback = () => {
+                        onLoadObservable.removeCallback(onLoadCallback);
+                        if (--numRemaining === 0) {
+                            callback();
                         }
                     };
 
-                    observable.add(callback);
+                    onLoadObservable.add(onLoadCallback);
                 }
             }
         }

src/Materials/Textures/babylon.cubeTexture.ts

@@ -14,11 +14,11 @@
             return new CubeTexture("", scene, null, noMipmap, files);
         }
 
-        public static CreateFromPrefilteredData(url: string, scene: Scene) {
-            return new CubeTexture(url, scene, null, false, null, null, null, undefined, true);
+        public static CreateFromPrefilteredData(url: string, scene: Scene, forcedExtension = null) {
+            return new CubeTexture(url, scene, null, false, null, null, null, undefined, true, forcedExtension);
         }
 
-        constructor(rootUrl: string, scene: Scene, extensions?: string[], noMipmap?: boolean, files?: string[], onLoad: () => void = null, onError: () => void = null, format: number = Engine.TEXTUREFORMAT_RGBA, prefiltered = false) {
+        constructor(rootUrl: string, scene: Scene, extensions?: string[], noMipmap?: boolean, files?: string[], onLoad: () => void = null, onError: () => void = null, format: number = Engine.TEXTUREFORMAT_RGBA, prefiltered = false, forcedExtension = null) {
             super(scene);
 
             this.name = rootUrl;
@@ -59,10 +59,10 @@
             if (!this._texture) {
                 if (!scene.useDelayedTextureLoading) {
                     if (prefiltered) {
-                        this._texture = scene.getEngine().createPrefilteredCubeTexture(rootUrl, scene, this.lodGenerationScale, this.lodGenerationOffset, onLoad, onError, format);
+                        this._texture = scene.getEngine().createPrefilteredCubeTexture(rootUrl, scene, this.lodGenerationScale, this.lodGenerationOffset, onLoad, onError, format, forcedExtension);
                     }
                     else {
-                        this._texture = scene.getEngine().createCubeTexture(rootUrl, scene, files, noMipmap, onLoad, onError, this._format);
+                        this._texture = scene.getEngine().createCubeTexture(rootUrl, scene, files, noMipmap, onLoad, onError, this._format, forcedExtension);
                     }
                 } else {
                     this.delayLoadState = Engine.DELAYLOADSTATE_NOTLOADED;

src/Materials/Textures/babylon.texture.ts

@@ -337,6 +337,10 @@
             return serializationObject;
         }
 
+        public getClassName(): string {
+            return "Texture";
+        }     
+
         // Statics
         public static CreateFromBase64String(data: string, name: string, scene: Scene, noMipmap?: boolean, invertY?: boolean, samplingMode: number = Texture.TRILINEAR_SAMPLINGMODE, onLoad: () => void = null, onError: () => void = null, format: number = Engine.TEXTUREFORMAT_RGBA): Texture {
             return new Texture("data:" + name, scene, noMipmap, invertY, samplingMode, onLoad, onError, data, false, format);