refactoring for managing backward compatibility

Tools/Gulp/config.json

@@ -48,6 +48,7 @@
       "../../src/cameras/inputs/babylon.freecamera.input.keyboard.js",
       "../../src/cameras/inputs/babylon.freecamera.input.touch.js",
       "../../src/cameras/inputs/babylon.freecamera.input.deviceorientation.js",
+      "../../src/cameras/inputs/babylon.freecamera.input.vrdeviceorientation.js",
       "../../src/cameras/inputs/babylon.freecamera.input.gamepad.js",
       "../../src/cameras/inputs/babylon.freecamera.input.virtualjoystick.js",
       "../../src/cameras/inputs/babylon.arcrotatecamera.input.keyboard.js",

src/Cameras/Inputs/babylon.arcrotatecamera.input.keyboard.js

@@ -84,7 +84,10 @@ var BABYLON;
             }
         };
         ArcRotateCameraKeyboardMoveInput.prototype.getTypeName = function () {
-            return "arcrotate.keyboard";
+            return "ArcRotateCameraKeyboardMoveInput";
+        };
+        ArcRotateCameraKeyboardMoveInput.prototype.getSimpleName = function () {
+            return "keyboard";
         };
         __decorate([
             BABYLON.serialize()
@@ -101,5 +104,5 @@ var BABYLON;
         return ArcRotateCameraKeyboardMoveInput;
     }());
     BABYLON.ArcRotateCameraKeyboardMoveInput = ArcRotateCameraKeyboardMoveInput;
-    BABYLON.CameraInputTypes["arcrotate.keyboard"] = ArcRotateCameraKeyboardMoveInput;
+    BABYLON.CameraInputTypes["ArcRotateCameraKeyboardMoveInput"] = ArcRotateCameraKeyboardMoveInput;
 })(BABYLON || (BABYLON = {}));

src/Cameras/Inputs/babylon.arcrotatecamera.input.keyboard.ts

@@ -96,9 +96,13 @@ module BABYLON {
         }
 
         getTypeName(): string {
-            return "arcrotate.keyboard";
+            return "ArcRotateCameraKeyboardMoveInput";
+        }
+        
+        getSimpleName(){
+            return "keyboard";
         }
     }
     
-    CameraInputTypes["arcrotate.keyboard"] = ArcRotateCameraKeyboardMoveInput;
+    CameraInputTypes["ArcRotateCameraKeyboardMoveInput"] = ArcRotateCameraKeyboardMoveInput;
 }

src/Cameras/Inputs/babylon.arcrotatecamera.input.mousewheel.js

@@ -40,7 +40,10 @@ var BABYLON;
             this.attachedElement.removeEventListener('DOMMouseScroll', this._wheel);
         };
         ArcRotateCameraMouseWheelInput.prototype.getTypeName = function () {
-            return "arcrotate.mousewheel";
+            return "ArcRotateCameraMouseWheelInput";
+        };
+        ArcRotateCameraMouseWheelInput.prototype.getSimpleName = function () {
+            return "mousewheel";
         };
         __decorate([
             BABYLON.serialize()
@@ -48,5 +51,5 @@ var BABYLON;
         return ArcRotateCameraMouseWheelInput;
     }());
     BABYLON.ArcRotateCameraMouseWheelInput = ArcRotateCameraMouseWheelInput;
-    BABYLON.CameraInputTypes["arcrotate.mousewheel"] = ArcRotateCameraMouseWheelInput;
+    BABYLON.CameraInputTypes["ArcRotateCameraMouseWheelInput"] = ArcRotateCameraMouseWheelInput;
 })(BABYLON || (BABYLON = {}));

src/Cameras/Inputs/babylon.arcrotatecamera.input.mousewheel.ts

@@ -41,9 +41,13 @@ module BABYLON {
         }
 
         getTypeName(): string {
-            return "arcrotate.mousewheel";
+            return "ArcRotateCameraMouseWheelInput";
+        }
+        
+        getSimpleName(){
+            return "mousewheel";
         }
     }
     
-    CameraInputTypes["arcrotate.mousewheel"] = ArcRotateCameraMouseWheelInput;
+    CameraInputTypes["ArcRotateCameraMouseWheelInput"] = ArcRotateCameraMouseWheelInput;
 }

src/Cameras/Inputs/babylon.arcrotatecamera.input.pointers.js

@@ -169,7 +169,10 @@ var BABYLON;
             ]);
         };
         ArcRotateCameraPointersInput.prototype.getTypeName = function () {
-            return "arcrotate.pointers";
+            return "ArcRotateCameraPointersInput";
+        };
+        ArcRotateCameraPointersInput.prototype.getSimpleName = function () {
+            return "pointers";
         };
         __decorate([
             BABYLON.serialize()
@@ -186,5 +189,5 @@ var BABYLON;
         return ArcRotateCameraPointersInput;
     }());
     BABYLON.ArcRotateCameraPointersInput = ArcRotateCameraPointersInput;
-    BABYLON.CameraInputTypes["arcrotate.pointers"] = ArcRotateCameraPointersInput;
+    BABYLON.CameraInputTypes["ArcRotateCameraPointersInput"] = ArcRotateCameraPointersInput;
 })(BABYLON || (BABYLON = {}));

src/Cameras/Inputs/babylon.arcrotatecamera.input.pointers.ts

@@ -217,9 +217,13 @@ module BABYLON {
         }        
 
         getTypeName(): string {
-            return "arcrotate.pointers";
+            return "ArcRotateCameraPointersInput";
+        }
+                
+        getSimpleName(){
+            return "pointers";
         }
     }
     
-    CameraInputTypes["arcrotate.pointers"] = ArcRotateCameraPointersInput;
+    CameraInputTypes["ArcRotateCameraPointersInput"] = ArcRotateCameraPointersInput;
 }

src/Cameras/Inputs/babylon.freecamera.input.deviceorientation.js

@@ -57,7 +57,10 @@ var BABYLON;
             camera.cameraDirection.addInPlace(BABYLON.Vector3.TransformCoordinates(direction, camera._cameraRotationMatrix));
         };
         FreeCameraDeviceOrientationInput.prototype.getTypeName = function () {
-            return "freecamera.deviceorientation";
+            return "FreeCameraDeviceOrientationInput";
+        };
+        FreeCameraDeviceOrientationInput.prototype.getSimpleName = function () {
+            return "deviceOrientation";
         };
         __decorate([
             BABYLON.serialize()
@@ -68,5 +71,5 @@ var BABYLON;
         return FreeCameraDeviceOrientationInput;
     }());
     BABYLON.FreeCameraDeviceOrientationInput = FreeCameraDeviceOrientationInput;
-    BABYLON.CameraInputTypes["freecamera.deviceorientation"] = FreeCameraDeviceOrientationInput;
+    BABYLON.CameraInputTypes["FreeCameraDeviceOrientationInput"] = FreeCameraDeviceOrientationInput;
 })(BABYLON || (BABYLON = {}));

src/Cameras/Inputs/babylon.freecamera.input.deviceorientation.ts

@@ -72,9 +72,13 @@ module BABYLON {
         }
 
         getTypeName(): string {
-            return "freecamera.deviceorientation";
+            return "FreeCameraDeviceOrientationInput";
+        }
+        
+        getSimpleName(){
+            return "deviceOrientation";
         }
     }
     
-    CameraInputTypes["freecamera.deviceorientation"] = FreeCameraDeviceOrientationInput;
+    CameraInputTypes["FreeCameraDeviceOrientationInput"] = FreeCameraDeviceOrientationInput;
 }

src/Cameras/Inputs/babylon.freecamera.input.gamepad.js

@@ -45,7 +45,10 @@ var BABYLON;
             }
         };
         FreeCameraGamepadInput.prototype.getTypeName = function () {
-            return "freecamera.gamepad";
+            return "FreeCameraGamepadInput";
+        };
+        FreeCameraGamepadInput.prototype.getSimpleName = function () {
+            return "gamepad";
         };
         __decorate([
             BABYLON.serialize()
@@ -56,5 +59,5 @@ var BABYLON;
         return FreeCameraGamepadInput;
     }());
     BABYLON.FreeCameraGamepadInput = FreeCameraGamepadInput;
-    BABYLON.CameraInputTypes["freecamera.gamepad"] = FreeCameraGamepadInput;
+    BABYLON.CameraInputTypes["FreeCameraGamepadInput"] = FreeCameraGamepadInput;
 })(BABYLON || (BABYLON = {}));

src/Cameras/Inputs/babylon.freecamera.input.gamepad.ts

@@ -55,9 +55,13 @@ module BABYLON {
         }
         
         getTypeName(): string{
-            return "freecamera.gamepad";
+            return "FreeCameraGamepadInput";
+        }
+        
+        getSimpleName(){
+            return "gamepad";
         }
     }
     
-    CameraInputTypes["freecamera.gamepad"] = FreeCameraGamepadInput;
+    CameraInputTypes["FreeCameraGamepadInput"] = FreeCameraGamepadInput;
 }

src/Cameras/Inputs/babylon.freecamera.input.keyboard.js

@@ -84,11 +84,14 @@ var BABYLON;
             }
         };
         FreeCameraKeyboardMoveInput.prototype.getTypeName = function () {
-            return "freecamera.keyboardmove";
+            return "FreeCameraKeyboardMoveInput";
         };
         FreeCameraKeyboardMoveInput.prototype._onLostFocus = function (e) {
             this._keys = [];
         };
+        FreeCameraKeyboardMoveInput.prototype.getSimpleName = function () {
+            return "keyboard";
+        };
         __decorate([
             BABYLON.serialize()
         ], FreeCameraKeyboardMoveInput.prototype, "keysUp", void 0);
@@ -104,5 +107,5 @@ var BABYLON;
         return FreeCameraKeyboardMoveInput;
     }());
     BABYLON.FreeCameraKeyboardMoveInput = FreeCameraKeyboardMoveInput;
-    BABYLON.CameraInputTypes["freecamera.keyboardmove"] = FreeCameraKeyboardMoveInput;
+    BABYLON.CameraInputTypes["FreeCameraKeyboardMoveInput"] = FreeCameraKeyboardMoveInput;
 })(BABYLON || (BABYLON = {}));

src/Cameras/Inputs/babylon.freecamera.input.keyboard.ts

@@ -94,13 +94,17 @@ module BABYLON {
         }
 
         getTypeName(): string {
-            return "freecamera.keyboardmove";
+            return "FreeCameraKeyboardMoveInput";
         }
 
         public _onLostFocus(e: FocusEvent): void {
             this._keys = [];
         }
+        
+        getSimpleName(){
+            return "keyboard";
+        }
     }
     
-    CameraInputTypes["freecamera.keyboardmove"] = FreeCameraKeyboardMoveInput;
+    CameraInputTypes["FreeCameraKeyboardMoveInput"] = FreeCameraKeyboardMoveInput;
 }

src/Cameras/Inputs/babylon.freecamera.input.mouse.js

@@ -87,7 +87,10 @@ var BABYLON;
             }
         };
         FreeCameraMouseInput.prototype.getTypeName = function () {
-            return "freecamera.mouse";
+            return "FreeCameraMouseInput";
+        };
+        FreeCameraMouseInput.prototype.getSimpleName = function () {
+            return "mouse";
         };
         __decorate([
             BABYLON.serialize()
@@ -95,5 +98,5 @@ var BABYLON;
         return FreeCameraMouseInput;
     }());
     BABYLON.FreeCameraMouseInput = FreeCameraMouseInput;
-    BABYLON.CameraInputTypes["freecamera.mouse"] = FreeCameraMouseInput;
+    BABYLON.CameraInputTypes["FreeCameraMouseInput"] = FreeCameraMouseInput;
 })(BABYLON || (BABYLON = {}));

src/Cameras/Inputs/babylon.freecamera.input.mouse.ts

@@ -105,9 +105,13 @@ module BABYLON {
         }
         
         getTypeName(): string{
-            return "freecamera.mouse";
+            return "FreeCameraMouseInput";
+        }
+        
+        getSimpleName(){
+            return "mouse";
         }
     }
     
-    CameraInputTypes["freecamera.mouse"] = FreeCameraMouseInput;
+    CameraInputTypes["FreeCameraMouseInput"] = FreeCameraMouseInput;
 }

src/Cameras/Inputs/babylon.freecamera.input.touch.js

@@ -121,7 +121,10 @@ var BABYLON;
             }
         };
         FreeCameraTouchInput.prototype.getTypeName = function () {
-            return "freecamera.touch";
+            return "FreeCameraTouchInput";
+        };
+        FreeCameraTouchInput.prototype.getSimpleName = function () {
+            return "touch";
         };
         __decorate([
             BABYLON.serialize()
@@ -132,5 +135,5 @@ var BABYLON;
         return FreeCameraTouchInput;
     }());
     BABYLON.FreeCameraTouchInput = FreeCameraTouchInput;
-    BABYLON.CameraInputTypes["freecamera.touch"] = FreeCameraTouchInput;
+    BABYLON.CameraInputTypes["FreeCameraTouchInput"] = FreeCameraTouchInput;
 })(BABYLON || (BABYLON = {}));

src/Cameras/Inputs/babylon.freecamera.input.touch.ts

@@ -154,9 +154,13 @@ module BABYLON {
         }
 
         getTypeName(): string {
-            return "freecamera.touch";
+            return "FreeCameraTouchInput";
+        }
+        
+        getSimpleName(){
+            return "touch";
         }
     }
     
-    CameraInputTypes["freecamera.touch"] = FreeCameraTouchInput;
+    CameraInputTypes["FreeCameraTouchInput"] = FreeCameraTouchInput;
 }

src/Cameras/Inputs/babylon.freecamera.input.virtualjoystick.js

@@ -40,10 +40,13 @@ var BABYLON;
             this._leftjoystick.releaseCanvas();
         };
         FreeCameraVirtualJoystickInput.prototype.getTypeName = function () {
-            return "freecamera.virtualjoystick";
+            return "FreeCameraVirtualJoystickInput";
+        };
+        FreeCameraVirtualJoystickInput.prototype.getSimpleName = function () {
+            return "virtualJoystick";
         };
         return FreeCameraVirtualJoystickInput;
     }());
     BABYLON.FreeCameraVirtualJoystickInput = FreeCameraVirtualJoystickInput;
-    BABYLON.CameraInputTypes["freecamera.virtualjoystick"] = FreeCameraVirtualJoystickInput;
+    BABYLON.CameraInputTypes["FreeCameraVirtualJoystickInput"] = FreeCameraVirtualJoystickInput;
 })(BABYLON || (BABYLON = {}));

src/Cameras/Inputs/babylon.freecamera.input.virtualjoystick.ts

@@ -49,9 +49,13 @@ module BABYLON {
         }
 
         getTypeName(): string {
-            return "freecamera.virtualjoystick";
+            return "FreeCameraVirtualJoystickInput";
+        }
+        
+        getSimpleName(){
+            return "virtualJoystick";
         }
     }
     
-    CameraInputTypes["freecamera.virtualjoystick"] = FreeCameraVirtualJoystickInput;
+    CameraInputTypes["FreeCameraVirtualJoystickInput"] = FreeCameraVirtualJoystickInput;
 }

src/Cameras/Inputs/babylon.freecamera.input.vrdeviceorientation.js

@@ -0,0 +1,43 @@
+var BABYLON;
+(function (BABYLON) {
+    var FreeCameraVRDeviceOrientationInput = (function () {
+        function FreeCameraVRDeviceOrientationInput() {
+            this._alpha = 0;
+            this._beta = 0;
+            this._gamma = 0;
+            this._deviceOrientationHandler = this._onOrientationEvent.bind(this);
+        }
+        FreeCameraVRDeviceOrientationInput.prototype.attachCamera = function (camera) {
+            this.camera = camera;
+            window.addEventListener("deviceorientation", this._deviceOrientationHandler);
+        };
+        FreeCameraVRDeviceOrientationInput.prototype._onOrientationEvent = function (evt) {
+            var camera = this.camera;
+            this._alpha = +evt.alpha | 0;
+            this._beta = +evt.beta | 0;
+            this._gamma = +evt.gamma | 0;
+            if (this._gamma < 0) {
+                this._gamma = 90 + this._gamma;
+            }
+            else {
+                // Incline it in the correct angle.
+                this._gamma = 270 - this._gamma;
+            }
+            camera.rotation.x = this._gamma / 180.0 * Math.PI;
+            camera.rotation.y = -this._alpha / 180.0 * Math.PI;
+            camera.rotation.z = this._beta / 180.0 * Math.PI;
+        };
+        FreeCameraVRDeviceOrientationInput.prototype.detach = function () {
+            window.removeEventListener("deviceorientation", this._deviceOrientationHandler);
+        };
+        FreeCameraVRDeviceOrientationInput.prototype.getTypeName = function () {
+            return "FreeCameraVRDeviceOrientationInput";
+        };
+        FreeCameraVRDeviceOrientationInput.prototype.getSimpleName = function () {
+            return "VRDeviceOrientation";
+        };
+        return FreeCameraVRDeviceOrientationInput;
+    }());
+    BABYLON.FreeCameraVRDeviceOrientationInput = FreeCameraVRDeviceOrientationInput;
+    BABYLON.CameraInputTypes["FreeCameraVRDeviceOrientationInput"] = FreeCameraVRDeviceOrientationInput;
+})(BABYLON || (BABYLON = {}));

src/Cameras/Inputs/babylon.freecamera.input.vrdeviceorientation.ts

@@ -0,0 +1,55 @@
+module BABYLON {
+    export class FreeCameraVRDeviceOrientationInput implements ICameraInput<FreeCamera> {
+        camera: FreeCamera;
+
+        public _alpha = 0;
+        public _beta = 0;
+        public _gamma = 0;
+    
+        private _offsetOrientation: { yaw: number; pitch: number; roll: number };
+        private _deviceOrientationHandler;
+        
+        constructor() {
+            this._deviceOrientationHandler = this._onOrientationEvent.bind(this);
+        }
+
+        attachCamera(camera: FreeCamera) {
+            this.camera = camera;
+
+            window.addEventListener("deviceorientation", this._deviceOrientationHandler);
+        }
+
+        public _onOrientationEvent(evt: DeviceOrientationEvent): void {
+            var camera = this.camera;
+            this._alpha = +evt.alpha|0;
+            this._beta = +evt.beta|0;
+            this._gamma = +evt.gamma|0;
+
+            if (this._gamma < 0) {
+                this._gamma = 90 + this._gamma;
+            }
+            else {
+                // Incline it in the correct angle.
+                this._gamma = 270 - this._gamma;
+            }
+
+            camera.rotation.x = this._gamma / 180.0 * Math.PI;   
+            camera.rotation.y = -this._alpha / 180.0 * Math.PI;   
+            camera.rotation.z = this._beta / 180.0 * Math.PI;     
+        }
+
+        detach() {
+            window.removeEventListener("deviceorientation", this._deviceOrientationHandler);
+        }
+
+        getTypeName(): string {
+            return "FreeCameraVRDeviceOrientationInput";
+        }
+        
+        getSimpleName(){
+            return "VRDeviceOrientation";
+        }
+    }
+    
+    CameraInputTypes["FreeCameraVRDeviceOrientationInput"] = FreeCameraVRDeviceOrientationInput;
+}

src/Cameras/VR/babylon.vrDeviceOrientationCamera.js

@@ -10,38 +10,11 @@ var BABYLON;
         function VRDeviceOrientationFreeCamera(name, position, scene, compensateDistortion) {
             if (compensateDistortion === void 0) { compensateDistortion = true; }
             _super.call(this, name, position, scene);
-            this._alpha = 0;
-            this._beta = 0;
-            this._gamma = 0;
             var metrics = BABYLON.VRCameraMetrics.GetDefault();
             metrics.compensateDistortion = compensateDistortion;
             this.setCameraRigMode(BABYLON.Camera.RIG_MODE_VR, { vrCameraMetrics: metrics });
-            this._deviceOrientationHandler = this._onOrientationEvent.bind(this);
+            this.inputs.addVRDeviceOrientation();
         }
-        VRDeviceOrientationFreeCamera.prototype._onOrientationEvent = function (evt) {
-            this._alpha = +evt.alpha | 0;
-            this._beta = +evt.beta | 0;
-            this._gamma = +evt.gamma | 0;
-            if (this._gamma < 0) {
-                this._gamma = 90 + this._gamma;
-            }
-            else {
-                // Incline it in the correct angle.
-                this._gamma = 270 - this._gamma;
-            }
-            this.rotation.x = this._gamma / 180.0 * Math.PI;
-            this.rotation.y = -this._alpha / 180.0 * Math.PI;
-            this.rotation.z = this._beta / 180.0 * Math.PI;
-        };
-        VRDeviceOrientationFreeCamera.prototype.attachControl = function (element, noPreventDefault) {
-            _super.prototype.attachControl.call(this, element, noPreventDefault);
-            noPreventDefault = BABYLON.Camera.ForceAttachControlToAlwaysPreventDefault ? false : noPreventDefault;
-            window.addEventListener("deviceorientation", this._deviceOrientationHandler);
-        };
-        VRDeviceOrientationFreeCamera.prototype.detachControl = function (element) {
-            _super.prototype.detachControl.call(this, element);
-            window.removeEventListener("deviceorientation", this._deviceOrientationHandler);
-        };
         VRDeviceOrientationFreeCamera.prototype.getTypeName = function () {
             return "VRDeviceOrientationFreeCamera";
         };

src/Cameras/VR/babylon.vrDeviceOrientationCamera.ts

@@ -1,11 +1,5 @@
 module BABYLON {
-    export class VRDeviceOrientationFreeCamera extends FreeCamera {
-        public _alpha = 0;
-        public _beta = 0;
-        public _gamma = 0;
-    
-        private _offsetOrientation: { yaw: number; pitch: number; roll: number };
-        private _deviceOrientationHandler;
+    export class VRDeviceOrientationFreeCamera extends FreeCamera {        
 
         constructor(name: string, position: Vector3, scene: Scene, compensateDistortion = true) {
             super(name, position, scene);
@@ -14,40 +8,9 @@ module BABYLON {
             metrics.compensateDistortion = compensateDistortion;
             this.setCameraRigMode(Camera.RIG_MODE_VR, { vrCameraMetrics: metrics });
 
-            this._deviceOrientationHandler = this._onOrientationEvent.bind(this);
+            this.inputs.addVRDeviceOrientation();
         }
 
-        public _onOrientationEvent(evt: DeviceOrientationEvent): void {
-            this._alpha = +evt.alpha|0;
-            this._beta = +evt.beta|0;
-            this._gamma = +evt.gamma|0;
-
-            if (this._gamma < 0) {
-                this._gamma = 90 + this._gamma;
-            }
-            else {
-                // Incline it in the correct angle.
-                this._gamma = 270 - this._gamma;
-            }
-
-            this.rotation.x = this._gamma / 180.0 * Math.PI;   
-            this.rotation.y = -this._alpha / 180.0 * Math.PI;   
-            this.rotation.z = this._beta / 180.0 * Math.PI;     
-        }
-
-        public attachControl(element: HTMLElement, noPreventDefault?: boolean): void {
-            super.attachControl(element, noPreventDefault);
-
-            noPreventDefault = Camera.ForceAttachControlToAlwaysPreventDefault ? false : noPreventDefault;
-
-            window.addEventListener("deviceorientation", this._deviceOrientationHandler);
-        }
-
-        public detachControl(element: HTMLElement): void {
-            super.detachControl(element);
-
-            window.removeEventListener("deviceorientation", this._deviceOrientationHandler);
-        }
 
         public getTypeName(): string {
             return "VRDeviceOrientationFreeCamera";

src/Cameras/babylon.arcRotateCamera.js

@@ -14,17 +14,6 @@ var BABYLON;
     // var eventPrefix = Tools.GetPointerPrefix();
     var ArcRotateCamera = (function (_super) {
         __extends(ArcRotateCamera, _super);
-        //deprecated angularSensibility support
-        // public get angularSensibility() {
-        //     Tools.Warn("Warning: angularSensibility is deprecated, use angularSensibilityX and angularSensibilityY instead.");
-        //     return Math.max(this.angularSensibilityX, this.angularSensibilityY);
-        // }
-        // //deprecated angularSensibility support
-        // public set angularSensibility(value) {
-        //     Tools.Warn("Warning: angularSensibility is deprecated, use angularSensibilityX and angularSensibilityY instead.");
-        //     this.angularSensibilityX = value;
-        //     this.angularSensibilityY = value;
-        // }
         function ArcRotateCamera(name, alpha, beta, radius, target, scene) {
             var _this = this;
             _super.call(this, name, BABYLON.Vector3.Zero(), scene);
@@ -37,31 +26,12 @@ var BABYLON;
             this.upperBetaLimit = Math.PI;
             this.lowerRadiusLimit = null;
             this.upperRadiusLimit = null;
-            // @serialize()
-            // public angularSensibilityX = 1000.0;
-            // @serialize()
-            // public angularSensibilityY = 1000.0;
-            // @serialize()
-            // public wheelPrecision = 3.0;
-            // @serialize()
-            // public pinchPrecision = 2.0;
-            // @serialize()
-            // public panningSensibility: number = 50.0;
             this.inertialPanningX = 0;
             this.inertialPanningY = 0;
-            // @serialize()
-            // public keysUp = [38];
-            // @serialize()
-            // public keysDown = [40];
-            // @serialize()
-            // public keysLeft = [37];
-            // @serialize()
-            // public keysRight = [39];
+            //-- end properties for backward compatibility for inputs        
             this.zoomOnFactor = 1;
             this.targetScreenOffset = BABYLON.Vector2.Zero();
-            // public pinchInwards = true;
             this.allowUpsideDown = true;
-            // private _keys = [];
             this._viewMatrix = new BABYLON.Matrix();
             // Panning
             this.panningAxis = new BABYLON.Vector3(1, 1, 0);
@@ -119,6 +89,193 @@ var BABYLON;
             this.inputs = new BABYLON.ArcRotateCameraInputsManager(this);
             this.inputs.addKeyboard().addMouseWheel().addPointers();
         }
+        Object.defineProperty(ArcRotateCamera.prototype, "angularSensibility", {
+            //-- 2016-03-08 properties for backward compatibility for inputs
+            //deprecated angularSensibility support
+            get: function () {
+                BABYLON.Tools.Warn("Warning: angularSensibility is deprecated on ArcRotateCamera, use camera.inputs.attached.pointers.angularSensibilityX and camera.inputs.attached.pointers.angularSensibilityY instead.");
+                var pointers = this.inputs.attached["pointers"];
+                if (pointers)
+                    return Math.max(pointers.angularSensibilityX, pointers.angularSensibilityY);
+            },
+            //deprecated angularSensibility support
+            set: function (value) {
+                BABYLON.Tools.Warn("Warning: angularSensibility is deprecated on ArcRotateCamera, use camera.inputs.attached.pointers.angularSensibilityX and camera.inputs.attached.pointers.angularSensibilityY instead.");
+                var pointers = this.inputs.attached["pointers"];
+                if (pointers) {
+                    pointers.angularSensibilityX = value;
+                    pointers.angularSensibilityY = value;
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(ArcRotateCamera.prototype, "angularSensibilityX", {
+            //deprecated angularSensibilityX support
+            get: function () {
+                BABYLON.Tools.Warn("Warning: angularSensibilityX is deprecated on ArcRotateCamera, use camera.inputs.attached.pointers.angularSensibilityX instead.");
+                var pointers = this.inputs.attached["pointers"];
+                if (pointers)
+                    return pointers.angularSensibilityX;
+            },
+            //deprecated angularSensibilityX support
+            set: function (value) {
+                BABYLON.Tools.Warn("Warning: angularSensibilityX is deprecated on ArcRotateCamera, use camera.inputs.attached.pointers.angularSensibilityX instead.");
+                var pointers = this.inputs.attached["pointers"];
+                if (pointers) {
+                    pointers.angularSensibilityX = value;
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(ArcRotateCamera.prototype, "angularSensibilityY", {
+            //deprecated angularSensibilityY support
+            get: function () {
+                BABYLON.Tools.Warn("Warning: angularSensibilityY is deprecated on ArcRotateCamera, use camera.inputs.attached.pointers.angularSensibilityY instead.");
+                var pointers = this.inputs.attached["pointers"];
+                if (pointers)
+                    return pointers.angularSensibilityY;
+            },
+            //deprecated angularSensibilityY support
+            set: function (value) {
+                BABYLON.Tools.Warn("Warning: angularSensibilityY is deprecated on ArcRotateCamera, use camera.inputs.attached.pointers.angularSensibilityY instead.");
+                var pointers = this.inputs.attached["pointers"];
+                if (pointers) {
+                    pointers.angularSensibilityY = value;
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(ArcRotateCamera.prototype, "pinchPrecision", {
+            //deprecated pinchPrecision support
+            get: function () {
+                BABYLON.Tools.Warn("Warning: pinchPrecision is deprecated on ArcRotateCamera, use camera.inputs.attached.pointers.pinchPrecision instead.");
+                var pointers = this.inputs.attached["pointers"];
+                if (pointers)
+                    return pointers.pinchPrecision;
+            },
+            //deprecated pinchPrecision support
+            set: function (value) {
+                BABYLON.Tools.Warn("Warning: pinchPrecision is deprecated on ArcRotateCamera, use camera.inputs.attached.pointers.pinchPrecision instead.");
+                var pointers = this.inputs.attached["pointers"];
+                if (pointers) {
+                    pointers.pinchPrecision = value;
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(ArcRotateCamera.prototype, "panningSensibility", {
+            //deprecated panningSensibility support
+            get: function () {
+                BABYLON.Tools.Warn("Warning: panningSensibility is deprecated on ArcRotateCamera, use camera.inputs.attached.pointers.panningSensibility instead.");
+                var pointers = this.inputs.attached["pointers"];
+                if (pointers)
+                    return pointers.panningSensibility;
+            },
+            //deprecated pinchPrecision support
+            set: function (value) {
+                BABYLON.Tools.Warn("Warning: panningSensibility is deprecated on ArcRotateCamera, use camera.inputs.attached.pointers.panningSensibility instead.");
+                var pointers = this.inputs.attached["pointers"];
+                if (pointers) {
+                    pointers.panningSensibility = value;
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(ArcRotateCamera.prototype, "keysUp", {
+            //deprecated
+            get: function () {
+                BABYLON.Tools.Warn("Warning: keysUp is deprecated on ArcRotateCamera, use camera.inputs.attached.keyboard.keysUp instead.");
+                var keyboard = this.inputs.attached["keyboard"];
+                if (keyboard)
+                    return keyboard.keysUp;
+            },
+            //deprecated
+            set: function (value) {
+                BABYLON.Tools.Warn("Warning: keysUp is deprecated on ArcRotateCamera, use camera.inputs.attached.keyboard.keysUp instead.");
+                var keyboard = this.inputs.attached["keyboard"];
+                if (keyboard)
+                    keyboard.keysUp = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(ArcRotateCamera.prototype, "keysDown", {
+            //deprecated
+            get: function () {
+                BABYLON.Tools.Warn("Warning: keysDown is deprecated on ArcRotateCamera, use camera.inputs.attached.keyboard.keysDown instead.");
+                var keyboard = this.inputs.attached["keyboard"];
+                if (keyboard)
+                    return keyboard.keysDown;
+            },
+            //deprecated
+            set: function (value) {
+                BABYLON.Tools.Warn("Warning: keysDown is deprecated on ArcRotateCamera, use camera.inputs.attached.keyboard.keysDown instead.");
+                var keyboard = this.inputs.attached["keyboard"];
+                if (keyboard)
+                    keyboard.keysDown = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(ArcRotateCamera.prototype, "keysLeft", {
+            //deprecated
+            get: function () {
+                BABYLON.Tools.Warn("Warning: keysLeft is deprecated on ArcRotateCamera, use camera.inputs.attached.keyboard.keysLeft instead.");
+                var keyboard = this.inputs.attached["keyboard"];
+                if (keyboard)
+                    return keyboard.keysLeft;
+            },
+            //deprecated
+            set: function (value) {
+                BABYLON.Tools.Warn("Warning: keysLeft is deprecated on ArcRotateCamera, use camera.inputs.attached.keyboard.keysLeft instead.");
+                var keyboard = this.inputs.attached["keyboard"];
+                if (keyboard)
+                    keyboard.keysLeft = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(ArcRotateCamera.prototype, "keysRight", {
+            //deprecated
+            get: function () {
+                BABYLON.Tools.Warn("Warning: keysRight is deprecated on ArcRotateCamera, use camera.inputs.attached.keyboard.keysRight instead.");
+                var keyboard = this.inputs.attached["keyboard"];
+                if (keyboard)
+                    return keyboard.keysRight;
+            },
+            //deprecated
+            set: function (value) {
+                BABYLON.Tools.Warn("Warning: keysRight is deprecated on ArcRotateCamera, use camera.inputs.attached.keyboard.keysRight instead.");
+                var keyboard = this.inputs.attached["keyboard"];
+                if (keyboard)
+                    keyboard.keysRight = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(ArcRotateCamera.prototype, "wheelPrecision", {
+            //deprecated
+            get: function () {
+                BABYLON.Tools.Warn("Warning: wheelPrecision is deprecated on ArcRotateCamera, use camera.inputs.attached.mousewheel.wheelPrecision instead.");
+                var mousewheel = this.inputs.attached["mousewheel"];
+                if (mousewheel)
+                    return mousewheel.wheelPrecision;
+            },
+            //deprecated
+            set: function (value) {
+                BABYLON.Tools.Warn("Warning: wheelPrecision is deprecated on ArcRotateCamera, use camera.inputs.attached.mousewheel.wheelPrecision instead.");
+                var mousewheel = this.inputs.attached["mousewheel"];
+                if (mousewheel)
+                    mousewheel.wheelPrecision = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
         // Cache
         ArcRotateCamera.prototype._initCache = function () {
             _super.prototype._initCache.call(this);
@@ -156,9 +313,6 @@ var BABYLON;
         };
         // Methods
         ArcRotateCamera.prototype.attachControl = function (element, noPreventDefault, useCtrlForPanning) {
-            // var cacheSoloPointer; // cache pointer object for better perf on camera rotation
-            // var previousPinchDistance = 0;
-            // // var pointers = new SmartCollection();
             var _this = this;
             if (useCtrlForPanning === void 0) { useCtrlForPanning = true; }
             if (this._attachedElement) {
@@ -168,210 +322,17 @@ var BABYLON;
             this._noPreventDefault = noPreventDefault;
             this._useCtrlForPanning = useCtrlForPanning;
             this.inputs.attachElement(element, noPreventDefault);
-            // var engine = this.getEngine();
-            // if (this._wheel === undefined) {
-            //     this._onPointerDown = evt => {
-            //         // Manage panning with right click
-            //         this._isRightClick = evt.button === 2;
-            //         // manage pointers
-            //         pointers.add(evt.pointerId, { x: evt.clientX, y: evt.clientY, type: evt.pointerType });
-            //         cacheSoloPointer = pointers.item(evt.pointerId);
-            //         if (!noPreventDefault) {
-            //             evt.preventDefault();
-            //         }
-            //     };
-            //     this._onPointerUp = evt => {
-            //         cacheSoloPointer = null;
-            //         previousPinchDistance = 0;
-            //         //would be better to use pointers.remove(evt.pointerId) for multitouch gestures, 
-            //         //but emptying completly pointers collection is required to fix a bug on iPhone : 
-            //         //when changing orientation while pinching camera, one pointer stay pressed forever if we don't release all pointers  
-            //         //will be ok to put back pointers.remove(evt.pointerId); when iPhone bug corrected
-            //         pointers.empty();
-            //         if (!noPreventDefault) {
-            //             evt.preventDefault();
-            //         }
-            //     };
-            //     this._onContextMenu = evt => {
-            //         evt.preventDefault();
-            //     };
-            //     this._onPointerMove = evt => {
-            //         if (!noPreventDefault) {
-            //             evt.preventDefault();
-            //         }
-            //         switch (pointers.count) {
-            //             case 1: //normal camera rotation
-            //                 if (this.panningSensibility !== 0 && ((this._isCtrlPushed && useCtrlForPanning) || (!useCtrlForPanning && this._isRightClick))) {
-            //                     this.inertialPanningX += -(evt.clientX - cacheSoloPointer.x) / this.panningSensibility;
-            //                     this.inertialPanningY += (evt.clientY - cacheSoloPointer.y) / this.panningSensibility;
-            //                 } else {
-            //                     var offsetX = evt.clientX - cacheSoloPointer.x;
-            //                     var offsetY = evt.clientY - cacheSoloPointer.y;
-            //                     this.inertialAlphaOffset -= offsetX / this.angularSensibilityX;
-            //                     this.inertialBetaOffset -= offsetY / this.angularSensibilityY;
-            //                 }
-            //                 cacheSoloPointer.x = evt.clientX;
-            //                 cacheSoloPointer.y = evt.clientY;
-            //                 break;
-            //             case 2: //pinch
-            //                 //if (noPreventDefault) { evt.preventDefault(); } //if pinch gesture, could be usefull to force preventDefault to avoid html page scroll/zoom in some mobile browsers
-            //                 pointers.item(evt.pointerId).x = evt.clientX;
-            //                 pointers.item(evt.pointerId).y = evt.clientY;
-            //                 var direction = this.pinchInwards ? 1 : -1;
-            //                 var distX = pointers.getItemByIndex(0).x - pointers.getItemByIndex(1).x;
-            //                 var distY = pointers.getItemByIndex(0).y - pointers.getItemByIndex(1).y;
-            //                 var pinchSquaredDistance = (distX * distX) + (distY * distY);
-            //                 if (previousPinchDistance === 0) {
-            //                     previousPinchDistance = pinchSquaredDistance;
-            //                     return;
-            //                 }
-            //                 if (pinchSquaredDistance !== previousPinchDistance) {
-            //                     this.inertialRadiusOffset += (pinchSquaredDistance - previousPinchDistance) / (this.pinchPrecision * this.wheelPrecision * ((this.angularSensibilityX + this.angularSensibilityY) / 2) * direction);
-            //                     previousPinchDistance = pinchSquaredDistance;
-            //                 }
-            //                 break;
-            //             default:
-            //                 if (pointers.item(evt.pointerId)) {
-            //                     pointers.item(evt.pointerId).x = evt.clientX;
-            //                     pointers.item(evt.pointerId).y = evt.clientY;
-            //                 }
-            //         }
-            //     };
-            //     this._onMouseMove = evt => {
-            //         if (!engine.isPointerLock) {
-            //             return;
-            //         }
-            //         var offsetX = evt.movementX || evt.mozMovementX || evt.webkitMovementX || evt.msMovementX || 0;
-            //         var offsetY = evt.movementY || evt.mozMovementY || evt.webkitMovementY || evt.msMovementY || 0;
-            //         this.inertialAlphaOffset -= offsetX / this.angularSensibilityX;
-            //         this.inertialBetaOffset -= offsetY / this.angularSensibilityY;
-            //         if (!noPreventDefault) {
-            //             evt.preventDefault();
-            //         }
-            //     };
-            // this._wheel = event => {
-            //     var delta = 0;
-            //     if (event.wheelDelta) {
-            //         delta = event.wheelDelta / (this.wheelPrecision * 40);
-            //     } else if (event.detail) {
-            //         delta = -event.detail / this.wheelPrecision;
-            //     }
-            //     if (delta)
-            //         this.inertialRadiusOffset += delta;
-            //     if (event.preventDefault) {
-            //         if (!noPreventDefault) {
-            //             event.preventDefault();
-            //         }
-            //     }
-            // };
-            // this._onKeyDown = evt => {
-            //     this._isCtrlPushed = evt.ctrlKey;
-            //     if (this.keysUp.indexOf(evt.keyCode) !== -1 ||
-            //         this.keysDown.indexOf(evt.keyCode) !== -1 ||
-            //         this.keysLeft.indexOf(evt.keyCode) !== -1 ||
-            //         this.keysRight.indexOf(evt.keyCode) !== -1) {
-            //         var index = this._keys.indexOf(evt.keyCode);
-            //         if (index === -1) {
-            //             this._keys.push(evt.keyCode);
-            //         }
-            //         if (evt.preventDefault) {
-            //             if (!noPreventDefault) {
-            //                 evt.preventDefault();
-            //             }
-            //         }
-            //     }
-            // };
-            // this._onKeyUp = evt => {
-            //     this._isCtrlPushed = evt.ctrlKey;
-            //     if (this.keysUp.indexOf(evt.keyCode) !== -1 ||
-            //         this.keysDown.indexOf(evt.keyCode) !== -1 ||
-            //         this.keysLeft.indexOf(evt.keyCode) !== -1 ||
-            //         this.keysRight.indexOf(evt.keyCode) !== -1) {
-            //         var index = this._keys.indexOf(evt.keyCode);
-            //         if (index >= 0) {
-            //             this._keys.splice(index, 1);
-            //         }
-            //         if (evt.preventDefault) {
-            //             if (!noPreventDefault) {
-            //                 evt.preventDefault();
-            //             }
-            //         }
-            //     }
-            // };
-            // this._onLostFocus = () => {
-            //     //this._keys = [];
-            //     pointers.empty();
-            //     previousPinchDistance = 0;
-            //     cacheSoloPointer = null;
-            // };
-            // this._onGestureStart = e => {
-            //     if (window.MSGesture === undefined) {
-            //         return;
-            //     }
-            //     if (!this._MSGestureHandler) {
-            //         this._MSGestureHandler = new MSGesture();
-            //         this._MSGestureHandler.target = element;
-            //     }
-            //     this._MSGestureHandler.addPointer(e.pointerId);
-            // };
-            // this._onGesture = e => {
-            //     this.radius *= e.scale;
-            //     if (e.preventDefault) {
-            //         if (!noPreventDefault) {
-            //             e.stopPropagation();
-            //             e.preventDefault();
-            //         }
-            //     }
-            // };
             this._reset = function () {
-                // this._keys = [];
                 _this.inertialAlphaOffset = 0;
                 _this.inertialBetaOffset = 0;
                 _this.inertialRadiusOffset = 0;
-                // pointers.empty();
-                // previousPinchDistance = 0;
-                // cacheSoloPointer = null;
             };
-            // }
-            // if (!useCtrlForPanning) {
-            //     element.addEventListener("contextmenu", this._onContextMenu, false);
-            // }
-            //element.addEventListener(eventPrefix + "down", this._onPointerDown, false);
-            // element.addEventListener(eventPrefix + "up", this._onPointerUp, false);
-            // element.addEventListener(eventPrefix + "out", this._onPointerUp, false);
-            // element.addEventListener(eventPrefix + "move", this._onPointerMove, false);
-            // element.addEventListener("mousemove", this._onMouseMove, false);
-            // element.addEventListener("MSPointerDown", this._onGestureStart, false);
-            // element.addEventListener("MSGestureChange", this._onGesture, false);
-            // element.addEventListener('mousewheel', this._wheel, false);
-            // element.addEventListener('DOMMouseScroll', this._wheel, false);
-            // Tools.RegisterTopRootEvents([
-            //     // { name: "keydown", handler: this._onKeyDown },
-            //     // { name: "keyup", handler: this._onKeyUp },
-            //     { name: "blur", handler: this._onLostFocus }
-            // ]);
         };
         ArcRotateCamera.prototype.detachControl = function (element) {
             if (this._attachedElement !== element) {
                 return;
             }
             this.inputs.detachElement(this._attachedElement);
-            // element.removeEventListener("contextmenu", this._onContextMenu);
-            // element.removeEventListener(eventPrefix + "down", this._onPointerDown);
-            // element.removeEventListener(eventPrefix + "up", this._onPointerUp);
-            // element.removeEventListener(eventPrefix + "out", this._onPointerUp);
-            // element.removeEventListener(eventPrefix + "move", this._onPointerMove);
-            // element.removeEventListener("mousemove", this._onMouseMove);
-            // element.removeEventListener("MSPointerDown", this._onGestureStart);
-            // element.removeEventListener("MSGestureChange", this._onGesture);
-            // element.removeEventListener('mousewheel', this._wheel);
-            // element.removeEventListener('DOMMouseScroll', this._wheel);
-            // Tools.UnregisterTopRootEvents([
-            //     // { name: "keydown", handler: this._onKeyDown },
-            //     // { name: "keyup", handler: this._onKeyUp },
-            //     { name: "blur", handler: this._onLostFocus }
-            // ]);
-            // this._MSGestureHandler = null;
             this._attachedElement = null;
             if (this._reset) {
                 this._reset();
@@ -383,19 +344,6 @@ var BABYLON;
                 return;
             }
             this.inputs.checkInputs();
-            // Keyboard
-            // for (var index = 0; index < this._keys.length; index++) {
-            //     var keyCode = this._keys[index];
-            //     if (this.keysLeft.indexOf(keyCode) !== -1) {
-            //         this.inertialAlphaOffset -= 0.01;
-            //     } else if (this.keysUp.indexOf(keyCode) !== -1) {
-            //         this.inertialBetaOffset -= 0.01;
-            //     } else if (this.keysRight.indexOf(keyCode) !== -1) {
-            //         this.inertialAlphaOffset += 0.01;
-            //     } else if (this.keysDown.indexOf(keyCode) !== -1) {
-            //         this.inertialBetaOffset += 0.01;
-            //     }
-            // }			
             // Inertia
             if (this.inertialAlphaOffset !== 0 || this.inertialBetaOffset !== 0 || this.inertialRadiusOffset !== 0) {
                 this.alpha += this.beta <= 0 ? -this.inertialAlphaOffset : this.inertialAlphaOffset;
@@ -590,6 +538,10 @@ var BABYLON;
             }
             _super.prototype._updateRigCameras.call(this);
         };
+        ArcRotateCamera.prototype.dispose = function () {
+            this.inputs.clear();
+            _super.prototype.dispose.call(this);
+        };
         ArcRotateCamera.prototype.getTypeName = function () {
             return "ArcRotateCamera";
         };

src/Cameras/babylon.arcRotateCamera.ts

@@ -40,77 +40,202 @@
 
         @serialize()
         public upperRadiusLimit = null;
-
-        // @serialize()
-        // public angularSensibilityX = 1000.0;
-
-        // @serialize()
-        // public angularSensibilityY = 1000.0;
-
-        // @serialize()
-        // public wheelPrecision = 3.0;
-
-        // @serialize()
-        // public pinchPrecision = 2.0;
-
-        // @serialize()
-        // public panningSensibility: number = 50.0;
-
+        
         @serialize()
         public inertialPanningX: number = 0;
 
         @serialize()
         public inertialPanningY: number = 0;
 
-        // @serialize()
-        // public keysUp = [38];
-
-        // @serialize()
-        // public keysDown = [40];
-
-        // @serialize()
-        // public keysLeft = [37];
-
-        // @serialize()
-        // public keysRight = [39];
+        //-- 2016-03-08 properties for backward compatibility for inputs
+        //deprecated angularSensibility support
+        public get angularSensibility() {
+            Tools.Warn("Warning: angularSensibility is deprecated on ArcRotateCamera, use camera.inputs.attached.pointers.angularSensibilityX and camera.inputs.attached.pointers.angularSensibilityY instead.");
+            var pointers = <ArcRotateCameraPointersInput>this.inputs.attached["pointers"];
+            if (pointers)
+                return Math.max(pointers.angularSensibilityX, pointers.angularSensibilityY);
+        }
+        
+        //deprecated angularSensibility support
+        public set angularSensibility(value) {
+            Tools.Warn("Warning: angularSensibility is deprecated on ArcRotateCamera, use camera.inputs.attached.pointers.angularSensibilityX and camera.inputs.attached.pointers.angularSensibilityY instead.");
+            var pointers = <ArcRotateCameraPointersInput>this.inputs.attached["pointers"];
+            if (pointers){
+                pointers.angularSensibilityX = value;
+                pointers.angularSensibilityY = value;
+            }
+        }
+        
+        //deprecated angularSensibilityX support
+        public get angularSensibilityX() {
+            Tools.Warn("Warning: angularSensibilityX is deprecated on ArcRotateCamera, use camera.inputs.attached.pointers.angularSensibilityX instead.");
+            var pointers = <ArcRotateCameraPointersInput>this.inputs.attached["pointers"];
+            if (pointers)
+                return pointers.angularSensibilityX;
+        }
+        
+        //deprecated angularSensibilityX support
+        public set angularSensibilityX(value) {
+            Tools.Warn("Warning: angularSensibilityX is deprecated on ArcRotateCamera, use camera.inputs.attached.pointers.angularSensibilityX instead.");
+            var pointers = <ArcRotateCameraPointersInput>this.inputs.attached["pointers"];
+            if (pointers){
+                pointers.angularSensibilityX = value;
+            }
+        }
+        
+        //deprecated angularSensibilityY support
+        public get angularSensibilityY() {
+            Tools.Warn("Warning: angularSensibilityY is deprecated on ArcRotateCamera, use camera.inputs.attached.pointers.angularSensibilityY instead.");
+            var pointers = <ArcRotateCameraPointersInput>this.inputs.attached["pointers"];
+            if (pointers)
+                return pointers.angularSensibilityY;
+        }
+        
+        //deprecated angularSensibilityY support
+        public set angularSensibilityY(value) {
+            Tools.Warn("Warning: angularSensibilityY is deprecated on ArcRotateCamera, use camera.inputs.attached.pointers.angularSensibilityY instead.");
+            var pointers = <ArcRotateCameraPointersInput>this.inputs.attached["pointers"];
+            if (pointers){
+                pointers.angularSensibilityY = value;
+            }
+        }
+        
+        //deprecated pinchPrecision support
+        public get pinchPrecision() {
+            Tools.Warn("Warning: pinchPrecision is deprecated on ArcRotateCamera, use camera.inputs.attached.pointers.pinchPrecision instead.");
+            var pointers = <ArcRotateCameraPointersInput>this.inputs.attached["pointers"];
+            if (pointers)
+                return pointers.pinchPrecision;
+        }
+        
+        //deprecated pinchPrecision support
+        public set pinchPrecision(value) {
+            Tools.Warn("Warning: pinchPrecision is deprecated on ArcRotateCamera, use camera.inputs.attached.pointers.pinchPrecision instead.");
+            var pointers = <ArcRotateCameraPointersInput>this.inputs.attached["pointers"];
+            if (pointers){
+                pointers.pinchPrecision = value;
+            }
+        }
+        
+        //deprecated panningSensibility support
+        public get panningSensibility() {
+            Tools.Warn("Warning: panningSensibility is deprecated on ArcRotateCamera, use camera.inputs.attached.pointers.panningSensibility instead.");
+            var pointers = <ArcRotateCameraPointersInput>this.inputs.attached["pointers"];
+            if (pointers)
+                return pointers.panningSensibility;
+        }
+        
+        //deprecated pinchPrecision support
+        public set panningSensibility(value) {
+            Tools.Warn("Warning: panningSensibility is deprecated on ArcRotateCamera, use camera.inputs.attached.pointers.panningSensibility instead.");
+            var pointers = <ArcRotateCameraPointersInput>this.inputs.attached["pointers"];
+            if (pointers){
+                pointers.panningSensibility = value;
+            }
+        }
+        
+        //deprecated
+        public get keysUp() {
+            Tools.Warn("Warning: keysUp is deprecated on ArcRotateCamera, use camera.inputs.attached.keyboard.keysUp instead.");
+            var keyboard = <ArcRotateCameraKeyboardMoveInput>this.inputs.attached["keyboard"];
+            if (keyboard)
+                return keyboard.keysUp;
+        }
+        
+        //deprecated
+        public set keysUp(value) {
+            Tools.Warn("Warning: keysUp is deprecated on ArcRotateCamera, use camera.inputs.attached.keyboard.keysUp instead.");
+            var keyboard = <ArcRotateCameraKeyboardMoveInput>this.inputs.attached["keyboard"];
+            if (keyboard)
+                keyboard.keysUp = value;
+        }
+        
+        //deprecated
+        public get keysDown() {
+            Tools.Warn("Warning: keysDown is deprecated on ArcRotateCamera, use camera.inputs.attached.keyboard.keysDown instead.");
+            var keyboard = <ArcRotateCameraKeyboardMoveInput>this.inputs.attached["keyboard"];
+            if (keyboard)
+                return keyboard.keysDown;
+        }
+        
+        //deprecated
+        public set keysDown(value) {
+            Tools.Warn("Warning: keysDown is deprecated on ArcRotateCamera, use camera.inputs.attached.keyboard.keysDown instead.");
+            var keyboard = <ArcRotateCameraKeyboardMoveInput>this.inputs.attached["keyboard"];
+            if (keyboard)
+                keyboard.keysDown = value;
+        }
+        
+        //deprecated
+        public get keysLeft() {
+            Tools.Warn("Warning: keysLeft is deprecated on ArcRotateCamera, use camera.inputs.attached.keyboard.keysLeft instead.");
+            var keyboard = <ArcRotateCameraKeyboardMoveInput>this.inputs.attached["keyboard"];
+            if (keyboard)
+                return keyboard.keysLeft;
+        }
+        
+        //deprecated
+        public set keysLeft(value) {
+            Tools.Warn("Warning: keysLeft is deprecated on ArcRotateCamera, use camera.inputs.attached.keyboard.keysLeft instead.");
+            var keyboard = <ArcRotateCameraKeyboardMoveInput>this.inputs.attached["keyboard"];
+            if (keyboard)
+                keyboard.keysLeft = value;
+        }
+        
+        //deprecated
+        public get keysRight() {
+            Tools.Warn("Warning: keysRight is deprecated on ArcRotateCamera, use camera.inputs.attached.keyboard.keysRight instead.");
+            var keyboard = <ArcRotateCameraKeyboardMoveInput>this.inputs.attached["keyboard"];
+            if (keyboard)
+                return keyboard.keysRight;
+        }
+        
+        //deprecated
+        public set keysRight(value) {
+            Tools.Warn("Warning: keysRight is deprecated on ArcRotateCamera, use camera.inputs.attached.keyboard.keysRight instead.");
+            var keyboard = <ArcRotateCameraKeyboardMoveInput>this.inputs.attached["keyboard"];
+            if (keyboard)
+                keyboard.keysRight = value;
+        }
+        
+        //deprecated
+        public get wheelPrecision() {
+            Tools.Warn("Warning: wheelPrecision is deprecated on ArcRotateCamera, use camera.inputs.attached.mousewheel.wheelPrecision instead.");
+            var mousewheel = <ArcRotateCameraMouseWheelInput>this.inputs.attached["mousewheel"];
+            if (mousewheel)
+                return mousewheel.wheelPrecision;
+        }
+        
+        //deprecated
+        public set wheelPrecision(value) {
+            Tools.Warn("Warning: wheelPrecision is deprecated on ArcRotateCamera, use camera.inputs.attached.mousewheel.wheelPrecision instead.");
+            var mousewheel = <ArcRotateCameraMouseWheelInput>this.inputs.attached["mousewheel"];
+            if (mousewheel)
+                mousewheel.wheelPrecision = value;
+        }
+        
+        //-- end properties for backward compatibility for inputs        
 
         @serialize()
         public zoomOnFactor = 1;
 
         public targetScreenOffset = Vector2.Zero();
-        // public pinchInwards = true;
-
+        
         @serialize()
         public allowUpsideDown = true;
 
-        // private _keys = [];
         public _viewMatrix = new Matrix();
         public _attachedElement: HTMLElement;
         public _noPreventDefault : boolean;
         public _useCtrlForPanning : boolean;
         public inputs : ArcRotateCameraInputsManager;
         
-        // private _onContextMenu: (e: PointerEvent) => void;
-        // private _onPointerDown: (e: PointerEvent) => void;
-        // private _onPointerUp: (e: PointerEvent) => void;
-        // private _onPointerMove: (e: PointerEvent) => void;
-        // private _onMouseMove: (e: MouseEvent) => any;
-        // private _onGestureStart: (e: PointerEvent) => void;
-        // private _onGesture: (e: MSGestureEvent) => void;
-        // private _MSGestureHandler: MSGesture;
-
-        // private _wheel: (e: MouseWheelEvent) => void;
-        // private _onKeyDown: (e: KeyboardEvent) => any;
-        // private _onKeyUp: (e: KeyboardEvent) => any;
-        // private _onLostFocus: (e: FocusEvent) => any;
         public _reset: () => void;
         
         // Panning
         public panningAxis: Vector3 = new Vector3(1, 1, 0);
         private _localDirection: Vector3;
         private _transformedDirection: Vector3;
-        // private _isRightClick: boolean = false;
-        // private _isCtrlPushed: boolean = false;
 
         // Collisions
         public onCollide: (collidedMesh: AbstractMesh) => void;
@@ -126,19 +251,6 @@
         //due to async collision inspection
         private _collisionTriggered: boolean;
         
-        //deprecated angularSensibility support
-        // public get angularSensibility() {
-        //     Tools.Warn("Warning: angularSensibility is deprecated, use angularSensibilityX and angularSensibilityY instead.");
-        //     return Math.max(this.angularSensibilityX, this.angularSensibilityY);
-        // }
-        
-        // //deprecated angularSensibility support
-        // public set angularSensibility(value) {
-        //     Tools.Warn("Warning: angularSensibility is deprecated, use angularSensibilityX and angularSensibilityY instead.");
-        //     this.angularSensibilityX = value;
-        //     this.angularSensibilityY = value;
-        // }
-
         constructor(name: string, alpha: number, beta: number, radius: number, target: Vector3, scene: Scene) {
             super(name, Vector3.Zero(), scene);
 
@@ -201,10 +313,6 @@
 
         // Methods
         public attachControl(element: HTMLElement, noPreventDefault?: boolean, useCtrlForPanning: boolean = true): void {
-            // var cacheSoloPointer; // cache pointer object for better perf on camera rotation
-            // var previousPinchDistance = 0;
-            // // var pointers = new SmartCollection();
-
             if (this._attachedElement) {
                 return;
             }
@@ -214,225 +322,12 @@
 
             this.inputs.attachElement(element, noPreventDefault);
             
-            // var engine = this.getEngine();
-
-            // if (this._wheel === undefined) {
-            //     this._onPointerDown = evt => {
-            //         // Manage panning with right click
-            //         this._isRightClick = evt.button === 2;
-
-            //         // manage pointers
-            //         pointers.add(evt.pointerId, { x: evt.clientX, y: evt.clientY, type: evt.pointerType });
-            //         cacheSoloPointer = pointers.item(evt.pointerId);
-            //         if (!noPreventDefault) {
-            //             evt.preventDefault();
-            //         }
-            //     };
-
-            //     this._onPointerUp = evt => {
-            //         cacheSoloPointer = null;
-            //         previousPinchDistance = 0;
-                    
-            //         //would be better to use pointers.remove(evt.pointerId) for multitouch gestures, 
-            //         //but emptying completly pointers collection is required to fix a bug on iPhone : 
-            //         //when changing orientation while pinching camera, one pointer stay pressed forever if we don't release all pointers  
-            //         //will be ok to put back pointers.remove(evt.pointerId); when iPhone bug corrected
-            //         pointers.empty();
-
-            //         if (!noPreventDefault) {
-            //             evt.preventDefault();
-            //         }
-            //     };
-
-            //     this._onContextMenu = evt => {
-            //         evt.preventDefault();
-            //     };
-
-            //     this._onPointerMove = evt => {
-            //         if (!noPreventDefault) {
-            //             evt.preventDefault();
-            //         }
-
-            //         switch (pointers.count) {
-
-            //             case 1: //normal camera rotation
-            //                 if (this.panningSensibility !== 0 && ((this._isCtrlPushed && useCtrlForPanning) || (!useCtrlForPanning && this._isRightClick))) {
-            //                     this.inertialPanningX += -(evt.clientX - cacheSoloPointer.x) / this.panningSensibility;
-            //                     this.inertialPanningY += (evt.clientY - cacheSoloPointer.y) / this.panningSensibility;
-            //                 } else {
-            //                     var offsetX = evt.clientX - cacheSoloPointer.x;
-            //                     var offsetY = evt.clientY - cacheSoloPointer.y;
-            //                     this.inertialAlphaOffset -= offsetX / this.angularSensibilityX;
-            //                     this.inertialBetaOffset -= offsetY / this.angularSensibilityY;
-            //                 }
-            //                 cacheSoloPointer.x = evt.clientX;
-            //                 cacheSoloPointer.y = evt.clientY;
-            //                 break;
-
-            //             case 2: //pinch
-            //                 //if (noPreventDefault) { evt.preventDefault(); } //if pinch gesture, could be usefull to force preventDefault to avoid html page scroll/zoom in some mobile browsers
-            //                 pointers.item(evt.pointerId).x = evt.clientX;
-            //                 pointers.item(evt.pointerId).y = evt.clientY;
-            //                 var direction = this.pinchInwards ? 1 : -1;
-            //                 var distX = pointers.getItemByIndex(0).x - pointers.getItemByIndex(1).x;
-            //                 var distY = pointers.getItemByIndex(0).y - pointers.getItemByIndex(1).y;
-            //                 var pinchSquaredDistance = (distX * distX) + (distY * distY);
-            //                 if (previousPinchDistance === 0) {
-            //                     previousPinchDistance = pinchSquaredDistance;
-            //                     return;
-            //                 }
-
-            //                 if (pinchSquaredDistance !== previousPinchDistance) {
-            //                     this.inertialRadiusOffset += (pinchSquaredDistance - previousPinchDistance) / (this.pinchPrecision * this.wheelPrecision * ((this.angularSensibilityX + this.angularSensibilityY) / 2) * direction);
-            //                     previousPinchDistance = pinchSquaredDistance;
-            //                 }
-            //                 break;
-
-            //             default:
-            //                 if (pointers.item(evt.pointerId)) {
-            //                     pointers.item(evt.pointerId).x = evt.clientX;
-            //                     pointers.item(evt.pointerId).y = evt.clientY;
-            //                 }
-            //         }
-            //     };
-
-            //     this._onMouseMove = evt => {
-            //         if (!engine.isPointerLock) {
-            //             return;
-            //         }
-
-            //         var offsetX = evt.movementX || evt.mozMovementX || evt.webkitMovementX || evt.msMovementX || 0;
-            //         var offsetY = evt.movementY || evt.mozMovementY || evt.webkitMovementY || evt.msMovementY || 0;
-
-            //         this.inertialAlphaOffset -= offsetX / this.angularSensibilityX;
-            //         this.inertialBetaOffset -= offsetY / this.angularSensibilityY;
-
-            //         if (!noPreventDefault) {
-            //             evt.preventDefault();
-            //         }
-            //     };
-
-                // this._wheel = event => {
-                //     var delta = 0;
-                //     if (event.wheelDelta) {
-                //         delta = event.wheelDelta / (this.wheelPrecision * 40);
-                //     } else if (event.detail) {
-                //         delta = -event.detail / this.wheelPrecision;
-                //     }
-
-                //     if (delta)
-                //         this.inertialRadiusOffset += delta;
-
-                //     if (event.preventDefault) {
-                //         if (!noPreventDefault) {
-                //             event.preventDefault();
-                //         }
-                //     }
-                // };
-
-                // this._onKeyDown = evt => {
-                //     this._isCtrlPushed = evt.ctrlKey;
-                //     if (this.keysUp.indexOf(evt.keyCode) !== -1 ||
-                //         this.keysDown.indexOf(evt.keyCode) !== -1 ||
-                //         this.keysLeft.indexOf(evt.keyCode) !== -1 ||
-                //         this.keysRight.indexOf(evt.keyCode) !== -1) {
-                //         var index = this._keys.indexOf(evt.keyCode);
-
-                //         if (index === -1) {
-                //             this._keys.push(evt.keyCode);
-                //         }
-
-                //         if (evt.preventDefault) {
-                //             if (!noPreventDefault) {
-                //                 evt.preventDefault();
-                //             }
-                //         }
-                //     }
-                // };
-
-                // this._onKeyUp = evt => {
-                //     this._isCtrlPushed = evt.ctrlKey;
-                //     if (this.keysUp.indexOf(evt.keyCode) !== -1 ||
-                //         this.keysDown.indexOf(evt.keyCode) !== -1 ||
-                //         this.keysLeft.indexOf(evt.keyCode) !== -1 ||
-                //         this.keysRight.indexOf(evt.keyCode) !== -1) {
-                //         var index = this._keys.indexOf(evt.keyCode);
-
-                //         if (index >= 0) {
-                //             this._keys.splice(index, 1);
-                //         }
-
-                //         if (evt.preventDefault) {
-                //             if (!noPreventDefault) {
-                //                 evt.preventDefault();
-                //             }
-                //         }
-                //     }
-                // };
-
-                // this._onLostFocus = () => {
-                //     //this._keys = [];
-                //     pointers.empty();
-                //     previousPinchDistance = 0;
-                //     cacheSoloPointer = null;
-                // };
-
-                // this._onGestureStart = e => {
-                //     if (window.MSGesture === undefined) {
-                //         return;
-                //     }
-
-                //     if (!this._MSGestureHandler) {
-                //         this._MSGestureHandler = new MSGesture();
-                //         this._MSGestureHandler.target = element;
-                //     }
-
-                //     this._MSGestureHandler.addPointer(e.pointerId);
-                // };
-
-                // this._onGesture = e => {
-                //     this.radius *= e.scale;
-
-
-                //     if (e.preventDefault) {
-                //         if (!noPreventDefault) {
-                //             e.stopPropagation();
-                //             e.preventDefault();
-                //         }
-                //     }
-                // };
 
                 this._reset = () => {
-                    // this._keys = [];
                     this.inertialAlphaOffset = 0;
                     this.inertialBetaOffset = 0;
                     this.inertialRadiusOffset = 0;
-                    // pointers.empty();
-                    // previousPinchDistance = 0;
-                    // cacheSoloPointer = null;
                 };
-
-
-            // }
-
-            // if (!useCtrlForPanning) {
-            //     element.addEventListener("contextmenu", this._onContextMenu, false);
-            // }
-            //element.addEventListener(eventPrefix + "down", this._onPointerDown, false);
-            // element.addEventListener(eventPrefix + "up", this._onPointerUp, false);
-            // element.addEventListener(eventPrefix + "out", this._onPointerUp, false);
-            // element.addEventListener(eventPrefix + "move", this._onPointerMove, false);
-            // element.addEventListener("mousemove", this._onMouseMove, false);
-            // element.addEventListener("MSPointerDown", this._onGestureStart, false);
-            // element.addEventListener("MSGestureChange", this._onGesture, false);
-            // element.addEventListener('mousewheel', this._wheel, false);
-            // element.addEventListener('DOMMouseScroll', this._wheel, false);
-
-            // Tools.RegisterTopRootEvents([
-            //     // { name: "keydown", handler: this._onKeyDown },
-            //     // { name: "keyup", handler: this._onKeyUp },
-            //     { name: "blur", handler: this._onLostFocus }
-            // ]);
         }
 
         public detachControl(element: HTMLElement): void {
@@ -441,25 +336,6 @@
             }
 
             this.inputs.detachElement(this._attachedElement);
-            
-            // element.removeEventListener("contextmenu", this._onContextMenu);
-            // element.removeEventListener(eventPrefix + "down", this._onPointerDown);
-            // element.removeEventListener(eventPrefix + "up", this._onPointerUp);
-            // element.removeEventListener(eventPrefix + "out", this._onPointerUp);
-            // element.removeEventListener(eventPrefix + "move", this._onPointerMove);
-            // element.removeEventListener("mousemove", this._onMouseMove);
-            // element.removeEventListener("MSPointerDown", this._onGestureStart);
-            // element.removeEventListener("MSGestureChange", this._onGesture);
-            // element.removeEventListener('mousewheel', this._wheel);
-            // element.removeEventListener('DOMMouseScroll', this._wheel);
-
-            // Tools.UnregisterTopRootEvents([
-            //     // { name: "keydown", handler: this._onKeyDown },
-            //     // { name: "keyup", handler: this._onKeyUp },
-            //     { name: "blur", handler: this._onLostFocus }
-            // ]);
-
-            // this._MSGestureHandler = null;
             this._attachedElement = null;
 
             if (this._reset) {
@@ -473,21 +349,7 @@
                 return;
             }
             
-            this.inputs.checkInputs();
-            
-            // Keyboard
-            // for (var index = 0; index < this._keys.length; index++) {
-            //     var keyCode = this._keys[index];
-            //     if (this.keysLeft.indexOf(keyCode) !== -1) {
-            //         this.inertialAlphaOffset -= 0.01;
-            //     } else if (this.keysUp.indexOf(keyCode) !== -1) {
-            //         this.inertialBetaOffset -= 0.01;
-            //     } else if (this.keysRight.indexOf(keyCode) !== -1) {
-            //         this.inertialAlphaOffset += 0.01;
-            //     } else if (this.keysDown.indexOf(keyCode) !== -1) {
-            //         this.inertialBetaOffset += 0.01;
-            //     }
-            // }			
+            this.inputs.checkInputs();            
 			
             // Inertia
             if (this.inertialAlphaOffset !== 0 || this.inertialBetaOffset !== 0 || this.inertialRadiusOffset !== 0) {
@@ -755,6 +617,11 @@
             super._updateRigCameras();
         }
 
+        public dispose(): void {
+            this.inputs.clear();
+            super.dispose();
+        }
+        
         public getTypeName(): string {
             return "ArcRotateCamera";
         }

src/Cameras/babylon.arcRotateCameraInputsManager.js

@@ -10,6 +10,12 @@ var BABYLON;
         function ArcRotateCameraInputsManager(camera) {
             _super.call(this, camera);
         }
+        ArcRotateCameraInputsManager.prototype.add = function (input) {
+            _super.prototype.add.call(this, input);
+            if (this.camera._attachedElement && input.attachElement) {
+                input.attachElement(this.camera._attachedElement, this.camera._noPreventDefault);
+            }
+        };
         ArcRotateCameraInputsManager.prototype.addMouseWheel = function () {
             this.add(new BABYLON.ArcRotateCameraMouseWheelInput());
             return this;

src/Cameras/babylon.arcRotateCameraInputsManager.ts

@@ -4,6 +4,13 @@ module BABYLON {
             super(camera);    
         }
         
+        add(input: ICameraInput<ArcRotateCamera>){
+            super.add(input);
+            if (this.camera._attachedElement && input.attachElement) {
+                input.attachElement(this.camera._attachedElement, this.camera._noPreventDefault);
+            }
+        }
+        
         public addMouseWheel(){
             this.add(new ArcRotateCameraMouseWheelInput());
             return this;

src/Cameras/babylon.camera.js

@@ -461,7 +461,7 @@ var BABYLON;
                 serializationObject.parentId = this.parent.id;
             }
             if (this.inputs) {
-                serializationObject.inputs = this.inputs.serialize();
+                this.inputs.serialize(serializationObject);
             }
             // Animations
             BABYLON.Animation.AppendSerializedAnimations(this, serializationObject);
@@ -528,7 +528,7 @@ var BABYLON;
             }
             //Input manager
             if (parsedCamera.inputs) {
-                camera.inputs.parse(parsedCamera.inputs);
+                camera.inputs.parse(parsedCamera);
             }
             // Target
             if (parsedCamera.target) {

src/Cameras/babylon.camera.ts

@@ -573,7 +573,7 @@
             }
             
             if (this.inputs){
-                serializationObject.inputs = this.inputs.serialize();
+                this.inputs.serialize(serializationObject);
             }
             // Animations
             Animation.AppendSerializedAnimations(this, serializationObject);
@@ -646,7 +646,7 @@
             
             //Input manager
             if (parsedCamera.inputs){
-                camera.inputs.parse(parsedCamera.inputs);
+                camera.inputs.parse(parsedCamera);
             }
 
             // Target

src/Cameras/babylon.cameraInputsManager.js

@@ -3,17 +3,17 @@ var BABYLON;
     BABYLON.CameraInputTypes = {};
     var CameraInputsManager = (function () {
         function CameraInputsManager(camera) {
-            this.inputs = {};
+            this.attached = {};
             this.camera = camera;
             this.checkInputs = function () { };
         }
         CameraInputsManager.prototype.add = function (input) {
-            var type = input.getTypeName();
-            if (this.inputs[type]) {
+            var type = input.getSimpleName();
+            if (this.attached[type]) {
                 BABYLON.Tools.Warn("camera input of type " + type + " already exists on camera");
                 return;
             }
-            this.inputs[type] = input;
+            this.attached[type] = input;
             input.attachCamera(this.camera);
             //for checkInputs, we are dynamically creating a function
             //the goal is to avoid the performance penalty of looping for inputs in the render loop
@@ -29,45 +29,46 @@ var BABYLON;
             };
         };
         CameraInputsManager.prototype.attachElement = function (element, noPreventDefault) {
-            for (var cam in this.inputs) {
-                var input = this.inputs[cam];
+            for (var cam in this.attached) {
+                var input = this.attached[cam];
                 if (input.attachElement)
-                    this.inputs[cam].attachElement(element, noPreventDefault);
+                    this.attached[cam].attachElement(element, noPreventDefault);
             }
         };
         CameraInputsManager.prototype.detachElement = function (element) {
-            for (var cam in this.inputs) {
-                var input = this.inputs[cam];
+            for (var cam in this.attached) {
+                var input = this.attached[cam];
                 if (input.detachElement)
-                    this.inputs[cam].detachElement(element);
+                    this.attached[cam].detachElement(element);
             }
         };
         CameraInputsManager.prototype.rebuildInputCheck = function (element) {
             this.checkInputs = function () { };
-            for (var cam in this.inputs) {
-                var input = this.inputs[cam];
+            for (var cam in this.attached) {
+                var input = this.attached[cam];
                 if (input.checkInputs) {
                     this.checkInputs = this._addCheckInputs(input.checkInputs.bind(input));
                 }
             }
         };
         CameraInputsManager.prototype.clear = function () {
-            for (var cam in this.inputs) {
-                this.inputs[cam].detach();
+            for (var cam in this.attached) {
+                this.attached[cam].detach();
             }
-            this.inputs = {};
+            this.attached = {};
             this.checkInputs = function () { };
         };
-        CameraInputsManager.prototype.serialize = function () {
+        CameraInputsManager.prototype.serialize = function (serializedCamera) {
             var inputs = {};
-            for (var cam in this.inputs) {
-                var input = this.inputs[cam];
-                var res = BABYLON.SerializationHelper.Serialize(input);
+            for (var cam in this.attached) {
+                var input = this.attached[cam];
+                var res = BABYLON.SerializationHelper.Serialize(input, serializedCamera);
                 inputs[input.getTypeName()] = res;
             }
-            return inputs;
+            serializedCamera.inputsmgr = inputs;
         };
-        CameraInputsManager.prototype.parse = function (parsedInputs) {
+        CameraInputsManager.prototype.parse = function (parsedCamera) {
+            var parsedInputs = parsedCamera.inputsmgr;
             if (parsedInputs) {
                 this.clear();
                 for (var n in parsedInputs) {
@@ -79,6 +80,16 @@ var BABYLON;
                     }
                 }
             }
+            else {
+                //2016-03-08 this part is for managing backward compatibility
+                for (var n in this.attached) {
+                    var construct = BABYLON.CameraInputTypes[this.attached[n].getTypeName()];
+                    if (construct) {
+                        var input = BABYLON.SerializationHelper.Parse(function () { return new construct(); }, parsedCamera, null);
+                        this.add(input);
+                    }
+                }
+            }
         };
         return CameraInputsManager;
     }());

src/Cameras/babylon.cameraInputsManager.ts

@@ -6,6 +6,7 @@ module BABYLON {
         attachCamera(camera: TCamera);
         detach();        
         getTypeName(): string;
+        getSimpleName(): string;
         
         attachElement? : (element: HTMLElement, noPreventDefault?: boolean) => void;
         detachElement? : (element: HTMLElement) => void;
@@ -18,24 +19,24 @@ module BABYLON {
     }
 
     export class CameraInputsManager<TCamera extends BABYLON.Camera> {
-        inputs: CameraInputsMap<TCamera>;
+        attached: CameraInputsMap<TCamera>;
         camera: TCamera;
         checkInputs: () => void;
 
         constructor(camera: TCamera) {
-            this.inputs = {};
+            this.attached = {};
             this.camera = camera;
             this.checkInputs = () => { };
         }
 
         public add(input: ICameraInput<TCamera>) {
-            var type = input.getTypeName();
-            if (this.inputs[type]) {
+            var type = input.getSimpleName();
+            if (this.attached[type]) {
                 Tools.Warn("camera input of type " + type + " already exists on camera");
                 return;
             }
 
-            this.inputs[type] = input;
+            this.attached[type] = input;
             input.attachCamera(this.camera);
             
             //for checkInputs, we are dynamically creating a function
@@ -43,8 +44,6 @@ module BABYLON {
             if (input.checkInputs) {
                 this.checkInputs = this._addCheckInputs(input.checkInputs.bind(input));
             }
-
-            
         }
         
         private _addCheckInputs(fn){
@@ -56,26 +55,26 @@ module BABYLON {
         }
 
         public attachElement(element: HTMLElement, noPreventDefault?: boolean) {
-            for (var cam in this.inputs) {
-                var input = this.inputs[cam];
+            for (var cam in this.attached) {
+                var input = this.attached[cam];
                 if (input.attachElement)
-                    this.inputs[cam].attachElement(element, noPreventDefault);
+                    this.attached[cam].attachElement(element, noPreventDefault);
             }
         }
 
         public detachElement(element: HTMLElement) {
-            for (var cam in this.inputs) {
-                var input = this.inputs[cam];
+            for (var cam in this.attached) {
+                var input = this.attached[cam];
                 if (input.detachElement)
-                    this.inputs[cam].detachElement(element);
+                    this.attached[cam].detachElement(element);
             }
         }
 
         public rebuildInputCheck(element: HTMLElement) {
             this.checkInputs = () => { };
 
-            for (var cam in this.inputs) {
-                var input = this.inputs[cam];
+            for (var cam in this.attached) {
+                var input = this.attached[cam];
                 if (input.checkInputs) {
                     this.checkInputs = this._addCheckInputs(input.checkInputs.bind(input));
                 }
@@ -83,26 +82,27 @@ module BABYLON {
         }
 
         public clear() {
-            for (var cam in this.inputs) {
-                this.inputs[cam].detach();
+            for (var cam in this.attached) {
+                this.attached[cam].detach();
             }
 
-            this.inputs = {};
+            this.attached = {};
             this.checkInputs = () => { };
         }
         
-        public serialize(){
+        public serialize(serializedCamera){
             var inputs = {};
-            for (var cam in this.inputs) {
-                var input = this.inputs[cam];
-                var res = SerializationHelper.Serialize(input);
+            for (var cam in this.attached) {
+                var input = this.attached[cam];
+                var res = SerializationHelper.Serialize(input, serializedCamera);
                 inputs[input.getTypeName()] = res;
             }
             
-            return inputs;
+            serializedCamera.inputsmgr = inputs;
         }
         
-        public parse(parsedInputs){
+        public parse(parsedCamera){
+            var parsedInputs = parsedCamera.inputsmgr;
             if (parsedInputs){
                 this.clear();
                 
@@ -114,6 +114,15 @@ module BABYLON {
                         this.add(input as any);
                     }
                 }
+            } else { 
+                //2016-03-08 this part is for managing backward compatibility
+                for (var n in this.attached) {                    
+                    var construct = CameraInputTypes[this.attached[n].getTypeName()];
+                    if (construct){                        
+                        var input = SerializationHelper.Parse(() => { return new construct() }, parsedCamera, null);
+                        this.add(input as any);
+                    }
+                }
             }
         }
         

src/Cameras/babylon.deviceOrientationCamera.js

@@ -8,10 +8,48 @@ var BABYLON;
     // We're mainly based on the logic defined into the FreeCamera code
     var DeviceOrientationCamera = (function (_super) {
         __extends(DeviceOrientationCamera, _super);
+        //-- end properties for backward compatibility for inputs
         function DeviceOrientationCamera(name, position, scene) {
             _super.call(this, name, position, scene);
             this.inputs.addDeviceOrientation();
         }
+        Object.defineProperty(DeviceOrientationCamera.prototype, "angularSensibility", {
+            //-- 2016-03-08 properties for backward compatibility for inputs
+            //deprecated
+            get: function () {
+                BABYLON.Tools.Warn("Warning: angularSensibility is deprecated on DeviceOrientationCamera, use camera.inputs.attached.deviceOrientation.angularSensibility instead.");
+                var gamepad = this.inputs.attached["deviceOrientation"];
+                if (gamepad)
+                    return gamepad.angularSensibility;
+            },
+            //deprecated
+            set: function (value) {
+                BABYLON.Tools.Warn("Warning: angularSensibility is deprecated on DeviceOrientationCamera, use camera.inputs.attached.deviceOrientation.angularSensibility instead.");
+                var gamepad = this.inputs.attached["deviceOrientation"];
+                if (gamepad)
+                    gamepad.angularSensibility = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(DeviceOrientationCamera.prototype, "moveSensibility", {
+            //deprecated
+            get: function () {
+                BABYLON.Tools.Warn("Warning: moveSensibility is deprecated on DeviceOrientationCamera, use camera.inputs.attached.deviceOrientation.moveSensibility instead.");
+                var gamepad = this.inputs.attached["deviceOrientation"];
+                if (gamepad)
+                    return gamepad.moveSensibility;
+            },
+            //deprecated
+            set: function (value) {
+                BABYLON.Tools.Warn("Warning: moveSensibility is deprecated on DeviceOrientationCamera, use camera.inputs.attached.deviceOrientation.moveSensibility instead.");
+                var gamepad = this.inputs.attached["deviceOrientation"];
+                if (gamepad)
+                    gamepad.moveSensibility = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
         DeviceOrientationCamera.prototype.getTypeName = function () {
             return "DeviceOrientationCamera";
         };

src/Cameras/babylon.deviceOrientationCamera.ts

@@ -1,6 +1,40 @@
 module BABYLON {
     // We're mainly based on the logic defined into the FreeCamera code
     export class DeviceOrientationCamera extends FreeCamera {
+        //-- 2016-03-08 properties for backward compatibility for inputs
+        //deprecated
+        public get angularSensibility() {
+            Tools.Warn("Warning: angularSensibility is deprecated on DeviceOrientationCamera, use camera.inputs.attached.deviceOrientation.angularSensibility instead.");
+            var gamepad = <FreeCameraDeviceOrientationInput>this.inputs.attached["deviceOrientation"];
+            if (gamepad)
+                return gamepad.angularSensibility;
+        }
+        
+        //deprecated
+        public set angularSensibility(value) {
+            Tools.Warn("Warning: angularSensibility is deprecated on DeviceOrientationCamera, use camera.inputs.attached.deviceOrientation.angularSensibility instead.");
+            var gamepad = <FreeCameraDeviceOrientationInput>this.inputs.attached["deviceOrientation"];
+            if (gamepad)
+                gamepad.angularSensibility = value;
+        }
+        
+        //deprecated
+        public get moveSensibility() {
+            Tools.Warn("Warning: moveSensibility is deprecated on DeviceOrientationCamera, use camera.inputs.attached.deviceOrientation.moveSensibility instead.");
+            var gamepad = <FreeCameraDeviceOrientationInput>this.inputs.attached["deviceOrientation"];
+            if (gamepad)
+                return gamepad.moveSensibility;
+        }
+        
+        //deprecated
+        public set moveSensibility(value) {
+            Tools.Warn("Warning: moveSensibility is deprecated on DeviceOrientationCamera, use camera.inputs.attached.deviceOrientation.moveSensibility instead.");
+            var gamepad = <FreeCameraDeviceOrientationInput>this.inputs.attached["deviceOrientation"];
+            if (gamepad)
+                gamepad.moveSensibility = value;
+        }
+        //-- end properties for backward compatibility for inputs
+        
         constructor(name: string, position: Vector3, scene: Scene) {
             super(name, position, scene);
             this.inputs.addDeviceOrientation();

src/Cameras/babylon.freeCamera.js

@@ -45,6 +45,97 @@ var BABYLON;
             this.inputs = new BABYLON.FreeCameraInputsManager(this);
             this.inputs.addKeyboard().addMouse();
         }
+        Object.defineProperty(FreeCamera.prototype, "angularSensibility", {
+            //-- 2016-03-08 properties for backward compatibility for inputs
+            //deprecated
+            get: function () {
+                BABYLON.Tools.Warn("Warning: angularSensibility is deprecated on FreeCamera, use camera.inputs.attached.mouse.angularSensibility instead.");
+                var mouse = this.inputs.attached["mouse"];
+                if (mouse)
+                    return mouse.angularSensibility;
+            },
+            //deprecated
+            set: function (value) {
+                BABYLON.Tools.Warn("Warning: angularSensibility is deprecated on FreeCamera, use camera.inputs.attached.mouse.angularSensibility instead.");
+                var mouse = this.inputs.attached["mouse"];
+                if (mouse)
+                    mouse.angularSensibility = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(FreeCamera.prototype, "keysUp", {
+            //deprecated
+            get: function () {
+                BABYLON.Tools.Warn("Warning: keysUp is deprecated on FreeCamera, use camera.inputs.attached.keyboard.keysUp instead.");
+                var keyboard = this.inputs.attached["keyboard"];
+                if (keyboard)
+                    return keyboard.keysUp;
+            },
+            //deprecated
+            set: function (value) {
+                BABYLON.Tools.Warn("Warning: keysUp is deprecated on FreeCamera, use camera.inputs.attached.keyboard.keysUp instead.");
+                var keyboard = this.inputs.attached["keyboard"];
+                if (keyboard)
+                    keyboard.keysUp = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(FreeCamera.prototype, "keysDown", {
+            //deprecated
+            get: function () {
+                BABYLON.Tools.Warn("Warning: keysDown is deprecated on FreeCamera, use camera.inputs.attached.keyboard.keysDown instead.");
+                var keyboard = this.inputs.attached["keyboard"];
+                if (keyboard)
+                    return keyboard.keysDown;
+            },
+            //deprecated
+            set: function (value) {
+                BABYLON.Tools.Warn("Warning: keysDown is deprecated on FreeCamera, use camera.inputs.attached.keyboard.keysDown instead.");
+                var keyboard = this.inputs.attached["keyboard"];
+                if (keyboard)
+                    keyboard.keysDown = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(FreeCamera.prototype, "keysLeft", {
+            //deprecated
+            get: function () {
+                BABYLON.Tools.Warn("Warning: keysLeft is deprecated on FreeCamera, use camera.inputs.attached.keyboard.keysLeft instead.");
+                var keyboard = this.inputs.attached["keyboard"];
+                if (keyboard)
+                    return keyboard.keysLeft;
+            },
+            //deprecated
+            set: function (value) {
+                BABYLON.Tools.Warn("Warning: keysLeft is deprecated on FreeCamera, use camera.inputs.attached.keyboard.keysLeft instead.");
+                var keyboard = this.inputs.attached["keyboard"];
+                if (keyboard)
+                    keyboard.keysLeft = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(FreeCamera.prototype, "keysRight", {
+            //deprecated
+            get: function () {
+                BABYLON.Tools.Warn("Warning: keysRight is deprecated on FreeCamera, use camera.inputs.attached.keyboard.keysRight instead.");
+                var keyboard = this.inputs.attached["keyboard"];
+                if (keyboard)
+                    return keyboard.keysRight;
+            },
+            //deprecated
+            set: function (value) {
+                BABYLON.Tools.Warn("Warning: keysRight is deprecated on FreeCamera, use camera.inputs.attached.keyboard.keysRight instead.");
+                var keyboard = this.inputs.attached["keyboard"];
+                if (keyboard)
+                    keyboard.keysRight = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
         // Controls
         FreeCamera.prototype.attachControl = function (element, noPreventDefault) {
             if (this._attachedElement) {

src/Cameras/babylon.freeCamera.ts

@@ -8,9 +8,92 @@
 
         @serialize()
         public applyGravity = false;
-        
+                
         public inputs : FreeCameraInputsManager;
-
+        
+        //-- 2016-03-08 properties for backward compatibility for inputs
+        //deprecated
+        public get angularSensibility() {
+            Tools.Warn("Warning: angularSensibility is deprecated on FreeCamera, use camera.inputs.attached.mouse.angularSensibility instead.");
+            var mouse = <FreeCameraMouseInput>this.inputs.attached["mouse"];
+            if (mouse)
+                return mouse.angularSensibility;
+        }
+        
+        //deprecated
+        public set angularSensibility(value) {
+            Tools.Warn("Warning: angularSensibility is deprecated on FreeCamera, use camera.inputs.attached.mouse.angularSensibility instead.");
+            var mouse = <FreeCameraMouseInput>this.inputs.attached["mouse"];
+            if (mouse)
+                mouse.angularSensibility = value;
+        }
+        
+        //deprecated
+        public get keysUp() {
+            Tools.Warn("Warning: keysUp is deprecated on FreeCamera, use camera.inputs.attached.keyboard.keysUp instead.");
+            var keyboard = <FreeCameraKeyboardMoveInput>this.inputs.attached["keyboard"];
+            if (keyboard)
+                return keyboard.keysUp;
+        }
+        
+        //deprecated
+        public set keysUp(value) {
+            Tools.Warn("Warning: keysUp is deprecated on FreeCamera, use camera.inputs.attached.keyboard.keysUp instead.");
+            var keyboard = <FreeCameraKeyboardMoveInput>this.inputs.attached["keyboard"];
+            if (keyboard)
+                keyboard.keysUp = value;
+        }
+        
+        //deprecated
+        public get keysDown() {
+            Tools.Warn("Warning: keysDown is deprecated on FreeCamera, use camera.inputs.attached.keyboard.keysDown instead.");
+            var keyboard = <FreeCameraKeyboardMoveInput>this.inputs.attached["keyboard"];
+            if (keyboard)
+                return keyboard.keysDown;
+        }
+        
+        //deprecated
+        public set keysDown(value) {
+            Tools.Warn("Warning: keysDown is deprecated on FreeCamera, use camera.inputs.attached.keyboard.keysDown instead.");
+            var keyboard = <FreeCameraKeyboardMoveInput>this.inputs.attached["keyboard"];
+            if (keyboard)
+                keyboard.keysDown = value;
+        }
+        
+        //deprecated
+        public get keysLeft() {
+            Tools.Warn("Warning: keysLeft is deprecated on FreeCamera, use camera.inputs.attached.keyboard.keysLeft instead.");
+            var keyboard = <FreeCameraKeyboardMoveInput>this.inputs.attached["keyboard"];
+            if (keyboard)
+                return keyboard.keysLeft;
+        }
+        
+        //deprecated
+        public set keysLeft(value) {
+            Tools.Warn("Warning: keysLeft is deprecated on FreeCamera, use camera.inputs.attached.keyboard.keysLeft instead.");
+            var keyboard = <FreeCameraKeyboardMoveInput>this.inputs.attached["keyboard"];
+            if (keyboard)
+                keyboard.keysLeft = value;
+        }
+        
+        //deprecated
+        public get keysRight() {
+            Tools.Warn("Warning: keysRight is deprecated on FreeCamera, use camera.inputs.attached.keyboard.keysRight instead.");
+            var keyboard = <FreeCameraKeyboardMoveInput>this.inputs.attached["keyboard"];
+            if (keyboard)
+                return keyboard.keysRight;
+        }
+        
+        //deprecated
+        public set keysRight(value) {
+            Tools.Warn("Warning: keysRight is deprecated on FreeCamera, use camera.inputs.attached.keyboard.keysRight instead.");
+            var keyboard = <FreeCameraKeyboardMoveInput>this.inputs.attached["keyboard"];
+            if (keyboard)
+                keyboard.keysRight = value;
+        }
+        
+        //-- end properties for backward compatibility for inputs
+        
         public onCollide: (collidedMesh: AbstractMesh) => void;
         
         private _collider = new Collider();

src/Cameras/babylon.freeCameraInputsManager.js

@@ -32,6 +32,10 @@ var BABYLON;
             this.add(new BABYLON.FreeCameraDeviceOrientationInput());
             return this;
         };
+        FreeCameraInputsManager.prototype.addVRDeviceOrientation = function () {
+            this.add(new BABYLON.FreeCameraVRDeviceOrientationInput());
+            return this;
+        };
         FreeCameraInputsManager.prototype.addTouch = function () {
             this.add(new BABYLON.FreeCameraTouchInput());
             return this;

src/Cameras/babylon.freeCameraInputsManager.ts

@@ -31,6 +31,11 @@ module BABYLON {
             return this;
         }
         
+        addVRDeviceOrientation(){
+            this.add(new FreeCameraVRDeviceOrientationInput());
+            return this;
+        }
+        
         addTouch(){
             this.add(new FreeCameraTouchInput());
             return this;

src/Cameras/babylon.gamepadCamera.js

@@ -8,10 +8,48 @@ var BABYLON;
     // We're mainly based on the logic defined into the FreeCamera code
     var GamepadCamera = (function (_super) {
         __extends(GamepadCamera, _super);
+        //-- end properties for backward compatibility for inputs
         function GamepadCamera(name, position, scene) {
             BABYLON.Tools.Warn("Deprecated. Please use Universal Camera instead.");
             _super.call(this, name, position, scene);
         }
+        Object.defineProperty(GamepadCamera.prototype, "gamepadAngularSensibility", {
+            //-- 2016-03-08 properties for backward compatibility for inputs
+            //deprecated
+            get: function () {
+                BABYLON.Tools.Warn("Warning: gamepadAngularSensibility is deprecated on GamepadCamera, use camera.inputs.attached.gamepad.gamepadAngularSensibility instead.");
+                var gamepad = this.inputs.attached["gamepad"];
+                if (gamepad)
+                    return gamepad.gamepadAngularSensibility;
+            },
+            //deprecated
+            set: function (value) {
+                BABYLON.Tools.Warn("Warning: gamepadAngularSensibility is deprecated on GamepadCamera, use camera.inputs.attached.gamepad.gamepadAngularSensibility instead.");
+                var gamepad = this.inputs.attached["gamepad"];
+                if (gamepad)
+                    gamepad.gamepadAngularSensibility = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GamepadCamera.prototype, "gamepadMoveSensibility", {
+            //deprecated
+            get: function () {
+                BABYLON.Tools.Warn("Warning: gamepadMoveSensibility is deprecated on GamepadCamera, use camera.inputs.attached.gamepad.gamepadMoveSensibility instead.");
+                var gamepad = this.inputs.attached["gamepad"];
+                if (gamepad)
+                    return gamepad.gamepadMoveSensibility;
+            },
+            //deprecated
+            set: function (value) {
+                BABYLON.Tools.Warn("Warning: gamepadMoveSensibility is deprecated on GamepadCamera, use camera.inputs.attached.gamepad.gamepadMoveSensibility instead.");
+                var gamepad = this.inputs.attached["gamepad"];
+                if (gamepad)
+                    gamepad.gamepadMoveSensibility = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
         GamepadCamera.prototype.getTypeName = function () {
             return "GamepadCamera";
         };

src/Cameras/babylon.gamepadCamera.ts

@@ -1,6 +1,41 @@
 module BABYLON {
     // We're mainly based on the logic defined into the FreeCamera code
     export class GamepadCamera extends UniversalCamera {
+        //-- 2016-03-08 properties for backward compatibility for inputs
+        //deprecated
+        public get gamepadAngularSensibility() {
+            Tools.Warn("Warning: gamepadAngularSensibility is deprecated on GamepadCamera, use camera.inputs.attached.gamepad.gamepadAngularSensibility instead.");
+            var gamepad = <FreeCameraGamepadInput>this.inputs.attached["gamepad"];
+            if (gamepad)
+                return gamepad.gamepadAngularSensibility;
+        }
+        
+        //deprecated
+        public set gamepadAngularSensibility(value) {
+            Tools.Warn("Warning: gamepadAngularSensibility is deprecated on GamepadCamera, use camera.inputs.attached.gamepad.gamepadAngularSensibility instead.");
+            var gamepad = <FreeCameraGamepadInput>this.inputs.attached["gamepad"];
+            if (gamepad)
+                gamepad.gamepadAngularSensibility = value;
+        }
+        
+        //deprecated
+        public get gamepadMoveSensibility() {
+            Tools.Warn("Warning: gamepadMoveSensibility is deprecated on GamepadCamera, use camera.inputs.attached.gamepad.gamepadMoveSensibility instead.");
+            var gamepad = <FreeCameraGamepadInput>this.inputs.attached["gamepad"];
+            if (gamepad)
+                return gamepad.gamepadMoveSensibility;
+        }
+        
+        //deprecated
+        public set gamepadMoveSensibility(value) {
+            Tools.Warn("Warning: gamepadMoveSensibility is deprecated on GamepadCamera, use camera.inputs.attached.gamepad.gamepadMoveSensibility instead.");
+            var gamepad = <FreeCameraGamepadInput>this.inputs.attached["gamepad"];
+            if (gamepad)
+                gamepad.gamepadMoveSensibility = value;
+        }
+        //-- end properties for backward compatibility for inputs
+        
+        
         constructor(name: string, position: Vector3, scene: Scene) {
             Tools.Warn("Deprecated. Please use Universal Camera instead.");
             super(name, position, scene);

src/Cameras/babylon.touchCamera.js

@@ -8,10 +8,48 @@ var BABYLON;
     // We're mainly based on the logic defined into the FreeCamera code
     var TouchCamera = (function (_super) {
         __extends(TouchCamera, _super);
+        //-- end properties for backward compatibility for inputs
         function TouchCamera(name, position, scene) {
             _super.call(this, name, position, scene);
             this.inputs.addTouch();
         }
+        Object.defineProperty(TouchCamera.prototype, "touchAngularSensibility", {
+            //-- 2016-03-08 properties for backward compatibility for inputs
+            //deprecated
+            get: function () {
+                BABYLON.Tools.Warn("Warning: touchAngularSensibility is deprecated on TouchCamera, use camera.inputs.attached.touch.touchAngularSensibility instead.");
+                var touch = this.inputs.attached["touch"];
+                if (touch)
+                    return touch.touchAngularSensibility;
+            },
+            //deprecated
+            set: function (value) {
+                BABYLON.Tools.Warn("Warning: touchAngularSensibility is deprecated on TouchCamera, use camera.inputs.attached.touch.touchAngularSensibility instead.");
+                var touch = this.inputs.attached["touch"];
+                if (touch)
+                    touch.touchAngularSensibility = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(TouchCamera.prototype, "touchMoveSensibility", {
+            //deprecated
+            get: function () {
+                BABYLON.Tools.Warn("Warning: touchMoveSensibility is deprecated on TouchCamera, use camera.inputs.attached.touch.touchMoveSensibility instead.");
+                var touch = this.inputs.attached["touch"];
+                if (touch)
+                    return touch.touchMoveSensibility;
+            },
+            //deprecated
+            set: function (value) {
+                BABYLON.Tools.Warn("Warning: touchMoveSensibility is deprecated on TouchCamera, use camera.inputs.attached.touch.touchMoveSensibility instead.");
+                var touch = this.inputs.attached["touch"];
+                if (touch)
+                    touch.touchMoveSensibility = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
         TouchCamera.prototype.getTypeName = function () {
             return "TouchCamera";
         };

src/Cameras/babylon.touchCamera.ts

@@ -1,6 +1,40 @@
 module BABYLON {
     // We're mainly based on the logic defined into the FreeCamera code
     export class TouchCamera extends FreeCamera {
+        //-- 2016-03-08 properties for backward compatibility for inputs
+        //deprecated
+        public get touchAngularSensibility() {
+            Tools.Warn("Warning: touchAngularSensibility is deprecated on TouchCamera, use camera.inputs.attached.touch.touchAngularSensibility instead.");
+            var touch = <FreeCameraTouchInput>this.inputs.attached["touch"];
+            if (touch)
+                return touch.touchAngularSensibility;
+        }
+        
+        //deprecated
+        public set touchAngularSensibility(value) {
+            Tools.Warn("Warning: touchAngularSensibility is deprecated on TouchCamera, use camera.inputs.attached.touch.touchAngularSensibility instead.");
+            var touch = <FreeCameraTouchInput>this.inputs.attached["touch"];
+            if (touch)
+                touch.touchAngularSensibility = value;
+        }
+        
+        //deprecated
+        public get touchMoveSensibility() {
+            Tools.Warn("Warning: touchMoveSensibility is deprecated on TouchCamera, use camera.inputs.attached.touch.touchMoveSensibility instead.");
+            var touch = <FreeCameraTouchInput>this.inputs.attached["touch"];
+            if (touch)
+                return touch.touchMoveSensibility;
+        }
+        
+        //deprecated
+        public set touchMoveSensibility(value) {
+            Tools.Warn("Warning: touchMoveSensibility is deprecated on TouchCamera, use camera.inputs.attached.touch.touchMoveSensibility instead.");
+            var touch = <FreeCameraTouchInput>this.inputs.attached["touch"];
+            if (touch)
+                touch.touchMoveSensibility = value;
+        }
+        //-- end properties for backward compatibility for inputs
+        
         constructor(name: string, position: Vector3, scene: Scene) {
             super(name, position, scene);
             this.inputs.addTouch();

src/Cameras/babylon.universalCamera.js

@@ -8,10 +8,48 @@ var BABYLON;
     // We're mainly based on the logic defined into the FreeCamera code
     var UniversalCamera = (function (_super) {
         __extends(UniversalCamera, _super);
+        //-- end properties for backward compatibility for inputs
         function UniversalCamera(name, position, scene) {
             _super.call(this, name, position, scene);
             this.inputs.addGamepad();
         }
+        Object.defineProperty(UniversalCamera.prototype, "gamepadAngularSensibility", {
+            //-- 2016-03-08 properties for backward compatibility for inputs
+            //deprecated
+            get: function () {
+                BABYLON.Tools.Warn("Warning: gamepadAngularSensibility is deprecated, use camera.inputs.attached.gamepad.gamepadAngularSensibility instead.");
+                var gamepad = this.inputs.attached["gamepad"];
+                if (gamepad)
+                    return gamepad.gamepadAngularSensibility;
+            },
+            //deprecated
+            set: function (value) {
+                BABYLON.Tools.Warn("Warning: gamepadAngularSensibility is deprecated, use camera.inputs.attached.gamepad.gamepadAngularSensibility instead.");
+                var gamepad = this.inputs.attached["gamepad"];
+                if (gamepad)
+                    gamepad.gamepadAngularSensibility = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(UniversalCamera.prototype, "gamepadMoveSensibility", {
+            //deprecated
+            get: function () {
+                BABYLON.Tools.Warn("Warning: gamepadMoveSensibility is deprecated, use camera.inputs.attached.gamepad.gamepadMoveSensibility instead.");
+                var gamepad = this.inputs.attached["gamepad"];
+                if (gamepad)
+                    return gamepad.gamepadMoveSensibility;
+            },
+            //deprecated
+            set: function (value) {
+                BABYLON.Tools.Warn("Warning: gamepadMoveSensibility is deprecated, use camera.inputs.attached.gamepad.gamepadMoveSensibility instead.");
+                var gamepad = this.inputs.attached["gamepad"];
+                if (gamepad)
+                    gamepad.gamepadMoveSensibility = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
         UniversalCamera.prototype.getTypeName = function () {
             return "UniversalCamera";
         };

src/Cameras/babylon.universalCamera.ts

@@ -1,7 +1,40 @@
 module BABYLON {
     // We're mainly based on the logic defined into the FreeCamera code
     export class UniversalCamera extends TouchCamera {
-
+        //-- 2016-03-08 properties for backward compatibility for inputs
+        //deprecated
+        public get gamepadAngularSensibility() {
+            Tools.Warn("Warning: gamepadAngularSensibility is deprecated, use camera.inputs.attached.gamepad.gamepadAngularSensibility instead.");
+            var gamepad = <FreeCameraGamepadInput>this.inputs.attached["gamepad"];
+            if (gamepad)
+                return gamepad.gamepadAngularSensibility;
+        }
+        
+        //deprecated
+        public set gamepadAngularSensibility(value) {
+            Tools.Warn("Warning: gamepadAngularSensibility is deprecated, use camera.inputs.attached.gamepad.gamepadAngularSensibility instead.");
+            var gamepad = <FreeCameraGamepadInput>this.inputs.attached["gamepad"];
+            if (gamepad)
+                gamepad.gamepadAngularSensibility = value;
+        }
+        
+        //deprecated
+        public get gamepadMoveSensibility() {
+            Tools.Warn("Warning: gamepadMoveSensibility is deprecated, use camera.inputs.attached.gamepad.gamepadMoveSensibility instead.");
+            var gamepad = <FreeCameraGamepadInput>this.inputs.attached["gamepad"];
+            if (gamepad)
+                return gamepad.gamepadMoveSensibility;
+        }
+        
+        //deprecated
+        public set gamepadMoveSensibility(value) {
+            Tools.Warn("Warning: gamepadMoveSensibility is deprecated, use camera.inputs.attached.gamepad.gamepadMoveSensibility instead.");
+            var gamepad = <FreeCameraGamepadInput>this.inputs.attached["gamepad"];
+            if (gamepad)
+                gamepad.gamepadMoveSensibility = value;
+        }
+        //-- end properties for backward compatibility for inputs
+        
         constructor(name: string, position: Vector3, scene: Scene) {
             super(name, position, scene);
             this.inputs.addGamepad();

src/Cameras/babylon.virtualJoysticksCamera.js

@@ -8,21 +8,9 @@ var BABYLON;
     // We're mainly based on the logic defined into the FreeCamera code
     var VirtualJoysticksCamera = (function (_super) {
         __extends(VirtualJoysticksCamera, _super);
-        // private _leftjoystick: VirtualJoystick;
-        // private _rightjoystick: VirtualJoystick;
         function VirtualJoysticksCamera(name, position, scene) {
             _super.call(this, name, position, scene);
             this.inputs.addVirtualJoystick();
-            // this._leftjoystick = new VirtualJoystick(true);
-            // this._leftjoystick.setAxisForUpDown(JoystickAxis.Z);
-            // this._leftjoystick.setAxisForLeftRight(JoystickAxis.X);
-            // this._leftjoystick.setJoystickSensibility(0.15);
-            // this._rightjoystick = new VirtualJoystick(false);
-            // this._rightjoystick.setAxisForUpDown(JoystickAxis.X);
-            // this._rightjoystick.setAxisForLeftRight(JoystickAxis.Y);
-            // this._rightjoystick.reverseUpDown = true;
-            // this._rightjoystick.setJoystickSensibility(0.05);
-            // this._rightjoystick.setJoystickColor("yellow");
         }
         return VirtualJoysticksCamera;
     }(BABYLON.FreeCamera));

src/Cameras/babylon.virtualJoysticksCamera.ts

@@ -1,55 +1,10 @@
 module BABYLON {
     // We're mainly based on the logic defined into the FreeCamera code
     export class VirtualJoysticksCamera extends FreeCamera {
-        // private _leftjoystick: VirtualJoystick;
-        // private _rightjoystick: VirtualJoystick;
-
+        
         constructor(name: string, position: Vector3, scene: Scene) {
             super(name, position, scene);
             this.inputs.addVirtualJoystick();
-            // this._leftjoystick = new VirtualJoystick(true);
-            // this._leftjoystick.setAxisForUpDown(JoystickAxis.Z);
-            // this._leftjoystick.setAxisForLeftRight(JoystickAxis.X);
-            // this._leftjoystick.setJoystickSensibility(0.15);
-            // this._rightjoystick = new VirtualJoystick(false);
-            // this._rightjoystick.setAxisForUpDown(JoystickAxis.X);
-            // this._rightjoystick.setAxisForLeftRight(JoystickAxis.Y);
-            // this._rightjoystick.reverseUpDown = true;
-            // this._rightjoystick.setJoystickSensibility(0.05);
-            // this._rightjoystick.setJoystickColor("yellow");
         }
-
-        // public getLeftJoystick(): VirtualJoystick {
-        //     return this._leftjoystick;
-        // }
-
-        // public getRightJoystick(): VirtualJoystick {
-        //     return this._rightjoystick;
-        // }
-
-        // public _checkInputs(): void {
-        //     var speed = this._computeLocalCameraSpeed() * 50;
-        //     var cameraTransform = Matrix.RotationYawPitchRoll(this.rotation.y, this.rotation.x, 0);
-        //     var deltaTransform = Vector3.TransformCoordinates(new Vector3(this._leftjoystick.deltaPosition.x * speed, this._leftjoystick.deltaPosition.y * speed, this._leftjoystick.deltaPosition.z * speed), cameraTransform);
-        //     this.cameraDirection = this.cameraDirection.add(deltaTransform);
-        //     this.cameraRotation = this.cameraRotation.addVector3(this._rightjoystick.deltaPosition);
-        //     if (!this._leftjoystick.pressed) {
-        //         this._leftjoystick.deltaPosition = this._leftjoystick.deltaPosition.scale(0.9);
-        //     }
-        //     if (!this._rightjoystick.pressed) {
-        //         this._rightjoystick.deltaPosition = this._rightjoystick.deltaPosition.scale(0.9);
-        //     }
-
-        //     super._checkInputs();
-        // }
-
-        // public dispose(): void {
-        //     this._leftjoystick.releaseCanvas();
-        //     super.dispose();
-        // }
-
-        // public getTypeName(): string {
-        //     return "VirtualJoysticksCamera";
-        // }
     }
 }