Fix #3698

dist/preview release/babylon.max.js

@@ -14972,23 +14972,38 @@ var BABYLON;
      */
     var Node = /** @class */ (function () {
         /**
-         * @constructor
+         * Creates a new Node
          * @param {string} name - the name and id to be given to this node
          * @param {BABYLON.Scene} the scene this node will be added to
          */
         function Node(name, scene) {
             if (scene === void 0) { scene = null; }
+            /**
+             * Gets or sets a string used to store user defined state for the node
+             */
             this.state = "";
+            /**
+             * Gets or sets an object used to store user defined information for the node
+             */
             this.metadata = null;
+            /**
+             * Gets or sets a boolean used to define if the node must be serialized
+             */
             this.doNotSerialize = false;
+            /** @ignore */
+            this._isDisposed = false;
+            /**
+             * Gets a list of {BABYLON.Animation} associated with the node
+             */
             this.animations = new Array();
             this._ranges = {};
             this._isEnabled = true;
             this._isReady = true;
+            /** @ignore */
             this._currentRenderId = -1;
             this._parentRenderId = -1;
             /**
-            * An event triggered when the mesh is disposed.
+            * An event triggered when the mesh is disposed
             * @type {BABYLON.Observable}
             */
             this.onDisposeObservable = new BABYLON.Observable();
@@ -15000,10 +15015,20 @@ var BABYLON;
             this.uniqueId = this._scene.getUniqueId();
             this._initCache();
         }
+        /**
+         * Gets a boolean indicating if the node has been disposed
+         * @returns true if the node was disposed
+         */
+        Node.prototype.isDisposed = function () {
+            return this._isDisposed;
+        };
         Object.defineProperty(Node.prototype, "parent", {
             get: function () {
                 return this._parentNode;
             },
+            /**
+             * Gets or sets the parent of the node
+             */
             set: function (parent) {
                 if (this._parentNode === parent) {
                     return;
@@ -15028,10 +15053,17 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
+        /**
+         * Gets a string idenfifying the name of the class
+         * @returns "Node" string
+         */
         Node.prototype.getClassName = function () {
             return "Node";
         };
         Object.defineProperty(Node.prototype, "onDispose", {
+            /**
+             * Sets a callback that will be raised when the node will be disposed
+             */
             set: function (callback) {
                 if (this._onDisposeObserver) {
                     this.onDisposeObservable.remove(this._onDisposeObserver);
@@ -15041,12 +15073,26 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
+        /**
+         * Gets the scene of the node
+         * @returns a {BABYLON.Scene}
+         */
         Node.prototype.getScene = function () {
             return this._scene;
         };
+        /**
+         * Gets the engine of the node
+         * @returns a {BABYLON.Engine}
+         */
         Node.prototype.getEngine = function () {
             return this._scene.getEngine();
         };
+        /**
+         * Attach a behavior to the node
+         * @see http://doc.babylonjs.com/features/behaviour
+         * @param behavior defines the behavior to attach
+         * @returns the current Node
+         */
         Node.prototype.addBehavior = function (behavior) {
             var _this = this;
             var index = this._behaviors.indexOf(behavior);
@@ -15070,6 +15116,12 @@ var BABYLON;
             this._behaviors.push(behavior);
             return this;
         };
+        /**
+         * Remove an attached behavior
+         * @see http://doc.babylonjs.com/features/behaviour
+         * @param behavior defines the behavior to attach
+         * @returns the current Node
+         */
         Node.prototype.removeBehavior = function (behavior) {
             var index = this._behaviors.indexOf(behavior);
             if (index === -1) {
@@ -15080,12 +15132,22 @@ var BABYLON;
             return this;
         };
         Object.defineProperty(Node.prototype, "behaviors", {
+            /**
+             * Gets the list of attached behaviors
+             * @see http://doc.babylonjs.com/features/behaviour
+             */
             get: function () {
                 return this._behaviors;
             },
             enumerable: true,
             configurable: true
         });
+        /**
+         * Gets an attached behavior by name
+         * @param name defines the name of the behavior to look for
+         * @see http://doc.babylonjs.com/features/behaviour
+         * @returns null if behavior was not found else the requested behavior
+         */
         Node.prototype.getBehaviorByName = function (name) {
             for (var _i = 0, _a = this._behaviors; _i < _a.length; _i++) {
                 var behavior = _a[_i];
@@ -15095,16 +15157,21 @@ var BABYLON;
             }
             return null;
         };
-        // override it in derived class
+        /**
+         * Returns the world matrix of the node
+         * @returns a matrix containing the node's world matrix
+         */
         Node.prototype.getWorldMatrix = function () {
             return BABYLON.Matrix.Identity();
         };
         // override it in derived class if you add new variables to the cache
         // and call the parent class method
+        /** @ignore */
         Node.prototype._initCache = function () {
             this._cache = {};
             this._cache.parent = undefined;
         };
+        /** @ignore */
         Node.prototype.updateCache = function (force) {
             if (!force && this.isSynchronized())
                 return;
@@ -15113,17 +15180,21 @@ var BABYLON;
         };
         // override it in derived class if you add new variables to the cache
         // and call the parent class method if !ignoreParentClass
+        /** @ignore */
         Node.prototype._updateCache = function (ignoreParentClass) {
         };
         // override it in derived class if you add new variables to the cache
+        /** @ignore */
         Node.prototype._isSynchronized = function () {
             return true;
         };
+        /** @ignore */
         Node.prototype._markSyncedWithParent = function () {
             if (this.parent) {
                 this._parentRenderId = this.parent._currentRenderId;
             }
         };
+        /** @ignore */
         Node.prototype.isSynchronizedWithParent = function () {
             if (!this.parent) {
                 return true;
@@ -15133,6 +15204,7 @@ var BABYLON;
             }
             return this.parent.isSynchronized();
         };
+        /** @ignore */
         Node.prototype.isSynchronized = function (updateCache) {
             var check = this.hasNewParent();
             check = check || !this.isSynchronizedWithParent();
@@ -15141,6 +15213,7 @@ var BABYLON;
                 this.updateCache(true);
             return !check;
         };
+        /** @ignore */
         Node.prototype.hasNewParent = function (update) {
             if (this._cache.parent === this.parent)
                 return false;
@@ -15150,16 +15223,16 @@ var BABYLON;
         };
         /**
          * Is this node ready to be used/rendered
-         * @return {boolean} is it ready
+         * @return true if the node is ready
          */
         Node.prototype.isReady = function () {
             return this._isReady;
         };
         /**
-         * Is this node enabled.
-         * If the node has a parent, all ancestors will be checked and false will be returned if any are false (not enabled), otherwise will return true.
-         * @param {boolean} [checkAncestors=true] - Indicates if this method should check the ancestors. The default is to check the ancestors. If set to false, the method will return the value of this node without checking ancestors.
-         * @return {boolean} whether this node (and its parent) is enabled.
+         * Is this node enabled?
+         * If the node has a parent, all ancestors will be checked and false will be returned if any are false (not enabled), otherwise will return true
+         * @param checkAncestors indicates if this method should check the ancestors. The default is to check the ancestors. If set to false, the method will return the value of this node without checking ancestors
+         * @return whether this node (and its parent) is enabled
          * @see setEnabled
          */
         Node.prototype.isEnabled = function (checkAncestors) {
@@ -15176,18 +15249,19 @@ var BABYLON;
             return true;
         };
         /**
-         * Set the enabled state of this node.
-         * @param {boolean} value - the new enabled state
+         * Set the enabled state of this node
+         * @param value defines the new enabled state
          * @see isEnabled
          */
         Node.prototype.setEnabled = function (value) {
             this._isEnabled = value;
         };
         /**
-         * Is this node a descendant of the given node.
-         * The function will iterate up the hierarchy until the ancestor was found or no more parents defined.
-         * @param {BABYLON.Node} ancestor - The parent node to inspect
+         * Is this node a descendant of the given node?
+         * The function will iterate up the hierarchy until the ancestor was found or no more parents defined
+         * @param ancestor defines the parent node to inspect
          * @see parent
+         * @returns a boolean indicating if this node is a descendant of the given node
          */
         Node.prototype.isDescendantOf = function (ancestor) {
             if (this.parent) {
@@ -15198,12 +15272,7 @@ var BABYLON;
             }
             return false;
         };
-        /**
-         * Evaluate the list of children and determine if they should be considered as descendants considering the given criterias
-         * @param {BABYLON.Node[]} results the result array containing the nodes matching the given criterias
-         * @param {boolean} directDescendantsOnly if true only direct descendants of 'this' will be considered, if false direct and also indirect (children of children, an so on in a recursive manner) descendants of 'this' will be considered.
-         * @param predicate: an optional predicate that will be called on every evaluated children, the predicate must return true for a given child to be part of the result, otherwise it will be ignored.
-         */
+        /** @ignore */
         Node.prototype._getDescendants = function (results, directDescendantsOnly, predicate) {
             if (directDescendantsOnly === void 0) { directDescendantsOnly = false; }
             if (!this._children) {
@@ -15220,10 +15289,10 @@ var BABYLON;
             }
         };
         /**
-         * Will return all nodes that have this node as ascendant.
-         * @param {boolean} directDescendantsOnly if true only direct descendants of 'this' will be considered, if false direct and also indirect (children of children, an so on in a recursive manner) descendants of 'this' will be considered.
-         * @param predicate: an optional predicate that will be called on every evaluated children, the predicate must return true for a given child to be part of the result, otherwise it will be ignored.
-         * @return {BABYLON.Node[]} all children nodes of all types.
+         * Will return all nodes that have this node as ascendant
+         * @param directDescendantsOnly defines if true only direct descendants of 'this' will be considered, if false direct and also indirect (children of children, an so on in a recursive manner) descendants of 'this' will be considered
+         * @param predicate defines an optional predicate that will be called on every evaluated child, the predicate must return true for a given child to be part of the result, otherwise it will be ignored
+         * @return all children nodes of all types
          */
         Node.prototype.getDescendants = function (directDescendantsOnly, predicate) {
             var results = new Array();
@@ -15231,7 +15300,10 @@ var BABYLON;
             return results;
         };
         /**
-         * Get all child-meshes of this node.
+         * Get all child-meshes of this node
+         * @param directDescendantsOnly defines if true only direct descendants of 'this' will be considered, if false direct and also indirect (children of children, an so on in a recursive manner) descendants of 'this' will be considered
+         * @param predicate defines an optional predicate that will be called on every evaluated child, the predicate must return true for a given child to be part of the result, otherwise it will be ignored
+         * @returns an array of {BABYLON.AbstractMesh}
          */
         Node.prototype.getChildMeshes = function (directDescendantsOnly, predicate) {
             var results = [];
@@ -15241,7 +15313,10 @@ var BABYLON;
             return results;
         };
         /**
-         * Get all child-transformNodes of this node.
+         * Get all child-transformNodes of this node
+         * @param directDescendantsOnly defines if true only direct descendants of 'this' will be considered, if false direct and also indirect (children of children, an so on in a recursive manner) descendants of 'this' will be considered
+         * @param predicate defines an optional predicate that will be called on every evaluated child, the predicate must return true for a given child to be part of the result, otherwise it will be ignored
+         * @returns an array of {BABYLON.TransformNode}
          */
         Node.prototype.getChildTransformNodes = function (directDescendantsOnly, predicate) {
             var results = [];
@@ -15251,11 +15326,14 @@ var BABYLON;
             return results;
         };
         /**
-         * Get all direct children of this node.
-        */
+         * Get all direct children of this node
+         * @param predicate defines an optional predicate that will be called on every evaluated child, the predicate must return true for a given child to be part of the result, otherwise it will be ignored
+         * @returns an array of {BABYLON.Node}
+         */
         Node.prototype.getChildren = function (predicate) {
             return this.getDescendants(true, predicate);
         };
+        /** @ignore */
         Node.prototype._setReady = function (state) {
             if (state === this._isReady) {
                 return;
@@ -15269,6 +15347,11 @@ var BABYLON;
                 this.onReady(this);
             }
         };
+        /**
+         * Get an animation by name
+         * @param name defines the name of the animation to look for
+         * @returns null if not found else the requested animation
+         */
         Node.prototype.getAnimationByName = function (name) {
             for (var i = 0; i < this.animations.length; i++) {
                 var animation = this.animations[i];
@@ -15278,6 +15361,12 @@ var BABYLON;
             }
             return null;
         };
+        /**
+         * Creates an animation range for this node
+         * @param name defines the name of the range
+         * @param from defines the starting key
+         * @param to defines the end key
+         */
         Node.prototype.createAnimationRange = function (name, from, to) {
             // check name not already in use
             if (!this._ranges[name]) {
@@ -15289,6 +15378,11 @@ var BABYLON;
                 }
             }
         };
+        /**
+         * Delete a specific animation range
+         * @param name defines the name of the range to delete
+         * @param deleteFrames defines if animation frames from the range must be deleted as well
+         */
         Node.prototype.deleteAnimationRange = function (name, deleteFrames) {
             if (deleteFrames === void 0) { deleteFrames = true; }
             for (var i = 0, nAnimations = this.animations.length; i < nAnimations; i++) {
@@ -15298,6 +15392,11 @@ var BABYLON;
             }
             this._ranges[name] = null; // said much faster than 'delete this._range[name]' 
         };
+        /**
+         * Get an animation range by name
+         * @param name defines the name of the animation range to look for
+         * @returns null if not found else the requested animation range
+         */
         Node.prototype.getAnimationRange = function (name) {
             return this._ranges[name];
         };
@@ -15307,7 +15406,7 @@ var BABYLON;
          * @param loop defines if the animation should loop (false by default)
          * @param speedRatio defines the speed factor in which to run the animation (1 by default)
          * @param onAnimationEnd defines a function to be executed when the animation ended (undefined by default)
-         * @returns the {BABYLON.Animatable} object created for this animation. If range does not exist, it will return null
+         * @returns the object created for this animation. If range does not exist, it will return null
          */
         Node.prototype.beginAnimation = function (name, loop, speedRatio, onAnimationEnd) {
             var range = this.getAnimationRange(name);
@@ -15316,6 +15415,10 @@ var BABYLON;
             }
             return this._scene.beginAnimation(this, range.from, range.to, loop, speedRatio, onAnimationEnd);
         };
+        /**
+         * Serialize animation ranges into a JSON compatible object
+         * @returns serialization object
+         */
         Node.prototype.serializeAnimationRanges = function () {
             var serializationRanges = [];
             for (var name in this._ranges) {
@@ -15331,10 +15434,17 @@ var BABYLON;
             }
             return serializationRanges;
         };
-        // override it in derived class
+        /**
+         * Computes the world matrix of the node
+         * @param force defines if the cache version should be invalidated forcing the world matrix to be created from scratch
+         * @returns the world matrix
+         */
         Node.prototype.computeWorldMatrix = function (force) {
             return BABYLON.Matrix.Identity();
         };
+        /**
+         * Releases all associated resources
+         */
         Node.prototype.dispose = function () {
             this.parent = null;
             // Callback
@@ -15346,7 +15456,14 @@ var BABYLON;
                 behavior.detach();
             }
             this._behaviors = [];
+            this._isDisposed = true;
         };
+        /**
+         * Parse animation range data from a serialization object and store them into a given node
+         * @param node defines where to store the animation ranges
+         * @param parsedNode defines the serialization object to read data from
+         * @param scene defines the hosting scene
+         */
         Node.ParseAnimationRanges = function (node, parsedNode, scene) {
             if (parsedNode.ranges) {
                 for (var index = 0; index < parsedNode.ranges.length; index++) {
@@ -16769,7 +16886,6 @@ var BABYLON;
             // Cache
             _this._collisionsTransformMatrix = BABYLON.Matrix.Zero();
             _this._collisionsScalingMatrix = BABYLON.Matrix.Zero();
-            _this._isDisposed = false;
             _this._renderId = 0;
             _this._intersectionsInProgress = new Array();
             _this._unIndexed = false;
@@ -17144,12 +17260,6 @@ var BABYLON;
             configurable: true
         });
         /**
-         * Boolean : true if the mesh has been disposed.
-         */
-        AbstractMesh.prototype.isDisposed = function () {
-            return this._isDisposed;
-        };
-        /**
          * Returns the string "AbstractMesh"
          */
         AbstractMesh.prototype.getClassName = function () {
@@ -18003,7 +18113,6 @@ var BABYLON;
             this.onAfterWorldMatrixUpdateObservable.clear();
             this.onCollideObservable.clear();
             this.onCollisionPositionChangeObservable.clear();
-            this._isDisposed = true;
             _super.prototype.dispose.call(this, doNotRecurse);
         };
         /**
@@ -51300,7 +51409,7 @@ var BABYLON;
 
 
 
-//# sourceMappingURL=babylon.IParticleEmitterType.js.map
+//# sourceMappingURL=babylon.iParticleEmitterType.js.map
 
 var BABYLON;
 (function (BABYLON) {

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

@@ -14972,23 +14972,38 @@ var BABYLON;
      */
     var Node = /** @class */ (function () {
         /**
-         * @constructor
+         * Creates a new Node
          * @param {string} name - the name and id to be given to this node
          * @param {BABYLON.Scene} the scene this node will be added to
          */
         function Node(name, scene) {
             if (scene === void 0) { scene = null; }
+            /**
+             * Gets or sets a string used to store user defined state for the node
+             */
             this.state = "";
+            /**
+             * Gets or sets an object used to store user defined information for the node
+             */
             this.metadata = null;
+            /**
+             * Gets or sets a boolean used to define if the node must be serialized
+             */
             this.doNotSerialize = false;
+            /** @ignore */
+            this._isDisposed = false;
+            /**
+             * Gets a list of {BABYLON.Animation} associated with the node
+             */
             this.animations = new Array();
             this._ranges = {};
             this._isEnabled = true;
             this._isReady = true;
+            /** @ignore */
             this._currentRenderId = -1;
             this._parentRenderId = -1;
             /**
-            * An event triggered when the mesh is disposed.
+            * An event triggered when the mesh is disposed
             * @type {BABYLON.Observable}
             */
             this.onDisposeObservable = new BABYLON.Observable();
@@ -15000,10 +15015,20 @@ var BABYLON;
             this.uniqueId = this._scene.getUniqueId();
             this._initCache();
         }
+        /**
+         * Gets a boolean indicating if the node has been disposed
+         * @returns true if the node was disposed
+         */
+        Node.prototype.isDisposed = function () {
+            return this._isDisposed;
+        };
         Object.defineProperty(Node.prototype, "parent", {
             get: function () {
                 return this._parentNode;
             },
+            /**
+             * Gets or sets the parent of the node
+             */
             set: function (parent) {
                 if (this._parentNode === parent) {
                     return;
@@ -15028,10 +15053,17 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
+        /**
+         * Gets a string idenfifying the name of the class
+         * @returns "Node" string
+         */
         Node.prototype.getClassName = function () {
             return "Node";
         };
         Object.defineProperty(Node.prototype, "onDispose", {
+            /**
+             * Sets a callback that will be raised when the node will be disposed
+             */
             set: function (callback) {
                 if (this._onDisposeObserver) {
                     this.onDisposeObservable.remove(this._onDisposeObserver);
@@ -15041,12 +15073,26 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
+        /**
+         * Gets the scene of the node
+         * @returns a {BABYLON.Scene}
+         */
         Node.prototype.getScene = function () {
             return this._scene;
         };
+        /**
+         * Gets the engine of the node
+         * @returns a {BABYLON.Engine}
+         */
         Node.prototype.getEngine = function () {
             return this._scene.getEngine();
         };
+        /**
+         * Attach a behavior to the node
+         * @see http://doc.babylonjs.com/features/behaviour
+         * @param behavior defines the behavior to attach
+         * @returns the current Node
+         */
         Node.prototype.addBehavior = function (behavior) {
             var _this = this;
             var index = this._behaviors.indexOf(behavior);
@@ -15070,6 +15116,12 @@ var BABYLON;
             this._behaviors.push(behavior);
             return this;
         };
+        /**
+         * Remove an attached behavior
+         * @see http://doc.babylonjs.com/features/behaviour
+         * @param behavior defines the behavior to attach
+         * @returns the current Node
+         */
         Node.prototype.removeBehavior = function (behavior) {
             var index = this._behaviors.indexOf(behavior);
             if (index === -1) {
@@ -15080,12 +15132,22 @@ var BABYLON;
             return this;
         };
         Object.defineProperty(Node.prototype, "behaviors", {
+            /**
+             * Gets the list of attached behaviors
+             * @see http://doc.babylonjs.com/features/behaviour
+             */
             get: function () {
                 return this._behaviors;
             },
             enumerable: true,
             configurable: true
         });
+        /**
+         * Gets an attached behavior by name
+         * @param name defines the name of the behavior to look for
+         * @see http://doc.babylonjs.com/features/behaviour
+         * @returns null if behavior was not found else the requested behavior
+         */
         Node.prototype.getBehaviorByName = function (name) {
             for (var _i = 0, _a = this._behaviors; _i < _a.length; _i++) {
                 var behavior = _a[_i];
@@ -15095,16 +15157,21 @@ var BABYLON;
             }
             return null;
         };
-        // override it in derived class
+        /**
+         * Returns the world matrix of the node
+         * @returns a matrix containing the node's world matrix
+         */
         Node.prototype.getWorldMatrix = function () {
             return BABYLON.Matrix.Identity();
         };
         // override it in derived class if you add new variables to the cache
         // and call the parent class method
+        /** @ignore */
         Node.prototype._initCache = function () {
             this._cache = {};
             this._cache.parent = undefined;
         };
+        /** @ignore */
         Node.prototype.updateCache = function (force) {
             if (!force && this.isSynchronized())
                 return;
@@ -15113,17 +15180,21 @@ var BABYLON;
         };
         // override it in derived class if you add new variables to the cache
         // and call the parent class method if !ignoreParentClass
+        /** @ignore */
         Node.prototype._updateCache = function (ignoreParentClass) {
         };
         // override it in derived class if you add new variables to the cache
+        /** @ignore */
         Node.prototype._isSynchronized = function () {
             return true;
         };
+        /** @ignore */
         Node.prototype._markSyncedWithParent = function () {
             if (this.parent) {
                 this._parentRenderId = this.parent._currentRenderId;
             }
         };
+        /** @ignore */
         Node.prototype.isSynchronizedWithParent = function () {
             if (!this.parent) {
                 return true;
@@ -15133,6 +15204,7 @@ var BABYLON;
             }
             return this.parent.isSynchronized();
         };
+        /** @ignore */
         Node.prototype.isSynchronized = function (updateCache) {
             var check = this.hasNewParent();
             check = check || !this.isSynchronizedWithParent();
@@ -15141,6 +15213,7 @@ var BABYLON;
                 this.updateCache(true);
             return !check;
         };
+        /** @ignore */
         Node.prototype.hasNewParent = function (update) {
             if (this._cache.parent === this.parent)
                 return false;
@@ -15150,16 +15223,16 @@ var BABYLON;
         };
         /**
          * Is this node ready to be used/rendered
-         * @return {boolean} is it ready
+         * @return true if the node is ready
          */
         Node.prototype.isReady = function () {
             return this._isReady;
         };
         /**
-         * Is this node enabled.
-         * If the node has a parent, all ancestors will be checked and false will be returned if any are false (not enabled), otherwise will return true.
-         * @param {boolean} [checkAncestors=true] - Indicates if this method should check the ancestors. The default is to check the ancestors. If set to false, the method will return the value of this node without checking ancestors.
-         * @return {boolean} whether this node (and its parent) is enabled.
+         * Is this node enabled?
+         * If the node has a parent, all ancestors will be checked and false will be returned if any are false (not enabled), otherwise will return true
+         * @param checkAncestors indicates if this method should check the ancestors. The default is to check the ancestors. If set to false, the method will return the value of this node without checking ancestors
+         * @return whether this node (and its parent) is enabled
          * @see setEnabled
          */
         Node.prototype.isEnabled = function (checkAncestors) {
@@ -15176,18 +15249,19 @@ var BABYLON;
             return true;
         };
         /**
-         * Set the enabled state of this node.
-         * @param {boolean} value - the new enabled state
+         * Set the enabled state of this node
+         * @param value defines the new enabled state
          * @see isEnabled
          */
         Node.prototype.setEnabled = function (value) {
             this._isEnabled = value;
         };
         /**
-         * Is this node a descendant of the given node.
-         * The function will iterate up the hierarchy until the ancestor was found or no more parents defined.
-         * @param {BABYLON.Node} ancestor - The parent node to inspect
+         * Is this node a descendant of the given node?
+         * The function will iterate up the hierarchy until the ancestor was found or no more parents defined
+         * @param ancestor defines the parent node to inspect
          * @see parent
+         * @returns a boolean indicating if this node is a descendant of the given node
          */
         Node.prototype.isDescendantOf = function (ancestor) {
             if (this.parent) {
@@ -15198,12 +15272,7 @@ var BABYLON;
             }
             return false;
         };
-        /**
-         * Evaluate the list of children and determine if they should be considered as descendants considering the given criterias
-         * @param {BABYLON.Node[]} results the result array containing the nodes matching the given criterias
-         * @param {boolean} directDescendantsOnly if true only direct descendants of 'this' will be considered, if false direct and also indirect (children of children, an so on in a recursive manner) descendants of 'this' will be considered.
-         * @param predicate: an optional predicate that will be called on every evaluated children, the predicate must return true for a given child to be part of the result, otherwise it will be ignored.
-         */
+        /** @ignore */
         Node.prototype._getDescendants = function (results, directDescendantsOnly, predicate) {
             if (directDescendantsOnly === void 0) { directDescendantsOnly = false; }
             if (!this._children) {
@@ -15220,10 +15289,10 @@ var BABYLON;
             }
         };
         /**
-         * Will return all nodes that have this node as ascendant.
-         * @param {boolean} directDescendantsOnly if true only direct descendants of 'this' will be considered, if false direct and also indirect (children of children, an so on in a recursive manner) descendants of 'this' will be considered.
-         * @param predicate: an optional predicate that will be called on every evaluated children, the predicate must return true for a given child to be part of the result, otherwise it will be ignored.
-         * @return {BABYLON.Node[]} all children nodes of all types.
+         * Will return all nodes that have this node as ascendant
+         * @param directDescendantsOnly defines if true only direct descendants of 'this' will be considered, if false direct and also indirect (children of children, an so on in a recursive manner) descendants of 'this' will be considered
+         * @param predicate defines an optional predicate that will be called on every evaluated child, the predicate must return true for a given child to be part of the result, otherwise it will be ignored
+         * @return all children nodes of all types
          */
         Node.prototype.getDescendants = function (directDescendantsOnly, predicate) {
             var results = new Array();
@@ -15231,7 +15300,10 @@ var BABYLON;
             return results;
         };
         /**
-         * Get all child-meshes of this node.
+         * Get all child-meshes of this node
+         * @param directDescendantsOnly defines if true only direct descendants of 'this' will be considered, if false direct and also indirect (children of children, an so on in a recursive manner) descendants of 'this' will be considered
+         * @param predicate defines an optional predicate that will be called on every evaluated child, the predicate must return true for a given child to be part of the result, otherwise it will be ignored
+         * @returns an array of {BABYLON.AbstractMesh}
          */
         Node.prototype.getChildMeshes = function (directDescendantsOnly, predicate) {
             var results = [];
@@ -15241,7 +15313,10 @@ var BABYLON;
             return results;
         };
         /**
-         * Get all child-transformNodes of this node.
+         * Get all child-transformNodes of this node
+         * @param directDescendantsOnly defines if true only direct descendants of 'this' will be considered, if false direct and also indirect (children of children, an so on in a recursive manner) descendants of 'this' will be considered
+         * @param predicate defines an optional predicate that will be called on every evaluated child, the predicate must return true for a given child to be part of the result, otherwise it will be ignored
+         * @returns an array of {BABYLON.TransformNode}
          */
         Node.prototype.getChildTransformNodes = function (directDescendantsOnly, predicate) {
             var results = [];
@@ -15251,11 +15326,14 @@ var BABYLON;
             return results;
         };
         /**
-         * Get all direct children of this node.
-        */
+         * Get all direct children of this node
+         * @param predicate defines an optional predicate that will be called on every evaluated child, the predicate must return true for a given child to be part of the result, otherwise it will be ignored
+         * @returns an array of {BABYLON.Node}
+         */
         Node.prototype.getChildren = function (predicate) {
             return this.getDescendants(true, predicate);
         };
+        /** @ignore */
         Node.prototype._setReady = function (state) {
             if (state === this._isReady) {
                 return;
@@ -15269,6 +15347,11 @@ var BABYLON;
                 this.onReady(this);
             }
         };
+        /**
+         * Get an animation by name
+         * @param name defines the name of the animation to look for
+         * @returns null if not found else the requested animation
+         */
         Node.prototype.getAnimationByName = function (name) {
             for (var i = 0; i < this.animations.length; i++) {
                 var animation = this.animations[i];
@@ -15278,6 +15361,12 @@ var BABYLON;
             }
             return null;
         };
+        /**
+         * Creates an animation range for this node
+         * @param name defines the name of the range
+         * @param from defines the starting key
+         * @param to defines the end key
+         */
         Node.prototype.createAnimationRange = function (name, from, to) {
             // check name not already in use
             if (!this._ranges[name]) {
@@ -15289,6 +15378,11 @@ var BABYLON;
                 }
             }
         };
+        /**
+         * Delete a specific animation range
+         * @param name defines the name of the range to delete
+         * @param deleteFrames defines if animation frames from the range must be deleted as well
+         */
         Node.prototype.deleteAnimationRange = function (name, deleteFrames) {
             if (deleteFrames === void 0) { deleteFrames = true; }
             for (var i = 0, nAnimations = this.animations.length; i < nAnimations; i++) {
@@ -15298,6 +15392,11 @@ var BABYLON;
             }
             this._ranges[name] = null; // said much faster than 'delete this._range[name]' 
         };
+        /**
+         * Get an animation range by name
+         * @param name defines the name of the animation range to look for
+         * @returns null if not found else the requested animation range
+         */
         Node.prototype.getAnimationRange = function (name) {
             return this._ranges[name];
         };
@@ -15307,7 +15406,7 @@ var BABYLON;
          * @param loop defines if the animation should loop (false by default)
          * @param speedRatio defines the speed factor in which to run the animation (1 by default)
          * @param onAnimationEnd defines a function to be executed when the animation ended (undefined by default)
-         * @returns the {BABYLON.Animatable} object created for this animation. If range does not exist, it will return null
+         * @returns the object created for this animation. If range does not exist, it will return null
          */
         Node.prototype.beginAnimation = function (name, loop, speedRatio, onAnimationEnd) {
             var range = this.getAnimationRange(name);
@@ -15316,6 +15415,10 @@ var BABYLON;
             }
             return this._scene.beginAnimation(this, range.from, range.to, loop, speedRatio, onAnimationEnd);
         };
+        /**
+         * Serialize animation ranges into a JSON compatible object
+         * @returns serialization object
+         */
         Node.prototype.serializeAnimationRanges = function () {
             var serializationRanges = [];
             for (var name in this._ranges) {
@@ -15331,10 +15434,17 @@ var BABYLON;
             }
             return serializationRanges;
         };
-        // override it in derived class
+        /**
+         * Computes the world matrix of the node
+         * @param force defines if the cache version should be invalidated forcing the world matrix to be created from scratch
+         * @returns the world matrix
+         */
         Node.prototype.computeWorldMatrix = function (force) {
             return BABYLON.Matrix.Identity();
         };
+        /**
+         * Releases all associated resources
+         */
         Node.prototype.dispose = function () {
             this.parent = null;
             // Callback
@@ -15346,7 +15456,14 @@ var BABYLON;
                 behavior.detach();
             }
             this._behaviors = [];
+            this._isDisposed = true;
         };
+        /**
+         * Parse animation range data from a serialization object and store them into a given node
+         * @param node defines where to store the animation ranges
+         * @param parsedNode defines the serialization object to read data from
+         * @param scene defines the hosting scene
+         */
         Node.ParseAnimationRanges = function (node, parsedNode, scene) {
             if (parsedNode.ranges) {
                 for (var index = 0; index < parsedNode.ranges.length; index++) {
@@ -16769,7 +16886,6 @@ var BABYLON;
             // Cache
             _this._collisionsTransformMatrix = BABYLON.Matrix.Zero();
             _this._collisionsScalingMatrix = BABYLON.Matrix.Zero();
-            _this._isDisposed = false;
             _this._renderId = 0;
             _this._intersectionsInProgress = new Array();
             _this._unIndexed = false;
@@ -17144,12 +17260,6 @@ var BABYLON;
             configurable: true
         });
         /**
-         * Boolean : true if the mesh has been disposed.
-         */
-        AbstractMesh.prototype.isDisposed = function () {
-            return this._isDisposed;
-        };
-        /**
          * Returns the string "AbstractMesh"
          */
         AbstractMesh.prototype.getClassName = function () {
@@ -18003,7 +18113,6 @@ var BABYLON;
             this.onAfterWorldMatrixUpdateObservable.clear();
             this.onCollideObservable.clear();
             this.onCollisionPositionChangeObservable.clear();
-            this._isDisposed = true;
             _super.prototype.dispose.call(this, doNotRecurse);
         };
         /**
@@ -51300,7 +51409,7 @@ var BABYLON;
 
 
 
-//# sourceMappingURL=babylon.IParticleEmitterType.js.map
+//# sourceMappingURL=babylon.iParticleEmitterType.js.map
 
 var BABYLON;
 (function (BABYLON) {

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

@@ -14958,23 +14958,38 @@ var BABYLON;
      */
     var Node = /** @class */ (function () {
         /**
-         * @constructor
+         * Creates a new Node
          * @param {string} name - the name and id to be given to this node
          * @param {BABYLON.Scene} the scene this node will be added to
          */
         function Node(name, scene) {
             if (scene === void 0) { scene = null; }
+            /**
+             * Gets or sets a string used to store user defined state for the node
+             */
             this.state = "";
+            /**
+             * Gets or sets an object used to store user defined information for the node
+             */
             this.metadata = null;
+            /**
+             * Gets or sets a boolean used to define if the node must be serialized
+             */
             this.doNotSerialize = false;
+            /** @ignore */
+            this._isDisposed = false;
+            /**
+             * Gets a list of {BABYLON.Animation} associated with the node
+             */
             this.animations = new Array();
             this._ranges = {};
             this._isEnabled = true;
             this._isReady = true;
+            /** @ignore */
             this._currentRenderId = -1;
             this._parentRenderId = -1;
             /**
-            * An event triggered when the mesh is disposed.
+            * An event triggered when the mesh is disposed
             * @type {BABYLON.Observable}
             */
             this.onDisposeObservable = new BABYLON.Observable();
@@ -14986,10 +15001,20 @@ var BABYLON;
             this.uniqueId = this._scene.getUniqueId();
             this._initCache();
         }
+        /**
+         * Gets a boolean indicating if the node has been disposed
+         * @returns true if the node was disposed
+         */
+        Node.prototype.isDisposed = function () {
+            return this._isDisposed;
+        };
         Object.defineProperty(Node.prototype, "parent", {
             get: function () {
                 return this._parentNode;
             },
+            /**
+             * Gets or sets the parent of the node
+             */
             set: function (parent) {
                 if (this._parentNode === parent) {
                     return;
@@ -15014,10 +15039,17 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
+        /**
+         * Gets a string idenfifying the name of the class
+         * @returns "Node" string
+         */
         Node.prototype.getClassName = function () {
             return "Node";
         };
         Object.defineProperty(Node.prototype, "onDispose", {
+            /**
+             * Sets a callback that will be raised when the node will be disposed
+             */
             set: function (callback) {
                 if (this._onDisposeObserver) {
                     this.onDisposeObservable.remove(this._onDisposeObserver);
@@ -15027,12 +15059,26 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
+        /**
+         * Gets the scene of the node
+         * @returns a {BABYLON.Scene}
+         */
         Node.prototype.getScene = function () {
             return this._scene;
         };
+        /**
+         * Gets the engine of the node
+         * @returns a {BABYLON.Engine}
+         */
         Node.prototype.getEngine = function () {
             return this._scene.getEngine();
         };
+        /**
+         * Attach a behavior to the node
+         * @see http://doc.babylonjs.com/features/behaviour
+         * @param behavior defines the behavior to attach
+         * @returns the current Node
+         */
         Node.prototype.addBehavior = function (behavior) {
             var _this = this;
             var index = this._behaviors.indexOf(behavior);
@@ -15056,6 +15102,12 @@ var BABYLON;
             this._behaviors.push(behavior);
             return this;
         };
+        /**
+         * Remove an attached behavior
+         * @see http://doc.babylonjs.com/features/behaviour
+         * @param behavior defines the behavior to attach
+         * @returns the current Node
+         */
         Node.prototype.removeBehavior = function (behavior) {
             var index = this._behaviors.indexOf(behavior);
             if (index === -1) {
@@ -15066,12 +15118,22 @@ var BABYLON;
             return this;
         };
         Object.defineProperty(Node.prototype, "behaviors", {
+            /**
+             * Gets the list of attached behaviors
+             * @see http://doc.babylonjs.com/features/behaviour
+             */
             get: function () {
                 return this._behaviors;
             },
             enumerable: true,
             configurable: true
         });
+        /**
+         * Gets an attached behavior by name
+         * @param name defines the name of the behavior to look for
+         * @see http://doc.babylonjs.com/features/behaviour
+         * @returns null if behavior was not found else the requested behavior
+         */
         Node.prototype.getBehaviorByName = function (name) {
             for (var _i = 0, _a = this._behaviors; _i < _a.length; _i++) {
                 var behavior = _a[_i];
@@ -15081,16 +15143,21 @@ var BABYLON;
             }
             return null;
         };
-        // override it in derived class
+        /**
+         * Returns the world matrix of the node
+         * @returns a matrix containing the node's world matrix
+         */
         Node.prototype.getWorldMatrix = function () {
             return BABYLON.Matrix.Identity();
         };
         // override it in derived class if you add new variables to the cache
         // and call the parent class method
+        /** @ignore */
         Node.prototype._initCache = function () {
             this._cache = {};
             this._cache.parent = undefined;
         };
+        /** @ignore */
         Node.prototype.updateCache = function (force) {
             if (!force && this.isSynchronized())
                 return;
@@ -15099,17 +15166,21 @@ var BABYLON;
         };
         // override it in derived class if you add new variables to the cache
         // and call the parent class method if !ignoreParentClass
+        /** @ignore */
         Node.prototype._updateCache = function (ignoreParentClass) {
         };
         // override it in derived class if you add new variables to the cache
+        /** @ignore */
         Node.prototype._isSynchronized = function () {
             return true;
         };
+        /** @ignore */
         Node.prototype._markSyncedWithParent = function () {
             if (this.parent) {
                 this._parentRenderId = this.parent._currentRenderId;
             }
         };
+        /** @ignore */
         Node.prototype.isSynchronizedWithParent = function () {
             if (!this.parent) {
                 return true;
@@ -15119,6 +15190,7 @@ var BABYLON;
             }
             return this.parent.isSynchronized();
         };
+        /** @ignore */
         Node.prototype.isSynchronized = function (updateCache) {
             var check = this.hasNewParent();
             check = check || !this.isSynchronizedWithParent();
@@ -15127,6 +15199,7 @@ var BABYLON;
                 this.updateCache(true);
             return !check;
         };
+        /** @ignore */
         Node.prototype.hasNewParent = function (update) {
             if (this._cache.parent === this.parent)
                 return false;
@@ -15136,16 +15209,16 @@ var BABYLON;
         };
         /**
          * Is this node ready to be used/rendered
-         * @return {boolean} is it ready
+         * @return true if the node is ready
          */
         Node.prototype.isReady = function () {
             return this._isReady;
         };
         /**
-         * Is this node enabled.
-         * If the node has a parent, all ancestors will be checked and false will be returned if any are false (not enabled), otherwise will return true.
-         * @param {boolean} [checkAncestors=true] - Indicates if this method should check the ancestors. The default is to check the ancestors. If set to false, the method will return the value of this node without checking ancestors.
-         * @return {boolean} whether this node (and its parent) is enabled.
+         * Is this node enabled?
+         * If the node has a parent, all ancestors will be checked and false will be returned if any are false (not enabled), otherwise will return true
+         * @param checkAncestors indicates if this method should check the ancestors. The default is to check the ancestors. If set to false, the method will return the value of this node without checking ancestors
+         * @return whether this node (and its parent) is enabled
          * @see setEnabled
          */
         Node.prototype.isEnabled = function (checkAncestors) {
@@ -15162,18 +15235,19 @@ var BABYLON;
             return true;
         };
         /**
-         * Set the enabled state of this node.
-         * @param {boolean} value - the new enabled state
+         * Set the enabled state of this node
+         * @param value defines the new enabled state
          * @see isEnabled
          */
         Node.prototype.setEnabled = function (value) {
             this._isEnabled = value;
         };
         /**
-         * Is this node a descendant of the given node.
-         * The function will iterate up the hierarchy until the ancestor was found or no more parents defined.
-         * @param {BABYLON.Node} ancestor - The parent node to inspect
+         * Is this node a descendant of the given node?
+         * The function will iterate up the hierarchy until the ancestor was found or no more parents defined
+         * @param ancestor defines the parent node to inspect
          * @see parent
+         * @returns a boolean indicating if this node is a descendant of the given node
          */
         Node.prototype.isDescendantOf = function (ancestor) {
             if (this.parent) {
@@ -15184,12 +15258,7 @@ var BABYLON;
             }
             return false;
         };
-        /**
-         * Evaluate the list of children and determine if they should be considered as descendants considering the given criterias
-         * @param {BABYLON.Node[]} results the result array containing the nodes matching the given criterias
-         * @param {boolean} directDescendantsOnly if true only direct descendants of 'this' will be considered, if false direct and also indirect (children of children, an so on in a recursive manner) descendants of 'this' will be considered.
-         * @param predicate: an optional predicate that will be called on every evaluated children, the predicate must return true for a given child to be part of the result, otherwise it will be ignored.
-         */
+        /** @ignore */
         Node.prototype._getDescendants = function (results, directDescendantsOnly, predicate) {
             if (directDescendantsOnly === void 0) { directDescendantsOnly = false; }
             if (!this._children) {
@@ -15206,10 +15275,10 @@ var BABYLON;
             }
         };
         /**
-         * Will return all nodes that have this node as ascendant.
-         * @param {boolean} directDescendantsOnly if true only direct descendants of 'this' will be considered, if false direct and also indirect (children of children, an so on in a recursive manner) descendants of 'this' will be considered.
-         * @param predicate: an optional predicate that will be called on every evaluated children, the predicate must return true for a given child to be part of the result, otherwise it will be ignored.
-         * @return {BABYLON.Node[]} all children nodes of all types.
+         * Will return all nodes that have this node as ascendant
+         * @param directDescendantsOnly defines if true only direct descendants of 'this' will be considered, if false direct and also indirect (children of children, an so on in a recursive manner) descendants of 'this' will be considered
+         * @param predicate defines an optional predicate that will be called on every evaluated child, the predicate must return true for a given child to be part of the result, otherwise it will be ignored
+         * @return all children nodes of all types
          */
         Node.prototype.getDescendants = function (directDescendantsOnly, predicate) {
             var results = new Array();
@@ -15217,7 +15286,10 @@ var BABYLON;
             return results;
         };
         /**
-         * Get all child-meshes of this node.
+         * Get all child-meshes of this node
+         * @param directDescendantsOnly defines if true only direct descendants of 'this' will be considered, if false direct and also indirect (children of children, an so on in a recursive manner) descendants of 'this' will be considered
+         * @param predicate defines an optional predicate that will be called on every evaluated child, the predicate must return true for a given child to be part of the result, otherwise it will be ignored
+         * @returns an array of {BABYLON.AbstractMesh}
          */
         Node.prototype.getChildMeshes = function (directDescendantsOnly, predicate) {
             var results = [];
@@ -15227,7 +15299,10 @@ var BABYLON;
             return results;
         };
         /**
-         * Get all child-transformNodes of this node.
+         * Get all child-transformNodes of this node
+         * @param directDescendantsOnly defines if true only direct descendants of 'this' will be considered, if false direct and also indirect (children of children, an so on in a recursive manner) descendants of 'this' will be considered
+         * @param predicate defines an optional predicate that will be called on every evaluated child, the predicate must return true for a given child to be part of the result, otherwise it will be ignored
+         * @returns an array of {BABYLON.TransformNode}
          */
         Node.prototype.getChildTransformNodes = function (directDescendantsOnly, predicate) {
             var results = [];
@@ -15237,11 +15312,14 @@ var BABYLON;
             return results;
         };
         /**
-         * Get all direct children of this node.
-        */
+         * Get all direct children of this node
+         * @param predicate defines an optional predicate that will be called on every evaluated child, the predicate must return true for a given child to be part of the result, otherwise it will be ignored
+         * @returns an array of {BABYLON.Node}
+         */
         Node.prototype.getChildren = function (predicate) {
             return this.getDescendants(true, predicate);
         };
+        /** @ignore */
         Node.prototype._setReady = function (state) {
             if (state === this._isReady) {
                 return;
@@ -15255,6 +15333,11 @@ var BABYLON;
                 this.onReady(this);
             }
         };
+        /**
+         * Get an animation by name
+         * @param name defines the name of the animation to look for
+         * @returns null if not found else the requested animation
+         */
         Node.prototype.getAnimationByName = function (name) {
             for (var i = 0; i < this.animations.length; i++) {
                 var animation = this.animations[i];
@@ -15264,6 +15347,12 @@ var BABYLON;
             }
             return null;
         };
+        /**
+         * Creates an animation range for this node
+         * @param name defines the name of the range
+         * @param from defines the starting key
+         * @param to defines the end key
+         */
         Node.prototype.createAnimationRange = function (name, from, to) {
             // check name not already in use
             if (!this._ranges[name]) {
@@ -15275,6 +15364,11 @@ var BABYLON;
                 }
             }
         };
+        /**
+         * Delete a specific animation range
+         * @param name defines the name of the range to delete
+         * @param deleteFrames defines if animation frames from the range must be deleted as well
+         */
         Node.prototype.deleteAnimationRange = function (name, deleteFrames) {
             if (deleteFrames === void 0) { deleteFrames = true; }
             for (var i = 0, nAnimations = this.animations.length; i < nAnimations; i++) {
@@ -15284,6 +15378,11 @@ var BABYLON;
             }
             this._ranges[name] = null; // said much faster than 'delete this._range[name]' 
         };
+        /**
+         * Get an animation range by name
+         * @param name defines the name of the animation range to look for
+         * @returns null if not found else the requested animation range
+         */
         Node.prototype.getAnimationRange = function (name) {
             return this._ranges[name];
         };
@@ -15293,7 +15392,7 @@ var BABYLON;
          * @param loop defines if the animation should loop (false by default)
          * @param speedRatio defines the speed factor in which to run the animation (1 by default)
          * @param onAnimationEnd defines a function to be executed when the animation ended (undefined by default)
-         * @returns the {BABYLON.Animatable} object created for this animation. If range does not exist, it will return null
+         * @returns the object created for this animation. If range does not exist, it will return null
          */
         Node.prototype.beginAnimation = function (name, loop, speedRatio, onAnimationEnd) {
             var range = this.getAnimationRange(name);
@@ -15302,6 +15401,10 @@ var BABYLON;
             }
             return this._scene.beginAnimation(this, range.from, range.to, loop, speedRatio, onAnimationEnd);
         };
+        /**
+         * Serialize animation ranges into a JSON compatible object
+         * @returns serialization object
+         */
         Node.prototype.serializeAnimationRanges = function () {
             var serializationRanges = [];
             for (var name in this._ranges) {
@@ -15317,10 +15420,17 @@ var BABYLON;
             }
             return serializationRanges;
         };
-        // override it in derived class
+        /**
+         * Computes the world matrix of the node
+         * @param force defines if the cache version should be invalidated forcing the world matrix to be created from scratch
+         * @returns the world matrix
+         */
         Node.prototype.computeWorldMatrix = function (force) {
             return BABYLON.Matrix.Identity();
         };
+        /**
+         * Releases all associated resources
+         */
         Node.prototype.dispose = function () {
             this.parent = null;
             // Callback
@@ -15332,7 +15442,14 @@ var BABYLON;
                 behavior.detach();
             }
             this._behaviors = [];
+            this._isDisposed = true;
         };
+        /**
+         * Parse animation range data from a serialization object and store them into a given node
+         * @param node defines where to store the animation ranges
+         * @param parsedNode defines the serialization object to read data from
+         * @param scene defines the hosting scene
+         */
         Node.ParseAnimationRanges = function (node, parsedNode, scene) {
             if (parsedNode.ranges) {
                 for (var index = 0; index < parsedNode.ranges.length; index++) {
@@ -16755,7 +16872,6 @@ var BABYLON;
             // Cache
             _this._collisionsTransformMatrix = BABYLON.Matrix.Zero();
             _this._collisionsScalingMatrix = BABYLON.Matrix.Zero();
-            _this._isDisposed = false;
             _this._renderId = 0;
             _this._intersectionsInProgress = new Array();
             _this._unIndexed = false;
@@ -17130,12 +17246,6 @@ var BABYLON;
             configurable: true
         });
         /**
-         * Boolean : true if the mesh has been disposed.
-         */
-        AbstractMesh.prototype.isDisposed = function () {
-            return this._isDisposed;
-        };
-        /**
          * Returns the string "AbstractMesh"
          */
         AbstractMesh.prototype.getClassName = function () {
@@ -17989,7 +18099,6 @@ var BABYLON;
             this.onAfterWorldMatrixUpdateObservable.clear();
             this.onCollideObservable.clear();
             this.onCollisionPositionChangeObservable.clear();
-            this._isDisposed = true;
             _super.prototype.dispose.call(this, doNotRecurse);
         };
         /**
@@ -51286,7 +51395,7 @@ var BABYLON;
 
 
 
-//# sourceMappingURL=babylon.IParticleEmitterType.js.map
+//# sourceMappingURL=babylon.iParticleEmitterType.js.map
 
 var BABYLON;
 (function (BABYLON) {

dist/preview release/es6.js

@@ -14958,23 +14958,38 @@ var BABYLON;
      */
     var Node = /** @class */ (function () {
         /**
-         * @constructor
+         * Creates a new Node
          * @param {string} name - the name and id to be given to this node
          * @param {BABYLON.Scene} the scene this node will be added to
          */
         function Node(name, scene) {
             if (scene === void 0) { scene = null; }
+            /**
+             * Gets or sets a string used to store user defined state for the node
+             */
             this.state = "";
+            /**
+             * Gets or sets an object used to store user defined information for the node
+             */
             this.metadata = null;
+            /**
+             * Gets or sets a boolean used to define if the node must be serialized
+             */
             this.doNotSerialize = false;
+            /** @ignore */
+            this._isDisposed = false;
+            /**
+             * Gets a list of {BABYLON.Animation} associated with the node
+             */
             this.animations = new Array();
             this._ranges = {};
             this._isEnabled = true;
             this._isReady = true;
+            /** @ignore */
             this._currentRenderId = -1;
             this._parentRenderId = -1;
             /**
-            * An event triggered when the mesh is disposed.
+            * An event triggered when the mesh is disposed
             * @type {BABYLON.Observable}
             */
             this.onDisposeObservable = new BABYLON.Observable();
@@ -14986,10 +15001,20 @@ var BABYLON;
             this.uniqueId = this._scene.getUniqueId();
             this._initCache();
         }
+        /**
+         * Gets a boolean indicating if the node has been disposed
+         * @returns true if the node was disposed
+         */
+        Node.prototype.isDisposed = function () {
+            return this._isDisposed;
+        };
         Object.defineProperty(Node.prototype, "parent", {
             get: function () {
                 return this._parentNode;
             },
+            /**
+             * Gets or sets the parent of the node
+             */
             set: function (parent) {
                 if (this._parentNode === parent) {
                     return;
@@ -15014,10 +15039,17 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
+        /**
+         * Gets a string idenfifying the name of the class
+         * @returns "Node" string
+         */
         Node.prototype.getClassName = function () {
             return "Node";
         };
         Object.defineProperty(Node.prototype, "onDispose", {
+            /**
+             * Sets a callback that will be raised when the node will be disposed
+             */
             set: function (callback) {
                 if (this._onDisposeObserver) {
                     this.onDisposeObservable.remove(this._onDisposeObserver);
@@ -15027,12 +15059,26 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
+        /**
+         * Gets the scene of the node
+         * @returns a {BABYLON.Scene}
+         */
         Node.prototype.getScene = function () {
             return this._scene;
         };
+        /**
+         * Gets the engine of the node
+         * @returns a {BABYLON.Engine}
+         */
         Node.prototype.getEngine = function () {
             return this._scene.getEngine();
         };
+        /**
+         * Attach a behavior to the node
+         * @see http://doc.babylonjs.com/features/behaviour
+         * @param behavior defines the behavior to attach
+         * @returns the current Node
+         */
         Node.prototype.addBehavior = function (behavior) {
             var _this = this;
             var index = this._behaviors.indexOf(behavior);
@@ -15056,6 +15102,12 @@ var BABYLON;
             this._behaviors.push(behavior);
             return this;
         };
+        /**
+         * Remove an attached behavior
+         * @see http://doc.babylonjs.com/features/behaviour
+         * @param behavior defines the behavior to attach
+         * @returns the current Node
+         */
         Node.prototype.removeBehavior = function (behavior) {
             var index = this._behaviors.indexOf(behavior);
             if (index === -1) {
@@ -15066,12 +15118,22 @@ var BABYLON;
             return this;
         };
         Object.defineProperty(Node.prototype, "behaviors", {
+            /**
+             * Gets the list of attached behaviors
+             * @see http://doc.babylonjs.com/features/behaviour
+             */
             get: function () {
                 return this._behaviors;
             },
             enumerable: true,
             configurable: true
         });
+        /**
+         * Gets an attached behavior by name
+         * @param name defines the name of the behavior to look for
+         * @see http://doc.babylonjs.com/features/behaviour
+         * @returns null if behavior was not found else the requested behavior
+         */
         Node.prototype.getBehaviorByName = function (name) {
             for (var _i = 0, _a = this._behaviors; _i < _a.length; _i++) {
                 var behavior = _a[_i];
@@ -15081,16 +15143,21 @@ var BABYLON;
             }
             return null;
         };
-        // override it in derived class
+        /**
+         * Returns the world matrix of the node
+         * @returns a matrix containing the node's world matrix
+         */
         Node.prototype.getWorldMatrix = function () {
             return BABYLON.Matrix.Identity();
         };
         // override it in derived class if you add new variables to the cache
         // and call the parent class method
+        /** @ignore */
         Node.prototype._initCache = function () {
             this._cache = {};
             this._cache.parent = undefined;
         };
+        /** @ignore */
         Node.prototype.updateCache = function (force) {
             if (!force && this.isSynchronized())
                 return;
@@ -15099,17 +15166,21 @@ var BABYLON;
         };
         // override it in derived class if you add new variables to the cache
         // and call the parent class method if !ignoreParentClass
+        /** @ignore */
         Node.prototype._updateCache = function (ignoreParentClass) {
         };
         // override it in derived class if you add new variables to the cache
+        /** @ignore */
         Node.prototype._isSynchronized = function () {
             return true;
         };
+        /** @ignore */
         Node.prototype._markSyncedWithParent = function () {
             if (this.parent) {
                 this._parentRenderId = this.parent._currentRenderId;
             }
         };
+        /** @ignore */
         Node.prototype.isSynchronizedWithParent = function () {
             if (!this.parent) {
                 return true;
@@ -15119,6 +15190,7 @@ var BABYLON;
             }
             return this.parent.isSynchronized();
         };
+        /** @ignore */
         Node.prototype.isSynchronized = function (updateCache) {
             var check = this.hasNewParent();
             check = check || !this.isSynchronizedWithParent();
@@ -15127,6 +15199,7 @@ var BABYLON;
                 this.updateCache(true);
             return !check;
         };
+        /** @ignore */
         Node.prototype.hasNewParent = function (update) {
             if (this._cache.parent === this.parent)
                 return false;
@@ -15136,16 +15209,16 @@ var BABYLON;
         };
         /**
          * Is this node ready to be used/rendered
-         * @return {boolean} is it ready
+         * @return true if the node is ready
          */
         Node.prototype.isReady = function () {
             return this._isReady;
         };
         /**
-         * Is this node enabled.
-         * If the node has a parent, all ancestors will be checked and false will be returned if any are false (not enabled), otherwise will return true.
-         * @param {boolean} [checkAncestors=true] - Indicates if this method should check the ancestors. The default is to check the ancestors. If set to false, the method will return the value of this node without checking ancestors.
-         * @return {boolean} whether this node (and its parent) is enabled.
+         * Is this node enabled?
+         * If the node has a parent, all ancestors will be checked and false will be returned if any are false (not enabled), otherwise will return true
+         * @param checkAncestors indicates if this method should check the ancestors. The default is to check the ancestors. If set to false, the method will return the value of this node without checking ancestors
+         * @return whether this node (and its parent) is enabled
          * @see setEnabled
          */
         Node.prototype.isEnabled = function (checkAncestors) {
@@ -15162,18 +15235,19 @@ var BABYLON;
             return true;
         };
         /**
-         * Set the enabled state of this node.
-         * @param {boolean} value - the new enabled state
+         * Set the enabled state of this node
+         * @param value defines the new enabled state
          * @see isEnabled
          */
         Node.prototype.setEnabled = function (value) {
             this._isEnabled = value;
         };
         /**
-         * Is this node a descendant of the given node.
-         * The function will iterate up the hierarchy until the ancestor was found or no more parents defined.
-         * @param {BABYLON.Node} ancestor - The parent node to inspect
+         * Is this node a descendant of the given node?
+         * The function will iterate up the hierarchy until the ancestor was found or no more parents defined
+         * @param ancestor defines the parent node to inspect
          * @see parent
+         * @returns a boolean indicating if this node is a descendant of the given node
          */
         Node.prototype.isDescendantOf = function (ancestor) {
             if (this.parent) {
@@ -15184,12 +15258,7 @@ var BABYLON;
             }
             return false;
         };
-        /**
-         * Evaluate the list of children and determine if they should be considered as descendants considering the given criterias
-         * @param {BABYLON.Node[]} results the result array containing the nodes matching the given criterias
-         * @param {boolean} directDescendantsOnly if true only direct descendants of 'this' will be considered, if false direct and also indirect (children of children, an so on in a recursive manner) descendants of 'this' will be considered.
-         * @param predicate: an optional predicate that will be called on every evaluated children, the predicate must return true for a given child to be part of the result, otherwise it will be ignored.
-         */
+        /** @ignore */
         Node.prototype._getDescendants = function (results, directDescendantsOnly, predicate) {
             if (directDescendantsOnly === void 0) { directDescendantsOnly = false; }
             if (!this._children) {
@@ -15206,10 +15275,10 @@ var BABYLON;
             }
         };
         /**
-         * Will return all nodes that have this node as ascendant.
-         * @param {boolean} directDescendantsOnly if true only direct descendants of 'this' will be considered, if false direct and also indirect (children of children, an so on in a recursive manner) descendants of 'this' will be considered.
-         * @param predicate: an optional predicate that will be called on every evaluated children, the predicate must return true for a given child to be part of the result, otherwise it will be ignored.
-         * @return {BABYLON.Node[]} all children nodes of all types.
+         * Will return all nodes that have this node as ascendant
+         * @param directDescendantsOnly defines if true only direct descendants of 'this' will be considered, if false direct and also indirect (children of children, an so on in a recursive manner) descendants of 'this' will be considered
+         * @param predicate defines an optional predicate that will be called on every evaluated child, the predicate must return true for a given child to be part of the result, otherwise it will be ignored
+         * @return all children nodes of all types
          */
         Node.prototype.getDescendants = function (directDescendantsOnly, predicate) {
             var results = new Array();
@@ -15217,7 +15286,10 @@ var BABYLON;
             return results;
         };
         /**
-         * Get all child-meshes of this node.
+         * Get all child-meshes of this node
+         * @param directDescendantsOnly defines if true only direct descendants of 'this' will be considered, if false direct and also indirect (children of children, an so on in a recursive manner) descendants of 'this' will be considered
+         * @param predicate defines an optional predicate that will be called on every evaluated child, the predicate must return true for a given child to be part of the result, otherwise it will be ignored
+         * @returns an array of {BABYLON.AbstractMesh}
          */
         Node.prototype.getChildMeshes = function (directDescendantsOnly, predicate) {
             var results = [];
@@ -15227,7 +15299,10 @@ var BABYLON;
             return results;
         };
         /**
-         * Get all child-transformNodes of this node.
+         * Get all child-transformNodes of this node
+         * @param directDescendantsOnly defines if true only direct descendants of 'this' will be considered, if false direct and also indirect (children of children, an so on in a recursive manner) descendants of 'this' will be considered
+         * @param predicate defines an optional predicate that will be called on every evaluated child, the predicate must return true for a given child to be part of the result, otherwise it will be ignored
+         * @returns an array of {BABYLON.TransformNode}
          */
         Node.prototype.getChildTransformNodes = function (directDescendantsOnly, predicate) {
             var results = [];
@@ -15237,11 +15312,14 @@ var BABYLON;
             return results;
         };
         /**
-         * Get all direct children of this node.
-        */
+         * Get all direct children of this node
+         * @param predicate defines an optional predicate that will be called on every evaluated child, the predicate must return true for a given child to be part of the result, otherwise it will be ignored
+         * @returns an array of {BABYLON.Node}
+         */
         Node.prototype.getChildren = function (predicate) {
             return this.getDescendants(true, predicate);
         };
+        /** @ignore */
         Node.prototype._setReady = function (state) {
             if (state === this._isReady) {
                 return;
@@ -15255,6 +15333,11 @@ var BABYLON;
                 this.onReady(this);
             }
         };
+        /**
+         * Get an animation by name
+         * @param name defines the name of the animation to look for
+         * @returns null if not found else the requested animation
+         */
         Node.prototype.getAnimationByName = function (name) {
             for (var i = 0; i < this.animations.length; i++) {
                 var animation = this.animations[i];
@@ -15264,6 +15347,12 @@ var BABYLON;
             }
             return null;
         };
+        /**
+         * Creates an animation range for this node
+         * @param name defines the name of the range
+         * @param from defines the starting key
+         * @param to defines the end key
+         */
         Node.prototype.createAnimationRange = function (name, from, to) {
             // check name not already in use
             if (!this._ranges[name]) {
@@ -15275,6 +15364,11 @@ var BABYLON;
                 }
             }
         };
+        /**
+         * Delete a specific animation range
+         * @param name defines the name of the range to delete
+         * @param deleteFrames defines if animation frames from the range must be deleted as well
+         */
         Node.prototype.deleteAnimationRange = function (name, deleteFrames) {
             if (deleteFrames === void 0) { deleteFrames = true; }
             for (var i = 0, nAnimations = this.animations.length; i < nAnimations; i++) {
@@ -15284,6 +15378,11 @@ var BABYLON;
             }
             this._ranges[name] = null; // said much faster than 'delete this._range[name]' 
         };
+        /**
+         * Get an animation range by name
+         * @param name defines the name of the animation range to look for
+         * @returns null if not found else the requested animation range
+         */
         Node.prototype.getAnimationRange = function (name) {
             return this._ranges[name];
         };
@@ -15293,7 +15392,7 @@ var BABYLON;
          * @param loop defines if the animation should loop (false by default)
          * @param speedRatio defines the speed factor in which to run the animation (1 by default)
          * @param onAnimationEnd defines a function to be executed when the animation ended (undefined by default)
-         * @returns the {BABYLON.Animatable} object created for this animation. If range does not exist, it will return null
+         * @returns the object created for this animation. If range does not exist, it will return null
          */
         Node.prototype.beginAnimation = function (name, loop, speedRatio, onAnimationEnd) {
             var range = this.getAnimationRange(name);
@@ -15302,6 +15401,10 @@ var BABYLON;
             }
             return this._scene.beginAnimation(this, range.from, range.to, loop, speedRatio, onAnimationEnd);
         };
+        /**
+         * Serialize animation ranges into a JSON compatible object
+         * @returns serialization object
+         */
         Node.prototype.serializeAnimationRanges = function () {
             var serializationRanges = [];
             for (var name in this._ranges) {
@@ -15317,10 +15420,17 @@ var BABYLON;
             }
             return serializationRanges;
         };
-        // override it in derived class
+        /**
+         * Computes the world matrix of the node
+         * @param force defines if the cache version should be invalidated forcing the world matrix to be created from scratch
+         * @returns the world matrix
+         */
         Node.prototype.computeWorldMatrix = function (force) {
             return BABYLON.Matrix.Identity();
         };
+        /**
+         * Releases all associated resources
+         */
         Node.prototype.dispose = function () {
             this.parent = null;
             // Callback
@@ -15332,7 +15442,14 @@ var BABYLON;
                 behavior.detach();
             }
             this._behaviors = [];
+            this._isDisposed = true;
         };
+        /**
+         * Parse animation range data from a serialization object and store them into a given node
+         * @param node defines where to store the animation ranges
+         * @param parsedNode defines the serialization object to read data from
+         * @param scene defines the hosting scene
+         */
         Node.ParseAnimationRanges = function (node, parsedNode, scene) {
             if (parsedNode.ranges) {
                 for (var index = 0; index < parsedNode.ranges.length; index++) {
@@ -16755,7 +16872,6 @@ var BABYLON;
             // Cache
             _this._collisionsTransformMatrix = BABYLON.Matrix.Zero();
             _this._collisionsScalingMatrix = BABYLON.Matrix.Zero();
-            _this._isDisposed = false;
             _this._renderId = 0;
             _this._intersectionsInProgress = new Array();
             _this._unIndexed = false;
@@ -17130,12 +17246,6 @@ var BABYLON;
             configurable: true
         });
         /**
-         * Boolean : true if the mesh has been disposed.
-         */
-        AbstractMesh.prototype.isDisposed = function () {
-            return this._isDisposed;
-        };
-        /**
          * Returns the string "AbstractMesh"
          */
         AbstractMesh.prototype.getClassName = function () {
@@ -17989,7 +18099,6 @@ var BABYLON;
             this.onAfterWorldMatrixUpdateObservable.clear();
             this.onCollideObservable.clear();
             this.onCollisionPositionChangeObservable.clear();
-            this._isDisposed = true;
             _super.prototype.dispose.call(this, doNotRecurse);
         };
         /**
@@ -51286,7 +51395,7 @@ var BABYLON;
 
 
 
-//# sourceMappingURL=babylon.IParticleEmitterType.js.map
+//# sourceMappingURL=babylon.iParticleEmitterType.js.map
 
 var BABYLON;
 (function (BABYLON) {

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

@@ -543,6 +543,8 @@ declare module BABYLON.GUI {
         private _lines;
         private _resizeToFit;
         private _lineSpacing;
+        private _outlineWidth;
+        private _outlineColor;
         /**
         * An event triggered after the text is changed
         * @type {BABYLON.Observable}
@@ -600,6 +602,20 @@ declare module BABYLON.GUI {
          */
         lineSpacing: string | number;
         /**
+         * Gets or sets outlineWidth of the text to display
+         */
+        /**
+         * Gets or sets outlineWidth of the text to display
+         */
+        outlineWidth: number;
+        /**
+         * Gets or sets outlineColor of the text to display
+         */
+        /**
+         * Gets or sets outlineColor of the text to display
+         */
+        outlineColor: string;
+        /**
          * Creates a new TextBlock object
          * @param name defines the name of the control
          * @param text defines the text to display (emptry string by default)
@@ -613,6 +629,7 @@ declare module BABYLON.GUI {
         private _drawText(text, textWidth, y, context);
         /** @ignore */
         _draw(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
+        protected _applyStates(context: CanvasRenderingContext2D): void;
         protected _additionalProcessing(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
         protected _parseLine(line: string | undefined, context: CanvasRenderingContext2D): object;
         protected _parseLineWithTextWrapping(line: string | undefined, context: CanvasRenderingContext2D): object;

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

@@ -3241,6 +3241,8 @@ var BABYLON;
                 _this._textVerticalAlignment = GUI.Control.VERTICAL_ALIGNMENT_CENTER;
                 _this._resizeToFit = false;
                 _this._lineSpacing = new GUI.ValueAndUnit(0);
+                _this._outlineWidth = 0;
+                _this._outlineColor = "white";
                 /**
                 * An event triggered after the text is changed
                 * @type {BABYLON.Observable}
@@ -3383,6 +3385,46 @@ var BABYLON;
                 enumerable: true,
                 configurable: true
             });
+            Object.defineProperty(TextBlock.prototype, "outlineWidth", {
+                /**
+                 * Gets or sets outlineWidth of the text to display
+                 */
+                get: function () {
+                    return this._outlineWidth;
+                },
+                /**
+                 * Gets or sets outlineWidth of the text to display
+                 */
+                set: function (value) {
+                    if (this._outlineWidth === value) {
+                        return;
+                    }
+                    this._outlineWidth = value;
+                    this._markAsDirty();
+                },
+                enumerable: true,
+                configurable: true
+            });
+            Object.defineProperty(TextBlock.prototype, "outlineColor", {
+                /**
+                 * Gets or sets outlineColor of the text to display
+                 */
+                get: function () {
+                    return this._outlineColor;
+                },
+                /**
+                 * Gets or sets outlineColor of the text to display
+                 */
+                set: function (value) {
+                    if (this._outlineColor === value) {
+                        return;
+                    }
+                    this._outlineColor = value;
+                    this._markAsDirty();
+                },
+                enumerable: true,
+                configurable: true
+            });
             TextBlock.prototype._getTypeName = function () {
                 return "TextBlock";
             };
@@ -3406,6 +3448,9 @@ var BABYLON;
                     context.shadowOffsetX = this.shadowOffsetX;
                     context.shadowOffsetY = this.shadowOffsetY;
                 }
+                if (this.outlineWidth) {
+                    context.strokeText(text, this._currentMeasure.left + x, y);
+                }
                 context.fillText(text, this._currentMeasure.left + x, y);
             };
             /** @ignore */
@@ -3418,6 +3463,13 @@ var BABYLON;
                 }
                 context.restore();
             };
+            TextBlock.prototype._applyStates = function (context) {
+                _super.prototype._applyStates.call(this, context);
+                if (this.outlineWidth) {
+                    context.lineWidth = this.outlineWidth;
+                    context.strokeStyle = this.outlineColor;
+                }
+            };
             TextBlock.prototype._additionalProcessing = function (parentMeasure, context) {
                 this._lines = [];
                 var _lines = this.text.split("\n");

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

@@ -549,6 +549,8 @@ declare module BABYLON.GUI {
         private _lines;
         private _resizeToFit;
         private _lineSpacing;
+        private _outlineWidth;
+        private _outlineColor;
         /**
         * An event triggered after the text is changed
         * @type {BABYLON.Observable}
@@ -606,6 +608,20 @@ declare module BABYLON.GUI {
          */
         lineSpacing: string | number;
         /**
+         * Gets or sets outlineWidth of the text to display
+         */
+        /**
+         * Gets or sets outlineWidth of the text to display
+         */
+        outlineWidth: number;
+        /**
+         * Gets or sets outlineColor of the text to display
+         */
+        /**
+         * Gets or sets outlineColor of the text to display
+         */
+        outlineColor: string;
+        /**
          * Creates a new TextBlock object
          * @param name defines the name of the control
          * @param text defines the text to display (emptry string by default)
@@ -619,6 +635,7 @@ declare module BABYLON.GUI {
         private _drawText(text, textWidth, y, context);
         /** @ignore */
         _draw(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
+        protected _applyStates(context: CanvasRenderingContext2D): void;
         protected _additionalProcessing(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
         protected _parseLine(line: string | undefined, context: CanvasRenderingContext2D): object;
         protected _parseLineWithTextWrapping(line: string | undefined, context: CanvasRenderingContext2D): object;

dist/preview release/typedocValidationBaseline.json

@@ -1,7 +1,7 @@
 {
-  "errors": 7341,
+  "errors": 7267,
   "babylon.typedoc.json": {
-    "errors": 7341,
+    "errors": 7267,
     "AnimationKeyInterpolation": {
       "Enumeration": {
         "Comments": {
@@ -334,11 +334,6 @@
             "MissingText": true
           }
         },
-        "_isDisposed": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
         "_lightSources": {
           "Comments": {
             "MissingText": true
@@ -1195,11 +1190,6 @@
             }
           }
         },
-        "isDisposed": {
-          "Comments": {
-            "MissingReturn": true
-          }
-        },
         "isInFrustum": {
           "Comments": {
             "MissingReturn": true
@@ -20141,418 +20131,6 @@
         }
       }
     },
-    "Node": {
-      "Constructor": {
-        "new Node": {
-          "Comments": {
-            "MissingText": true,
-            "MissingReturn": true
-          },
-          "Parameter": {
-            "scene": {
-              "Comments": {
-                "MissingText": true
-              }
-            }
-          }
-        }
-      },
-      "Property": {
-        "_cache": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "_currentRenderId": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "_waitingParentId": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "animations": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "behaviors": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "doNotSerialize": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "id": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "metadata": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "name": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "onDispose": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "onReady": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "parent": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "state": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "uniqueId": {
-          "Comments": {
-            "MissingText": true
-          }
-        }
-      },
-      "Method": {
-        "_getDescendants": {
-          "Parameter": {
-            "predicate": {
-              "Comments": {
-                "MissingText": true
-              }
-            }
-          }
-        },
-        "_initCache": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "_isSynchronized": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "_markSyncedWithParent": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "_setReady": {
-          "Comments": {
-            "MissingText": true
-          },
-          "Parameter": {
-            "state": {
-              "Comments": {
-                "MissingText": true
-              }
-            }
-          }
-        },
-        "_updateCache": {
-          "Comments": {
-            "MissingText": true
-          },
-          "Parameter": {
-            "ignoreParentClass": {
-              "Comments": {
-                "MissingText": true
-              }
-            }
-          }
-        },
-        "addBehavior": {
-          "Comments": {
-            "MissingText": true
-          },
-          "Parameter": {
-            "behavior": {
-              "Comments": {
-                "MissingText": true
-              }
-            }
-          }
-        },
-        "computeWorldMatrix": {
-          "Comments": {
-            "MissingText": true
-          },
-          "Parameter": {
-            "force": {
-              "Comments": {
-                "MissingText": true
-              }
-            }
-          }
-        },
-        "createAnimationRange": {
-          "Comments": {
-            "MissingText": true
-          },
-          "Parameter": {
-            "name": {
-              "Comments": {
-                "MissingText": true
-              }
-            },
-            "from": {
-              "Comments": {
-                "MissingText": true
-              }
-            },
-            "to": {
-              "Comments": {
-                "MissingText": true
-              }
-            }
-          }
-        },
-        "deleteAnimationRange": {
-          "Comments": {
-            "MissingText": true
-          },
-          "Parameter": {
-            "name": {
-              "Comments": {
-                "MissingText": true
-              }
-            },
-            "deleteFrames": {
-              "Comments": {
-                "MissingText": true
-              }
-            }
-          }
-        },
-        "dispose": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "getAnimationByName": {
-          "Comments": {
-            "MissingText": true
-          },
-          "Parameter": {
-            "name": {
-              "Comments": {
-                "MissingText": true
-              }
-            }
-          }
-        },
-        "getAnimationRange": {
-          "Comments": {
-            "MissingText": true
-          },
-          "Parameter": {
-            "name": {
-              "Comments": {
-                "MissingText": true
-              }
-            }
-          }
-        },
-        "getBehaviorByName": {
-          "Comments": {
-            "MissingText": true
-          },
-          "Parameter": {
-            "name": {
-              "Comments": {
-                "MissingText": true
-              }
-            }
-          }
-        },
-        "getChildMeshes": {
-          "Comments": {
-            "MissingReturn": true
-          },
-          "Parameter": {
-            "directDescendantsOnly": {
-              "Comments": {
-                "MissingText": true
-              }
-            },
-            "predicate": {
-              "Comments": {
-                "MissingText": true
-              }
-            }
-          }
-        },
-        "getChildTransformNodes": {
-          "Comments": {
-            "MissingReturn": true
-          },
-          "Parameter": {
-            "directDescendantsOnly": {
-              "Comments": {
-                "MissingText": true
-              }
-            },
-            "predicate": {
-              "Comments": {
-                "MissingText": true
-              }
-            }
-          }
-        },
-        "getChildren": {
-          "Comments": {
-            "MissingReturn": true
-          },
-          "Parameter": {
-            "predicate": {
-              "Comments": {
-                "MissingText": true
-              }
-            }
-          }
-        },
-        "getClassName": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "getDescendants": {
-          "Parameter": {
-            "predicate": {
-              "Comments": {
-                "MissingText": true
-              }
-            }
-          }
-        },
-        "getEngine": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "getScene": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "getWorldMatrix": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "hasNewParent": {
-          "Comments": {
-            "MissingText": true
-          },
-          "Parameter": {
-            "update": {
-              "Comments": {
-                "MissingText": true
-              }
-            }
-          }
-        },
-        "isDescendantOf": {
-          "Comments": {
-            "MissingReturn": true
-          }
-        },
-        "isEnabled": {
-          "Parameter": {
-            "checkAncestors": {
-              "Comments": {
-                "MissingText": true
-              }
-            }
-          }
-        },
-        "isSynchronized": {
-          "Comments": {
-            "MissingText": true
-          },
-          "Parameter": {
-            "updateCache": {
-              "Comments": {
-                "MissingText": true
-              }
-            }
-          }
-        },
-        "isSynchronizedWithParent": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "removeBehavior": {
-          "Comments": {
-            "MissingText": true
-          },
-          "Parameter": {
-            "behavior": {
-              "Comments": {
-                "MissingText": true
-              }
-            }
-          }
-        },
-        "serializeAnimationRanges": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "updateCache": {
-          "Comments": {
-            "MissingText": true
-          },
-          "Parameter": {
-            "force": {
-              "Comments": {
-                "MissingText": true
-              }
-            }
-          }
-        },
-        "ParseAnimationRanges": {
-          "Comments": {
-            "MissingText": true
-          },
-          "Parameter": {
-            "node": {
-              "Comments": {
-                "MissingText": true
-              }
-            },
-            "parsedNode": {
-              "Comments": {
-                "MissingText": true
-              }
-            },
-            "scene": {
-              "Comments": {
-                "MissingText": true
-              }
-            }
-          }
-        }
-      }
-    },
     "NullEngineOptions": {
       "Class": {
         "Comments": {

src/Mesh/babylon.abstractMesh.ts

@@ -412,7 +412,6 @@
         public _masterMesh: Nullable<AbstractMesh>;
 
         public _boundingInfo: Nullable<BoundingInfo>;
-        public _isDisposed = false;
         public _renderId = 0;
 
         public subMeshes: SubMesh[];
@@ -467,13 +466,6 @@
         }
 
         /**
-         * Boolean : true if the mesh has been disposed.  
-         */
-        public isDisposed(): boolean {
-            return this._isDisposed;
-        }
-
-        /**
          * Returns the string "AbstractMesh"
          */
         public getClassName(): string {
@@ -1456,8 +1448,6 @@
             this.onCollideObservable.clear();
             this.onCollisionPositionChangeObservable.clear();
 
-            this._isDisposed = true;
-
             super.dispose(doNotRecurse);
         }
 

src/babylon.node.ts

@@ -4,41 +4,82 @@
      * Node is the basic class for all scene objects (Mesh, Light Camera).
      */
     export class Node {
+        /**
+         * Gets or sets the name of the node
+         */
         @serialize()
         public name: string;
 
+        /**
+         * Gets or sets the id of the node
+         */
         @serialize()
         public id: string;
 
+        /**
+         * Gets or sets the unique id of the node
+         */
         @serialize()
         public uniqueId: number;
 
+        /**
+         * Gets or sets a string used to store user defined state for the node
+         */
         @serialize()
         public state = "";
 
+        /**
+         * Gets or sets an object used to store user defined information for the node
+         */
         @serialize()
         public metadata: any = null;
 
+        /**
+         * Gets or sets a boolean used to define if the node must be serialized
+         */
         public doNotSerialize = false;
+        
+        /** @ignore */
+        public _isDisposed = false;        
 
+        /**
+         * Gets a list of {BABYLON.Animation} associated with the node
+         */
         public animations = new Array<Animation>();
         private _ranges: { [name: string]: Nullable<AnimationRange> } = {};
 
+        /**
+         * Callback raised when the node is ready to be used
+         */
         public onReady: (node: Node) => void;
 
         private _isEnabled = true;
         private _isReady = true;
+        /** @ignore */
         public _currentRenderId = -1;
         private _parentRenderId = -1;
 
+        /** @ignore */
         public _waitingParentId: Nullable<string>;
 
         private _scene: Scene;
+        /** @ignore */
         public _cache: any;
 
         private _parentNode: Nullable<Node>;
         private _children: Node[];
 
+        /**
+         * Gets a boolean indicating if the node has been disposed
+         * @returns true if the node was disposed
+         */
+        public isDisposed(): boolean {
+            return this._isDisposed;
+        }        
+
+        /**
+         * Gets or sets the parent of the node
+         */
         public set parent(parent: Nullable<Node>) {
             if (this._parentNode === parent) {
                 return;
@@ -68,17 +109,24 @@
             return this._parentNode;
         }
 
+        /**
+         * Gets a string idenfifying the name of the class
+         * @returns "Node" string
+         */
         public getClassName(): string {
             return "Node";
         }
 
         /**
-        * An event triggered when the mesh is disposed.
+        * An event triggered when the mesh is disposed
         * @type {BABYLON.Observable}
         */
         public onDisposeObservable = new Observable<Node>();
 
         private _onDisposeObserver: Nullable<Observer<Node>>;
+        /**
+         * Sets a callback that will be raised when the node will be disposed
+         */
         public set onDispose(callback: () => void) {
             if (this._onDisposeObserver) {
                 this.onDisposeObservable.remove(this._onDisposeObserver);
@@ -87,7 +135,7 @@
         }
 
         /**
-         * @constructor
+         * Creates a new Node
          * @param {string} name - the name and id to be given to this node
          * @param {BABYLON.Scene} the scene this node will be added to
          */
@@ -99,10 +147,18 @@
             this._initCache();
         }
 
+        /**
+         * Gets the scene of the node
+         * @returns a {BABYLON.Scene}
+         */
         public getScene(): Scene {
             return this._scene;
         }
 
+        /**
+         * Gets the engine of the node
+         * @returns a {BABYLON.Engine}
+         */
         public getEngine(): Engine {
             return this._scene.getEngine();
         }
@@ -110,6 +166,12 @@
         // Behaviors
         private _behaviors = new Array<Behavior<Node>>();
 
+        /**
+         * Attach a behavior to the node
+         * @see http://doc.babylonjs.com/features/behaviour
+         * @param behavior defines the behavior to attach
+         * @returns the current Node
+         */
         public addBehavior(behavior: Behavior<Node>): Node {
             var index = this._behaviors.indexOf(behavior);
 
@@ -135,6 +197,12 @@
             return this;
         }
 
+        /**
+         * Remove an attached behavior
+         * @see http://doc.babylonjs.com/features/behaviour
+         * @param behavior defines the behavior to attach
+         * @returns the current Node
+         */
         public removeBehavior(behavior: Behavior<Node>): Node {
             var index = this._behaviors.indexOf(behavior);
 
@@ -148,10 +216,20 @@
             return this;
         }
 
+        /**
+         * Gets the list of attached behaviors
+         * @see http://doc.babylonjs.com/features/behaviour
+         */
         public get behaviors(): Behavior<Node>[] {
             return this._behaviors;
         }
 
+        /**
+         * Gets an attached behavior by name
+         * @param name defines the name of the behavior to look for
+         * @see http://doc.babylonjs.com/features/behaviour
+         * @returns null if behavior was not found else the requested behavior
+         */
         public getBehaviorByName(name: string): Nullable<Behavior<Node>> {
             for (var behavior of this._behaviors) {
                 if (behavior.name === name) {
@@ -162,18 +240,23 @@
             return null;
         }
 
-        // override it in derived class
+        /**
+         * Returns the world matrix of the node
+         * @returns a matrix containing the node's world matrix
+         */
         public getWorldMatrix(): Matrix {
             return Matrix.Identity();
         }
 
         // override it in derived class if you add new variables to the cache
         // and call the parent class method
+        /** @ignore */
         public _initCache() {
             this._cache = {};
             this._cache.parent = undefined;
         }
 
+        /** @ignore */
         public updateCache(force?: boolean): void {
             if (!force && this.isSynchronized())
                 return;
@@ -185,20 +268,24 @@
 
         // override it in derived class if you add new variables to the cache
         // and call the parent class method if !ignoreParentClass
+        /** @ignore */
         public _updateCache(ignoreParentClass?: boolean): void {
         }
 
         // override it in derived class if you add new variables to the cache
+        /** @ignore */
         public _isSynchronized(): boolean {
             return true;
         }
 
+        /** @ignore */
         public _markSyncedWithParent() {
             if (this.parent) {
                 this._parentRenderId = this.parent._currentRenderId;
             }
         }
 
+        /** @ignore */
         public isSynchronizedWithParent(): boolean {
             if (!this.parent) {
                 return true;
@@ -211,6 +298,7 @@
             return this.parent.isSynchronized();
         }
 
+        /** @ignore */
         public isSynchronized(updateCache?: boolean): boolean {
             var check = this.hasNewParent();
 
@@ -224,6 +312,7 @@
             return !check;
         }
 
+        /** @ignore */
         public hasNewParent(update?: boolean): boolean {
             if (this._cache.parent === this.parent)
                 return false;
@@ -236,17 +325,17 @@
 
         /**
          * Is this node ready to be used/rendered
-         * @return {boolean} is it ready
+         * @return true if the node is ready
          */
         public isReady(): boolean {
             return this._isReady;
         }
 
         /**
-         * Is this node enabled. 
-         * If the node has a parent, all ancestors will be checked and false will be returned if any are false (not enabled), otherwise will return true.
-         * @param {boolean} [checkAncestors=true] - Indicates if this method should check the ancestors. The default is to check the ancestors. If set to false, the method will return the value of this node without checking ancestors.
-         * @return {boolean} whether this node (and its parent) is enabled.
+         * Is this node enabled?
+         * If the node has a parent, all ancestors will be checked and false will be returned if any are false (not enabled), otherwise will return true
+         * @param checkAncestors indicates if this method should check the ancestors. The default is to check the ancestors. If set to false, the method will return the value of this node without checking ancestors
+         * @return whether this node (and its parent) is enabled
          * @see setEnabled
          */
         public isEnabled(checkAncestors: boolean = true): boolean {
@@ -266,8 +355,8 @@
         }
 
         /**
-         * Set the enabled state of this node.
-         * @param {boolean} value - the new enabled state
+         * Set the enabled state of this node
+         * @param value defines the new enabled state
          * @see isEnabled
          */
         public setEnabled(value: boolean): void {
@@ -275,10 +364,11 @@
         }
 
         /**
-         * Is this node a descendant of the given node.
-         * The function will iterate up the hierarchy until the ancestor was found or no more parents defined.
-         * @param {BABYLON.Node} ancestor - The parent node to inspect
+         * Is this node a descendant of the given node?
+         * The function will iterate up the hierarchy until the ancestor was found or no more parents defined
+         * @param ancestor defines the parent node to inspect
          * @see parent
+         * @returns a boolean indicating if this node is a descendant of the given node
          */
         public isDescendantOf(ancestor: Node): boolean {
             if (this.parent) {
@@ -291,12 +381,7 @@
             return false;
         }
 
-        /**
-         * Evaluate the list of children and determine if they should be considered as descendants considering the given criterias
-         * @param {BABYLON.Node[]} results the result array containing the nodes matching the given criterias
-         * @param {boolean} directDescendantsOnly if true only direct descendants of 'this' will be considered, if false direct and also indirect (children of children, an so on in a recursive manner) descendants of 'this' will be considered.
-         * @param predicate: an optional predicate that will be called on every evaluated children, the predicate must return true for a given child to be part of the result, otherwise it will be ignored.
-         */
+        /** @ignore */
         public _getDescendants(results: Node[], directDescendantsOnly: boolean = false, predicate?: (node: Node) => boolean): void {
             if (!this._children) {
                 return;
@@ -316,10 +401,10 @@
         }
 
         /**
-         * Will return all nodes that have this node as ascendant.
-         * @param {boolean} directDescendantsOnly if true only direct descendants of 'this' will be considered, if false direct and also indirect (children of children, an so on in a recursive manner) descendants of 'this' will be considered.
-         * @param predicate: an optional predicate that will be called on every evaluated children, the predicate must return true for a given child to be part of the result, otherwise it will be ignored.
-         * @return {BABYLON.Node[]} all children nodes of all types.
+         * Will return all nodes that have this node as ascendant
+         * @param directDescendantsOnly defines if true only direct descendants of 'this' will be considered, if false direct and also indirect (children of children, an so on in a recursive manner) descendants of 'this' will be considered
+         * @param predicate defines an optional predicate that will be called on every evaluated child, the predicate must return true for a given child to be part of the result, otherwise it will be ignored
+         * @return all children nodes of all types
          */
         public getDescendants(directDescendantsOnly?: boolean, predicate?: (node: Node) => boolean): Node[] {
             var results = new Array<Node>();
@@ -330,7 +415,10 @@
         }
 
         /**
-         * Get all child-meshes of this node.
+         * Get all child-meshes of this node
+         * @param directDescendantsOnly defines if true only direct descendants of 'this' will be considered, if false direct and also indirect (children of children, an so on in a recursive manner) descendants of 'this' will be considered
+         * @param predicate defines an optional predicate that will be called on every evaluated child, the predicate must return true for a given child to be part of the result, otherwise it will be ignored
+         * @returns an array of {BABYLON.AbstractMesh}
          */
         public getChildMeshes(directDescendantsOnly?: boolean, predicate?: (node: Node) => boolean): AbstractMesh[] {
             var results: Array<AbstractMesh> = [];
@@ -341,7 +429,10 @@
         }
 
         /**
-         * Get all child-transformNodes of this node.
+         * Get all child-transformNodes of this node
+         * @param directDescendantsOnly defines if true only direct descendants of 'this' will be considered, if false direct and also indirect (children of children, an so on in a recursive manner) descendants of 'this' will be considered
+         * @param predicate defines an optional predicate that will be called on every evaluated child, the predicate must return true for a given child to be part of the result, otherwise it will be ignored
+         * @returns an array of {BABYLON.TransformNode}
          */
         public getChildTransformNodes(directDescendantsOnly?: boolean, predicate?: (node: Node) => boolean): TransformNode[] {
             var results: Array<TransformNode> = [];
@@ -352,12 +443,15 @@
         }
 
         /**
-         * Get all direct children of this node.
-        */
+         * Get all direct children of this node
+         * @param predicate defines an optional predicate that will be called on every evaluated child, the predicate must return true for a given child to be part of the result, otherwise it will be ignored
+         * @returns an array of {BABYLON.Node}
+         */
         public getChildren(predicate?: (node: Node) => boolean): Node[] {
             return this.getDescendants(true, predicate);
         }
 
+        /** @ignore */
         public _setReady(state: boolean): void {
             if (state === this._isReady) {
                 return;
@@ -374,6 +468,11 @@
             }
         }
 
+        /**
+         * Get an animation by name
+         * @param name defines the name of the animation to look for
+         * @returns null if not found else the requested animation
+         */
         public getAnimationByName(name: string): Nullable<Animation> {
             for (var i = 0; i < this.animations.length; i++) {
                 var animation = this.animations[i];
@@ -386,6 +485,12 @@
             return null;
         }
 
+        /**
+         * Creates an animation range for this node
+         * @param name defines the name of the range
+         * @param from defines the starting key
+         * @param to defines the end key
+         */
         public createAnimationRange(name: string, from: number, to: number): void {
             // check name not already in use
             if (!this._ranges[name]) {
@@ -398,6 +503,11 @@
             }
         }
 
+        /**
+         * Delete a specific animation range
+         * @param name defines the name of the range to delete
+         * @param deleteFrames defines if animation frames from the range must be deleted as well
+         */
         public deleteAnimationRange(name: string, deleteFrames = true): void {
             for (var i = 0, nAnimations = this.animations.length; i < nAnimations; i++) {
                 if (this.animations[i]) {
@@ -407,6 +517,11 @@
             this._ranges[name] = null; // said much faster than 'delete this._range[name]' 
         }
 
+        /**
+         * Get an animation range by name
+         * @param name defines the name of the animation range to look for
+         * @returns null if not found else the requested animation range
+         */
         public getAnimationRange(name: string): Nullable<AnimationRange> {
             return this._ranges[name];
         }
@@ -417,7 +532,7 @@
          * @param loop defines if the animation should loop (false by default)
          * @param speedRatio defines the speed factor in which to run the animation (1 by default)
          * @param onAnimationEnd defines a function to be executed when the animation ended (undefined by default)
-         * @returns the {BABYLON.Animatable} object created for this animation. If range does not exist, it will return null
+         * @returns the object created for this animation. If range does not exist, it will return null
          */
         public beginAnimation(name: string, loop?: boolean, speedRatio?: number, onAnimationEnd?: () => void): Nullable<Animatable> {
             var range = this.getAnimationRange(name);
@@ -429,6 +544,10 @@
             return this._scene.beginAnimation(this, range.from, range.to, loop, speedRatio, onAnimationEnd);
         }
 
+        /**
+         * Serialize animation ranges into a JSON compatible object
+         * @returns serialization object
+         */
         public serializeAnimationRanges(): any {
             var serializationRanges = [];
             for (var name in this._ranges) {
@@ -445,11 +564,18 @@
             return serializationRanges;
         }
 
-        // override it in derived class
+        /**
+         * Computes the world matrix of the node
+         * @param force defines if the cache version should be invalidated forcing the world matrix to be created from scratch
+         * @returns the world matrix
+         */
         public computeWorldMatrix(force?: boolean): Matrix {
             return Matrix.Identity();
         }
 
+        /**
+         * Releases all associated resources
+         */
         public dispose(): void {
             this.parent = null;
 
@@ -463,8 +589,15 @@
             }
 
             this._behaviors = [];
+            this._isDisposed = true;            
         }
 
+        /**
+         * Parse animation range data from a serialization object and store them into a given node
+         * @param node defines where to store the animation ranges
+         * @param parsedNode defines the serialization object to read data from
+         * @param scene defines the hosting scene
+         */
         public static ParseAnimationRanges(node: Node, parsedNode: any, scene: Scene): void {
             if (parsedNode.ranges) {
                 for (var index = 0; index < parsedNode.ranges.length; index++) {