Merge master

dist/preview release/babylon.max.js

@@ -15303,9 +15303,11 @@ var BABYLON;
         };
         /**
          * Is this node ready to be used/rendered
+         * @param completeCheck defines if a complete check (including materials and lights) has to be done (false by default)
          * @return true if the node is ready
          */
-        Node.prototype.isReady = function () {
+        Node.prototype.isReady = function (completeCheck) {
+            if (completeCheck === void 0) { completeCheck = false; }
             return this._isReady;
         };
         /**
@@ -22484,7 +22486,7 @@ var BABYLON;
                 if (!mesh.subMeshes || mesh.subMeshes.length === 0) {
                     continue;
                 }
-                if (!mesh.isReady()) {
+                if (!mesh.isReady(true)) {
                     return false;
                 }
                 // Effect layers
@@ -25979,24 +25981,15 @@ var BABYLON;
             this.level = 1;
             this.coordinatesIndex = 0;
             this._coordinatesMode = BABYLON.Texture.EXPLICIT_MODE;
-            /*
-            * How a texture is mapped.
-            *
-            * | Value | Type                                | Description |
-            * | ----- | ----------------------------------- | ----------- |
-            * | 0     | EXPLICIT_MODE                       |             |
-            * | 1     | SPHERICAL_MODE                      |             |
-            * | 2     | PLANAR_MODE                         |             |
-            * | 3     | CUBIC_MODE                          |             |
-            * | 4     | PROJECTION_MODE                     |             |
-            * | 5     | SKYBOX_MODE                         |             |
-            * | 6     | INVCUBIC_MODE                       |             |
-            * | 7     | EQUIRECTANGULAR_MODE                |             |
-            * | 8     | FIXED_EQUIRECTANGULAR_MODE          |             |
-            * | 9     | FIXED_EQUIRECTANGULAR_MIRRORED_MODE |             |
+            /**
+            * | Value | Type               | Description |
+            * | ----- | ------------------ | ----------- |
+            * | 0     | CLAMP_ADDRESSMODE  |             |
+            * | 1     | WRAP_ADDRESSMODE   |             |
+            * | 2     | MIRROR_ADDRESSMODE |             |
             */
             this.wrapU = BABYLON.Texture.WRAP_ADDRESSMODE;
-            /*
+            /**
             * | Value | Type               | Description |
             * | ----- | ------------------ | ----------- |
             * | 0     | CLAMP_ADDRESSMODE  |             |
@@ -26004,6 +25997,13 @@ var BABYLON;
             * | 2     | MIRROR_ADDRESSMODE |             |
             */
             this.wrapV = BABYLON.Texture.WRAP_ADDRESSMODE;
+            /**
+            * | Value | Type               | Description |
+            * | ----- | ------------------ | ----------- |
+            * | 0     | CLAMP_ADDRESSMODE  |             |
+            * | 1     | WRAP_ADDRESSMODE   |             |
+            * | 2     | MIRROR_ADDRESSMODE |             |
+            */
             this.wrapR = BABYLON.Texture.WRAP_ADDRESSMODE;
             this.anisotropicFilteringLevel = BaseTexture.DEFAULT_ANISOTROPIC_FILTERING_LEVEL;
             this.isCube = false;
@@ -26047,6 +26047,22 @@ var BABYLON;
             get: function () {
                 return this._coordinatesMode;
             },
+            /**
+            * How a texture is mapped.
+            *
+            * | Value | Type                                | Description |
+            * | ----- | ----------------------------------- | ----------- |
+            * | 0     | EXPLICIT_MODE                       |             |
+            * | 1     | SPHERICAL_MODE                      |             |
+            * | 2     | PLANAR_MODE                         |             |
+            * | 3     | CUBIC_MODE                          |             |
+            * | 4     | PROJECTION_MODE                     |             |
+            * | 5     | SKYBOX_MODE                         |             |
+            * | 6     | INVCUBIC_MODE                       |             |
+            * | 7     | EQUIRECTANGULAR_MODE                |             |
+            * | 8     | FIXED_EQUIRECTANGULAR_MODE          |             |
+            * | 9     | FIXED_EQUIRECTANGULAR_MIRRORED_MODE |             |
+            */
             set: function (value) {
                 if (this._coordinatesMode === value) {
                     return;
@@ -27411,20 +27427,25 @@ var BABYLON;
         });
         /**
          * Determine if the current mesh is ready to be rendered
+         * @param completeCheck defines if a complete check (including materials and lights) has to be done (false by default)
          * @param forceInstanceSupport will check if the mesh will be ready when used with instances (false by default)
          * @returns true if all associated assets are ready (material, textures, shaders)
          */
-        Mesh.prototype.isReady = function (forceInstanceSupport) {
+        Mesh.prototype.isReady = function (completeCheck, forceInstanceSupport) {
+            if (completeCheck === void 0) { completeCheck = false; }
             if (forceInstanceSupport === void 0) { forceInstanceSupport = false; }
             if (this.delayLoadState === BABYLON.Engine.DELAYLOADSTATE_LOADING) {
                 return false;
             }
-            if (!_super.prototype.isReady.call(this)) {
+            if (!_super.prototype.isReady.call(this, completeCheck)) {
                 return false;
             }
             if (!this.subMeshes || this.subMeshes.length === 0) {
                 return true;
             }
+            if (!completeCheck) {
+                return true;
+            }
             var engine = this.getEngine();
             var scene = this.getScene();
             var hardwareInstancedRendering = forceInstanceSupport || engine.getCaps().instancedArrays && this.instances.length > 0;
@@ -54148,10 +54169,12 @@ var BABYLON;
         });
         /**
          * Is this node ready to be used/rendered
+         * @param completeCheck defines if a complete check (including materials and lights) has to be done (false by default)
          * @return {boolean} is it ready
          */
-        InstancedMesh.prototype.isReady = function () {
-            return this._sourceMesh.isReady(true);
+        InstancedMesh.prototype.isReady = function (completeCheck) {
+            if (completeCheck === void 0) { completeCheck = false; }
+            return this._sourceMesh.isReady(completeCheck, true);
         };
         /**
          * Returns a float array or a Float32Array of the requested kind of data : positons, normals, uvs, etc.

dist/preview release/customConfigurations/minimalGLTFViewer/babylon.max.js

@@ -15262,9 +15262,11 @@ var BABYLON;
         };
         /**
          * Is this node ready to be used/rendered
+         * @param completeCheck defines if a complete check (including materials and lights) has to be done (false by default)
          * @return true if the node is ready
          */
-        Node.prototype.isReady = function () {
+        Node.prototype.isReady = function (completeCheck) {
+            if (completeCheck === void 0) { completeCheck = false; }
             return this._isReady;
         };
         /**
@@ -22443,7 +22445,7 @@ var BABYLON;
                 if (!mesh.subMeshes || mesh.subMeshes.length === 0) {
                     continue;
                 }
-                if (!mesh.isReady()) {
+                if (!mesh.isReady(true)) {
                     return false;
                 }
                 // Effect layers
@@ -25924,24 +25926,15 @@ var BABYLON;
             this.level = 1;
             this.coordinatesIndex = 0;
             this._coordinatesMode = BABYLON.Texture.EXPLICIT_MODE;
-            /*
-            * How a texture is mapped.
-            *
-            * | Value | Type                                | Description |
-            * | ----- | ----------------------------------- | ----------- |
-            * | 0     | EXPLICIT_MODE                       |             |
-            * | 1     | SPHERICAL_MODE                      |             |
-            * | 2     | PLANAR_MODE                         |             |
-            * | 3     | CUBIC_MODE                          |             |
-            * | 4     | PROJECTION_MODE                     |             |
-            * | 5     | SKYBOX_MODE                         |             |
-            * | 6     | INVCUBIC_MODE                       |             |
-            * | 7     | EQUIRECTANGULAR_MODE                |             |
-            * | 8     | FIXED_EQUIRECTANGULAR_MODE          |             |
-            * | 9     | FIXED_EQUIRECTANGULAR_MIRRORED_MODE |             |
+            /**
+            * | Value | Type               | Description |
+            * | ----- | ------------------ | ----------- |
+            * | 0     | CLAMP_ADDRESSMODE  |             |
+            * | 1     | WRAP_ADDRESSMODE   |             |
+            * | 2     | MIRROR_ADDRESSMODE |             |
             */
             this.wrapU = BABYLON.Texture.WRAP_ADDRESSMODE;
-            /*
+            /**
             * | Value | Type               | Description |
             * | ----- | ------------------ | ----------- |
             * | 0     | CLAMP_ADDRESSMODE  |             |
@@ -25949,6 +25942,13 @@ var BABYLON;
             * | 2     | MIRROR_ADDRESSMODE |             |
             */
             this.wrapV = BABYLON.Texture.WRAP_ADDRESSMODE;
+            /**
+            * | Value | Type               | Description |
+            * | ----- | ------------------ | ----------- |
+            * | 0     | CLAMP_ADDRESSMODE  |             |
+            * | 1     | WRAP_ADDRESSMODE   |             |
+            * | 2     | MIRROR_ADDRESSMODE |             |
+            */
             this.wrapR = BABYLON.Texture.WRAP_ADDRESSMODE;
             this.anisotropicFilteringLevel = BaseTexture.DEFAULT_ANISOTROPIC_FILTERING_LEVEL;
             this.isCube = false;
@@ -25992,6 +25992,22 @@ var BABYLON;
             get: function () {
                 return this._coordinatesMode;
             },
+            /**
+            * How a texture is mapped.
+            *
+            * | Value | Type                                | Description |
+            * | ----- | ----------------------------------- | ----------- |
+            * | 0     | EXPLICIT_MODE                       |             |
+            * | 1     | SPHERICAL_MODE                      |             |
+            * | 2     | PLANAR_MODE                         |             |
+            * | 3     | CUBIC_MODE                          |             |
+            * | 4     | PROJECTION_MODE                     |             |
+            * | 5     | SKYBOX_MODE                         |             |
+            * | 6     | INVCUBIC_MODE                       |             |
+            * | 7     | EQUIRECTANGULAR_MODE                |             |
+            * | 8     | FIXED_EQUIRECTANGULAR_MODE          |             |
+            * | 9     | FIXED_EQUIRECTANGULAR_MIRRORED_MODE |             |
+            */
             set: function (value) {
                 if (this._coordinatesMode === value) {
                     return;
@@ -27356,20 +27372,25 @@ var BABYLON;
         });
         /**
          * Determine if the current mesh is ready to be rendered
+         * @param completeCheck defines if a complete check (including materials and lights) has to be done (false by default)
          * @param forceInstanceSupport will check if the mesh will be ready when used with instances (false by default)
          * @returns true if all associated assets are ready (material, textures, shaders)
          */
-        Mesh.prototype.isReady = function (forceInstanceSupport) {
+        Mesh.prototype.isReady = function (completeCheck, forceInstanceSupport) {
+            if (completeCheck === void 0) { completeCheck = false; }
             if (forceInstanceSupport === void 0) { forceInstanceSupport = false; }
             if (this.delayLoadState === BABYLON.Engine.DELAYLOADSTATE_LOADING) {
                 return false;
             }
-            if (!_super.prototype.isReady.call(this)) {
+            if (!_super.prototype.isReady.call(this, completeCheck)) {
                 return false;
             }
             if (!this.subMeshes || this.subMeshes.length === 0) {
                 return true;
             }
+            if (!completeCheck) {
+                return true;
+            }
             var engine = this.getEngine();
             var scene = this.getScene();
             var hardwareInstancedRendering = forceInstanceSupport || engine.getCaps().instancedArrays && this.instances.length > 0;
@@ -53803,10 +53824,12 @@ var BABYLON;
         });
         /**
          * Is this node ready to be used/rendered
+         * @param completeCheck defines if a complete check (including materials and lights) has to be done (false by default)
          * @return {boolean} is it ready
          */
-        InstancedMesh.prototype.isReady = function () {
-            return this._sourceMesh.isReady(true);
+        InstancedMesh.prototype.isReady = function (completeCheck) {
+            if (completeCheck === void 0) { completeCheck = false; }
+            return this._sourceMesh.isReady(completeCheck, true);
         };
         /**
          * Returns a float array or a Float32Array of the requested kind of data : positons, normals, uvs, etc.
@@ -91784,6 +91807,12 @@ var BABYLON;
                         if (node._babylonMesh) {
                             meshes.push(node._babylonMesh);
                         }
+                        if (node._primitiveBabylonMeshes) {
+                            for (var _a = 0, _b = node._primitiveBabylonMeshes; _a < _b.length; _a++) {
+                                var babylonMesh = _b[_a];
+                                meshes.push(babylonMesh);
+                            }
+                        }
                     }
                 }
                 return meshes;

dist/preview release/customConfigurations/minimalGLTFViewer/es6.js

@@ -15248,9 +15248,11 @@ var BABYLON;
         };
         /**
          * Is this node ready to be used/rendered
+         * @param completeCheck defines if a complete check (including materials and lights) has to be done (false by default)
          * @return true if the node is ready
          */
-        Node.prototype.isReady = function () {
+        Node.prototype.isReady = function (completeCheck) {
+            if (completeCheck === void 0) { completeCheck = false; }
             return this._isReady;
         };
         /**
@@ -22429,7 +22431,7 @@ var BABYLON;
                 if (!mesh.subMeshes || mesh.subMeshes.length === 0) {
                     continue;
                 }
-                if (!mesh.isReady()) {
+                if (!mesh.isReady(true)) {
                     return false;
                 }
                 // Effect layers
@@ -25910,24 +25912,15 @@ var BABYLON;
             this.level = 1;
             this.coordinatesIndex = 0;
             this._coordinatesMode = BABYLON.Texture.EXPLICIT_MODE;
-            /*
-            * How a texture is mapped.
-            *
-            * | Value | Type                                | Description |
-            * | ----- | ----------------------------------- | ----------- |
-            * | 0     | EXPLICIT_MODE                       |             |
-            * | 1     | SPHERICAL_MODE                      |             |
-            * | 2     | PLANAR_MODE                         |             |
-            * | 3     | CUBIC_MODE                          |             |
-            * | 4     | PROJECTION_MODE                     |             |
-            * | 5     | SKYBOX_MODE                         |             |
-            * | 6     | INVCUBIC_MODE                       |             |
-            * | 7     | EQUIRECTANGULAR_MODE                |             |
-            * | 8     | FIXED_EQUIRECTANGULAR_MODE          |             |
-            * | 9     | FIXED_EQUIRECTANGULAR_MIRRORED_MODE |             |
+            /**
+            * | Value | Type               | Description |
+            * | ----- | ------------------ | ----------- |
+            * | 0     | CLAMP_ADDRESSMODE  |             |
+            * | 1     | WRAP_ADDRESSMODE   |             |
+            * | 2     | MIRROR_ADDRESSMODE |             |
             */
             this.wrapU = BABYLON.Texture.WRAP_ADDRESSMODE;
-            /*
+            /**
             * | Value | Type               | Description |
             * | ----- | ------------------ | ----------- |
             * | 0     | CLAMP_ADDRESSMODE  |             |
@@ -25935,6 +25928,13 @@ var BABYLON;
             * | 2     | MIRROR_ADDRESSMODE |             |
             */
             this.wrapV = BABYLON.Texture.WRAP_ADDRESSMODE;
+            /**
+            * | Value | Type               | Description |
+            * | ----- | ------------------ | ----------- |
+            * | 0     | CLAMP_ADDRESSMODE  |             |
+            * | 1     | WRAP_ADDRESSMODE   |             |
+            * | 2     | MIRROR_ADDRESSMODE |             |
+            */
             this.wrapR = BABYLON.Texture.WRAP_ADDRESSMODE;
             this.anisotropicFilteringLevel = BaseTexture.DEFAULT_ANISOTROPIC_FILTERING_LEVEL;
             this.isCube = false;
@@ -25978,6 +25978,22 @@ var BABYLON;
             get: function () {
                 return this._coordinatesMode;
             },
+            /**
+            * How a texture is mapped.
+            *
+            * | Value | Type                                | Description |
+            * | ----- | ----------------------------------- | ----------- |
+            * | 0     | EXPLICIT_MODE                       |             |
+            * | 1     | SPHERICAL_MODE                      |             |
+            * | 2     | PLANAR_MODE                         |             |
+            * | 3     | CUBIC_MODE                          |             |
+            * | 4     | PROJECTION_MODE                     |             |
+            * | 5     | SKYBOX_MODE                         |             |
+            * | 6     | INVCUBIC_MODE                       |             |
+            * | 7     | EQUIRECTANGULAR_MODE                |             |
+            * | 8     | FIXED_EQUIRECTANGULAR_MODE          |             |
+            * | 9     | FIXED_EQUIRECTANGULAR_MIRRORED_MODE |             |
+            */
             set: function (value) {
                 if (this._coordinatesMode === value) {
                     return;
@@ -27342,20 +27358,25 @@ var BABYLON;
         });
         /**
          * Determine if the current mesh is ready to be rendered
+         * @param completeCheck defines if a complete check (including materials and lights) has to be done (false by default)
          * @param forceInstanceSupport will check if the mesh will be ready when used with instances (false by default)
          * @returns true if all associated assets are ready (material, textures, shaders)
          */
-        Mesh.prototype.isReady = function (forceInstanceSupport) {
+        Mesh.prototype.isReady = function (completeCheck, forceInstanceSupport) {
+            if (completeCheck === void 0) { completeCheck = false; }
             if (forceInstanceSupport === void 0) { forceInstanceSupport = false; }
             if (this.delayLoadState === BABYLON.Engine.DELAYLOADSTATE_LOADING) {
                 return false;
             }
-            if (!_super.prototype.isReady.call(this)) {
+            if (!_super.prototype.isReady.call(this, completeCheck)) {
                 return false;
             }
             if (!this.subMeshes || this.subMeshes.length === 0) {
                 return true;
             }
+            if (!completeCheck) {
+                return true;
+            }
             var engine = this.getEngine();
             var scene = this.getScene();
             var hardwareInstancedRendering = forceInstanceSupport || engine.getCaps().instancedArrays && this.instances.length > 0;
@@ -53789,10 +53810,12 @@ var BABYLON;
         });
         /**
          * Is this node ready to be used/rendered
+         * @param completeCheck defines if a complete check (including materials and lights) has to be done (false by default)
          * @return {boolean} is it ready
          */
-        InstancedMesh.prototype.isReady = function () {
-            return this._sourceMesh.isReady(true);
+        InstancedMesh.prototype.isReady = function (completeCheck) {
+            if (completeCheck === void 0) { completeCheck = false; }
+            return this._sourceMesh.isReady(completeCheck, true);
         };
         /**
          * Returns a float array or a Float32Array of the requested kind of data : positons, normals, uvs, etc.
@@ -91770,6 +91793,12 @@ var BABYLON;
                         if (node._babylonMesh) {
                             meshes.push(node._babylonMesh);
                         }
+                        if (node._primitiveBabylonMeshes) {
+                            for (var _a = 0, _b = node._primitiveBabylonMeshes; _a < _b.length; _a++) {
+                                var babylonMesh = _b[_a];
+                                meshes.push(babylonMesh);
+                            }
+                        }
                     }
                 }
                 return meshes;

dist/preview release/es6.js

@@ -15289,9 +15289,11 @@ var BABYLON;
         };
         /**
          * Is this node ready to be used/rendered
+         * @param completeCheck defines if a complete check (including materials and lights) has to be done (false by default)
          * @return true if the node is ready
          */
-        Node.prototype.isReady = function () {
+        Node.prototype.isReady = function (completeCheck) {
+            if (completeCheck === void 0) { completeCheck = false; }
             return this._isReady;
         };
         /**
@@ -22470,7 +22472,7 @@ var BABYLON;
                 if (!mesh.subMeshes || mesh.subMeshes.length === 0) {
                     continue;
                 }
-                if (!mesh.isReady()) {
+                if (!mesh.isReady(true)) {
                     return false;
                 }
                 // Effect layers
@@ -25965,24 +25967,15 @@ var BABYLON;
             this.level = 1;
             this.coordinatesIndex = 0;
             this._coordinatesMode = BABYLON.Texture.EXPLICIT_MODE;
-            /*
-            * How a texture is mapped.
-            *
-            * | Value | Type                                | Description |
-            * | ----- | ----------------------------------- | ----------- |
-            * | 0     | EXPLICIT_MODE                       |             |
-            * | 1     | SPHERICAL_MODE                      |             |
-            * | 2     | PLANAR_MODE                         |             |
-            * | 3     | CUBIC_MODE                          |             |
-            * | 4     | PROJECTION_MODE                     |             |
-            * | 5     | SKYBOX_MODE                         |             |
-            * | 6     | INVCUBIC_MODE                       |             |
-            * | 7     | EQUIRECTANGULAR_MODE                |             |
-            * | 8     | FIXED_EQUIRECTANGULAR_MODE          |             |
-            * | 9     | FIXED_EQUIRECTANGULAR_MIRRORED_MODE |             |
+            /**
+            * | Value | Type               | Description |
+            * | ----- | ------------------ | ----------- |
+            * | 0     | CLAMP_ADDRESSMODE  |             |
+            * | 1     | WRAP_ADDRESSMODE   |             |
+            * | 2     | MIRROR_ADDRESSMODE |             |
             */
             this.wrapU = BABYLON.Texture.WRAP_ADDRESSMODE;
-            /*
+            /**
             * | Value | Type               | Description |
             * | ----- | ------------------ | ----------- |
             * | 0     | CLAMP_ADDRESSMODE  |             |
@@ -25990,6 +25983,13 @@ var BABYLON;
             * | 2     | MIRROR_ADDRESSMODE |             |
             */
             this.wrapV = BABYLON.Texture.WRAP_ADDRESSMODE;
+            /**
+            * | Value | Type               | Description |
+            * | ----- | ------------------ | ----------- |
+            * | 0     | CLAMP_ADDRESSMODE  |             |
+            * | 1     | WRAP_ADDRESSMODE   |             |
+            * | 2     | MIRROR_ADDRESSMODE |             |
+            */
             this.wrapR = BABYLON.Texture.WRAP_ADDRESSMODE;
             this.anisotropicFilteringLevel = BaseTexture.DEFAULT_ANISOTROPIC_FILTERING_LEVEL;
             this.isCube = false;
@@ -26033,6 +26033,22 @@ var BABYLON;
             get: function () {
                 return this._coordinatesMode;
             },
+            /**
+            * How a texture is mapped.
+            *
+            * | Value | Type                                | Description |
+            * | ----- | ----------------------------------- | ----------- |
+            * | 0     | EXPLICIT_MODE                       |             |
+            * | 1     | SPHERICAL_MODE                      |             |
+            * | 2     | PLANAR_MODE                         |             |
+            * | 3     | CUBIC_MODE                          |             |
+            * | 4     | PROJECTION_MODE                     |             |
+            * | 5     | SKYBOX_MODE                         |             |
+            * | 6     | INVCUBIC_MODE                       |             |
+            * | 7     | EQUIRECTANGULAR_MODE                |             |
+            * | 8     | FIXED_EQUIRECTANGULAR_MODE          |             |
+            * | 9     | FIXED_EQUIRECTANGULAR_MIRRORED_MODE |             |
+            */
             set: function (value) {
                 if (this._coordinatesMode === value) {
                     return;
@@ -27397,20 +27413,25 @@ var BABYLON;
         });
         /**
          * Determine if the current mesh is ready to be rendered
+         * @param completeCheck defines if a complete check (including materials and lights) has to be done (false by default)
          * @param forceInstanceSupport will check if the mesh will be ready when used with instances (false by default)
          * @returns true if all associated assets are ready (material, textures, shaders)
          */
-        Mesh.prototype.isReady = function (forceInstanceSupport) {
+        Mesh.prototype.isReady = function (completeCheck, forceInstanceSupport) {
+            if (completeCheck === void 0) { completeCheck = false; }
             if (forceInstanceSupport === void 0) { forceInstanceSupport = false; }
             if (this.delayLoadState === BABYLON.Engine.DELAYLOADSTATE_LOADING) {
                 return false;
             }
-            if (!_super.prototype.isReady.call(this)) {
+            if (!_super.prototype.isReady.call(this, completeCheck)) {
                 return false;
             }
             if (!this.subMeshes || this.subMeshes.length === 0) {
                 return true;
             }
+            if (!completeCheck) {
+                return true;
+            }
             var engine = this.getEngine();
             var scene = this.getScene();
             var hardwareInstancedRendering = forceInstanceSupport || engine.getCaps().instancedArrays && this.instances.length > 0;
@@ -54134,10 +54155,12 @@ var BABYLON;
         });
         /**
          * Is this node ready to be used/rendered
+         * @param completeCheck defines if a complete check (including materials and lights) has to be done (false by default)
          * @return {boolean} is it ready
          */
-        InstancedMesh.prototype.isReady = function () {
-            return this._sourceMesh.isReady(true);
+        InstancedMesh.prototype.isReady = function (completeCheck) {
+            if (completeCheck === void 0) { completeCheck = false; }
+            return this._sourceMesh.isReady(completeCheck, true);
         };
         /**
          * Returns a float array or a Float32Array of the requested kind of data : positons, normals, uvs, etc.

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

@@ -724,6 +724,12 @@ var BABYLON;
                         if (node._babylonMesh) {
                             meshes.push(node._babylonMesh);
                         }
+                        if (node._primitiveBabylonMeshes) {
+                            for (var _a = 0, _b = node._primitiveBabylonMeshes; _a < _b.length; _a++) {
+                                var babylonMesh = _b[_a];
+                                meshes.push(babylonMesh);
+                            }
+                        }
                     }
                 }
                 return meshes;

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

@@ -2900,6 +2900,12 @@ var BABYLON;
                         if (node._babylonMesh) {
                             meshes.push(node._babylonMesh);
                         }
+                        if (node._primitiveBabylonMeshes) {
+                            for (var _a = 0, _b = node._primitiveBabylonMeshes; _a < _b.length; _a++) {
+                                var babylonMesh = _b[_a];
+                                meshes.push(babylonMesh);
+                            }
+                        }
                     }
                 }
                 return meshes;

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

@@ -3868,6 +3868,12 @@ var BABYLON;
                         if (node._babylonMesh) {
                             meshes.push(node._babylonMesh);
                         }
+                        if (node._primitiveBabylonMeshes) {
+                            for (var _a = 0, _b = node._primitiveBabylonMeshes; _a < _b.length; _a++) {
+                                var babylonMesh = _b[_a];
+                                meshes.push(babylonMesh);
+                            }
+                        }
                     }
                 }
                 return meshes;

dist/preview release/typedocValidationBaseline.json

@@ -1,7 +1,7 @@
 {
-  "errors": 7267,
+  "errors": 7263,
   "babylon.typedoc.json": {
-    "errors": 7267,
+    "errors": 7263,
     "AnimationKeyInterpolation": {
       "Enumeration": {
         "Comments": {
@@ -4381,11 +4381,6 @@
             "MissingText": true
           }
         },
-        "coordinatesMode": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
         "delayLoadState": {
           "Comments": {
             "MissingText": true
@@ -4481,21 +4476,6 @@
             "MissingText": true
           }
         },
-        "wrapR": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "wrapU": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "wrapV": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
         "DEFAULT_ANISOTROPIC_FILTERING_LEVEL": {
           "Comments": {
             "MissingText": true

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

@@ -298,6 +298,12 @@ module BABYLON.GLTF2 {
                     if (node._babylonMesh) {
                         meshes.push(node._babylonMesh);
                     }
+
+                    if (node._primitiveBabylonMeshes) {
+                        for (const babylonMesh of node._primitiveBabylonMeshes) {
+                            meshes.push(babylonMesh);
+                        }
+                    }
                 }
             }
 

src/Materials/Textures/babylon.baseTexture.ts

@@ -28,23 +28,11 @@
 
         @serialize()
         public coordinatesIndex = 0;
-
+        
         @serialize("coordinatesMode")
         private _coordinatesMode = Texture.EXPLICIT_MODE;
-        public set coordinatesMode(value: number) {
-            if (this._coordinatesMode === value) {
-                return;
-            }
-            this._coordinatesMode = value;
-            if (this._scene) {
-                this._scene.markAllMaterialsAsDirty(Material.TextureDirtyFlag);
-            }
-        }
-        public get coordinatesMode(): number {
-            return this._coordinatesMode;
-        }
         
-        /*
+        /**
         * How a texture is mapped.
         *
         * | Value | Type                                | Description |
@@ -60,21 +48,46 @@
         * | 8     | FIXED_EQUIRECTANGULAR_MODE          |             |
         * | 9     | FIXED_EQUIRECTANGULAR_MIRRORED_MODE |             |
         */
-
+        public set coordinatesMode(value: number) {
+            if (this._coordinatesMode === value) {
+                return;
+            }
+            this._coordinatesMode = value;
+            if (this._scene) {
+                this._scene.markAllMaterialsAsDirty(Material.TextureDirtyFlag);
+            }
+        }
+        public get coordinatesMode(): number {
+            return this._coordinatesMode;
+        } 
+        
+        /**
+        * | Value | Type               | Description |
+        * | ----- | ------------------ | ----------- |
+        * | 0     | CLAMP_ADDRESSMODE  |             |
+        * | 1     | WRAP_ADDRESSMODE   |             |
+        * | 2     | MIRROR_ADDRESSMODE |             |
+        */
         @serialize()
         public wrapU = Texture.WRAP_ADDRESSMODE;
         
-        /* 
+        /**
         * | Value | Type               | Description |
         * | ----- | ------------------ | ----------- |
         * | 0     | CLAMP_ADDRESSMODE  |             |
         * | 1     | WRAP_ADDRESSMODE   |             |
         * | 2     | MIRROR_ADDRESSMODE |             |
         */
-
         @serialize()
         public wrapV = Texture.WRAP_ADDRESSMODE;
-
+        
+        /**
+        * | Value | Type               | Description |
+        * | ----- | ------------------ | ----------- |
+        * | 0     | CLAMP_ADDRESSMODE  |             |
+        * | 1     | WRAP_ADDRESSMODE   |             |
+        * | 2     | MIRROR_ADDRESSMODE |             |
+        */
         @serialize()
         public wrapR = Texture.WRAP_ADDRESSMODE;
 

src/Mesh/babylon.instancedMesh.ts

@@ -71,10 +71,11 @@
 
         /**
          * Is this node ready to be used/rendered
+         * @param completeCheck defines if a complete check (including materials and lights) has to be done (false by default)
          * @return {boolean} is it ready
          */
-        public isReady(): boolean {
-            return this._sourceMesh.isReady(true);
+        public isReady(completeCheck = false): boolean {
+            return this._sourceMesh.isReady(completeCheck, true);
         }
 
         /**

src/Mesh/babylon.mesh.ts

@@ -607,15 +607,16 @@
 
         /**
          * Determine if the current mesh is ready to be rendered
+         * @param completeCheck defines if a complete check (including materials and lights) has to be done (false by default)
          * @param forceInstanceSupport will check if the mesh will be ready when used with instances (false by default)
          * @returns true if all associated assets are ready (material, textures, shaders)
          */
-        public isReady(forceInstanceSupport = false): boolean {
+        public isReady(completeCheck = false, forceInstanceSupport = false): boolean {
             if (this.delayLoadState === Engine.DELAYLOADSTATE_LOADING) {
                 return false;
             }
 
-            if (!super.isReady()) {
+            if (!super.isReady(completeCheck)) {
                 return false;
             }
 
@@ -623,6 +624,10 @@
                 return true;
             }
 
+            if (!completeCheck) {
+                return true;
+            }
+
             let engine = this.getEngine();
             let scene = this.getScene();
             let hardwareInstancedRendering = forceInstanceSupport || engine.getCaps().instancedArrays && this.instances.length > 0;

src/babylon.node.ts

@@ -325,9 +325,10 @@
 
         /**
          * Is this node ready to be used/rendered
+         * @param completeCheck defines if a complete check (including materials and lights) has to be done (false by default)
          * @return true if the node is ready
          */
-        public isReady(): boolean {
+        public isReady(completeCheck = false): boolean {
             return this._isReady;
         }
 

src/babylon.scene.ts

@@ -1913,7 +1913,7 @@
                     continue;
                 }
 
-                if (!mesh.isReady()) {
+                if (!mesh.isReady(true)) {
                     return false;
                 }
 
@@ -4232,11 +4232,12 @@
             for (var index = 0; index < this.meshes.length; index++) {
                 var mesh = this.meshes[index];
 
+                mesh.computeWorldMatrix(true);
+
                 if (!mesh.subMeshes || mesh.subMeshes.length === 0 || mesh.infiniteDistance) {
                     continue;
                 }
 
-                mesh.computeWorldMatrix(true);
                 let boundingInfo = mesh.getBoundingInfo();
 
                 var minBox = boundingInfo.boundingBox.minimumWorld;

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

@@ -53,6 +53,15 @@ describe('Babylon Scene Loader', function () {
             });
         });
 
+        it('Load BoomBox with ImportMesh', () => {
+            const scene = new BABYLON.Scene(subject);
+            return BABYLON.SceneLoader.ImportMeshAsync(null, "/Playground/scenes/BoomBox/", "BoomBox.gltf", scene).then(result => {
+                expect(result.meshes.length, "meshes.length").to.equal(scene.meshes.length);
+                expect(result.particleSystems.length, "particleSystems.length").to.equal(0);
+                expect(result.skeletons.length, "skeletons.length").to.equal(0);
+            });
+        });
+
         it('Load BoomBox with callbacks', () => {
             let parsedCount = 0;
             let meshCount = 0;
@@ -183,7 +192,7 @@ describe('Babylon Scene Loader', function () {
         it('should be loaded from BoomBox GLTF', () => {
             var scene = new BABYLON.Scene(subject);
             return BABYLON.SceneLoader.LoadAssetContainerAsync("/Playground/scenes/BoomBox/", "BoomBox.gltf", scene).then(container => {
-                expect(container.meshes.length).to.eq(2);
+                expect(container.meshes.length).to.eq(3);
             });
         });
         it('should be adding and removing objects from scene', () => {