PR Changes (Not including DeviceSource)

src/DeviceInput/InputDevices/deviceEnums.ts

@@ -14,16 +14,15 @@ export enum DeviceType {
     Xbox = 4,
     /** Switch Controller */
     Switch = 5,
-    /** Generic Device */
-    GenericDevice = 6
+    /** Generic */
+    Generic = 6
 }
 
 // Device Enums
 /**
  * Enum for All Pointers (Touch/Mouse)
  */
-export enum PointerInputs
-{
+export enum PointerInput {
     /** Horizontal Axis */
     Horizontal = 0,
     /** Vertical Axis */
@@ -43,7 +42,7 @@ export enum PointerInputs
 /**
  * Enum for Dual Shock Gamepad
  */
-export enum DualShockInputs {
+export enum DualShockInput {
     /** Cross */
     Cross = 0,
     /** Circle */
@@ -93,7 +92,7 @@ export enum DualShockInputs {
 /**
  * Enum for Xbox Gamepad
  */
-export enum XboxInputs {
+export enum XboxInput {
     /** A */
     A = 0,
     /** B */
@@ -141,7 +140,7 @@ export enum XboxInputs {
 /**
  * Enum for Switch (Pro/JoyCon L+R) Gamepad
  */
-export enum SwitchInputs {
+export enum SwitchInput {
     /** B */
     B = 0,
     /** A */
@@ -186,4 +185,15 @@ export enum SwitchInputs {
     RStickXAxis = 20,
     /** RStickYAxis */
     RStickYAxis = 21
-}
+}
+
+/**
+ * Type to handle enforcement of inputs
+ */
+export type DeviceInputs<T extends DeviceType> =
+    T extends DeviceType.Keyboard | DeviceType.Generic ? number :
+    T extends DeviceType.Mouse | DeviceType.Touch ? PointerInput :
+    T extends DeviceType.DualShock ? DualShockInput :
+    T extends DeviceType.Xbox ? XboxInput :
+    T extends DeviceType.Switch ? SwitchInput :
+    never;

src/DeviceInput/InputDevices/deviceSourceManager.ts

@@ -1,7 +1,7 @@
-import { DeviceInputSystem } from '../deviceInputSystem';
+import { DeviceInputSystem, POINTER_DEVICE, KEYBOARD_DEVICE, MOUSE_DEVICE } from '../deviceInputSystem';
 import { Engine } from '../../Engines/engine';
 import { IDisposable } from '../../scene';
-import { DeviceType } from './deviceEnums';
+import { DeviceType, DeviceInputs } from './deviceEnums';
 import { Nullable } from '../../types';
 import { Observable } from '../../Misc/observable';
 
@@ -13,22 +13,22 @@ export class DeviceSourceManager implements IDisposable {
     /**
      * Observable to be triggered when before a device is connected
      */
-    public onBeforeDeviceConnectedObservable = new Observable<string>();
+    public onBeforeDeviceConnectedObservable = new Observable<{deviceType: DeviceType, deviceSlot: number}>();
 
     /**
      * Observable to be triggered when before a device is disconnected
      */
-    public onBeforeDeviceDisconnectedObservable = new Observable<string>();
+    public onBeforeDeviceDisconnectedObservable = new Observable<{deviceType: DeviceType, deviceSlot: number}>();
 
     /**
      * Observable to be triggered when after a device is connected
      */
-    public onAfterDeviceConnectedObservable = new Observable<string>();
+    public onAfterDeviceConnectedObservable = new Observable<{deviceType: DeviceType, deviceSlot: number}>();
 
     /**
      * Observable to be triggered when after a device is disconnected
      */
-    public onAfterDeviceDisconnectedObservable = new Observable<string>();
+    public onAfterDeviceDisconnectedObservable = new Observable<{deviceType: DeviceType, deviceSlot: number}>();
 
     // Private Members
     private _devices: Array<Array<string>>;
@@ -46,27 +46,33 @@ export class DeviceSourceManager implements IDisposable {
         this._firstDevice = new Array<number>(numberOfDeviceTypes);
         this._deviceInputSystem = new DeviceInputSystem(engine);
 
-        this._deviceInputSystem.onDeviceConnectedObservable.add((deviceName) => {
-            this.onBeforeDeviceConnectedObservable.notifyObservers(deviceName);
+        this._deviceInputSystem.onDeviceConnected = (deviceName) => {
+            const deviceType = this._getDeviceTypeFromName(deviceName);
+            const deviceSlot = this._getDeviceSlot(deviceName);
+
+            this.onBeforeDeviceConnectedObservable.notifyObservers({deviceType, deviceSlot});
             this._addDevice(deviceName);
-            this.onAfterDeviceConnectedObservable.notifyObservers(deviceName);
-        });
-        this._deviceInputSystem.onDeviceDisconnectedObservable.add((deviceName) => {
-            this.onBeforeDeviceDisconnectedObservable.notifyObservers(deviceName);
+            this.onAfterDeviceConnectedObservable.notifyObservers({deviceType, deviceSlot});
+        };
+        this._deviceInputSystem.onDeviceDisconnected = (deviceName) => {
+            const deviceType = this._getDeviceTypeFromName(deviceName);
+            const deviceSlot = this._getDeviceSlot(deviceName);
+
+            this.onBeforeDeviceDisconnectedObservable.notifyObservers({deviceType, deviceSlot});
             this._removeDevice(deviceName);
-            this.onAfterDeviceDisconnectedObservable.notifyObservers(deviceName);
-        });
+            this.onAfterDeviceDisconnectedObservable.notifyObservers({deviceType, deviceSlot});
+        };
     }
 
     // Public Functions
     /**
      * Checks for current device input value, given DeviceType, slot, and inputIndex
      * @param type Enum specifiying device type
-     * @param deviceSlot "Slot" or index that device is referenced in
      * @param inputIndex Index of device input
+     * @param deviceSlot "Slot" or index that device is referenced in
      * @returns Current value of input
      */
-    public getInput(type: DeviceType, inputIndex: number, deviceSlot: number = this._firstDevice[type]): Nullable<number> {
+    public getInput<T extends DeviceType>(type: T, inputIndex: DeviceInputs<T>, deviceSlot: number = this._firstDevice[type]): Nullable<number> {
         if (!this._devices[type] || this._firstDevice[type] === undefined)
         {
             return null;
@@ -99,10 +105,10 @@ export class DeviceSourceManager implements IDisposable {
         {
             this._devices[deviceType] = new Array<string>();
 
-            if(deviceType == DeviceType.Touch)
+            if (deviceType == DeviceType.Touch)
             {
                 this._touchPoints = new Array<string>();
-                this._devices[deviceType][deviceSlot] = DeviceInputSystem.POINTER_DEVICE;
+                this._devices[deviceType][deviceSlot] = POINTER_DEVICE;
             }
         }
 
@@ -115,7 +121,7 @@ export class DeviceSourceManager implements IDisposable {
         {
             this._devices[deviceType][deviceSlot] = deviceName;
         }
-        
+
         this._updateFirstDevices(deviceType);
     }
 
@@ -169,7 +175,7 @@ export class DeviceSourceManager implements IDisposable {
             case DeviceType.DualShock:
             case DeviceType.Xbox:
             case DeviceType.Switch:
-            case DeviceType.GenericDevice:
+            case DeviceType.Generic:
                 let i = 0;
                 let first = -1;
 
@@ -194,13 +200,13 @@ export class DeviceSourceManager implements IDisposable {
      */
     private _getDeviceTypeFromName(deviceName: string): DeviceType
     {
-        if (deviceName == DeviceInputSystem.KEYBOARD_DEVICE) {
+        if (deviceName == KEYBOARD_DEVICE) {
             return DeviceType.Keyboard;
         }
-        else if (deviceName == DeviceInputSystem.MOUSE_DEVICE) {
+        else if (deviceName == MOUSE_DEVICE) {
             return DeviceType.Mouse;
         }
-        else if (deviceName.search(DeviceInputSystem.POINTER_DEVICE) !== -1) {
+        else if (deviceName.search(POINTER_DEVICE) !== -1) {
             return DeviceType.Touch;
         }
         else if (deviceName.search("054c") !== -1) { // DualShock 4 Gamepad
@@ -213,6 +219,6 @@ export class DeviceSourceManager implements IDisposable {
             return DeviceType.Switch;
         }
 
-        return DeviceType.GenericDevice;
+        return DeviceType.Generic;
     }
 }

src/DeviceInput/deviceInputSystem.ts

@@ -1,32 +1,51 @@
-import { Observable } from "../Misc/observable";
 import { Engine } from '../Engines/engine';
 import { IDisposable } from '../scene';
 import { Nullable } from '../types';
 
 /**
+ * Pointer device string
+ * @hidden
+ */
+const POINTER_DEVICE: string = "Pointer";
+/**
+ * Keyboard device string
+ * @hidden
+ */
+const KEYBOARD_DEVICE: string = "Keyboard";
+/**
+ * Mouse device string
+ * @hidden
+ */
+const MOUSE_DEVICE: string = "Mouse";
+
+/** POINTER_DEVICE */
+export { POINTER_DEVICE };
+/** KEYBOARD_DEVICE */
+export { KEYBOARD_DEVICE };
+/** MOUSE_DEVICE */
+export { MOUSE_DEVICE };
+
+/**
  * This class will take all inputs from Keyboard, Pointer, and
  * any Gamepads and provide a polling system that all devices
  * will use.  This class assumes that there will only be one
  * pointer device and one keyboard.
  */
 export class DeviceInputSystem implements IDisposable {
-    // Static
-    /** POINTER_DEVICE */
-    public static readonly POINTER_DEVICE: string = "Pointer";
-    /** KEYBOARD_DEVICE */
-    public static readonly KEYBOARD_DEVICE: string = "Keyboard";
-    /** MOUSE_DEVICE */
-    public static readonly MOUSE_DEVICE: string = "Mouse";
+    /**
+     * Callback to be triggered when a device is connected
+     */
+    public onDeviceConnected = (deviceName: string) => {};
 
     /**
-     * Observable to be triggered when a device is connected
+     * Callback to be triggered when a device is disconnected
      */
-    public onDeviceConnectedObservable = new Observable<string>();
+    public onDeviceDisconnected = (deviceName: string) => {};
 
     /**
-     * Observable to be triggered when a device is disconnected
+     * Callback to be triggered when keyboard/mouse/pointer changes input values
      */
-    public onDeviceDisconnectedObservable = new Observable<string>();
+    public observeInput = (deviceName: string, inputIndex: number, previousState: Nullable<number>, currentState: Nullable<number>) => { };
 
     // Private Members
     private _inputs: { [key: string]: Array<Nullable<number>> } = {};
@@ -89,9 +108,6 @@ export class DeviceInputSystem implements IDisposable {
      * Dispose of all the eventlisteners and clears the observables
      */
     public dispose() {
-        this.onDeviceConnectedObservable.clear();
-        this.onDeviceDisconnectedObservable.clear();
-
         // Keyboard Events
         if (this._keyboardActive) {
             window.removeEventListener("keydown", this._keyboardDownEvent);
@@ -125,7 +141,7 @@ export class DeviceInputSystem implements IDisposable {
             }
 
             this._inputs[deviceName] = device;
-            this.onDeviceConnectedObservable.notifyObservers(deviceName);
+            this.onDeviceConnected(deviceName);
         }
     }
 
@@ -136,7 +152,7 @@ export class DeviceInputSystem implements IDisposable {
     private _unregisterDevice(deviceName: string) {
         if (this._inputs[deviceName]) {
             delete this._inputs[deviceName];
-            this.onDeviceDisconnectedObservable.notifyObservers(deviceName);
+            this.onDeviceDisconnected(deviceName);
         }
     }
 
@@ -147,18 +163,20 @@ export class DeviceInputSystem implements IDisposable {
         this._keyboardDownEvent = ((evt) => {
             if (!this._keyboardActive) {
                 this._keyboardActive = true;
-                this._registerDevice(DeviceInputSystem.KEYBOARD_DEVICE, DeviceInputSystem._MAX_KEYCODES);
+                this._registerDevice(KEYBOARD_DEVICE, DeviceInputSystem._MAX_KEYCODES);
             }
 
-            const kbKey = this._inputs[DeviceInputSystem.KEYBOARD_DEVICE];
+            const kbKey = this._inputs[KEYBOARD_DEVICE];
             if (kbKey) {
+                this.observeInput(KEYBOARD_DEVICE, evt.keyCode, kbKey[evt.keyCode], 1);
                 kbKey[evt.keyCode] = 1;
             }
         });
 
         this._keyboardUpEvent = ((evt) => {
-            const kbKey = this._inputs[DeviceInputSystem.KEYBOARD_DEVICE];
+            const kbKey = this._inputs[KEYBOARD_DEVICE];
             if (kbKey) {
+                this.observeInput(KEYBOARD_DEVICE, evt.keyCode, kbKey[evt.keyCode], 0);
                 kbKey[evt.keyCode] = 0;
             }
         });
@@ -172,7 +190,7 @@ export class DeviceInputSystem implements IDisposable {
      */
     private _handlePointerActions() {
         this._pointerMoveEvent = ((evt) => {
-            const deviceName = (evt.pointerType == "mouse") ? DeviceInputSystem.MOUSE_DEVICE : `${DeviceInputSystem.POINTER_DEVICE}-${evt.pointerId}`;
+            const deviceName = (evt.pointerType == "mouse") ? MOUSE_DEVICE : `${POINTER_DEVICE}-${evt.pointerId}`;
 
             if (!this._inputs[deviceName]) {
                 this._pointerActive = true;
@@ -181,6 +199,8 @@ export class DeviceInputSystem implements IDisposable {
 
             const pointer = this._inputs[deviceName];
             if (pointer) {
+                this.observeInput(deviceName, 0, pointer[0], evt.clientX);
+                this.observeInput(deviceName, 1, pointer[1], evt.clientY);
                 pointer[0] = evt.clientX;
                 pointer[1] = evt.clientY;
             }
@@ -188,7 +208,7 @@ export class DeviceInputSystem implements IDisposable {
 
         this._pointerDownEvent = ((evt) => {
 
-            const deviceName = (evt.pointerType == "mouse") ? DeviceInputSystem.MOUSE_DEVICE : `${DeviceInputSystem.POINTER_DEVICE}-${evt.pointerId}`;
+            const deviceName = (evt.pointerType == "mouse") ? MOUSE_DEVICE : `${POINTER_DEVICE}-${evt.pointerId}`;
             if (!this._inputs[deviceName]) {
                 this._pointerActive = true;
                 this._registerDevice(deviceName, DeviceInputSystem._MAX_POINTER_INPUTS);
@@ -196,6 +216,9 @@ export class DeviceInputSystem implements IDisposable {
 
             const pointer = this._inputs[deviceName];
             if (pointer) {
+                this.observeInput(deviceName, 0, pointer[0], evt.clientX);
+                this.observeInput(deviceName, 1, pointer[1], evt.clientY);
+                this.observeInput(deviceName, evt.button + 2, pointer[evt.button + 2], 1);
                 pointer[0] = evt.clientX;
                 pointer[1] = evt.clientY;
                 pointer[evt.button + 2] = 1;
@@ -203,10 +226,11 @@ export class DeviceInputSystem implements IDisposable {
         });
 
         this._pointerUpEvent = ((evt) => {
-            const deviceName = (evt.pointerType == "mouse") ? DeviceInputSystem.MOUSE_DEVICE : `${DeviceInputSystem.POINTER_DEVICE}-${evt.pointerId}`;
+            const deviceName = (evt.pointerType == "mouse") ? MOUSE_DEVICE : `${POINTER_DEVICE}-${evt.pointerId}`;
 
             const pointer = this._inputs[deviceName];
             if (pointer) {
+                this.observeInput(deviceName, evt.button + 2, pointer[evt.button + 2], 0);
                 pointer[evt.button + 2] = 0;
             }
             if (evt.pointerType != "mouse") // Don't unregister the mouse