public _ functions are now all hidden

src/Actions/babylon.directActions.ts

@@ -9,6 +9,7 @@
             this._target = this._effectiveTarget = target;
         }
 
+        /** @hidden */
         public _prepare(): void {
             this._effectiveTarget = this._getEffectiveTarget(this._effectiveTarget, this.propertyPath);
             this._property = this._getProperty(this.propertyPath);
@@ -17,7 +18,7 @@
         public execute(): void {
             this._effectiveTarget[this._property] = !this._effectiveTarget[this._property];
         }
-        
+
         public serialize(parent: any): any {
             return super._serialize({
                 name: "SwitchBooleanAction",
@@ -40,7 +41,7 @@
         public execute(): void {
             this._target.state = this.value;
         }
-        
+
         public serialize(parent: any): any {
             return super._serialize({
                 name: "SetStateAction",
@@ -62,6 +63,7 @@
             this._target = this._effectiveTarget = target;
         }
 
+        /** @hidden */
         public _prepare(): void {
             this._effectiveTarget = this._getEffectiveTarget(this._effectiveTarget, this.propertyPath);
             this._property = this._getProperty(this.propertyPath);
@@ -74,7 +76,7 @@
                 this._target.markAsDirty(this._property);
             }
         }
-        
+
         public serialize(parent: any): any {
             return super._serialize({
                 name: "SetValueAction",
@@ -97,6 +99,7 @@
             this._target = this._effectiveTarget = target;
         }
 
+        /** @hidden */
         public _prepare(): void {
             this._effectiveTarget = this._getEffectiveTarget(this._effectiveTarget, this.propertyPath);
             this._property = this._getProperty(this.propertyPath);
@@ -113,7 +116,7 @@
                 this._target.markAsDirty(this._property);
             }
         }
-        
+
         public serialize(parent: any): any {
             return super._serialize({
                 name: "IncrementValueAction",
@@ -134,6 +137,7 @@
             this._target = target;
         }
 
+        /** @hidden */
         public _prepare(): void {
         }
 
@@ -141,7 +145,7 @@
             var scene = this._actionManager.getScene();
             scene.beginAnimation(this._target, this.from, this.to, this.loop);
         }
-        
+
         public serialize(parent: any): any {
             return super._serialize({
                 name: "PlayAnimationAction",
@@ -163,14 +167,15 @@
             this._target = target;
         }
 
-        public _prepare(): void {           
+        /** @hidden */
+        public _prepare(): void {
         }
 
         public execute(): void {
             var scene = this._actionManager.getScene();
             scene.stopAnimation(this._target);
         }
-        
+
         public serialize(parent: any): any {
             return super._serialize({
                 name: "StopAnimationAction",
@@ -186,7 +191,7 @@
 
         public execute(): void {
         }
-        
+
         public serialize(parent: any): any {
             return super._serialize({
                 name: "DoNothingAction",
@@ -200,6 +205,7 @@
             super(triggerOptions, condition);
         }
 
+        /** @hidden */
         public _prepare(): void {
             for (var index = 0; index < this.children.length; index++) {
                 this.children[index]._actionManager = this._actionManager;
@@ -212,18 +218,18 @@
                 this.children[index].execute(evt);
             }
         }
-        
+
         public serialize(parent: any): any {
             var serializationObject = super._serialize({
                 name: "CombineAction",
                 properties: [],
                 combine: []
             }, parent);
-            
-            for (var i=0; i < this.children.length; i++) {
+
+            for (var i = 0; i < this.children.length; i++) {
                 serializationObject.combine.push(this.children[i].serialize(null));
             }
-            
+
             return serializationObject;
         }
     }
@@ -248,6 +254,7 @@
             this._parent = parent;
         }
 
+        /** @hidden */
         public _prepare(): void {
         }
 
@@ -263,7 +270,7 @@
 
             this._target.parent = this._parent;
         }
-        
+
         public serialize(parent: any): any {
             return super._serialize({
                 name: "SetParentAction",
@@ -283,6 +290,7 @@
             this._sound = sound;
         }
 
+        /** @hidden */
         public _prepare(): void {
         }
 
@@ -290,7 +298,7 @@
             if (this._sound !== undefined)
                 this._sound.play();
         }
-        
+
         public serialize(parent: any): any {
             return super._serialize({
                 name: "PlaySoundAction",
@@ -307,6 +315,7 @@
             this._sound = sound;
         }
 
+        /** @hidden */
         public _prepare(): void {
         }
 
@@ -314,7 +323,7 @@
             if (this._sound !== undefined)
                 this._sound.stop();
         }
-        
+
         public serialize(parent: any): any {
             return super._serialize({
                 name: "StopSoundAction",

src/Actions/babylon.interpolateValueAction.ts

@@ -12,6 +12,7 @@
             this._target = this._effectiveTarget = target;
         }
 
+        /** @hidden */
         public _prepare(): void {
             this._effectiveTarget = this._getEffectiveTarget(this._effectiveTarget, this.propertyPath);
             this._property = this._getProperty(this.propertyPath);
@@ -54,7 +55,7 @@
                 scene.stopAnimation(this._effectiveTarget);
             }
 
-            let wrapper = ()=> {
+            let wrapper = () => {
                 this.onInterpolationDoneObservable.notifyObservers(this);
                 if (this.onInterpolationDone) {
                     this.onInterpolationDone();
@@ -63,7 +64,7 @@
 
             scene.beginDirectAnimation(this._effectiveTarget, [animation], 0, 100, false, 1, wrapper);
         }
-        
+
         public serialize(parent: any): any {
             return super._serialize({
                 name: "InterpolateValueAction",

src/Cameras/Inputs/babylon.arcRotateCameraVRDeviceOrientationInput.ts

@@ -21,6 +21,7 @@ module BABYLON {
             window.addEventListener("deviceorientation", this._deviceOrientationHandler);
         }
 
+        /** @hidden */
         public _onOrientationEvent(evt: DeviceOrientationEvent): void {
             if (evt.alpha !== null) {
                 this._alpha = +evt.alpha | 0;

src/Cameras/Inputs/babylon.freeCameraKeyboardMoveInput.ts

@@ -5,7 +5,7 @@ module BABYLON {
         private _onCanvasBlurObserver: Nullable<Observer<Engine>>;
         private _onKeyboardObserver: Nullable<Observer<KeyboardInfo>>;
         private _engine: Engine;
-        private _scene: Scene;        
+        private _scene: Scene;
 
         @serialize()
         public keysUp = [38];
@@ -19,7 +19,7 @@ module BABYLON {
         @serialize()
         public keysRight = [39];
 
-        attachControl(element : HTMLElement, noPreventDefault?: boolean) {
+        attachControl(element: HTMLElement, noPreventDefault?: boolean) {
             if (this._onCanvasBlurObserver) {
                 return;
             }
@@ -27,7 +27,7 @@ module BABYLON {
             this._scene = this.camera.getScene();
             this._engine = this._scene.getEngine();
 
-            this._onCanvasBlurObserver = this._engine.onCanvasBlurObservable.add(()=>{
+            this._onCanvasBlurObserver = this._engine.onCanvasBlurObservable.add(() => {
                 this._keys = [];
             });
 
@@ -63,7 +63,7 @@ module BABYLON {
                         }
                     }
                 }
-            });     
+            });
         }
 
         detachControl(element: Nullable<HTMLElement>) {
@@ -80,9 +80,9 @@ module BABYLON {
             }
             this._keys = [];
         }
-        
+
         public checkInputs() {
-            if (this._onKeyboardObserver){
+            if (this._onKeyboardObserver) {
                 var camera = this.camera;
                 // Keyboard
                 for (var index = 0; index < this._keys.length; index++) {
@@ -114,14 +114,15 @@ module BABYLON {
             return "FreeCameraKeyboardMoveInput";
         }
 
+        /** @hidden */
         public _onLostFocus(e: FocusEvent): void {
             this._keys = [];
         }
-        
-        getSimpleName(){
+
+        getSimpleName() {
             return "keyboard";
         }
     }
-    
+
     (<any>CameraInputTypes)["FreeCameraKeyboardMoveInput"] = FreeCameraKeyboardMoveInput;
 }

src/Cameras/VR/babylon.vrExperienceHelper.ts

@@ -28,7 +28,7 @@ module BABYLON {
         /**
          * Uses the main button on the controller to toggle the laser casted. (default: true)
          */
-        laserToggle?:boolean;
+        laserToggle?: boolean;
         /**
          * A list of meshes to be used as the teleportation floor. If specified, teleportation will be enabled (default: undefined)
          */
@@ -36,32 +36,46 @@ module BABYLON {
     }
 
     class VRExperienceHelperGazer implements IDisposable {
-        public _gazeTracker:Mesh;
-        
-        public _currentMeshSelected:Nullable<AbstractMesh>;
-        public _currentHit:Nullable<PickingInfo>;
+        /** @hidden */
+        public _gazeTracker: Mesh;
+
+        /** @hidden */
+        public _currentMeshSelected: Nullable<AbstractMesh>;
+        /** @hidden */
+        public _currentHit: Nullable<PickingInfo>;
 
         public static _idCounter = 0;
-        public _id:number;
+        /** @hidden */
+        public _id: number;
+
+        /** @hidden */
+        public _pointerDownOnMeshAsked: boolean = false;
+        /** @hidden */
+        public _isActionableMesh: boolean = false;
 
-        public _pointerDownOnMeshAsked:boolean = false;
-        public _isActionableMesh:boolean = false;
-        
+        /** @hidden */
         public _interactionsEnabled: boolean;
+        /** @hidden */
         public _teleportationEnabled: boolean;
+        /** @hidden */
         public _teleportationRequestInitiated = false;
+        /** @hidden */
         public _teleportationBackRequestInitiated = false;
+        /** @hidden */
         public _rotationRightAsked = false;
+        /** @hidden */
         public _rotationLeftAsked = false;
+        /** @hidden */
         public _dpadPressed = true;
 
+        /** @hidden */
         public _activePointer = false;
 
-        constructor(public scene: Scene, gazeTrackerToClone:Nullable<Mesh> = null){
+        constructor(public scene: Scene, gazeTrackerToClone: Nullable<Mesh> = null) {
             this._id = VRExperienceHelperGazer._idCounter++;
 
             // Gaze tracker
-            if(!gazeTrackerToClone){
+            if (!gazeTrackerToClone) {
                 this._gazeTracker = Mesh.CreateTorus("gazeTracker", 0.0035, 0.0025, 20, scene, false);
                 this._gazeTracker.bakeCurrentTransformIntoVertices();
                 this._gazeTracker.isPickable = false;
@@ -71,54 +85,60 @@ module BABYLON {
                 targetMat.emissiveColor = new Color3(0.7, 0.7, 0.7)
                 targetMat.backFaceCulling = false;
                 this._gazeTracker.material = targetMat;
-            }else{
+            } else {
                 this._gazeTracker = gazeTrackerToClone.clone("gazeTracker");
             }
-            
+
         }
 
-        public _getForwardRay(length:number):Ray{
-            return new Ray(Vector3.Zero(),new Vector3(0,0,length));
+        /** @hidden */
+        public _getForwardRay(length: number): Ray {
+            return new Ray(Vector3.Zero(), new Vector3(0, 0, length));
         }
 
+        /** @hidden */
         public _selectionPointerDown() {
             this._pointerDownOnMeshAsked = true;
             if (this._currentHit) {
-                this.scene.simulatePointerDown(this._currentHit, {pointerId: this._id});
+                this.scene.simulatePointerDown(this._currentHit, { pointerId: this._id });
             }
         }
 
+        /** @hidden */
         public _selectionPointerUp() {
             if (this._currentHit) {
-                this.scene.simulatePointerUp(this._currentHit, {pointerId: this._id});
+                this.scene.simulatePointerUp(this._currentHit, { pointerId: this._id });
             }
             this._pointerDownOnMeshAsked = false;
         }
 
+        /** @hidden */
         public _activatePointer() {
             this._activePointer = true;
         }
 
+        /** @hidden */
         public _deactivatePointer() {
             this._activePointer = false;
         }
 
-        public _updatePointerDistance(distance:number = 100) {
+        /** @hidden */
+        public _updatePointerDistance(distance: number = 100) {
         }
 
-        public dispose(){
+        public dispose() {
             this._interactionsEnabled = false;
             this._teleportationEnabled = false;
-            if(this._gazeTracker){
+            if (this._gazeTracker) {
                 this._gazeTracker.dispose()
             }
         }
     }
 
-    class VRExperienceHelperControllerGazer extends VRExperienceHelperGazer{
+    class VRExperienceHelperControllerGazer extends VRExperienceHelperGazer {
         private _laserPointer: Mesh;
         private _meshAttachedObserver: Nullable<Observer<AbstractMesh>>;
-        constructor(public webVRController: WebVRController, scene: Scene, gazeTrackerToClone:Mesh){
+        constructor(public webVRController: WebVRController, scene: Scene, gazeTrackerToClone: Mesh) {
             super(scene, gazeTrackerToClone);
             // Laser pointer
             this._laserPointer = Mesh.CreateCylinder("laserPointer", 1, 0.004, 0.0002, 20, 1, scene, false);
@@ -131,7 +151,7 @@ module BABYLON {
             this._laserPointer.isVisible = false;
             this._laserPointer.isPickable = false;
 
-            if(!webVRController.mesh){
+            if (!webVRController.mesh) {
                 // Create an empty mesh that is used prior to loading the high quality model
                 var preloadMesh = new Mesh("preloadControllerMesh", scene);
                 var preloadPointerPose = new Mesh(PoseEnabledController.POINTING_POSE, scene);
@@ -142,30 +162,34 @@ module BABYLON {
 
             this._setLaserPointerParent(webVRController.mesh!);
 
-            this._meshAttachedObserver = webVRController._meshAttachedObservable.add((mesh)=>{
+            this._meshAttachedObserver = webVRController._meshAttachedObservable.add((mesh) => {
                 this._setLaserPointerParent(mesh);
             });
         }
 
-        _getForwardRay(length:number):Ray{
+        _getForwardRay(length: number): Ray {
             return this.webVRController.getForwardRay(length);
         }
 
+        /** @hidden */
         public _activatePointer() {
             super._activatePointer();
             this._laserPointer.isVisible = true;
         }
-        
+
+        /** @hidden */
         public _deactivatePointer() {
             super._deactivatePointer();
             this._laserPointer.isVisible = false;
         }
 
-        public _setLaserPointerColor(color:Color3){
+        /** @hidden */
+        public _setLaserPointerColor(color: Color3) {
             (<StandardMaterial>this._laserPointer.material).emissiveColor = color;
         }
 
-        public _setLaserPointerParent(mesh:AbstractMesh){
+        /** @hidden */
+        public _setLaserPointerParent(mesh: AbstractMesh) {
             var makeNotPick = (root: AbstractMesh) => {
                 root.isPickable = false;
                 root.getChildMeshes().forEach((c) => {
@@ -186,29 +210,29 @@ module BABYLON {
             this._laserPointer.parent = mesh;
         }
 
-        public _updatePointerDistance(distance:number = 100) {
+        public _updatePointerDistance(distance: number = 100) {
             this._laserPointer.scaling.y = distance;
-            this._laserPointer.position.z = -distance / 2;  
+            this._laserPointer.position.z = -distance / 2;
         }
 
-        dispose(){
+        dispose() {
             super.dispose();
             this._laserPointer.dispose();
-            if(this._meshAttachedObserver){
+            if (this._meshAttachedObserver) {
                 this.webVRController._meshAttachedObservable.remove(this._meshAttachedObserver);
             }
         }
     }
 
-    class VRExperienceHelperCameraGazer extends VRExperienceHelperGazer{
-        constructor(private getCamera:()=>Nullable<Camera>, scene: Scene){
+    class VRExperienceHelperCameraGazer extends VRExperienceHelperGazer {
+        constructor(private getCamera: () => Nullable<Camera>, scene: Scene) {
             super(scene);
         }
-        _getForwardRay(length:number):Ray{
+        _getForwardRay(length: number): Ray {
             var camera = this.getCamera();
-            if(camera){
+            if (camera) {
                 return camera.getForwardRay(length);
-            }else{
+            } else {
                 return new Ray(Vector3.Zero(), Vector3.Forward());
             }
         }
@@ -304,10 +328,10 @@ module BABYLON {
         private _cameraGazer: VRExperienceHelperCameraGazer;
         private _padSensibilityUp = 0.65;
         private _padSensibilityDown = 0.35;
-        
 
-        private leftController:Nullable<VRExperienceHelperControllerGazer> = null;
-        private rightController:Nullable<VRExperienceHelperControllerGazer> = null;
+
+        private leftController: Nullable<VRExperienceHelperControllerGazer> = null;
+        private rightController: Nullable<VRExperienceHelperControllerGazer> = null;
 
         /**
          * Observable raised when a new mesh is selected based on meshSelectionPredicate
@@ -352,7 +376,7 @@ module BABYLON {
          * Set teleportation enabled. If set to false camera teleportation will be disabled but camera rotation will be kept.
          */
         public teleportationEnabled: boolean = true;
-        
+
         private _defaultHeight: number;
         private _teleportationInitialized = false;
         private _interactionsEnabled = false;
@@ -394,11 +418,11 @@ module BABYLON {
                 this._cameraGazer._gazeTracker.isPickable = false;
                 this._cameraGazer._gazeTracker.isVisible = false;
                 this._cameraGazer._gazeTracker.name = "gazeTracker";
-                if(this.leftController){
+                if (this.leftController) {
                     this.leftController._gazeTracker = this._cameraGazer._gazeTracker.clone("gazeTracker");
                 }
 
-                if(this.rightController){
+                if (this.rightController) {
                     this.rightController._gazeTracker = this._cameraGazer._gazeTracker.clone("gazeTracker");
                 }
             }
@@ -419,11 +443,11 @@ module BABYLON {
             if (!value) {
                 this._cameraGazer._gazeTracker.isVisible = false;
 
-                if(this.leftController){
+                if (this.leftController) {
                     this.leftController._gazeTracker.isVisible = false;
                 }
 
-                if(this.rightController){
+                if (this.rightController) {
                     this.rightController._gazeTracker.isVisible = false;
                 }
             }
@@ -496,8 +520,8 @@ module BABYLON {
 
         private get _teleportationRequestInitiated(): boolean {
             var result = this._cameraGazer._teleportationRequestInitiated
-            || (this.leftController !== null && this.leftController._teleportationRequestInitiated)
-            || (this.rightController !== null && this.rightController._teleportationRequestInitiated);
+                || (this.leftController !== null && this.leftController._teleportationRequestInitiated)
+                || (this.rightController !== null && this.rightController._teleportationRequestInitiated);
             return result;
         }
 
@@ -507,7 +531,7 @@ module BABYLON {
          * @param scene The scene the VRExperienceHelper belongs to.
          * @param webVROptions Options to modify the vr experience helper's behavior.
          */
-        constructor(scene: Scene, 
+        constructor(scene: Scene,
             /** Options to modify the vr experience helper's behavior. */
             public webVROptions: VRExperienceHelperOptions = {}) {
             this._scene = scene;
@@ -537,7 +561,7 @@ module BABYLON {
             }
             this._defaultHeight = webVROptions.defaultHeight;
 
-            if(webVROptions.positionScale){
+            if (webVROptions.positionScale) {
                 this._rayLength *= webVROptions.positionScale;
                 this._defaultHeight *= webVROptions.positionScale;
             }
@@ -584,7 +608,7 @@ module BABYLON {
             this._webVRCamera = new WebVRFreeCamera("WebVRHelper", this._position, this._scene, webVROptions);
             this._webVRCamera.useStandingMatrix()
 
-            this._cameraGazer = new VRExperienceHelperCameraGazer(()=>{return this.currentVRCamera;}, scene);
+            this._cameraGazer = new VRExperienceHelperCameraGazer(() => { return this.currentVRCamera; }, scene);
             // Create default button
             if (!this._useCustomVRButton) {
                 this._btnVR = <HTMLButtonElement>document.createElement("BUTTON");
@@ -683,25 +707,25 @@ module BABYLON {
             //create easing functions
             this._circleEase = new CircleEase();
             this._circleEase.setEasingMode(EasingFunction.EASINGMODE_EASEINOUT);
-            
-            if(this.webVROptions.floorMeshes){
-                this.enableTeleportation({floorMeshes: this.webVROptions.floorMeshes});
+
+            if (this.webVROptions.floorMeshes) {
+                this.enableTeleportation({ floorMeshes: this.webVROptions.floorMeshes });
             }
         }
 
         // Raised when one of the controller has loaded successfully its associated default mesh
         private _onDefaultMeshLoaded(webVRController: WebVRController) {
-            if(this.leftController && this.leftController.webVRController == webVRController){
-                if(webVRController.mesh){
+            if (this.leftController && this.leftController.webVRController == webVRController) {
+                if (webVRController.mesh) {
                     this.leftController._setLaserPointerParent(webVRController.mesh)
                 }
             }
-            if(this.rightController && this.rightController.webVRController == webVRController){
-                if(webVRController.mesh){
+            if (this.rightController && this.rightController.webVRController == webVRController) {
+                if (webVRController.mesh) {
                     this.rightController._setLaserPointerParent(webVRController.mesh)
                 }
             }
-            
+
             try {
                 this.onControllerMeshLoadedObservable.notifyObservers(webVRController);
             }
@@ -830,7 +854,7 @@ module BABYLON {
             }
             else if (this._vrDeviceOrientationCamera) {
                 this._vrDeviceOrientationCamera.position = this._position;
-                if(this._scene.activeCamera){
+                if (this._scene.activeCamera) {
                     this._vrDeviceOrientationCamera.minZ = this._scene.activeCamera.minZ
                 }
                 this._scene.activeCamera = this._vrDeviceOrientationCamera;
@@ -911,7 +935,7 @@ module BABYLON {
          */
         public enableInteractions() {
             if (!this._interactionsEnabled) {
-                this._interactionsRequested = true;            
+                this._interactionsRequested = true;
 
                 if (this.leftController) {
                     this._enableInteractionOnController(this.leftController)
@@ -942,25 +966,25 @@ module BABYLON {
             }
         }
 
-        private get _noControllerIsActive(){
+        private get _noControllerIsActive() {
             return !(this.leftController && this.leftController._activePointer) && !(this.rightController && this.rightController._activePointer)
         }
 
         private beforeRender = () => {
-            if(this.leftController && this.leftController._activePointer){
+            if (this.leftController && this.leftController._activePointer) {
                 this._castRayAndSelectObject(this.leftController);
             }
-            
-            if(this.rightController && this.rightController._activePointer){
+
+            if (this.rightController && this.rightController._activePointer) {
                 this._castRayAndSelectObject(this.rightController);
             }
 
-            if(this._noControllerIsActive){
+            if (this._noControllerIsActive) {
                 this._castRayAndSelectObject(this._cameraGazer);
-            }else{
+            } else {
                 this._cameraGazer._gazeTracker.isVisible = false;
             }
-            
+
         }
 
         private _isTeleportationFloor(mesh: AbstractMesh): boolean {
@@ -1094,10 +1118,10 @@ module BABYLON {
 
                 if (webVRController.hand === "right" || (this.leftController && this.leftController.webVRController != webVRController)) {
                     this.rightController = controller;
-                }else{
+                } else {
                     this.leftController = controller;
                 }
-                
+
                 this._tryEnableInteractionOnController(controller);
             }
         }
@@ -1114,7 +1138,7 @@ module BABYLON {
 
         private _onNewGamepadDisconnected = (gamepad: Gamepad) => {
             if (gamepad instanceof WebVRController) {
-                
+
                 if (gamepad.hand === "left" && this.leftController != null) {
                     this.leftController.dispose();
                     this.leftController = null;
@@ -1129,27 +1153,27 @@ module BABYLON {
         private _enableInteractionOnController(controller: VRExperienceHelperControllerGazer) {
             var controllerMesh = controller.webVRController.mesh;
             if (controllerMesh) {
-                
+
                 controller._interactionsEnabled = true;
                 controller._activatePointer();
-                if(this.webVROptions.laserToggle){
+                if (this.webVROptions.laserToggle) {
                     controller.webVRController.onMainButtonStateChangedObservable.add((stateObject) => {
                         // Enabling / disabling laserPointer 
                         if (this._displayLaserPointer && stateObject.value === 1) {
-                            if(controller._activePointer){
+                            if (controller._activePointer) {
                                 controller._deactivatePointer();
-                            }else{
+                            } else {
                                 controller._activatePointer();
                             }
-                            if(this.displayGaze){
+                            if (this.displayGaze) {
                                 controller._gazeTracker.isVisible = controller._activePointer;
                             }
                         }
                     });
                 }
                 controller.webVRController.onTriggerStateChangedObservable.add((stateObject) => {
-                    var gazer:VRExperienceHelperGazer = controller;
-                    if(this._noControllerIsActive){
+                    var gazer: VRExperienceHelperGazer = controller;
+                    if (this._noControllerIsActive) {
                         gazer = this._cameraGazer;
                     }
                     if (!gazer._pointerDownOnMeshAsked) {
@@ -1165,7 +1189,7 @@ module BABYLON {
 
         private _checkTeleportWithRay(stateObject: StickValues, gazer: VRExperienceHelperGazer) {
             // Dont teleport if another gaze already requested teleportation
-            if(this._teleportationRequestInitiated && !gazer._teleportationRequestInitiated){
+            if (this._teleportationRequestInitiated && !gazer._teleportationRequestInitiated) {
                 return;
             }
             if (!gazer._teleportationRequestInitiated) {
@@ -1176,15 +1200,15 @@ module BABYLON {
             } else {
                 // Listening to the proper controller values changes to confirm teleportation
                 if (Math.sqrt(stateObject.y * stateObject.y + stateObject.x * stateObject.x) < this._padSensibilityDown) {
-                    if(this._teleportActive){
+                    if (this._teleportActive) {
                         this._teleportCamera(this._haloCenter);
                     }
-                    
+
                     gazer._teleportationRequestInitiated = false;
                 }
             }
         }
-        private _checkRotate(stateObject: StickValues, gazer:VRExperienceHelperGazer) {
+        private _checkRotate(stateObject: StickValues, gazer: VRExperienceHelperGazer) {
             // Only rotate when user is not currently selecting a teleportation location
             if (gazer._teleportationRequestInitiated) {
                 return;
@@ -1216,7 +1240,7 @@ module BABYLON {
                 }
             }
         }
-        private _checkTeleportBackwards(stateObject: StickValues, gazer:VRExperienceHelperGazer) {
+        private _checkTeleportBackwards(stateObject: StickValues, gazer: VRExperienceHelperGazer) {
             // Only teleport backwards when user is not currently selecting a teleportation location
             if (gazer._teleportationRequestInitiated) {
                 return;
@@ -1462,14 +1486,14 @@ module BABYLON {
             this._scene.beginAnimation(this.currentVRCamera, 0, 6, false, 1);
         }
 
-        private _moveTeleportationSelectorTo(hit: PickingInfo, gazer:VRExperienceHelperGazer, ray: Ray) {
+        private _moveTeleportationSelectorTo(hit: PickingInfo, gazer: VRExperienceHelperGazer, ray: Ray) {
             if (hit.pickedPoint) {
                 if (gazer._teleportationRequestInitiated) {
                     this._displayTeleportationTarget();
                     this._haloCenter.copyFrom(hit.pickedPoint);
                     this._teleportationTarget.position.copyFrom(hit.pickedPoint);
                 }
-                
+
                 var pickNormal = this._convertNormalToDirectionOfRay(hit.getNormal(true, false), ray);
                 if (pickNormal) {
                     var axis1 = Vector3.Cross(Axis.Y, pickNormal);
@@ -1577,34 +1601,34 @@ module BABYLON {
             this._hideTeleportationTarget();
         }
 
-        private _convertNormalToDirectionOfRay(normal:Nullable<Vector3>, ray:Ray){
-            if(normal){
+        private _convertNormalToDirectionOfRay(normal: Nullable<Vector3>, ray: Ray) {
+            if (normal) {
                 var angle = Math.acos(BABYLON.Vector3.Dot(normal, ray.direction));
-                if(angle < Math.PI/2){
+                if (angle < Math.PI / 2) {
                     normal.scaleInPlace(-1);
                 }
-            }            
+            }
             return normal;
         }
 
-        private _castRayAndSelectObject(gazer:VRExperienceHelperGazer) {
+        private _castRayAndSelectObject(gazer: VRExperienceHelperGazer) {
             if (!(this.currentVRCamera instanceof FreeCamera)) {
                 return;
             }
-             
+
             var ray = gazer._getForwardRay(this._rayLength);
             var hit = this._scene.pickWithRay(ray, this._raySelectionPredicate);
-            if(hit){
+            if (hit) {
                 // Populate the contrllers mesh that can be used for drag/drop
-                if((<any>gazer)._laserPointer){
+                if ((<any>gazer)._laserPointer) {
                     hit.originMesh = (<any>gazer)._laserPointer.parent;
                 }
-                this._scene.simulatePointerMove(hit, {pointerId: gazer._id});
+                this._scene.simulatePointerMove(hit, { pointerId: gazer._id });
             }
             gazer._currentHit = hit;
 
             // Moving the gazeTracker on the mesh face targetted
-            if (hit && hit.pickedPoint) {                
+            if (hit && hit.pickedPoint) {
                 if (this._displayGaze) {
                     let multiplier = 1;
 
@@ -1649,13 +1673,13 @@ module BABYLON {
                 }
 
                 // Changing the size of the laser pointer based on the distance from the targetted point
-                gazer._updatePointerDistance(hit.distance);        
+                gazer._updatePointerDistance(hit.distance);
             }
             else {
-                gazer._updatePointerDistance();   
+                gazer._updatePointerDistance();
                 gazer._gazeTracker.isVisible = false;
             }
-            
+
             if (hit && hit.pickedMesh) {
                 // The object selected is the floor, we're in a teleportation scenario
                 if (this._teleportationInitialized && this._isTeleportationFloor(hit.pickedMesh) && hit.pickedPoint) {
@@ -1667,7 +1691,7 @@ module BABYLON {
                     }
 
                     gazer._currentMeshSelected = null;
-                    if(gazer._teleportationRequestInitiated){
+                    if (gazer._teleportationRequestInitiated) {
                         this._moveTeleportationSelectorTo(hit, gazer, ray);
                     }
                     return;
@@ -1711,9 +1735,9 @@ module BABYLON {
                 this.changeLaserColor(new Color3(0.7, 0.7, 0.7));
             }
         }
-        
-        private _notifySelectedMeshUnselected(mesh:Nullable<AbstractMesh>) {
-            if(mesh) {
+
+        private _notifySelectedMeshUnselected(mesh: Nullable<AbstractMesh>) {
+            if (mesh) {
                 this.onSelectedMeshUnselected.notifyObservers(mesh);
             }
         }
@@ -1725,7 +1749,7 @@ module BABYLON {
         public changeLaserColor(color: Color3) {
             if (this.leftController) {
                 this.leftController._setLaserPointerColor(color);
-                
+
             }
             if (this.rightController) {
                 this.rightController._setLaserPointerColor(color);
@@ -1737,14 +1761,14 @@ module BABYLON {
          * @param color new color for the ray.
          */
         public changeGazeColor(color: Color3) {
-            if(!(<StandardMaterial>this._cameraGazer._gazeTracker.material)){
+            if (!(<StandardMaterial>this._cameraGazer._gazeTracker.material)) {
                 return;
             }
             (<StandardMaterial>this._cameraGazer._gazeTracker.material).emissiveColor = color;
-            if(this.leftController){
+            if (this.leftController) {
                 (<StandardMaterial>this.leftController._gazeTracker.material).emissiveColor = color;
             }
-            if(this.rightController){
+            if (this.rightController) {
                 (<StandardMaterial>this.rightController._gazeTracker.material).emissiveColor = color;
             }
         }
@@ -1756,7 +1780,7 @@ module BABYLON {
             if (this.isInVRMode) {
                 this.exitVR();
             }
-            
+
             if (this._postProcessMove) {
                 this._postProcessMove.dispose();
             }

src/Cameras/VR/babylon.webVRCamera.ts

@@ -41,11 +41,11 @@ module BABYLON {
         readonly angularAcceleration: Nullable<Float32Array>;
     }
 
-     /**
-     * Interface representing a pose controlled object in Babylon.
-     * A pose controlled object has both regular pose values as well as pose values 
-     * from an external device such as a VR head mounted display
-     */
+    /**
+    * Interface representing a pose controlled object in Babylon.
+    * A pose controlled object has both regular pose values as well as pose values 
+    * from an external device such as a VR head mounted display
+    */
     export interface PoseControlled {
         /**
          * The position of the object in babylon space.
@@ -131,6 +131,7 @@ module BABYLON {
      */
     export class WebVRFreeCamera extends FreeCamera implements PoseControlled {
         /**
+         * @hidden
          * The vrDisplay tied to the camera. See https://developer.mozilla.org/en-US/docs/Web/API/VRDisplay
          */
         public _vrDevice: any = null;
@@ -302,7 +303,7 @@ module BABYLON {
                 return this._deviceRoomPosition.y + this._workingVector.y
             }
             //If VRDisplay does not inform stage parameters and no default height is set we fallback to zero.
-            return this._defaultHeight || 0;            
+            return this._defaultHeight || 0;
         }
 
         /**
@@ -311,7 +312,7 @@ module BABYLON {
          */
         public useStandingMatrix(callback = (bool: boolean) => { }) {
             // Use standing matrix if available
-            this.getEngine().initWebVRAsync().then((result)=>{
+            this.getEngine().initWebVRAsync().then((result) => {
                 if (!result.vrDisplay || !result.vrDisplay.stageParameters || !result.vrDisplay.stageParameters.sittingToStandingTransform) {
                     callback(false);
                 } else {
@@ -333,9 +334,9 @@ module BABYLON {
          * Enables the standing matrix when supported. This can be used to position the user's view the correct height from the ground.
          * @returns A promise with a boolean set to if the standing matrix is supported.
          */
-        public useStandingMatrixAsync():Promise<boolean> {
-            return new Promise((res, rej)=>{
-                this.useStandingMatrix((supported)=>{
+        public useStandingMatrixAsync(): Promise<boolean> {
+            return new Promise((res, rej) => {
+                this.useStandingMatrix((supported) => {
                     res(supported);
                 });
             });
@@ -405,6 +406,7 @@ module BABYLON {
         }
 
         /**
+         * @hidden
          * Updates the camera based on device's frame data
          */
         public _checkInputs(): void {
@@ -492,6 +494,7 @@ module BABYLON {
         }
 
         /**
+         * @hidden
          * Updates the rig cameras (left and right eye)
          */
         public _updateRigCameras() {
@@ -511,6 +514,7 @@ module BABYLON {
         private updateCacheCalled: boolean;
 
         /**
+         * @hidden
          * Updates the cached values of the camera
          * @param ignoreParentClass ignores updating the parent class's cache (default: false)
          */
@@ -565,13 +569,14 @@ module BABYLON {
             this._workingMatrix.multiplyToRef(this._deviceToWorld, this._workingMatrix)
             Quaternion.FromRotationMatrixToRef(this._workingMatrix, this.deviceRotationQuaternion);
 
-            if(this._poseSet){
+            if (this._poseSet) {
                 this.onPoseUpdatedFromDeviceObservable.notifyObservers(null);
             }
             super.update();
         }
 
         /**
+         * @hidden
          * Gets the view matrix of this camera (Always set to identity as left and right eye cameras contain the actual view matrix)
          * @returns an identity matrix
          */
@@ -590,7 +595,7 @@ module BABYLON {
 
             //WebVR 1.1
             var viewArray = this._cameraRigParams["left"] ? this._cameraRigParams["frameData"].leftViewMatrix : this._cameraRigParams["frameData"].rightViewMatrix;
-            
+
             Matrix.FromArrayToRef(viewArray, 0, this._webvrViewMatrix);
 
             if (!this.getScene().useRightHandedSystem) {

src/Cameras/babylon.arcRotateCamera.ts

@@ -239,11 +239,16 @@
         @serialize()
         public allowUpsideDown = true;
 
+        /** @hidden */
         public _viewMatrix = new Matrix();
+        /** @hidden */
         public _useCtrlForPanning: boolean;
+        /** @hidden */
         public _panningMouseButton: number;
+
         public inputs: ArcRotateCameraInputsManager;
 
+        /** @hidden */
         public _reset: () => void;
 
         // Panning
@@ -362,6 +367,7 @@
         }
 
         // Cache
+        /** @hidden */
         public _initCache(): void {
             super._initCache();
             this._cache._target = new Vector3(Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE);
@@ -371,6 +377,7 @@
             this._cache.targetScreenOffset = Vector2.Zero();
         }
 
+        /** @hidden */
         public _updateCache(ignoreParentClass?: boolean): void {
             if (!ignoreParentClass) {
                 super._updateCache();
@@ -422,6 +429,7 @@
         }
 
         /**
+         * @hidden
          * Restored camera state. You must call storeState() first
          */
         public _restoreStateValues(): boolean {
@@ -444,6 +452,7 @@
         }
 
         // Synchronized
+        /** @hidden */
         public _isSynchronizedViewMatrix(): boolean {
             if (!super._isSynchronizedViewMatrix())
                 return false;
@@ -479,6 +488,7 @@
             }
         }
 
+        /** @hidden */
         public _checkInputs(): void {
             //if (async) collision inspection was triggered, don't update the camera's position - until the collision callback was called.
             if (this._collisionTriggered) {
@@ -645,6 +655,7 @@
             this.rebuildAnglesAndRadius();
         }
 
+        /** @hidden */
         public _getViewMatrix(): Matrix {
             // Compute
             var cosa = Math.cos(this.alpha);
@@ -785,6 +796,7 @@
         }
 
         /**
+         * @hidden
          * @override
          * Override Camera._updateRigCameras
          */

src/Cameras/babylon.camera.ts

@@ -141,11 +141,17 @@
         @serialize()
         public isStereoscopicSideBySide: boolean
 
+        /** @hidden */
         public _cameraRigParams: any;
+        /** @hidden */
         public _rigCameras = new Array<Camera>();
+        /** @hidden */
         public _rigPostProcess: Nullable<PostProcess>;
+
         protected _webvrViewMatrix = Matrix.Identity();
+        /** @hidden */
         public _skipRendering = false;
+        /** @hidden */
         public _alternateCamera: Camera;
 
         public customRenderTargets = new Array<RenderTargetTexture>();
@@ -269,6 +275,7 @@
         }
 
         //Cache
+        /** @hidden */
         public _initCache() {
             super._initCache();
 
@@ -291,6 +298,7 @@
             this._cache.renderHeight = undefined;
         }
 
+        /** @hidden */
         public _updateCache(ignoreParentClass?: boolean): void {
             if (!ignoreParentClass) {
                 super._updateCache();
@@ -301,10 +309,12 @@
         }
 
         // Synchronized
+        /** @hidden */
         public _isSynchronized(): boolean {
             return this._isSynchronizedViewMatrix() && this._isSynchronizedProjectionMatrix();
         }
 
+        /** @hidden */
         public _isSynchronizedViewMatrix(): boolean {
             if (!super._isSynchronized())
                 return false;
@@ -314,6 +324,7 @@
                 && this.isSynchronizedWithParent();
         }
 
+        /** @hidden */
         public _isSynchronizedProjectionMatrix(): boolean {
             var check = this._cache.mode === this.mode
                 && this._cache.minZ === this.minZ
@@ -356,6 +367,7 @@
             }
         }
 
+        /** @hidden */
         public _checkInputs(): void {
             this.onAfterCheckInputsObservable.notifyObservers(this);
         }
@@ -372,9 +384,9 @@
          * Internal, gets the first post proces.
          * @returns the first post process to be run on this camera.
          */
-        public _getFirstPostProcess():Nullable<PostProcess>{
-            for(var ppIndex = 0; ppIndex < this._postProcesses.length; ppIndex++){
-                if(this._postProcesses[ppIndex] !== null){
+        public _getFirstPostProcess(): Nullable<PostProcess> {
+            for (var ppIndex = 0; ppIndex < this._postProcesses.length; ppIndex++) {
+                if (this._postProcesses[ppIndex] !== null) {
                     return this._postProcesses[ppIndex];
                 }
             }
@@ -417,9 +429,9 @@
 
             if (insertAt == null || insertAt < 0) {
                 this._postProcesses.push(postProcess);
-            } else if(this._postProcesses[insertAt] === null) {
+            } else if (this._postProcesses[insertAt] === null) {
                 this._postProcesses[insertAt] = postProcess;
-            }else{
+            } else {
                 this._postProcesses.splice(insertAt, 0, postProcess);
             }
             this._cascadePostProcessesToRigCams(); // also ensures framebuffer invalidated
@@ -445,6 +457,7 @@
             return this._worldMatrix;
         }
 
+        /** @hidden */
         public _getViewMatrix(): Matrix {
             return Matrix.Identity();
         }
@@ -652,7 +665,7 @@
                 var i = this._postProcesses.length;
                 while (--i >= 0) {
                     var postProcess = this._postProcesses[i]
-                    if(postProcess){
+                    if (postProcess) {
                         postProcess.dispose(this);
                     }
                 }
@@ -858,6 +871,7 @@
 
         /**
          * May need to be overridden by children
+         * @hidden
          */
         public _updateRigCameras() {
             for (var i = 0; i < this._rigCameras.length; i++) {
@@ -872,6 +886,7 @@
             }
         }
 
+        /** @hidden */
         public _setupInputs() {
         }
 

src/Cameras/babylon.deviceOrientationCamera.ts

@@ -36,6 +36,7 @@ module BABYLON {
         }
 
         /**
+         * @hidden
          * Checks and applies the current values of the inputs to the camera. (Internal use only)
          */
         public _checkInputs(): void {

src/Cameras/babylon.followCamera.ts

@@ -5,7 +5,7 @@
 
     Node.AddNodeConstructor("ArcFollowCamera", (name, scene) => {
         return () => new ArcFollowCamera(name, 0, 0, 1.0, null, scene);
-    });    
+    });
 
     export class FollowCamera extends TargetCamera {
         @serialize()
@@ -76,6 +76,7 @@
             this.setTarget(targetPosition);
         }
 
+        /** @hidden */
         public _checkInputs(): void {
             super._checkInputs();
             if (this.lockedTarget) {
@@ -110,6 +111,7 @@
             this.setTarget(targetPosition);
         }
 
+        /** @hidden */
         public _checkInputs(): void {
             super._checkInputs();
             this.follow();

src/Cameras/babylon.freeCamera.ts

@@ -1,7 +1,7 @@
 module BABYLON {
     Node.AddNodeConstructor("FreeCamera", (name, scene) => {
         // Forcing to use the Universal camera
-        return () => new UniversalCamera(name, Vector3.Zero(), scene);   
+        return () => new UniversalCamera(name, Vector3.Zero(), scene);
     });
 
     export class FreeCamera extends TargetCamera {
@@ -108,7 +108,9 @@
         private _diffPosition = Vector3.Zero();
         private _newPosition = Vector3.Zero();
 
+        /** @hidden */
         public _localDirection: Vector3;
+        /** @hidden */
         public _transformedDirection: Vector3;
 
         constructor(name: string, position: Vector3, scene: Scene, setActiveOnSceneIfNoneActive = true) {
@@ -140,6 +142,7 @@
             this._collisionMask = !isNaN(mask) ? mask : -1;
         }
 
+        /** @hidden */
         public _collideWithWorld(displacement: Vector3): void {
             var globalPosition: Vector3;
 
@@ -193,6 +196,7 @@
             updatePosition(newPosition);
         }
 
+        /** @hidden */
         public _checkInputs(): void {
             if (!this._localDirection) {
                 this._localDirection = Vector3.Zero();
@@ -204,10 +208,12 @@
             super._checkInputs();
         }
 
+        /** @hidden */
         public _decideIfNeedsToMove(): boolean {
             return this._needMoveForGravity || Math.abs(this.cameraDirection.x) > 0 || Math.abs(this.cameraDirection.y) > 0 || Math.abs(this.cameraDirection.z) > 0;
         }
 
+        /** @hidden */
         public _updatePosition(): void {
             if (this.checkCollisions && this.getScene().collisionsEnabled) {
                 this._collideWithWorld(this.cameraDirection);

src/Cameras/babylon.targetCamera.ts

@@ -17,20 +17,28 @@
         @serializeAsMeshReference("lockedTargetId")
         public lockedTarget: any = null;
 
+        /** @hidden */
         public _currentTarget = Vector3.Zero();
+        /** @hidden */
         public _viewMatrix = Matrix.Zero();
+        /** @hidden */
         public _camMatrix = Matrix.Zero();
+        /** @hidden */
         public _cameraTransformMatrix = Matrix.Zero();
+        /** @hidden */
         public _cameraRotationMatrix = Matrix.Zero();
         private _rigCamTransformMatrix: Matrix;
 
+        /** @hidden */
         public _referencePoint = new Vector3(0, 0, 1);
         private _currentUpVector = new Vector3(0, 1, 0);
+        /** @hidden */
         public _transformedReferencePoint = Vector3.Zero();
 
         protected _globalCurrentTarget = Vector3.Zero();
         protected _globalCurrentUpVector = Vector3.Zero();
 
+        /** @hidden */
         public _reset: () => void;
 
         constructor(name: string, position: Vector3, scene: Scene, setActiveOnSceneIfNoneActive = true) {
@@ -45,6 +53,7 @@
             return this.globalPosition.add(direction);
         }
 
+        /** @hidden */
         public _getLockedTargetPosition(): Nullable<Vector3> {
             if (!this.lockedTarget) {
                 return null;
@@ -79,6 +88,7 @@
         /**
          * Restored camera state. You must call storeState() first
          * @returns whether it was successful or not
+         * @hidden
          */
         public _restoreStateValues(): boolean {
             if (!super._restoreStateValues()) {
@@ -99,6 +109,7 @@
         }
 
         // Cache
+        /** @hidden */
         public _initCache() {
             super._initCache();
             this._cache.lockedTarget = new Vector3(Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE);
@@ -106,6 +117,7 @@
             this._cache.rotationQuaternion = new Quaternion(Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE);
         }
 
+        /** @hidden */
         public _updateCache(ignoreParentClass?: boolean): void {
             if (!ignoreParentClass) {
                 super._updateCache();
@@ -130,6 +142,7 @@
         }
 
         // Synchronized
+        /** @hidden */
         public _isSynchronizedViewMatrix(): boolean {
             if (!super._isSynchronizedViewMatrix()) {
                 return false;
@@ -142,12 +155,14 @@
         }
 
         // Methods
+        /** @hidden */
         public _computeLocalCameraSpeed(): number {
             var engine = this.getEngine();
             return this.speed * Math.sqrt((engine.getDeltaTime() / (engine.getFps() * 100.0)));
         }
 
         // Target
+        /** @hidden */
         public setTarget(target: Vector3): void {
             this.upVector.normalize();
 
@@ -195,10 +210,12 @@
             return this._currentTarget;
         }
 
+        /** @hidden */
         public _decideIfNeedsToMove(): boolean {
             return Math.abs(this.cameraDirection.x) > 0 || Math.abs(this.cameraDirection.y) > 0 || Math.abs(this.cameraDirection.z) > 0;
         }
 
+        /** @hidden */
         public _updatePosition(): void {
             if (this.parent) {
                 this.parent.getWorldMatrix().invertToRef(Tmp.Matrix[0]);
@@ -208,6 +225,8 @@
             }
             this.position.addInPlace(this.cameraDirection);
         }
+
+        /** @hidden */
         public _checkInputs(): void {
             var needToMove = this._decideIfNeedsToMove();
             var needToRotate = Math.abs(this.cameraRotation.x) > 0 || Math.abs(this.cameraRotation.y) > 0;
@@ -283,6 +302,7 @@
             Vector3.TransformNormalToRef(this.upVector, this._cameraRotationMatrix, this._currentUpVector);
         }
 
+        /** @hidden */
         public _getViewMatrix(): Matrix {
             if (this.lockedTarget) {
                 this.setTarget(this._getLockedTargetPosition()!);
@@ -340,6 +360,7 @@
         }
 
         /**
+         * @hidden
          * @override
          * Override Camera._updateRigCameras
          */

src/Cameras/babylon.touchCamera.ts

@@ -46,6 +46,7 @@ module BABYLON {
             return "TouchCamera";
         }
 
+        /** @hidden */
         public _setupInputs() {
             var mouse = <FreeCameraMouseInput>this.inputs.attached["mouse"];
             if (mouse) {

src/Collisions/babylon.collider.ts

@@ -83,16 +83,22 @@
         private _slidePlaneNormal = Vector3.Zero();
         private _displacementVector = Vector3.Zero();
 
+        /** @hidden */
         public _radius = Vector3.One();
+        /** @hidden */
         public _retry = 0;
         private _velocity: Vector3;
         private _basePoint: Vector3;
         private _epsilon: number;
+        /** @hidden */
         public _velocityWorldLength: number;
+        /** @hidden */
         public _basePointWorld = Vector3.Zero();
         private _velocityWorld = Vector3.Zero();
         private _normalizedVelocity = Vector3.Zero();
+        /** @hidden */
         public _initialVelocity: Vector3;
+        /** @hidden */
         public _initialPosition: Vector3;
         private _nearestDistance: number;
 
@@ -114,6 +120,7 @@
         }
 
         // Methods
+        /** @hidden */
         public _initialize(source: Vector3, dir: Vector3, e: number): void {
             this._velocity = dir;
             Vector3.NormalizeToRef(dir, this._normalizedVelocity);
@@ -128,6 +135,7 @@
             this.collisionFound = false;
         }
 
+        /** @hidden */
         public _checkPointInTriangle(point: Vector3, pa: Vector3, pb: Vector3, pc: Vector3, n: Vector3): boolean {
             pa.subtractToRef(point, this._tempVector);
             pb.subtractToRef(point, this._tempVector2);
@@ -148,6 +156,7 @@
             return d >= 0;
         }
 
+        /** @hidden */
         public _canDoCollision(sphereCenter: Vector3, sphereRadius: number, vecMin: Vector3, vecMax: Vector3): boolean {
             var distance = Vector3.Distance(this._basePointWorld, sphereCenter);
 
@@ -163,6 +172,7 @@
             return true;
         }
 
+        /** @hidden */
         public _testTriangle(faceIndex: number, trianglePlaneArray: Array<Plane>, p1: Vector3, p2: Vector3, p3: Vector3, hasMaterial: boolean): void {
             var t0;
             var embeddedInPlane = false;
@@ -346,6 +356,7 @@
             }
         }
 
+        /** @hidden */
         public _collide(trianglePlaneArray: Array<Plane>, pts: Vector3[], indices: IndicesArray, indexStart: number, indexEnd: number, decal: number, hasMaterial: boolean): void {
             for (var i = indexStart; i < indexEnd; i += 3) {
                 var p1 = pts[indices[i] - decal];
@@ -356,6 +367,7 @@
             }
         }
 
+        /** @hidden */
         public _getResponse(pos: Vector3, vel: Vector3): void {
             pos.addToRef(vel, this._destinationPoint);
             vel.scaleInPlace((this._nearestDistance / vel.length()));

src/Culling/babylon.boundingInfo.ts

@@ -42,7 +42,7 @@
             return this._isLocked;
         }
 
-        public set isLocked(value: boolean) { 
+        public set isLocked(value: boolean) {
             this._isLocked = value;
         }
 
@@ -92,16 +92,16 @@
         /**
 		 * Gets the world distance between the min and max points of the bounding box
 		 */
-		public get diagonalLength(): number {
+        public get diagonalLength(): number {
             let boundingBox = this.boundingBox;
             let size = boundingBox.maximumWorld.subtract(boundingBox.minimumWorld);
-		    return size.length();
-		}     
+            return size.length();
+        }
 
         public isCompletelyInFrustum(frustumPlanes: Plane[]): boolean {
             return this.boundingBox.isCompletelyInFrustum(frustumPlanes);
         }
-       
+        /** @hidden */
         public _checkCollision(collider: Collider): boolean {
             return collider._canDoCollision(this.boundingSphere.centerWorld, this.boundingSphere.radiusWorld, this.boundingBox.minimumWorld, this.boundingBox.maximumWorld);
         }

src/Culling/babylon.boundingSphere.ts

@@ -33,7 +33,7 @@
             this.radius = distance * 0.5;
 
             this.centerWorld = Vector3.Zero();
-            this._update(Matrix.Identity());            
+            this._update(Matrix.Identity());
         }
 
         /**
@@ -54,6 +54,7 @@
         }
 
         // Methods
+        /** @hidden */
         public _update(world: Matrix): void {
             Vector3.TransformCoordinatesToRef(this.center, world, this.centerWorld);
             Vector3.TransformNormalFromFloatsToRef(1.0, 1.0, 1.0, world, this._tempRadiusVector);

src/Engine/babylon.nullEngine.ts

@@ -288,10 +288,12 @@
         public drawArraysType(fillMode: number, verticesStart: number, verticesCount: number, instancesCount?: number): void {
         }
 
+        /** @hidden */
         public _createTexture(): WebGLTexture {
             return {};
         }
 
+        /** @hidden */
         public _releaseTexture(texture: InternalTexture): void {
         }
 
@@ -404,6 +406,7 @@
         }
 
         /**
+         * @hidden
          * Get the current error code of the webGL context
          * @returns the error code
          * @see https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/getError
@@ -442,6 +445,7 @@
             return false;
         }
 
+        /** @hidden */
         public _bindTexture(channel: number, texture: InternalTexture): void {
             if (channel < 0) {
                 return;
@@ -450,6 +454,7 @@
             this._bindTextureDirectly(0, texture);
         }
 
+        /** @hidden */
         public _releaseBuffer(buffer: WebGLBuffer): boolean {
             buffer.references--;
 

src/Gamepad/Controllers/babylon.poseEnabledController.ts

@@ -147,6 +147,7 @@ module BABYLON {
 
         /**
          * Internal, the mesh attached to the controller
+         * @hidden
          */
         public _mesh: Nullable<AbstractMesh>; // a node that will be attached to this Gamepad
         private _poseControlledCamera: TargetCamera;
@@ -155,13 +156,15 @@ module BABYLON {
 
         /**
          * Internal, matrix used to convert room space to babylon space
+         * @hidden
          */
         public _deviceToWorld = Matrix.Identity();
 
         /**
          * Node to be used when casting a ray from the controller
+         * @hidden
          */
-        public _pointingPoseNode:Nullable<AbstractMesh> = null;
+        public _pointingPoseNode: Nullable<AbstractMesh> = null;
         /**
          * Name of the child mesh that can be used to cast a ray from the controller
          */
@@ -194,7 +197,7 @@ module BABYLON {
         /**
          * Updates only the pose device and mesh without doing any button event checking
          */
-        protected _updatePoseAndMesh(){
+        protected _updatePoseAndMesh() {
             var pose: GamepadPose = this.browserGamepad.pose;
             this.updateFromDevice(pose);
 
@@ -269,14 +272,14 @@ module BABYLON {
 
             // Sync controller mesh and pointing pose node's state with controller, this is done to avoid a frame where position is 0,0,0 when attaching mesh
             this._updatePoseAndMesh();
-            if(this._pointingPoseNode){
+            if (this._pointingPoseNode) {
                 var parents = [];
-                var obj:Node = this._pointingPoseNode;
-                while(obj.parent){
-                    parents.push(obj.parent); 
+                var obj: Node = this._pointingPoseNode;
+                while (obj.parent) {
+                    parents.push(obj.parent);
                     obj = obj.parent;
                 }
-                parents.reverse().forEach((p)=>{p.computeWorldMatrix(true)});
+                parents.reverse().forEach((p) => { p.computeWorldMatrix(true) });
             }
 
             this._meshAttachedObservable.notifyObservers(mesh);

src/Gamepad/babylon.gamepad.ts

@@ -10,7 +10,7 @@
         touchChanged: boolean;
         valueChanged: boolean;
     }
-    
+
     export class Gamepad {
 
         public type: number;
@@ -18,6 +18,7 @@
         private _leftStick: StickValues;
         private _rightStick: StickValues;
 
+        /** @hidden */
         public _isConnected = true;
 
         private _leftStickAxisX: number;
@@ -33,7 +34,7 @@
         public static XBOX = 2;
         public static POSE_ENABLED = 3;
 
-        protected _invertLeftStickY:boolean = false;
+        protected _invertLeftStickY: boolean = false;
 
         public get isConnected(): boolean {
             return this._isConnected;
@@ -83,7 +84,7 @@
         public update() {
             if (this._leftStick) {
                 this.leftStick = { x: this.browserGamepad.axes[this._leftStickAxisX], y: this.browserGamepad.axes[this._leftStickAxisY] };
-                if(this._invertLeftStickY){
+                if (this._invertLeftStickY) {
                     this.leftStick.y *= -1;
                 }
             }
@@ -92,14 +93,14 @@
             }
         }
 
-        public dispose() {            
+        public dispose() {
         }
     }
 
     export class GenericPad extends Gamepad {
         private _buttons: Array<number>;
         private _onbuttondown: (buttonPressed: number) => void;
-        private _onbuttonup: (buttonReleased: number) => void;        
+        private _onbuttonup: (buttonReleased: number) => void;
 
         public onButtonDownObservable = new Observable<number>();
         public onButtonUpObservable = new Observable<number>();
@@ -144,7 +145,7 @@
             }
         }
 
-        public dispose(){
+        public dispose() {
             super.dispose();
             this.onButtonDownObservable.clear();
             this.onButtonUpObservable.clear();

src/Gamepad/babylon.gamepadManager.ts

@@ -3,6 +3,7 @@
         private _babylonGamepads: Array<Gamepad> = [];
         private _oneGamepadConnected: boolean = false;
 
+        /** @hidden */
         public _isMonitoring: boolean = false;
         private _gamepadEventSupported: boolean;
         private _gamepadSupport: () => Array<any>;
@@ -160,6 +161,7 @@
             this._isMonitoring = false;
         }
 
+        /** @hidden */
         public _checkGamepadsStatus() {
             // Hack to be compatible Chrome
             this._updateGamepadObjects();

src/Layer/babylon.glowLayer.ts

@@ -9,7 +9,7 @@
         getGlowLayerByName(name: string): Nullable<GlowLayer>;
     }
 
-    AbstractScene.prototype.getGlowLayerByName = function(name: string): Nullable<GlowLayer> {
+    AbstractScene.prototype.getGlowLayerByName = function (name: string): Nullable<GlowLayer> {
         for (var index = 0; index < this.effectLayers.length; index++) {
             if (this.effectLayers[index].name === name && this.effectLayers[index].getEffectName() === GlowLayer.EffectName) {
                 return (<any>this.effectLayers[index]) as GlowLayer;
@@ -172,7 +172,7 @@
         /**
          * Get the effect name of the layer.
          * @return The effect name
-         */ 
+         */
         public getEffectName(): string {
             return GlowLayer.EffectName;
         }
@@ -182,8 +182,8 @@
          * to the main canvas at the end of the scene rendering.
          */
         protected _createMergeEffect(): Effect {
-             // Effect
-             return this._engine.createEffect("glowMapMerge",
+            // Effect
+            return this._engine.createEffect("glowMapMerge",
                 [VertexBuffer.PositionKind],
                 ["offset"],
                 ["textureSampler", "textureSampler2"],
@@ -241,12 +241,12 @@
             this._blurTexture2.renderParticles = false;
             this._blurTexture2.ignoreCameraViewport = true;
 
-            this._textures = [ this._blurTexture1, this._blurTexture2 ];
+            this._textures = [this._blurTexture1, this._blurTexture2];
 
             this._horizontalBlurPostprocess1 = new BlurPostProcess("GlowLayerHBP1", new Vector2(1.0, 0), this._options.blurKernelSize / 2, {
-                    width:  blurTextureWidth,
-                    height: blurTextureHeight
-                },
+                width: blurTextureWidth,
+                height: blurTextureHeight
+            },
                 null, Texture.BILINEAR_SAMPLINGMODE, this._scene.getEngine(), false, textureType);
             this._horizontalBlurPostprocess1.width = blurTextureWidth;
             this._horizontalBlurPostprocess1.height = blurTextureHeight;
@@ -255,15 +255,15 @@
             });
 
             this._verticalBlurPostprocess1 = new BlurPostProcess("GlowLayerVBP1", new Vector2(0, 1.0), this._options.blurKernelSize / 2, {
-                    width:  blurTextureWidth,
-                    height: blurTextureHeight
-                },
+                width: blurTextureWidth,
+                height: blurTextureHeight
+            },
                 null, Texture.BILINEAR_SAMPLINGMODE, this._scene.getEngine(), false, textureType);
 
             this._horizontalBlurPostprocess2 = new BlurPostProcess("GlowLayerHBP2", new Vector2(1.0, 0), this._options.blurKernelSize / 2, {
-                    width:  blurTextureWidth2,
-                    height: blurTextureHeight2
-                },
+                width: blurTextureWidth2,
+                height: blurTextureHeight2
+            },
                 null, Texture.BILINEAR_SAMPLINGMODE, this._scene.getEngine(), false, textureType);
             this._horizontalBlurPostprocess2.width = blurTextureWidth2;
             this._horizontalBlurPostprocess2.height = blurTextureHeight2;
@@ -272,14 +272,14 @@
             });
 
             this._verticalBlurPostprocess2 = new BlurPostProcess("GlowLayerVBP2", new Vector2(0, 1.0), this._options.blurKernelSize / 2, {
-                    width:  blurTextureWidth2,
-                    height: blurTextureHeight2
-                },
+                width: blurTextureWidth2,
+                height: blurTextureHeight2
+            },
                 null, Texture.BILINEAR_SAMPLINGMODE, this._scene.getEngine(), false, textureType);
 
-            this._postProcesses = [ this._horizontalBlurPostprocess1, this._verticalBlurPostprocess1, this._horizontalBlurPostprocess2, this._verticalBlurPostprocess2 ];
-            this._postProcesses1 = [ this._horizontalBlurPostprocess1, this._verticalBlurPostprocess1 ];
-            this._postProcesses2 = [ this._horizontalBlurPostprocess2, this._verticalBlurPostprocess2 ];
+            this._postProcesses = [this._horizontalBlurPostprocess1, this._verticalBlurPostprocess1, this._horizontalBlurPostprocess2, this._verticalBlurPostprocess2];
+            this._postProcesses1 = [this._horizontalBlurPostprocess1, this._verticalBlurPostprocess1];
+            this._postProcesses2 = [this._horizontalBlurPostprocess2, this._verticalBlurPostprocess2];
 
             this._mainTexture.samples = this._options.mainTextureSamples!;
             this._mainTexture.onAfterUnbindObservable.add(() => {
@@ -287,16 +287,16 @@
                 if (internalTexture) {
                     this._scene.postProcessManager.directRender(
                         this._postProcesses1,
-                        internalTexture, 
+                        internalTexture,
                         true);
 
-                        internalTexture = this._blurTexture2.getInternalTexture();
-                        if (internalTexture) {
-                            this._scene.postProcessManager.directRender(
-                                this._postProcesses2,
-                                internalTexture, 
-                                true);
-                        }
+                    internalTexture = this._blurTexture2.getInternalTexture();
+                    if (internalTexture) {
+                        this._scene.postProcessManager.directRender(
+                            this._postProcesses2,
+                            internalTexture,
+                            true);
+                    }
                 }
             });
 
@@ -343,7 +343,7 @@
             // Cache
             var engine = this._engine;
             var previousStencilBuffer = engine.getStencilBuffer();
-                
+
             // Draw order
             engine.setStencilBuffer(false);
 
@@ -380,7 +380,7 @@
                     this._emissiveTextureAndColor.color.set(
                         (<any>material).emissiveColor.r * textureLevel,
                         (<any>material).emissiveColor.g * textureLevel,
-                        (<any>material).emissiveColor .b * textureLevel,
+                        (<any>material).emissiveColor.b * textureLevel,
                         1.0);
                 }
                 else {
@@ -420,7 +420,7 @@
             var index = this._excludedMeshes.indexOf(mesh.uniqueId);
             if (index !== -1) {
                 this._excludedMeshes.splice(index, 1);
-            } 
+            }
         }
 
         /**
@@ -441,7 +441,7 @@
             var index = this._includedOnlyMeshes.indexOf(mesh.uniqueId);
             if (index !== -1) {
                 this._includedOnlyMeshes.splice(index, 1);
-            } 
+            }
         }
 
         /**
@@ -471,6 +471,7 @@
          * Free any resources and references associated to a mesh.
          * Internal use
          * @param mesh The mesh to free.
+         * @hidden
          */
         public _disposeMesh(mesh: Mesh): void {
             this.removeIncludedOnlyMesh(mesh);
@@ -481,7 +482,7 @@
           * Gets the class name of the effect layer
           * @returns the string with the class name of the effect layer
           */
-         public getClassName(): string {
+        public getClassName(): string {
             return "GlowLayer";
         }
 

src/Layer/babylon.highlightLayer.ts

@@ -8,7 +8,7 @@
         getHighlightLayerByName(name: string): Nullable<HighlightLayer>;
     }
 
-    AbstractScene.prototype.getHighlightLayerByName = function(name: string): Nullable<HighlightLayer> {
+    AbstractScene.prototype.getHighlightLayerByName = function (name: string): Nullable<HighlightLayer> {
         for (var index = 0; index < this.effectLayers.length; index++) {
             if (this.effectLayers[index].name === name && this.effectLayers[index].getEffectName() === HighlightLayer.EffectName) {
                 return (<any>this.effectLayers[index]) as HighlightLayer;
@@ -25,7 +25,7 @@
     class GlowBlurPostProcess extends PostProcess {
         constructor(name: string, public direction: Vector2, public kernel: number, options: number | PostProcessOptions, camera: Nullable<Camera>, samplingMode: number = Texture.BILINEAR_SAMPLINGMODE, engine?: Engine, reusable?: boolean) {
             super(name, "glowBlurPostProcess", ["screenSize", "direction", "blurWidth"], null, options, camera, samplingMode, engine, reusable);
-            
+
             this.onApplyObservable.add((effect: Effect) => {
                 effect.setFloat2("screenSize", this.width, this.height);
                 effect.setVector2("direction", this.direction);
@@ -269,7 +269,7 @@
         /**
          * Get the effect name of the layer.
          * @return The effect name
-         */ 
+         */
         public getEffectName(): string {
             return HighlightLayer.EffectName;
         }
@@ -279,8 +279,8 @@
          * to the main canvas at the end of the scene rendering.
          */
         protected _createMergeEffect(): Effect {
-             // Effect
-             return this._engine.createEffect("glowMapMerge",
+            // Effect
+            return this._engine.createEffect("glowMapMerge",
                 [VertexBuffer.PositionKind],
                 ["offset"],
                 ["textureSampler"],
@@ -321,7 +321,7 @@
             this._blurTexture.renderParticles = false;
             this._blurTexture.ignoreCameraViewport = true;
 
-            this._textures = [ this._blurTexture ];
+            this._textures = [this._blurTexture];
 
             if (this._options.alphaBlendingMode === Engine.ALPHA_COMBINE) {
                 this._downSamplePostprocess = new PassPostProcess("HighlightLayerPPP", this._options.blurTextureSizeRatio,
@@ -346,9 +346,9 @@
             }
             else {
                 this._horizontalBlurPostprocess = new BlurPostProcess("HighlightLayerHBP", new Vector2(1.0, 0), this._options.blurHorizontalSize / 2, {
-                        width:  blurTextureWidth,
-                        height: blurTextureHeight
-                    },
+                    width: blurTextureWidth,
+                    height: blurTextureHeight
+                },
                     null, Texture.BILINEAR_SAMPLINGMODE, this._scene.getEngine(), false, textureType);
                 this._horizontalBlurPostprocess.width = blurTextureWidth;
                 this._horizontalBlurPostprocess.height = blurTextureHeight;
@@ -357,9 +357,9 @@
                 });
 
                 this._verticalBlurPostprocess = new BlurPostProcess("HighlightLayerVBP", new Vector2(0, 1.0), this._options.blurVerticalSize / 2, {
-                        width:  blurTextureWidth,
-                        height: blurTextureHeight
-                    },
+                    width: blurTextureWidth,
+                    height: blurTextureHeight
+                },
                     null, Texture.BILINEAR_SAMPLINGMODE, this._scene.getEngine(), false, textureType);
 
                 this._postProcesses = [this._horizontalBlurPostprocess, this._verticalBlurPostprocess];
@@ -372,7 +372,7 @@
                 if (internalTexture) {
                     this._scene.postProcessManager.directRender(
                         this._postProcesses,
-                        internalTexture, 
+                        internalTexture,
                         true);
                 }
 
@@ -672,6 +672,7 @@
          * Free any resources and references associated to a mesh.
          * Internal use
          * @param mesh The mesh to free.
+         * @hidden
          */
         public _disposeMesh(mesh: Mesh): void {
             this.removeMesh(mesh);
@@ -724,7 +725,7 @@
           * Gets the class name of the effect layer
           * @returns the string with the class name of the effect layer
           */
-         public getClassName(): string {
+        public getClassName(): string {
             return "HighlightLayer";
         }
 
@@ -784,7 +785,7 @@
             for (index = 0; index < parsedHightlightLayer.excludedMeshes.length; index++) {
                 var mesh = scene.getMeshByID(parsedHightlightLayer.excludedMeshes[index]);
                 if (mesh) {
-                    hl.addExcludedMesh(<Mesh> mesh);
+                    hl.addExcludedMesh(<Mesh>mesh);
                 }
             }
 
@@ -794,7 +795,7 @@
                 var mesh = scene.getMeshByID(highlightedMesh.meshId);
 
                 if (mesh) {
-                    hl.addMesh(<Mesh> mesh, Color3.FromArray(highlightedMesh.color), highlightedMesh.glowEmissiveOnly);
+                    hl.addMesh(<Mesh>mesh, Color3.FromArray(highlightedMesh.color), highlightedMesh.glowEmissiveOnly);
                 }
             }
 

src/Layer/babylon.layer.ts

@@ -112,6 +112,7 @@
             this._indexBuffer = engine.createIndexBuffer(indices);
         }
 
+        /** @hidden */
         public _rebuild(): void {
             let vb = this._vertexBuffers[VertexBuffer.PositionKind];
 

src/LensFlare/babylon.lensFlareSystem.ts

@@ -95,7 +95,7 @@
 
             position = Vector3.TransformCoordinates(this.getEmitterPosition(), this._scene.getViewMatrix());
 
-            if (this.viewportBorder>0) {
+            if (this.viewportBorder > 0) {
                 globalViewport.x -= this.viewportBorder;
                 globalViewport.y -= this.viewportBorder;
                 globalViewport.width += this.viewportBorder * 2;
@@ -117,6 +117,7 @@
             return false;
         }
 
+        /** @hidden */
         public _isVisible(): boolean {
             if (!this._isEnabled || !this._scene.activeCamera) {
                 return false;
@@ -188,7 +189,7 @@
                 intensity = 1.0;
             }
 
-            if (this.viewportBorder>0) {
+            if (this.viewportBorder > 0) {
                 globalViewport.x += this.viewportBorder;
                 globalViewport.y += this.viewportBorder;
                 globalViewport.width -= this.viewportBorder * 2;

src/Lights/babylon.light.ts

@@ -305,7 +305,7 @@ module BABYLON {
 
         /**
          * Shadow generator associted to the light.
-         * Internal use only.
+         * @hidden Internal use only.
          */
         public _shadowGenerator: Nullable<IShadowGenerator>;
 

src/Materials/Textures/Procedurals/babylon.proceduralTexture.ts

@@ -3,6 +3,7 @@
         @serialize()
         private _size: number;
 
+        /** @hidden */
         @serialize()
         public _generateMipMaps: boolean;
 
@@ -21,15 +22,16 @@
         private _samplers = new Array<string>();
         private _fragment: any;
 
-        public _textures: {[key: string]: Texture} = {};
-        private _floats: {[key: string]: number} = {};
-        private _ints: {[key: string]: number} = {};
-        private _floatsArrays: {[key: string]: number[]} = {};
-        private _colors3: {[key: string]: Color3} = {};
-        private _colors4: {[key: string]: Color4} = {};
-        private _vectors2: {[key: string]: Vector2} = {};
-        private _vectors3: {[key: string]: Vector3} = {};
-        private _matrices: {[key: string]: Matrix} = {};
+        /** @hidden */
+        public _textures: { [key: string]: Texture } = {};
+        private _floats: { [key: string]: number } = {};
+        private _ints: { [key: string]: number } = {};
+        private _floatsArrays: { [key: string]: number[] } = {};
+        private _colors3: { [key: string]: Color3 } = {};
+        private _colors4: { [key: string]: Color4 } = {};
+        private _vectors2: { [key: string]: Vector2 } = {};
+        private _vectors3: { [key: string]: Vector3 } = {};
+        private _matrices: { [key: string]: Matrix } = {};
 
         private _fallbackTexture: Nullable<Texture>;
 
@@ -90,25 +92,26 @@
             this._indexBuffer = engine.createIndexBuffer(indices);
         }
 
+        /** @hidden */
         public _rebuild(): void {
             let vb = this._vertexBuffers[VertexBuffer.PositionKind];
 
             if (vb) {
                 vb._rebuild();
             }
-            
+
             this._createIndexBuffer();
 
             if (this.refreshRate === RenderTargetTexture.REFRESHRATE_RENDER_ONCE) {
                 this.refreshRate = RenderTargetTexture.REFRESHRATE_RENDER_ONCE;
-            }            
+            }
         }
 
         public reset(): void {
             if (this._effect === undefined) {
                 return;
-            }      
-            
+            }
+
             var engine = this._engine;
             engine._releaseEffect(this._effect);
         }
@@ -173,6 +176,7 @@
             this.resetRefreshCounter();
         }
 
+        /** @hidden */
         public _shouldRender(): boolean {
             if (!this.isEnabled || !this.isReady() || !this._texture) {
                 return false;
@@ -311,7 +315,7 @@
             // Float    
             for (name in this._ints) {
                 this._effect.setInt(name, this._ints[name]);
-            }            
+            }
 
             // Float    
             for (name in this._floats) {
@@ -347,8 +351,8 @@
             // Matrix      
             for (name in this._matrices) {
                 this._effect.setMatrix(name, this._matrices[name]);
-            }           
-            
+            }
+
             if (!this._texture) {
                 return;
             }

src/Materials/Textures/babylon.baseTexture.ts

@@ -28,10 +28,10 @@
 
         @serialize()
         public coordinatesIndex = 0;
-        
+
         @serialize("coordinatesMode")
         private _coordinatesMode = Texture.EXPLICIT_MODE;
-        
+
         /**
         * How a texture is mapped.
         *
@@ -59,8 +59,8 @@
         }
         public get coordinatesMode(): number {
             return this._coordinatesMode;
-        } 
-        
+        }
+
         /**
         * | Value | Type               | Description |
         * | ----- | ------------------ | ----------- |
@@ -70,7 +70,7 @@
         */
         @serialize()
         public wrapU = Texture.WRAP_ADDRESSMODE;
-        
+
         /**
         * | Value | Type               | Description |
         * | ----- | ------------------ | ----------- |
@@ -80,7 +80,7 @@
         */
         @serialize()
         public wrapV = Texture.WRAP_ADDRESSMODE;
-        
+
         /**
         * | Value | Type               | Description |
         * | ----- | ------------------ | ----------- |
@@ -172,6 +172,8 @@
         public delayLoadState = Engine.DELAYLOADSTATE_NONE;
 
         private _scene: Nullable<Scene>;
+
+        /** @hidden */
         public _texture: Nullable<InternalTexture>;
         private _uid: Nullable<string>;
 
@@ -257,6 +259,7 @@
             return false;
         }
 
+        /** @hidden */
         public _getFromCache(url: Nullable<string>, noMipmap: boolean, sampling?: number): Nullable<InternalTexture> {
             if (!this._scene) {
                 return null
@@ -277,6 +280,7 @@
             return null;
         }
 
+        /** @hidden */
         public _rebuild(): void {
 
         }

src/Materials/Textures/babylon.internalTexture.ts

@@ -382,6 +382,7 @@ module BABYLON {
             }
         }
 
+        /** @hidden */
         public _swapAndDie(target: InternalTexture): void {
             target._webGLTexture = this._webGLTexture;
 

src/Materials/Textures/babylon.multiRenderTarget.ts

@@ -94,6 +94,7 @@ module BABYLON {
             this._createTextures();
         }
 
+        /** @hidden */
         public _rebuild(): void {
             this.releaseInternalTextures();
             this._createInternalTextures();

src/Materials/Textures/babylon.renderTargetTexture.ts

@@ -29,7 +29,7 @@
         public get renderList(): Nullable<Array<AbstractMesh>> {
             return this._renderList;
         }
- 
+
         public set renderList(value: Nullable<Array<AbstractMesh>>) {
             this._renderList = value;
 
@@ -42,7 +42,7 @@
             var oldPush = array.push;
             array.push = (...items: AbstractMesh[]) => {
                 var result = oldPush.apply(array, items);
-                
+
                 this.getScene()!.meshes.forEach(mesh => {
                     mesh._markSubMeshesAsLightDirty();
                 })
@@ -71,7 +71,7 @@
         public ignoreCameraViewport: boolean = false;
 
         private _postProcessManager: Nullable<PostProcessManager>;
-        private _postProcesses: PostProcess[];        
+        private _postProcesses: PostProcess[];
 
         private _resizeObserver: Nullable<Observer<Engine>>;
 
@@ -135,11 +135,13 @@
         }
 
         public clearColor: Color4;
-        protected _size: number | {width: number, height: number};
-        protected _initialSizeParameter: number | {width: number, height: number} | {ratio: number}
+        protected _size: number | { width: number, height: number };
+        protected _initialSizeParameter: number | { width: number, height: number } | { ratio: number }
         protected _sizeRatio: Nullable<number>;
+        /** @hidden */
         public _generateMipMaps: boolean;
         protected _renderingManager: RenderingManager;
+        /** @hidden */
         public _waitingRenderList: string[];
         protected _doNotChangeAspectRatio: boolean;
         protected _currentRefreshId = -1;
@@ -172,7 +174,7 @@
          * When defined, the cubemap will switch to local mode
          * @see https://community.arm.com/graphics/b/blog/posts/reflections-based-on-local-cubemaps-in-unity
          * @example https://www.babylonjs-playground.com/#RNASML
-         */        
+         */
         public set boundingBoxSize(value: Vector3) {
             if (this._boundingBoxSize && this._boundingBoxSize.equals(value)) {
                 return;
@@ -210,7 +212,7 @@
          * @param isMulti True if multiple textures need to be created (Draw Buffers)
          * @param format The internal format of the buffer in the RTT (RED, RG, RGB, RGBA, ALPHA...)
          */
-        constructor(name: string, size: number | {width: number, height: number} | {ratio: number}, scene: Nullable<Scene>, generateMipMaps?: boolean, doNotChangeAspectRatio: boolean = true, type: number = Engine.TEXTURETYPE_UNSIGNED_INT, public isCube = false, samplingMode = Texture.TRILINEAR_SAMPLINGMODE, generateDepthBuffer = true, generateStencilBuffer = false, isMulti = false, format = Engine.TEXTUREFORMAT_RGBA) {
+        constructor(name: string, size: number | { width: number, height: number } | { ratio: number }, scene: Nullable<Scene>, generateMipMaps?: boolean, doNotChangeAspectRatio: boolean = true, type: number = Engine.TEXTURETYPE_UNSIGNED_INT, public isCube = false, samplingMode = Texture.TRILINEAR_SAMPLINGMODE, generateDepthBuffer = true, generateStencilBuffer = false, isMulti = false, format = Engine.TEXTUREFORMAT_RGBA) {
             super(null, scene, !generateMipMaps);
             scene = this.getScene();
 
@@ -227,7 +229,7 @@
             this._processSizeParameter(size);
 
             this._resizeObserver = this.getScene()!.getEngine().onResizeObservable.add(() => {
-            });            
+            });
 
             this._generateMipMaps = generateMipMaps ? true : false;
             this._doNotChangeAspectRatio = doNotChangeAspectRatio;
@@ -271,7 +273,7 @@
          * @param bilinearFiltering Specifies whether or not bilinear filtering is enable on the texture
          * @param generateStencil Specifies whether or not a stencil should be allocated in the texture
          */
-        public createDepthStencilTexture(comparisonFunction: number = 0, bilinearFiltering: boolean = true, generateStencil: boolean = false) : void {
+        public createDepthStencilTexture(comparisonFunction: number = 0, bilinearFiltering: boolean = true, generateStencil: boolean = false): void {
             if (!this.getScene()) {
                 return;
             }
@@ -286,15 +288,15 @@
             engine.setFrameBufferDepthStencilTexture(this);
         }
 
-        private _processSizeParameter(size: number | {width: number, height: number} | {ratio: number}): void {
-            if ((<{ratio: number}>size).ratio) {
-                this._sizeRatio = (<{ratio: number}>size).ratio;
+        private _processSizeParameter(size: number | { width: number, height: number } | { ratio: number }): void {
+            if ((<{ ratio: number }>size).ratio) {
+                this._sizeRatio = (<{ ratio: number }>size).ratio;
                 this._size = {
                     width: this._bestReflectionRenderTargetDimension(this._engine.getRenderWidth(), this._sizeRatio),
                     height: this._bestReflectionRenderTargetDimension(this._engine.getRenderHeight(), this._sizeRatio)
                 }
-            } else {            
-                this._size = <number | {width: number, height: number}>size;
+            } else {
+                this._size = <number | { width: number, height: number }>size;
             }
         }
 
@@ -333,10 +335,10 @@
         public addPostProcess(postProcess: PostProcess): void {
             if (!this._postProcessManager) {
                 let scene = this.getScene();
-                
+
                 if (!scene) {
                     return;
-                }                
+                }
                 this._postProcessManager = new PostProcessManager(scene);
                 this._postProcesses = new Array<PostProcess>();
             }
@@ -377,6 +379,7 @@
             }
         }
 
+        /** @hidden */
         public _shouldRender(): boolean {
             if (this._currentRefreshId === -1) { // At least render once
                 this._currentRefreshId = 1;
@@ -393,24 +396,24 @@
         }
 
         public getRenderSize(): number {
-            if ((<{width: number, height: number}>this._size).width) {
-                return (<{width: number, height: number}>this._size).width;
+            if ((<{ width: number, height: number }>this._size).width) {
+                return (<{ width: number, height: number }>this._size).width;
             }
 
             return <number>this._size;
         }
 
         public getRenderWidth(): number {
-            if ((<{width: number, height: number}>this._size).width) {
-                return (<{width: number, height: number}>this._size).width;
+            if ((<{ width: number, height: number }>this._size).width) {
+                return (<{ width: number, height: number }>this._size).width;
             }
 
             return <number>this._size;
         }
 
         public getRenderHeight(): number {
-            if ((<{width: number, height: number}>this._size).width) {
-                return (<{width: number, height: number}>this._size).height;
+            if ((<{ width: number, height: number }>this._size).width) {
+                return (<{ width: number, height: number }>this._size).height;
             }
 
             return <number>this._size;
@@ -434,16 +437,16 @@
             return super.getReflectionTextureMatrix();
         }
 
-        public resize(size: number | {width: number, height: number} | {ratio: number}) {
+        public resize(size: number | { width: number, height: number } | { ratio: number }) {
             this.releaseInternalTexture();
             let scene = this.getScene();
-            
+
             if (!scene) {
                 return;
             }
-            
+
             this._processSizeParameter(size);
-            
+
             if (this.isCube) {
                 this._texture = scene.getEngine().createRenderTargetCubeTexture(this.getRenderSize(), this._renderTargetOptions);
             } else {
@@ -486,7 +489,7 @@
                 }
 
                 var scene = this.getScene();
-                
+
                 if (!scene) {
                     return;
                 }
@@ -596,7 +599,7 @@
             let minimum = 128;
             let x = renderDimension * scale;
             let curved = Tools.NearestPOT(x + (minimum * minimum / (minimum + x)));
-            
+
             // Ensure we don't exceed the render dimension (while staying POT)
             return Math.min(Tools.FloorPOT(renderDimension), curved);
         }
@@ -612,7 +615,7 @@
 
         private renderToTarget(faceIndex: number, currentRenderList: AbstractMesh[], currentRenderListLength: number, useCameraPostProcess: boolean, dumpForDebug: boolean): void {
             var scene = this.getScene();
-            
+
             if (!scene) {
                 return;
             }
@@ -674,7 +677,7 @@
                     }
                 }
 
-            this.unbindFrameBuffer(engine, faceIndex);
+                this.unbindFrameBuffer(engine, faceIndex);
 
             } else {
                 this.onAfterRenderObservable.notifyObservers(faceIndex);
@@ -807,6 +810,7 @@
             super.dispose();
         }
 
+        /** @hidden */
         public _rebuild(): void {
             if (this.refreshRate === RenderTargetTexture.REFRESHRATE_RENDER_ONCE) {
                 this.refreshRate = RenderTargetTexture.REFRESHRATE_RENDER_ONCE;

src/Materials/Textures/babylon.texture.ts

@@ -88,6 +88,7 @@
         }
 
         private _noMipmap: boolean;
+        /** @hidden */
         public _invertY: boolean;
         private _rowGenerationMatrix: Matrix;
         private _cachedTextureMatrix: Matrix;
@@ -105,6 +106,7 @@
         private _cachedWAng: number;
         private _cachedProjectionMatrixId: number;
         private _cachedCoordinatesMode: number;
+        /** @hidden */
         public _samplingMode: number;
         /** @hidden */
         public _buffer: Nullable<string | ArrayBuffer | HTMLImageElement | Blob>;
@@ -245,10 +247,10 @@
             }
 
             let scene = this.getScene();
-            
+
             if (!scene) {
                 return;
-            }            
+            }
 
             this._samplingMode = samplingMode;
             scene.getEngine().updateTextureSamplingMode(samplingMode, this._texture);
@@ -312,7 +314,7 @@
             this._cachedTextureMatrix.m[8] = this._t0.x; this._cachedTextureMatrix.m[9] = this._t0.y; this._cachedTextureMatrix.m[10] = this._t0.z;
 
             let scene = this.getScene();
-            
+
             if (!scene) {
                 return this._cachedTextureMatrix;
             }
@@ -349,11 +351,11 @@
             if (!this._cachedTextureMatrix) {
                 this._cachedTextureMatrix = Matrix.Zero();
             }
-            
+
             if (!this._projectionModeMatrix) {
                 this._projectionModeMatrix = Matrix.Zero();
             }
-            
+
             this._cachedUOffset = this.uOffset;
             this._cachedVOffset = this.vOffset;
             this._cachedUScale = this.uScale;
@@ -439,8 +441,8 @@
         }
 
         // Statics
-        public static CreateFromBase64String(data: string, name: string, scene: Scene, noMipmap?: boolean, invertY?: boolean, samplingMode: number = Texture.TRILINEAR_SAMPLINGMODE, 
-                                            onLoad: Nullable<() => void> = null, onError: Nullable<() => void> = null, format: number = Engine.TEXTUREFORMAT_RGBA): Texture {
+        public static CreateFromBase64String(data: string, name: string, scene: Scene, noMipmap?: boolean, invertY?: boolean, samplingMode: number = Texture.TRILINEAR_SAMPLINGMODE,
+            onLoad: Nullable<() => void> = null, onError: Nullable<() => void> = null, format: number = Engine.TEXTUREFORMAT_RGBA): Texture {
             return new Texture("data:" + name, scene, noMipmap, invertY, samplingMode, onLoad, onError, data, false, format);
         }
 
@@ -486,9 +488,9 @@
                     if (parsedTexture.base64String) {
                         texture = Texture.CreateFromBase64String(parsedTexture.base64String, parsedTexture.name, scene, !generateMipMaps);
                     } else {
-                        let url = rootUrl + parsedTexture.name; 
+                        let url = rootUrl + parsedTexture.name;
 
-                        if (Texture.UseSerializedUrlIfAny && parsedTexture.url ) {
+                        if (Texture.UseSerializedUrlIfAny && parsedTexture.url) {
                             url = parsedTexture.url;
                         }
                         texture = new Texture(url, scene, !generateMipMaps, parsedTexture.invertY);
@@ -518,8 +520,8 @@
             return texture;
         }
 
-        public static LoadFromDataString(name: string, buffer: any, scene: Scene, deleteBuffer: boolean = false, noMipmap: boolean = false, invertY: boolean = true, samplingMode: number = Texture.TRILINEAR_SAMPLINGMODE, 
-                                    onLoad: Nullable<() => void> = null, onError: Nullable<(message?: string, exception?: any) => void> = null, format: number = Engine.TEXTUREFORMAT_RGBA): Texture {
+        public static LoadFromDataString(name: string, buffer: any, scene: Scene, deleteBuffer: boolean = false, noMipmap: boolean = false, invertY: boolean = true, samplingMode: number = Texture.TRILINEAR_SAMPLINGMODE,
+            onLoad: Nullable<() => void> = null, onError: Nullable<(message?: string, exception?: any) => void> = null, format: number = Engine.TEXTUREFORMAT_RGBA): Texture {
             if (name.substr(0, 5) !== "data:") {
                 name = "data:" + name;
             }

src/Materials/Textures/babylon.videoTexture.ts

@@ -94,7 +94,7 @@
             }
 
             this.video.setAttribute("playsinline", "");
-                
+
             this.video.addEventListener("canplay", this._createInternalTexture);
             this.video.addEventListener("paused", this._updateInternalTexture);
             this.video.addEventListener("seeked", this._updateInternalTexture);
@@ -114,14 +114,14 @@
             if (src instanceof HTMLVideoElement) {
                 return src.currentSrc;
             }
-    
+
             if (typeof src === "object") {
                 return src.toString();
             }
 
             return src;
         };
-    
+
         private _getVideo(src: string | string[] | HTMLVideoElement): HTMLVideoElement {
             if (src instanceof HTMLVideoElement) {
                 Tools.SetCorsBehavior(src.currentSrc, src);
@@ -189,13 +189,13 @@
                     playing.then(() => {
                         // Everything is good.
                     })
-                    .catch(() => {
-                        error = true;
-                        // On Chrome for instance, new policies might prevent playing without user interaction.
-                        if (this._onUserActionRequestedObservable && this._onUserActionRequestedObservable.hasObservers()) {
-                            this._onUserActionRequestedObservable.notifyObservers(this);
-                        }
-                    });
+                        .catch(() => {
+                            error = true;
+                            // On Chrome for instance, new policies might prevent playing without user interaction.
+                            if (this._onUserActionRequestedObservable && this._onUserActionRequestedObservable.hasObservers()) {
+                                this._onUserActionRequestedObservable.notifyObservers(this);
+                            }
+                        });
                 }
                 else {
                     this.video.onplaying = oldHandler;
@@ -227,7 +227,7 @@
         };
 
         /**
-         * Internal method to initiate `update`.
+         * @hidden Internal method to initiate `update`.
          */
         public _rebuild(): void {
             this.update();
@@ -281,7 +281,7 @@
 
         public dispose(): void {
             super.dispose();
-            
+
             if (this._onUserActionRequestedObservable) {
                 this._onUserActionRequestedObservable.clear();
                 this._onUserActionRequestedObservable = null;
@@ -321,7 +321,7 @@
 
             if (navigator.mediaDevices) {
                 navigator.mediaDevices.getUserMedia({ video: constraints })
-                    .then(function(stream) {
+                    .then(function (stream) {
                         if (video.mozSrcObject !== undefined) {
                             // hack for Firefox < 19
                             video.mozSrcObject = stream;
@@ -339,7 +339,7 @@
                         video.addEventListener("playing", onPlaying);
                         video.play();
                     })
-                    .catch(function(err) {
+                    .catch(function (err) {
                         Tools.Error(err.name);
                     });
             }
@@ -379,7 +379,7 @@
                                 onReady(new VideoTexture("video", video, scene, true, true));
                             }
                         },
-                        function(e: MediaStreamError) {
+                        function (e: MediaStreamError) {
                             Tools.Error(e.name);
                         }
                     );

src/Materials/babylon.effect.ts

@@ -234,6 +234,7 @@
         private _uniforms: Nullable<WebGLUniformLocation>[];
         /**
          * Key for the effect.
+         * @hidden
          */
         public _key: string;
         private _indexParameters: any;
@@ -245,6 +246,7 @@
         private _transformFeedbackVaryings: Nullable<string[]>;
         /**
          * Compiled shader to webGL program.
+         * @hidden
          */
         public _program: WebGLProgram;
         private _valueCache: { [key: string]: any };
@@ -725,6 +727,7 @@
          * @param fragmentSourceCode The source code for the fragment shader.
          * @param onCompiled Callback called when completed.
          * @param onError Callback called on error.
+         * @hidden
          */
         public _rebuildProgram(vertexSourceCode: string, fragmentSourceCode: string, onCompiled: (program: WebGLProgram) => void, onError: (message: string) => void) {
             this._isReady = false;
@@ -762,6 +765,7 @@
 
         /**
          * Prepares the effect
+         * @hidden
          */
         public _prepareEffect() {
             let attributesNames = this._attributesNames;
@@ -871,6 +875,7 @@
          * Binds a texture to the engine to be used as output of the shader.
          * @param channel Name of the output variable.
          * @param texture Texture to bind.
+         * @hidden
          */
         public _bindTexture(channel: string, texture: InternalTexture): void {
             this._engine._bindTexture(this._samplers.indexOf(channel), texture);

src/Materials/babylon.imageProcessingConfiguration.ts

@@ -156,6 +156,7 @@ module BABYLON {
             this._updateParameters();
         }
 
+        /** @hidden */
         @serialize()
         public _exposure = 1.0;
         /**
@@ -427,7 +428,7 @@ module BABYLON {
             defines.VIGNETTE = this.vignetteEnabled;
             defines.VIGNETTEBLENDMODEMULTIPLY = (this.vignetteBlendMode === ImageProcessingConfiguration._VIGNETTEMODE_MULTIPLY);
             defines.VIGNETTEBLENDMODEOPAQUE = !defines.VIGNETTEBLENDMODEMULTIPLY;
-            
+
             defines.TONEMAPPING = this.toneMappingEnabled;
             switch (this._toneMappingType) {
                 case ImageProcessingConfiguration.TONEMAPPING_ACES:

src/Materials/babylon.material.ts

@@ -446,7 +446,7 @@
          */
         public get alpha(): number {
             return this._alpha;
-        }        
+        }
 
         /**
          * Specifies if back face culling is enabled
@@ -528,7 +528,7 @@
             }
             this._onDisposeObserver = this.onDisposeObservable.add(callback);
         }
-        
+
         private _onBindObservable: Nullable<Observable<AbstractMesh>>;
 
         /**
@@ -752,11 +752,13 @@
         }
 
         /**
+         * @hidden
          * Stores the effects for the material
          */
         public _effect: Nullable<Effect>;
 
         /**
+         * @hidden
          * Specifies if the material was previously ready
          */
         public _wasPreviouslyReady = false;
@@ -825,10 +827,10 @@
             return ret;
         }
 
-         /**
-          * Gets the class name of the material
-          * @returns a string with the class name of the material
-          */
+        /**
+         * Gets the class name of the material
+         * @returns a string with the class name of the material
+         */
         public getClassName(): string {
             return "Material";
         }
@@ -1242,7 +1244,7 @@
                 defines.markAsFresnelDirty();
                 defines.markAsMiscDirty();
             });
-        }        
+        }
 
         /**
          * Indicates that lights need to be re-calculated for all submeshes
@@ -1333,7 +1335,7 @@
             if (this._onBindObservable) {
                 this._onBindObservable.clear();
             }
-            
+
             if (this._onUnBindObservable) {
                 this._onUnBindObservable.clear();
             }
@@ -1383,7 +1385,7 @@
          * @returns a new material
          */
         public static Parse(parsedMaterial: any, scene: Scene, rootUrl: string): any {
-            if (!parsedMaterial.customType || parsedMaterial.customType === "BABYLON.StandardMaterial" ) {
+            if (!parsedMaterial.customType || parsedMaterial.customType === "BABYLON.StandardMaterial") {
                 return StandardMaterial.Parse(parsedMaterial, scene, rootUrl);
             }
 

src/Materials/babylon.uniformBuffer.ts

@@ -376,6 +376,7 @@ module BABYLON {
             this._needSync = true;
         }
 
+        /** @hidden */
         public _rebuild(): void {
             if (this._noUBO) {
                 return;

src/Mesh/babylon.buffer.ts

@@ -105,9 +105,10 @@
             } else if (this._updatable) { // update buffer
                 this._engine.updateDynamicVertexBuffer(this._buffer, data);
                 this._data = data;
-            }     
+            }
         }
 
+        /** @hidden */
         public _rebuild(): void {
             this._buffer = null;
             this.create(this._data);

src/Mesh/babylon.groundMesh.ts

@@ -4,13 +4,21 @@
 
         private _heightQuads: { slope: Vector2; facet1: Vector4; facet2: Vector4 }[];
 
+        /** @hidden */
         public _subdivisionsX: number;
+        /** @hidden */
         public _subdivisionsY: number;
+        /** @hidden */
         public _width: number;
+        /** @hidden */
         public _height: number;
+        /** @hidden */
         public _minX: number;
+        /** @hidden */
         public _maxX: number;
+        /** @hidden */
         public _minZ: number;
+        /** @hidden */
         public _maxZ: number;
 
         constructor(name: string, scene: Scene) {

src/Mesh/babylon.instancedMesh.ts

@@ -202,6 +202,7 @@
             return this;
         }
 
+        /** @hidden */
         public _preActivate(): InstancedMesh {
             if (this._currentLOD) {
                 this._currentLOD._preActivate();
@@ -209,6 +210,7 @@
             return this;
         }
 
+        /** @hidden */
         public _activate(renderId: number): InstancedMesh {
             if (this._currentLOD) {
                 this._currentLOD._registerInstanceForRenderId(this, renderId);
@@ -235,6 +237,7 @@
             return this._currentLOD;
         }
 
+        /** @hidden */
         public _syncSubMeshes(): InstancedMesh {
             this.releaseSubMeshes();
             if (this._sourceMesh.subMeshes) {
@@ -245,6 +248,7 @@
             return this;
         }
 
+        /** @hidden */
         public _generatePointsArray(): boolean {
             return this._sourceMesh._generatePointsArray();
         }

src/Mesh/babylon.linesMesh.ts

@@ -44,18 +44,18 @@
 
             this._intersectionThreshold = 0.1;
 
-            var defines: String[] = []; 
+            var defines: String[] = [];
             var options = {
                 attributes: [VertexBuffer.PositionKind],
                 uniforms: ["world", "viewProjection"],
                 needAlphaBlending: true,
                 defines: defines
             };
-            
+
             if (useVertexAlpha === false) {
                 options.needAlphaBlending = false;
             }
-            
+
             if (!useVertexColor) {
                 options.uniforms.push("color");
             }
@@ -99,6 +99,7 @@
             throw new Error("LinesMeshes do not support createInstance.");
         }
 
+        /** @hidden */
         public _bind(subMesh: SubMesh, effect: Effect, fillMode: number): LinesMesh {
             if (!this._geometry) {
                 return this;
@@ -113,6 +114,7 @@
             return this;
         }
 
+        /** @hidden */
         public _draw(subMesh: SubMesh, fillMode: number, instancesCount?: number): LinesMesh {
             if (!this._geometry || !this._geometry.getVertexBuffers() || (!this._unIndexed && !this._geometry.getIndexBuffer())) {
                 return this;

src/Mesh/babylon.mesh.ts

@@ -1,7 +1,7 @@
 module BABYLON {
     /**
      * @hidden
-     **/        
+     **/
     export class _InstancesBatch {
         public mustReturn = false;
         public visibleInstances = new Array<Nullable<Array<InstancedMesh>>>();
@@ -111,12 +111,13 @@
                 this.onBeforeDrawObservable.remove(this._onBeforeDrawObserver);
             }
             this._onBeforeDrawObserver = this.onBeforeDrawObservable.add(callback);
-        }     
+        }
 
         // Members
         public delayLoadState = Engine.DELAYLOADSTATE_NONE;
         public instances = new Array<InstancedMesh>();
         public delayLoadingFile: string;
+        /** @hidden */
         public _binaryInfo: any;
         private _LODLevels = new Array<MeshLODLevel>();
         public onLODLevelSelection: (distance: number, mesh: Mesh, selectedLevel: Nullable<Mesh>) => void;
@@ -137,10 +138,14 @@
         }
 
         // Private
+        /** @hidden */
         public _geometry: Nullable<Geometry>;
+        /** @hidden */
         public _delayInfo: Array<string>;
+        /** @hidden */
         public _delayLoadingFunction: (any: any, mesh: Mesh) => void;
 
+        /** @hidden */
         public _visibleInstances: any = {};
         private _renderIdForInstances = new Array<number>();
         private _batchCache = new _InstancesBatch();
@@ -151,10 +156,12 @@
 
         private _effectiveMaterial: Material;
 
+        /** @hidden */
         public _shouldGenerateFlatShading: boolean;
         private _preActivateId: number;
 
         // Use by builder only to know what orientation were the mesh build in.
+        /** @hidden */
         public _originalBuilderSideOrientation: number = Mesh._DEFAULTSIDE;
 
         public overrideMaterialSideOrientation: Nullable<number> = null;
@@ -204,11 +211,11 @@
                 }
 
                 // Deep copy
-                Tools.DeepCopy(source, this, ["name", "material", "skeleton", "instances", "parent", "uniqueId", 
-                                              "source", "metadata", "hasLODLevels", "geometry", "isBlocked", "areNormalsFrozen",
-                                              "onBeforeDrawObservable", "onBeforeRenderObservable", "onAfterRenderObservable", "onBeforeDraw"
-                                            ], 
-                                              ["_poseMatrix"]);
+                Tools.DeepCopy(source, this, ["name", "material", "skeleton", "instances", "parent", "uniqueId",
+                    "source", "metadata", "hasLODLevels", "geometry", "isBlocked", "areNormalsFrozen",
+                    "onBeforeDrawObservable", "onBeforeRenderObservable", "onAfterRenderObservable", "onBeforeDraw"
+                ],
+                    ["_poseMatrix"]);
 
                 // Source mesh
                 this._source = source;
@@ -315,13 +322,14 @@
             return ret;
         }
 
+        /** @hidden */
         public _unBindEffect() {
             super._unBindEffect();
 
             for (var instance of this.instances) {
                 instance._unBindEffect();
             }
-        }           
+        }
 
         /**
          * True if the mesh has some Levels Of Details (LOD).  
@@ -455,7 +463,7 @@
                         this.onLODLevelSelection(distanceToCamera, this, level.mesh);
                     }
 
-                    return level.mesh;                   
+                    return level.mesh;
                 }
             }
 
@@ -662,7 +670,7 @@
                             if (effectiveMaterial.storeEffectOnSubMeshes) {
                                 if (!effectiveMaterial.isReadyForSubMesh(this, subMesh, hardwareInstancedRendering)) {
                                     return false;
-                                } 
+                                }
                             }
                             else {
                                 if (!effectiveMaterial.isReady(this, hardwareInstancedRendering)) {
@@ -739,6 +747,7 @@
         }
 
         // Methods
+        /** @hidden */
         public _preActivate(): Mesh {
             var sceneRenderId = this.getScene().getRenderId();
             if (this._preActivateId === sceneRenderId) {
@@ -750,6 +759,7 @@
             return this;
         }
 
+        /** @hidden */
         public _preActivateForIntermediateRendering(renderId: number): Mesh {
             if (this._visibleInstances) {
                 this._visibleInstances.intermediateDefaultRenderId = renderId;
@@ -757,6 +767,7 @@
             return this;
         }
 
+        /** @hidden */
         public _registerInstanceForRenderId(instance: InstancedMesh, renderId: number): Mesh {
             if (!this._visibleInstances) {
                 this._visibleInstances = {};
@@ -781,6 +792,7 @@
             return this._refreshBoundingInfo(false);
         }
 
+        /** @hidden */
         public _refreshBoundingInfo(applySkeleton: boolean): Mesh {
             if (this._boundingInfo && this._boundingInfo.isLocked) {
                 return this;
@@ -853,6 +865,7 @@
             return data;
         }
 
+        /** @hidden */
         public _createGlobalSubMesh(force: boolean): Nullable<SubMesh> {
             var totalVertices = this.getTotalVertices();
             if (!totalVertices || !this.getIndices()) {
@@ -1062,6 +1075,7 @@
             return this;
         }
 
+        /** @hidden */
         public _bind(subMesh: SubMesh, effect: Effect, fillMode: number): Mesh {
             if (!this._geometry) {
                 return this;
@@ -1094,6 +1108,7 @@
             return this;
         }
 
+        /** @hidden */
         public _draw(subMesh: SubMesh, fillMode: number, instancesCount?: number, alternate = false): Mesh {
             if (!this._geometry || !this._geometry.getVertexBuffers() || (!this._unIndexed && !this._geometry.getIndexBuffer())) {
                 return this;
@@ -1176,6 +1191,7 @@
             return this;
         }
 
+        /** @hidden */
         public _getInstancesRenderList(subMeshId: number): _InstancesBatch {
             var scene = this.getScene();
             this._batchCache.mustReturn = false;
@@ -1212,6 +1228,7 @@
             return this._batchCache;
         }
 
+        /** @hidden */
         public _renderWithInstances(subMesh: SubMesh, fillMode: number, batch: _InstancesBatch, effect: Effect, engine: Engine): Mesh {
             var visibleInstances = batch.visibleInstances[subMesh._id];
             if (!visibleInstances) {
@@ -1274,6 +1291,7 @@
             return this;
         }
 
+        /** @hidden */
         public _processRendering(subMesh: SubMesh, effect: Effect, fillMode: number, batch: _InstancesBatch, hardwareInstancedRendering: boolean,
             onBeforeDraw: (isInstance: boolean, world: Matrix, effectiveMaterial?: Material) => void, effectiveMaterial?: Material): Mesh {
             var scene = this.getScene();
@@ -1487,7 +1505,7 @@
 
             return results;
         }
-        
+
         /**
          * Normalize matrix weights so that all vertices have a total weight set to 1
          */
@@ -1499,7 +1517,7 @@
                 noInfluenceBoneIndex = this.skeleton.bones.length;
             } else {
                 return;
-            }            
+            }
 
             let matricesIndices = (<FloatArray>this.getVerticesData(VertexBuffer.MatricesIndicesKind));
             let matricesIndicesExtra = (<FloatArray>this.getVerticesData(VertexBuffer.MatricesIndicesExtraKind));
@@ -1559,10 +1577,11 @@
             this.setVerticesData(VertexBuffer.MatricesWeightsKind, matricesWeights);
             if (matricesWeightsExtra) {
                 this.setVerticesData(VertexBuffer.MatricesWeightsExtraKind, matricesWeightsExtra);
-            }            
+            }
         }
 
 
+        /** @hidden */
         public _checkDelayState(): Mesh {
             var scene = this.getScene();
             if (this._geometry) {
@@ -1739,6 +1758,7 @@
             return null;
         }
 
+        /** @hidden */
         public _resetPointsArrayCache(): Mesh {
             if (this._geometry) {
                 this._geometry._resetPointsArrayCache();
@@ -1746,6 +1766,7 @@
             return this;
         }
 
+        /** @hidden */
         public _generatePointsArray(): boolean {
             if (this._geometry) {
                 return this._geometry._generatePointsArray();
@@ -1787,7 +1808,7 @@
 
             if (this._onAfterRenderObservable) {
                 this._onAfterRenderObservable.clear();
-            }            
+            }
 
             // Sources
             var meshes = this.getScene().meshes;
@@ -2353,6 +2374,7 @@
             }
         }
 
+        /** @hidden */
         public _syncGeometryWithMorphTargetManager() {
             if (!this.geometry) {
                 return;
@@ -2660,8 +2682,8 @@
 
                         if (parsedMesh.autoAnimate) {
                             scene.beginAnimation(instance, parsedMesh.autoAnimateFrom, parsedMesh.autoAnimateTo, parsedMesh.autoAnimateLoop, parsedMesh.autoAnimateSpeed || 1.0);
-                        }                            
-                }
+                        }
+                    }
                 }
             }
 

src/Mesh/babylon.subMesh.ts

@@ -1,6 +1,8 @@
 module BABYLON {
     export class BaseSubMesh {
+        /** @hidden */
         public _materialDefines: Nullable<MaterialDefines>;
+        /** @hidden */
         public _materialEffect: Nullable<Effect>;
 
         public get effect(): Nullable<Effect> {
@@ -26,13 +28,20 @@
         private _renderingMesh: Mesh;
         private _boundingInfo: BoundingInfo;
         private _linesIndexBuffer: Nullable<WebGLBuffer>;
+        /** @hidden */
         public _lastColliderWorldVertices: Nullable<Vector3[]>;
+        /** @hidden */
         public _trianglePlanes: Plane[];
+        /** @hidden */
         public _lastColliderTransformMatrix: Matrix;
 
+        /** @hidden */
         public _renderId = 0;
+        /** @hidden */
         public _alphaIndex: number;
+        /** @hidden */
         public _distanceToCamera: number;
+        /** @hidden */
         public _id: number;
 
         private _currentMaterial: Nullable<Material>;
@@ -152,6 +161,7 @@
             return this;
         }
 
+        /** @hidden */
         public _checkCollision(collider: Collider): boolean {
             let boundingInfo = this.getBoundingInfo();
 
@@ -314,6 +324,7 @@
             return intersectInfo;
         }
 
+        /** @hidden */
         public _rebuild(): void {
             if (this._linesIndexBuffer) {
                 this._linesIndexBuffer = null;

src/Mesh/babylon.transformNode.ts

@@ -6,7 +6,7 @@ module BABYLON {
         public static BILLBOARDMODE_Y = 2;
         public static BILLBOARDMODE_Z = 4;
         public static BILLBOARDMODE_ALL = 7;
-        
+
         private _forward = new Vector3(0, 0, 1);
         private _forwardInverted = new Vector3(0, 0, -1);
         private _up = new Vector3(0, 1, 0);
@@ -51,15 +51,18 @@ module BABYLON {
          * By default the system will update normals to compensate
          */
         @serialize()
-        public ignoreNonUniformScaling = false;        
+        public ignoreNonUniformScaling = false;
 
         @serializeAsVector3()
         public position = Vector3.Zero();
 
-        // Cache        
+        // Cache      
+        /** @hidden */
         public _poseMatrix: Matrix;
         private _localWorld = Matrix.Zero();
+        /** @hidden */
         public _worldMatrix = Matrix.Zero();
+        /** @hidden */
         public _worldMatrixDeterminant = 0;
         private _absolutePosition = Vector3.Zero();
         private _pivotMatrix = Matrix.Identity();
@@ -206,6 +209,7 @@ module BABYLON {
             return this._poseMatrix;
         }
 
+        /** @hidden */
         public _isSynchronized(): boolean {
             if (this._isDirty) {
                 return false;
@@ -239,6 +243,7 @@ module BABYLON {
             return true;
         }
 
+        /** @hidden */
         public _initCache() {
             super._initCache();
 
@@ -471,7 +476,7 @@ module BABYLON {
          * @param point defines the new pivot point to use
          * @param space defines if the point is in world or local space (local by default)
          * @returns the current TransformNode
-        */        
+        */
         public setPivotPoint(point: Vector3, space: Space = Space.LOCAL): TransformNode {
             if (this.getScene().getRenderId() == 0) {
                 this.computeWorldMatrix(true);
@@ -601,6 +606,7 @@ module BABYLON {
             return this._nonUniformScaling;
         }
 
+        /** @hidden */
         public _updateNonUniformScalingState(value: boolean): boolean {
             if (this._nonUniformScaling === value) {
                 return false;
@@ -792,7 +798,7 @@ module BABYLON {
                 Matrix.RotationYawPitchRollToRef(this.rotation.y, this.rotation.x, this.rotation.z, Tmp.Matrix[0]);
                 this._cache.rotation.copyFrom(this.rotation);
             }
-          
+
             // Translation
             let camera = (<Camera>this.getScene().activeCamera);
 
@@ -809,7 +815,7 @@ module BABYLON {
             }
 
             // Composing transformations
-            this._pivotMatrix.multiplyToRef(Tmp.Matrix[1], Tmp.Matrix[4]);           
+            this._pivotMatrix.multiplyToRef(Tmp.Matrix[1], Tmp.Matrix[4]);
             Tmp.Matrix[4].multiplyToRef(Tmp.Matrix[0], Tmp.Matrix[5]);
 
             // Billboarding (testing PG:http://www.babylonjs-playground.com/#UJEIL#13)
@@ -859,7 +865,7 @@ module BABYLON {
             // Post multiply inverse of pivotMatrix
             if (this._postMultiplyPivotMatrix) {
                 Tmp.Matrix[5].multiplyToRef(this._pivotMatrixInverse, Tmp.Matrix[5]);
-            }           
+            }
 
             // Local world
             Tmp.Matrix[5].multiplyToRef(Tmp.Matrix[2], this._localWorld);
@@ -902,7 +908,7 @@ module BABYLON {
                 } else {
                     this._updateNonUniformScalingState(false);
                 }
-            }else {
+            } else {
                 this._updateNonUniformScalingState(false);
             }
 

src/Particles/babylon.solidParticle.ts

@@ -55,14 +55,15 @@ module BABYLON {
         public isVisible: boolean = true;
         /**
          * Index of this particle in the global "positions" array (Internal use)
+         * @hidden
          */
         public _pos: number = 0;
         /**
-         * Index of this particle in the global "indices" array (Internal use)
+         * @hidden Index of this particle in the global "indices" array (Internal use)
          */
         public _ind: number = 0;
         /**
-         * ModelShape of this particle (Internal use)
+         * @hidden ModelShape of this particle (Internal use)
          */
         public _model: ModelShape;
         /**
@@ -74,23 +75,23 @@ module BABYLON {
          */
         public idxInShape: number = 0;
         /**
-         * Reference to the shape model BoundingInfo object (Internal use)
+         * @hidden Reference to the shape model BoundingInfo object (Internal use)
          */
         public _modelBoundingInfo: BoundingInfo;
         /**
-         * Particle BoundingInfo object (Internal use)
+         * @hidden Particle BoundingInfo object (Internal use)
          */
         public _boundingInfo: BoundingInfo;
         /**
-         * Reference to the SPS what the particle belongs to (Internal use)
+         * @hidden Reference to the SPS what the particle belongs to (Internal use)
          */
         public _sps: SolidParticleSystem;
         /**
-         * Still set as invisible in order to skip useless computations (Internal use)
+         * @hidden Still set as invisible in order to skip useless computations (Internal use)
          */
         public _stillInvisible: boolean = false;
         /**
-         * Last computed particle rotation matrix
+         * @hidden Last computed particle rotation matrix
          */
         public _rotationMatrix: number[] = [1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0];
         /**
@@ -99,7 +100,7 @@ module BABYLON {
          */
         public parentId: Nullable<number> = null;
         /**
-         * Internal global position in the SPS.
+         * @hidden Internal global position in the SPS.
          */
         public _globalPosition: Vector3 = Vector3.Zero();
 
@@ -179,27 +180,33 @@ module BABYLON {
      */
     export class ModelShape {
         /**
-         * The shape id.
+         * The shape id
+         * @hidden 
          */
         public shapeID: number;
         /**
          * flat array of model positions (internal use)
+         * @hidden 
          */
         public _shape: Vector3[];
         /**
          * flat array of model UVs (internal use)
+         * @hidden
          */
         public _shapeUV: number[];
         /**
          * length of the shape in the model indices array (internal use)
+         * @hidden
          */
         public _indicesLength: number = 0;
         /**
          * Custom position function (internal use)
+         * @hidden
          */
         public _positionFunction: Nullable<(particle: SolidParticle, i: number, s: number) => void>;
         /**
          * Custom vertex function (internal use)
+         * @hidden
          */
         public _vertexFunction: Nullable<(particle: SolidParticle, vertex: Vector3, i: number) => void>;
 
@@ -208,8 +215,8 @@ module BABYLON {
          * SPS internal tool, don't use it manually.
          * @hidden
          */
-        constructor(id: number, shape: Vector3[], indicesLength: number, shapeUV: number[], 
-                        posFunction: Nullable<(particle: SolidParticle, i: number, s: number) => void>, vtxFunction: Nullable<(particle: SolidParticle, vertex: Vector3, i: number) => void>) {
+        constructor(id: number, shape: Vector3[], indicesLength: number, shapeUV: number[],
+            posFunction: Nullable<(particle: SolidParticle, i: number, s: number) => void>, vtxFunction: Nullable<(particle: SolidParticle, vertex: Vector3, i: number) => void>) {
             this.shapeID = id;
             this._shape = shape;
             this._indicesLength = indicesLength;

src/Physics/babylon.physicsEngine.ts

@@ -61,7 +61,7 @@
 
         private _impostors: Array<PhysicsImpostor> = [];
         private _joints: Array<PhysicsImpostorJoint> = [];
-        
+
         /**
          * Adding a new impostor for the impostor tracking.
          * This will be done by the impostor itself.
@@ -124,6 +124,7 @@
 
         /**
          * Called by the scene. no need to call it.
+         * @hidden
          */
         public _step(delta: number) {
             //check if any mesh has no body / requires an update
@@ -146,7 +147,7 @@
         public getPhysicsPlugin(): IPhysicsEnginePlugin {
             return this._physicsPlugin;
         }
-        
+
         public getImpostors(): Array<PhysicsImpostor> {
             return this._impostors;
         }
@@ -202,13 +203,13 @@
         sleepBody(impostor: PhysicsImpostor): void;
         wakeUpBody(impostor: PhysicsImpostor): void;
         //Joint Update
-        updateDistanceJoint(joint: PhysicsJoint, maxDistance:number, minDistance?: number): void;
+        updateDistanceJoint(joint: PhysicsJoint, maxDistance: number, minDistance?: number): void;
         setMotor(joint: IMotorEnabledJoint, speed: number, maxForce?: number, motorIndex?: number): void;
         setLimit(joint: IMotorEnabledJoint, upperLimit: number, lowerLimit?: number, motorIndex?: number): void;
-        getRadius(impostor: PhysicsImpostor):number;
-        getBoxSizeToRef(impostor: PhysicsImpostor, result:Vector3): void;
-        syncMeshWithImpostor(mesh:AbstractMesh, impostor:PhysicsImpostor): void;
+        getRadius(impostor: PhysicsImpostor): number;
+        getBoxSizeToRef(impostor: PhysicsImpostor, result: Vector3): void;
+        syncMeshWithImpostor(mesh: AbstractMesh, impostor: PhysicsImpostor): void;
         dispose(): void;
     }
-    
+
 }

src/Physics/babylon.physicsImpostor.ts

@@ -149,6 +149,7 @@ module BABYLON {
          * It will create a new body - but only if this mesh has no parent.
          * If it has, this impostor will not be used other than to define the impostor
          * of the child mesh.
+         * @hidden
          */
         public _init() {
             if (!this._physicsEngine) {

src/PostProcess/RenderPipeline/Pipelines/babylon.ssao2RenderingPipeline.ts

@@ -247,6 +247,7 @@
             };
         }
 
+        /** @hidden */
         public _rebuild() {
             this._firstUpdate = true;
 

src/PostProcess/RenderPipeline/Pipelines/babylon.ssaoRenderingPipeline.ts

@@ -152,6 +152,7 @@
             });
         }
 
+        /** @hidden */
         public _rebuild() {
             this._firstUpdate = true;
             super._rebuild();

src/PostProcess/RenderPipeline/babylon.postProcessRenderEffect.ts

@@ -5,7 +5,7 @@ module BABYLON {
      * @example https://doc.babylonjs.com/how_to/how_to_use_postprocessrenderpipeline
      */
     export class PostProcessRenderEffect {
-        private _postProcesses: {[Key:string]:Array<PostProcess>};
+        private _postProcesses: { [Key: string]: Array<PostProcess> };
         private _getPostProcesses: () => Nullable<PostProcess | Array<PostProcess>>;
 
         private _singleInstance: boolean;
@@ -15,9 +15,10 @@ module BABYLON {
 
         /**
          * Name of the effect
+         * @hidden
          */
         public _name: string;
-        
+
         /**
          * Instantiates a post process render effect.
          * A post process can be used to apply a shader to a texture after it is rendered.
@@ -45,7 +46,7 @@ module BABYLON {
             for (var index in this._postProcesses) {
                 if (this._postProcesses.hasOwnProperty(index)) {
                     let pps = this._postProcesses[index];
-                    for(var ppIndex = 0; ppIndex < pps.length; ppIndex++){
+                    for (var ppIndex = 0; ppIndex < pps.length; ppIndex++) {
                         if (!pps[ppIndex].isSupported) {
                             return false;
                         }
@@ -57,6 +58,7 @@ module BABYLON {
 
         /**
          * Updates the current state of the effect
+         * @hidden
          */
         public _update(): void {
         }
@@ -64,16 +66,19 @@ module BABYLON {
         /**
          * Attaches the effect on cameras
          * @param cameras The camera to attach to.
+         * @hidden
          */
         public _attachCameras(cameras: Camera): void;
         /**
          * Attaches the effect on cameras
          * @param cameras The camera to attach to.
+         * @hidden
          */
         public _attachCameras(cameras: Camera[]): void;
         /**
          * Attaches the effect on cameras
          * @param cameras The camera to attach to.
+         * @hidden
          */
         public _attachCameras(cameras: any): void {
             var cameraKey;
@@ -95,10 +100,10 @@ module BABYLON {
                     cameraKey = cameraName;
                 }
 
-                if(!this._postProcesses[cameraKey]){
+                if (!this._postProcesses[cameraKey]) {
                     var postProcess = this._getPostProcesses();
-                    if(postProcess){
-                        this._postProcesses[cameraKey] = Array.isArray(postProcess) ? postProcess :[postProcess];
+                    if (postProcess) {
+                        this._postProcesses[cameraKey] = Array.isArray(postProcess) ? postProcess : [postProcess];
                     }
                 }
 
@@ -106,12 +111,12 @@ module BABYLON {
                     this._indicesForCamera[cameraName] = [];
                 }
 
-                this._postProcesses[cameraKey].forEach((postProcess:PostProcess) => {
+                this._postProcesses[cameraKey].forEach((postProcess: PostProcess) => {
                     var index = camera.attachPostProcess(postProcess);
-    
+
                     this._indicesForCamera[cameraName].push(index);
                 });
-                
+
                 if (!this._cameras[cameraName]) {
                     this._cameras[cameraName] = camera;
                 }
@@ -122,16 +127,19 @@ module BABYLON {
         /**
          * Detatches the effect on cameras
          * @param cameras The camera to detatch from.
+         * @hidden
          */
         public _detachCameras(cameras: Camera): void;
         /**
          * Detatches the effect on cameras
          * @param cameras The camera to detatch from.
+         * @hidden
          */
         public _detachCameras(cameras: Camera[]): void;
         /**
          * Detatches the effect on cameras
          * @param cameras The camera to detatch from.
+         * @hidden
          */
         public _detachCameras(cameras: any): void {
             var cams = Tools.MakeArray(cameras || this._cameras);
@@ -143,7 +151,7 @@ module BABYLON {
             for (var i = 0; i < cams.length; i++) {
                 var camera: Camera = cams[i];
                 var cameraName: string = camera.name;
-                this._postProcesses[this._singleInstance ? 0 : cameraName].forEach((postProcess:PostProcess)=>{
+                this._postProcesses[this._singleInstance ? 0 : cameraName].forEach((postProcess: PostProcess) => {
                     camera.detachPostProcess(postProcess);
                 })
 
@@ -157,19 +165,22 @@ module BABYLON {
         /**
          * Enables the effect on given cameras
          * @param cameras The camera to enable.
+         * @hidden
          */
         public _enable(cameras: Camera): void;
         /**
          * Enables the effect on given cameras
          * @param cameras The camera to enable.
+         * @hidden
          */
         public _enable(cameras: Nullable<Camera[]>): void;
         /**
          * Enables the effect on given cameras
          * @param cameras The camera to enable.
+         * @hidden
          */
         public _enable(cameras: any): void {
-            var cams:Nullable<Array<Camera>> = Tools.MakeArray(cameras || this._cameras);
+            var cams: Nullable<Array<Camera>> = Tools.MakeArray(cameras || this._cameras);
 
             if (!cams) {
                 return;
@@ -181,7 +192,7 @@ module BABYLON {
 
                 for (var j = 0; j < this._indicesForCamera[cameraName].length; j++) {
                     if (camera._postProcesses[this._indicesForCamera[cameraName][j]] === undefined || camera._postProcesses[this._indicesForCamera[cameraName][j]] === null) {
-                        this._postProcesses[this._singleInstance ? 0 : cameraName].forEach((postProcess)=>{
+                        this._postProcesses[this._singleInstance ? 0 : cameraName].forEach((postProcess) => {
                             cams![i].attachPostProcess(postProcess, this._indicesForCamera[cameraName][j]);
                         });
                     }
@@ -192,19 +203,22 @@ module BABYLON {
         /**
          * Disables the effect on the given cameras
          * @param cameras The camera to disable.
+         * @hidden
          */
         public _disable(cameras: Camera): void;
         /**
          * Disables the effect on the given cameras
          * @param cameras The camera to disable.
+         * @hidden
          */
         public _disable(cameras: Nullable<Camera[]>): void;
         /**
          * Disables the effect on the given cameras
          * @param cameras The camera to disable.
+         * @hidden
          */
         public _disable(cameras: any): void {
-            var cams:Nullable<Array<Camera>> = Tools.MakeArray(cameras || this._cameras);
+            var cams: Nullable<Array<Camera>> = Tools.MakeArray(cameras || this._cameras);
 
             if (!cams) {
                 return;
@@ -213,7 +227,7 @@ module BABYLON {
             for (var i = 0; i < cams.length; i++) {
                 var camera = cams[i];
                 var cameraName = camera.name;
-                this._postProcesses[this._singleInstance ? 0 : cameraName].forEach((postProcess)=>{
+                this._postProcesses[this._singleInstance ? 0 : cameraName].forEach((postProcess) => {
                     camera.detachPostProcess(postProcess);
                 });
             }

src/PostProcess/RenderPipeline/babylon.postProcessRenderPipeline.ts

@@ -1,12 +1,12 @@
 module BABYLON {
     export class PostProcessRenderPipeline {
 
-        private _renderEffects: {[key: string]: PostProcessRenderEffect};
+        private _renderEffects: { [key: string]: PostProcessRenderEffect };
         private _renderEffectsForIsolatedPass: PostProcessRenderEffect[];
 
         protected _cameras: Camera[];
 
-        // private
+        /** @hidden */
         @serialize()
         public _name: string;
 
@@ -21,7 +21,7 @@ module BABYLON {
 
         public getClassName(): string {
             return "PostProcessRenderPipeline";
-        }        
+        }
 
         public get isSupported(): boolean {
             for (var renderEffectName in this._renderEffects) {
@@ -41,12 +41,16 @@ module BABYLON {
 
         // private
 
+        /** @hidden */
         public _rebuild() {
-            
+
         }
 
+        /** @hidden */
         public _enableEffect(renderEffectName: string, cameras: Camera): void;
+        /** @hidden */
         public _enableEffect(renderEffectName: string, cameras: Camera[]): void;
+        /** @hidden */
         public _enableEffect(renderEffectName: string, cameras: any): void {
             var renderEffects: PostProcessRenderEffect = (<any>this._renderEffects)[renderEffectName];
 
@@ -69,8 +73,11 @@ module BABYLON {
             renderEffects._disable(Tools.MakeArray(cameras || this._cameras));
         }
 
+        /** @hidden */
         public _attachCameras(cameras: Camera, unique: boolean): void;
+        /** @hidden */
         public _attachCameras(cameras: Camera[], unique: boolean): void;
+        /** @hidden */
         public _attachCameras(cameras: any, unique: boolean): void {
             var cams = Tools.MakeArray(cameras || this._cameras);
 
@@ -103,8 +110,11 @@ module BABYLON {
             }
         }
 
+        /** @hidden */
         public _detachCameras(cameras: Camera): void;
+        /** @hidden */
         public _detachCameras(cameras: Nullable<Camera[]>): void;
+        /** @hidden */
         public _detachCameras(cameras: any): void {
             var cams = Tools.MakeArray(cameras || this._cameras);
 
@@ -123,6 +133,7 @@ module BABYLON {
             }
         }
 
+        /** @hidden */
         public _update(): void {
             for (var renderEffectName in this._renderEffects) {
                 if (this._renderEffects.hasOwnProperty(renderEffectName)) {
@@ -138,17 +149,18 @@ module BABYLON {
             }
         }
 
+        /** @hidden */
         public _reset(): void {
             this._renderEffects = {};
             this._renderEffectsForIsolatedPass = new Array<PostProcessRenderEffect>();
         }
 
-        protected _enableMSAAOnFirstPostProcess(sampleCount: number):boolean{
+        protected _enableMSAAOnFirstPostProcess(sampleCount: number): boolean {
             // Set samples of the very first post process to 4 to enable native anti-aliasing in browsers that support webGL 2.0 (See: https://github.com/BabylonJS/Babylon.js/issues/3754)
             var effectKeys = Object.keys(this._renderEffects);
-            if(this.engine.webGLVersion >= 2 && effectKeys.length > 0){
+            if (this.engine.webGLVersion >= 2 && effectKeys.length > 0) {
                 var postProcesses = this._renderEffects[effectKeys[0]].getPostProcesses();
-                if(postProcesses){
+                if (postProcesses) {
                     postProcesses[0].samples = sampleCount;
                     return true;
                 }
@@ -157,7 +169,7 @@ module BABYLON {
         }
 
         public dispose() {
-           // Must be implemented by children 
+            // Must be implemented by children 
         }
     }
 }

src/PostProcess/RenderPipeline/babylon.postProcessRenderPipelineManager.ts

@@ -1,7 +1,7 @@
 module BABYLON {
     export class PostProcessRenderPipelineManager {
-        private _renderPipelines: {[Key:string]:PostProcessRenderPipeline};
-        
+        private _renderPipelines: { [Key: string]: PostProcessRenderPipeline };
+
         constructor() {
             this._renderPipelines = {};
         }
@@ -72,6 +72,7 @@ module BABYLON {
             }
         }
 
+        /** @hidden */
         public _rebuild(): void {
             for (var renderPipelineName in this._renderPipelines) {
                 if (this._renderPipelines.hasOwnProperty(renderPipelineName)) {

src/PostProcess/babylon.bloomEffect.ts

@@ -2,51 +2,51 @@ module BABYLON {
     /**
      * The bloom effect spreads bright areas of an image to simulate artifacts seen in cameras
      */
-    export class BloomEffect extends PostProcessRenderEffect{
+    export class BloomEffect extends PostProcessRenderEffect {
         /**
-         * Internal
+         * @hidden Internal
          */
         public _effects: Array<PostProcess> = [];
 
         /**
-         * Internal
+         * @hidden Internal
          */
-        public _downscale:ExtractHighlightsPostProcess;
-        private _blurX:BlurPostProcess;
-        private _blurY:BlurPostProcess;
-        private _merge:BloomMergePostProcess;
-        
+        public _downscale: ExtractHighlightsPostProcess;
+        private _blurX: BlurPostProcess;
+        private _blurY: BlurPostProcess;
+        private _merge: BloomMergePostProcess;
+
         /**
          * The luminance threshold to find bright areas of the image to bloom. 
          */
-        public get threshold():number{
+        public get threshold(): number {
             return this._downscale.threshold;
         }
-        public set threshold(value: number){
+        public set threshold(value: number) {
             this._downscale.threshold = value;
         }
 
         /**
          * The strength of the bloom.
          */
-        public get weight():number{
+        public get weight(): number {
             return this._merge.weight;
         }
-        public set weight(value: number){
+        public set weight(value: number) {
             this._merge.weight = value;
         }
 
         /**
          * Specifies the size of the bloom blur kernel, relative to the final output size
          */
-        public get kernel():number{
+        public get kernel(): number {
             return this._blurX.kernel / this.bloomScale;
         }
-        public set kernel(value: number){
+        public set kernel(value: number) {
             this._blurX.kernel = value * this.bloomScale;
             this._blurY.kernel = value * this.bloomScale;
         }
-        
+
         /**
          * Creates a new instance of @see BloomEffect
          * @param scene The scene the effect belongs to.
@@ -56,8 +56,8 @@ module BABYLON {
          * @param pipelineTextureType The type of texture to be used when performing the post processing.
          * @param blockCompilation If compilation of the shader should not be done in the constructor. The updateEffect method can be used to compile the shader at a later time. (default: false)
          */
-        constructor(scene: Scene, private bloomScale:number, bloomWeight:number, bloomKernel:number, pipelineTextureType = 0, blockCompilation = false) {
-            super(scene.getEngine(), "bloom", ()=>{
+        constructor(scene: Scene, private bloomScale: number, bloomWeight: number, bloomKernel: number, pipelineTextureType = 0, blockCompilation = false) {
+            super(scene.getEngine(), "bloom", () => {
                 return this._effects;
             }, true);
             this._downscale = new ExtractHighlightsPostProcess("highlights", 1.0, null, Texture.BILINEAR_SAMPLINGMODE, scene.getEngine(), false, pipelineTextureType, blockCompilation);
@@ -83,17 +83,17 @@ module BABYLON {
          * Disposes each of the internal effects for a given camera.
          * @param camera The camera to dispose the effect on.
          */
-        public disposeEffects(camera:Camera){
-            for(var effectIndex = 0; effectIndex < this._effects.length; effectIndex++){
+        public disposeEffects(camera: Camera) {
+            for (var effectIndex = 0; effectIndex < this._effects.length; effectIndex++) {
                 this._effects[effectIndex].dispose(camera);
             }
         }
-        
+
         /**
-         * Internal
+         * @hidden Internal
          */
-        public _updateEffects(){
-            for(var effectIndex = 0; effectIndex < this._effects.length; effectIndex++){
+        public _updateEffects() {
+            for (var effectIndex = 0; effectIndex < this._effects.length; effectIndex++) {
                 this._effects[effectIndex].updateEffect();
             }
         }
@@ -101,10 +101,11 @@ module BABYLON {
         /**
          * Internal
          * @returns if all the contained post processes are ready.
+         * @hidden
          */
-        public _isReady(){
-            for(var effectIndex = 0; effectIndex < this._effects.length; effectIndex++){
-                if(!this._effects[effectIndex].isReady()){
+        public _isReady() {
+            for (var effectIndex = 0; effectIndex < this._effects.length; effectIndex++) {
+                if (!this._effects[effectIndex].isReady()) {
                     return false;
                 }
             }

src/PostProcess/babylon.depthOfFieldEffect.ts

@@ -19,54 +19,54 @@ module BABYLON {
     /**
      * The depth of field effect applies a blur to objects that are closer or further from where the camera is focusing.
      */
-    export class DepthOfFieldEffect extends PostProcessRenderEffect{
+    export class DepthOfFieldEffect extends PostProcessRenderEffect {
         private _circleOfConfusion: CircleOfConfusionPostProcess;
         /**
-         * Internal, blurs from high to low
+         * @hidden Internal, blurs from high to low
          */
         public _depthOfFieldBlurX: Array<DepthOfFieldBlurPostProcess>;
         private _depthOfFieldBlurY: Array<DepthOfFieldBlurPostProcess>;
         private _dofMerge: Nullable<DepthOfFieldMergePostProcess>;
 
         /**
-         * Internal post processes in depth of field effect
+         * @hidden Internal post processes in depth of field effect
          */
         public _effects: Array<PostProcess> = [];
 
         /**
          * The focal the length of the camera used in the effect in scene units/1000 (eg. millimeter)
          */
-        public set focalLength(value: number){
+        public set focalLength(value: number) {
             this._circleOfConfusion.focalLength = value;
         }
-        public get focalLength(){
+        public get focalLength() {
             return this._circleOfConfusion.focalLength;
         }
         /**
          * F-Stop of the effect's camera. The diamater of the resulting aperture can be computed by lensSize/fStop. (default: 1.4)
          */
-        public set fStop(value: number){
+        public set fStop(value: number) {
             this._circleOfConfusion.fStop = value;
         }
-        public get fStop(){
+        public get fStop() {
             return this._circleOfConfusion.fStop;
         }
         /**
          * Distance away from the camera to focus on in scene units/1000 (eg. millimeter). (default: 2000)
          */
-        public set focusDistance(value: number){
+        public set focusDistance(value: number) {
             this._circleOfConfusion.focusDistance = value;
         }
-        public get focusDistance(){
+        public get focusDistance() {
             return this._circleOfConfusion.focusDistance;
         }
         /**
          * Max lens size in scene units/1000 (eg. millimeter). Standard cameras are 50mm. (default: 50) The diamater of the resulting aperture can be computed by lensSize/fStop.
          */
-        public set lensSize(value: number){
+        public set lensSize(value: number) {
             this._circleOfConfusion.lensSize = value;
         }
-        public get lensSize(){
+        public get lensSize() {
             return this._circleOfConfusion.lensSize;
         }
 
@@ -78,7 +78,7 @@ module BABYLON {
          * @param blockCompilation If compilation of the shader should not be done in the constructor. The updateEffect method can be used to compile the shader at a later time. (default: false)
          */
         constructor(scene: Scene, depthTexture: Nullable<RenderTargetTexture>, blurLevel: DepthOfFieldEffectBlurLevel = DepthOfFieldEffectBlurLevel.Low, pipelineTextureType = 0, blockCompilation = false) {
-            super(scene.getEngine(), "depth of field", ()=>{
+            super(scene.getEngine(), "depth of field", () => {
                 return this._effects;
             }, true);
             // Circle of confusion value for each pixel is used to determine how much to blur that pixel
@@ -91,7 +91,7 @@ module BABYLON {
             this._depthOfFieldBlurX = []
             var blurCount = 1;
             var kernelSize = 15;
-            switch(blurLevel){
+            switch (blurLevel) {
                 case DepthOfFieldEffectBlurLevel.High: {
                     blurCount = 3;
                     kernelSize = 51;
@@ -108,21 +108,21 @@ module BABYLON {
                     break;
                 }
             }
-            var adjustedKernelSize = kernelSize/Math.pow(2, blurCount-1);
+            var adjustedKernelSize = kernelSize / Math.pow(2, blurCount - 1);
             var ratio = 1.0;
-            for(var i = 0;i<blurCount;i++){
+            for (var i = 0; i < blurCount; i++) {
                 var blurY = new DepthOfFieldBlurPostProcess("verticle blur", scene, new Vector2(0, 1.0), adjustedKernelSize, ratio, null, this._circleOfConfusion, i == 0 ? this._circleOfConfusion : null, Texture.BILINEAR_SAMPLINGMODE, scene.getEngine(), false, pipelineTextureType, blockCompilation);
                 blurY.autoClear = false;
-                ratio = 0.75/Math.pow(2, i);
-                var blurX = new DepthOfFieldBlurPostProcess("horizontal blur", scene, new Vector2(1.0, 0), adjustedKernelSize, ratio, null,  this._circleOfConfusion, null, Texture.BILINEAR_SAMPLINGMODE, scene.getEngine(), false, pipelineTextureType, blockCompilation);
+                ratio = 0.75 / Math.pow(2, i);
+                var blurX = new DepthOfFieldBlurPostProcess("horizontal blur", scene, new Vector2(1.0, 0), adjustedKernelSize, ratio, null, this._circleOfConfusion, null, Texture.BILINEAR_SAMPLINGMODE, scene.getEngine(), false, pipelineTextureType, blockCompilation);
                 blurX.autoClear = false;
                 this._depthOfFieldBlurY.push(blurY);
                 this._depthOfFieldBlurX.push(blurX);
             }
-            
+
             // Set all post processes on the effect.
-            this._effects= [this._circleOfConfusion];
-            for(var i=0;i<this._depthOfFieldBlurX.length;i++){
+            this._effects = [this._circleOfConfusion];
+            for (var i = 0; i < this._depthOfFieldBlurX.length; i++) {
                 this._effects.push(this._depthOfFieldBlurY[i]);
                 this._effects.push(this._depthOfFieldBlurX[i]);
             }
@@ -136,7 +136,7 @@ module BABYLON {
         /**
          * Depth texture to be used to compute the circle of confusion. This must be set here or in the constructor in order for the post process to function.
          */
-        public set depthTexture(value: RenderTargetTexture){
+        public set depthTexture(value: RenderTargetTexture) {
             this._circleOfConfusion.depthTexture = value;
         }
 
@@ -144,17 +144,17 @@ module BABYLON {
          * Disposes each of the internal effects for a given camera.
          * @param camera The camera to dispose the effect on.
          */
-        public disposeEffects(camera:Camera){
-            for(var effectIndex = 0; effectIndex < this._effects.length; effectIndex++){
+        public disposeEffects(camera: Camera) {
+            for (var effectIndex = 0; effectIndex < this._effects.length; effectIndex++) {
                 this._effects[effectIndex].dispose(camera);
             }
         }
 
         /**
-         * Internal
+         * @hidden Internal
          */
-        public _updateEffects(){
-            for(var effectIndex = 0; effectIndex <  this._effects.length; effectIndex++){
+        public _updateEffects() {
+            for (var effectIndex = 0; effectIndex < this._effects.length; effectIndex++) {
                 this._effects[effectIndex].updateEffect();
             }
         }
@@ -162,10 +162,11 @@ module BABYLON {
         /**
          * Internal
          * @returns if all the contained post processes are ready.
+         * @hidden
          */
-        public _isReady(){
-            for(var effectIndex = 0; effectIndex < this._effects.length; effectIndex++){
-                if(!this._effects[effectIndex].isReady()){
+        public _isReady() {
+            for (var effectIndex = 0; effectIndex < this._effects.length; effectIndex++) {
+                if (!this._effects[effectIndex].isReady()) {
                     return false;
                 }
             }

src/PostProcess/babylon.extractHighlightsPostProcess.ts

@@ -8,18 +8,17 @@ module BABYLON {
          */
         public threshold = 0.9;
 
-        /**
-         * Internal
-         */
+        /** @hidden */
         public _exposure = 1;
         /**
          * Post process which has the input texture to be used when performing highlight extraction
+         * @hidden
          */
-        public _inputPostProcess:Nullable<PostProcess> = null;
+        public _inputPostProcess: Nullable<PostProcess> = null;
         constructor(name: string, options: number | PostProcessOptions, camera: Nullable<Camera>, samplingMode?: number, engine?: Engine, reusable?: boolean, textureType: number = Engine.TEXTURETYPE_UNSIGNED_INT, blockCompilation = false) {
             super(name, "extractHighlights", ["threshold", "exposure"], null, options, camera, samplingMode, engine, reusable, null, textureType, undefined, null, blockCompilation);
             this.onApplyObservable.add((effect: Effect) => {
-                if(this._inputPostProcess){
+                if (this._inputPostProcess) {
                     effect.setTextureFromPostProcess("textureSampler", this._inputPostProcess);
                 }
                 effect.setFloat('threshold', Math.pow(this.threshold, BABYLON.ToGammaSpace));

src/PostProcess/babylon.postProcess.ts

@@ -17,6 +17,7 @@
 
         /**
         * Internal, reference to the location where this postprocess was output to. (Typically the texture on the next postprocess in the chain)
+        * @hidden
         */
         public _outputTexture: Nullable<InternalTexture> = null;
         /**
@@ -84,16 +85,18 @@
         private _camera: Camera;
         private _scene: Scene;
         private _engine: Engine;
-        
+
         private _options: number | PostProcessOptions;
         private _reusable = false;
         private _textureType: number;
         /**
         * Smart array of input and output textures for the post process.
+        * @hidden
         */
         public _textures = new SmartArray<InternalTexture>(2);
         /**
         * The index in _textures that corresponds to the output texture.
+        * @hidden
         */
         public _currentRenderTextureInd = 0;
         private _effect: Effect;
@@ -246,7 +249,7 @@
          */
         constructor(
             /** Name of the PostProcess. */
-            public name: string, 
+            public name: string,
             fragmentUrl: string, parameters: Nullable<string[]>, samplers: Nullable<string[]>, options: number | PostProcessOptions, camera: Nullable<Camera>,
             samplingMode: number = Texture.NEAREST_SAMPLINGMODE, engine?: Engine, reusable?: boolean, defines: Nullable<string> = null, textureType: number = Engine.TEXTURETYPE_UNSIGNED_INT, vertexUrl: string = "postprocess", indexParameters?: any, blockCompilation = false) {
             if (camera != null) {
@@ -317,7 +320,7 @@
          * This should be called if the post process that shares output with this post process is disabled/disposed.
          */
         public useOwnOutput() {
-            if(this._textures.length == 0){
+            if (this._textures.length == 0) {
                 this._textures = new SmartArray<InternalTexture>(2);
             }
 
@@ -380,8 +383,8 @@
 
             // If rendering to a webvr camera's left or right eye only half the width should be used to avoid resize when rendered to screen
             var webVRCamera = (<WebVRFreeCamera>camera.parent);
-            if(webVRCamera && (webVRCamera.leftCamera == camera || webVRCamera.rightCamera == camera)){
-                requiredWidth/=2;
+            if (webVRCamera && (webVRCamera.leftCamera == camera || webVRCamera.rightCamera == camera)) {
+                requiredWidth /= 2;
             }
 
             var desiredWidth = ((<PostProcessOptions>this._options).width || requiredWidth);
@@ -592,7 +595,7 @@
             var index = camera._postProcesses.indexOf(this);
             if (index === 0 && camera._postProcesses.length > 0) {
                 var firstPostProcess = this._camera._getFirstPostProcess();
-                if(firstPostProcess){
+                if (firstPostProcess) {
                     firstPostProcess.markTextureDirty();
                 }
             }

src/PostProcess/babylon.postProcessManager.ts

@@ -49,6 +49,7 @@
 
         /**
          * Rebuilds the vertex buffers of the manager.
+         * @hidden
          */
         public _rebuild(): void {
             let vb = this._vertexBuffers[VertexBuffer.PositionKind];
@@ -66,6 +67,7 @@
          * @param sourceTexture The input texture to the post procesess. (default: null)
          * @param postProcesses An array of post processes to be run. (default: null)
          * @returns True if the post processes were able to be run.
+         * @hidden
          */
         public _prepareFrame(sourceTexture: Nullable<InternalTexture> = null, postProcesses: Nullable<PostProcess[]> = null): boolean {
             let camera = this._scene.activeCamera;
@@ -73,7 +75,7 @@
                 return false;
             }
 
-            var postProcesses = postProcesses || (<Nullable<PostProcess[]>>camera._postProcesses.filter((pp)=>{return pp != null;}));
+            var postProcesses = postProcesses || (<Nullable<PostProcess[]>>camera._postProcesses.filter((pp) => { return pp != null; }));
 
             if (!postProcesses || postProcesses.length === 0 || !this._scene.postProcessesEnabled) {
                 return false;
@@ -134,6 +136,7 @@
          * @param faceIndex The index of the face to bind the target texture to.
          * @param postProcesses The array of post processes to render.
          * @param forceFullscreenViewport force gl.viewport to be full screen eg. 0,0,textureWidth,textureHeight (default: false)
+         * @hidden
          */
         public _finalizeFrame(doNotPresent?: boolean, targetTexture?: InternalTexture, faceIndex?: number, postProcesses?: Array<PostProcess>, forceFullscreenViewport = false): void {
             let camera = this._scene.activeCamera;
@@ -142,7 +145,7 @@
                 return;
             }
 
-            postProcesses = postProcesses || <Array<PostProcess>>camera._postProcesses.filter((pp)=>{return pp != null;});
+            postProcesses = postProcesses || <Array<PostProcess>>camera._postProcesses.filter((pp) => { return pp != null; });
             if (postProcesses.length === 0 || !this._scene.postProcessesEnabled) {
                 return;
             }
@@ -166,7 +169,7 @@
                 if (doNotPresent) {
                     break;
                 }
-                
+
                 var effect = pp.apply();
 
                 if (effect) {

src/Rendering/babylon.edgesRenderer.ts

@@ -52,6 +52,7 @@
             this._lineShader.backFaceCulling = false;
         }
 
+        /** @hidden */
         public _rebuild(): void {
             var buffer = this._buffers[VertexBuffer.PositionKind];
             if (buffer) {
@@ -279,7 +280,7 @@
                     }
                 }
             }
-            
+
             // Create lines
             for (index = 0; index < adjacencies.length; index++) {
                 // We need a line when a face has no adjacency on a specific edge or if all the adjacencies has an angle greater than epsilon

src/Rendering/babylon.renderingManager.ts

@@ -36,14 +36,14 @@
         public static AUTOCLEAR = true;
 
         /**
-         * Hidden
+         * @hidden
          */
         public _useSceneAutoClearSetup = false;
 
         private _scene: Scene;
         private _renderingGroups = new Array<RenderingGroup>();
         private _depthStencilBufferAlreadyCleaned: boolean;
-        
+
         private _autoClearDepthStencil: { [id: number]: IRenderingManagerAutoClearSetup } = {};
         private _customOpaqueSortCompareFn: { [id: number]: Nullable<(a: SubMesh, b: SubMesh) => number> } = {};
         private _customAlphaTestSortCompareFn: { [id: number]: Nullable<(a: SubMesh, b: SubMesh) => number> } = {};
@@ -98,7 +98,7 @@
 
                 // Clear depth/stencil if needed
                 if (RenderingManager.AUTOCLEAR) {
-                    const autoClear = this._useSceneAutoClearSetup ? 
+                    const autoClear = this._useSceneAutoClearSetup ?
                         this._scene.getAutoClearDepthStencilSetup(index) :
                         this._autoClearDepthStencil[index];
 

src/Sprites/babylon.sprite.ts

@@ -63,6 +63,7 @@
             this._animationStarted = false;
         }
 
+        /** @hidden */
         public _animate(deltaTime: number): void {
             if (!this._animationStarted)
                 return;