Dispatch cameras to specific files

Tools/Gulp/config.json

@@ -99,6 +99,7 @@
             "gizmos",
             "morphTargets",
             "octrees",
+            "anaglyph",
             "vr",
             "virtualJoystick",
             "optimizations",
@@ -655,7 +656,8 @@
                 "../../src/Gamepad/Controllers/babylon.genericController.js",
                 "../../src/Gamepad/Controllers/babylon.windowsMotionController.js",
                 "../../src/Gamepad/Controllers/babylon.gearVRController.js",
-                "../../src/Gamepad/Controllers/babylon.daydreamController.js"
+                "../../src/Gamepad/Controllers/babylon.daydreamController.js",
+                "../../src/Gamepad/babylon.gamepadSceneComponent.js"
             ],
             "dependUpon": [
                 "core"
@@ -1108,28 +1110,62 @@
                 "core"
             ]
         },
-        "vr": {
+        "anaglyph": {
             "files": [
-                "../../src/PostProcess/babylon.vrDistortionCorrectionPostProcess.js",
                 "../../src/PostProcess/babylon.anaglyphPostProcess.js",
+                "../../src/Cameras/Stereoscopic/babylon.anaglyphArcRotateCamera.js",
+                "../../src/Cameras/Stereoscopic/babylon.anaglyphFreeCamera.js",
+                "../../src/Cameras/Stereoscopic/babylon.anaglyphGamepadCamera.js",
+                "../../src/Cameras/Stereoscopic/babylon.anaglyphUniversalCamera.js"
+            ],
+            "dependUpon": [
+                "core",
+                "postProcesses",
+                "freeCamera",
+                "gamepad"
+            ],
+            "shaders": [
+                "anaglyph.fragment"
+            ]
+        },       
+        "stereoscopic": {
+            "files": [
                 "../../src/PostProcess/babylon.stereoscopicInterlacePostProcess.js",
+                "../../src/Cameras/Stereoscopic/babylon.stereoscopicArcRotateCamera.js",
+                "../../src/Cameras/Stereoscopic/babylon.stereoscopicFreeCamera.js",
+                "../../src/Cameras/Stereoscopic/babylon.stereoscopicGamepadCamera.js",
+                "../../src/Cameras/Stereoscopic/babylon.stereoscopicUniversalCamera.js"
+            ],
+            "dependUpon": [
+                "core",
+                "postProcesses",
+                "freeCamera",
+                "gamepad"
+            ],
+            "shaders": [
+                "stereoscopicInterlace.fragment"
+            ]
+        },           
+        "vr": {
+            "files": [
+                "../../src/PostProcess/babylon.vrDistortionCorrectionPostProcess.js",
                 "../../src/Cameras/Inputs/babylon.freeCameraDeviceOrientationInput.js",
                 "../../src/Cameras/Inputs/babylon.arcRotateCameraVRDeviceOrientationInput.js",
                 "../../src/Cameras/VR/babylon.vrCameraMetrics.js",
                 "../../src/Cameras/VR/babylon.webVRCamera.js",
                 "../../src/Cameras/babylon.deviceOrientationCamera.js",
-                "../../src/Cameras/VR/babylon.vrDeviceOrientationCamera.js",
-                "../../src/Cameras/babylon.stereoscopicCameras.js",
+                "../../src/Cameras/VR/babylon.vrDeviceOrientationFreeCamera.js",
+                "../../src/Cameras/VR/babylon.vrDeviceOrientationArcRotateCamera.js",
+                "../../src/Cameras/VR/babylon.vrDeviceOrientationGamepadCamera.js",
                 "../../src/Cameras/VR/babylon.vrExperienceHelper.js"
             ],
             "dependUpon": [
                 "core",
                 "postProcesses",
-                "freeCamera"
+                "freeCamera",
+                "gamepad"
             ],
             "shaders": [
-                "anaglyph.fragment",
-                "stereoscopicInterlace.fragment",
                 "vrDistortionCorrection.fragment"
             ]
         },

dist/preview release/typedocValidationBaseline.json

@@ -1,7 +1,7 @@
 {
-  "errors": 4221,
+  "errors": 4224,
   "babylon.typedoc.json": {
-    "errors": 4221,
+    "errors": 4224,
     "AbstractScene": {
       "Property": {
         "effectLayers": {
@@ -580,11 +580,6 @@
         }
       },
       "Method": {
-        "addGamepad": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
         "addKeyboard": {
           "Comments": {
             "MissingText": true
@@ -604,6 +599,14 @@
           "Comments": {
             "MissingText": true
           }
+        },
+        "addGamepad": {
+          "Naming": {
+            "NotPascalCase": true
+          },
+          "Comments": {
+            "MissingText": true
+          }
         }
       }
     },
@@ -5693,11 +5696,6 @@
             "MissingText": true
           }
         },
-        "addGamepad": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
         "addKeyboard": {
           "Comments": {
             "MissingText": true
@@ -5724,6 +5722,14 @@
           "Comments": {
             "MissingText": true
           }
+        },
+        "addGamepad": {
+          "Naming": {
+            "NotPascalCase": true
+          },
+          "Comments": {
+            "MissingText": true
+          }
         }
       }
     },
@@ -15129,6 +15135,11 @@
           "Naming": {
             "NotPascalCase": true
           }
+        },
+        "gamepadManager": {
+          "Naming": {
+            "NotPascalCase": true
+          }
         }
       },
       "Method": {

src/Cameras/Stereoscopic/babylon.anaglyphArcRotateCamera.ts

@@ -0,0 +1,35 @@
+module BABYLON {
+    Node.AddNodeConstructor("AnaglyphArcRotateCamera", (name, scene, options) => {
+        return () => new AnaglyphArcRotateCamera(name, 0, 0, 1.0, Vector3.Zero(), options.interaxial_distance, scene);
+    });
+
+    /**
+     * Camera used to simulate anaglyphic rendering (based on ArcRotateCamera)
+     */    
+    export class AnaglyphArcRotateCamera extends ArcRotateCamera {
+
+        /**
+         * Creates a new AnaglyphArcRotateCamera
+         * @param name defines camera name
+         * @param alpha defines alpha angle (in radians)
+         * @param beta defines beta angle (in radians)
+         * @param radius defines radius
+         * @param target defines camera target 
+         * @param interaxialDistance defines distance between each color axis
+         * @param scene defines the hosting scene
+         */
+        constructor(name: string, alpha: number, beta: number, radius: number, target: Vector3, interaxialDistance: number, scene: Scene) {
+            super(name, alpha, beta, radius, target, scene);
+            this.interaxialDistance = interaxialDistance;
+            this.setCameraRigMode(Camera.RIG_MODE_STEREOSCOPIC_ANAGLYPH, { interaxialDistance: interaxialDistance });
+        }
+
+        /**
+         * Gets camera class name
+         * @returns AnaglyphArcRotateCamera
+         */        
+        public getClassName(): string {
+            return "AnaglyphArcRotateCamera";
+        }
+    }
+}

src/Cameras/Stereoscopic/babylon.anaglyphFreeCamera.ts

@@ -0,0 +1,31 @@
+module BABYLON {
+    Node.AddNodeConstructor("AnaglyphFreeCamera", (name, scene, options) => {
+        return () => new AnaglyphFreeCamera(name, Vector3.Zero(), options.interaxial_distance, scene);
+    });
+
+    /**
+     * Camera used to simulate anaglyphic rendering (based on FreeCamera)
+     */
+    export class AnaglyphFreeCamera extends FreeCamera {
+        /**
+         * Creates a new AnaglyphFreeCamera
+         * @param name defines camera name
+         * @param position defines initial position
+         * @param interaxialDistance defines distance between each color axis
+         * @param scene defines the hosting scene
+         */
+        constructor(name: string, position: Vector3, interaxialDistance: number, scene: Scene) {
+            super(name, position, scene);
+            this.interaxialDistance = interaxialDistance;
+            this.setCameraRigMode(Camera.RIG_MODE_STEREOSCOPIC_ANAGLYPH, { interaxialDistance: interaxialDistance });
+        }
+
+        /**
+         * Gets camera class name
+         * @returns AnaglyphFreeCamera
+         */
+        public getClassName(): string {
+            return "AnaglyphFreeCamera";
+        }
+    }
+}

src/Cameras/Stereoscopic/babylon.anaglyphGamepadCamera.ts

@@ -0,0 +1,31 @@
+module BABYLON {
+    Node.AddNodeConstructor("AnaglyphGamepadCamera", (name, scene, options) => {
+        return () => new AnaglyphGamepadCamera(name, Vector3.Zero(), options.interaxial_distance, scene);
+    });
+
+    /**
+     * Camera used to simulate anaglyphic rendering (based on GamepadCamera)
+     */       
+    export class AnaglyphGamepadCamera extends GamepadCamera {
+        /**
+         * Creates a new AnaglyphGamepadCamera
+         * @param name defines camera name
+         * @param position defines initial position
+         * @param interaxialDistance defines distance between each color axis
+         * @param scene defines the hosting scene
+         */
+        constructor(name: string, position: Vector3, interaxialDistance: number, scene: Scene) {
+            super(name, position, scene);
+            this.interaxialDistance = interaxialDistance;
+            this.setCameraRigMode(Camera.RIG_MODE_STEREOSCOPIC_ANAGLYPH, { interaxialDistance: interaxialDistance });
+        }
+
+        /**
+         * Gets camera class name
+         * @returns AnaglyphGamepadCamera
+         */   
+        public getClassName(): string {
+            return "AnaglyphGamepadCamera";
+        }
+    }
+}

src/Cameras/Stereoscopic/babylon.anaglyphUniversalCamera.ts

@@ -0,0 +1,31 @@
+module BABYLON {
+    Node.AddNodeConstructor("AnaglyphUniversalCamera", (name, scene, options) => {
+        return () => new AnaglyphUniversalCamera(name, Vector3.Zero(), options.interaxial_distance, scene);
+    });
+
+    /**
+     * Camera used to simulate anaglyphic rendering (based on UniversalCamera)
+     */        
+    export class AnaglyphUniversalCamera extends UniversalCamera {
+        /**
+         * Creates a new AnaglyphUniversalCamera
+         * @param name defines camera name
+         * @param position defines initial position
+         * @param interaxialDistance defines distance between each color axis
+         * @param scene defines the hosting scene
+         */
+        constructor(name: string, position: Vector3, interaxialDistance: number, scene: Scene) {
+            super(name, position, scene);
+            this.interaxialDistance = interaxialDistance;
+            this.setCameraRigMode(Camera.RIG_MODE_STEREOSCOPIC_ANAGLYPH, { interaxialDistance: interaxialDistance });
+        }
+
+        /**
+         * Gets camera class name
+         * @returns AnaglyphUniversalCamera
+         */           
+        public getClassName(): string {
+            return "AnaglyphUniversalCamera";
+        }
+    }
+}

src/Cameras/Stereoscopic/babylon.stereoscopicArcRotateCamera.ts

@@ -0,0 +1,36 @@
+module BABYLON {
+    Node.AddNodeConstructor("StereoscopicArcRotateCamera", (name, scene, options) => {
+        return () => new StereoscopicArcRotateCamera(name, 0, 0, 1.0, Vector3.Zero(), options.interaxial_distance, options.isStereoscopicSideBySide, scene);
+    });
+
+    /**
+     * Camera used to simulate stereoscopic rendering (based on ArcRotateCamera)
+     */      
+    export class StereoscopicArcRotateCamera extends ArcRotateCamera {
+        /**
+         * Creates a new StereoscopicArcRotateCamera
+         * @param name defines camera name
+         * @param alpha defines alpha angle (in radians)
+         * @param beta defines beta angle (in radians)
+         * @param radius defines radius
+         * @param target defines camera target 
+         * @param interaxialDistance defines distance between each color axis
+         * @param isStereoscopicSideBySide defines is stereoscopic is done side by side or over under
+         * @param scene defines the hosting scene
+         */        
+        constructor(name: string, alpha: number, beta: number, radius: number, target: Vector3, interaxialDistance: number, isStereoscopicSideBySide: boolean, scene: Scene) {
+            super(name, alpha, beta, radius, target, scene);
+            this.interaxialDistance = interaxialDistance;
+            this.isStereoscopicSideBySide = isStereoscopicSideBySide;
+            this.setCameraRigMode(isStereoscopicSideBySide ? Camera.RIG_MODE_STEREOSCOPIC_SIDEBYSIDE_PARALLEL : Camera.RIG_MODE_STEREOSCOPIC_OVERUNDER, { interaxialDistance: interaxialDistance });
+        }
+
+        /**
+         * Gets camera class name
+         * @returns StereoscopicArcRotateCamera
+         */              
+        public getClassName(): string {
+            return "StereoscopicArcRotateCamera";
+        }
+    }
+}

src/Cameras/Stereoscopic/babylon.stereoscopicFreeCamera.ts

@@ -0,0 +1,33 @@
+module BABYLON {
+    Node.AddNodeConstructor("StereoscopicFreeCamera", (name, scene, options) => {
+        return () => new StereoscopicFreeCamera(name, Vector3.Zero(), options.interaxial_distance, options.isStereoscopicSideBySide, scene);
+    });
+
+    /**
+     * Camera used to simulate stereoscopic rendering (based on FreeCamera)
+     */    
+    export class StereoscopicFreeCamera extends FreeCamera {
+        /**
+         * Creates a new StereoscopicFreeCamera
+         * @param name defines camera name
+         * @param position defines initial position
+         * @param interaxialDistance defines distance between each color axis
+         * @param isStereoscopicSideBySide defines is stereoscopic is done side by side or over under
+         * @param scene defines the hosting scene
+         */
+        constructor(name: string, position: Vector3, interaxialDistance: number, isStereoscopicSideBySide: boolean, scene: Scene) {
+            super(name, position, scene);
+            this.interaxialDistance = interaxialDistance;
+            this.isStereoscopicSideBySide = isStereoscopicSideBySide;
+            this.setCameraRigMode(isStereoscopicSideBySide ? Camera.RIG_MODE_STEREOSCOPIC_SIDEBYSIDE_PARALLEL : Camera.RIG_MODE_STEREOSCOPIC_OVERUNDER, { interaxialDistance: interaxialDistance });
+        }
+
+        /**
+         * Gets camera class name
+         * @returns StereoscopicFreeCamera
+         */            
+        public getClassName(): string {
+            return "StereoscopicFreeCamera";
+        }
+    }
+}

src/Cameras/Stereoscopic/babylon.stereoscopicGamepadCamera.ts

@@ -0,0 +1,33 @@
+module BABYLON {
+    Node.AddNodeConstructor("StereoscopicGamepadCamera", (name, scene, options) => {
+        return () => new StereoscopicGamepadCamera(name, Vector3.Zero(), options.interaxial_distance, options.isStereoscopicSideBySide, scene);
+    });
+
+    /**
+     * Camera used to simulate stereoscopic rendering (based on GamepadCamera)
+     */      
+    export class StereoscopicGamepadCamera extends GamepadCamera {
+        /**
+         * Creates a new StereoscopicGamepadCamera
+         * @param name defines camera name
+         * @param position defines initial position
+         * @param interaxialDistance defines distance between each color axis
+         * @param isStereoscopicSideBySide defines is stereoscopic is done side by side or over under
+         * @param scene defines the hosting scene
+         */        
+        constructor(name: string, position: Vector3, interaxialDistance: number, isStereoscopicSideBySide: boolean, scene: Scene) {
+            super(name, position, scene);
+            this.interaxialDistance = interaxialDistance;
+            this.isStereoscopicSideBySide = isStereoscopicSideBySide;
+            this.setCameraRigMode(isStereoscopicSideBySide ? Camera.RIG_MODE_STEREOSCOPIC_SIDEBYSIDE_PARALLEL : Camera.RIG_MODE_STEREOSCOPIC_OVERUNDER, { interaxialDistance: interaxialDistance });
+        }
+
+        /**
+         * Gets camera class name
+         * @returns StereoscopicGamepadCamera
+         */              
+        public getClassName(): string {
+            return "StereoscopicGamepadCamera";
+        }
+    }
+}

src/Cameras/Stereoscopic/babylon.stereoscopicUniversalCamera.ts

@@ -0,0 +1,32 @@
+module BABYLON {
+    Node.AddNodeConstructor("StereoscopicFreeCamera", (name, scene, options) => {
+        return () => new StereoscopicUniversalCamera(name, Vector3.Zero(), options.interaxial_distance, options.isStereoscopicSideBySide, scene);
+    });    
+    /**
+     * Camera used to simulate stereoscopic rendering (based on UniversalCamera)
+     */      
+    export class StereoscopicUniversalCamera extends UniversalCamera {
+        /**
+         * Creates a new StereoscopicUniversalCamera
+         * @param name defines camera name
+         * @param position defines initial position
+         * @param interaxialDistance defines distance between each color axis
+         * @param isStereoscopicSideBySide defines is stereoscopic is done side by side or over under
+         * @param scene defines the hosting scene
+         */        
+        constructor(name: string, position: Vector3, interaxialDistance: number, isStereoscopicSideBySide: boolean, scene: Scene) {
+            super(name, position, scene);
+            this.interaxialDistance = interaxialDistance;
+            this.isStereoscopicSideBySide = isStereoscopicSideBySide;
+            this.setCameraRigMode(isStereoscopicSideBySide ? Camera.RIG_MODE_STEREOSCOPIC_SIDEBYSIDE_PARALLEL : Camera.RIG_MODE_STEREOSCOPIC_OVERUNDER, { interaxialDistance: interaxialDistance });
+        }
+
+        /**
+         * Gets camera class name
+         * @returns StereoscopicUniversalCamera
+         */              
+        public getClassName(): string {
+            return "StereoscopicUniversalCamera";
+        }
+    }
+} 

src/Cameras/VR/babylon.vrDeviceOrientationArcRotateCamera.ts

@@ -0,0 +1,21 @@
+module BABYLON {
+    Node.AddNodeConstructor("VRDeviceOrientationFreeCamera", (name, scene) => {
+        return () => new VRDeviceOrientationArcRotateCamera(name, 0, 0, 1.0, Vector3.Zero(), scene);
+    });
+
+    export class VRDeviceOrientationArcRotateCamera extends ArcRotateCamera {
+
+        constructor(name: string, alpha: number, beta: number, radius: number, target: Vector3, scene: Scene, compensateDistortion = true, vrCameraMetrics: VRCameraMetrics = VRCameraMetrics.GetDefault()) {
+            super(name, alpha, beta, radius, target, scene);
+
+            vrCameraMetrics.compensateDistortion = compensateDistortion;
+            this.setCameraRigMode(Camera.RIG_MODE_VR, { vrCameraMetrics: vrCameraMetrics });
+
+            this.inputs.addVRDeviceOrientation();
+        }
+
+        public getClassName(): string {
+            return "VRDeviceOrientationArcRotateCamera";
+        }
+    }
+}

src/Cameras/VR/babylon.vrDeviceOrientationCamera.ts

@@ -1,45 +0,0 @@
-module BABYLON {
-    export class VRDeviceOrientationFreeCamera extends DeviceOrientationCamera {
-
-        constructor(name: string, position: Vector3, scene: Scene, compensateDistortion = true, vrCameraMetrics: VRCameraMetrics = VRCameraMetrics.GetDefault()) {
-            super(name, position, scene);
-
-            vrCameraMetrics.compensateDistortion = compensateDistortion;
-            this.setCameraRigMode(Camera.RIG_MODE_VR, { vrCameraMetrics: vrCameraMetrics });
-        }
-
-
-        public getClassName(): string {
-            return "VRDeviceOrientationFreeCamera";
-        }
-    }
-
-    export class VRDeviceOrientationGamepadCamera extends VRDeviceOrientationFreeCamera {
-
-        constructor(name: string, position: Vector3, scene: Scene, compensateDistortion = true, vrCameraMetrics: VRCameraMetrics = VRCameraMetrics.GetDefault()) {
-            super(name, position, scene, compensateDistortion, vrCameraMetrics);
-            
-            this.inputs.addGamepad();
-        }
-
-        public getClassName(): string {
-            return "VRDeviceOrientationGamepadCamera";
-        }
-    }
-
-    export class VRDeviceOrientationArcRotateCamera extends ArcRotateCamera {
-
-        constructor(name: string, alpha: number, beta: number, radius: number, target: Vector3, scene: Scene, compensateDistortion = true, vrCameraMetrics: VRCameraMetrics = VRCameraMetrics.GetDefault()) {
-            super(name, alpha, beta, radius, target, scene);
-
-            vrCameraMetrics.compensateDistortion = compensateDistortion;
-            this.setCameraRigMode(Camera.RIG_MODE_VR, { vrCameraMetrics: vrCameraMetrics });
-
-            this.inputs.addVRDeviceOrientation();
-        }
-
-        public getClassName(): string {
-            return "VRDeviceOrientationArcRotateCamera";
-        }
-    }
-}

src/Cameras/VR/babylon.vrDeviceOrientationFreeCamera.ts

@@ -0,0 +1,20 @@
+module BABYLON {
+    Node.AddNodeConstructor("VRDeviceOrientationFreeCamera", (name, scene) => {
+        return () => new VRDeviceOrientationFreeCamera(name, Vector3.Zero(), scene);
+    });
+
+    export class VRDeviceOrientationFreeCamera extends DeviceOrientationCamera {
+
+        constructor(name: string, position: Vector3, scene: Scene, compensateDistortion = true, vrCameraMetrics: VRCameraMetrics = VRCameraMetrics.GetDefault()) {
+            super(name, position, scene);
+
+            vrCameraMetrics.compensateDistortion = compensateDistortion;
+            this.setCameraRigMode(Camera.RIG_MODE_VR, { vrCameraMetrics: vrCameraMetrics });
+        }
+
+
+        public getClassName(): string {
+            return "VRDeviceOrientationFreeCamera";
+        }
+    }
+}

src/Cameras/VR/babylon.vrDeviceOrientationGamepadCamera.ts

@@ -0,0 +1,18 @@
+module BABYLON {
+    Node.AddNodeConstructor("VRDeviceOrientationGamepadCamera", (name, scene) => {
+        return () => new VRDeviceOrientationGamepadCamera(name, Vector3.Zero(), scene);
+    });
+
+    export class VRDeviceOrientationGamepadCamera extends VRDeviceOrientationFreeCamera {
+
+        constructor(name: string, position: Vector3, scene: Scene, compensateDistortion = true, vrCameraMetrics: VRCameraMetrics = VRCameraMetrics.GetDefault()) {
+            super(name, position, scene, compensateDistortion, vrCameraMetrics);
+            
+            this.inputs.addGamepad();
+        }
+
+        public getClassName(): string {
+            return "VRDeviceOrientationGamepadCamera";
+        }
+    }
+}

src/Cameras/VR/babylon.webVRCamera.ts

@@ -1,4 +1,12 @@
 module BABYLON {
+    Node.AddNodeConstructor("WebVRFreeCamera", (name, scene) => {
+        return () => new WebVRFreeCamera(name, Vector3.Zero(), scene);
+    });
+
+    Node.AddNodeConstructor("WebVRGamepadCamera", (name, scene) => {
+        return () => new WebVRFreeCamera(name, Vector3.Zero(), scene);
+    });
+
     /**
      * This is a copy of VRPose. See https://developer.mozilla.org/en-US/docs/Web/API/VRPose
      * IMPORTANT!! The data is right-hand data.

src/Cameras/babylon.arcRotateCamera.ts

@@ -1,4 +1,8 @@
 module BABYLON {
+    Node.AddNodeConstructor("ArcRotateCamera", (name, scene) => {
+        return () => new ArcRotateCamera(name, 0, 0, 1.0, Vector3.Zero(), scene);
+    });
+
     export class ArcRotateCamera extends TargetCamera {
         @serialize()
         public alpha: number;

src/Cameras/babylon.arcRotateCameraInputsManager.ts

@@ -19,11 +19,6 @@ module BABYLON {
             return this;
         }
 
-        public addGamepad(): ArcRotateCameraInputsManager {
-            this.add(new ArcRotateCameraGamepadInput());
-            return this;
-        }
-
         public addVRDeviceOrientation(): ArcRotateCameraInputsManager {
             this.add(new ArcRotateCameraVRDeviceOrientationInput());
             return this;

src/Cameras/babylon.camera.ts

@@ -909,50 +909,17 @@
         }
 
         static GetConstructorFromName(type: string, name: string, scene: Scene, interaxial_distance: number = 0, isStereoscopicSideBySide: boolean = true): () => Camera {
-            switch (type) {
-                case "ArcRotateCamera":
-                    return () => new ArcRotateCamera(name, 0, 0, 1.0, Vector3.Zero(), scene);
-                case "DeviceOrientationCamera":
-                    return () => new DeviceOrientationCamera(name, Vector3.Zero(), scene);
-                case "FollowCamera":
-                    return () => new FollowCamera(name, Vector3.Zero(), scene);
-                case "ArcFollowCamera":
-                    return () => new ArcFollowCamera(name, 0, 0, 1.0, null, scene);
-                case "GamepadCamera":
-                    return () => new GamepadCamera(name, Vector3.Zero(), scene);
-                case "TouchCamera":
-                    return () => new TouchCamera(name, Vector3.Zero(), scene);
-                case "VirtualJoysticksCamera":
-                    return () => new VirtualJoysticksCamera(name, Vector3.Zero(), scene);
-                case "WebVRFreeCamera":
-                    return () => new WebVRFreeCamera(name, Vector3.Zero(), scene);
-                case "WebVRGamepadCamera":
-                    return () => new WebVRFreeCamera(name, Vector3.Zero(), scene);
-                case "VRDeviceOrientationFreeCamera":
-                    return () => new VRDeviceOrientationFreeCamera(name, Vector3.Zero(), scene);
-                case "VRDeviceOrientationGamepadCamera":
-                    return () => new VRDeviceOrientationGamepadCamera(name, Vector3.Zero(), scene);
-                case "AnaglyphArcRotateCamera":
-                    return () => new AnaglyphArcRotateCamera(name, 0, 0, 1.0, Vector3.Zero(), interaxial_distance, scene);
-                case "AnaglyphFreeCamera":
-                    return () => new AnaglyphFreeCamera(name, Vector3.Zero(), interaxial_distance, scene);
-                case "AnaglyphGamepadCamera":
-                    return () => new AnaglyphGamepadCamera(name, Vector3.Zero(), interaxial_distance, scene);
-                case "AnaglyphUniversalCamera":
-                    return () => new AnaglyphUniversalCamera(name, Vector3.Zero(), interaxial_distance, scene);
-                case "StereoscopicArcRotateCamera":
-                    return () => new StereoscopicArcRotateCamera(name, 0, 0, 1.0, Vector3.Zero(), interaxial_distance, isStereoscopicSideBySide, scene);
-                case "StereoscopicFreeCamera":
-                    return () => new StereoscopicFreeCamera(name, Vector3.Zero(), interaxial_distance, isStereoscopicSideBySide, scene);
-                case "StereoscopicGamepadCamera":
-                    return () => new StereoscopicGamepadCamera(name, Vector3.Zero(), interaxial_distance, isStereoscopicSideBySide, scene);
-                case "StereoscopicUniversalCamera":
-                    return () => new StereoscopicUniversalCamera(name, Vector3.Zero(), interaxial_distance, isStereoscopicSideBySide, scene);
-                case "FreeCamera": // Forcing Universal here
-                    return () => new UniversalCamera(name, Vector3.Zero(), scene);
-                default: // Universal Camera is the default value
-                    return () => new UniversalCamera(name, Vector3.Zero(), scene);
+            let constructorFunc = Node.Construct(type, name, scene, {
+                interaxial_distance: interaxial_distance,
+                isStereoscopicSideBySide: isStereoscopicSideBySide
+            });
+
+            if (constructorFunc) {
+                return <() => Camera>constructorFunc;
             }
+
+            // Default to universal camera
+            return () => new UniversalCamera(name, Vector3.Zero(), scene);
         }
 
         public computeWorldMatrix(): Matrix {

src/Cameras/babylon.cameraInputsManager.ts

@@ -29,9 +29,8 @@ module BABYLON {
         }
 
         /**
-         * Add an input method to a camera.
-         * builtin inputs example: camera.inputs.addGamepad();
-         * custom inputs example: camera.inputs.add(new BABYLON.FreeCameraGamepadInput());
+         * Add an input method to a camera
+         * @see http://doc.babylonjs.com/how_to/customizing_camera_inputs
          * @param input camera input method
          */
         public add(input: ICameraInput<TCamera>) {

src/Cameras/babylon.deviceOrientationCamera.ts

@@ -1,4 +1,9 @@
 module BABYLON {
+
+    Node.AddNodeConstructor("DeviceOrientationCamera", (name, scene) => {
+        return () => new DeviceOrientationCamera(name, Vector3.Zero(), scene);
+    });
+
     // We're mainly based on the logic defined into the FreeCamera code
     /**
      * This is a camera specifically designed to react to device orientation events such as a modern mobile device

src/Cameras/babylon.followCamera.ts

@@ -1,4 +1,12 @@
 module BABYLON {
+    Node.AddNodeConstructor("FollowCamera", (name, scene) => {
+        return () => new FollowCamera(name, Vector3.Zero(), scene);
+    });
+
+    Node.AddNodeConstructor("ArcFollowCamera", (name, scene) => {
+        return () => new ArcFollowCamera(name, 0, 0, 1.0, null, scene);
+    });    
+
     export class FollowCamera extends TargetCamera {
         @serialize()
         public radius: number = 12;

src/Cameras/babylon.freeCamera.ts

@@ -1,4 +1,9 @@
 module BABYLON {
+    Node.AddNodeConstructor("FreeCamera", (name, scene) => {
+        // Forcing to use the Universal camera
+        return () => new UniversalCamera(name, Vector3.Zero(), scene);   
+    });
+
     export class FreeCamera extends TargetCamera {
         @serializeAsVector3()
         public ellipsoid = new Vector3(0.5, 1, 0.5);

src/Cameras/babylon.freeCameraInputsManager.ts

@@ -14,11 +14,6 @@ module BABYLON {
             return this;
         }
 
-        addGamepad(): FreeCameraInputsManager {
-            this.add(new FreeCameraGamepadInput());
-            return this;
-        }
-
         addDeviceOrientation(): FreeCameraInputsManager {
             this.add(new FreeCameraDeviceOrientationInput());
             return this;

src/Cameras/babylon.gamepadCamera.ts

@@ -1,4 +1,8 @@
 module BABYLON {
+    Node.AddNodeConstructor("GamepadCamera", (name, scene) => {
+        return () => new GamepadCamera(name, Vector3.Zero(), scene);
+    });
+
     // We're mainly based on the logic defined into the FreeCamera code
     export class GamepadCamera extends UniversalCamera {
         //-- Begin properties for backward compatibility for inputs

src/Cameras/babylon.stereoscopicCameras.ts

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

src/Cameras/babylon.touchCamera.ts

@@ -1,4 +1,8 @@
 module BABYLON {
+    Node.AddNodeConstructor("TouchCamera", (name, scene) => {
+        return () => new TouchCamera(name, Vector3.Zero(), scene);
+    });
+
     // We're mainly based on the logic defined into the FreeCamera code
     export class TouchCamera extends FreeCamera {
         //-- Begin properties for backward compatibility for inputs

src/Cameras/babylon.virtualJoysticksCamera.ts

@@ -1,4 +1,8 @@
 module BABYLON {
+    Node.AddNodeConstructor("VirtualJoysticksCamera", (name, scene) => {
+        return () => new VirtualJoysticksCamera(name, Vector3.Zero(), scene);
+    });
+
     // We're mainly based on the logic defined into the FreeCamera code
     export class VirtualJoysticksCamera extends FreeCamera {
         

src/Gamepad/babylon.gamepadSceneComponent.ts

@@ -0,0 +1,99 @@
+module BABYLON {
+    export interface Scene {
+        /** @hidden */
+        _gamepadManager: Nullable<GamepadManager>;
+
+        /**
+         * Gets the gamepad manager associated with the scene
+         * @see http://doc.babylonjs.com/how_to/how_to_use_gamepads
+         */
+        gamepadManager: GamepadManager;
+    }
+
+    Object.defineProperty(Scene.prototype, "gamepadManager", {
+        get: function (this:Scene) {
+            if (!this._gamepadManager) {
+                this._gamepadManager = new GamepadManager(this);
+            }
+
+            return this._gamepadManager;
+        },
+        enumerable: true,
+        configurable: true
+    });
+
+    export interface FreeCameraInputsManager {
+        addGamepad(): FreeCameraInputsManager;
+    }
+    
+    FreeCameraInputsManager.prototype.addGamepad = function(): FreeCameraInputsManager {
+        this.add(new FreeCameraGamepadInput());
+        return this;
+    }
+
+    export interface ArcRotateCameraInputsManager {
+        addGamepad(): ArcRotateCameraInputsManager;
+    }
+    
+    ArcRotateCameraInputsManager.prototype.addGamepad = function(): ArcRotateCameraInputsManager {
+        this.add(new ArcRotateCameraGamepadInput());
+        return this;
+    }  
+
+   /**
+     * Defines the gamepad scene component responsible to manage gamepads in a given scene
+     */
+    export class GamepadSystemSceneComponent implements ISceneComponent {
+        /**
+         * The component name helpfull to identify the component in the list of scene components.
+         */
+        public readonly name = SceneComponentConstants.NAME_GAMEPAD;
+
+        /**
+         * The scene the component belongs to.
+         */
+        public scene: Scene;
+
+        /**
+         * Creates a new instance of the component for the given scene
+         * @param scene Defines the scene to register the component in
+         */
+        constructor(scene: Scene) {
+            this.scene = scene;
+        }
+
+        /**
+         * Registers the component in a given scene
+         */
+        public register(): void {
+            this.scene._beforeCameraUpdateStage.registerStep(SceneComponentConstants.STEP_BEFORECAMERAUPDATE_GAMEPAD, this, this._beforeCameraUpdate);
+        }
+
+        /**
+         * Rebuilds the elements related to this component in case of
+         * context lost for instance.
+         */
+        public rebuild(): void {
+            // Nothing to do for gamepads
+        }
+
+        /**
+         * Disposes the component and the associated ressources
+         */
+        public dispose(): void {
+            let gamepadManager = this.scene._gamepadManager;
+            if (gamepadManager) {
+                gamepadManager.dispose();
+                this.scene._gamepadManager = null;
+            }
+        }
+
+        private _beforeCameraUpdate(): void {            
+            let gamepadManager = this.scene._gamepadManager;
+
+            if (gamepadManager && gamepadManager._isMonitoring) {
+                gamepadManager._checkGamepadsStatus();
+            }
+        }
+    }    
+}

src/Materials/babylon.effect.ts

@@ -533,7 +533,8 @@
             this._engine._loadFile(fragmentShaderUrl + ".fragment.fx", callback);
         }
 
-        private _dumpShadersSource(vertexCode: string, fragmentCode: string, defines: string): void {
+        /** @hidden */
+        public _dumpShadersSource(vertexCode: string, fragmentCode: string, defines: string): void {
             // Rebuild shaders source code
             var shaderVersion = (this._engine.webGLVersion > 1) ? "#version 300 es\n#define WEBGL2 \n" : "";
             var prefix = shaderVersion + (defines ? defines + "\n" : "");
@@ -818,7 +819,6 @@
                 Tools.Error("Attributes: " + attributesNames.map(function (attribute) {
                     return " " + attribute;
                 }));
-                this._dumpShadersSource(this._vertexSourceCode, this._fragmentSourceCode, defines);
                 Tools.Error("Error: " + this._compilationError);
                 if (previousProgram) {
                     this._program = previousProgram;

src/babylon.node.ts

@@ -1,9 +1,43 @@
 module BABYLON {
 
     /**
+     * Defines how a node can be built from a string name.
+     */
+    export type NodeConstructor = (name: string, scene: Scene, options?: any) => () => Node;
+
+    /**
      * Node is the basic class for all scene objects (Mesh, Light Camera).
      */
     export class Node implements IBehaviorAware<Node> {
+        private static _NodeConstructors: {[key: string]: any} = {};
+
+        /**
+         * Add a new node constructor
+         * @param type defines the type name of the node to construct
+         * @param constructorFunc defines the constructor function
+         */
+        public static AddNodeConstructor(type: string, constructorFunc: NodeConstructor) {
+            this._NodeConstructors[type] = constructorFunc;
+        }
+
+        /**
+         * Returns a node constructor based on type name
+         * @param type defines the type name
+         * @param name defines the new node name
+         * @param scene defines the hosting scene
+         * @param options defines optional options to transmit to constructors
+         * @returns the new constructor or null
+         */
+        public static Construct(type: string, name: string, scene: Scene, options?: any): Nullable<() => Node> {
+            let constructorFunc = this._NodeConstructors[type];
+
+            if (!constructorFunc) {
+                return null;
+            }
+
+            return constructorFunc(name, scene, options);
+        }
+
         /**
          * Gets or sets the name of the node
          */

src/babylon.scene.ts

@@ -567,21 +567,6 @@
         /** Deprecated. Use onPointerObservable instead */
         public onPointerPick: (evt: PointerEvent, pickInfo: PickingInfo) => void;
 
-        // Gamepads
-        private _gamepadManager: Nullable<GamepadManager>;
-
-        /**
-         * Gets the gamepad manager associated with the scene
-         * @see http://doc.babylonjs.com/how_to/how_to_use_gamepads
-         */
-        public get gamepadManager(): GamepadManager {
-            if (!this._gamepadManager) {
-                this._gamepadManager = new GamepadManager(this);
-            }
-
-            return this._gamepadManager;
-        }
-
         /**
          * This observable event is triggered when any ponter event is triggered. It is registered during Scene.attachControl() and it is called BEFORE the 3D engine process anything (mesh/sprite picking for instance).
          * You have the possibility to skip the process and the call to onPointerObservable by setting PointerInfoPre.skipOnPointerObservable to true
@@ -1195,6 +1180,11 @@
             return null;
         }
 
+
+        /**
+         * Defines the actions happening before camera updates.
+         */
+        public _beforeCameraUpdateStage = Stage.Create<SimpleStageAction>();
         /**
          * Defines the actions happening during the per mesh ready checks.
          */
@@ -4604,9 +4594,9 @@
                 }
             }
 
-            // update gamepad manager
-            if (this._gamepadManager && this._gamepadManager._isMonitoring) {
-                this._gamepadManager._checkGamepadsStatus();
+            // Before camera update steps
+            for (let step of this._beforeCameraUpdateStage) {
+                step.action();
             }
 
             // Update Cameras
@@ -5013,6 +5003,7 @@
             this._beforeRenderingGroupDrawStage.clear();
             this._afterRenderingGroupDrawStage.clear();
             this._afterCameraDrawStage.clear();
+            this._beforeCameraUpdateStage.clear();
             for (let component of this._components) {
                 component.dispose();
             }
@@ -5027,11 +5018,6 @@
                 this._depthRenderer[key].dispose();
             }
 
-            if (this._gamepadManager) {
-                this._gamepadManager.dispose();
-                this._gamepadManager = null;
-            }
-
             // Smart arrays
             if (this.activeCamera) {
                 this.activeCamera._activeMeshes.dispose();

src/babylon.sceneComponent.ts

@@ -9,6 +9,7 @@
         public static readonly NAME_LENSFLARESYSTEM = "LensFlareSystem";
         public static readonly NAME_BOUNDINGBOXRENDERER = "BoundingBoxRenderer";
         public static readonly NAME_PARTICLESYSTEM = "ParticleSystem";
+        public static readonly NAME_GAMEPAD = "Gamepad";
 
         public static readonly STEP_ISREADYFORMESH_EFFECTLAYER = 0;
 
@@ -25,6 +26,8 @@
 
         public static readonly STEP_AFTERRENDERINGGROUPDRAW_EFFECTLAYER_DRAW = 0;
 
+        public static readonly STEP_BEFORECAMERAUPDATE_GAMEPAD = 0;
+
         public static readonly STEP_AFTERCAMERADRAW_EFFECTLAYER = 0;
         public static readonly STEP_AFTERCAMERADRAW_LENSFLARESYSTEM = 1;
         public static readonly STEP_AFTERCAMERADRAW_BOUNDINGBOXRENDERER = 2;