Nightly

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

@@ -564,15 +564,15 @@ var BABYLON;
                     Matrix2D._TempCompose1.multiplyToRef(Matrix2D._TempPostTranslationMatrix, result);
                 }
             };
-            Matrix2D._TempPreTranslationMatrix = Matrix2D.Identity();
-            Matrix2D._TempPostTranslationMatrix = Matrix2D.Identity();
-            Matrix2D._TempRotationMatrix = Matrix2D.Identity();
-            Matrix2D._TempScalingMatrix = Matrix2D.Identity();
-            Matrix2D._TempCompose0 = Matrix2D.Identity();
-            Matrix2D._TempCompose1 = Matrix2D.Identity();
-            Matrix2D._TempCompose2 = Matrix2D.Identity();
             return Matrix2D;
         }());
+        Matrix2D._TempPreTranslationMatrix = Matrix2D.Identity();
+        Matrix2D._TempPostTranslationMatrix = Matrix2D.Identity();
+        Matrix2D._TempRotationMatrix = Matrix2D.Identity();
+        Matrix2D._TempScalingMatrix = Matrix2D.Identity();
+        Matrix2D._TempCompose0 = Matrix2D.Identity();
+        Matrix2D._TempCompose1 = Matrix2D.Identity();
+        Matrix2D._TempCompose2 = Matrix2D.Identity();
         GUI.Matrix2D = Matrix2D;
     })(GUI = BABYLON.GUI || (BABYLON.GUI = {}));
 })(BABYLON || (BABYLON = {}));
@@ -685,12 +685,12 @@ var BABYLON;
                 enumerable: true,
                 configurable: true
             });
-            // Static
-            ValueAndUnit._Regex = /(^-?\d*(\.\d+)?)(%|px)?/;
-            ValueAndUnit._UNITMODE_PERCENTAGE = 0;
-            ValueAndUnit._UNITMODE_PIXEL = 1;
             return ValueAndUnit;
         }());
+        // Static
+        ValueAndUnit._Regex = /(^-?\d*(\.\d+)?)(%|px)?/;
+        ValueAndUnit._UNITMODE_PERCENTAGE = 0;
+        ValueAndUnit._UNITMODE_PIXEL = 1;
         GUI.ValueAndUnit = ValueAndUnit;
     })(GUI = BABYLON.GUI || (BABYLON.GUI = {}));
 })(BABYLON || (BABYLON = {}));
@@ -1630,16 +1630,16 @@ var BABYLON;
                 context.scale(1 / width, 1 / height);
                 context.translate(-x, -y);
             };
-            // Statics
-            Control._HORIZONTAL_ALIGNMENT_LEFT = 0;
-            Control._HORIZONTAL_ALIGNMENT_RIGHT = 1;
-            Control._HORIZONTAL_ALIGNMENT_CENTER = 2;
-            Control._VERTICAL_ALIGNMENT_TOP = 0;
-            Control._VERTICAL_ALIGNMENT_BOTTOM = 1;
-            Control._VERTICAL_ALIGNMENT_CENTER = 2;
-            Control._FontHeightSizes = {};
             return Control;
         }());
+        // Statics
+        Control._HORIZONTAL_ALIGNMENT_LEFT = 0;
+        Control._HORIZONTAL_ALIGNMENT_RIGHT = 1;
+        Control._HORIZONTAL_ALIGNMENT_CENTER = 2;
+        Control._VERTICAL_ALIGNMENT_TOP = 0;
+        Control._VERTICAL_ALIGNMENT_BOTTOM = 1;
+        Control._VERTICAL_ALIGNMENT_CENTER = 2;
+        Control._FontHeightSizes = {};
         GUI.Control = Control;
     })(GUI = BABYLON.GUI || (BABYLON.GUI = {}));
 })(BABYLON || (BABYLON = {}));
@@ -3196,13 +3196,13 @@ var BABYLON;
                 enumerable: true,
                 configurable: true
             });
-            // Static
-            Image._STRETCH_NONE = 0;
-            Image._STRETCH_FILL = 1;
-            Image._STRETCH_UNIFORM = 2;
-            Image._STRETCH_EXTEND = 3;
             return Image;
         }(GUI.Control));
+        // Static
+        Image._STRETCH_NONE = 0;
+        Image._STRETCH_FILL = 1;
+        Image._STRETCH_UNIFORM = 2;
+        Image._STRETCH_EXTEND = 3;
         GUI.Image = Image;
     })(GUI = BABYLON.GUI || (BABYLON.GUI = {}));
 })(BABYLON || (BABYLON = {}));
@@ -3858,7 +3858,7 @@ var BABYLON;
             InputText.prototype.processKey = function (keyCode, key) {
                 // Specific cases
                 switch (keyCode) {
-                    case 8:// BACKSPACE
+                    case 8:
                         if (this._text && this._text.length > 0) {
                             if (this._cursorOffset === 0) {
                                 this.text = this._text.substr(0, this._text.length - 1);
@@ -3871,27 +3871,27 @@ var BABYLON;
                             }
                         }
                         return;
-                    case 46:// DELETE
+                    case 46:
                         if (this._text && this._text.length > 0) {
                             var deletePosition = this._text.length - this._cursorOffset;
                             this.text = this._text.slice(0, deletePosition) + this._text.slice(deletePosition + 1);
                             this._cursorOffset--;
                         }
                         return;
-                    case 13:// RETURN
+                    case 13:
                         this._host.focusedControl = null;
                         return;
-                    case 35:// END
+                    case 35:
                         this._cursorOffset = 0;
                         this._blinkIsEven = false;
                         this._markAsDirty();
                         return;
-                    case 36:// HOME
+                    case 36:
                         this._cursorOffset = this._text.length;
                         this._blinkIsEven = false;
                         this._markAsDirty();
                         return;
-                    case 37:// LEFT
+                    case 37:
                         this._cursorOffset++;
                         if (this._cursorOffset > this._text.length) {
                             this._cursorOffset = this._text.length;
@@ -3899,7 +3899,7 @@ var BABYLON;
                         this._blinkIsEven = false;
                         this._markAsDirty();
                         return;
-                    case 39:// RIGHT
+                    case 39:
                         this._cursorOffset--;
                         if (this._cursorOffset < 0) {
                             this._cursorOffset = 0;

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

@@ -924,10 +924,10 @@ var INSPECTOR;
             enumerable: true,
             configurable: true
         });
-        // a unique name for this adapter, to retrieve its own key in the local storage
-        Adapter._name = BABYLON.Geometry.RandomId();
         return Adapter;
     }());
+    // a unique name for this adapter, to retrieve its own key in the local storage
+    Adapter._name = BABYLON.Geometry.RandomId();
     INSPECTOR.Adapter = Adapter;
 })(INSPECTOR || (INSPECTOR = {}));
 
@@ -2029,12 +2029,12 @@ var INSPECTOR;
                 });
             }
         };
-        // Array representing the simple type. All others are considered 'complex'
-        PropertyLine._SIMPLE_TYPE = ['number', 'string', 'boolean'];
-        // The number of pixel at each children step
-        PropertyLine._MARGIN_LEFT = 15;
         return PropertyLine;
     }());
+    // Array representing the simple type. All others are considered 'complex'
+    PropertyLine._SIMPLE_TYPE = ['number', 'string', 'boolean'];
+    // The number of pixel at each children step
+    PropertyLine._MARGIN_LEFT = 15;
     INSPECTOR.PropertyLine = PropertyLine;
 })(INSPECTOR || (INSPECTOR = {}));
 
@@ -2657,10 +2657,10 @@ var INSPECTOR;
                 }
             }
         };
-        /** All properties are refreshed every 250ms */
-        Scheduler.REFRESH_TIME = 250;
         return Scheduler;
     }());
+    /** All properties are refreshed every 250ms */
+    Scheduler.REFRESH_TIME = 250;
     INSPECTOR.Scheduler = Scheduler;
 })(INSPECTOR || (INSPECTOR = {}));
 

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

@@ -53,10 +53,10 @@ var BABYLON;
             return ((data.indexOf("scene") !== -1) && (data.indexOf("node") !== -1));
         };
         GLTFFileLoader._parse = function (data, onError) {
-            if (data instanceof ArrayBuffer) {
-                return GLTFFileLoader._parseBinary(data, onError);
-            }
             try {
+                if (data instanceof ArrayBuffer) {
+                    return GLTFFileLoader._parseBinary(data, onError);
+                }
                 return {
                     json: JSON.parse(data),
                     bin: null
@@ -223,11 +223,11 @@ var BABYLON;
             }
             return result;
         };
-        // V1 options
-        GLTFFileLoader.HomogeneousCoordinates = false;
-        GLTFFileLoader.IncrementalLoading = true;
         return GLTFFileLoader;
     }());
+    // V1 options
+    GLTFFileLoader.HomogeneousCoordinates = false;
+    GLTFFileLoader.IncrementalLoading = true;
     BABYLON.GLTFFileLoader = GLTFFileLoader;
     var BinaryReader = (function () {
         function BinaryReader(arrayBuffer) {
@@ -1789,9 +1789,9 @@ var BABYLON;
                     }
                 }
             };
-            GLTFLoader.Extensions = {};
             return GLTFLoader;
         }());
+        GLTFLoader.Extensions = {};
         GLTF1.GLTFLoader = GLTFLoader;
         ;
         BABYLON.GLTFFileLoader.CreateGLTFLoaderV1 = function () { return new GLTFLoader(); };
@@ -2043,10 +2043,10 @@ var BABYLON;
                 }
                 return GLTFUtils._DefaultMaterial;
             };
-            // The GLTF default material
-            GLTFUtils._DefaultMaterial = null;
             return GLTFUtils;
         }());
+        // The GLTF default material
+        GLTFUtils._DefaultMaterial = null;
         GLTF1.GLTFUtils = GLTFUtils;
     })(GLTF1 = BABYLON.GLTF1 || (BABYLON.GLTF1 = {}));
 })(BABYLON || (BABYLON = {}));

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

@@ -299,6 +299,7 @@ declare module BABYLON.GLTF2 {
         private _parent;
         private _rootUrl;
         private _defaultMaterial;
+        private _rootNode;
         private _successCallback;
         private _progressCallback;
         private _errorCallback;
@@ -317,7 +318,7 @@ declare module BABYLON.GLTF2 {
         importMeshAsync(meshesNames: any, scene: Scene, data: IGLTFLoaderData, rootUrl: string, onSuccess: (meshes: AbstractMesh[], particleSystems: ParticleSystem[], skeletons: Skeleton[]) => void, onProgress: (event: ProgressEvent) => void, onError: (message: string) => void): void;
         loadAsync(scene: Scene, data: IGLTFLoaderData, rootUrl: string, onSuccess: () => void, onProgress: (event: ProgressEvent) => void, onError: (message: string) => void): void;
         private _loadAsync(nodeNames, scene, data, rootUrl, onSuccess, onProgress, onError);
-        private _onError(message);
+        _onError(message: string): void;
         private _onProgress(event);
         _executeWhenRenderReady(func: () => void): void;
         private _onRenderReady();
@@ -343,7 +344,8 @@ declare module BABYLON.GLTF2 {
         _traverseNode(index: number, action: (node: IGLTFNode, index: number, parentNode: IGLTFNode) => boolean, parentNode?: IGLTFNode): void;
         private _loadAnimations();
         private _loadAnimationChannel(animation, animationIndex, channelIndex);
-        private _loadBufferAsync(index, onSuccess);
+        private _validateUri(uri);
+        private _loadBufferAsync(buffer, onSuccess);
         private _buildInt8ArrayBuffer(buffer, byteOffset, byteLength, byteStride, bytePerComponent);
         private _buildUint8ArrayBuffer(buffer, byteOffset, byteLength, byteStride, bytePerComponent);
         private _buildInt16ArrayBuffer(buffer, byteOffset, byteLength, byteStride, bytePerComponent);
@@ -366,6 +368,7 @@ declare module BABYLON.GLTF2 {
         _loadMaterialBaseProperties(material: IGLTFMaterial): void;
         _loadMaterialAlphaProperties(material: IGLTFMaterial, colorFactor?: number[]): void;
         _loadTexture(textureInfo: IGLTFTextureInfo): Texture;
+        _getArrayItem<T>(array: ArrayLike<T>, index: number, name: string): T;
     }
 }
 

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

@@ -53,10 +53,10 @@ var BABYLON;
             return ((data.indexOf("scene") !== -1) && (data.indexOf("node") !== -1));
         };
         GLTFFileLoader._parse = function (data, onError) {
-            if (data instanceof ArrayBuffer) {
-                return GLTFFileLoader._parseBinary(data, onError);
-            }
             try {
+                if (data instanceof ArrayBuffer) {
+                    return GLTFFileLoader._parseBinary(data, onError);
+                }
                 return {
                     json: JSON.parse(data),
                     bin: null
@@ -223,11 +223,11 @@ var BABYLON;
             }
             return result;
         };
-        // V1 options
-        GLTFFileLoader.HomogeneousCoordinates = false;
-        GLTFFileLoader.IncrementalLoading = true;
         return GLTFFileLoader;
     }());
+    // V1 options
+    GLTFFileLoader.HomogeneousCoordinates = false;
+    GLTFFileLoader.IncrementalLoading = true;
     BABYLON.GLTFFileLoader = GLTFFileLoader;
     var BinaryReader = (function () {
         function BinaryReader(arrayBuffer) {
@@ -390,24 +390,36 @@ var BABYLON;
                 this._loadAsync(null, scene, data, rootUrl, onSuccess, onProgress, onError);
             };
             GLTFLoader.prototype._loadAsync = function (nodeNames, scene, data, rootUrl, onSuccess, onProgress, onError) {
-                this._loadData(data);
-                this._babylonScene = scene;
-                this._rootUrl = rootUrl;
-                this._successCallback = onSuccess;
-                this._progressCallback = onProgress;
-                this._errorCallback = onError;
-                this._addPendingData(this);
-                this._loadScene(nodeNames);
-                this._loadAnimations();
-                this._removePendingData(this);
+                try {
+                    this._loadData(data);
+                    this._babylonScene = scene;
+                    this._rootUrl = rootUrl;
+                    this._successCallback = onSuccess;
+                    this._progressCallback = onProgress;
+                    this._errorCallback = onError;
+                    this._addPendingData(this);
+                    this._loadScene(nodeNames);
+                    this._loadAnimations();
+                    this._removePendingData(this);
+                }
+                catch (e) {
+                    this._onError(e.message);
+                }
             };
             GLTFLoader.prototype._onError = function (message) {
+                if (this._disposed) {
+                    return;
+                }
+                BABYLON.Tools.Error("glTF Loader Error: " + message);
                 if (this._errorCallback) {
                     this._errorCallback(message);
                 }
                 this.dispose();
             };
             GLTFLoader.prototype._onProgress = function (event) {
+                if (this._disposed) {
+                    return;
+                }
                 if (this._progressCallback) {
                     this._progressCallback(event);
                 }
@@ -421,8 +433,7 @@ var BABYLON;
                 }
             };
             GLTFLoader.prototype._onRenderReady = function () {
-                var rootNode = this._gltf.nodes[this._gltf.nodes.length - 1];
-                rootNode.babylonMesh.setEnabled(true);
+                this._rootNode.babylonMesh.setEnabled(true);
                 this._startAnimations();
                 this._successCallback();
                 this._renderReadyObservable.notifyObservers(this);
@@ -438,25 +449,22 @@ var BABYLON;
             };
             GLTFLoader.prototype._loadData = function (data) {
                 this._gltf = data.json;
-                var binaryBuffer;
-                var buffers = this._gltf.buffers;
-                if (buffers && buffers[0].uri === undefined) {
-                    binaryBuffer = buffers[0];
-                }
                 if (data.bin) {
-                    if (binaryBuffer) {
+                    var buffers = this._gltf.buffers;
+                    if (buffers && buffers[0] && !buffers[0].uri) {
+                        var binaryBuffer = buffers[0];
                         if (binaryBuffer.byteLength != data.bin.byteLength) {
                             BABYLON.Tools.Warn("Binary buffer length (" + binaryBuffer.byteLength + ") from JSON does not match chunk length (" + data.bin.byteLength + ")");
                         }
+                        binaryBuffer.loadedData = data.bin;
                     }
                     else {
                         BABYLON.Tools.Warn("Unexpected BIN chunk");
                     }
-                    binaryBuffer.loadedData = data.bin;
                 }
             };
             GLTFLoader.prototype._getMeshes = function () {
-                var meshes = [];
+                var meshes = [this._rootNode.babylonMesh];
                 var nodes = this._gltf.nodes;
                 if (nodes) {
                     nodes.forEach(function (node) {
@@ -494,13 +502,16 @@ var BABYLON;
                 this._getAnimationTargets().forEach(function (target) { return _this._babylonScene.beginAnimation(target, 0, Number.MAX_VALUE, true); });
             };
             GLTFLoader.prototype._loadScene = function (nodeNames) {
-                var scene = this._gltf.scenes[this._gltf.scene || 0];
-                var rootNode = { name: "root", children: scene.nodes };
+                var scene = this._getArrayItem(this._gltf.scenes, this._gltf.scene || 0, "Scene");
+                if (!scene) {
+                    return;
+                }
+                this._rootNode = { name: "__root__" };
                 switch (this._parent.coordinateSystemMode) {
                     case BABYLON.GLTFLoaderCoordinateSystemMode.AUTO:
                         if (!this._babylonScene.useRightHandedSystem) {
-                            rootNode.rotation = [0, 1, 0, 0];
-                            rootNode.scale = [1, 1, -1];
+                            this._rootNode.rotation = [0, 1, 0, 0];
+                            this._rootNode.scale = [1, 1, -1];
                         }
                         break;
                     case BABYLON.GLTFLoaderCoordinateSystemMode.PASS_THROUGH:
@@ -511,22 +522,23 @@ var BABYLON;
                         break;
                     default:
                         BABYLON.Tools.Error("Invalid coordinate system mode (" + this._parent.coordinateSystemMode + ")");
-                        break;
+                        return;
                 }
-                // Inject a root node into the scene.
-                this._gltf.nodes = this._gltf.nodes || [];
-                scene.nodes = [this._gltf.nodes.length];
-                this._gltf.nodes.push(rootNode);
+                this._loadNode(this._rootNode);
                 var nodeIndices = scene.nodes;
                 this._traverseNodes(nodeIndices, function (node, index, parentNode) {
                     node.index = index;
                     node.parent = parentNode;
                     return true;
-                });
+                }, this._rootNode);
                 var materials = this._gltf.materials;
                 if (materials) {
                     materials.forEach(function (material, index) { return material.index = index; });
                 }
+                var skins = this._gltf.skins;
+                if (skins) {
+                    skins.forEach(function (skin, index) { return skin.index = index; });
+                }
                 if (nodeNames) {
                     if (!(nodeNames instanceof Array)) {
                         nodeNames = [nodeNames];
@@ -538,14 +550,18 @@ var BABYLON;
                             return false;
                         }
                         return true;
-                    });
+                    }, this._rootNode);
                     nodeIndices = filteredNodeIndices;
                 }
                 for (var i = 0; i < nodeIndices.length; i++) {
-                    this._loadNode(this._gltf.nodes[nodeIndices[i]]);
+                    var node = this._getArrayItem(this._gltf.nodes, nodeIndices[i], "Node");
+                    if (!node) {
+                        return;
+                    }
+                    this._loadNode(node);
                 }
                 // Disable the root mesh until the asset is ready to render.
-                rootNode.babylonMesh.setEnabled(false);
+                this._rootNode.babylonMesh.setEnabled(false);
             };
             GLTFLoader.prototype._loadNode = function (node) {
                 if (GLTF2.GLTFLoaderExtension.LoadNode(this, node)) {
@@ -554,15 +570,20 @@ var BABYLON;
                 node.babylonMesh = new BABYLON.Mesh(node.name || "mesh" + node.index, this._babylonScene);
                 this._loadTransform(node);
                 if (node.mesh !== undefined) {
-                    var mesh = this._gltf.meshes[node.mesh];
+                    var mesh = this._getArrayItem(this._gltf.meshes, node.mesh, "Mesh");
+                    if (!mesh) {
+                        return;
+                    }
                     this._loadMesh(node, mesh);
                 }
                 node.babylonMesh.parent = node.parent ? node.parent.babylonMesh : null;
                 node.babylonAnimationTargets = node.babylonAnimationTargets || [];
                 node.babylonAnimationTargets.push(node.babylonMesh);
                 if (node.skin !== undefined) {
-                    var skin = this._gltf.skins[node.skin];
-                    skin.index = node.skin;
+                    var skin = this._getArrayItem(this._gltf.skins, node.skin, "Skin");
+                    if (!skin) {
+                        return;
+                    }
                     node.babylonMesh.skeleton = this._loadSkin(skin);
                 }
                 if (node.camera !== undefined) {
@@ -570,7 +591,11 @@ var BABYLON;
                 }
                 if (node.children) {
                     for (var i = 0; i < node.children.length; i++) {
-                        this._loadNode(this._gltf.nodes[node.children[i]]);
+                        var childNode = this._getArrayItem(this._gltf.nodes, node.children[i], "Node");
+                        if (!childNode) {
+                            return;
+                        }
+                        this._loadNode(childNode);
                     }
                 }
             };
@@ -602,11 +627,14 @@ var BABYLON;
                             indicesStart: vertexData.indices.length,
                             indicesCount: subVertexData.indices.length,
                             loadMaterial: function () {
-                                if (primitive.material === undefined) {
+                                if (primitive.material == null) {
                                     babylonMultiMaterial.subMaterials[i] = _this._getDefaultMaterial();
                                     return;
                                 }
-                                var material = _this._gltf.materials[primitive.material];
+                                var material = _this._getArrayItem(_this._gltf.materials, primitive.material, "Material");
+                                if (!material) {
+                                    return;
+                                }
                                 _this._loadMaterial(material, function (babylonMaterial, isNew) {
                                     if (isNew && _this._parent.onMaterialLoaded) {
                                         _this._parent.onMaterialLoaded(babylonMaterial);
@@ -650,10 +678,13 @@ var BABYLON;
                 var vertexData = new BABYLON.VertexData();
                 var loadedAttributes = 0;
                 var totalAttributes = Object.keys(attributes).length;
-                var _loop_2 = function (semantic) {
-                    accessor = this_2._gltf.accessors[attributes[semantic]];
+                var _loop_2 = function (attribute) {
+                    accessor = this_2._getArrayItem(this_2._gltf.accessors, attributes[attribute], "Mesh primitive attribute '" + attribute + "' accessor");
+                    if (!accessor) {
+                        return { value: void 0 };
+                    }
                     this_2._loadAccessorAsync(accessor, function (data) {
-                        switch (semantic) {
+                        switch (attribute) {
                             case "NORMAL":
                                 vertexData.normals = data;
                                 break;
@@ -679,28 +710,33 @@ var BABYLON;
                                 vertexData.colors = data;
                                 break;
                             default:
-                                BABYLON.Tools.Warn("Ignoring unrecognized semantic '" + semantic + "'");
+                                BABYLON.Tools.Warn("Ignoring unrecognized attribute '" + attribute + "'");
                                 break;
                         }
                         if (++loadedAttributes === totalAttributes) {
-                            var indicesAccessor = _this._gltf.accessors[primitive.indices];
-                            if (indicesAccessor) {
+                            if (primitive.indices == null) {
+                                vertexData.indices = new Uint32Array(vertexData.positions.length / 3);
+                                vertexData.indices.forEach(function (v, i) { return vertexData.indices[i] = i; });
+                                onSuccess(vertexData);
+                            }
+                            else {
+                                var indicesAccessor = _this._getArrayItem(_this._gltf.accessors, primitive.indices, "Mesh primitive 'indices' accessor");
+                                if (!indicesAccessor) {
+                                    return;
+                                }
                                 _this._loadAccessorAsync(indicesAccessor, function (data) {
                                     vertexData.indices = data;
                                     onSuccess(vertexData);
                                 });
                             }
-                            else {
-                                vertexData.indices = new Uint32Array(vertexData.positions.length / 3);
-                                vertexData.indices.forEach(function (v, i) { return vertexData.indices[i] = i; });
-                                onSuccess(vertexData);
-                            }
                         }
                     });
                 };
                 var this_2 = this, accessor;
-                for (var semantic in attributes) {
-                    _loop_2(semantic);
+                for (var attribute in attributes) {
+                    var state_1 = _loop_2(attribute);
+                    if (typeof state_1 === "object")
+                        return state_1.value;
                 }
             };
             GLTFLoader.prototype._createMorphTargets = function (node, mesh, primitive, babylonMesh) {
@@ -724,8 +760,11 @@ var BABYLON;
                 var _loop_3 = function () {
                     var babylonMorphTarget = babylonMesh.morphTargetManager.getTarget(index);
                     attributes = targets[index];
-                    var _loop_4 = function (semantic) {
-                        accessor = this_3._gltf.accessors[attributes[semantic]];
+                    var _loop_4 = function (attribute) {
+                        accessor = this_3._getArrayItem(this_3._gltf.accessors, attributes[attribute], "Mesh primitive morph target attribute '" + attribute + "' accessor");
+                        if (!accessor) {
+                            return { value: void 0 };
+                        }
                         this_3._loadAccessorAsync(accessor, function (data) {
                             if (accessor.name) {
                                 babylonMorphTarget.name = accessor.name;
@@ -733,7 +772,7 @@ var BABYLON;
                             // glTF stores morph target information as deltas while babylon.js expects the final data.
                             // As a result we have to add the original data to the delta to calculate the final data.
                             var values = data;
-                            switch (semantic) {
+                            switch (attribute) {
                                 case "NORMAL":
                                     GLTF2.GLTFUtils.ForEach(values, function (v, i) { return values[i] += vertexData.normals[i]; });
                                     babylonMorphTarget.setNormals(values);
@@ -755,18 +794,22 @@ var BABYLON;
                                     babylonMorphTarget.setTangents(values);
                                     break;
                                 default:
-                                    BABYLON.Tools.Warn("Ignoring unrecognized semantic '" + semantic + "'");
+                                    BABYLON.Tools.Warn("Ignoring unrecognized attribute '" + attribute + "'");
                                     break;
                             }
                         });
                     };
-                    for (var semantic in attributes) {
-                        _loop_4(semantic);
+                    for (var attribute in attributes) {
+                        var state_2 = _loop_4(attribute);
+                        if (typeof state_2 === "object")
+                            return state_2;
                     }
                 };
                 var this_3 = this, attributes, accessor;
                 for (var index = 0; index < targets.length; index++) {
-                    _loop_3();
+                    var state_3 = _loop_3();
+                    if (typeof state_3 === "object")
+                        return state_3.value;
                 }
             };
             GLTFLoader.prototype._loadTransform = function (node) {
@@ -793,11 +836,14 @@ var BABYLON;
                 var _this = this;
                 var skeletonId = "skeleton" + skin.index;
                 skin.babylonSkeleton = new BABYLON.Skeleton(skin.name || skeletonId, skeletonId, this._babylonScene);
-                if (skin.inverseBindMatrices === undefined) {
+                if (skin.inverseBindMatrices == null) {
                     this._loadBones(skin, null);
                 }
                 else {
-                    var accessor = this._gltf.accessors[skin.inverseBindMatrices];
+                    var accessor = this._getArrayItem(this._gltf.accessors, skin.inverseBindMatrices, "Skin (" + skin.index + ") inverse bind matrices attribute accessor");
+                    if (!accessor) {
+                        return;
+                    }
                     this._loadAccessorAsync(accessor, function (data) {
                         _this._loadBones(skin, data);
                     });
@@ -815,7 +861,10 @@ var BABYLON;
             GLTFLoader.prototype._loadBones = function (skin, inverseBindMatrixData) {
                 var babylonBones = {};
                 for (var i = 0; i < skin.joints.length; i++) {
-                    var node = this._gltf.nodes[skin.joints[i]];
+                    var node = this._getArrayItem(this._gltf.nodes, skin.joints[i], "Skin (" + skin.index + ") joint");
+                    if (!node) {
+                        return;
+                    }
                     this._loadBone(node, skin, inverseBindMatrixData, babylonBones);
                 }
             };
@@ -855,7 +904,10 @@ var BABYLON;
                 if (GLTF2.GLTFLoaderExtension.TraverseNode(this, index, action, parentNode)) {
                     return;
                 }
-                var node = this._gltf.nodes[index];
+                var node = this._getArrayItem(this._gltf.nodes, index, "Node");
+                if (!node) {
+                    return;
+                }
                 if (!action(node, index, parentNode)) {
                     return;
                 }
@@ -865,7 +917,7 @@ var BABYLON;
             };
             GLTFLoader.prototype._loadAnimations = function () {
                 var animations = this._gltf.animations;
-                if (!animations || animations.length === 0) {
+                if (!animations) {
                     return;
                 }
                 for (var animationIndex = 0; animationIndex < animations.length; animationIndex++) {
@@ -879,9 +931,8 @@ var BABYLON;
                 var channel = animation.channels[channelIndex];
                 var samplerIndex = channel.sampler;
                 var sampler = animation.samplers[samplerIndex];
-                var targetNode = this._gltf.nodes[channel.target.node];
+                var targetNode = this._getArrayItem(this._gltf.nodes, channel.target.node, "Animation channel target");
                 if (!targetNode) {
-                    BABYLON.Tools.Warn("Animation channel target node (" + channel.target.node + ") does not exist");
                     return;
                 }
                 var targetPath = {
@@ -891,7 +942,7 @@ var BABYLON;
                     "weights": "influence"
                 }[channel.target.path];
                 if (!targetPath) {
-                    BABYLON.Tools.Warn("Animation channel target path '" + channel.target.path + "' is not valid");
+                    this._onError("Invalid animation channel target path '" + channel.target.path + "'");
                     return;
                 }
                 var animationType = {
@@ -976,18 +1027,32 @@ var BABYLON;
                         }
                     }
                 };
-                this._loadAccessorAsync(this._gltf.accessors[sampler.input], function (data) {
+                var inputAccessor = this._getArrayItem(this._gltf.accessors, sampler.input, "Animation sampler input accessor");
+                if (!inputAccessor) {
+                    return;
+                }
+                this._loadAccessorAsync(inputAccessor, function (data) {
                     inputData = data;
                     checkSuccess();
                 });
-                this._loadAccessorAsync(this._gltf.accessors[sampler.output], function (data) {
+                var outputAccessor = this._getArrayItem(this._gltf.accessors, sampler.output, "Animation sampler output accessor");
+                if (!outputAccessor) {
+                    return;
+                }
+                this._loadAccessorAsync(outputAccessor, function (data) {
                     outputData = data;
                     checkSuccess();
                 });
             };
-            GLTFLoader.prototype._loadBufferAsync = function (index, onSuccess) {
+            GLTFLoader.prototype._validateUri = function (uri) {
+                if (!uri) {
+                    this._onError("Uri is missing");
+                    return false;
+                }
+                return true;
+            };
+            GLTFLoader.prototype._loadBufferAsync = function (buffer, onSuccess) {
                 var _this = this;
-                var buffer = this._gltf.buffers[index];
                 this._addPendingData(buffer);
                 if (buffer.loadedData) {
                     setTimeout(function () {
@@ -995,40 +1060,37 @@ var BABYLON;
                         _this._removePendingData(buffer);
                     });
                 }
-                else if (GLTF2.GLTFUtils.IsBase64(buffer.uri)) {
-                    var data = GLTF2.GLTFUtils.DecodeBase64(buffer.uri);
-                    buffer.loadedData = new Uint8Array(data);
-                    setTimeout(function () {
-                        onSuccess(buffer.loadedData);
-                        _this._removePendingData(buffer);
-                    });
-                }
                 else if (buffer.loadedObservable) {
                     buffer.loadedObservable.add(function (buffer) {
                         onSuccess(buffer.loadedData);
                         _this._removePendingData(buffer);
                     });
                 }
-                else {
-                    buffer.loadedObservable = new BABYLON.Observable();
-                    buffer.loadedObservable.add(function (buffer) {
-                        onSuccess(buffer.loadedData);
-                        _this._removePendingData(buffer);
-                    });
-                    BABYLON.Tools.LoadFile(this._rootUrl + buffer.uri, function (data) {
+                else if (this._validateUri(buffer.uri)) {
+                    if (GLTF2.GLTFUtils.IsBase64(buffer.uri)) {
+                        var data = GLTF2.GLTFUtils.DecodeBase64(buffer.uri);
                         buffer.loadedData = new Uint8Array(data);
-                        buffer.loadedObservable.notifyObservers(buffer);
-                        buffer.loadedObservable = null;
-                    }, function (event) {
-                        if (!_this._disposed) {
-                            _this._onProgress(event);
-                        }
-                    }, this._babylonScene.database, true, function (request) {
-                        if (!_this._disposed) {
-                            _this._onError("Failed to load file '" + buffer.uri + "': " + request.status + " " + request.statusText);
+                        setTimeout(function () {
+                            onSuccess(buffer.loadedData);
                             _this._removePendingData(buffer);
-                        }
-                    });
+                        });
+                    }
+                    else {
+                        buffer.loadedObservable = new BABYLON.Observable();
+                        buffer.loadedObservable.add(function (buffer) {
+                            onSuccess(buffer.loadedData);
+                            _this._removePendingData(buffer);
+                        });
+                        BABYLON.Tools.LoadFile(this._rootUrl + buffer.uri, function (data) {
+                            buffer.loadedData = new Uint8Array(data);
+                            buffer.loadedObservable.notifyObservers(buffer);
+                            buffer.loadedObservable = null;
+                        }, function (event) {
+                            _this._onProgress(event);
+                        }, this._babylonScene.database, true, function (request) {
+                            _this._onError("Failed to load file '" + buffer.uri + "'" + (request ? ": " + request.status + " " + request.statusText : ""));
+                        });
+                    }
                 }
             };
             GLTFLoader.prototype._buildInt8ArrayBuffer = function (buffer, byteOffset, byteLength, byteStride, bytePerComponent) {
@@ -1100,7 +1162,11 @@ var BABYLON;
             GLTFLoader.prototype._loadBufferViewAsync = function (bufferView, byteOffset, byteLength, bytePerComponent, componentType, onSuccess) {
                 var _this = this;
                 byteOffset += (bufferView.byteOffset || 0);
-                this._loadBufferAsync(bufferView.buffer, function (bufferData) {
+                var buffer = this._getArrayItem(this._gltf.buffers, bufferView.buffer, "Buffer");
+                if (!buffer) {
+                    return;
+                }
+                this._loadBufferAsync(buffer, function (bufferData) {
                     if (byteOffset + byteLength > bufferData.byteLength) {
                         _this._onError("Buffer access is out of range");
                         return;
@@ -1135,7 +1201,10 @@ var BABYLON;
                 });
             };
             GLTFLoader.prototype._loadAccessorAsync = function (accessor, onSuccess) {
-                var bufferView = this._gltf.bufferViews[accessor.bufferView];
+                var bufferView = this._getArrayItem(this._gltf.bufferViews, accessor.bufferView, "Buffer view");
+                if (!bufferView) {
+                    return;
+                }
                 var byteOffset = accessor.byteOffset || 0;
                 var bytePerComponent = this._getByteStrideFromType(accessor);
                 var byteLength = accessor.count * bytePerComponent;
@@ -1215,8 +1284,8 @@ var BABYLON;
                     return;
                 }
                 babylonMaterial.albedoColor = properties.baseColorFactor ? BABYLON.Color3.FromArray(properties.baseColorFactor) : new BABYLON.Color3(1, 1, 1);
-                babylonMaterial.metallic = properties.metallicFactor === undefined ? 1 : properties.metallicFactor;
-                babylonMaterial.roughness = properties.roughnessFactor === undefined ? 1 : properties.roughnessFactor;
+                babylonMaterial.metallic = properties.metallicFactor == null ? 1 : properties.metallicFactor;
+                babylonMaterial.roughness = properties.roughnessFactor == null ? 1 : properties.roughnessFactor;
                 if (properties.baseColorTexture) {
                     babylonMaterial.albedoTexture = this._loadTexture(properties.baseColorTexture);
                 }
@@ -1290,20 +1359,26 @@ var BABYLON;
                         }
                         break;
                     default:
-                        BABYLON.Tools.Warn("Invalid alpha mode '" + material.alphaMode + "'");
-                        break;
+                        this._onError("Invalid alpha mode '" + material.alphaMode + "'");
+                        return;
                 }
-                babylonMaterial.alphaCutOff = material.alphaCutoff === undefined ? 0.5 : material.alphaCutoff;
+                babylonMaterial.alphaCutOff = material.alphaCutoff == null ? 0.5 : material.alphaCutoff;
             };
             GLTFLoader.prototype._loadTexture = function (textureInfo) {
                 var _this = this;
-                var texture = this._gltf.textures[textureInfo.index];
+                var texture = this._getArrayItem(this._gltf.textures, textureInfo.index, "Texture");
+                if (!texture) {
+                    return null;
+                }
                 var texCoord = textureInfo.texCoord || 0;
-                if (!texture || texture.source === undefined) {
+                var source = this._getArrayItem(this._gltf.images, texture.source, "Texture (" + textureInfo.index + ") source");
+                if (!source) {
                     return null;
                 }
-                var source = this._gltf.images[texture.source];
-                var sampler = (texture.sampler === undefined ? {} : this._gltf.samplers[texture.sampler]);
+                var sampler = (texture.sampler == null ? {} : this._getArrayItem(this._gltf.samplers, texture.sampler, "Texture (" + textureInfo.index + ") sampler"));
+                if (!sampler) {
+                    return;
+                }
                 var noMipMaps = (sampler.minFilter === GLTF2.ETextureMinFilter.NEAREST || sampler.minFilter === GLTF2.ETextureMinFilter.LINEAR);
                 var samplingMode = GLTF2.GLTFUtils.GetTextureSamplingMode(sampler.magFilter, sampler.minFilter);
                 this._addPendingData(texture);
@@ -1335,7 +1410,10 @@ var BABYLON;
                         texture.dataReadyObservable.notifyObservers(texture);
                     };
                     if (!source.uri) {
-                        var bufferView = this._gltf.bufferViews[source.bufferView];
+                        var bufferView = this._getArrayItem(this._gltf.bufferViews, source.bufferView, "Texture (" + textureInfo.index + ") source (" + texture.source + ") buffer view");
+                        if (!bufferView) {
+                            return;
+                        }
                         this._loadBufferViewAsync(bufferView, 0, bufferView.byteLength, 1, GLTF2.EComponentType.UNSIGNED_BYTE, setTextureData);
                     }
                     else if (GLTF2.GLTFUtils.IsBase64(source.uri)) {
@@ -1343,9 +1421,7 @@ var BABYLON;
                     }
                     else {
                         BABYLON.Tools.LoadFile(this._rootUrl + source.uri, setTextureData, function (event) {
-                            if (!_this._disposed) {
-                                _this._onProgress(event);
-                            }
+                            _this._onProgress(event);
                         }, this._babylonScene.database, true, function (request) {
                             _this._onError("Failed to load file '" + source.uri + "': " + request.status + " " + request.statusText);
                         });
@@ -1360,9 +1436,16 @@ var BABYLON;
                 }
                 return babylonTexture;
             };
-            GLTFLoader.Extensions = {};
+            GLTFLoader.prototype._getArrayItem = function (array, index, name) {
+                if (!array || !array[index]) {
+                    this._onError(name + " index (" + index + ") was not found");
+                    return null;
+                }
+                return array[index];
+            };
             return GLTFLoader;
         }());
+        GLTFLoader.Extensions = {};
         GLTF2.GLTFLoader = GLTFLoader;
         BABYLON.GLTFFileLoader.CreateGLTFLoaderV2 = function (parent) { return new GLTFLoader(parent); };
     })(GLTF2 = BABYLON.GLTF2 || (BABYLON.GLTF2 = {}));
@@ -1523,12 +1606,12 @@ var BABYLON;
                 }
                 return false;
             };
-            //
-            // Utilities
-            //
-            GLTFLoaderExtension._Extensions = [];
             return GLTFLoaderExtension;
         }());
+        //
+        // Utilities
+        //
+        GLTFLoaderExtension._Extensions = [];
         GLTF2.GLTFLoaderExtension = GLTFLoaderExtension;
     })(GLTF2 = BABYLON.GLTF2 || (BABYLON.GLTF2 = {}));
 })(BABYLON || (BABYLON = {}));
@@ -1566,7 +1649,10 @@ var BABYLON;
                     configurable: true
                 });
                 MSFTLOD.prototype._traverseNode = function (loader, index, action, parentNode) {
-                    var node = loader._gltf.nodes[index];
+                    var node = loader._getArrayItem(loader._gltf.nodes, index, "Node");
+                    if (!node) {
+                        return true;
+                    }
                     return this._loadExtension(node, function (extension, onComplete) {
                         for (var i = extension.ids.length - 1; i >= 0; i--) {
                             loader._traverseNode(extension.ids[i], action, parentNode);
@@ -1635,12 +1721,12 @@ var BABYLON;
                         });
                     });
                 };
-                /**
-                 * Specify the minimal delay between LODs in ms (default = 250)
-                 */
-                MSFTLOD.MinimalLODDelay = 250;
                 return MSFTLOD;
             }(GLTF2.GLTFLoaderExtension));
+            /**
+             * Specify the minimal delay between LODs in ms (default = 250)
+             */
+            MSFTLOD.MinimalLODDelay = 250;
             Extensions.MSFTLOD = MSFTLOD;
             GLTF2.GLTFLoader.RegisterExtension(new MSFTLOD());
         })(Extensions = GLTF2.Extensions || (GLTF2.Extensions = {}));

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

@@ -795,6 +795,7 @@ declare module BABYLON.GLTF2 {
         private _parent;
         private _rootUrl;
         private _defaultMaterial;
+        private _rootNode;
         private _successCallback;
         private _progressCallback;
         private _errorCallback;
@@ -813,7 +814,7 @@ declare module BABYLON.GLTF2 {
         importMeshAsync(meshesNames: any, scene: Scene, data: IGLTFLoaderData, rootUrl: string, onSuccess: (meshes: AbstractMesh[], particleSystems: ParticleSystem[], skeletons: Skeleton[]) => void, onProgress: (event: ProgressEvent) => void, onError: (message: string) => void): void;
         loadAsync(scene: Scene, data: IGLTFLoaderData, rootUrl: string, onSuccess: () => void, onProgress: (event: ProgressEvent) => void, onError: (message: string) => void): void;
         private _loadAsync(nodeNames, scene, data, rootUrl, onSuccess, onProgress, onError);
-        private _onError(message);
+        _onError(message: string): void;
         private _onProgress(event);
         _executeWhenRenderReady(func: () => void): void;
         private _onRenderReady();
@@ -839,7 +840,8 @@ declare module BABYLON.GLTF2 {
         _traverseNode(index: number, action: (node: IGLTFNode, index: number, parentNode: IGLTFNode) => boolean, parentNode?: IGLTFNode): void;
         private _loadAnimations();
         private _loadAnimationChannel(animation, animationIndex, channelIndex);
-        private _loadBufferAsync(index, onSuccess);
+        private _validateUri(uri);
+        private _loadBufferAsync(buffer, onSuccess);
         private _buildInt8ArrayBuffer(buffer, byteOffset, byteLength, byteStride, bytePerComponent);
         private _buildUint8ArrayBuffer(buffer, byteOffset, byteLength, byteStride, bytePerComponent);
         private _buildInt16ArrayBuffer(buffer, byteOffset, byteLength, byteStride, bytePerComponent);
@@ -862,6 +864,7 @@ declare module BABYLON.GLTF2 {
         _loadMaterialBaseProperties(material: IGLTFMaterial): void;
         _loadMaterialAlphaProperties(material: IGLTFMaterial, colorFactor?: number[]): void;
         _loadTexture(textureInfo: IGLTFTextureInfo): Texture;
+        _getArrayItem<T>(array: ArrayLike<T>, index: number, name: string): T;
     }
 }
 

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

@@ -53,10 +53,10 @@ var BABYLON;
             return ((data.indexOf("scene") !== -1) && (data.indexOf("node") !== -1));
         };
         GLTFFileLoader._parse = function (data, onError) {
-            if (data instanceof ArrayBuffer) {
-                return GLTFFileLoader._parseBinary(data, onError);
-            }
             try {
+                if (data instanceof ArrayBuffer) {
+                    return GLTFFileLoader._parseBinary(data, onError);
+                }
                 return {
                     json: JSON.parse(data),
                     bin: null
@@ -223,11 +223,11 @@ var BABYLON;
             }
             return result;
         };
-        // V1 options
-        GLTFFileLoader.HomogeneousCoordinates = false;
-        GLTFFileLoader.IncrementalLoading = true;
         return GLTFFileLoader;
     }());
+    // V1 options
+    GLTFFileLoader.HomogeneousCoordinates = false;
+    GLTFFileLoader.IncrementalLoading = true;
     BABYLON.GLTFFileLoader = GLTFFileLoader;
     var BinaryReader = (function () {
         function BinaryReader(arrayBuffer) {
@@ -1789,9 +1789,9 @@ var BABYLON;
                     }
                 }
             };
-            GLTFLoader.Extensions = {};
             return GLTFLoader;
         }());
+        GLTFLoader.Extensions = {};
         GLTF1.GLTFLoader = GLTFLoader;
         ;
         BABYLON.GLTFFileLoader.CreateGLTFLoaderV1 = function () { return new GLTFLoader(); };
@@ -2043,10 +2043,10 @@ var BABYLON;
                 }
                 return GLTFUtils._DefaultMaterial;
             };
-            // The GLTF default material
-            GLTFUtils._DefaultMaterial = null;
             return GLTFUtils;
         }());
+        // The GLTF default material
+        GLTFUtils._DefaultMaterial = null;
         GLTF1.GLTFUtils = GLTFUtils;
     })(GLTF1 = BABYLON.GLTF1 || (BABYLON.GLTF1 = {}));
 })(BABYLON || (BABYLON = {}));
@@ -2548,24 +2548,36 @@ var BABYLON;
                 this._loadAsync(null, scene, data, rootUrl, onSuccess, onProgress, onError);
             };
             GLTFLoader.prototype._loadAsync = function (nodeNames, scene, data, rootUrl, onSuccess, onProgress, onError) {
-                this._loadData(data);
-                this._babylonScene = scene;
-                this._rootUrl = rootUrl;
-                this._successCallback = onSuccess;
-                this._progressCallback = onProgress;
-                this._errorCallback = onError;
-                this._addPendingData(this);
-                this._loadScene(nodeNames);
-                this._loadAnimations();
-                this._removePendingData(this);
+                try {
+                    this._loadData(data);
+                    this._babylonScene = scene;
+                    this._rootUrl = rootUrl;
+                    this._successCallback = onSuccess;
+                    this._progressCallback = onProgress;
+                    this._errorCallback = onError;
+                    this._addPendingData(this);
+                    this._loadScene(nodeNames);
+                    this._loadAnimations();
+                    this._removePendingData(this);
+                }
+                catch (e) {
+                    this._onError(e.message);
+                }
             };
             GLTFLoader.prototype._onError = function (message) {
+                if (this._disposed) {
+                    return;
+                }
+                BABYLON.Tools.Error("glTF Loader Error: " + message);
                 if (this._errorCallback) {
                     this._errorCallback(message);
                 }
                 this.dispose();
             };
             GLTFLoader.prototype._onProgress = function (event) {
+                if (this._disposed) {
+                    return;
+                }
                 if (this._progressCallback) {
                     this._progressCallback(event);
                 }
@@ -2579,8 +2591,7 @@ var BABYLON;
                 }
             };
             GLTFLoader.prototype._onRenderReady = function () {
-                var rootNode = this._gltf.nodes[this._gltf.nodes.length - 1];
-                rootNode.babylonMesh.setEnabled(true);
+                this._rootNode.babylonMesh.setEnabled(true);
                 this._startAnimations();
                 this._successCallback();
                 this._renderReadyObservable.notifyObservers(this);
@@ -2596,25 +2607,22 @@ var BABYLON;
             };
             GLTFLoader.prototype._loadData = function (data) {
                 this._gltf = data.json;
-                var binaryBuffer;
-                var buffers = this._gltf.buffers;
-                if (buffers && buffers[0].uri === undefined) {
-                    binaryBuffer = buffers[0];
-                }
                 if (data.bin) {
-                    if (binaryBuffer) {
+                    var buffers = this._gltf.buffers;
+                    if (buffers && buffers[0] && !buffers[0].uri) {
+                        var binaryBuffer = buffers[0];
                         if (binaryBuffer.byteLength != data.bin.byteLength) {
                             BABYLON.Tools.Warn("Binary buffer length (" + binaryBuffer.byteLength + ") from JSON does not match chunk length (" + data.bin.byteLength + ")");
                         }
+                        binaryBuffer.loadedData = data.bin;
                     }
                     else {
                         BABYLON.Tools.Warn("Unexpected BIN chunk");
                     }
-                    binaryBuffer.loadedData = data.bin;
                 }
             };
             GLTFLoader.prototype._getMeshes = function () {
-                var meshes = [];
+                var meshes = [this._rootNode.babylonMesh];
                 var nodes = this._gltf.nodes;
                 if (nodes) {
                     nodes.forEach(function (node) {
@@ -2652,13 +2660,16 @@ var BABYLON;
                 this._getAnimationTargets().forEach(function (target) { return _this._babylonScene.beginAnimation(target, 0, Number.MAX_VALUE, true); });
             };
             GLTFLoader.prototype._loadScene = function (nodeNames) {
-                var scene = this._gltf.scenes[this._gltf.scene || 0];
-                var rootNode = { name: "root", children: scene.nodes };
+                var scene = this._getArrayItem(this._gltf.scenes, this._gltf.scene || 0, "Scene");
+                if (!scene) {
+                    return;
+                }
+                this._rootNode = { name: "__root__" };
                 switch (this._parent.coordinateSystemMode) {
                     case BABYLON.GLTFLoaderCoordinateSystemMode.AUTO:
                         if (!this._babylonScene.useRightHandedSystem) {
-                            rootNode.rotation = [0, 1, 0, 0];
-                            rootNode.scale = [1, 1, -1];
+                            this._rootNode.rotation = [0, 1, 0, 0];
+                            this._rootNode.scale = [1, 1, -1];
                         }
                         break;
                     case BABYLON.GLTFLoaderCoordinateSystemMode.PASS_THROUGH:
@@ -2669,22 +2680,23 @@ var BABYLON;
                         break;
                     default:
                         BABYLON.Tools.Error("Invalid coordinate system mode (" + this._parent.coordinateSystemMode + ")");
-                        break;
+                        return;
                 }
-                // Inject a root node into the scene.
-                this._gltf.nodes = this._gltf.nodes || [];
-                scene.nodes = [this._gltf.nodes.length];
-                this._gltf.nodes.push(rootNode);
+                this._loadNode(this._rootNode);
                 var nodeIndices = scene.nodes;
                 this._traverseNodes(nodeIndices, function (node, index, parentNode) {
                     node.index = index;
                     node.parent = parentNode;
                     return true;
-                });
+                }, this._rootNode);
                 var materials = this._gltf.materials;
                 if (materials) {
                     materials.forEach(function (material, index) { return material.index = index; });
                 }
+                var skins = this._gltf.skins;
+                if (skins) {
+                    skins.forEach(function (skin, index) { return skin.index = index; });
+                }
                 if (nodeNames) {
                     if (!(nodeNames instanceof Array)) {
                         nodeNames = [nodeNames];
@@ -2696,14 +2708,18 @@ var BABYLON;
                             return false;
                         }
                         return true;
-                    });
+                    }, this._rootNode);
                     nodeIndices = filteredNodeIndices;
                 }
                 for (var i = 0; i < nodeIndices.length; i++) {
-                    this._loadNode(this._gltf.nodes[nodeIndices[i]]);
+                    var node = this._getArrayItem(this._gltf.nodes, nodeIndices[i], "Node");
+                    if (!node) {
+                        return;
+                    }
+                    this._loadNode(node);
                 }
                 // Disable the root mesh until the asset is ready to render.
-                rootNode.babylonMesh.setEnabled(false);
+                this._rootNode.babylonMesh.setEnabled(false);
             };
             GLTFLoader.prototype._loadNode = function (node) {
                 if (GLTF2.GLTFLoaderExtension.LoadNode(this, node)) {
@@ -2712,15 +2728,20 @@ var BABYLON;
                 node.babylonMesh = new BABYLON.Mesh(node.name || "mesh" + node.index, this._babylonScene);
                 this._loadTransform(node);
                 if (node.mesh !== undefined) {
-                    var mesh = this._gltf.meshes[node.mesh];
+                    var mesh = this._getArrayItem(this._gltf.meshes, node.mesh, "Mesh");
+                    if (!mesh) {
+                        return;
+                    }
                     this._loadMesh(node, mesh);
                 }
                 node.babylonMesh.parent = node.parent ? node.parent.babylonMesh : null;
                 node.babylonAnimationTargets = node.babylonAnimationTargets || [];
                 node.babylonAnimationTargets.push(node.babylonMesh);
                 if (node.skin !== undefined) {
-                    var skin = this._gltf.skins[node.skin];
-                    skin.index = node.skin;
+                    var skin = this._getArrayItem(this._gltf.skins, node.skin, "Skin");
+                    if (!skin) {
+                        return;
+                    }
                     node.babylonMesh.skeleton = this._loadSkin(skin);
                 }
                 if (node.camera !== undefined) {
@@ -2728,7 +2749,11 @@ var BABYLON;
                 }
                 if (node.children) {
                     for (var i = 0; i < node.children.length; i++) {
-                        this._loadNode(this._gltf.nodes[node.children[i]]);
+                        var childNode = this._getArrayItem(this._gltf.nodes, node.children[i], "Node");
+                        if (!childNode) {
+                            return;
+                        }
+                        this._loadNode(childNode);
                     }
                 }
             };
@@ -2760,11 +2785,14 @@ var BABYLON;
                             indicesStart: vertexData.indices.length,
                             indicesCount: subVertexData.indices.length,
                             loadMaterial: function () {
-                                if (primitive.material === undefined) {
+                                if (primitive.material == null) {
                                     babylonMultiMaterial.subMaterials[i] = _this._getDefaultMaterial();
                                     return;
                                 }
-                                var material = _this._gltf.materials[primitive.material];
+                                var material = _this._getArrayItem(_this._gltf.materials, primitive.material, "Material");
+                                if (!material) {
+                                    return;
+                                }
                                 _this._loadMaterial(material, function (babylonMaterial, isNew) {
                                     if (isNew && _this._parent.onMaterialLoaded) {
                                         _this._parent.onMaterialLoaded(babylonMaterial);
@@ -2808,10 +2836,13 @@ var BABYLON;
                 var vertexData = new BABYLON.VertexData();
                 var loadedAttributes = 0;
                 var totalAttributes = Object.keys(attributes).length;
-                var _loop_2 = function (semantic) {
-                    accessor = this_2._gltf.accessors[attributes[semantic]];
+                var _loop_2 = function (attribute) {
+                    accessor = this_2._getArrayItem(this_2._gltf.accessors, attributes[attribute], "Mesh primitive attribute '" + attribute + "' accessor");
+                    if (!accessor) {
+                        return { value: void 0 };
+                    }
                     this_2._loadAccessorAsync(accessor, function (data) {
-                        switch (semantic) {
+                        switch (attribute) {
                             case "NORMAL":
                                 vertexData.normals = data;
                                 break;
@@ -2837,28 +2868,33 @@ var BABYLON;
                                 vertexData.colors = data;
                                 break;
                             default:
-                                BABYLON.Tools.Warn("Ignoring unrecognized semantic '" + semantic + "'");
+                                BABYLON.Tools.Warn("Ignoring unrecognized attribute '" + attribute + "'");
                                 break;
                         }
                         if (++loadedAttributes === totalAttributes) {
-                            var indicesAccessor = _this._gltf.accessors[primitive.indices];
-                            if (indicesAccessor) {
+                            if (primitive.indices == null) {
+                                vertexData.indices = new Uint32Array(vertexData.positions.length / 3);
+                                vertexData.indices.forEach(function (v, i) { return vertexData.indices[i] = i; });
+                                onSuccess(vertexData);
+                            }
+                            else {
+                                var indicesAccessor = _this._getArrayItem(_this._gltf.accessors, primitive.indices, "Mesh primitive 'indices' accessor");
+                                if (!indicesAccessor) {
+                                    return;
+                                }
                                 _this._loadAccessorAsync(indicesAccessor, function (data) {
                                     vertexData.indices = data;
                                     onSuccess(vertexData);
                                 });
                             }
-                            else {
-                                vertexData.indices = new Uint32Array(vertexData.positions.length / 3);
-                                vertexData.indices.forEach(function (v, i) { return vertexData.indices[i] = i; });
-                                onSuccess(vertexData);
-                            }
                         }
                     });
                 };
                 var this_2 = this, accessor;
-                for (var semantic in attributes) {
-                    _loop_2(semantic);
+                for (var attribute in attributes) {
+                    var state_1 = _loop_2(attribute);
+                    if (typeof state_1 === "object")
+                        return state_1.value;
                 }
             };
             GLTFLoader.prototype._createMorphTargets = function (node, mesh, primitive, babylonMesh) {
@@ -2882,8 +2918,11 @@ var BABYLON;
                 var _loop_3 = function () {
                     var babylonMorphTarget = babylonMesh.morphTargetManager.getTarget(index);
                     attributes = targets[index];
-                    var _loop_4 = function (semantic) {
-                        accessor = this_3._gltf.accessors[attributes[semantic]];
+                    var _loop_4 = function (attribute) {
+                        accessor = this_3._getArrayItem(this_3._gltf.accessors, attributes[attribute], "Mesh primitive morph target attribute '" + attribute + "' accessor");
+                        if (!accessor) {
+                            return { value: void 0 };
+                        }
                         this_3._loadAccessorAsync(accessor, function (data) {
                             if (accessor.name) {
                                 babylonMorphTarget.name = accessor.name;
@@ -2891,7 +2930,7 @@ var BABYLON;
                             // glTF stores morph target information as deltas while babylon.js expects the final data.
                             // As a result we have to add the original data to the delta to calculate the final data.
                             var values = data;
-                            switch (semantic) {
+                            switch (attribute) {
                                 case "NORMAL":
                                     GLTF2.GLTFUtils.ForEach(values, function (v, i) { return values[i] += vertexData.normals[i]; });
                                     babylonMorphTarget.setNormals(values);
@@ -2913,18 +2952,22 @@ var BABYLON;
                                     babylonMorphTarget.setTangents(values);
                                     break;
                                 default:
-                                    BABYLON.Tools.Warn("Ignoring unrecognized semantic '" + semantic + "'");
+                                    BABYLON.Tools.Warn("Ignoring unrecognized attribute '" + attribute + "'");
                                     break;
                             }
                         });
                     };
-                    for (var semantic in attributes) {
-                        _loop_4(semantic);
+                    for (var attribute in attributes) {
+                        var state_2 = _loop_4(attribute);
+                        if (typeof state_2 === "object")
+                            return state_2;
                     }
                 };
                 var this_3 = this, attributes, accessor;
                 for (var index = 0; index < targets.length; index++) {
-                    _loop_3();
+                    var state_3 = _loop_3();
+                    if (typeof state_3 === "object")
+                        return state_3.value;
                 }
             };
             GLTFLoader.prototype._loadTransform = function (node) {
@@ -2951,11 +2994,14 @@ var BABYLON;
                 var _this = this;
                 var skeletonId = "skeleton" + skin.index;
                 skin.babylonSkeleton = new BABYLON.Skeleton(skin.name || skeletonId, skeletonId, this._babylonScene);
-                if (skin.inverseBindMatrices === undefined) {
+                if (skin.inverseBindMatrices == null) {
                     this._loadBones(skin, null);
                 }
                 else {
-                    var accessor = this._gltf.accessors[skin.inverseBindMatrices];
+                    var accessor = this._getArrayItem(this._gltf.accessors, skin.inverseBindMatrices, "Skin (" + skin.index + ") inverse bind matrices attribute accessor");
+                    if (!accessor) {
+                        return;
+                    }
                     this._loadAccessorAsync(accessor, function (data) {
                         _this._loadBones(skin, data);
                     });
@@ -2973,7 +3019,10 @@ var BABYLON;
             GLTFLoader.prototype._loadBones = function (skin, inverseBindMatrixData) {
                 var babylonBones = {};
                 for (var i = 0; i < skin.joints.length; i++) {
-                    var node = this._gltf.nodes[skin.joints[i]];
+                    var node = this._getArrayItem(this._gltf.nodes, skin.joints[i], "Skin (" + skin.index + ") joint");
+                    if (!node) {
+                        return;
+                    }
                     this._loadBone(node, skin, inverseBindMatrixData, babylonBones);
                 }
             };
@@ -3013,7 +3062,10 @@ var BABYLON;
                 if (GLTF2.GLTFLoaderExtension.TraverseNode(this, index, action, parentNode)) {
                     return;
                 }
-                var node = this._gltf.nodes[index];
+                var node = this._getArrayItem(this._gltf.nodes, index, "Node");
+                if (!node) {
+                    return;
+                }
                 if (!action(node, index, parentNode)) {
                     return;
                 }
@@ -3023,7 +3075,7 @@ var BABYLON;
             };
             GLTFLoader.prototype._loadAnimations = function () {
                 var animations = this._gltf.animations;
-                if (!animations || animations.length === 0) {
+                if (!animations) {
                     return;
                 }
                 for (var animationIndex = 0; animationIndex < animations.length; animationIndex++) {
@@ -3037,9 +3089,8 @@ var BABYLON;
                 var channel = animation.channels[channelIndex];
                 var samplerIndex = channel.sampler;
                 var sampler = animation.samplers[samplerIndex];
-                var targetNode = this._gltf.nodes[channel.target.node];
+                var targetNode = this._getArrayItem(this._gltf.nodes, channel.target.node, "Animation channel target");
                 if (!targetNode) {
-                    BABYLON.Tools.Warn("Animation channel target node (" + channel.target.node + ") does not exist");
                     return;
                 }
                 var targetPath = {
@@ -3049,7 +3100,7 @@ var BABYLON;
                     "weights": "influence"
                 }[channel.target.path];
                 if (!targetPath) {
-                    BABYLON.Tools.Warn("Animation channel target path '" + channel.target.path + "' is not valid");
+                    this._onError("Invalid animation channel target path '" + channel.target.path + "'");
                     return;
                 }
                 var animationType = {
@@ -3134,18 +3185,32 @@ var BABYLON;
                         }
                     }
                 };
-                this._loadAccessorAsync(this._gltf.accessors[sampler.input], function (data) {
+                var inputAccessor = this._getArrayItem(this._gltf.accessors, sampler.input, "Animation sampler input accessor");
+                if (!inputAccessor) {
+                    return;
+                }
+                this._loadAccessorAsync(inputAccessor, function (data) {
                     inputData = data;
                     checkSuccess();
                 });
-                this._loadAccessorAsync(this._gltf.accessors[sampler.output], function (data) {
+                var outputAccessor = this._getArrayItem(this._gltf.accessors, sampler.output, "Animation sampler output accessor");
+                if (!outputAccessor) {
+                    return;
+                }
+                this._loadAccessorAsync(outputAccessor, function (data) {
                     outputData = data;
                     checkSuccess();
                 });
             };
-            GLTFLoader.prototype._loadBufferAsync = function (index, onSuccess) {
+            GLTFLoader.prototype._validateUri = function (uri) {
+                if (!uri) {
+                    this._onError("Uri is missing");
+                    return false;
+                }
+                return true;
+            };
+            GLTFLoader.prototype._loadBufferAsync = function (buffer, onSuccess) {
                 var _this = this;
-                var buffer = this._gltf.buffers[index];
                 this._addPendingData(buffer);
                 if (buffer.loadedData) {
                     setTimeout(function () {
@@ -3153,40 +3218,37 @@ var BABYLON;
                         _this._removePendingData(buffer);
                     });
                 }
-                else if (GLTF2.GLTFUtils.IsBase64(buffer.uri)) {
-                    var data = GLTF2.GLTFUtils.DecodeBase64(buffer.uri);
-                    buffer.loadedData = new Uint8Array(data);
-                    setTimeout(function () {
-                        onSuccess(buffer.loadedData);
-                        _this._removePendingData(buffer);
-                    });
-                }
                 else if (buffer.loadedObservable) {
                     buffer.loadedObservable.add(function (buffer) {
                         onSuccess(buffer.loadedData);
                         _this._removePendingData(buffer);
                     });
                 }
-                else {
-                    buffer.loadedObservable = new BABYLON.Observable();
-                    buffer.loadedObservable.add(function (buffer) {
-                        onSuccess(buffer.loadedData);
-                        _this._removePendingData(buffer);
-                    });
-                    BABYLON.Tools.LoadFile(this._rootUrl + buffer.uri, function (data) {
+                else if (this._validateUri(buffer.uri)) {
+                    if (GLTF2.GLTFUtils.IsBase64(buffer.uri)) {
+                        var data = GLTF2.GLTFUtils.DecodeBase64(buffer.uri);
                         buffer.loadedData = new Uint8Array(data);
-                        buffer.loadedObservable.notifyObservers(buffer);
-                        buffer.loadedObservable = null;
-                    }, function (event) {
-                        if (!_this._disposed) {
-                            _this._onProgress(event);
-                        }
-                    }, this._babylonScene.database, true, function (request) {
-                        if (!_this._disposed) {
-                            _this._onError("Failed to load file '" + buffer.uri + "': " + request.status + " " + request.statusText);
+                        setTimeout(function () {
+                            onSuccess(buffer.loadedData);
                             _this._removePendingData(buffer);
-                        }
-                    });
+                        });
+                    }
+                    else {
+                        buffer.loadedObservable = new BABYLON.Observable();
+                        buffer.loadedObservable.add(function (buffer) {
+                            onSuccess(buffer.loadedData);
+                            _this._removePendingData(buffer);
+                        });
+                        BABYLON.Tools.LoadFile(this._rootUrl + buffer.uri, function (data) {
+                            buffer.loadedData = new Uint8Array(data);
+                            buffer.loadedObservable.notifyObservers(buffer);
+                            buffer.loadedObservable = null;
+                        }, function (event) {
+                            _this._onProgress(event);
+                        }, this._babylonScene.database, true, function (request) {
+                            _this._onError("Failed to load file '" + buffer.uri + "'" + (request ? ": " + request.status + " " + request.statusText : ""));
+                        });
+                    }
                 }
             };
             GLTFLoader.prototype._buildInt8ArrayBuffer = function (buffer, byteOffset, byteLength, byteStride, bytePerComponent) {
@@ -3258,7 +3320,11 @@ var BABYLON;
             GLTFLoader.prototype._loadBufferViewAsync = function (bufferView, byteOffset, byteLength, bytePerComponent, componentType, onSuccess) {
                 var _this = this;
                 byteOffset += (bufferView.byteOffset || 0);
-                this._loadBufferAsync(bufferView.buffer, function (bufferData) {
+                var buffer = this._getArrayItem(this._gltf.buffers, bufferView.buffer, "Buffer");
+                if (!buffer) {
+                    return;
+                }
+                this._loadBufferAsync(buffer, function (bufferData) {
                     if (byteOffset + byteLength > bufferData.byteLength) {
                         _this._onError("Buffer access is out of range");
                         return;
@@ -3293,7 +3359,10 @@ var BABYLON;
                 });
             };
             GLTFLoader.prototype._loadAccessorAsync = function (accessor, onSuccess) {
-                var bufferView = this._gltf.bufferViews[accessor.bufferView];
+                var bufferView = this._getArrayItem(this._gltf.bufferViews, accessor.bufferView, "Buffer view");
+                if (!bufferView) {
+                    return;
+                }
                 var byteOffset = accessor.byteOffset || 0;
                 var bytePerComponent = this._getByteStrideFromType(accessor);
                 var byteLength = accessor.count * bytePerComponent;
@@ -3373,8 +3442,8 @@ var BABYLON;
                     return;
                 }
                 babylonMaterial.albedoColor = properties.baseColorFactor ? BABYLON.Color3.FromArray(properties.baseColorFactor) : new BABYLON.Color3(1, 1, 1);
-                babylonMaterial.metallic = properties.metallicFactor === undefined ? 1 : properties.metallicFactor;
-                babylonMaterial.roughness = properties.roughnessFactor === undefined ? 1 : properties.roughnessFactor;
+                babylonMaterial.metallic = properties.metallicFactor == null ? 1 : properties.metallicFactor;
+                babylonMaterial.roughness = properties.roughnessFactor == null ? 1 : properties.roughnessFactor;
                 if (properties.baseColorTexture) {
                     babylonMaterial.albedoTexture = this._loadTexture(properties.baseColorTexture);
                 }
@@ -3448,20 +3517,26 @@ var BABYLON;
                         }
                         break;
                     default:
-                        BABYLON.Tools.Warn("Invalid alpha mode '" + material.alphaMode + "'");
-                        break;
+                        this._onError("Invalid alpha mode '" + material.alphaMode + "'");
+                        return;
                 }
-                babylonMaterial.alphaCutOff = material.alphaCutoff === undefined ? 0.5 : material.alphaCutoff;
+                babylonMaterial.alphaCutOff = material.alphaCutoff == null ? 0.5 : material.alphaCutoff;
             };
             GLTFLoader.prototype._loadTexture = function (textureInfo) {
                 var _this = this;
-                var texture = this._gltf.textures[textureInfo.index];
+                var texture = this._getArrayItem(this._gltf.textures, textureInfo.index, "Texture");
+                if (!texture) {
+                    return null;
+                }
                 var texCoord = textureInfo.texCoord || 0;
-                if (!texture || texture.source === undefined) {
+                var source = this._getArrayItem(this._gltf.images, texture.source, "Texture (" + textureInfo.index + ") source");
+                if (!source) {
                     return null;
                 }
-                var source = this._gltf.images[texture.source];
-                var sampler = (texture.sampler === undefined ? {} : this._gltf.samplers[texture.sampler]);
+                var sampler = (texture.sampler == null ? {} : this._getArrayItem(this._gltf.samplers, texture.sampler, "Texture (" + textureInfo.index + ") sampler"));
+                if (!sampler) {
+                    return;
+                }
                 var noMipMaps = (sampler.minFilter === GLTF2.ETextureMinFilter.NEAREST || sampler.minFilter === GLTF2.ETextureMinFilter.LINEAR);
                 var samplingMode = GLTF2.GLTFUtils.GetTextureSamplingMode(sampler.magFilter, sampler.minFilter);
                 this._addPendingData(texture);
@@ -3493,7 +3568,10 @@ var BABYLON;
                         texture.dataReadyObservable.notifyObservers(texture);
                     };
                     if (!source.uri) {
-                        var bufferView = this._gltf.bufferViews[source.bufferView];
+                        var bufferView = this._getArrayItem(this._gltf.bufferViews, source.bufferView, "Texture (" + textureInfo.index + ") source (" + texture.source + ") buffer view");
+                        if (!bufferView) {
+                            return;
+                        }
                         this._loadBufferViewAsync(bufferView, 0, bufferView.byteLength, 1, GLTF2.EComponentType.UNSIGNED_BYTE, setTextureData);
                     }
                     else if (GLTF2.GLTFUtils.IsBase64(source.uri)) {
@@ -3501,9 +3579,7 @@ var BABYLON;
                     }
                     else {
                         BABYLON.Tools.LoadFile(this._rootUrl + source.uri, setTextureData, function (event) {
-                            if (!_this._disposed) {
-                                _this._onProgress(event);
-                            }
+                            _this._onProgress(event);
                         }, this._babylonScene.database, true, function (request) {
                             _this._onError("Failed to load file '" + source.uri + "': " + request.status + " " + request.statusText);
                         });
@@ -3518,9 +3594,16 @@ var BABYLON;
                 }
                 return babylonTexture;
             };
-            GLTFLoader.Extensions = {};
+            GLTFLoader.prototype._getArrayItem = function (array, index, name) {
+                if (!array || !array[index]) {
+                    this._onError(name + " index (" + index + ") was not found");
+                    return null;
+                }
+                return array[index];
+            };
             return GLTFLoader;
         }());
+        GLTFLoader.Extensions = {};
         GLTF2.GLTFLoader = GLTFLoader;
         BABYLON.GLTFFileLoader.CreateGLTFLoaderV2 = function (parent) { return new GLTFLoader(parent); };
     })(GLTF2 = BABYLON.GLTF2 || (BABYLON.GLTF2 = {}));
@@ -3681,12 +3764,12 @@ var BABYLON;
                 }
                 return false;
             };
-            //
-            // Utilities
-            //
-            GLTFLoaderExtension._Extensions = [];
             return GLTFLoaderExtension;
         }());
+        //
+        // Utilities
+        //
+        GLTFLoaderExtension._Extensions = [];
         GLTF2.GLTFLoaderExtension = GLTFLoaderExtension;
     })(GLTF2 = BABYLON.GLTF2 || (BABYLON.GLTF2 = {}));
 })(BABYLON || (BABYLON = {}));
@@ -3724,7 +3807,10 @@ var BABYLON;
                     configurable: true
                 });
                 MSFTLOD.prototype._traverseNode = function (loader, index, action, parentNode) {
-                    var node = loader._gltf.nodes[index];
+                    var node = loader._getArrayItem(loader._gltf.nodes, index, "Node");
+                    if (!node) {
+                        return true;
+                    }
                     return this._loadExtension(node, function (extension, onComplete) {
                         for (var i = extension.ids.length - 1; i >= 0; i--) {
                             loader._traverseNode(extension.ids[i], action, parentNode);
@@ -3793,12 +3879,12 @@ var BABYLON;
                         });
                     });
                 };
-                /**
-                 * Specify the minimal delay between LODs in ms (default = 250)
-                 */
-                MSFTLOD.MinimalLODDelay = 250;
                 return MSFTLOD;
             }(GLTF2.GLTFLoaderExtension));
+            /**
+             * Specify the minimal delay between LODs in ms (default = 250)
+             */
+            MSFTLOD.MinimalLODDelay = 250;
             Extensions.MSFTLOD = MSFTLOD;
             GLTF2.GLTFLoader.RegisterExtension(new MSFTLOD());
         })(Extensions = GLTF2.Extensions || (GLTF2.Extensions = {}));

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

@@ -774,9 +774,9 @@ var BABYLON;
             //Return an array with all BABYLON.Mesh
             return babylonMeshesArray;
         };
-        OBJFileLoader.OPTIMIZE_WITH_UV = false;
         return OBJFileLoader;
     }());
+    OBJFileLoader.OPTIMIZE_WITH_UV = false;
     BABYLON.OBJFileLoader = OBJFileLoader;
     if (BABYLON.SceneLoader) {
         //Add this loader into the register plugin

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

@@ -956,9 +956,9 @@ var BABYLON;
             //Return an array with all BABYLON.Mesh
             return babylonMeshesArray;
         };
-        OBJFileLoader.OPTIMIZE_WITH_UV = false;
         return OBJFileLoader;
     }());
+    OBJFileLoader.OPTIMIZE_WITH_UV = false;
     BABYLON.OBJFileLoader = OBJFileLoader;
     if (BABYLON.SceneLoader) {
         //Add this loader into the register plugin
@@ -1023,10 +1023,10 @@ var BABYLON;
             return ((data.indexOf("scene") !== -1) && (data.indexOf("node") !== -1));
         };
         GLTFFileLoader._parse = function (data, onError) {
-            if (data instanceof ArrayBuffer) {
-                return GLTFFileLoader._parseBinary(data, onError);
-            }
             try {
+                if (data instanceof ArrayBuffer) {
+                    return GLTFFileLoader._parseBinary(data, onError);
+                }
                 return {
                     json: JSON.parse(data),
                     bin: null
@@ -1193,11 +1193,11 @@ var BABYLON;
             }
             return result;
         };
-        // V1 options
-        GLTFFileLoader.HomogeneousCoordinates = false;
-        GLTFFileLoader.IncrementalLoading = true;
         return GLTFFileLoader;
     }());
+    // V1 options
+    GLTFFileLoader.HomogeneousCoordinates = false;
+    GLTFFileLoader.IncrementalLoading = true;
     BABYLON.GLTFFileLoader = GLTFFileLoader;
     var BinaryReader = (function () {
         function BinaryReader(arrayBuffer) {
@@ -2759,9 +2759,9 @@ var BABYLON;
                     }
                 }
             };
-            GLTFLoader.Extensions = {};
             return GLTFLoader;
         }());
+        GLTFLoader.Extensions = {};
         GLTF1.GLTFLoader = GLTFLoader;
         ;
         BABYLON.GLTFFileLoader.CreateGLTFLoaderV1 = function () { return new GLTFLoader(); };
@@ -3013,10 +3013,10 @@ var BABYLON;
                 }
                 return GLTFUtils._DefaultMaterial;
             };
-            // The GLTF default material
-            GLTFUtils._DefaultMaterial = null;
             return GLTFUtils;
         }());
+        // The GLTF default material
+        GLTFUtils._DefaultMaterial = null;
         GLTF1.GLTFUtils = GLTFUtils;
     })(GLTF1 = BABYLON.GLTF1 || (BABYLON.GLTF1 = {}));
 })(BABYLON || (BABYLON = {}));
@@ -3500,24 +3500,36 @@ var BABYLON;
                 this._loadAsync(null, scene, data, rootUrl, onSuccess, onProgress, onError);
             };
             GLTFLoader.prototype._loadAsync = function (nodeNames, scene, data, rootUrl, onSuccess, onProgress, onError) {
-                this._loadData(data);
-                this._babylonScene = scene;
-                this._rootUrl = rootUrl;
-                this._successCallback = onSuccess;
-                this._progressCallback = onProgress;
-                this._errorCallback = onError;
-                this._addPendingData(this);
-                this._loadScene(nodeNames);
-                this._loadAnimations();
-                this._removePendingData(this);
+                try {
+                    this._loadData(data);
+                    this._babylonScene = scene;
+                    this._rootUrl = rootUrl;
+                    this._successCallback = onSuccess;
+                    this._progressCallback = onProgress;
+                    this._errorCallback = onError;
+                    this._addPendingData(this);
+                    this._loadScene(nodeNames);
+                    this._loadAnimations();
+                    this._removePendingData(this);
+                }
+                catch (e) {
+                    this._onError(e.message);
+                }
             };
             GLTFLoader.prototype._onError = function (message) {
+                if (this._disposed) {
+                    return;
+                }
+                BABYLON.Tools.Error("glTF Loader Error: " + message);
                 if (this._errorCallback) {
                     this._errorCallback(message);
                 }
                 this.dispose();
             };
             GLTFLoader.prototype._onProgress = function (event) {
+                if (this._disposed) {
+                    return;
+                }
                 if (this._progressCallback) {
                     this._progressCallback(event);
                 }
@@ -3531,8 +3543,7 @@ var BABYLON;
                 }
             };
             GLTFLoader.prototype._onRenderReady = function () {
-                var rootNode = this._gltf.nodes[this._gltf.nodes.length - 1];
-                rootNode.babylonMesh.setEnabled(true);
+                this._rootNode.babylonMesh.setEnabled(true);
                 this._startAnimations();
                 this._successCallback();
                 this._renderReadyObservable.notifyObservers(this);
@@ -3548,25 +3559,22 @@ var BABYLON;
             };
             GLTFLoader.prototype._loadData = function (data) {
                 this._gltf = data.json;
-                var binaryBuffer;
-                var buffers = this._gltf.buffers;
-                if (buffers && buffers[0].uri === undefined) {
-                    binaryBuffer = buffers[0];
-                }
                 if (data.bin) {
-                    if (binaryBuffer) {
+                    var buffers = this._gltf.buffers;
+                    if (buffers && buffers[0] && !buffers[0].uri) {
+                        var binaryBuffer = buffers[0];
                         if (binaryBuffer.byteLength != data.bin.byteLength) {
                             BABYLON.Tools.Warn("Binary buffer length (" + binaryBuffer.byteLength + ") from JSON does not match chunk length (" + data.bin.byteLength + ")");
                         }
+                        binaryBuffer.loadedData = data.bin;
                     }
                     else {
                         BABYLON.Tools.Warn("Unexpected BIN chunk");
                     }
-                    binaryBuffer.loadedData = data.bin;
                 }
             };
             GLTFLoader.prototype._getMeshes = function () {
-                var meshes = [];
+                var meshes = [this._rootNode.babylonMesh];
                 var nodes = this._gltf.nodes;
                 if (nodes) {
                     nodes.forEach(function (node) {
@@ -3604,13 +3612,16 @@ var BABYLON;
                 this._getAnimationTargets().forEach(function (target) { return _this._babylonScene.beginAnimation(target, 0, Number.MAX_VALUE, true); });
             };
             GLTFLoader.prototype._loadScene = function (nodeNames) {
-                var scene = this._gltf.scenes[this._gltf.scene || 0];
-                var rootNode = { name: "root", children: scene.nodes };
+                var scene = this._getArrayItem(this._gltf.scenes, this._gltf.scene || 0, "Scene");
+                if (!scene) {
+                    return;
+                }
+                this._rootNode = { name: "__root__" };
                 switch (this._parent.coordinateSystemMode) {
                     case BABYLON.GLTFLoaderCoordinateSystemMode.AUTO:
                         if (!this._babylonScene.useRightHandedSystem) {
-                            rootNode.rotation = [0, 1, 0, 0];
-                            rootNode.scale = [1, 1, -1];
+                            this._rootNode.rotation = [0, 1, 0, 0];
+                            this._rootNode.scale = [1, 1, -1];
                         }
                         break;
                     case BABYLON.GLTFLoaderCoordinateSystemMode.PASS_THROUGH:
@@ -3621,22 +3632,23 @@ var BABYLON;
                         break;
                     default:
                         BABYLON.Tools.Error("Invalid coordinate system mode (" + this._parent.coordinateSystemMode + ")");
-                        break;
+                        return;
                 }
-                // Inject a root node into the scene.
-                this._gltf.nodes = this._gltf.nodes || [];
-                scene.nodes = [this._gltf.nodes.length];
-                this._gltf.nodes.push(rootNode);
+                this._loadNode(this._rootNode);
                 var nodeIndices = scene.nodes;
                 this._traverseNodes(nodeIndices, function (node, index, parentNode) {
                     node.index = index;
                     node.parent = parentNode;
                     return true;
-                });
+                }, this._rootNode);
                 var materials = this._gltf.materials;
                 if (materials) {
                     materials.forEach(function (material, index) { return material.index = index; });
                 }
+                var skins = this._gltf.skins;
+                if (skins) {
+                    skins.forEach(function (skin, index) { return skin.index = index; });
+                }
                 if (nodeNames) {
                     if (!(nodeNames instanceof Array)) {
                         nodeNames = [nodeNames];
@@ -3648,14 +3660,18 @@ var BABYLON;
                             return false;
                         }
                         return true;
-                    });
+                    }, this._rootNode);
                     nodeIndices = filteredNodeIndices;
                 }
                 for (var i = 0; i < nodeIndices.length; i++) {
-                    this._loadNode(this._gltf.nodes[nodeIndices[i]]);
+                    var node = this._getArrayItem(this._gltf.nodes, nodeIndices[i], "Node");
+                    if (!node) {
+                        return;
+                    }
+                    this._loadNode(node);
                 }
                 // Disable the root mesh until the asset is ready to render.
-                rootNode.babylonMesh.setEnabled(false);
+                this._rootNode.babylonMesh.setEnabled(false);
             };
             GLTFLoader.prototype._loadNode = function (node) {
                 if (GLTF2.GLTFLoaderExtension.LoadNode(this, node)) {
@@ -3664,15 +3680,20 @@ var BABYLON;
                 node.babylonMesh = new BABYLON.Mesh(node.name || "mesh" + node.index, this._babylonScene);
                 this._loadTransform(node);
                 if (node.mesh !== undefined) {
-                    var mesh = this._gltf.meshes[node.mesh];
+                    var mesh = this._getArrayItem(this._gltf.meshes, node.mesh, "Mesh");
+                    if (!mesh) {
+                        return;
+                    }
                     this._loadMesh(node, mesh);
                 }
                 node.babylonMesh.parent = node.parent ? node.parent.babylonMesh : null;
                 node.babylonAnimationTargets = node.babylonAnimationTargets || [];
                 node.babylonAnimationTargets.push(node.babylonMesh);
                 if (node.skin !== undefined) {
-                    var skin = this._gltf.skins[node.skin];
-                    skin.index = node.skin;
+                    var skin = this._getArrayItem(this._gltf.skins, node.skin, "Skin");
+                    if (!skin) {
+                        return;
+                    }
                     node.babylonMesh.skeleton = this._loadSkin(skin);
                 }
                 if (node.camera !== undefined) {
@@ -3680,7 +3701,11 @@ var BABYLON;
                 }
                 if (node.children) {
                     for (var i = 0; i < node.children.length; i++) {
-                        this._loadNode(this._gltf.nodes[node.children[i]]);
+                        var childNode = this._getArrayItem(this._gltf.nodes, node.children[i], "Node");
+                        if (!childNode) {
+                            return;
+                        }
+                        this._loadNode(childNode);
                     }
                 }
             };
@@ -3712,11 +3737,14 @@ var BABYLON;
                             indicesStart: vertexData.indices.length,
                             indicesCount: subVertexData.indices.length,
                             loadMaterial: function () {
-                                if (primitive.material === undefined) {
+                                if (primitive.material == null) {
                                     babylonMultiMaterial.subMaterials[i] = _this._getDefaultMaterial();
                                     return;
                                 }
-                                var material = _this._gltf.materials[primitive.material];
+                                var material = _this._getArrayItem(_this._gltf.materials, primitive.material, "Material");
+                                if (!material) {
+                                    return;
+                                }
                                 _this._loadMaterial(material, function (babylonMaterial, isNew) {
                                     if (isNew && _this._parent.onMaterialLoaded) {
                                         _this._parent.onMaterialLoaded(babylonMaterial);
@@ -3760,10 +3788,13 @@ var BABYLON;
                 var vertexData = new BABYLON.VertexData();
                 var loadedAttributes = 0;
                 var totalAttributes = Object.keys(attributes).length;
-                var _loop_2 = function (semantic) {
-                    accessor = this_2._gltf.accessors[attributes[semantic]];
+                var _loop_2 = function (attribute) {
+                    accessor = this_2._getArrayItem(this_2._gltf.accessors, attributes[attribute], "Mesh primitive attribute '" + attribute + "' accessor");
+                    if (!accessor) {
+                        return { value: void 0 };
+                    }
                     this_2._loadAccessorAsync(accessor, function (data) {
-                        switch (semantic) {
+                        switch (attribute) {
                             case "NORMAL":
                                 vertexData.normals = data;
                                 break;
@@ -3789,28 +3820,33 @@ var BABYLON;
                                 vertexData.colors = data;
                                 break;
                             default:
-                                BABYLON.Tools.Warn("Ignoring unrecognized semantic '" + semantic + "'");
+                                BABYLON.Tools.Warn("Ignoring unrecognized attribute '" + attribute + "'");
                                 break;
                         }
                         if (++loadedAttributes === totalAttributes) {
-                            var indicesAccessor = _this._gltf.accessors[primitive.indices];
-                            if (indicesAccessor) {
+                            if (primitive.indices == null) {
+                                vertexData.indices = new Uint32Array(vertexData.positions.length / 3);
+                                vertexData.indices.forEach(function (v, i) { return vertexData.indices[i] = i; });
+                                onSuccess(vertexData);
+                            }
+                            else {
+                                var indicesAccessor = _this._getArrayItem(_this._gltf.accessors, primitive.indices, "Mesh primitive 'indices' accessor");
+                                if (!indicesAccessor) {
+                                    return;
+                                }
                                 _this._loadAccessorAsync(indicesAccessor, function (data) {
                                     vertexData.indices = data;
                                     onSuccess(vertexData);
                                 });
                             }
-                            else {
-                                vertexData.indices = new Uint32Array(vertexData.positions.length / 3);
-                                vertexData.indices.forEach(function (v, i) { return vertexData.indices[i] = i; });
-                                onSuccess(vertexData);
-                            }
                         }
                     });
                 };
                 var this_2 = this, accessor;
-                for (var semantic in attributes) {
-                    _loop_2(semantic);
+                for (var attribute in attributes) {
+                    var state_1 = _loop_2(attribute);
+                    if (typeof state_1 === "object")
+                        return state_1.value;
                 }
             };
             GLTFLoader.prototype._createMorphTargets = function (node, mesh, primitive, babylonMesh) {
@@ -3834,8 +3870,11 @@ var BABYLON;
                 var _loop_3 = function () {
                     var babylonMorphTarget = babylonMesh.morphTargetManager.getTarget(index);
                     attributes = targets[index];
-                    var _loop_4 = function (semantic) {
-                        accessor = this_3._gltf.accessors[attributes[semantic]];
+                    var _loop_4 = function (attribute) {
+                        accessor = this_3._getArrayItem(this_3._gltf.accessors, attributes[attribute], "Mesh primitive morph target attribute '" + attribute + "' accessor");
+                        if (!accessor) {
+                            return { value: void 0 };
+                        }
                         this_3._loadAccessorAsync(accessor, function (data) {
                             if (accessor.name) {
                                 babylonMorphTarget.name = accessor.name;
@@ -3843,7 +3882,7 @@ var BABYLON;
                             // glTF stores morph target information as deltas while babylon.js expects the final data.
                             // As a result we have to add the original data to the delta to calculate the final data.
                             var values = data;
-                            switch (semantic) {
+                            switch (attribute) {
                                 case "NORMAL":
                                     GLTF2.GLTFUtils.ForEach(values, function (v, i) { return values[i] += vertexData.normals[i]; });
                                     babylonMorphTarget.setNormals(values);
@@ -3865,18 +3904,22 @@ var BABYLON;
                                     babylonMorphTarget.setTangents(values);
                                     break;
                                 default:
-                                    BABYLON.Tools.Warn("Ignoring unrecognized semantic '" + semantic + "'");
+                                    BABYLON.Tools.Warn("Ignoring unrecognized attribute '" + attribute + "'");
                                     break;
                             }
                         });
                     };
-                    for (var semantic in attributes) {
-                        _loop_4(semantic);
+                    for (var attribute in attributes) {
+                        var state_2 = _loop_4(attribute);
+                        if (typeof state_2 === "object")
+                            return state_2;
                     }
                 };
                 var this_3 = this, attributes, accessor;
                 for (var index = 0; index < targets.length; index++) {
-                    _loop_3();
+                    var state_3 = _loop_3();
+                    if (typeof state_3 === "object")
+                        return state_3.value;
                 }
             };
             GLTFLoader.prototype._loadTransform = function (node) {
@@ -3903,11 +3946,14 @@ var BABYLON;
                 var _this = this;
                 var skeletonId = "skeleton" + skin.index;
                 skin.babylonSkeleton = new BABYLON.Skeleton(skin.name || skeletonId, skeletonId, this._babylonScene);
-                if (skin.inverseBindMatrices === undefined) {
+                if (skin.inverseBindMatrices == null) {
                     this._loadBones(skin, null);
                 }
                 else {
-                    var accessor = this._gltf.accessors[skin.inverseBindMatrices];
+                    var accessor = this._getArrayItem(this._gltf.accessors, skin.inverseBindMatrices, "Skin (" + skin.index + ") inverse bind matrices attribute accessor");
+                    if (!accessor) {
+                        return;
+                    }
                     this._loadAccessorAsync(accessor, function (data) {
                         _this._loadBones(skin, data);
                     });
@@ -3925,7 +3971,10 @@ var BABYLON;
             GLTFLoader.prototype._loadBones = function (skin, inverseBindMatrixData) {
                 var babylonBones = {};
                 for (var i = 0; i < skin.joints.length; i++) {
-                    var node = this._gltf.nodes[skin.joints[i]];
+                    var node = this._getArrayItem(this._gltf.nodes, skin.joints[i], "Skin (" + skin.index + ") joint");
+                    if (!node) {
+                        return;
+                    }
                     this._loadBone(node, skin, inverseBindMatrixData, babylonBones);
                 }
             };
@@ -3965,7 +4014,10 @@ var BABYLON;
                 if (GLTF2.GLTFLoaderExtension.TraverseNode(this, index, action, parentNode)) {
                     return;
                 }
-                var node = this._gltf.nodes[index];
+                var node = this._getArrayItem(this._gltf.nodes, index, "Node");
+                if (!node) {
+                    return;
+                }
                 if (!action(node, index, parentNode)) {
                     return;
                 }
@@ -3975,7 +4027,7 @@ var BABYLON;
             };
             GLTFLoader.prototype._loadAnimations = function () {
                 var animations = this._gltf.animations;
-                if (!animations || animations.length === 0) {
+                if (!animations) {
                     return;
                 }
                 for (var animationIndex = 0; animationIndex < animations.length; animationIndex++) {
@@ -3989,9 +4041,8 @@ var BABYLON;
                 var channel = animation.channels[channelIndex];
                 var samplerIndex = channel.sampler;
                 var sampler = animation.samplers[samplerIndex];
-                var targetNode = this._gltf.nodes[channel.target.node];
+                var targetNode = this._getArrayItem(this._gltf.nodes, channel.target.node, "Animation channel target");
                 if (!targetNode) {
-                    BABYLON.Tools.Warn("Animation channel target node (" + channel.target.node + ") does not exist");
                     return;
                 }
                 var targetPath = {
@@ -4001,7 +4052,7 @@ var BABYLON;
                     "weights": "influence"
                 }[channel.target.path];
                 if (!targetPath) {
-                    BABYLON.Tools.Warn("Animation channel target path '" + channel.target.path + "' is not valid");
+                    this._onError("Invalid animation channel target path '" + channel.target.path + "'");
                     return;
                 }
                 var animationType = {
@@ -4086,18 +4137,32 @@ var BABYLON;
                         }
                     }
                 };
-                this._loadAccessorAsync(this._gltf.accessors[sampler.input], function (data) {
+                var inputAccessor = this._getArrayItem(this._gltf.accessors, sampler.input, "Animation sampler input accessor");
+                if (!inputAccessor) {
+                    return;
+                }
+                this._loadAccessorAsync(inputAccessor, function (data) {
                     inputData = data;
                     checkSuccess();
                 });
-                this._loadAccessorAsync(this._gltf.accessors[sampler.output], function (data) {
+                var outputAccessor = this._getArrayItem(this._gltf.accessors, sampler.output, "Animation sampler output accessor");
+                if (!outputAccessor) {
+                    return;
+                }
+                this._loadAccessorAsync(outputAccessor, function (data) {
                     outputData = data;
                     checkSuccess();
                 });
             };
-            GLTFLoader.prototype._loadBufferAsync = function (index, onSuccess) {
+            GLTFLoader.prototype._validateUri = function (uri) {
+                if (!uri) {
+                    this._onError("Uri is missing");
+                    return false;
+                }
+                return true;
+            };
+            GLTFLoader.prototype._loadBufferAsync = function (buffer, onSuccess) {
                 var _this = this;
-                var buffer = this._gltf.buffers[index];
                 this._addPendingData(buffer);
                 if (buffer.loadedData) {
                     setTimeout(function () {
@@ -4105,40 +4170,37 @@ var BABYLON;
                         _this._removePendingData(buffer);
                     });
                 }
-                else if (GLTF2.GLTFUtils.IsBase64(buffer.uri)) {
-                    var data = GLTF2.GLTFUtils.DecodeBase64(buffer.uri);
-                    buffer.loadedData = new Uint8Array(data);
-                    setTimeout(function () {
-                        onSuccess(buffer.loadedData);
-                        _this._removePendingData(buffer);
-                    });
-                }
                 else if (buffer.loadedObservable) {
                     buffer.loadedObservable.add(function (buffer) {
                         onSuccess(buffer.loadedData);
                         _this._removePendingData(buffer);
                     });
                 }
-                else {
-                    buffer.loadedObservable = new BABYLON.Observable();
-                    buffer.loadedObservable.add(function (buffer) {
-                        onSuccess(buffer.loadedData);
-                        _this._removePendingData(buffer);
-                    });
-                    BABYLON.Tools.LoadFile(this._rootUrl + buffer.uri, function (data) {
+                else if (this._validateUri(buffer.uri)) {
+                    if (GLTF2.GLTFUtils.IsBase64(buffer.uri)) {
+                        var data = GLTF2.GLTFUtils.DecodeBase64(buffer.uri);
                         buffer.loadedData = new Uint8Array(data);
-                        buffer.loadedObservable.notifyObservers(buffer);
-                        buffer.loadedObservable = null;
-                    }, function (event) {
-                        if (!_this._disposed) {
-                            _this._onProgress(event);
-                        }
-                    }, this._babylonScene.database, true, function (request) {
-                        if (!_this._disposed) {
-                            _this._onError("Failed to load file '" + buffer.uri + "': " + request.status + " " + request.statusText);
+                        setTimeout(function () {
+                            onSuccess(buffer.loadedData);
                             _this._removePendingData(buffer);
-                        }
-                    });
+                        });
+                    }
+                    else {
+                        buffer.loadedObservable = new BABYLON.Observable();
+                        buffer.loadedObservable.add(function (buffer) {
+                            onSuccess(buffer.loadedData);
+                            _this._removePendingData(buffer);
+                        });
+                        BABYLON.Tools.LoadFile(this._rootUrl + buffer.uri, function (data) {
+                            buffer.loadedData = new Uint8Array(data);
+                            buffer.loadedObservable.notifyObservers(buffer);
+                            buffer.loadedObservable = null;
+                        }, function (event) {
+                            _this._onProgress(event);
+                        }, this._babylonScene.database, true, function (request) {
+                            _this._onError("Failed to load file '" + buffer.uri + "'" + (request ? ": " + request.status + " " + request.statusText : ""));
+                        });
+                    }
                 }
             };
             GLTFLoader.prototype._buildInt8ArrayBuffer = function (buffer, byteOffset, byteLength, byteStride, bytePerComponent) {
@@ -4210,7 +4272,11 @@ var BABYLON;
             GLTFLoader.prototype._loadBufferViewAsync = function (bufferView, byteOffset, byteLength, bytePerComponent, componentType, onSuccess) {
                 var _this = this;
                 byteOffset += (bufferView.byteOffset || 0);
-                this._loadBufferAsync(bufferView.buffer, function (bufferData) {
+                var buffer = this._getArrayItem(this._gltf.buffers, bufferView.buffer, "Buffer");
+                if (!buffer) {
+                    return;
+                }
+                this._loadBufferAsync(buffer, function (bufferData) {
                     if (byteOffset + byteLength > bufferData.byteLength) {
                         _this._onError("Buffer access is out of range");
                         return;
@@ -4245,7 +4311,10 @@ var BABYLON;
                 });
             };
             GLTFLoader.prototype._loadAccessorAsync = function (accessor, onSuccess) {
-                var bufferView = this._gltf.bufferViews[accessor.bufferView];
+                var bufferView = this._getArrayItem(this._gltf.bufferViews, accessor.bufferView, "Buffer view");
+                if (!bufferView) {
+                    return;
+                }
                 var byteOffset = accessor.byteOffset || 0;
                 var bytePerComponent = this._getByteStrideFromType(accessor);
                 var byteLength = accessor.count * bytePerComponent;
@@ -4325,8 +4394,8 @@ var BABYLON;
                     return;
                 }
                 babylonMaterial.albedoColor = properties.baseColorFactor ? BABYLON.Color3.FromArray(properties.baseColorFactor) : new BABYLON.Color3(1, 1, 1);
-                babylonMaterial.metallic = properties.metallicFactor === undefined ? 1 : properties.metallicFactor;
-                babylonMaterial.roughness = properties.roughnessFactor === undefined ? 1 : properties.roughnessFactor;
+                babylonMaterial.metallic = properties.metallicFactor == null ? 1 : properties.metallicFactor;
+                babylonMaterial.roughness = properties.roughnessFactor == null ? 1 : properties.roughnessFactor;
                 if (properties.baseColorTexture) {
                     babylonMaterial.albedoTexture = this._loadTexture(properties.baseColorTexture);
                 }
@@ -4400,20 +4469,26 @@ var BABYLON;
                         }
                         break;
                     default:
-                        BABYLON.Tools.Warn("Invalid alpha mode '" + material.alphaMode + "'");
-                        break;
+                        this._onError("Invalid alpha mode '" + material.alphaMode + "'");
+                        return;
                 }
-                babylonMaterial.alphaCutOff = material.alphaCutoff === undefined ? 0.5 : material.alphaCutoff;
+                babylonMaterial.alphaCutOff = material.alphaCutoff == null ? 0.5 : material.alphaCutoff;
             };
             GLTFLoader.prototype._loadTexture = function (textureInfo) {
                 var _this = this;
-                var texture = this._gltf.textures[textureInfo.index];
+                var texture = this._getArrayItem(this._gltf.textures, textureInfo.index, "Texture");
+                if (!texture) {
+                    return null;
+                }
                 var texCoord = textureInfo.texCoord || 0;
-                if (!texture || texture.source === undefined) {
+                var source = this._getArrayItem(this._gltf.images, texture.source, "Texture (" + textureInfo.index + ") source");
+                if (!source) {
                     return null;
                 }
-                var source = this._gltf.images[texture.source];
-                var sampler = (texture.sampler === undefined ? {} : this._gltf.samplers[texture.sampler]);
+                var sampler = (texture.sampler == null ? {} : this._getArrayItem(this._gltf.samplers, texture.sampler, "Texture (" + textureInfo.index + ") sampler"));
+                if (!sampler) {
+                    return;
+                }
                 var noMipMaps = (sampler.minFilter === GLTF2.ETextureMinFilter.NEAREST || sampler.minFilter === GLTF2.ETextureMinFilter.LINEAR);
                 var samplingMode = GLTF2.GLTFUtils.GetTextureSamplingMode(sampler.magFilter, sampler.minFilter);
                 this._addPendingData(texture);
@@ -4445,7 +4520,10 @@ var BABYLON;
                         texture.dataReadyObservable.notifyObservers(texture);
                     };
                     if (!source.uri) {
-                        var bufferView = this._gltf.bufferViews[source.bufferView];
+                        var bufferView = this._getArrayItem(this._gltf.bufferViews, source.bufferView, "Texture (" + textureInfo.index + ") source (" + texture.source + ") buffer view");
+                        if (!bufferView) {
+                            return;
+                        }
                         this._loadBufferViewAsync(bufferView, 0, bufferView.byteLength, 1, GLTF2.EComponentType.UNSIGNED_BYTE, setTextureData);
                     }
                     else if (GLTF2.GLTFUtils.IsBase64(source.uri)) {
@@ -4453,9 +4531,7 @@ var BABYLON;
                     }
                     else {
                         BABYLON.Tools.LoadFile(this._rootUrl + source.uri, setTextureData, function (event) {
-                            if (!_this._disposed) {
-                                _this._onProgress(event);
-                            }
+                            _this._onProgress(event);
                         }, this._babylonScene.database, true, function (request) {
                             _this._onError("Failed to load file '" + source.uri + "': " + request.status + " " + request.statusText);
                         });
@@ -4470,9 +4546,16 @@ var BABYLON;
                 }
                 return babylonTexture;
             };
-            GLTFLoader.Extensions = {};
+            GLTFLoader.prototype._getArrayItem = function (array, index, name) {
+                if (!array || !array[index]) {
+                    this._onError(name + " index (" + index + ") was not found");
+                    return null;
+                }
+                return array[index];
+            };
             return GLTFLoader;
         }());
+        GLTFLoader.Extensions = {};
         GLTF2.GLTFLoader = GLTFLoader;
         BABYLON.GLTFFileLoader.CreateGLTFLoaderV2 = function (parent) { return new GLTFLoader(parent); };
     })(GLTF2 = BABYLON.GLTF2 || (BABYLON.GLTF2 = {}));
@@ -4633,12 +4716,12 @@ var BABYLON;
                 }
                 return false;
             };
-            //
-            // Utilities
-            //
-            GLTFLoaderExtension._Extensions = [];
             return GLTFLoaderExtension;
         }());
+        //
+        // Utilities
+        //
+        GLTFLoaderExtension._Extensions = [];
         GLTF2.GLTFLoaderExtension = GLTFLoaderExtension;
     })(GLTF2 = BABYLON.GLTF2 || (BABYLON.GLTF2 = {}));
 })(BABYLON || (BABYLON = {}));
@@ -4667,7 +4750,10 @@ var BABYLON;
                     configurable: true
                 });
                 MSFTLOD.prototype._traverseNode = function (loader, index, action, parentNode) {
-                    var node = loader._gltf.nodes[index];
+                    var node = loader._getArrayItem(loader._gltf.nodes, index, "Node");
+                    if (!node) {
+                        return true;
+                    }
                     return this._loadExtension(node, function (extension, onComplete) {
                         for (var i = extension.ids.length - 1; i >= 0; i--) {
                             loader._traverseNode(extension.ids[i], action, parentNode);
@@ -4736,12 +4822,12 @@ var BABYLON;
                         });
                     });
                 };
-                /**
-                 * Specify the minimal delay between LODs in ms (default = 250)
-                 */
-                MSFTLOD.MinimalLODDelay = 250;
                 return MSFTLOD;
             }(GLTF2.GLTFLoaderExtension));
+            /**
+             * Specify the minimal delay between LODs in ms (default = 250)
+             */
+            MSFTLOD.MinimalLODDelay = 250;
             Extensions.MSFTLOD = MSFTLOD;
             GLTF2.GLTFLoader.RegisterExtension(new MSFTLOD());
         })(Extensions = GLTF2.Extensions || (GLTF2.Extensions = {}));

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

@@ -893,6 +893,7 @@ declare module BABYLON.GLTF2 {
         private _parent;
         private _rootUrl;
         private _defaultMaterial;
+        private _rootNode;
         private _successCallback;
         private _progressCallback;
         private _errorCallback;
@@ -911,7 +912,7 @@ declare module BABYLON.GLTF2 {
         importMeshAsync(meshesNames: any, scene: Scene, data: IGLTFLoaderData, rootUrl: string, onSuccess: (meshes: AbstractMesh[], particleSystems: ParticleSystem[], skeletons: Skeleton[]) => void, onProgress: (event: ProgressEvent) => void, onError: (message: string) => void): void;
         loadAsync(scene: Scene, data: IGLTFLoaderData, rootUrl: string, onSuccess: () => void, onProgress: (event: ProgressEvent) => void, onError: (message: string) => void): void;
         private _loadAsync(nodeNames, scene, data, rootUrl, onSuccess, onProgress, onError);
-        private _onError(message);
+        _onError(message: string): void;
         private _onProgress(event);
         _executeWhenRenderReady(func: () => void): void;
         private _onRenderReady();
@@ -937,7 +938,8 @@ declare module BABYLON.GLTF2 {
         _traverseNode(index: number, action: (node: IGLTFNode, index: number, parentNode: IGLTFNode) => boolean, parentNode?: IGLTFNode): void;
         private _loadAnimations();
         private _loadAnimationChannel(animation, animationIndex, channelIndex);
-        private _loadBufferAsync(index, onSuccess);
+        private _validateUri(uri);
+        private _loadBufferAsync(buffer, onSuccess);
         private _buildInt8ArrayBuffer(buffer, byteOffset, byteLength, byteStride, bytePerComponent);
         private _buildUint8ArrayBuffer(buffer, byteOffset, byteLength, byteStride, bytePerComponent);
         private _buildInt16ArrayBuffer(buffer, byteOffset, byteLength, byteStride, bytePerComponent);
@@ -960,6 +962,7 @@ declare module BABYLON.GLTF2 {
         _loadMaterialBaseProperties(material: IGLTFMaterial): void;
         _loadMaterialAlphaProperties(material: IGLTFMaterial, colorFactor?: number[]): void;
         _loadTexture(textureInfo: IGLTFTextureInfo): Texture;
+        _getArrayItem<T>(array: ArrayLike<T>, index: number, name: string): T;
     }
 }
 

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

@@ -255,35 +255,35 @@ var BABYLON;
         CellMaterial.Parse = function (source, scene, rootUrl) {
             return BABYLON.SerializationHelper.Parse(function () { return new CellMaterial(source.name, scene); }, source, scene, rootUrl);
         };
-        __decorate([
-            BABYLON.serializeAsTexture("diffuseTexture")
-        ], CellMaterial.prototype, "_diffuseTexture", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-        ], CellMaterial.prototype, "diffuseTexture", void 0);
-        __decorate([
-            BABYLON.serializeAsColor3("diffuseColor")
-        ], CellMaterial.prototype, "diffuseColor", void 0);
-        __decorate([
-            BABYLON.serialize("computeHighLevel")
-        ], CellMaterial.prototype, "_computeHighLevel", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-        ], CellMaterial.prototype, "computeHighLevel", void 0);
-        __decorate([
-            BABYLON.serialize("disableLighting")
-        ], CellMaterial.prototype, "_disableLighting", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
-        ], CellMaterial.prototype, "disableLighting", void 0);
-        __decorate([
-            BABYLON.serialize("maxSimultaneousLights")
-        ], CellMaterial.prototype, "_maxSimultaneousLights", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
-        ], CellMaterial.prototype, "maxSimultaneousLights", void 0);
         return CellMaterial;
     }(BABYLON.PushMaterial));
+    __decorate([
+        BABYLON.serializeAsTexture("diffuseTexture")
+    ], CellMaterial.prototype, "_diffuseTexture", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+    ], CellMaterial.prototype, "diffuseTexture", void 0);
+    __decorate([
+        BABYLON.serializeAsColor3("diffuseColor")
+    ], CellMaterial.prototype, "diffuseColor", void 0);
+    __decorate([
+        BABYLON.serialize("computeHighLevel")
+    ], CellMaterial.prototype, "_computeHighLevel", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+    ], CellMaterial.prototype, "computeHighLevel", void 0);
+    __decorate([
+        BABYLON.serialize("disableLighting")
+    ], CellMaterial.prototype, "_disableLighting", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
+    ], CellMaterial.prototype, "disableLighting", void 0);
+    __decorate([
+        BABYLON.serialize("maxSimultaneousLights")
+    ], CellMaterial.prototype, "_maxSimultaneousLights", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
+    ], CellMaterial.prototype, "maxSimultaneousLights", void 0);
     BABYLON.CellMaterial = CellMaterial;
 })(BABYLON || (BABYLON = {}));
 

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

@@ -1160,227 +1160,227 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
-        // Flags used to enable or disable a type of texture for all Standard Materials
-        StandardMaterial_OldVer._DiffuseTextureEnabled = true;
-        StandardMaterial_OldVer._AmbientTextureEnabled = true;
-        StandardMaterial_OldVer._OpacityTextureEnabled = true;
-        StandardMaterial_OldVer._ReflectionTextureEnabled = true;
-        StandardMaterial_OldVer._EmissiveTextureEnabled = true;
-        StandardMaterial_OldVer._SpecularTextureEnabled = true;
-        StandardMaterial_OldVer._BumpTextureEnabled = true;
-        StandardMaterial_OldVer._LightmapTextureEnabled = true;
-        StandardMaterial_OldVer._RefractionTextureEnabled = true;
-        StandardMaterial_OldVer._ColorGradingTextureEnabled = true;
-        StandardMaterial_OldVer._FresnelEnabled = true;
-        __decorate([
-            BABYLON.serializeAsTexture("diffuseTexture")
-        ], StandardMaterial_OldVer.prototype, "_diffuseTexture", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-        ], StandardMaterial_OldVer.prototype, "diffuseTexture", void 0);
-        __decorate([
-            BABYLON.serializeAsTexture("ambientTexture")
-        ], StandardMaterial_OldVer.prototype, "_ambientTexture", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-        ], StandardMaterial_OldVer.prototype, "ambientTexture", void 0);
-        __decorate([
-            BABYLON.serializeAsTexture("opacityTexture")
-        ], StandardMaterial_OldVer.prototype, "_opacityTexture", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-        ], StandardMaterial_OldVer.prototype, "opacityTexture", void 0);
-        __decorate([
-            BABYLON.serializeAsTexture("reflectionTexture")
-        ], StandardMaterial_OldVer.prototype, "_reflectionTexture", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-        ], StandardMaterial_OldVer.prototype, "reflectionTexture", void 0);
-        __decorate([
-            BABYLON.serializeAsTexture("emissiveTexture")
-        ], StandardMaterial_OldVer.prototype, "_emissiveTexture", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-        ], StandardMaterial_OldVer.prototype, "emissiveTexture", void 0);
-        __decorate([
-            BABYLON.serializeAsTexture("specularTexture")
-        ], StandardMaterial_OldVer.prototype, "_specularTexture", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-        ], StandardMaterial_OldVer.prototype, "specularTexture", void 0);
-        __decorate([
-            BABYLON.serializeAsTexture("bumpTexture")
-        ], StandardMaterial_OldVer.prototype, "_bumpTexture", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-        ], StandardMaterial_OldVer.prototype, "bumpTexture", void 0);
-        __decorate([
-            BABYLON.serializeAsTexture("lightmapTexture")
-        ], StandardMaterial_OldVer.prototype, "_lightmapTexture", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-        ], StandardMaterial_OldVer.prototype, "lightmapTexture", void 0);
-        __decorate([
-            BABYLON.serializeAsTexture("refractionTexture")
-        ], StandardMaterial_OldVer.prototype, "_refractionTexture", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-        ], StandardMaterial_OldVer.prototype, "refractionTexture", void 0);
-        __decorate([
-            BABYLON.serializeAsColor3("ambient")
-        ], StandardMaterial_OldVer.prototype, "ambientColor", void 0);
-        __decorate([
-            BABYLON.serializeAsColor3("diffuse")
-        ], StandardMaterial_OldVer.prototype, "diffuseColor", void 0);
-        __decorate([
-            BABYLON.serializeAsColor3("specular")
-        ], StandardMaterial_OldVer.prototype, "specularColor", void 0);
-        __decorate([
-            BABYLON.serializeAsColor3("emissive")
-        ], StandardMaterial_OldVer.prototype, "emissiveColor", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], StandardMaterial_OldVer.prototype, "specularPower", void 0);
-        __decorate([
-            BABYLON.serialize("useAlphaFromDiffuseTexture")
-        ], StandardMaterial_OldVer.prototype, "_useAlphaFromDiffuseTexture", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-        ], StandardMaterial_OldVer.prototype, "useAlphaFromDiffuseTexture", void 0);
-        __decorate([
-            BABYLON.serialize("useEmissiveAsIllumination")
-        ], StandardMaterial_OldVer.prototype, "_useEmissiveAsIllumination", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-        ], StandardMaterial_OldVer.prototype, "useEmissiveAsIllumination", void 0);
-        __decorate([
-            BABYLON.serialize("linkEmissiveWithDiffuse")
-        ], StandardMaterial_OldVer.prototype, "_linkEmissiveWithDiffuse", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-        ], StandardMaterial_OldVer.prototype, "linkEmissiveWithDiffuse", void 0);
-        __decorate([
-            BABYLON.serialize("useSpecularOverAlpha")
-        ], StandardMaterial_OldVer.prototype, "_useSpecularOverAlpha", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-        ], StandardMaterial_OldVer.prototype, "useSpecularOverAlpha", void 0);
-        __decorate([
-            BABYLON.serialize("useReflectionOverAlpha")
-        ], StandardMaterial_OldVer.prototype, "_useReflectionOverAlpha", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-        ], StandardMaterial_OldVer.prototype, "useReflectionOverAlpha", void 0);
-        __decorate([
-            BABYLON.serialize("disableLighting")
-        ], StandardMaterial_OldVer.prototype, "_disableLighting", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
-        ], StandardMaterial_OldVer.prototype, "disableLighting", void 0);
-        __decorate([
-            BABYLON.serialize("useParallax")
-        ], StandardMaterial_OldVer.prototype, "_useParallax", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-        ], StandardMaterial_OldVer.prototype, "useParallax", void 0);
-        __decorate([
-            BABYLON.serialize("useParallaxOcclusion")
-        ], StandardMaterial_OldVer.prototype, "_useParallaxOcclusion", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-        ], StandardMaterial_OldVer.prototype, "useParallaxOcclusion", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], StandardMaterial_OldVer.prototype, "parallaxScaleBias", void 0);
-        __decorate([
-            BABYLON.serialize("roughness")
-        ], StandardMaterial_OldVer.prototype, "_roughness", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-        ], StandardMaterial_OldVer.prototype, "roughness", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], StandardMaterial_OldVer.prototype, "indexOfRefraction", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], StandardMaterial_OldVer.prototype, "invertRefractionY", void 0);
-        __decorate([
-            BABYLON.serialize("useLightmapAsShadowmap")
-        ], StandardMaterial_OldVer.prototype, "_useLightmapAsShadowmap", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-        ], StandardMaterial_OldVer.prototype, "useLightmapAsShadowmap", void 0);
-        __decorate([
-            BABYLON.serializeAsFresnelParameters("diffuseFresnelParameters")
-        ], StandardMaterial_OldVer.prototype, "_diffuseFresnelParameters", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsFresnelDirty")
-        ], StandardMaterial_OldVer.prototype, "diffuseFresnelParameters", void 0);
-        __decorate([
-            BABYLON.serializeAsFresnelParameters("opacityFresnelParameters")
-        ], StandardMaterial_OldVer.prototype, "_opacityFresnelParameters", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsFresnelDirty")
-        ], StandardMaterial_OldVer.prototype, "opacityFresnelParameters", void 0);
-        __decorate([
-            BABYLON.serializeAsFresnelParameters("reflectionFresnelParameters")
-        ], StandardMaterial_OldVer.prototype, "_reflectionFresnelParameters", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsFresnelDirty")
-        ], StandardMaterial_OldVer.prototype, "reflectionFresnelParameters", void 0);
-        __decorate([
-            BABYLON.serializeAsFresnelParameters("refractionFresnelParameters")
-        ], StandardMaterial_OldVer.prototype, "_refractionFresnelParameters", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsFresnelDirty")
-        ], StandardMaterial_OldVer.prototype, "refractionFresnelParameters", void 0);
-        __decorate([
-            BABYLON.serializeAsFresnelParameters("emissiveFresnelParameters")
-        ], StandardMaterial_OldVer.prototype, "_emissiveFresnelParameters", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsFresnelDirty")
-        ], StandardMaterial_OldVer.prototype, "emissiveFresnelParameters", void 0);
-        __decorate([
-            BABYLON.serialize("useReflectionFresnelFromSpecular")
-        ], StandardMaterial_OldVer.prototype, "_useReflectionFresnelFromSpecular", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsFresnelDirty")
-        ], StandardMaterial_OldVer.prototype, "useReflectionFresnelFromSpecular", void 0);
-        __decorate([
-            BABYLON.serialize("useGlossinessFromSpecularMapAlpha")
-        ], StandardMaterial_OldVer.prototype, "_useGlossinessFromSpecularMapAlpha", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-        ], StandardMaterial_OldVer.prototype, "useGlossinessFromSpecularMapAlpha", void 0);
-        __decorate([
-            BABYLON.serialize("maxSimultaneousLights")
-        ], StandardMaterial_OldVer.prototype, "_maxSimultaneousLights", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
-        ], StandardMaterial_OldVer.prototype, "maxSimultaneousLights", void 0);
-        __decorate([
-            BABYLON.serialize("invertNormalMapX")
-        ], StandardMaterial_OldVer.prototype, "_invertNormalMapX", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-        ], StandardMaterial_OldVer.prototype, "invertNormalMapX", void 0);
-        __decorate([
-            BABYLON.serialize("invertNormalMapY")
-        ], StandardMaterial_OldVer.prototype, "_invertNormalMapY", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-        ], StandardMaterial_OldVer.prototype, "invertNormalMapY", void 0);
-        __decorate([
-            BABYLON.serialize("twoSidedLighting")
-        ], StandardMaterial_OldVer.prototype, "_twoSidedLighting", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-        ], StandardMaterial_OldVer.prototype, "twoSidedLighting", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], StandardMaterial_OldVer.prototype, "useLogarithmicDepth", null);
         return StandardMaterial_OldVer;
     }(BABYLON.PushMaterial));
+    // Flags used to enable or disable a type of texture for all Standard Materials
+    StandardMaterial_OldVer._DiffuseTextureEnabled = true;
+    StandardMaterial_OldVer._AmbientTextureEnabled = true;
+    StandardMaterial_OldVer._OpacityTextureEnabled = true;
+    StandardMaterial_OldVer._ReflectionTextureEnabled = true;
+    StandardMaterial_OldVer._EmissiveTextureEnabled = true;
+    StandardMaterial_OldVer._SpecularTextureEnabled = true;
+    StandardMaterial_OldVer._BumpTextureEnabled = true;
+    StandardMaterial_OldVer._LightmapTextureEnabled = true;
+    StandardMaterial_OldVer._RefractionTextureEnabled = true;
+    StandardMaterial_OldVer._ColorGradingTextureEnabled = true;
+    StandardMaterial_OldVer._FresnelEnabled = true;
+    __decorate([
+        BABYLON.serializeAsTexture("diffuseTexture")
+    ], StandardMaterial_OldVer.prototype, "_diffuseTexture", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+    ], StandardMaterial_OldVer.prototype, "diffuseTexture", void 0);
+    __decorate([
+        BABYLON.serializeAsTexture("ambientTexture")
+    ], StandardMaterial_OldVer.prototype, "_ambientTexture", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+    ], StandardMaterial_OldVer.prototype, "ambientTexture", void 0);
+    __decorate([
+        BABYLON.serializeAsTexture("opacityTexture")
+    ], StandardMaterial_OldVer.prototype, "_opacityTexture", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+    ], StandardMaterial_OldVer.prototype, "opacityTexture", void 0);
+    __decorate([
+        BABYLON.serializeAsTexture("reflectionTexture")
+    ], StandardMaterial_OldVer.prototype, "_reflectionTexture", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+    ], StandardMaterial_OldVer.prototype, "reflectionTexture", void 0);
+    __decorate([
+        BABYLON.serializeAsTexture("emissiveTexture")
+    ], StandardMaterial_OldVer.prototype, "_emissiveTexture", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+    ], StandardMaterial_OldVer.prototype, "emissiveTexture", void 0);
+    __decorate([
+        BABYLON.serializeAsTexture("specularTexture")
+    ], StandardMaterial_OldVer.prototype, "_specularTexture", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+    ], StandardMaterial_OldVer.prototype, "specularTexture", void 0);
+    __decorate([
+        BABYLON.serializeAsTexture("bumpTexture")
+    ], StandardMaterial_OldVer.prototype, "_bumpTexture", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+    ], StandardMaterial_OldVer.prototype, "bumpTexture", void 0);
+    __decorate([
+        BABYLON.serializeAsTexture("lightmapTexture")
+    ], StandardMaterial_OldVer.prototype, "_lightmapTexture", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+    ], StandardMaterial_OldVer.prototype, "lightmapTexture", void 0);
+    __decorate([
+        BABYLON.serializeAsTexture("refractionTexture")
+    ], StandardMaterial_OldVer.prototype, "_refractionTexture", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+    ], StandardMaterial_OldVer.prototype, "refractionTexture", void 0);
+    __decorate([
+        BABYLON.serializeAsColor3("ambient")
+    ], StandardMaterial_OldVer.prototype, "ambientColor", void 0);
+    __decorate([
+        BABYLON.serializeAsColor3("diffuse")
+    ], StandardMaterial_OldVer.prototype, "diffuseColor", void 0);
+    __decorate([
+        BABYLON.serializeAsColor3("specular")
+    ], StandardMaterial_OldVer.prototype, "specularColor", void 0);
+    __decorate([
+        BABYLON.serializeAsColor3("emissive")
+    ], StandardMaterial_OldVer.prototype, "emissiveColor", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], StandardMaterial_OldVer.prototype, "specularPower", void 0);
+    __decorate([
+        BABYLON.serialize("useAlphaFromDiffuseTexture")
+    ], StandardMaterial_OldVer.prototype, "_useAlphaFromDiffuseTexture", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+    ], StandardMaterial_OldVer.prototype, "useAlphaFromDiffuseTexture", void 0);
+    __decorate([
+        BABYLON.serialize("useEmissiveAsIllumination")
+    ], StandardMaterial_OldVer.prototype, "_useEmissiveAsIllumination", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+    ], StandardMaterial_OldVer.prototype, "useEmissiveAsIllumination", void 0);
+    __decorate([
+        BABYLON.serialize("linkEmissiveWithDiffuse")
+    ], StandardMaterial_OldVer.prototype, "_linkEmissiveWithDiffuse", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+    ], StandardMaterial_OldVer.prototype, "linkEmissiveWithDiffuse", void 0);
+    __decorate([
+        BABYLON.serialize("useSpecularOverAlpha")
+    ], StandardMaterial_OldVer.prototype, "_useSpecularOverAlpha", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+    ], StandardMaterial_OldVer.prototype, "useSpecularOverAlpha", void 0);
+    __decorate([
+        BABYLON.serialize("useReflectionOverAlpha")
+    ], StandardMaterial_OldVer.prototype, "_useReflectionOverAlpha", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+    ], StandardMaterial_OldVer.prototype, "useReflectionOverAlpha", void 0);
+    __decorate([
+        BABYLON.serialize("disableLighting")
+    ], StandardMaterial_OldVer.prototype, "_disableLighting", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
+    ], StandardMaterial_OldVer.prototype, "disableLighting", void 0);
+    __decorate([
+        BABYLON.serialize("useParallax")
+    ], StandardMaterial_OldVer.prototype, "_useParallax", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+    ], StandardMaterial_OldVer.prototype, "useParallax", void 0);
+    __decorate([
+        BABYLON.serialize("useParallaxOcclusion")
+    ], StandardMaterial_OldVer.prototype, "_useParallaxOcclusion", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+    ], StandardMaterial_OldVer.prototype, "useParallaxOcclusion", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], StandardMaterial_OldVer.prototype, "parallaxScaleBias", void 0);
+    __decorate([
+        BABYLON.serialize("roughness")
+    ], StandardMaterial_OldVer.prototype, "_roughness", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+    ], StandardMaterial_OldVer.prototype, "roughness", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], StandardMaterial_OldVer.prototype, "indexOfRefraction", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], StandardMaterial_OldVer.prototype, "invertRefractionY", void 0);
+    __decorate([
+        BABYLON.serialize("useLightmapAsShadowmap")
+    ], StandardMaterial_OldVer.prototype, "_useLightmapAsShadowmap", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+    ], StandardMaterial_OldVer.prototype, "useLightmapAsShadowmap", void 0);
+    __decorate([
+        BABYLON.serializeAsFresnelParameters("diffuseFresnelParameters")
+    ], StandardMaterial_OldVer.prototype, "_diffuseFresnelParameters", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsFresnelDirty")
+    ], StandardMaterial_OldVer.prototype, "diffuseFresnelParameters", void 0);
+    __decorate([
+        BABYLON.serializeAsFresnelParameters("opacityFresnelParameters")
+    ], StandardMaterial_OldVer.prototype, "_opacityFresnelParameters", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsFresnelDirty")
+    ], StandardMaterial_OldVer.prototype, "opacityFresnelParameters", void 0);
+    __decorate([
+        BABYLON.serializeAsFresnelParameters("reflectionFresnelParameters")
+    ], StandardMaterial_OldVer.prototype, "_reflectionFresnelParameters", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsFresnelDirty")
+    ], StandardMaterial_OldVer.prototype, "reflectionFresnelParameters", void 0);
+    __decorate([
+        BABYLON.serializeAsFresnelParameters("refractionFresnelParameters")
+    ], StandardMaterial_OldVer.prototype, "_refractionFresnelParameters", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsFresnelDirty")
+    ], StandardMaterial_OldVer.prototype, "refractionFresnelParameters", void 0);
+    __decorate([
+        BABYLON.serializeAsFresnelParameters("emissiveFresnelParameters")
+    ], StandardMaterial_OldVer.prototype, "_emissiveFresnelParameters", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsFresnelDirty")
+    ], StandardMaterial_OldVer.prototype, "emissiveFresnelParameters", void 0);
+    __decorate([
+        BABYLON.serialize("useReflectionFresnelFromSpecular")
+    ], StandardMaterial_OldVer.prototype, "_useReflectionFresnelFromSpecular", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsFresnelDirty")
+    ], StandardMaterial_OldVer.prototype, "useReflectionFresnelFromSpecular", void 0);
+    __decorate([
+        BABYLON.serialize("useGlossinessFromSpecularMapAlpha")
+    ], StandardMaterial_OldVer.prototype, "_useGlossinessFromSpecularMapAlpha", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+    ], StandardMaterial_OldVer.prototype, "useGlossinessFromSpecularMapAlpha", void 0);
+    __decorate([
+        BABYLON.serialize("maxSimultaneousLights")
+    ], StandardMaterial_OldVer.prototype, "_maxSimultaneousLights", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
+    ], StandardMaterial_OldVer.prototype, "maxSimultaneousLights", void 0);
+    __decorate([
+        BABYLON.serialize("invertNormalMapX")
+    ], StandardMaterial_OldVer.prototype, "_invertNormalMapX", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+    ], StandardMaterial_OldVer.prototype, "invertNormalMapX", void 0);
+    __decorate([
+        BABYLON.serialize("invertNormalMapY")
+    ], StandardMaterial_OldVer.prototype, "_invertNormalMapY", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+    ], StandardMaterial_OldVer.prototype, "invertNormalMapY", void 0);
+    __decorate([
+        BABYLON.serialize("twoSidedLighting")
+    ], StandardMaterial_OldVer.prototype, "_twoSidedLighting", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+    ], StandardMaterial_OldVer.prototype, "twoSidedLighting", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], StandardMaterial_OldVer.prototype, "useLogarithmicDepth", null);
     BABYLON.StandardMaterial_OldVer = StandardMaterial_OldVer;
     var CustomShaderStructure = (function () {
         function CustomShaderStructure() {
@@ -2047,9 +2047,9 @@ vColor=color;\n\
             this.CustomParts.Vertex_Before_NormalUpdated = shaderPart.replace("result", "normalUpdated");
             return this;
         };
-        CustomMaterial.ShaderIndexer = 1;
         return CustomMaterial;
     }(StandardMaterial_OldVer));
+    CustomMaterial.ShaderIndexer = 1;
     BABYLON.CustomMaterial = CustomMaterial;
 })(BABYLON || (BABYLON = {}));
 

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

@@ -293,32 +293,32 @@ var BABYLON;
             }
             return material;
         };
-        __decorate([
-            BABYLON.serializeAsTexture("diffuseTexture")
-        ], FireMaterial.prototype, "_diffuseTexture", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-        ], FireMaterial.prototype, "diffuseTexture", void 0);
-        __decorate([
-            BABYLON.serializeAsTexture("distortionTexture")
-        ], FireMaterial.prototype, "_distortionTexture", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-        ], FireMaterial.prototype, "distortionTexture", void 0);
-        __decorate([
-            BABYLON.serializeAsTexture("opacityTexture")
-        ], FireMaterial.prototype, "_opacityTexture", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-        ], FireMaterial.prototype, "opacityTexture", void 0);
-        __decorate([
-            BABYLON.serialize("diffuseColor")
-        ], FireMaterial.prototype, "diffuseColor", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], FireMaterial.prototype, "speed", void 0);
         return FireMaterial;
     }(BABYLON.PushMaterial));
+    __decorate([
+        BABYLON.serializeAsTexture("diffuseTexture")
+    ], FireMaterial.prototype, "_diffuseTexture", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+    ], FireMaterial.prototype, "diffuseTexture", void 0);
+    __decorate([
+        BABYLON.serializeAsTexture("distortionTexture")
+    ], FireMaterial.prototype, "_distortionTexture", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+    ], FireMaterial.prototype, "distortionTexture", void 0);
+    __decorate([
+        BABYLON.serializeAsTexture("opacityTexture")
+    ], FireMaterial.prototype, "_opacityTexture", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+    ], FireMaterial.prototype, "opacityTexture", void 0);
+    __decorate([
+        BABYLON.serialize("diffuseColor")
+    ], FireMaterial.prototype, "diffuseColor", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], FireMaterial.prototype, "speed", void 0);
     BABYLON.FireMaterial = FireMaterial;
 })(BABYLON || (BABYLON = {}));
 

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

@@ -402,65 +402,65 @@ var BABYLON;
             sourceMesh.material._meshes = meshes;
             return meshes;
         };
-        __decorate([
-            BABYLON.serializeAsTexture("diffuseTexture")
-        ], FurMaterial.prototype, "_diffuseTexture", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-        ], FurMaterial.prototype, "diffuseTexture", void 0);
-        __decorate([
-            BABYLON.serializeAsTexture("heightTexture")
-        ], FurMaterial.prototype, "_heightTexture", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-        ], FurMaterial.prototype, "heightTexture", void 0);
-        __decorate([
-            BABYLON.serializeAsColor3()
-        ], FurMaterial.prototype, "diffuseColor", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], FurMaterial.prototype, "furLength", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], FurMaterial.prototype, "furAngle", void 0);
-        __decorate([
-            BABYLON.serializeAsColor3()
-        ], FurMaterial.prototype, "furColor", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], FurMaterial.prototype, "furOffset", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], FurMaterial.prototype, "furSpacing", void 0);
-        __decorate([
-            BABYLON.serializeAsVector3()
-        ], FurMaterial.prototype, "furGravity", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], FurMaterial.prototype, "furSpeed", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], FurMaterial.prototype, "furDensity", void 0);
-        __decorate([
-            BABYLON.serialize("disableLighting")
-        ], FurMaterial.prototype, "_disableLighting", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
-        ], FurMaterial.prototype, "disableLighting", void 0);
-        __decorate([
-            BABYLON.serialize("maxSimultaneousLights")
-        ], FurMaterial.prototype, "_maxSimultaneousLights", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
-        ], FurMaterial.prototype, "maxSimultaneousLights", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], FurMaterial.prototype, "highLevelFur", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], FurMaterial.prototype, "furTime", null);
         return FurMaterial;
     }(BABYLON.PushMaterial));
+    __decorate([
+        BABYLON.serializeAsTexture("diffuseTexture")
+    ], FurMaterial.prototype, "_diffuseTexture", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+    ], FurMaterial.prototype, "diffuseTexture", void 0);
+    __decorate([
+        BABYLON.serializeAsTexture("heightTexture")
+    ], FurMaterial.prototype, "_heightTexture", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+    ], FurMaterial.prototype, "heightTexture", void 0);
+    __decorate([
+        BABYLON.serializeAsColor3()
+    ], FurMaterial.prototype, "diffuseColor", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], FurMaterial.prototype, "furLength", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], FurMaterial.prototype, "furAngle", void 0);
+    __decorate([
+        BABYLON.serializeAsColor3()
+    ], FurMaterial.prototype, "furColor", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], FurMaterial.prototype, "furOffset", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], FurMaterial.prototype, "furSpacing", void 0);
+    __decorate([
+        BABYLON.serializeAsVector3()
+    ], FurMaterial.prototype, "furGravity", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], FurMaterial.prototype, "furSpeed", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], FurMaterial.prototype, "furDensity", void 0);
+    __decorate([
+        BABYLON.serialize("disableLighting")
+    ], FurMaterial.prototype, "_disableLighting", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
+    ], FurMaterial.prototype, "disableLighting", void 0);
+    __decorate([
+        BABYLON.serialize("maxSimultaneousLights")
+    ], FurMaterial.prototype, "_maxSimultaneousLights", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
+    ], FurMaterial.prototype, "maxSimultaneousLights", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], FurMaterial.prototype, "highLevelFur", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], FurMaterial.prototype, "furTime", null);
     BABYLON.FurMaterial = FurMaterial;
 })(BABYLON || (BABYLON = {}));
 

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

@@ -251,35 +251,35 @@ var BABYLON;
         GradientMaterial.Parse = function (source, scene, rootUrl) {
             return BABYLON.SerializationHelper.Parse(function () { return new GradientMaterial(source.name, scene); }, source, scene, rootUrl);
         };
-        __decorate([
-            BABYLON.serialize("maxSimultaneousLights")
-        ], GradientMaterial.prototype, "_maxSimultaneousLights", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
-        ], GradientMaterial.prototype, "maxSimultaneousLights", void 0);
-        __decorate([
-            BABYLON.serializeAsColor3()
-        ], GradientMaterial.prototype, "topColor", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], GradientMaterial.prototype, "topColorAlpha", void 0);
-        __decorate([
-            BABYLON.serializeAsColor3()
-        ], GradientMaterial.prototype, "bottomColor", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], GradientMaterial.prototype, "bottomColorAlpha", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], GradientMaterial.prototype, "offset", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], GradientMaterial.prototype, "smoothness", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], GradientMaterial.prototype, "disableLighting", void 0);
         return GradientMaterial;
     }(BABYLON.PushMaterial));
+    __decorate([
+        BABYLON.serialize("maxSimultaneousLights")
+    ], GradientMaterial.prototype, "_maxSimultaneousLights", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
+    ], GradientMaterial.prototype, "maxSimultaneousLights", void 0);
+    __decorate([
+        BABYLON.serializeAsColor3()
+    ], GradientMaterial.prototype, "topColor", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], GradientMaterial.prototype, "topColorAlpha", void 0);
+    __decorate([
+        BABYLON.serializeAsColor3()
+    ], GradientMaterial.prototype, "bottomColor", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], GradientMaterial.prototype, "bottomColorAlpha", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], GradientMaterial.prototype, "offset", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], GradientMaterial.prototype, "smoothness", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], GradientMaterial.prototype, "disableLighting", void 0);
     BABYLON.GradientMaterial = GradientMaterial;
 })(BABYLON || (BABYLON = {}));
 

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

@@ -172,32 +172,32 @@ var BABYLON;
         GridMaterial.Parse = function (source, scene, rootUrl) {
             return BABYLON.SerializationHelper.Parse(function () { return new GridMaterial(source.name, scene); }, source, scene, rootUrl);
         };
-        __decorate([
-            BABYLON.serializeAsColor3()
-        ], GridMaterial.prototype, "mainColor", void 0);
-        __decorate([
-            BABYLON.serializeAsColor3()
-        ], GridMaterial.prototype, "lineColor", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], GridMaterial.prototype, "gridRatio", void 0);
-        __decorate([
-            BABYLON.serializeAsColor3()
-        ], GridMaterial.prototype, "gridOffset", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], GridMaterial.prototype, "majorUnitFrequency", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], GridMaterial.prototype, "minorUnitVisibility", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], GridMaterial.prototype, "opacity", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], GridMaterial.prototype, "preMultiplyAlpha", void 0);
         return GridMaterial;
     }(BABYLON.PushMaterial));
+    __decorate([
+        BABYLON.serializeAsColor3()
+    ], GridMaterial.prototype, "mainColor", void 0);
+    __decorate([
+        BABYLON.serializeAsColor3()
+    ], GridMaterial.prototype, "lineColor", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], GridMaterial.prototype, "gridRatio", void 0);
+    __decorate([
+        BABYLON.serializeAsColor3()
+    ], GridMaterial.prototype, "gridOffset", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], GridMaterial.prototype, "majorUnitFrequency", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], GridMaterial.prototype, "minorUnitVisibility", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], GridMaterial.prototype, "opacity", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], GridMaterial.prototype, "preMultiplyAlpha", void 0);
     BABYLON.GridMaterial = GridMaterial;
 })(BABYLON || (BABYLON = {}));
 

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

@@ -312,47 +312,47 @@ var BABYLON;
         LavaMaterial.Parse = function (source, scene, rootUrl) {
             return BABYLON.SerializationHelper.Parse(function () { return new LavaMaterial(source.name, scene); }, source, scene, rootUrl);
         };
-        __decorate([
-            BABYLON.serializeAsTexture("diffuseTexture")
-        ], LavaMaterial.prototype, "_diffuseTexture", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-        ], LavaMaterial.prototype, "diffuseTexture", void 0);
-        __decorate([
-            BABYLON.serializeAsTexture()
-        ], LavaMaterial.prototype, "noiseTexture", void 0);
-        __decorate([
-            BABYLON.serializeAsColor3()
-        ], LavaMaterial.prototype, "fogColor", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], LavaMaterial.prototype, "speed", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], LavaMaterial.prototype, "movingSpeed", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], LavaMaterial.prototype, "lowFrequencySpeed", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], LavaMaterial.prototype, "fogDensity", void 0);
-        __decorate([
-            BABYLON.serializeAsColor3()
-        ], LavaMaterial.prototype, "diffuseColor", void 0);
-        __decorate([
-            BABYLON.serialize("disableLighting")
-        ], LavaMaterial.prototype, "_disableLighting", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
-        ], LavaMaterial.prototype, "disableLighting", void 0);
-        __decorate([
-            BABYLON.serialize("maxSimultaneousLights")
-        ], LavaMaterial.prototype, "_maxSimultaneousLights", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
-        ], LavaMaterial.prototype, "maxSimultaneousLights", void 0);
         return LavaMaterial;
     }(BABYLON.PushMaterial));
+    __decorate([
+        BABYLON.serializeAsTexture("diffuseTexture")
+    ], LavaMaterial.prototype, "_diffuseTexture", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+    ], LavaMaterial.prototype, "diffuseTexture", void 0);
+    __decorate([
+        BABYLON.serializeAsTexture()
+    ], LavaMaterial.prototype, "noiseTexture", void 0);
+    __decorate([
+        BABYLON.serializeAsColor3()
+    ], LavaMaterial.prototype, "fogColor", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], LavaMaterial.prototype, "speed", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], LavaMaterial.prototype, "movingSpeed", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], LavaMaterial.prototype, "lowFrequencySpeed", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], LavaMaterial.prototype, "fogDensity", void 0);
+    __decorate([
+        BABYLON.serializeAsColor3()
+    ], LavaMaterial.prototype, "diffuseColor", void 0);
+    __decorate([
+        BABYLON.serialize("disableLighting")
+    ], LavaMaterial.prototype, "_disableLighting", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
+    ], LavaMaterial.prototype, "disableLighting", void 0);
+    __decorate([
+        BABYLON.serialize("maxSimultaneousLights")
+    ], LavaMaterial.prototype, "_maxSimultaneousLights", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
+    ], LavaMaterial.prototype, "maxSimultaneousLights", void 0);
     BABYLON.LavaMaterial = LavaMaterial;
 })(BABYLON || (BABYLON = {}));
 

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

@@ -1284,228 +1284,228 @@ var BABYLON;
         LegacyPBRMaterial.Parse = function (source, scene, rootUrl) {
             return BABYLON.SerializationHelper.Parse(function () { return new LegacyPBRMaterial(source.name, scene); }, source, scene, rootUrl);
         };
-        LegacyPBRMaterial._scaledAlbedo = new BABYLON.Color3();
-        LegacyPBRMaterial._scaledReflectivity = new BABYLON.Color3();
-        LegacyPBRMaterial._scaledEmissive = new BABYLON.Color3();
-        LegacyPBRMaterial._scaledReflection = new BABYLON.Color3();
-        __decorate([
-            BABYLON.serialize()
-        ], LegacyPBRMaterial.prototype, "directIntensity", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], LegacyPBRMaterial.prototype, "emissiveIntensity", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], LegacyPBRMaterial.prototype, "environmentIntensity", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], LegacyPBRMaterial.prototype, "specularIntensity", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], LegacyPBRMaterial.prototype, "disableBumpMap", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], LegacyPBRMaterial.prototype, "overloadedShadowIntensity", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], LegacyPBRMaterial.prototype, "overloadedShadeIntensity", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], LegacyPBRMaterial.prototype, "cameraExposure", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], LegacyPBRMaterial.prototype, "cameraContrast", void 0);
-        __decorate([
-            BABYLON.serializeAsTexture()
-        ], LegacyPBRMaterial.prototype, "cameraColorGradingTexture", void 0);
-        __decorate([
-            BABYLON.serializeAsColorCurves()
-        ], LegacyPBRMaterial.prototype, "cameraColorCurves", void 0);
-        __decorate([
-            BABYLON.serializeAsColor3()
-        ], LegacyPBRMaterial.prototype, "overloadedAmbient", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], LegacyPBRMaterial.prototype, "overloadedAmbientIntensity", void 0);
-        __decorate([
-            BABYLON.serializeAsColor3()
-        ], LegacyPBRMaterial.prototype, "overloadedAlbedo", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], LegacyPBRMaterial.prototype, "overloadedAlbedoIntensity", void 0);
-        __decorate([
-            BABYLON.serializeAsColor3()
-        ], LegacyPBRMaterial.prototype, "overloadedReflectivity", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], LegacyPBRMaterial.prototype, "overloadedReflectivityIntensity", void 0);
-        __decorate([
-            BABYLON.serializeAsColor3()
-        ], LegacyPBRMaterial.prototype, "overloadedEmissive", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], LegacyPBRMaterial.prototype, "overloadedEmissiveIntensity", void 0);
-        __decorate([
-            BABYLON.serializeAsColor3()
-        ], LegacyPBRMaterial.prototype, "overloadedReflection", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], LegacyPBRMaterial.prototype, "overloadedReflectionIntensity", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], LegacyPBRMaterial.prototype, "overloadedMicroSurface", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], LegacyPBRMaterial.prototype, "overloadedMicroSurfaceIntensity", void 0);
-        __decorate([
-            BABYLON.serializeAsTexture()
-        ], LegacyPBRMaterial.prototype, "albedoTexture", void 0);
-        __decorate([
-            BABYLON.serializeAsTexture()
-        ], LegacyPBRMaterial.prototype, "ambientTexture", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], LegacyPBRMaterial.prototype, "ambientTextureStrength", void 0);
-        __decorate([
-            BABYLON.serializeAsTexture()
-        ], LegacyPBRMaterial.prototype, "opacityTexture", void 0);
-        __decorate([
-            BABYLON.serializeAsTexture()
-        ], LegacyPBRMaterial.prototype, "reflectionTexture", void 0);
-        __decorate([
-            BABYLON.serializeAsTexture()
-        ], LegacyPBRMaterial.prototype, "emissiveTexture", void 0);
-        __decorate([
-            BABYLON.serializeAsTexture()
-        ], LegacyPBRMaterial.prototype, "reflectivityTexture", void 0);
-        __decorate([
-            BABYLON.serializeAsTexture()
-        ], LegacyPBRMaterial.prototype, "metallicTexture", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], LegacyPBRMaterial.prototype, "metallic", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], LegacyPBRMaterial.prototype, "roughness", void 0);
-        __decorate([
-            BABYLON.serializeAsTexture()
-        ], LegacyPBRMaterial.prototype, "microSurfaceTexture", void 0);
-        __decorate([
-            BABYLON.serializeAsTexture()
-        ], LegacyPBRMaterial.prototype, "bumpTexture", void 0);
-        __decorate([
-            BABYLON.serializeAsTexture()
-        ], LegacyPBRMaterial.prototype, "lightmapTexture", void 0);
-        __decorate([
-            BABYLON.serializeAsTexture()
-        ], LegacyPBRMaterial.prototype, "refractionTexture", void 0);
-        __decorate([
-            BABYLON.serializeAsColor3("ambient")
-        ], LegacyPBRMaterial.prototype, "ambientColor", void 0);
-        __decorate([
-            BABYLON.serializeAsColor3("albedo")
-        ], LegacyPBRMaterial.prototype, "albedoColor", void 0);
-        __decorate([
-            BABYLON.serializeAsColor3("reflectivity")
-        ], LegacyPBRMaterial.prototype, "reflectivityColor", void 0);
-        __decorate([
-            BABYLON.serializeAsColor3("reflection")
-        ], LegacyPBRMaterial.prototype, "reflectionColor", void 0);
-        __decorate([
-            BABYLON.serializeAsColor3("emissive")
-        ], LegacyPBRMaterial.prototype, "emissiveColor", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], LegacyPBRMaterial.prototype, "microSurface", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], LegacyPBRMaterial.prototype, "indexOfRefraction", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], LegacyPBRMaterial.prototype, "invertRefractionY", void 0);
-        __decorate([
-            BABYLON.serializeAsFresnelParameters()
-        ], LegacyPBRMaterial.prototype, "opacityFresnelParameters", void 0);
-        __decorate([
-            BABYLON.serializeAsFresnelParameters()
-        ], LegacyPBRMaterial.prototype, "emissiveFresnelParameters", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], LegacyPBRMaterial.prototype, "linkRefractionWithTransparency", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], LegacyPBRMaterial.prototype, "linkEmissiveWithAlbedo", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], LegacyPBRMaterial.prototype, "useLightmapAsShadowmap", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], LegacyPBRMaterial.prototype, "useEmissiveAsIllumination", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], LegacyPBRMaterial.prototype, "useAlphaFromAlbedoTexture", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], LegacyPBRMaterial.prototype, "useSpecularOverAlpha", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], LegacyPBRMaterial.prototype, "useMicroSurfaceFromReflectivityMapAlpha", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], LegacyPBRMaterial.prototype, "useRoughnessFromMetallicTextureAlpha", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], LegacyPBRMaterial.prototype, "useRoughnessFromMetallicTextureGreen", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], LegacyPBRMaterial.prototype, "useMetallnessFromMetallicTextureBlue", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], LegacyPBRMaterial.prototype, "useAmbientOcclusionFromMetallicTextureRed", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], LegacyPBRMaterial.prototype, "useAmbientInGrayScale", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], LegacyPBRMaterial.prototype, "useAutoMicroSurfaceFromReflectivityMap", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], LegacyPBRMaterial.prototype, "useScalarInLinearSpace", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], LegacyPBRMaterial.prototype, "usePhysicalLightFalloff", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], LegacyPBRMaterial.prototype, "useRadianceOverAlpha", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], LegacyPBRMaterial.prototype, "useParallax", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], LegacyPBRMaterial.prototype, "useParallaxOcclusion", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], LegacyPBRMaterial.prototype, "parallaxScaleBias", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], LegacyPBRMaterial.prototype, "disableLighting", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], LegacyPBRMaterial.prototype, "maxSimultaneousLights", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], LegacyPBRMaterial.prototype, "invertNormalMapX", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], LegacyPBRMaterial.prototype, "invertNormalMapY", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], LegacyPBRMaterial.prototype, "twoSidedLighting", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], LegacyPBRMaterial.prototype, "useLogarithmicDepth", null);
         return LegacyPBRMaterial;
     }(BABYLON.Material));
+    LegacyPBRMaterial._scaledAlbedo = new BABYLON.Color3();
+    LegacyPBRMaterial._scaledReflectivity = new BABYLON.Color3();
+    LegacyPBRMaterial._scaledEmissive = new BABYLON.Color3();
+    LegacyPBRMaterial._scaledReflection = new BABYLON.Color3();
+    __decorate([
+        BABYLON.serialize()
+    ], LegacyPBRMaterial.prototype, "directIntensity", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], LegacyPBRMaterial.prototype, "emissiveIntensity", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], LegacyPBRMaterial.prototype, "environmentIntensity", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], LegacyPBRMaterial.prototype, "specularIntensity", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], LegacyPBRMaterial.prototype, "disableBumpMap", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], LegacyPBRMaterial.prototype, "overloadedShadowIntensity", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], LegacyPBRMaterial.prototype, "overloadedShadeIntensity", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], LegacyPBRMaterial.prototype, "cameraExposure", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], LegacyPBRMaterial.prototype, "cameraContrast", void 0);
+    __decorate([
+        BABYLON.serializeAsTexture()
+    ], LegacyPBRMaterial.prototype, "cameraColorGradingTexture", void 0);
+    __decorate([
+        BABYLON.serializeAsColorCurves()
+    ], LegacyPBRMaterial.prototype, "cameraColorCurves", void 0);
+    __decorate([
+        BABYLON.serializeAsColor3()
+    ], LegacyPBRMaterial.prototype, "overloadedAmbient", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], LegacyPBRMaterial.prototype, "overloadedAmbientIntensity", void 0);
+    __decorate([
+        BABYLON.serializeAsColor3()
+    ], LegacyPBRMaterial.prototype, "overloadedAlbedo", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], LegacyPBRMaterial.prototype, "overloadedAlbedoIntensity", void 0);
+    __decorate([
+        BABYLON.serializeAsColor3()
+    ], LegacyPBRMaterial.prototype, "overloadedReflectivity", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], LegacyPBRMaterial.prototype, "overloadedReflectivityIntensity", void 0);
+    __decorate([
+        BABYLON.serializeAsColor3()
+    ], LegacyPBRMaterial.prototype, "overloadedEmissive", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], LegacyPBRMaterial.prototype, "overloadedEmissiveIntensity", void 0);
+    __decorate([
+        BABYLON.serializeAsColor3()
+    ], LegacyPBRMaterial.prototype, "overloadedReflection", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], LegacyPBRMaterial.prototype, "overloadedReflectionIntensity", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], LegacyPBRMaterial.prototype, "overloadedMicroSurface", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], LegacyPBRMaterial.prototype, "overloadedMicroSurfaceIntensity", void 0);
+    __decorate([
+        BABYLON.serializeAsTexture()
+    ], LegacyPBRMaterial.prototype, "albedoTexture", void 0);
+    __decorate([
+        BABYLON.serializeAsTexture()
+    ], LegacyPBRMaterial.prototype, "ambientTexture", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], LegacyPBRMaterial.prototype, "ambientTextureStrength", void 0);
+    __decorate([
+        BABYLON.serializeAsTexture()
+    ], LegacyPBRMaterial.prototype, "opacityTexture", void 0);
+    __decorate([
+        BABYLON.serializeAsTexture()
+    ], LegacyPBRMaterial.prototype, "reflectionTexture", void 0);
+    __decorate([
+        BABYLON.serializeAsTexture()
+    ], LegacyPBRMaterial.prototype, "emissiveTexture", void 0);
+    __decorate([
+        BABYLON.serializeAsTexture()
+    ], LegacyPBRMaterial.prototype, "reflectivityTexture", void 0);
+    __decorate([
+        BABYLON.serializeAsTexture()
+    ], LegacyPBRMaterial.prototype, "metallicTexture", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], LegacyPBRMaterial.prototype, "metallic", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], LegacyPBRMaterial.prototype, "roughness", void 0);
+    __decorate([
+        BABYLON.serializeAsTexture()
+    ], LegacyPBRMaterial.prototype, "microSurfaceTexture", void 0);
+    __decorate([
+        BABYLON.serializeAsTexture()
+    ], LegacyPBRMaterial.prototype, "bumpTexture", void 0);
+    __decorate([
+        BABYLON.serializeAsTexture()
+    ], LegacyPBRMaterial.prototype, "lightmapTexture", void 0);
+    __decorate([
+        BABYLON.serializeAsTexture()
+    ], LegacyPBRMaterial.prototype, "refractionTexture", void 0);
+    __decorate([
+        BABYLON.serializeAsColor3("ambient")
+    ], LegacyPBRMaterial.prototype, "ambientColor", void 0);
+    __decorate([
+        BABYLON.serializeAsColor3("albedo")
+    ], LegacyPBRMaterial.prototype, "albedoColor", void 0);
+    __decorate([
+        BABYLON.serializeAsColor3("reflectivity")
+    ], LegacyPBRMaterial.prototype, "reflectivityColor", void 0);
+    __decorate([
+        BABYLON.serializeAsColor3("reflection")
+    ], LegacyPBRMaterial.prototype, "reflectionColor", void 0);
+    __decorate([
+        BABYLON.serializeAsColor3("emissive")
+    ], LegacyPBRMaterial.prototype, "emissiveColor", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], LegacyPBRMaterial.prototype, "microSurface", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], LegacyPBRMaterial.prototype, "indexOfRefraction", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], LegacyPBRMaterial.prototype, "invertRefractionY", void 0);
+    __decorate([
+        BABYLON.serializeAsFresnelParameters()
+    ], LegacyPBRMaterial.prototype, "opacityFresnelParameters", void 0);
+    __decorate([
+        BABYLON.serializeAsFresnelParameters()
+    ], LegacyPBRMaterial.prototype, "emissiveFresnelParameters", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], LegacyPBRMaterial.prototype, "linkRefractionWithTransparency", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], LegacyPBRMaterial.prototype, "linkEmissiveWithAlbedo", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], LegacyPBRMaterial.prototype, "useLightmapAsShadowmap", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], LegacyPBRMaterial.prototype, "useEmissiveAsIllumination", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], LegacyPBRMaterial.prototype, "useAlphaFromAlbedoTexture", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], LegacyPBRMaterial.prototype, "useSpecularOverAlpha", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], LegacyPBRMaterial.prototype, "useMicroSurfaceFromReflectivityMapAlpha", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], LegacyPBRMaterial.prototype, "useRoughnessFromMetallicTextureAlpha", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], LegacyPBRMaterial.prototype, "useRoughnessFromMetallicTextureGreen", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], LegacyPBRMaterial.prototype, "useMetallnessFromMetallicTextureBlue", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], LegacyPBRMaterial.prototype, "useAmbientOcclusionFromMetallicTextureRed", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], LegacyPBRMaterial.prototype, "useAmbientInGrayScale", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], LegacyPBRMaterial.prototype, "useAutoMicroSurfaceFromReflectivityMap", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], LegacyPBRMaterial.prototype, "useScalarInLinearSpace", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], LegacyPBRMaterial.prototype, "usePhysicalLightFalloff", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], LegacyPBRMaterial.prototype, "useRadianceOverAlpha", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], LegacyPBRMaterial.prototype, "useParallax", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], LegacyPBRMaterial.prototype, "useParallaxOcclusion", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], LegacyPBRMaterial.prototype, "parallaxScaleBias", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], LegacyPBRMaterial.prototype, "disableLighting", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], LegacyPBRMaterial.prototype, "maxSimultaneousLights", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], LegacyPBRMaterial.prototype, "invertNormalMapX", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], LegacyPBRMaterial.prototype, "invertNormalMapY", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], LegacyPBRMaterial.prototype, "twoSidedLighting", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], LegacyPBRMaterial.prototype, "useLogarithmicDepth", null);
     BABYLON.LegacyPBRMaterial = LegacyPBRMaterial;
 })(BABYLON || (BABYLON = {}));
 

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

@@ -285,29 +285,29 @@ var BABYLON;
         NormalMaterial.Parse = function (source, scene, rootUrl) {
             return BABYLON.SerializationHelper.Parse(function () { return new NormalMaterial(source.name, scene); }, source, scene, rootUrl);
         };
-        __decorate([
-            BABYLON.serializeAsTexture("diffuseTexture")
-        ], NormalMaterial.prototype, "_diffuseTexture", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-        ], NormalMaterial.prototype, "diffuseTexture", void 0);
-        __decorate([
-            BABYLON.serializeAsColor3()
-        ], NormalMaterial.prototype, "diffuseColor", void 0);
-        __decorate([
-            BABYLON.serialize("disableLighting")
-        ], NormalMaterial.prototype, "_disableLighting", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
-        ], NormalMaterial.prototype, "disableLighting", void 0);
-        __decorate([
-            BABYLON.serialize("maxSimultaneousLights")
-        ], NormalMaterial.prototype, "_maxSimultaneousLights", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
-        ], NormalMaterial.prototype, "maxSimultaneousLights", void 0);
         return NormalMaterial;
     }(BABYLON.PushMaterial));
+    __decorate([
+        BABYLON.serializeAsTexture("diffuseTexture")
+    ], NormalMaterial.prototype, "_diffuseTexture", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+    ], NormalMaterial.prototype, "diffuseTexture", void 0);
+    __decorate([
+        BABYLON.serializeAsColor3()
+    ], NormalMaterial.prototype, "diffuseColor", void 0);
+    __decorate([
+        BABYLON.serialize("disableLighting")
+    ], NormalMaterial.prototype, "_disableLighting", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
+    ], NormalMaterial.prototype, "disableLighting", void 0);
+    __decorate([
+        BABYLON.serialize("maxSimultaneousLights")
+    ], NormalMaterial.prototype, "_maxSimultaneousLights", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
+    ], NormalMaterial.prototype, "maxSimultaneousLights", void 0);
     BABYLON.NormalMaterial = NormalMaterial;
 })(BABYLON || (BABYLON = {}));
 

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

@@ -206,11 +206,11 @@ var BABYLON;
         ShadowOnlyMaterial.Parse = function (source, scene, rootUrl) {
             return BABYLON.SerializationHelper.Parse(function () { return new ShadowOnlyMaterial(source.name, scene); }, source, scene, rootUrl);
         };
-        __decorate([
-            BABYLON.serialize()
-        ], ShadowOnlyMaterial.prototype, "_worldViewProjectionMatrix", void 0);
         return ShadowOnlyMaterial;
     }(BABYLON.PushMaterial));
+    __decorate([
+        BABYLON.serialize()
+    ], ShadowOnlyMaterial.prototype, "_worldViewProjectionMatrix", void 0);
     BABYLON.ShadowOnlyMaterial = ShadowOnlyMaterial;
 })(BABYLON || (BABYLON = {}));
 

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

@@ -252,29 +252,29 @@ var BABYLON;
         SimpleMaterial.Parse = function (source, scene, rootUrl) {
             return BABYLON.SerializationHelper.Parse(function () { return new SimpleMaterial(source.name, scene); }, source, scene, rootUrl);
         };
-        __decorate([
-            BABYLON.serializeAsTexture("diffuseTexture")
-        ], SimpleMaterial.prototype, "_diffuseTexture", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-        ], SimpleMaterial.prototype, "diffuseTexture", void 0);
-        __decorate([
-            BABYLON.serializeAsColor3("diffuseColor")
-        ], SimpleMaterial.prototype, "diffuseColor", void 0);
-        __decorate([
-            BABYLON.serialize("disableLighting")
-        ], SimpleMaterial.prototype, "_disableLighting", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
-        ], SimpleMaterial.prototype, "disableLighting", void 0);
-        __decorate([
-            BABYLON.serialize("maxSimultaneousLights")
-        ], SimpleMaterial.prototype, "_maxSimultaneousLights", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
-        ], SimpleMaterial.prototype, "maxSimultaneousLights", void 0);
         return SimpleMaterial;
     }(BABYLON.PushMaterial));
+    __decorate([
+        BABYLON.serializeAsTexture("diffuseTexture")
+    ], SimpleMaterial.prototype, "_diffuseTexture", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+    ], SimpleMaterial.prototype, "diffuseTexture", void 0);
+    __decorate([
+        BABYLON.serializeAsColor3("diffuseColor")
+    ], SimpleMaterial.prototype, "diffuseColor", void 0);
+    __decorate([
+        BABYLON.serialize("disableLighting")
+    ], SimpleMaterial.prototype, "_disableLighting", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
+    ], SimpleMaterial.prototype, "disableLighting", void 0);
+    __decorate([
+        BABYLON.serialize("maxSimultaneousLights")
+    ], SimpleMaterial.prototype, "_maxSimultaneousLights", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
+    ], SimpleMaterial.prototype, "maxSimultaneousLights", void 0);
     BABYLON.SimpleMaterial = SimpleMaterial;
 })(BABYLON || (BABYLON = {}));
 

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

@@ -185,38 +185,38 @@ var BABYLON;
         SkyMaterial.Parse = function (source, scene, rootUrl) {
             return BABYLON.SerializationHelper.Parse(function () { return new SkyMaterial(source.name, scene); }, source, scene, rootUrl);
         };
-        __decorate([
-            BABYLON.serialize()
-        ], SkyMaterial.prototype, "luminance", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], SkyMaterial.prototype, "turbidity", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], SkyMaterial.prototype, "rayleigh", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], SkyMaterial.prototype, "mieCoefficient", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], SkyMaterial.prototype, "mieDirectionalG", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], SkyMaterial.prototype, "distance", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], SkyMaterial.prototype, "inclination", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], SkyMaterial.prototype, "azimuth", void 0);
-        __decorate([
-            BABYLON.serializeAsVector3()
-        ], SkyMaterial.prototype, "sunPosition", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], SkyMaterial.prototype, "useSunPosition", void 0);
         return SkyMaterial;
     }(BABYLON.PushMaterial));
+    __decorate([
+        BABYLON.serialize()
+    ], SkyMaterial.prototype, "luminance", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], SkyMaterial.prototype, "turbidity", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], SkyMaterial.prototype, "rayleigh", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], SkyMaterial.prototype, "mieCoefficient", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], SkyMaterial.prototype, "mieDirectionalG", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], SkyMaterial.prototype, "distance", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], SkyMaterial.prototype, "inclination", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], SkyMaterial.prototype, "azimuth", void 0);
+    __decorate([
+        BABYLON.serializeAsVector3()
+    ], SkyMaterial.prototype, "sunPosition", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], SkyMaterial.prototype, "useSunPosition", void 0);
     BABYLON.SkyMaterial = SkyMaterial;
 })(BABYLON || (BABYLON = {}));
 

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

@@ -324,71 +324,71 @@ var BABYLON;
         TerrainMaterial.Parse = function (source, scene, rootUrl) {
             return BABYLON.SerializationHelper.Parse(function () { return new TerrainMaterial(source.name, scene); }, source, scene, rootUrl);
         };
-        __decorate([
-            BABYLON.serializeAsTexture("mixTexture")
-        ], TerrainMaterial.prototype, "_mixTexture", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-        ], TerrainMaterial.prototype, "mixTexture", void 0);
-        __decorate([
-            BABYLON.serializeAsTexture("diffuseTexture1")
-        ], TerrainMaterial.prototype, "_diffuseTexture1", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-        ], TerrainMaterial.prototype, "diffuseTexture1", void 0);
-        __decorate([
-            BABYLON.serializeAsTexture("diffuseTexture2")
-        ], TerrainMaterial.prototype, "_diffuseTexture2", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-        ], TerrainMaterial.prototype, "diffuseTexture2", void 0);
-        __decorate([
-            BABYLON.serializeAsTexture("diffuseTexture3")
-        ], TerrainMaterial.prototype, "_diffuseTexture3", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-        ], TerrainMaterial.prototype, "diffuseTexture3", void 0);
-        __decorate([
-            BABYLON.serializeAsTexture("bumpTexture1")
-        ], TerrainMaterial.prototype, "_bumpTexture1", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-        ], TerrainMaterial.prototype, "bumpTexture1", void 0);
-        __decorate([
-            BABYLON.serializeAsTexture("bumpTexture2")
-        ], TerrainMaterial.prototype, "_bumpTexture2", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-        ], TerrainMaterial.prototype, "bumpTexture2", void 0);
-        __decorate([
-            BABYLON.serializeAsTexture("bumpTexture3")
-        ], TerrainMaterial.prototype, "_bumpTexture3", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-        ], TerrainMaterial.prototype, "bumpTexture3", void 0);
-        __decorate([
-            BABYLON.serializeAsColor3()
-        ], TerrainMaterial.prototype, "diffuseColor", void 0);
-        __decorate([
-            BABYLON.serializeAsColor3()
-        ], TerrainMaterial.prototype, "specularColor", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], TerrainMaterial.prototype, "specularPower", void 0);
-        __decorate([
-            BABYLON.serialize("disableLighting")
-        ], TerrainMaterial.prototype, "_disableLighting", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
-        ], TerrainMaterial.prototype, "disableLighting", void 0);
-        __decorate([
-            BABYLON.serialize("maxSimultaneousLights")
-        ], TerrainMaterial.prototype, "_maxSimultaneousLights", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
-        ], TerrainMaterial.prototype, "maxSimultaneousLights", void 0);
         return TerrainMaterial;
     }(BABYLON.PushMaterial));
+    __decorate([
+        BABYLON.serializeAsTexture("mixTexture")
+    ], TerrainMaterial.prototype, "_mixTexture", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+    ], TerrainMaterial.prototype, "mixTexture", void 0);
+    __decorate([
+        BABYLON.serializeAsTexture("diffuseTexture1")
+    ], TerrainMaterial.prototype, "_diffuseTexture1", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+    ], TerrainMaterial.prototype, "diffuseTexture1", void 0);
+    __decorate([
+        BABYLON.serializeAsTexture("diffuseTexture2")
+    ], TerrainMaterial.prototype, "_diffuseTexture2", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+    ], TerrainMaterial.prototype, "diffuseTexture2", void 0);
+    __decorate([
+        BABYLON.serializeAsTexture("diffuseTexture3")
+    ], TerrainMaterial.prototype, "_diffuseTexture3", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+    ], TerrainMaterial.prototype, "diffuseTexture3", void 0);
+    __decorate([
+        BABYLON.serializeAsTexture("bumpTexture1")
+    ], TerrainMaterial.prototype, "_bumpTexture1", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+    ], TerrainMaterial.prototype, "bumpTexture1", void 0);
+    __decorate([
+        BABYLON.serializeAsTexture("bumpTexture2")
+    ], TerrainMaterial.prototype, "_bumpTexture2", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+    ], TerrainMaterial.prototype, "bumpTexture2", void 0);
+    __decorate([
+        BABYLON.serializeAsTexture("bumpTexture3")
+    ], TerrainMaterial.prototype, "_bumpTexture3", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+    ], TerrainMaterial.prototype, "bumpTexture3", void 0);
+    __decorate([
+        BABYLON.serializeAsColor3()
+    ], TerrainMaterial.prototype, "diffuseColor", void 0);
+    __decorate([
+        BABYLON.serializeAsColor3()
+    ], TerrainMaterial.prototype, "specularColor", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], TerrainMaterial.prototype, "specularPower", void 0);
+    __decorate([
+        BABYLON.serialize("disableLighting")
+    ], TerrainMaterial.prototype, "_disableLighting", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
+    ], TerrainMaterial.prototype, "disableLighting", void 0);
+    __decorate([
+        BABYLON.serialize("maxSimultaneousLights")
+    ], TerrainMaterial.prototype, "_maxSimultaneousLights", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
+    ], TerrainMaterial.prototype, "maxSimultaneousLights", void 0);
     BABYLON.TerrainMaterial = TerrainMaterial;
 })(BABYLON || (BABYLON = {}));
 

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

@@ -319,71 +319,71 @@ var BABYLON;
         TriPlanarMaterial.Parse = function (source, scene, rootUrl) {
             return BABYLON.SerializationHelper.Parse(function () { return new TriPlanarMaterial(source.name, scene); }, source, scene, rootUrl);
         };
-        __decorate([
-            BABYLON.serializeAsTexture()
-        ], TriPlanarMaterial.prototype, "mixTexture", void 0);
-        __decorate([
-            BABYLON.serializeAsTexture("diffuseTextureX")
-        ], TriPlanarMaterial.prototype, "_diffuseTextureX", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-        ], TriPlanarMaterial.prototype, "diffuseTextureX", void 0);
-        __decorate([
-            BABYLON.serializeAsTexture("diffuseTexturY")
-        ], TriPlanarMaterial.prototype, "_diffuseTextureY", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-        ], TriPlanarMaterial.prototype, "diffuseTextureY", void 0);
-        __decorate([
-            BABYLON.serializeAsTexture("diffuseTextureZ")
-        ], TriPlanarMaterial.prototype, "_diffuseTextureZ", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-        ], TriPlanarMaterial.prototype, "diffuseTextureZ", void 0);
-        __decorate([
-            BABYLON.serializeAsTexture("normalTextureX")
-        ], TriPlanarMaterial.prototype, "_normalTextureX", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-        ], TriPlanarMaterial.prototype, "normalTextureX", void 0);
-        __decorate([
-            BABYLON.serializeAsTexture("normalTextureY")
-        ], TriPlanarMaterial.prototype, "_normalTextureY", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-        ], TriPlanarMaterial.prototype, "normalTextureY", void 0);
-        __decorate([
-            BABYLON.serializeAsTexture("normalTextureZ")
-        ], TriPlanarMaterial.prototype, "_normalTextureZ", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-        ], TriPlanarMaterial.prototype, "normalTextureZ", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], TriPlanarMaterial.prototype, "tileSize", void 0);
-        __decorate([
-            BABYLON.serializeAsColor3()
-        ], TriPlanarMaterial.prototype, "diffuseColor", void 0);
-        __decorate([
-            BABYLON.serializeAsColor3()
-        ], TriPlanarMaterial.prototype, "specularColor", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], TriPlanarMaterial.prototype, "specularPower", void 0);
-        __decorate([
-            BABYLON.serialize("disableLighting")
-        ], TriPlanarMaterial.prototype, "_disableLighting", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
-        ], TriPlanarMaterial.prototype, "disableLighting", void 0);
-        __decorate([
-            BABYLON.serialize("maxSimultaneousLights")
-        ], TriPlanarMaterial.prototype, "_maxSimultaneousLights", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
-        ], TriPlanarMaterial.prototype, "maxSimultaneousLights", void 0);
         return TriPlanarMaterial;
     }(BABYLON.PushMaterial));
+    __decorate([
+        BABYLON.serializeAsTexture()
+    ], TriPlanarMaterial.prototype, "mixTexture", void 0);
+    __decorate([
+        BABYLON.serializeAsTexture("diffuseTextureX")
+    ], TriPlanarMaterial.prototype, "_diffuseTextureX", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+    ], TriPlanarMaterial.prototype, "diffuseTextureX", void 0);
+    __decorate([
+        BABYLON.serializeAsTexture("diffuseTexturY")
+    ], TriPlanarMaterial.prototype, "_diffuseTextureY", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+    ], TriPlanarMaterial.prototype, "diffuseTextureY", void 0);
+    __decorate([
+        BABYLON.serializeAsTexture("diffuseTextureZ")
+    ], TriPlanarMaterial.prototype, "_diffuseTextureZ", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+    ], TriPlanarMaterial.prototype, "diffuseTextureZ", void 0);
+    __decorate([
+        BABYLON.serializeAsTexture("normalTextureX")
+    ], TriPlanarMaterial.prototype, "_normalTextureX", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+    ], TriPlanarMaterial.prototype, "normalTextureX", void 0);
+    __decorate([
+        BABYLON.serializeAsTexture("normalTextureY")
+    ], TriPlanarMaterial.prototype, "_normalTextureY", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+    ], TriPlanarMaterial.prototype, "normalTextureY", void 0);
+    __decorate([
+        BABYLON.serializeAsTexture("normalTextureZ")
+    ], TriPlanarMaterial.prototype, "_normalTextureZ", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+    ], TriPlanarMaterial.prototype, "normalTextureZ", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], TriPlanarMaterial.prototype, "tileSize", void 0);
+    __decorate([
+        BABYLON.serializeAsColor3()
+    ], TriPlanarMaterial.prototype, "diffuseColor", void 0);
+    __decorate([
+        BABYLON.serializeAsColor3()
+    ], TriPlanarMaterial.prototype, "specularColor", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], TriPlanarMaterial.prototype, "specularPower", void 0);
+    __decorate([
+        BABYLON.serialize("disableLighting")
+    ], TriPlanarMaterial.prototype, "_disableLighting", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
+    ], TriPlanarMaterial.prototype, "disableLighting", void 0);
+    __decorate([
+        BABYLON.serialize("maxSimultaneousLights")
+    ], TriPlanarMaterial.prototype, "_maxSimultaneousLights", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
+    ], TriPlanarMaterial.prototype, "maxSimultaneousLights", void 0);
     BABYLON.TriPlanarMaterial = TriPlanarMaterial;
 })(BABYLON || (BABYLON = {}));
 

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

@@ -516,86 +516,86 @@ var BABYLON;
             var mesh = BABYLON.Mesh.CreateGround(name, 512, 512, 32, scene, false);
             return mesh;
         };
-        __decorate([
-            BABYLON.serializeAsTexture("bumpTexture")
-        ], WaterMaterial.prototype, "_bumpTexture", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-        ], WaterMaterial.prototype, "bumpTexture", void 0);
-        __decorate([
-            BABYLON.serializeAsColor3()
-        ], WaterMaterial.prototype, "diffuseColor", void 0);
-        __decorate([
-            BABYLON.serializeAsColor3()
-        ], WaterMaterial.prototype, "specularColor", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], WaterMaterial.prototype, "specularPower", void 0);
-        __decorate([
-            BABYLON.serialize("disableLighting")
-        ], WaterMaterial.prototype, "_disableLighting", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
-        ], WaterMaterial.prototype, "disableLighting", void 0);
-        __decorate([
-            BABYLON.serialize("maxSimultaneousLights")
-        ], WaterMaterial.prototype, "_maxSimultaneousLights", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
-        ], WaterMaterial.prototype, "maxSimultaneousLights", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], WaterMaterial.prototype, "windForce", void 0);
-        __decorate([
-            BABYLON.serializeAsVector2()
-        ], WaterMaterial.prototype, "windDirection", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], WaterMaterial.prototype, "waveHeight", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], WaterMaterial.prototype, "bumpHeight", void 0);
-        __decorate([
-            BABYLON.serialize("bumpSuperimpose")
-        ], WaterMaterial.prototype, "_bumpSuperimpose", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsMiscDirty")
-        ], WaterMaterial.prototype, "bumpSuperimpose", void 0);
-        __decorate([
-            BABYLON.serialize("fresnelSeparate")
-        ], WaterMaterial.prototype, "_fresnelSeparate", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsMiscDirty")
-        ], WaterMaterial.prototype, "fresnelSeparate", void 0);
-        __decorate([
-            BABYLON.serialize("bumpAffectsReflection")
-        ], WaterMaterial.prototype, "_bumpAffectsReflection", void 0);
-        __decorate([
-            BABYLON.expandToProperty("_markAllSubMeshesAsMiscDirty")
-        ], WaterMaterial.prototype, "bumpAffectsReflection", void 0);
-        __decorate([
-            BABYLON.serializeAsColor3()
-        ], WaterMaterial.prototype, "waterColor", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], WaterMaterial.prototype, "colorBlendFactor", void 0);
-        __decorate([
-            BABYLON.serializeAsColor3()
-        ], WaterMaterial.prototype, "waterColor2", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], WaterMaterial.prototype, "colorBlendFactor2", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], WaterMaterial.prototype, "waveLength", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], WaterMaterial.prototype, "waveSpeed", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], WaterMaterial.prototype, "useLogarithmicDepth", null);
         return WaterMaterial;
     }(BABYLON.PushMaterial));
+    __decorate([
+        BABYLON.serializeAsTexture("bumpTexture")
+    ], WaterMaterial.prototype, "_bumpTexture", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+    ], WaterMaterial.prototype, "bumpTexture", void 0);
+    __decorate([
+        BABYLON.serializeAsColor3()
+    ], WaterMaterial.prototype, "diffuseColor", void 0);
+    __decorate([
+        BABYLON.serializeAsColor3()
+    ], WaterMaterial.prototype, "specularColor", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], WaterMaterial.prototype, "specularPower", void 0);
+    __decorate([
+        BABYLON.serialize("disableLighting")
+    ], WaterMaterial.prototype, "_disableLighting", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
+    ], WaterMaterial.prototype, "disableLighting", void 0);
+    __decorate([
+        BABYLON.serialize("maxSimultaneousLights")
+    ], WaterMaterial.prototype, "_maxSimultaneousLights", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
+    ], WaterMaterial.prototype, "maxSimultaneousLights", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], WaterMaterial.prototype, "windForce", void 0);
+    __decorate([
+        BABYLON.serializeAsVector2()
+    ], WaterMaterial.prototype, "windDirection", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], WaterMaterial.prototype, "waveHeight", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], WaterMaterial.prototype, "bumpHeight", void 0);
+    __decorate([
+        BABYLON.serialize("bumpSuperimpose")
+    ], WaterMaterial.prototype, "_bumpSuperimpose", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsMiscDirty")
+    ], WaterMaterial.prototype, "bumpSuperimpose", void 0);
+    __decorate([
+        BABYLON.serialize("fresnelSeparate")
+    ], WaterMaterial.prototype, "_fresnelSeparate", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsMiscDirty")
+    ], WaterMaterial.prototype, "fresnelSeparate", void 0);
+    __decorate([
+        BABYLON.serialize("bumpAffectsReflection")
+    ], WaterMaterial.prototype, "_bumpAffectsReflection", void 0);
+    __decorate([
+        BABYLON.expandToProperty("_markAllSubMeshesAsMiscDirty")
+    ], WaterMaterial.prototype, "bumpAffectsReflection", void 0);
+    __decorate([
+        BABYLON.serializeAsColor3()
+    ], WaterMaterial.prototype, "waterColor", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], WaterMaterial.prototype, "colorBlendFactor", void 0);
+    __decorate([
+        BABYLON.serializeAsColor3()
+    ], WaterMaterial.prototype, "waterColor2", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], WaterMaterial.prototype, "colorBlendFactor2", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], WaterMaterial.prototype, "waveLength", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], WaterMaterial.prototype, "waveSpeed", void 0);
+    __decorate([
+        BABYLON.serialize()
+    ], WaterMaterial.prototype, "useLogarithmicDepth", null);
     BABYLON.WaterMaterial = WaterMaterial;
 })(BABYLON || (BABYLON = {}));
 

dist/preview release/postProcessesLibrary/babylon.asciiArtPostProcess.js

@@ -145,14 +145,14 @@ var BABYLON;
             var texture = BABYLON.SerializationHelper.Parse(function () { return new AsciiArtFontTexture(source.name, source.font, source.text, scene); }, source, scene, null);
             return texture;
         };
-        __decorate([
-            BABYLON.serialize("font")
-        ], AsciiArtFontTexture.prototype, "_font", void 0);
-        __decorate([
-            BABYLON.serialize("text")
-        ], AsciiArtFontTexture.prototype, "_text", void 0);
         return AsciiArtFontTexture;
     }(BABYLON.BaseTexture));
+    __decorate([
+        BABYLON.serialize("font")
+    ], AsciiArtFontTexture.prototype, "_font", void 0);
+    __decorate([
+        BABYLON.serialize("text")
+    ], AsciiArtFontTexture.prototype, "_text", void 0);
     BABYLON.AsciiArtFontTexture = AsciiArtFontTexture;
     /**
      * AsciiArtPostProcess helps rendering everithing in Ascii Art.

dist/preview release/postProcessesLibrary/babylon.digitalRainPostProcess.js

@@ -145,14 +145,14 @@ var BABYLON;
             var texture = BABYLON.SerializationHelper.Parse(function () { return new DigitalRainFontTexture(source.name, source.font, source.text, scene); }, source, scene, null);
             return texture;
         };
-        __decorate([
-            BABYLON.serialize("font")
-        ], DigitalRainFontTexture.prototype, "_font", void 0);
-        __decorate([
-            BABYLON.serialize("text")
-        ], DigitalRainFontTexture.prototype, "_text", void 0);
         return DigitalRainFontTexture;
     }(BABYLON.BaseTexture));
+    __decorate([
+        BABYLON.serialize("font")
+    ], DigitalRainFontTexture.prototype, "_font", void 0);
+    __decorate([
+        BABYLON.serialize("text")
+    ], DigitalRainFontTexture.prototype, "_text", void 0);
     BABYLON.DigitalRainFontTexture = DigitalRainFontTexture;
     /**
      * DigitalRainPostProcess helps rendering everithing in digital rain.

dist/preview release/postProcessesLibrary/babylonjs.postProcess.js

@@ -148,14 +148,14 @@ var BABYLON;
             var texture = BABYLON.SerializationHelper.Parse(function () { return new AsciiArtFontTexture(source.name, source.font, source.text, scene); }, source, scene, null);
             return texture;
         };
-        __decorate([
-            BABYLON.serialize("font")
-        ], AsciiArtFontTexture.prototype, "_font", void 0);
-        __decorate([
-            BABYLON.serialize("text")
-        ], AsciiArtFontTexture.prototype, "_text", void 0);
         return AsciiArtFontTexture;
     }(BABYLON.BaseTexture));
+    __decorate([
+        BABYLON.serialize("font")
+    ], AsciiArtFontTexture.prototype, "_font", void 0);
+    __decorate([
+        BABYLON.serialize("text")
+    ], AsciiArtFontTexture.prototype, "_text", void 0);
     BABYLON.AsciiArtFontTexture = AsciiArtFontTexture;
     /**
      * AsciiArtPostProcess helps rendering everithing in Ascii Art.
@@ -352,14 +352,14 @@ var BABYLON;
             var texture = BABYLON.SerializationHelper.Parse(function () { return new DigitalRainFontTexture(source.name, source.font, source.text, scene); }, source, scene, null);
             return texture;
         };
-        __decorate([
-            BABYLON.serialize("font")
-        ], DigitalRainFontTexture.prototype, "_font", void 0);
-        __decorate([
-            BABYLON.serialize("text")
-        ], DigitalRainFontTexture.prototype, "_text", void 0);
         return DigitalRainFontTexture;
     }(BABYLON.BaseTexture));
+    __decorate([
+        BABYLON.serialize("font")
+    ], DigitalRainFontTexture.prototype, "_font", void 0);
+    __decorate([
+        BABYLON.serialize("text")
+    ], DigitalRainFontTexture.prototype, "_text", void 0);
     BABYLON.DigitalRainFontTexture = DigitalRainFontTexture;
     /**
      * DigitalRainPostProcess helps rendering everithing in digital rain.