Disconnected gamepads are not removed. Just disabled

src/Cameras/VR/babylon.webVRCamera.ts

@@ -386,39 +386,41 @@ module BABYLON {
             this._onGamepadDisconnectedObserver = manager.onGamepadDisconnectedObservable.add((gamepad) => {
                 if (gamepad.type === BABYLON.Gamepad.POSE_ENABLED) {
                     let webVrController: WebVRController = <WebVRController>gamepad;
-                    let index = this.controllers.indexOf(webVrController);
-
-                    if (index === -1) {
-                        // we are good
-                        return;
+                    
+                    if (webVrController.defaultModel) {
+                        webVrController.defaultModel.setEnabled(false);
                     }
-
-                    this.controllers.splice(index, 1);
                 }
             });
 
             this._onGamepadConnectedObserver = manager.onGamepadConnectedObservable.add((gamepad) => {
                 if (gamepad.type === BABYLON.Gamepad.POSE_ENABLED) {
                     let webVrController: WebVRController = <WebVRController>gamepad;
+                    
                     if (this.webVROptions.controllerMeshes) {
-                        webVrController.initControllerMesh(this.getScene(), (loadedMesh) => {
-                            if (this.webVROptions.defaultLightingOnControllers) {
-                                if (!this._lightOnControllers) {
-                                    this._lightOnControllers = new BABYLON.HemisphericLight("vrControllersLight", new BABYLON.Vector3(0, 1, 0), this.getScene());
-                                }
-                                let activateLightOnSubMeshes = function(mesh: AbstractMesh, light: HemisphericLight) {
-                                    let children = mesh.getChildren();
-                                    if (children.length !== 0) {
-                                        children.forEach((mesh) => {
-                                            light.includedOnlyMeshes.push(<AbstractMesh>mesh);
-                                            activateLightOnSubMeshes(<AbstractMesh>mesh, light);
-                                        });
+                        if (webVrController.defaultModel) {
+                            webVrController.defaultModel.setEnabled(true);
+                        } else {
+                            // Load the meshes
+                            webVrController.initControllerMesh(this.getScene(), (loadedMesh) => {
+                                if (this.webVROptions.defaultLightingOnControllers) {
+                                    if (!this._lightOnControllers) {
+                                        this._lightOnControllers = new BABYLON.HemisphericLight("vrControllersLight", new BABYLON.Vector3(0, 1, 0), this.getScene());
                                     }
+                                    let activateLightOnSubMeshes = function(mesh: AbstractMesh, light: HemisphericLight) {
+                                        let children = mesh.getChildren();
+                                        if (children.length !== 0) {
+                                            children.forEach((mesh) => {
+                                                light.includedOnlyMeshes.push(<AbstractMesh>mesh);
+                                                activateLightOnSubMeshes(<AbstractMesh>mesh, light);
+                                            });
+                                        }
+                                    }
+                                    this._lightOnControllers.includedOnlyMeshes.push(loadedMesh);
+                                    activateLightOnSubMeshes(loadedMesh, this._lightOnControllers);
                                 }
-                                this._lightOnControllers.includedOnlyMeshes.push(loadedMesh);
-                                activateLightOnSubMeshes(loadedMesh, this._lightOnControllers);
-                            }
-                        });
+                            });
+                        }
                     }
                     webVrController.attachToPoseControlledCamera(this);
 

src/Gamepad/Controllers/babylon.genericController.ts

@@ -1,8 +1,6 @@
 module BABYLON {
     
     export class GenericController extends WebVRController {
-        private _defaultModel: BABYLON.AbstractMesh;
-
         constructor(vrGamepad) {
             super(vrGamepad);
         }

src/Gamepad/Controllers/babylon.oculusTouchController.ts

@@ -1,8 +1,6 @@
 module BABYLON {
 
     export class OculusTouchController extends WebVRController {
-        private _defaultModel: BABYLON.AbstractMesh;
-
         public onSecondaryTriggerStateChangedObservable = new Observable<ExtendedGamepadButton>();
 
         public onThumbRestChangedObservable = new Observable<ExtendedGamepadButton>();

src/Gamepad/Controllers/babylon.poseEnabledController.ts

@@ -58,7 +58,7 @@ module BABYLON {
         private _poseControlledCamera: TargetCamera;
 
         private _leftHandSystemQuaternion: Quaternion = new Quaternion();
-
+        
         constructor(public vrGamepad) {
             super(vrGamepad.id, vrGamepad.index, vrGamepad);
             this.type = Gamepad.POSE_ENABLED;

src/Gamepad/Controllers/babylon.viveController.ts

@@ -1,7 +1,6 @@
 module BABYLON {
 
     export class ViveController extends WebVRController {
-        private _defaultModel: BABYLON.AbstractMesh;
 
         constructor(vrGamepad) {
             super(vrGamepad);

src/Gamepad/Controllers/babylon.webVRController.ts

@@ -2,6 +2,8 @@ module BABYLON {
 
     export abstract class WebVRController extends PoseEnabledController {
 
+        protected _defaultModel: AbstractMesh;
+
         public onTriggerStateChangedObservable = new Observable<ExtendedGamepadButton>();
 
         public onMainButtonStateChangedObservable = new Observable<ExtendedGamepadButton>();
@@ -23,6 +25,10 @@ module BABYLON {
 
         public hand: string; // 'left' or 'right', see https://w3c.github.io/gamepad/extensions.html#gamepadhand-enum
 
+        public get defaultModel(): AbstractMesh {
+            return this._defaultModel;
+        }
+
         constructor(vrGamepad) {
             super(vrGamepad);
             this._buttons = new Array<ExtendedGamepadButton>(vrGamepad.buttons.length);

src/Gamepad/babylon.gamepad.ts

@@ -18,6 +18,8 @@
         private _leftStick: StickValues;
         private _rightStick: StickValues;
 
+        public _isConnected = true;
+
         private _leftStickAxisX: number;
         private _leftStickAxisY: number;
         private _rightStickAxisX: number;
@@ -31,6 +33,10 @@
         public static XBOX = 2;
         public static POSE_ENABLED = 3;
 
+        public get isConnected(): boolean {
+            return this._isConnected;
+        }
+
         constructor(public id: string, public index: number, public browserGamepad, leftStickX: number = 0, leftStickY: number = 1, rightStickX: number = 2, rightStickY: number = 3) {
             this.type = Gamepad.GAMEPAD;
             this._leftStickAxisX = leftStickX;

src/Gamepad/babylon.gamepadManager.ts

@@ -18,13 +18,20 @@
             this._onGamepadConnectedEvent = (evt) => {
                 let gamepad = evt.gamepad;
 
-                // Protection code for Chrome which has a very buggy gamepad implementation...
-                // And raises a connected event on disconnection for instance
                 if (gamepad.index in this._babylonGamepads) {
-                    return;
+                    if (this._babylonGamepads[gamepad.index].isConnected) {
+                        return;
+                    }
                 }
 
-                var newGamepad = this._addNewGamepad(gamepad);
+                let newGamepad: Gamepad;
+
+                if (this._babylonGamepads[gamepad.index]) {
+                    newGamepad = this._babylonGamepads[gamepad.index];
+                    newGamepad._isConnected = true;
+                } else {
+                    newGamepad = this._addNewGamepad(gamepad);
+                }
                 this.onGamepadConnectedObservable.notifyObservers(newGamepad);
                 this._startMonitoringGamepads();                
             };
@@ -35,12 +42,10 @@
                 // Remove the gamepad from the list of gamepads to monitor.
                 for (var i in this._babylonGamepads) {
                     if (this._babylonGamepads[i].index === gamepad.index) {
-                        let gamepadToRemove = this._babylonGamepads[i];
-                        this._babylonGamepads[i] = null;
+                        let disconnectedGamepad = this._babylonGamepads[i];
+                        disconnectedGamepad._isConnected = false;
                         
-                        this.onGamepadDisconnectedObservable.notifyObservers(gamepadToRemove);
-
-                        gamepadToRemove.dispose();
+                        this.onGamepadDisconnectedObservable.notifyObservers(disconnectedGamepad);
                         break;
                     }
                 }            
@@ -84,6 +89,11 @@
                 this._onGamepadConnectedEvent = null;
                 this._onGamepadDisconnectedEvent = null;
             }
+
+            for (let gamepad of this._babylonGamepads) {
+                gamepad.dispose();
+            }
+
             this._oneGamepadConnected = false;
             this._stopMonitoringGamepads();
             this._babylonGamepads = [];
@@ -151,6 +161,11 @@
                     else {
                         // Forced to copy again this object for Chrome for unknown reason
                         this._babylonGamepads[i].browserGamepad = gamepads[i];
+
+                        if (!this._babylonGamepads[i].isConnected) {
+                            this._babylonGamepads[i]._isConnected = true;                            
+                            this.onGamepadConnectedObservable.notifyObservers(this._babylonGamepads[i]);
+                        }
                     }
                 }
             }