@babylonjs/core 5.0.0-beta.3 → 5.0.0-beta.7

package/DeviceInput/{Implementations → InputDevices}/webDeviceInputSystem.js

@@ -1,9 +1,12 @@
+import { DomManagement } from "../../Misc/domManagement.js";
 import { Tools } from "../../Misc/tools.js";
 import { DeviceEventFactory } from "../Helpers/eventFactory.js";
-import { DeviceType, PointerInput } from "../InputDevices/deviceEnums.js";
+import { DeviceType, PointerInput } from "./deviceEnums.js";
+var MAX_KEYCODES = 255;
+var MAX_POINTER_INPUTS = Object.keys(PointerInput).length / 2;
 /** @hidden */
-var WebDeviceInputSystemImpl = /** @class */ (function () {
-    function WebDeviceInputSystemImpl(engine) {
+var WebDeviceInputSystem = /** @class */ (function () {
+    function WebDeviceInputSystem(engine) {
         // Private Members
         this._inputs = [];
         this._keyboardActive = false;
@@ -18,10 +21,8 @@ var WebDeviceInputSystemImpl = /** @class */ (function () {
         this._pointerWheelEvent = function (evt) { };
         this._pointerBlurEvent = function (evt) { };
         this._mouseId = -1;
-        this._isUsingFirefox = navigator && navigator.userAgent && navigator.userAgent.indexOf("Firefox") !== -1;
-        // Array to store active Pointer ID values; prevents issues with negative pointerIds
-        this._activeTouchIds = [];
-        this._rollingTouchId = 0; // Rolling ID number to assign; emulates Chrome assignment
+        this._isUsingFirefox = DomManagement.IsNavigatorAvailable() && navigator.userAgent && navigator.userAgent.indexOf("Firefox") !== -1;
+        this._maxTouchPoints = 0;
         this._pointerInputClearObserver = null;
         this._gamepadConnectedEvent = function (evt) { };
         this._gamepadDisconnectedEvent = function (evt) { };
@@ -30,9 +31,9 @@ var WebDeviceInputSystemImpl = /** @class */ (function () {
         this.onDeviceConnected = function (deviceType, deviceSlot) { };
         this.onDeviceDisconnected = function (deviceType, deviceSlot) { };
         this.onInputChanged = function (deviceEvent) { };
-        this.configureEvents();
+        this._configureEvents();
     }
-    Object.defineProperty(WebDeviceInputSystemImpl.prototype, "onDeviceConnected", {
+    Object.defineProperty(WebDeviceInputSystem.prototype, "onDeviceConnected", {
         get: function () {
             return this._onDeviceConnected;
         },
@@ -55,26 +56,6 @@ var WebDeviceInputSystemImpl = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
-    /**
-     * Configures events to work with an engine's active element
-     */
-    WebDeviceInputSystemImpl.prototype.configureEvents = function () {
-        var inputElement = this._engine.getInputElement();
-        if (inputElement && this._elementToAttachTo !== inputElement) {
-            // If the engine's input element has changed, unregister events from previous element
-            if (this._elementToAttachTo) {
-                this._removeEvents();
-            }
-            this._elementToAttachTo = inputElement;
-            // Set tab index for the inputElement to the engine's canvasTabIndex, if and only if the element's tab index is -1
-            this._elementToAttachTo.tabIndex = (this._elementToAttachTo.tabIndex !== -1) ? this._elementToAttachTo.tabIndex : this._engine.canvasTabIndex;
-            this._handleKeyActions();
-            this._handlePointerActions();
-            this._handleGamepadActions();
-            // Check for devices that are already connected but aren't registered. Currently, only checks for gamepads and mouse
-            this._checkForConnectedDevices();
-        }
-    };
     // Public functions
     /**
      * Checks for current device input value, given an id and input index. Throws exception if requested device not initialized.
@@ -83,17 +64,17 @@ var WebDeviceInputSystemImpl = /** @class */ (function () {
      * @param inputIndex Id of input to be checked
      * @returns Current value of input
      */
-    WebDeviceInputSystemImpl.prototype.pollInput = function (deviceType, deviceSlot, inputIndex) {
+    WebDeviceInputSystem.prototype.pollInput = function (deviceType, deviceSlot, inputIndex) {
         var device = this._inputs[deviceType][deviceSlot];
         if (!device) {
-            throw "Unable to find device " + DeviceType[deviceType];
+            throw "Unable to find device ".concat(DeviceType[deviceType]);
         }
-        if (deviceType >= DeviceType.Xbox && deviceType <= DeviceType.Switch && navigator.getGamepads) {
+        if (deviceType >= DeviceType.DualShock && deviceType <= DeviceType.DualSense && navigator.getGamepads) {
             this._updateDevice(deviceType, deviceSlot, inputIndex);
         }
         var currentValue = device[inputIndex];
         if (currentValue === undefined) {
-            throw "Unable to find input " + inputIndex + " for device " + DeviceType[deviceType] + " in slot " + deviceSlot;
+            throw "Unable to find input ".concat(inputIndex, " for device ").concat(DeviceType[deviceType], " in slot ").concat(deviceSlot);
         }
         return currentValue;
     };
@@ -102,13 +83,13 @@ var WebDeviceInputSystemImpl = /** @class */ (function () {
      * @param deviceType Type of device to check for
      * @returns bool with status of device's existence
      */
-    WebDeviceInputSystemImpl.prototype.isDeviceAvailable = function (deviceType) {
+    WebDeviceInputSystem.prototype.isDeviceAvailable = function (deviceType) {
         return (this._inputs[deviceType] !== undefined);
     };
     /**
      * Dispose of all the eventlisteners
      */
-    WebDeviceInputSystemImpl.prototype.dispose = function () {
+    WebDeviceInputSystem.prototype.dispose = function () {
         // Observables
         this.onDeviceConnected = function () { };
         this.onDeviceDisconnected = function () { };
@@ -120,11 +101,31 @@ var WebDeviceInputSystemImpl = /** @class */ (function () {
             window.removeEventListener("gamepaddisconnected", this._gamepadDisconnectedEvent);
         }
     };
+    /**
+     * Configures events to work with an engine's active element
+     */
+    WebDeviceInputSystem.prototype._configureEvents = function () {
+        var inputElement = this._engine.getInputElement();
+        if (inputElement && this._elementToAttachTo !== inputElement) {
+            // If the engine's input element has changed, unregister events from previous element
+            if (this._elementToAttachTo) {
+                this._removeEvents();
+            }
+            this._elementToAttachTo = inputElement;
+            // Set tab index for the inputElement to the engine's canvasTabIndex, if and only if the element's tab index is -1
+            this._elementToAttachTo.tabIndex = (this._elementToAttachTo.tabIndex !== -1) ? this._elementToAttachTo.tabIndex : this._engine.canvasTabIndex;
+            this._handleKeyActions();
+            this._handlePointerActions();
+            this._handleGamepadActions();
+            // Check for devices that are already connected but aren't registered. Currently, only checks for gamepads and mouse
+            this._checkForConnectedDevices();
+        }
+    };
     /**
      * Checks for existing connections to devices and register them, if necessary
      * Currently handles gamepads and mouse
      */
-    WebDeviceInputSystemImpl.prototype._checkForConnectedDevices = function () {
+    WebDeviceInputSystem.prototype._checkForConnectedDevices = function () {
         if (navigator.getGamepads) {
             var gamepads = navigator.getGamepads();
             for (var _i = 0, gamepads_1 = gamepads; _i < gamepads_1.length; _i++) {
@@ -146,11 +147,11 @@ var WebDeviceInputSystemImpl = /** @class */ (function () {
      * Add a gamepad to the DeviceInputSystem
      * @param gamepad A single DOM Gamepad object
      */
-    WebDeviceInputSystemImpl.prototype._addGamePad = function (gamepad) {
+    WebDeviceInputSystem.prototype._addGamePad = function (gamepad) {
         var deviceType = this._getGamepadDeviceType(gamepad.id);
         var deviceSlot = gamepad.index;
-        this._registerDevice(deviceType, deviceSlot, gamepad.buttons.length + gamepad.axes.length);
         this._gamepads = this._gamepads || new Array(gamepad.index + 1);
+        this._registerDevice(deviceType, deviceSlot, gamepad.buttons.length + gamepad.axes.length);
         this._gamepads[deviceSlot] = deviceType;
     };
     /**
@@ -160,9 +161,11 @@ var WebDeviceInputSystemImpl = /** @class */ (function () {
      * @param currentX Current X at point of adding
      * @param currentY Current Y at point of adding
      */
-    WebDeviceInputSystemImpl.prototype._addPointerDevice = function (deviceType, deviceSlot, currentX, currentY) {
-        this._pointerActive = true;
-        this._registerDevice(deviceType, deviceSlot, WebDeviceInputSystemImpl.MAX_POINTER_INPUTS);
+    WebDeviceInputSystem.prototype._addPointerDevice = function (deviceType, deviceSlot, currentX, currentY) {
+        if (!this._pointerActive) {
+            this._pointerActive = true;
+        }
+        this._registerDevice(deviceType, deviceSlot, MAX_POINTER_INPUTS);
         var pointer = this._inputs[deviceType][deviceSlot]; /* initialize our pointer position immediately after registration */
         pointer[0] = currentX;
         pointer[1] = currentY;
@@ -173,9 +176,9 @@ var WebDeviceInputSystemImpl = /** @class */ (function () {
      * @param deviceSlot "Slot" or index that device is referenced in
      * @param numberOfInputs Number of input entries to create for given device
      */
-    WebDeviceInputSystemImpl.prototype._registerDevice = function (deviceType, deviceSlot, numberOfInputs) {
+    WebDeviceInputSystem.prototype._registerDevice = function (deviceType, deviceSlot, numberOfInputs) {
         if (deviceSlot === undefined) {
-            throw "Unable to register device " + DeviceType[deviceType] + " to undefined slot.";
+            throw "Unable to register device ".concat(DeviceType[deviceType], " to undefined slot.");
         }
         if (!this._inputs[deviceType]) {
             this._inputs[deviceType] = {};
@@ -194,7 +197,7 @@ var WebDeviceInputSystemImpl = /** @class */ (function () {
      * @param deviceType Enum specifiying device type
      * @param deviceSlot "Slot" or index that device is referenced in
      */
-    WebDeviceInputSystemImpl.prototype._unregisterDevice = function (deviceType, deviceSlot) {
+    WebDeviceInputSystem.prototype._unregisterDevice = function (deviceType, deviceSlot) {
         if (this._inputs[deviceType][deviceSlot]) {
             delete this._inputs[deviceType][deviceSlot];
             this.onDeviceDisconnected(deviceType, deviceSlot);
@@ -203,12 +206,12 @@ var WebDeviceInputSystemImpl = /** @class */ (function () {
     /**
      * Handle all actions that come from keyboard interaction
      */
-    WebDeviceInputSystemImpl.prototype._handleKeyActions = function () {
+    WebDeviceInputSystem.prototype._handleKeyActions = function () {
         var _this = this;
         this._keyboardDownEvent = (function (evt) {
             if (!_this._keyboardActive) {
                 _this._keyboardActive = true;
-                _this._registerDevice(DeviceType.Keyboard, 0, WebDeviceInputSystemImpl.MAX_KEYCODES);
+                _this._registerDevice(DeviceType.Keyboard, 0, MAX_KEYCODES);
             }
             var kbKey = _this._inputs[DeviceType.Keyboard][0];
             if (kbKey) {
@@ -225,7 +228,7 @@ var WebDeviceInputSystemImpl = /** @class */ (function () {
         this._keyboardUpEvent = (function (evt) {
             if (!_this._keyboardActive) {
                 _this._keyboardActive = true;
-                _this._registerDevice(DeviceType.Keyboard, 0, WebDeviceInputSystemImpl.MAX_KEYCODES);
+                _this._registerDevice(DeviceType.Keyboard, 0, MAX_KEYCODES);
             }
             var kbKey = _this._inputs[DeviceType.Keyboard][0];
             if (kbKey) {
@@ -264,8 +267,15 @@ var WebDeviceInputSystemImpl = /** @class */ (function () {
     /**
      * Handle all actions that come from pointer interaction
      */
-    WebDeviceInputSystemImpl.prototype._handlePointerActions = function () {
+    WebDeviceInputSystem.prototype._handlePointerActions = function () {
         var _this = this;
+        this._maxTouchPoints = (DomManagement.IsNavigatorAvailable() && navigator.maxTouchPoints) || 0;
+        if (!this._activeTouchIds) {
+            this._activeTouchIds = new Array(this._maxTouchPoints);
+        }
+        for (var i = 0; i < this._maxTouchPoints; i++) {
+            this._activeTouchIds[i] = -1;
+        }
         this._pointerMoveEvent = (function (evt) {
             var deviceType = _this._getPointerType(evt);
             var deviceSlot = (deviceType === DeviceType.Mouse) ? 0 : _this._activeTouchIds.indexOf(evt.pointerId);
@@ -277,11 +287,6 @@ var WebDeviceInputSystemImpl = /** @class */ (function () {
             }
             var pointer = _this._inputs[deviceType][deviceSlot];
             if (pointer) {
-                // Store previous values for event
-                var previousHorizontal = pointer[PointerInput.Horizontal];
-                var previousVertical = pointer[PointerInput.Vertical];
-                var previousDeltaHorizontal = pointer[PointerInput.DeltaHorizontal];
-                var previousDeltaVertical = pointer[PointerInput.DeltaVertical];
                 pointer[PointerInput.Horizontal] = evt.clientX;
                 pointer[PointerInput.Vertical] = evt.clientY;
                 pointer[PointerInput.DeltaHorizontal] = evt.movementX;
@@ -289,33 +294,8 @@ var WebDeviceInputSystemImpl = /** @class */ (function () {
                 var deviceEvent = evt;
                 deviceEvent.deviceType = deviceType;
                 deviceEvent.deviceSlot = deviceSlot;
-                // The browser might use a move event in case
-                // of simultaneous mouse buttons click for instance. So
-                // in this case we stil need to propagate it.
-                if (previousHorizontal !== evt.clientX) {
-                    deviceEvent.inputIndex = PointerInput.Horizontal;
-                    deviceEvent.previousState = previousHorizontal;
-                    deviceEvent.currentState = pointer[PointerInput.Horizontal];
-                    _this.onInputChanged(deviceEvent);
-                }
-                if (previousVertical !== evt.clientY) {
-                    deviceEvent.inputIndex = PointerInput.Vertical;
-                    deviceEvent.previousState = previousVertical;
-                    deviceEvent.currentState = pointer[PointerInput.Vertical];
-                    _this.onInputChanged(deviceEvent);
-                }
-                if (pointer[PointerInput.DeltaHorizontal] !== 0) {
-                    deviceEvent.inputIndex = PointerInput.DeltaHorizontal;
-                    deviceEvent.previousState = previousDeltaHorizontal;
-                    deviceEvent.currentState = pointer[PointerInput.DeltaHorizontal];
-                    _this.onInputChanged(deviceEvent);
-                }
-                if (pointer[PointerInput.DeltaVertical] !== 0) {
-                    deviceEvent.inputIndex = PointerInput.DeltaVertical;
-                    deviceEvent.previousState = previousDeltaVertical;
-                    deviceEvent.currentState = pointer[PointerInput.DeltaVertical];
-                    _this.onInputChanged(deviceEvent);
-                }
+                deviceEvent.inputIndex = PointerInput.Move;
+                _this.onInputChanged(deviceEvent);
                 // Lets Propagate the event for move with same position.
                 if (!_this._usingSafari && evt.button !== -1) {
                     deviceEvent.inputIndex = evt.button + 2;
@@ -330,8 +310,16 @@ var WebDeviceInputSystemImpl = /** @class */ (function () {
             var deviceType = _this._getPointerType(evt);
             var deviceSlot = (deviceType === DeviceType.Mouse) ? 0 : evt.pointerId;
             if (deviceType === DeviceType.Touch) {
-                deviceSlot = _this._rollingTouchId++;
-                _this._activeTouchIds[deviceSlot] = evt.pointerId;
+                var idx = _this._activeTouchIds.indexOf(-1);
+                if (idx >= 0) {
+                    deviceSlot = idx;
+                    _this._activeTouchIds[idx] = evt.pointerId;
+                }
+                else {
+                    // We can't find an open slot to store new pointer so just return (can only support max number of touches)
+                    Tools.Warn("Max number of touches exceeded.  Ignoring touches in excess of ".concat(_this._maxTouchPoints));
+                    return;
+                }
             }
             if (!_this._inputs[deviceType]) {
                 _this._inputs[deviceType] = {};
@@ -339,6 +327,9 @@ var WebDeviceInputSystemImpl = /** @class */ (function () {
             if (!_this._inputs[deviceType][deviceSlot]) {
                 _this._addPointerDevice(deviceType, deviceSlot, evt.clientX, evt.clientY);
             }
+            else if (deviceType === DeviceType.Touch) {
+                _this.onDeviceConnected(deviceType, deviceSlot);
+            }
             var pointer = _this._inputs[deviceType][deviceSlot];
             if (pointer) {
                 var previousHorizontal = pointer[PointerInput.Horizontal];
@@ -378,28 +369,31 @@ var WebDeviceInputSystemImpl = /** @class */ (function () {
                 var deviceEvent = evt;
                 deviceEvent.deviceType = deviceType;
                 deviceEvent.deviceSlot = deviceSlot;
-                if (previousHorizontal !== evt.clientX) {
-                    deviceEvent.inputIndex = PointerInput.Horizontal;
-                    deviceEvent.previousState = previousHorizontal;
-                    deviceEvent.currentState = pointer[PointerInput.Horizontal];
-                    _this.onInputChanged(deviceEvent);
-                }
-                if (previousVertical !== evt.clientY) {
-                    deviceEvent.inputIndex = PointerInput.Vertical;
-                    deviceEvent.previousState = previousVertical;
-                    deviceEvent.currentState = pointer[PointerInput.Vertical];
-                    _this.onInputChanged(deviceEvent);
-                }
+                // NOTE: The +2 used here to is because PointerInput has the same value progression for its mouse buttons as PointerEvent.button
+                // However, we have our X and Y values front-loaded to group together the touch inputs but not break this progression
+                // EG. ([X, Y, Left-click], Middle-click, etc...)
                 deviceEvent.inputIndex = evt.button + 2;
                 deviceEvent.previousState = previousButton;
-                deviceEvent.currentState = pointer[evt.button + 2];
+                deviceEvent.currentState = pointer[deviceEvent.inputIndex];
                 _this.onInputChanged(deviceEvent);
+                if (previousHorizontal !== evt.clientX || previousVertical !== evt.clientY) {
+                    deviceEvent.inputIndex = PointerInput.Move;
+                    _this.onInputChanged(deviceEvent);
+                }
             }
         });
         this._pointerUpEvent = (function (evt) {
             var _a, _b, _c, _d, _e;
             var deviceType = _this._getPointerType(evt);
             var deviceSlot = (deviceType === DeviceType.Mouse) ? 0 : _this._activeTouchIds.indexOf(evt.pointerId);
+            if (deviceType === DeviceType.Touch) {
+                if (deviceSlot === -1) {
+                    return;
+                }
+                else {
+                    _this._activeTouchIds[deviceSlot] = -1;
+                }
+            }
             var pointer = (_a = _this._inputs[deviceType]) === null || _a === void 0 ? void 0 : _a[deviceSlot];
             if (pointer && pointer[evt.button + 2] !== 0) {
                 var previousHorizontal = pointer[PointerInput.Horizontal];
@@ -411,21 +405,16 @@ var WebDeviceInputSystemImpl = /** @class */ (function () {
                 var deviceEvent = evt;
                 deviceEvent.deviceType = deviceType;
                 deviceEvent.deviceSlot = deviceSlot;
-                if (previousHorizontal !== evt.clientX) {
-                    deviceEvent.inputIndex = PointerInput.Horizontal;
-                    deviceEvent.previousState = previousHorizontal;
-                    deviceEvent.currentState = pointer[PointerInput.Horizontal];
-                    _this.onInputChanged(deviceEvent);
-                }
-                if (previousVertical !== evt.clientY) {
-                    deviceEvent.inputIndex = PointerInput.Vertical;
-                    deviceEvent.previousState = previousVertical;
-                    deviceEvent.currentState = pointer[PointerInput.Vertical];
+                if (previousHorizontal !== evt.clientX || previousVertical !== evt.clientY) {
+                    deviceEvent.inputIndex = PointerInput.Move;
                     _this.onInputChanged(deviceEvent);
                 }
+                // NOTE: The +2 used here to is because PointerInput has the same value progression for its mouse buttons as PointerEvent.button
+                // However, we have our X and Y values front-loaded to group together the touch inputs but not break this progression
+                // EG. ([X, Y, Left-click], Middle-click, etc...)
                 deviceEvent.inputIndex = evt.button + 2;
                 deviceEvent.previousState = previousButton;
-                deviceEvent.currentState = pointer[evt.button + 2];
+                deviceEvent.currentState = pointer[deviceEvent.inputIndex];
                 if (deviceType === DeviceType.Mouse && _this._mouseId >= 0 && ((_c = (_b = _this._elementToAttachTo).hasPointerCapture) === null || _c === void 0 ? void 0 : _c.call(_b, _this._mouseId))) {
                     _this._elementToAttachTo.releasePointerCapture(_this._mouseId);
                 }
@@ -433,11 +422,8 @@ var WebDeviceInputSystemImpl = /** @class */ (function () {
                     _this._elementToAttachTo.releasePointerCapture(evt.pointerId);
                 }
                 _this.onInputChanged(deviceEvent);
-                // We don't want to unregister the mouse because we may miss input data when a mouse is moving after a click
-                if (deviceType !== DeviceType.Mouse) {
-                    var idToRemove = _this._activeTouchIds.indexOf(evt.pointerId);
-                    delete _this._activeTouchIds[idToRemove];
-                    _this._unregisterDevice(deviceType, deviceSlot);
+                if (deviceType === DeviceType.Touch) {
+                    _this.onDeviceDisconnected(deviceType, deviceSlot);
                 }
             }
         });
@@ -490,28 +476,25 @@ var WebDeviceInputSystemImpl = /** @class */ (function () {
             // Handle Active Touches
             if (_this.isDeviceAvailable(DeviceType.Touch)) {
                 var pointer = _this._inputs[DeviceType.Touch];
-                // Get list of active touch ids and clear each one in the inputs array
-                for (var deviceSlotKey in Object.keys(_this._activeTouchIds)) {
-                    var deviceSlot = +deviceSlotKey;
+                for (var deviceSlot = 0; deviceSlot < _this._activeTouchIds.length; deviceSlot++) {
                     var pointerId = _this._activeTouchIds[deviceSlot];
                     if ((_d = (_c = _this._elementToAttachTo).hasPointerCapture) === null || _d === void 0 ? void 0 : _d.call(_c, pointerId)) {
                         _this._elementToAttachTo.releasePointerCapture(pointerId);
                     }
-                    if (((_e = pointer[deviceSlot]) === null || _e === void 0 ? void 0 : _e[PointerInput.LeftClick]) === 1) {
+                    if (pointerId !== -1 && ((_e = pointer[deviceSlot]) === null || _e === void 0 ? void 0 : _e[PointerInput.LeftClick]) === 1) {
                         pointer[deviceSlot][PointerInput.LeftClick] = 0;
-                        var evt_3 = DeviceEventFactory.CreateDeviceEvent(DeviceType.Touch, pointerId, PointerInput.LeftClick, 1, _this, _this._elementToAttachTo);
+                        var evt_3 = DeviceEventFactory.CreateDeviceEvent(DeviceType.Touch, deviceSlot, PointerInput.LeftClick, 1, _this, _this._elementToAttachTo);
                         var deviceEvent = evt_3;
-                        deviceEvent.deviceType = DeviceType.Mouse;
+                        deviceEvent.deviceType = DeviceType.Touch;
                         deviceEvent.deviceSlot = deviceSlot;
                         deviceEvent.inputIndex = PointerInput.LeftClick;
                         deviceEvent.currentState = pointer[deviceSlot][PointerInput.LeftClick];
                         deviceEvent.previousState = 1;
                         _this.onInputChanged(deviceEvent);
-                        _this._unregisterDevice(DeviceType.Touch, deviceSlot);
+                        _this._activeTouchIds[deviceSlot] = -1;
+                        _this.onDeviceDisconnected(DeviceType.Touch, deviceSlot);
                     }
                 }
-                // Clear all active touches
-                while (_this._activeTouchIds.pop() !== undefined) { }
             }
         });
         this._pointerWheelEvent = (function (evt) {
@@ -522,7 +505,7 @@ var WebDeviceInputSystemImpl = /** @class */ (function () {
             }
             if (!_this._inputs[deviceType][deviceSlot]) {
                 _this._pointerActive = true;
-                _this._registerDevice(deviceType, deviceSlot, WebDeviceInputSystemImpl.MAX_POINTER_INPUTS);
+                _this._registerDevice(deviceType, deviceSlot, MAX_POINTER_INPUTS);
             }
             var pointer = _this._inputs[deviceType][deviceSlot];
             if (pointer) {
@@ -576,7 +559,7 @@ var WebDeviceInputSystemImpl = /** @class */ (function () {
     /**
      * Handle all actions that come from gamepad interaction
      */
-    WebDeviceInputSystemImpl.prototype._handleGamepadActions = function () {
+    WebDeviceInputSystem.prototype._handleGamepadActions = function () {
         var _this = this;
         this._gamepadConnectedEvent = (function (evt) {
             _this._addGamePad(evt.gamepad);
@@ -598,7 +581,7 @@ var WebDeviceInputSystemImpl = /** @class */ (function () {
      * @param deviceSlot "Slot" or index that device is referenced in
      * @param inputIndex Id of input to be checked
      */
-    WebDeviceInputSystemImpl.prototype._updateDevice = function (deviceType, deviceSlot, inputIndex) {
+    WebDeviceInputSystem.prototype._updateDevice = function (deviceType, deviceSlot, inputIndex) {
         // Gamepads
         var gp = navigator.getGamepads()[deviceSlot];
         if (gp && deviceType === this._gamepads[deviceSlot]) {
@@ -616,9 +599,9 @@ var WebDeviceInputSystemImpl = /** @class */ (function () {
      * @param deviceName Name of Device from DeviceInputSystem
      * @returns DeviceType enum value
      */
-    WebDeviceInputSystemImpl.prototype._getGamepadDeviceType = function (deviceName) {
-        if (deviceName.indexOf("054c") !== -1 && deviceName.indexOf("0ce6") === -1) { // DualShock 4 Gamepad
-            return DeviceType.DualShock;
+    WebDeviceInputSystem.prototype._getGamepadDeviceType = function (deviceName) {
+        if (deviceName.indexOf("054c") !== -1) { // DualShock 4 Gamepad
+            return (deviceName.indexOf("0ce6") !== -1 ? DeviceType.DualSense : DeviceType.DualShock);
         }
         else if (deviceName.indexOf("Xbox One") !== -1 || deviceName.search("Xbox 360") !== -1 || deviceName.search("xinput") !== -1) { // Xbox Gamepad
             return DeviceType.Xbox;
@@ -633,7 +616,7 @@ var WebDeviceInputSystemImpl = /** @class */ (function () {
      * @param evt PointerEvent to evaluate
      * @returns DeviceType interpreted from event
      */
-    WebDeviceInputSystemImpl.prototype._getPointerType = function (evt) {
+    WebDeviceInputSystem.prototype._getPointerType = function (evt) {
         var deviceType = DeviceType.Mouse;
         if (evt.pointerType === "touch" || evt.pointerType === "pen" || evt.touches) {
             deviceType = DeviceType.Touch;
@@ -643,31 +626,23 @@ var WebDeviceInputSystemImpl = /** @class */ (function () {
     /**
      * Remove events from active input element
      */
-    WebDeviceInputSystemImpl.prototype._removeEvents = function () {
+    WebDeviceInputSystem.prototype._removeEvents = function () {
         // Blur Events
         this._elementToAttachTo.removeEventListener("blur", this._keyboardBlurEvent);
         this._elementToAttachTo.removeEventListener("blur", this._pointerBlurEvent);
         // Keyboard Events
-        if (this._keyboardActive) {
-            this._elementToAttachTo.removeEventListener("keydown", this._keyboardDownEvent);
-            this._elementToAttachTo.removeEventListener("keyup", this._keyboardUpEvent);
-        }
+        this._elementToAttachTo.removeEventListener("keydown", this._keyboardDownEvent);
+        this._elementToAttachTo.removeEventListener("keyup", this._keyboardUpEvent);
         // Pointer Events
-        if (this._pointerActive) {
-            this._elementToAttachTo.removeEventListener(this._eventPrefix + "move", this._pointerMoveEvent);
-            this._elementToAttachTo.removeEventListener(this._eventPrefix + "down", this._pointerDownEvent);
-            this._elementToAttachTo.removeEventListener(this._eventPrefix + "up", this._pointerUpEvent);
-            this._elementToAttachTo.removeEventListener(this._wheelEventName, this._pointerWheelEvent);
-            if (this._pointerInputClearObserver) {
-                this._engine.onEndFrameObservable.remove(this._pointerInputClearObserver);
-            }
+        this._elementToAttachTo.removeEventListener(this._eventPrefix + "move", this._pointerMoveEvent);
+        this._elementToAttachTo.removeEventListener(this._eventPrefix + "down", this._pointerDownEvent);
+        this._elementToAttachTo.removeEventListener(this._eventPrefix + "up", this._pointerUpEvent);
+        this._elementToAttachTo.removeEventListener(this._wheelEventName, this._pointerWheelEvent);
+        if (this._pointerInputClearObserver) {
+            this._engine.onEndFrameObservable.remove(this._pointerInputClearObserver);
         }
     };
-    /** Max number of keycodes */
-    WebDeviceInputSystemImpl.MAX_KEYCODES = 255;
-    /** Max number of pointer inputs */
-    WebDeviceInputSystemImpl.MAX_POINTER_INPUTS = Object.keys(PointerInput).length / 2;
-    return WebDeviceInputSystemImpl;
+    return WebDeviceInputSystem;
 }());
-export { WebDeviceInputSystemImpl };
+export { WebDeviceInputSystem };
 //# sourceMappingURL=webDeviceInputSystem.js.map