More code comments

dist/preview release/typedocValidationBaseline.json

@@ -2,587 +2,7 @@
   "errors": 4590,
   "babylon.typedoc.json": {
     "errors": 4590,
-    "Action": {
-      "Property": {
-        "triggerOptions": {
-          "Comments": {
-            "MissingText": true
-          }
-        }
-      },
-      "Method": {
-        "then": {
-          "Parameter": {
-            "action": {
-              "Comments": {
-                "MissingText": true
-              }
-            }
-          }
-        }
-      }
-    },
-    "ActionEvent": {
-      "Constructor": {
-        "new ActionEvent": {
-          "Comments": {
-            "MissingText": true,
-            "MissingReturn": true
-          },
-          "Parameter": {
-            "additionalData": {
-              "Comments": {
-                "MissingText": true
-              }
-            }
-          }
-        }
-      },
-      "Property": {
-        "additionalData": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "meshUnderPointer": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "pointerX": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "pointerY": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "source": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "sourceEvent": {
-          "Comments": {
-            "MissingText": true
-          }
-        }
-      },
-      "Method": {
-        "CreateNew": {
-          "Comments": {
-            "MissingReturn": true
-          },
-          "Parameter": {
-            "additionalData": {
-              "Comments": {
-                "MissingText": true
-              }
-            }
-          }
-        },
-        "CreateNewFromPrimitive": {
-          "Comments": {
-            "MissingText": true
-          },
-          "Parameter": {
-            "prim": {
-              "Comments": {
-                "MissingText": true
-              }
-            },
-            "pointerPos": {
-              "Comments": {
-                "MissingText": true
-              }
-            },
-            "evt": {
-              "Comments": {
-                "MissingText": true
-              }
-            },
-            "additionalData": {
-              "Comments": {
-                "MissingText": true
-              }
-            }
-          }
-        },
-        "CreateNewFromScene": {
-          "Comments": {
-            "MissingReturn": true
-          }
-        },
-        "CreateNewFromSprite": {
-          "Comments": {
-            "MissingReturn": true
-          },
-          "Parameter": {
-            "additionalData": {
-              "Comments": {
-                "MissingText": true
-              }
-            }
-          }
-        }
-      }
-    },
-    "ActionManager": {
-      "Constructor": {
-        "new ActionManager": {
-          "Comments": {
-            "MissingText": true
-          },
-          "Parameter": {
-            "scene": {
-              "Comments": {
-                "MissingText": true
-              }
-            }
-          }
-        }
-      },
-      "Property": {
-        "actions": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "hasPickTriggers": {
-          "Tags": {
-            "returns": true
-          }
-        },
-        "hasPointerTriggers": {
-          "Tags": {
-            "returns": true
-          }
-        },
-        "hoverCursor": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "HasPickTriggers": {
-          "Tags": {
-            "returns": true
-          }
-        },
-        "HasTriggers": {
-          "Tags": {
-            "returns": true
-          }
-        },
-        "NothingTrigger": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "OnCenterPickTrigger": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "OnDoublePickTrigger": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "OnEveryFrameTrigger": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "OnIntersectionEnterTrigger": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "OnIntersectionExitTrigger": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "OnKeyDownTrigger": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "OnKeyUpTrigger": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "OnLeftPickTrigger": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "OnLongPressTrigger": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "OnPickDownTrigger": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "OnPickOutTrigger": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "OnPickTrigger": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "OnPickUpTrigger": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "OnPointerOutTrigger": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "OnPointerOverTrigger": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "OnRightPickTrigger": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "Triggers": {
-          "Comments": {
-            "MissingText": true
-          }
-        }
-      },
-      "Method": {
-        "_getEffectiveTarget": {
-          "Comments": {
-            "MissingText": true
-          },
-          "Parameter": {
-            "target": {
-              "Comments": {
-                "MissingText": true
-              }
-            },
-            "propertyPath": {
-              "Comments": {
-                "MissingText": true
-              }
-            }
-          }
-        },
-        "_getProperty": {
-          "Comments": {
-            "MissingText": true
-          },
-          "Parameter": {
-            "propertyPath": {
-              "Comments": {
-                "MissingText": true
-              }
-            }
-          }
-        },
-        "dispose": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "getScene": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "serialize": {
-          "Comments": {
-            "MissingText": true
-          },
-          "Parameter": {
-            "name": {
-              "Comments": {
-                "MissingText": true
-              }
-            }
-          }
-        },
-        "GetTriggerName": {
-          "Comments": {
-            "MissingText": true
-          },
-          "Parameter": {
-            "trigger": {
-              "Comments": {
-                "MissingText": true
-              }
-            }
-          }
-        },
-        "Parse": {
-          "Comments": {
-            "MissingText": true
-          },
-          "Parameter": {
-            "parsedActions": {
-              "Comments": {
-                "MissingText": true
-              }
-            },
-            "object": {
-              "Comments": {
-                "MissingText": true
-              }
-            },
-            "scene": {
-              "Comments": {
-                "MissingText": true
-              }
-            }
-          }
-        }
-      }
-    },
-    "AnaglyphArcRotateCamera": {
-      "Class": {
-        "Comments": {
-          "MissingText": true
-        }
-      }
-    },
-    "AnaglyphFreeCamera": {
-      "Class": {
-        "Comments": {
-          "MissingText": true
-        }
-      }
-    },
-    "AnaglyphGamepadCamera": {
-      "Class": {
-        "Comments": {
-          "MissingText": true
-        }
-      }
-    },
-    "AnaglyphPostProcess": {
-      "Class": {
-        "Comments": {
-          "MissingText": true
-        }
-      }
-    },
-    "AnaglyphUniversalCamera": {
-      "Class": {
-        "Comments": {
-          "MissingText": true
-        }
-      }
-    },
-    "Analyser": {
-      "Class": {
-        "Comments": {
-          "MissingText": true
-        }
-      },
-      "Constructor": {
-        "new Analyser": {
-          "Comments": {
-            "MissingText": true
-          },
-          "Parameter": {
-            "scene": {
-              "Comments": {
-                "MissingText": true
-              }
-            }
-          }
-        }
-      },
-      "Property": {
-        "BARGRAPHAMPLITUDE": {
-          "Naming": {
-            "NotCamelCase": true
-          },
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "DEBUGCANVASPOS": {
-          "Naming": {
-            "NotCamelCase": true
-          },
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "DEBUGCANVASSIZE": {
-          "Naming": {
-            "NotCamelCase": true
-          },
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "FFT_SIZE": {
-          "Naming": {
-            "NotCamelCase": true
-          },
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "SMOOTHING": {
-          "Naming": {
-            "NotCamelCase": true
-          },
-          "Comments": {
-            "MissingText": true
-          }
-        }
-      },
-      "Method": {
-        "connectAudioNodes": {
-          "Comments": {
-            "MissingText": true
-          },
-          "Parameter": {
-            "inputAudioNode": {
-              "Comments": {
-                "MissingText": true
-              }
-            },
-            "outputAudioNode": {
-              "Comments": {
-                "MissingText": true
-              }
-            }
-          }
-        },
-        "dispose": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "drawDebugCanvas": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "getByteFrequencyData": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "getByteTimeDomainData": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "getFloatFrequencyData": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "getFrequencyBinCount": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "stopDebugCanvas": {
-          "Comments": {
-            "MissingText": true
-          }
-        }
-      }
-    },
-    "AndOrNotEvaluator": {
-      "Class": {
-        "Comments": {
-          "MissingText": true
-        }
-      },
-      "Method": {
-        "Eval": {
-          "Comments": {
-            "MissingText": true
-          },
-          "Parameter": {
-            "query": {
-              "Comments": {
-                "MissingText": true
-              }
-            },
-            "evaluateCallback": {
-              "Comments": {
-                "MissingText": true
-              }
-            }
-          }
-        }
-      }
-    },
-    "Angle": {
-      "Class": {
-        "Comments": {
-          "MissingText": true
-        }
-      },
-      "Method": {
-        "BetweenTwoPoints": {
-          "Comments": {
-            "MissingReturn": true
-          },
-          "Parameter": {
-            "a": {
-              "Comments": {
-                "MissingText": true
-              }
-            },
-            "b": {
-              "Comments": {
-                "MissingText": true
-              }
-            }
-          }
-        },
-        "FromDegrees": {
-          "Comments": {
-            "MissingReturn": true
-          },
-          "Parameter": {
-            "degrees": {
-              "Comments": {
-                "MissingText": true
-              }
-            }
-          }
-        },
-        "FromRadians": {
-          "Comments": {
-            "MissingReturn": true
-          },
-          "Parameter": {
-            "radians": {
-              "Comments": {
-                "MissingText": true
-              }
-            }
-          }
-        }
-      }
-    },
-    "Animatable": {
+     "Animatable": {
       "Class": {
         "Comments": {
           "MissingText": true
@@ -18675,27 +18095,6 @@
         }
       }
     },
-    "StereoscopicArcRotateCamera": {
-      "Class": {
-        "Comments": {
-          "MissingText": true
-        }
-      }
-    },
-    "StereoscopicFreeCamera": {
-      "Class": {
-        "Comments": {
-          "MissingText": true
-        }
-      }
-    },
-    "StereoscopicGamepadCamera": {
-      "Class": {
-        "Comments": {
-          "MissingText": true
-        }
-      }
-    },
     "StereoscopicInterlacePostProcess": {
       "Class": {
         "Comments": {
@@ -18703,13 +18102,6 @@
         }
       }
     },
-    "StereoscopicUniversalCamera": {
-      "Class": {
-        "Comments": {
-          "MissingText": true
-        }
-      }
-    },
     "StickValues": {
       "Class": {
         "Comments": {

src/Actions/babylon.action.ts

@@ -30,7 +30,9 @@
          * @param triggerOptions the trigger, with or without parameters, for the action
          * @param condition an optional determinant of action 
          */
-        constructor(public triggerOptions: any, condition?: Condition) {
+        constructor(
+            /** the trigger, with or without parameters, for the action */
+            public triggerOptions: any, condition?: Condition) {
 
             if (triggerOptions.parameter) {
                 this.trigger = triggerOptions.trigger;
@@ -116,7 +118,7 @@
 
         /**
          * Adds action to chain of actions, may be a DoNothingAction
-         * @param index The index of the attribute.
+         * @param action defines the next action to execute
          * @returns The action passed in
          * @see https://www.babylonjs-playground.com/#1T30HR#0
          */

src/Actions/babylon.actionManager.ts

@@ -5,20 +5,36 @@
      */
     export class ActionEvent {
         /**
-         * @param source The mesh or sprite that triggered the action.
+         * Creates a new ActionEvent
+         * @param source The mesh or sprite that triggered the action
          * @param pointerX The X mouse cursor position at the time of the event
          * @param pointerY The Y mouse cursor position at the time of the event
          * @param meshUnderPointer The mesh that is currently pointed at (can be null)
          * @param sourceEvent the original (browser) event that triggered the ActionEvent
+         * @param additionalData additional data for the event
          */
-        constructor(public source: any, public pointerX: number, public pointerY: number, public meshUnderPointer: Nullable<AbstractMesh>, public sourceEvent?: any, public additionalData?: any) {
+        constructor(
+            /** The mesh or sprite that triggered the action */
+            public source: any, 
+            /** The X mouse cursor position at the time of the event */
+            public pointerX: number, 
+            /** The Y mouse cursor position at the time of the event */
+            public pointerY: number, 
+            /** The mesh that is currently pointed at (can be null) */
+            public meshUnderPointer: Nullable<AbstractMesh>, 
+            /** the original (browser) event that triggered the ActionEvent */
+            public sourceEvent?: any, 
+            /** additional data for the event */
+            public additionalData?: any) {
 
         }
 
         /**
          * Helper function to auto-create an ActionEvent from a source mesh.
          * @param source The source mesh that triggered the event
-         * @param evt {Event} The original (browser) event
+         * @param evt The original (browser) event
+         * @param additionalData additional data for the event
+         * @returns the new ActionEvent
          */
         public static CreateNew(source: AbstractMesh, evt?: Event, additionalData?: any): ActionEvent {
             var scene = source.getScene();
@@ -26,10 +42,12 @@
         }
 
         /**
-         * Helper function to auto-create an ActionEvent from a source mesh.
+         * Helper function to auto-create an ActionEvent from a source sprite
          * @param source The source sprite that triggered the event
          * @param scene Scene associated with the sprite
-         * @param evt {Event} The original (browser) event
+         * @param evt The original (browser) event
+         * @param additionalData additional data for the event
+         * @returns the new ActionEvent
          */
         public static CreateNewFromSprite(source: Sprite, scene: Scene, evt?: Event, additionalData?: any): ActionEvent {
             return new ActionEvent(source, scene.pointerX, scene.pointerY, scene.meshUnderPointer, evt, additionalData);
@@ -38,12 +56,21 @@
         /**
          * Helper function to auto-create an ActionEvent from a scene. If triggered by a mesh use ActionEvent.CreateNew
          * @param scene the scene where the event occurred
-         * @param evt {Event} The original (browser) event
+         * @param evt The original (browser) event
+         * @returns the new ActionEvent
          */
         public static CreateNewFromScene(scene: Scene, evt: Event): ActionEvent {
             return new ActionEvent(null, scene.pointerX, scene.pointerY, scene.meshUnderPointer, evt);
         }
 
+        /**
+         * Helper function to auto-create an ActionEvent from a primitive
+         * @param prim defines the target primitive
+         * @param pointerPos defines the pointer position
+         * @param evt The original (browser) event
+         * @param additionalData additional data for the event
+         * @returns the new ActionEvent
+         */
         public static CreateNewFromPrimitive(prim: any, pointerPos: Vector2, evt?: Event, additionalData?: any): ActionEvent {
             return new ActionEvent(prim, pointerPos.x, pointerPos.y, null, evt, additionalData);
         }
@@ -52,6 +79,7 @@
     /**
      * Action Manager manages all events to be triggered on a given mesh or the global scene.
      * A single scene can have many Action Managers to handle predefined actions on specific meshes.
+     * @see http://doc.babylonjs.com/how_to/how_to_use_actions
      */
     export class ActionManager {
         // Statics
@@ -73,84 +101,159 @@
         private static _OnKeyUpTrigger = 15;
         private static _OnPickOutTrigger = 16;
 
+        /**
+         * Nothing
+         * @see http://doc.babylonjs.com/how_to/how_to_use_actions#triggers
+         */
         public static get NothingTrigger(): number {
             return ActionManager._NothingTrigger;
         }
 
+        /** 
+         * On pick 
+         * @see http://doc.babylonjs.com/how_to/how_to_use_actions#triggers
+         */
         public static get OnPickTrigger(): number {
             return ActionManager._OnPickTrigger;
         }
 
+        /** 
+         * On left pick
+         * @see http://doc.babylonjs.com/how_to/how_to_use_actions#triggers
+         */
         public static get OnLeftPickTrigger(): number {
             return ActionManager._OnLeftPickTrigger;
         }
 
+        /** 
+         * On right pick
+         * @see http://doc.babylonjs.com/how_to/how_to_use_actions#triggers
+         */
         public static get OnRightPickTrigger(): number {
             return ActionManager._OnRightPickTrigger;
         }
 
+        /** 
+         * On center pick 
+         * @see http://doc.babylonjs.com/how_to/how_to_use_actions#triggers
+         */
         public static get OnCenterPickTrigger(): number {
             return ActionManager._OnCenterPickTrigger;
         }
 
+        /** 
+         * On pick down
+         * @see http://doc.babylonjs.com/how_to/how_to_use_actions#triggers
+         */
         public static get OnPickDownTrigger(): number {
             return ActionManager._OnPickDownTrigger;
         }
 
+        /** 
+         * On double pick
+         * @see http://doc.babylonjs.com/how_to/how_to_use_actions#triggers
+         */
         public static get OnDoublePickTrigger(): number {
             return ActionManager._OnDoublePickTrigger;
         }
 
+        /** 
+         * On pick up
+         * @see http://doc.babylonjs.com/how_to/how_to_use_actions#triggers
+         */
         public static get OnPickUpTrigger(): number {
             return ActionManager._OnPickUpTrigger;
         }
 
-        /// This trigger will only be raised if you also declared a OnPickDown
+        /**
+         * On pick out.
+         * This trigger will only be raised if you also declared a OnPickDown
+         * @see http://doc.babylonjs.com/how_to/how_to_use_actions#triggers
+         */
         public static get OnPickOutTrigger(): number {
             return ActionManager._OnPickOutTrigger;
         }
 
+        /** 
+         * On long press
+         * @see http://doc.babylonjs.com/how_to/how_to_use_actions#triggers
+         */
         public static get OnLongPressTrigger(): number {
             return ActionManager._OnLongPressTrigger;
         }
 
+        /** 
+         * On pointer over
+         * @see http://doc.babylonjs.com/how_to/how_to_use_actions#triggers
+         */
         public static get OnPointerOverTrigger(): number {
             return ActionManager._OnPointerOverTrigger;
         }
 
+        /** 
+         * On pointer out
+         * @see http://doc.babylonjs.com/how_to/how_to_use_actions#triggers
+         */
         public static get OnPointerOutTrigger(): number {
             return ActionManager._OnPointerOutTrigger;
         }
 
+        /** 
+         * On every frame
+         * @see http://doc.babylonjs.com/how_to/how_to_use_actions#triggers
+         */
         public static get OnEveryFrameTrigger(): number {
             return ActionManager._OnEveryFrameTrigger;
         }
 
+        /** 
+         * On intersection enter
+         * @see http://doc.babylonjs.com/how_to/how_to_use_actions#triggers
+         */
         public static get OnIntersectionEnterTrigger(): number {
             return ActionManager._OnIntersectionEnterTrigger;
         }
 
+        /** 
+         * On intersection exit
+         * @see http://doc.babylonjs.com/how_to/how_to_use_actions#triggers
+         */
         public static get OnIntersectionExitTrigger(): number {
             return ActionManager._OnIntersectionExitTrigger;
         }
 
+        /**
+         * On key down
+         * @see http://doc.babylonjs.com/how_to/how_to_use_actions#triggers
+         */
         public static get OnKeyDownTrigger(): number {
             return ActionManager._OnKeyDownTrigger;
         }
 
+        /**
+         * On key up
+         * @see http://doc.babylonjs.com/how_to/how_to_use_actions#triggers
+         */
         public static get OnKeyUpTrigger(): number {
             return ActionManager._OnKeyUpTrigger;
         }
 
+        /** Gets the list of active triggers */
         public static Triggers: { [key: string]: number } = {};
 
         // Members
+        /** Gets the list of actions */
         public actions = new Array<Action>();
 
+        /** Gets the cursor to use when hovering items */
         public hoverCursor: string = '';
 
         private _scene: Scene;
 
+        /**
+         * Creates a new action manager
+         * @param scene defines the hosting scene
+         */
         constructor(scene: Scene) {
             this._scene = scene || Engine.LastCreatedScene;
 
@@ -158,6 +261,10 @@
         }
 
         // Methods
+
+        /**
+         * Releases all associated resources
+         */
         public dispose(): void {
             var index = this._scene._actionManagers.indexOf(this);
 
@@ -174,14 +281,18 @@
             }
         }
 
+        /** 
+         * Gets hosting scene 
+         * @returns the hosting scene
+         */
         public getScene(): Scene {
             return this._scene;
         }
 
         /**
          * Does this action manager handles actions of any of the given triggers
-         * @param {number[]} triggers - the triggers to be tested
-         * @return {boolean} whether one (or more) of the triggers is handeled 
+         * @param triggers defines the triggers to be tested
+         * @return a boolean indicating whether one (or more) of the triggers is handled 
          */
         public hasSpecificTriggers(triggers: number[]): boolean {
             for (var index = 0; index < this.actions.length; index++) {
@@ -221,7 +332,6 @@
 
         /**
          * Does this action manager has pointer triggers
-         * @return {boolean} whether or not it has pointer triggers
          */
         public get hasPointerTriggers(): boolean {
             for (var index = 0; index < this.actions.length; index++) {
@@ -237,7 +347,6 @@
 
         /**
          * Does this action manager has pick triggers
-         * @return {boolean} whether or not it has pick triggers
          */
         public get hasPickTriggers(): boolean {
             for (var index = 0; index < this.actions.length; index++) {
@@ -253,8 +362,7 @@
 
         /**
          * Does exist one action manager with at least one trigger 
-         * @return {boolean} whether or not it exists one action manager with one trigger
-        **/
+         **/
         public static get HasTriggers(): boolean {
             for (var t in ActionManager.Triggers) {
                 if (ActionManager.Triggers.hasOwnProperty(t)) {
@@ -266,8 +374,7 @@
 
         /**
          * Does exist one action manager with at least one pick trigger 
-         * @return {boolean} whether or not it exists one action manager with one pick trigger
-        **/
+         **/
         public static get HasPickTriggers(): boolean {
             for (var t in ActionManager.Triggers) {
                 if (ActionManager.Triggers.hasOwnProperty(t)) {
@@ -282,8 +389,8 @@
 
         /**
          * Does exist one action manager that handles actions of a given trigger
-         * @param {number} trigger - the trigger to be tested
-         * @return {boolean} whether the trigger is handeled by at least one action manager
+         * @param trigger defines the trigger to be tested
+         * @return a boolean indicating whether the trigger is handeled by at least one action manager
         **/
         public static HasSpecificTrigger(trigger: number): boolean {
             for (var t in ActionManager.Triggers) {
@@ -299,8 +406,8 @@
 
         /**
          * Registers an action to this action manager
-         * @param {BABYLON.Action} action - the action to be registered
-         * @return {BABYLON.Action} the action amended (prepared) after registration
+         * @param action defines the action to be registered
+         * @return the action amended (prepared) after registration
          */
         public registerAction(action: Action): Nullable<Action> {
             if (action.trigger === ActionManager.OnEveryFrameTrigger) {
@@ -327,8 +434,8 @@
 
         /**
          * Unregisters an action to this action manager
-         * @param action The action to be unregistered
-         * @return whether the action has been unregistered
+         * @param action defines the action to be unregistered
+         * @return a boolean indicating whether the action has been unregistered
          */
         public unregisterAction(action: Action): Boolean {
             var index = this.actions.indexOf(action);
@@ -346,8 +453,8 @@
 
         /**
          * Process a specific trigger
-         * @param {number} trigger - the trigger to process
-         * @param evt {BABYLON.ActionEvent} the event details to be processed
+         * @param trigger defines the trigger to process
+         * @param evt defines the event details to be processed
          */
         public processTrigger(trigger: number, evt?: ActionEvent): void {
             for (var index = 0; index < this.actions.length; index++) {
@@ -381,6 +488,7 @@
             }
         }
 
+        /** @hidden */
         public _getEffectiveTarget(target: any, propertyPath: string): any {
             var properties = propertyPath.split(".");
 
@@ -391,12 +499,18 @@
             return target;
         }
 
+        /** @hidden */
         public _getProperty(propertyPath: string): string {
             var properties = propertyPath.split(".");
 
             return properties[properties.length - 1];
         }
 
+        /**
+         * Serialize this manager to a JSON object
+         * @param name defines the property name to store this manager
+         * @returns a JSON representation of this manager
+         */
         public serialize(name: string): any {
             var root = {
                 children: new Array(),
@@ -441,7 +555,13 @@
             return root;
         }
 
-        public static Parse(parsedActions: any, object: Nullable<AbstractMesh>, scene: Scene) {
+        /**
+         * Creates a new ActionManager from a JSON data
+         * @param parsedActions defines the JSON data to read from
+         * @param object defines the hosting mesh
+         * @param scene defines the hosting scene
+         */
+        public static Parse(parsedActions: any, object: Nullable<AbstractMesh>, scene: Scene): void {
             var actionManager = new ActionManager(scene);
             if (object === null)
                 scene.actionManager = actionManager;
@@ -626,6 +746,11 @@
             }
         }
 
+        /**
+         * Get a trigger name by index
+         * @param trigger defines the trigger index
+         * @returns a trigger name
+         */
         public static GetTriggerName(trigger: number): string {
             switch (trigger) {
                 case 0: return "NothingTrigger";

src/Audio/babylon.analyser.ts

@@ -1,9 +1,33 @@
 module BABYLON {
+    /**
+     * Class used to work with sound analyzer using fast fourier transform (FFT)
+     * @see http://doc.babylonjs.com/how_to/playing_sounds_and_music
+     */
     export class Analyser {
+        /**
+         * Gets or sets the smoothing
+         * @ignorenaming
+         */
         public SMOOTHING = 0.75;
+        /**
+         * Gets or sets the FFT table size
+         * @ignorenaming
+         */
         public FFT_SIZE = 512;
+        /**
+         * Gets or sets the bar graph amplitude
+         * @ignorenaming
+         */
         public BARGRAPHAMPLITUDE = 256;
+        /**
+         * Gets or sets the position of the debug canvas
+         * @ignorenaming
+         */
         public DEBUGCANVASPOS = { x: 20, y: 20 };
+        /**
+         * Gets or sets the debug canvas size
+         * @ignorenaming
+         */
         public DEBUGCANVASSIZE = { width: 320, height: 200 }
 
         private _byteFreqs: Uint8Array;
@@ -16,6 +40,10 @@ module BABYLON {
         private _registerFunc: Nullable<() => void>;
         private _audioEngine: AudioEngine;
 
+        /**
+         * Creates a new analyser
+         * @param scene defines hosting scene
+         */
         constructor(scene: Scene) {
             this._scene = scene;
             this._audioEngine = Engine.audioEngine;
@@ -29,6 +57,11 @@ module BABYLON {
             }
         }
 
+        /**
+         * Get the number of data values you will have to play with for the visualization
+         * @see https://developer.mozilla.org/en-US/docs/Web/API/AnalyserNode/frequencyBinCount
+         * @returns a number
+         */
         public getFrequencyBinCount(): number {
             if (this._audioEngine.canUseWebAudio) {
                 return this._webAudioAnalyser.frequencyBinCount;
@@ -38,6 +71,11 @@ module BABYLON {
             }
         }
 
+        /**
+         * Gets the current frequency data as a byte array
+         * @see https://developer.mozilla.org/en-US/docs/Web/API/AnalyserNode/getByteFrequencyData
+         * @returns a Uint8Array
+         */
         public getByteFrequencyData(): Uint8Array {
             if (this._audioEngine.canUseWebAudio) {
                 this._webAudioAnalyser.smoothingTimeConstant = this.SMOOTHING;
@@ -47,6 +85,11 @@ module BABYLON {
             return this._byteFreqs;
         }
 
+        /**
+         * Gets the current waveform as a byte array
+         * @see https://developer.mozilla.org/en-US/docs/Web/API/AnalyserNode/getByteTimeDomainData
+         * @returns a Uint8Array
+         */
         public getByteTimeDomainData(): Uint8Array {
             if (this._audioEngine.canUseWebAudio) {
                 this._webAudioAnalyser.smoothingTimeConstant = this.SMOOTHING;
@@ -56,7 +99,12 @@ module BABYLON {
             return this._byteTime;
         }
 
-        public getFloatFrequencyData(): Uint8Array {
+        /**
+         * Gets the current frequency data as a float array
+         * @see https://developer.mozilla.org/en-US/docs/Web/API/AnalyserNode/getByteFrequencyData
+         * @returns a Float32Array
+         */        
+        public getFloatFrequencyData(): Float32Array {
             if (this._audioEngine.canUseWebAudio) {
                 this._webAudioAnalyser.smoothingTimeConstant = this.SMOOTHING;
                 this._webAudioAnalyser.fftSize = this.FFT_SIZE;
@@ -65,6 +113,9 @@ module BABYLON {
             return this._floatFreqs;
         }
 
+        /**
+         * Renders the debug canvas
+         */
         public drawDebugCanvas() {
             if (this._audioEngine.canUseWebAudio) {
                 if (!this._debugCanvas) {
@@ -102,6 +153,9 @@ module BABYLON {
             }
         }
 
+        /**
+         * Stops rendering the debug canvas and removes it
+         */
         public stopDebugCanvas() {
             if (this._debugCanvas) {
                 if (this._registerFunc) {
@@ -114,6 +168,11 @@ module BABYLON {
             }
         }
 
+        /**
+         * Connects two audio nodes
+         * @param inputAudioNode defines first node to connect
+         * @param outputAudioNode defines second node to connect
+         */
         public connectAudioNodes(inputAudioNode: AudioNode, outputAudioNode: AudioNode) {
             if (this._audioEngine.canUseWebAudio) {
                 inputAudioNode.connect(this._webAudioAnalyser);
@@ -121,6 +180,9 @@ module BABYLON {
             }
         }
 
+        /**
+         * Releases all associated resources
+         */
         public dispose() {
             if (this._audioEngine.canUseWebAudio) {
                 this._webAudioAnalyser.disconnect();

src/Cameras/babylon.stereoscopicCameras.ts

@@ -1,53 +1,124 @@
 module BABYLON {
+    /**
+     * Camera used to simulate anaglyphic rendering (based on FreeCamera)
+     */
     export class AnaglyphFreeCamera extends FreeCamera {
+        /**
+         * Creates a new AnaglyphFreeCamera
+         * @param name defines camera name
+         * @param position defines initial position
+         * @param interaxialDistance defines distance between each color axis
+         * @param scene defines the hosting scene
+         */
         constructor(name: string, position: Vector3, interaxialDistance: number, scene: Scene) {
             super(name, position, scene);
             this.interaxialDistance = interaxialDistance;
             this.setCameraRigMode(Camera.RIG_MODE_STEREOSCOPIC_ANAGLYPH, { interaxialDistance: interaxialDistance });
         }
 
+        /**
+         * Gets camera class name
+         * @returns AnaglyphFreeCamera
+         */
         public getClassName(): string {
             return "AnaglyphFreeCamera";
         }
     }
 
+    /**
+     * Camera used to simulate anaglyphic rendering (based on ArcRotateCamera)
+     */    
     export class AnaglyphArcRotateCamera extends ArcRotateCamera {
+
+        /**
+         * Creates a new AnaglyphArcRotateCamera
+         * @param name defines camera name
+         * @param alpha defines alpha angle (in radians)
+         * @param beta defines beta angle (in radians)
+         * @param radius defines radius
+         * @param target defines camera target 
+         * @param interaxialDistance defines distance between each color axis
+         * @param scene defines the hosting scene
+         */
         constructor(name: string, alpha: number, beta: number, radius: number, target: Vector3, interaxialDistance: number, scene: Scene) {
             super(name, alpha, beta, radius, target, scene);
             this.interaxialDistance = interaxialDistance;
             this.setCameraRigMode(Camera.RIG_MODE_STEREOSCOPIC_ANAGLYPH, { interaxialDistance: interaxialDistance });
         }
 
+        /**
+         * Gets camera class name
+         * @returns AnaglyphArcRotateCamera
+         */        
         public getClassName(): string {
             return "AnaglyphArcRotateCamera";
         }
     }
 
+    /**
+     * Camera used to simulate anaglyphic rendering (based on GamepadCamera)
+     */       
     export class AnaglyphGamepadCamera extends GamepadCamera {
+        /**
+         * Creates a new AnaglyphGamepadCamera
+         * @param name defines camera name
+         * @param position defines initial position
+         * @param interaxialDistance defines distance between each color axis
+         * @param scene defines the hosting scene
+         */
         constructor(name: string, position: Vector3, interaxialDistance: number, scene: Scene) {
             super(name, position, scene);
             this.interaxialDistance = interaxialDistance;
             this.setCameraRigMode(Camera.RIG_MODE_STEREOSCOPIC_ANAGLYPH, { interaxialDistance: interaxialDistance });
         }
 
+        /**
+         * Gets camera class name
+         * @returns AnaglyphGamepadCamera
+         */   
         public getClassName(): string {
             return "AnaglyphGamepadCamera";
         }
     }
 
+    /**
+     * Camera used to simulate anaglyphic rendering (based on UniversalCamera)
+     */        
     export class AnaglyphUniversalCamera extends UniversalCamera {
+        /**
+         * Creates a new AnaglyphUniversalCamera
+         * @param name defines camera name
+         * @param position defines initial position
+         * @param interaxialDistance defines distance between each color axis
+         * @param scene defines the hosting scene
+         */
         constructor(name: string, position: Vector3, interaxialDistance: number, scene: Scene) {
             super(name, position, scene);
             this.interaxialDistance = interaxialDistance;
             this.setCameraRigMode(Camera.RIG_MODE_STEREOSCOPIC_ANAGLYPH, { interaxialDistance: interaxialDistance });
         }
 
+        /**
+         * Gets camera class name
+         * @returns AnaglyphUniversalCamera
+         */           
         public getClassName(): string {
             return "AnaglyphUniversalCamera";
         }
     }
 
+    /**
+     * Camera used to simulate stereoscopic rendering (based on FreeCamera)
+     */    
     export class StereoscopicFreeCamera extends FreeCamera {
+        /**
+         * Creates a new StereoscopicFreeCamera
+         * @param name defines camera name
+         * @param position defines initial position
+         * @param interaxialDistance defines distance between each color axis
+         * @param isStereoscopicSideBySide defines is stereoscopic is done side by side or over under
+         * @param scene defines the hosting scene
+         */
         constructor(name: string, position: Vector3, interaxialDistance: number, isStereoscopicSideBySide: boolean, scene: Scene) {
             super(name, position, scene);
             this.interaxialDistance = interaxialDistance;
@@ -55,12 +126,30 @@
             this.setCameraRigMode(isStereoscopicSideBySide ? Camera.RIG_MODE_STEREOSCOPIC_SIDEBYSIDE_PARALLEL : Camera.RIG_MODE_STEREOSCOPIC_OVERUNDER, { interaxialDistance: interaxialDistance });
         }
 
+        /**
+         * Gets camera class name
+         * @returns StereoscopicFreeCamera
+         */            
         public getClassName(): string {
             return "StereoscopicFreeCamera";
         }
     }
 
+    /**
+     * Camera used to simulate stereoscopic rendering (based on ArcRotateCamera)
+     */      
     export class StereoscopicArcRotateCamera extends ArcRotateCamera {
+        /**
+         * Creates a new StereoscopicArcRotateCamera
+         * @param name defines camera name
+         * @param alpha defines alpha angle (in radians)
+         * @param beta defines beta angle (in radians)
+         * @param radius defines radius
+         * @param target defines camera target 
+         * @param interaxialDistance defines distance between each color axis
+         * @param isStereoscopicSideBySide defines is stereoscopic is done side by side or over under
+         * @param scene defines the hosting scene
+         */        
         constructor(name: string, alpha: number, beta: number, radius: number, target: Vector3, interaxialDistance: number, isStereoscopicSideBySide: boolean, scene: Scene) {
             super(name, alpha, beta, radius, target, scene);
             this.interaxialDistance = interaxialDistance;
@@ -68,12 +157,27 @@
             this.setCameraRigMode(isStereoscopicSideBySide ? Camera.RIG_MODE_STEREOSCOPIC_SIDEBYSIDE_PARALLEL : Camera.RIG_MODE_STEREOSCOPIC_OVERUNDER, { interaxialDistance: interaxialDistance });
         }
 
+        /**
+         * Gets camera class name
+         * @returns StereoscopicArcRotateCamera
+         */              
         public getClassName(): string {
             return "StereoscopicArcRotateCamera";
         }
     }
 
+    /**
+     * Camera used to simulate stereoscopic rendering (based on GamepadCamera)
+     */      
     export class StereoscopicGamepadCamera extends GamepadCamera {
+        /**
+         * Creates a new StereoscopicGamepadCamera
+         * @param name defines camera name
+         * @param position defines initial position
+         * @param interaxialDistance defines distance between each color axis
+         * @param isStereoscopicSideBySide defines is stereoscopic is done side by side or over under
+         * @param scene defines the hosting scene
+         */        
         constructor(name: string, position: Vector3, interaxialDistance: number, isStereoscopicSideBySide: boolean, scene: Scene) {
             super(name, position, scene);
             this.interaxialDistance = interaxialDistance;
@@ -81,12 +185,27 @@
             this.setCameraRigMode(isStereoscopicSideBySide ? Camera.RIG_MODE_STEREOSCOPIC_SIDEBYSIDE_PARALLEL : Camera.RIG_MODE_STEREOSCOPIC_OVERUNDER, { interaxialDistance: interaxialDistance });
         }
 
+        /**
+         * Gets camera class name
+         * @returns StereoscopicGamepadCamera
+         */              
         public getClassName(): string {
             return "StereoscopicGamepadCamera";
         }
     }
 
+    /**
+     * Camera used to simulate stereoscopic rendering (based on UniversalCamera)
+     */      
     export class StereoscopicUniversalCamera extends UniversalCamera {
+        /**
+         * Creates a new StereoscopicUniversalCamera
+         * @param name defines camera name
+         * @param position defines initial position
+         * @param interaxialDistance defines distance between each color axis
+         * @param isStereoscopicSideBySide defines is stereoscopic is done side by side or over under
+         * @param scene defines the hosting scene
+         */        
         constructor(name: string, position: Vector3, interaxialDistance: number, isStereoscopicSideBySide: boolean, scene: Scene) {
             super(name, position, scene);
             this.interaxialDistance = interaxialDistance;
@@ -94,6 +213,10 @@
             this.setCameraRigMode(isStereoscopicSideBySide ? Camera.RIG_MODE_STEREOSCOPIC_SIDEBYSIDE_PARALLEL : Camera.RIG_MODE_STEREOSCOPIC_OVERUNDER, { interaxialDistance: interaxialDistance });
         }
 
+        /**
+         * Gets camera class name
+         * @returns StereoscopicUniversalCamera
+         */              
         public getClassName(): string {
             return "StereoscopicUniversalCamera";
         }

src/Engine/babylon.engine.ts

@@ -5572,6 +5572,7 @@
                     var height = width;
 
                     this._prepareWorkingCanvas();
+
                     if (!this._workingCanvas || !this._workingContext) {
                         return;
                     }

src/Math/babylon.math.ts

@@ -5902,6 +5902,9 @@
         CCW = 1
     }
 
+    /**
+     * Defines angle representation
+     */
     export class Angle {
         private _radians: number;
 
@@ -5914,16 +5917,26 @@
         }
 
         /**
-         * Returns the Angle value in degrees (float).  
+         * Get value in degrees
+         * @returns the Angle value in degrees (float)
          */
-        public degrees = () => this._radians * 180.0 / Math.PI;
+        public degrees() {
+            return this._radians * 180.0 / Math.PI;
+        }
+
         /**
-         * Returns the Angle value in radians (float).  
+         * Get value in radians
+         * @returns the Angle value in radians (float)
          */
-        public radians = () => this._radians;
+        public radians() {
+            return this._radians;
+        }
 
         /**
-         * Returns a new Angle object valued with the angle value in radians between the two given vectors.  
+         * Gets a new Angle object valued with the angle value in radians between the two given vectors
+         * @param a defines first vector
+         * @param b defines second vector
+         * @returns a new Angle  
          */
         public static BetweenTwoPoints(a: Vector2, b: Vector2): Angle {
             var delta = b.subtract(a);
@@ -5932,13 +5945,17 @@
         }
 
         /**
-         * Returns a new Angle object from the given float in radians.  
+         * Gets a new Angle object from the given float in radians
+         * @param radians defines the angle value in radians
+         * @returns a new Angle
          */
         public static FromRadians(radians: number): Angle {
             return new Angle(radians);
         }
         /**
-         * Returns a new Angle object from the given float in degrees.  
+         * Gets a new Angle object from the given float in degrees
+         * @param degrees defines the angle value in degrees
+         * @returns a new Angle
          */
         public static FromDegrees(degrees: number): Angle {
             return new Angle(degrees * Math.PI / 180.0);

src/PostProcess/babylon.anaglyphPostProcess.ts

@@ -1,7 +1,19 @@
 module BABYLON {
+    /**
+     * Postprocess used to generate anaglyphic rendering
+     */
     export class AnaglyphPostProcess extends PostProcess {
         private _passedProcess : Nullable<PostProcess>;
 
+        /**
+         * Creates a new AnaglyphPostProcess
+         * @param name defines postprocess name
+         * @param options defines creation options or target ratio scale
+         * @param rigCameras defines cameras using this postprocess
+         * @param samplingMode defines required sampling mode (BABYLON.Texture.NEAREST_SAMPLINGMODE by default)
+         * @param engine defines hosting engine
+         * @param reusable defines if the postprocess will be reused multiple times per frame
+         */
         constructor(name: string, options: number | PostProcessOptions,  rigCameras: Camera[], samplingMode?: number, engine?: Engine, reusable?: boolean) {
             super(name, "anaglyph", null, ["leftSampler"], options, rigCameras[1], samplingMode, engine, reusable);
             this._passedProcess = rigCameras[0]._rigPostProcess;

src/Tools/babylon.andOrNotEvaluator.ts

@@ -1,5 +1,14 @@
 module BABYLON {
+    /**
+     * Class used to evalaute queries containing `and` and `or` operators
+     */
     export class AndOrNotEvaluator {
+        /**
+         * Evaluate a query
+         * @param query defines the query to evaluate
+         * @param evaluateCallback defines the callback used to filter result
+         * @returns true if the query matches
+         */
         public static Eval(query: string, evaluateCallback: (val: any) => boolean): boolean {
             if (!query.match(/\([^\(\)]*\)/g)) {
                 query = AndOrNotEvaluator._HandleParenthesisContent(query, evaluateCallback);