@epicgames-ps/lib-pixelstreamingfrontend-ue5.5 0.1.4 → 0.3.0

package/src/DataChannel/DataChannelLatencyTestResults.ts

@@ -4,7 +4,6 @@
  * Data Channel Latency Test types
  */
 
-
 /**
  * Unix epoch
  */
@@ -22,7 +21,7 @@ export type DataChannelLatencyTestRequest = {
     Seq: DataChannelLatencyTestSeq;
     FillResponseSize: number;
     Filler: string;
-}
+};
 
 /**
  * Response from the Streamer
@@ -32,15 +31,15 @@ export type DataChannelLatencyTestResponse = {
     Filler: string;
     ReceivedTimestamp: DataChannelLatencyTestTimestamp;
     SentTimestamp: DataChannelLatencyTestTimestamp;
-}
+};
 
 export type DataChannelLatencyTestResult = {
-    records: Map<DataChannelLatencyTestSeq, DataChannelLatencyTestRecord>
-    dataChannelRtt: number,
-    playerToStreamerTime: number,
-    streamerToPlayerTime: number,
-    exportLatencyAsCSV: () => string
-}
+    records: Map<DataChannelLatencyTestSeq, DataChannelLatencyTestRecord>;
+    dataChannelRtt: number;
+    playerToStreamerTime: number;
+    streamerToPlayerTime: number;
+    exportLatencyAsCSV: () => string;
+};
 
 export class DataChannelLatencyTestRecord {
     seq: DataChannelLatencyTestSeq;
@@ -63,5 +62,4 @@ export class DataChannelLatencyTestRecord {
         this.streamerSentTimestamp = response.SentTimestamp;
         this.responseFillerSize = response.Filler ? response.Filler.length : 0;
     }
-
 }

package/src/DataChannel/DataChannelSender.ts

@@ -18,10 +18,8 @@ export class DataChannelSender {
 
     canSend(): boolean {
         return (
-            this.dataChannelProvider.getDataChannelInstance().dataChannel !==
-                undefined &&
-            this.dataChannelProvider.getDataChannelInstance().dataChannel
-                .readyState == 'open'
+            this.dataChannelProvider.getDataChannelInstance().dataChannel !== undefined &&
+            this.dataChannelProvider.getDataChannelInstance().dataChannel.readyState == 'open'
         );
     }
 
@@ -31,22 +29,14 @@ export class DataChannelSender {
      */
     sendData(data: ArrayBuffer) {
         // reset the afk inactivity
-        const dataChannelInstance =
-            this.dataChannelProvider.getDataChannelInstance();
+        const dataChannelInstance = this.dataChannelProvider.getDataChannelInstance();
 
         if (dataChannelInstance.dataChannel.readyState == 'open') {
             dataChannelInstance.dataChannel.send(data);
-            Logger.Log(
-                Logger.GetStackTrace(),
-                `Message Sent: ${new Uint8Array(data)}`,
-                6
-            );
+            Logger.Info(`Message Sent: ${new Uint8Array(data)}`);
             this.resetAfkWarningTimerOnDataSend();
         } else {
-            Logger.Error(
-                Logger.GetStackTrace(),
-                `Message Failed: ${new Uint8Array(data)}`
-            );
+            Logger.Error(`Message Failed: ${new Uint8Array(data)}`);
         }
     }
 

package/src/DataChannel/LatencyTestResults.ts

@@ -48,15 +48,8 @@ export class LatencyTestResults {
      * Process the encoder times and set them
      */
     processFields() {
-        if (
-            this.EncodeMs == null &&
-            (this.PreEncodeTimeMs != null || this.PostEncodeTimeMs != null)
-        ) {
-            Logger.Log(
-                Logger.GetStackTrace(),
-                `Setting Encode Ms \n ${this.PostEncodeTimeMs} \n ${this.PreEncodeTimeMs}`,
-                6
-            );
+        if (this.EncodeMs == null && (this.PreEncodeTimeMs != null || this.PostEncodeTimeMs != null)) {
+            Logger.Info(`Setting Encode Ms \n ${this.PostEncodeTimeMs} \n ${this.PreEncodeTimeMs}`);
             this.EncodeMs = this.PostEncodeTimeMs - this.PreEncodeTimeMs;
         }
 
@@ -64,13 +57,10 @@ export class LatencyTestResults {
             this.CaptureToSendMs == null &&
             (this.PreCaptureTimeMs != null || this.PostCaptureTimeMs != null)
         ) {
-            Logger.Log(
-                Logger.GetStackTrace(),
-                `Setting CaptureToSendMs Ms \n ${this.PostCaptureTimeMs} \n ${this.PreCaptureTimeMs}`,
-                6
+            Logger.Info(
+                `Setting CaptureToSendMs Ms \n ${this.PostCaptureTimeMs} \n ${this.PreCaptureTimeMs}`
             );
-            this.CaptureToSendMs =
-                this.PostCaptureTimeMs - this.PreCaptureTimeMs;
+            this.CaptureToSendMs = this.PostCaptureTimeMs - this.PreCaptureTimeMs;
         }
     }
 }

package/src/FreezeFrame/FreezeFrame.ts

@@ -53,9 +53,7 @@ export class FreezeFrame {
      * @param jpeg - the freeze frame image as a byte array data
      */
     updateImageElementSource(jpeg: Uint8Array) {
-        const base64 = btoa(
-            jpeg.reduce((data, byte) => data + String.fromCharCode(byte), '')
-        );
+        const base64 = btoa(jpeg.reduce((data, byte) => data + String.fromCharCode(byte), ''));
         this.imageElement.src = 'data:image/jpeg;base64,' + base64;
     }
 
@@ -77,28 +75,18 @@ export class FreezeFrame {
             let displayHeight = 0;
             let displayTop = 0;
             let displayLeft = 0;
-            const parentAspectRatio =
-                this.rootDiv.clientWidth / this.rootDiv.clientHeight;
-            const videoAspectRatio =
-                this.freezeFrameWidth / this.freezeFrameHeight;
+            const parentAspectRatio = this.rootDiv.clientWidth / this.rootDiv.clientHeight;
+            const videoAspectRatio = this.freezeFrameWidth / this.freezeFrameHeight;
             if (parentAspectRatio < videoAspectRatio) {
                 displayWidth = this.rootDiv.clientWidth;
-                displayHeight = Math.floor(
-                    this.rootDiv.clientWidth / videoAspectRatio
-                );
-                displayTop = Math.floor(
-                    (this.rootDiv.clientHeight - displayHeight) * 0.5
-                );
+                displayHeight = Math.floor(this.rootDiv.clientWidth / videoAspectRatio);
+                displayTop = Math.floor((this.rootDiv.clientHeight - displayHeight) * 0.5);
                 displayLeft = 0;
             } else {
-                displayWidth = Math.floor(
-                    this.rootDiv.clientHeight * videoAspectRatio
-                );
+                displayWidth = Math.floor(this.rootDiv.clientHeight * videoAspectRatio);
                 displayHeight = this.rootDiv.clientHeight;
                 displayTop = 0;
-                displayLeft = Math.floor(
-                    (this.rootDiv.clientWidth - displayWidth) * 0.5
-                );
+                displayLeft = Math.floor((this.rootDiv.clientWidth - displayWidth) * 0.5);
             }
             this.rootElement.style.width = this.rootDiv.offsetWidth + 'px';
             this.rootElement.style.height = this.rootDiv.offsetHeight + 'px';

package/src/FreezeFrame/FreezeFrameController.ts

@@ -83,30 +83,19 @@ export class FreezeFrameController {
         else {
             this.jpeg = jpegBytes;
             this.receiving = true;
-            Logger.Log(
-                Logger.GetStackTrace(),
-                `received first chunk of freeze frame: ${this.jpeg.length}/${this.size}`,
-                6
-            );
+            Logger.Info(`received first chunk of freeze frame: ${this.jpeg.length}/${this.size}`);
         }
 
         // Finished receiving freeze frame, we can show it now
         if (this.jpeg.length === this.size) {
             this.receiving = false;
             this.valid = true;
-            Logger.Log(
-                Logger.GetStackTrace(),
-                `received complete freeze frame ${this.size}`,
-                6
-            );
+            Logger.Info(`received complete freeze frame ${this.size}`);
             this.updateFreezeFrameAndShow(this.jpeg, onLoadCallBack);
         }
         // We received more data than the freeze frame payload message indicate (this is an error)
         else if (this.jpeg.length > this.size) {
-            Logger.Error(
-                Logger.GetStackTrace(),
-                `received bigger freeze frame than advertised: ${this.jpeg.length}/${this.size}`
-            );
+            Logger.Error(`received bigger freeze frame than advertised: ${this.jpeg.length}/${this.size}`);
             this.jpeg = undefined;
             this.receiving = false;
         }

package/src/Inputs/GamepadController.ts

@@ -1,142 +1,148 @@
 // Copyright Epic Games, Inc. All Rights Reserved.
 
-import { Logger } from '@epicgames-ps/lib-pixelstreamingcommon-ue5.5';
 import { StreamMessageController } from '../UeInstanceMessage/StreamMessageController';
-import { EventListenerTracker } from '../Util/EventListenerTracker';
-import { Controller } from './GamepadTypes';
+import { IInputController } from './IInputController';
+import { Controller, deepCopyGamepad } from './GamepadTypes';
 
 /**
- * The class that handles the functionality of gamepads and controllers
+ * Additional types for Window and Navigator
+ */
+declare global {
+    interface Window {
+        mozRequestAnimationFrame(callback: FrameRequestCallback): number;
+        webkitRequestAnimationFrame(callback: FrameRequestCallback): number;
+    }
+
+    interface Navigator {
+        webkitGetGamepads(): Gamepad[];
+    }
+}
+
+/**
+ * Gamepad layout codes enum
+ */
+/* eslint-disable @typescript-eslint/no-duplicate-enum-values */
+export enum GamepadLayout {
+    RightClusterBottomButton = 0,
+    RightClusterRightButton = 1,
+    RightClusterLeftButton = 2,
+    RightClusterTopButton = 3,
+    LeftShoulder = 4,
+    RightShoulder = 5,
+    LeftTrigger = 6,
+    RightTrigger = 7,
+    SelectOrBack = 8,
+    StartOrForward = 9,
+    LeftAnalogPress = 10,
+    RightAnalogPress = 11,
+    LeftClusterTopButton = 12,
+    LeftClusterBottomButton = 13,
+    LeftClusterLeftButton = 14,
+    LeftClusterRightButton = 15,
+    CentreButton = 16,
+    // Axes
+    LeftStickHorizontal = 0,
+    LeftStickVertical = 1,
+    RightStickHorizontal = 2,
+    RightStickVertical = 3
+}
+/* eslint-enable @typescript-eslint/no-duplicate-enum-values */
+
+/**
+ * Handles gamepad events from the document to send to the streamer.
  */
-export class GamePadController {
+export class GamepadController implements IInputController {
     controllers: Array<Controller>;
-    requestAnimationFrame: (callback: FrameRequestCallback) => number;
-    toStreamerMessagesProvider: StreamMessageController;
+    streamMessageController: StreamMessageController;
 
-    // Utility for keeping track of event handlers and to unregister them.
-    private gamePadEventListenerTracker = new EventListenerTracker();
+    onGamepadConnectedListener: (event: GamepadEvent) => void;
+    onGamepadDisconnectedListener: (event: GamepadEvent) => void;
+    beforeUnloadListener: (event: Event) => void;
+    requestAnimationFrame: (callback: FrameRequestCallback) => number;
 
-    /**
-     * @param toStreamerMessagesProvider - Stream message instance
-     */
-    constructor(toStreamerMessagesProvider: StreamMessageController) {
-        this.toStreamerMessagesProvider = toStreamerMessagesProvider;
+    constructor(streamMessageController: StreamMessageController) {
+        this.streamMessageController = streamMessageController;
 
+        this.onGamepadConnectedListener = this.onGamepadConnected.bind(this);
+        this.onGamepadDisconnectedListener = this.onGamepadDisconnected.bind(this);
+        this.beforeUnloadListener = this.onBeforeUnload.bind(this);
         this.requestAnimationFrame = (
             window.mozRequestAnimationFrame ||
             window.webkitRequestAnimationFrame ||
             window.requestAnimationFrame
         ).bind(window);
-        const browserWindow = window as Window;
+    }
 
-        const onBeforeUnload = (ev: Event) =>
-                this.onBeforeUnload(ev);
-        window.addEventListener('beforeunload', onBeforeUnload);
+    register() {
+        window.addEventListener('beforeunload', this.beforeUnloadListener);
 
+        const browserWindow = window as Window;
         if ('GamepadEvent' in browserWindow) {
-            const onGamePadConnected = (ev: GamepadEvent) =>
-                this.gamePadConnectHandler(ev);
-            const onGamePadDisconnected = (ev: GamepadEvent) =>
-                this.gamePadDisconnectHandler(ev);
-            window.addEventListener('gamepadconnected', onGamePadConnected);
-            window.addEventListener('gamepaddisconnected', onGamePadDisconnected);
-            this.gamePadEventListenerTracker.addUnregisterCallback(
-                () => window.removeEventListener('gamepadconnected', onGamePadConnected)
-            );
-            this.gamePadEventListenerTracker.addUnregisterCallback(
-                () => window.removeEventListener('gamepaddisconnected', onGamePadDisconnected)
-            );
+            window.addEventListener('gamepadconnected', this.onGamepadConnectedListener);
+            window.addEventListener('gamepaddisconnected', this.onGamepadDisconnectedListener);
         } else if ('WebKitGamepadEvent' in browserWindow) {
-            const onWebkitGamePadConnected = (ev: GamepadEvent) => this.gamePadConnectHandler(ev);
-            const onWebkitGamePadDisconnected = (ev: GamepadEvent) => this.gamePadDisconnectHandler(ev);
-            window.addEventListener('webkitgamepadconnected', onWebkitGamePadConnected);
-            window.addEventListener('webkitgamepaddisconnected', onWebkitGamePadDisconnected);
-            this.gamePadEventListenerTracker.addUnregisterCallback(
-                () => window.removeEventListener('webkitgamepadconnected', onWebkitGamePadConnected)
-            );
-            this.gamePadEventListenerTracker.addUnregisterCallback(
-                () => window.removeEventListener('webkitgamepaddisconnected', onWebkitGamePadDisconnected)
-            );
+            window.addEventListener('webkitgamepadconnected', this.onGamepadConnectedListener);
+            window.addEventListener('webkitgamepaddisconnected', this.onGamepadDisconnectedListener);
         }
         this.controllers = [];
         if (navigator.getGamepads) {
             for (const gamepad of navigator.getGamepads()) {
                 if (gamepad) {
-                    this.gamePadConnectHandler(new GamepadEvent('gamepadconnected', { gamepad }));
+                    this.onGamepadConnected(new GamepadEvent('gamepadconnected', { gamepad }));
                 }
             }
         }
     }
 
-    /**
-     * Unregister all event handlers.
-     */
-    unregisterGamePadEvents() {
-        this.gamePadEventListenerTracker.unregisterAll();
-        for(const controller of this.controllers) {
-            if(controller.id !== undefined) {
-                this.onGamepadDisconnected(controller.id);
+    unregister() {
+        window.removeEventListener('gamepadconnected', this.onGamepadConnectedListener);
+        window.removeEventListener('gamepaddisconnected', this.onGamepadDisconnectedListener);
+        window.removeEventListener('webkitgamepadconnected', this.onGamepadConnectedListener);
+        window.removeEventListener('webkitgamepaddisconnected', this.onGamepadDisconnectedListener);
+        for (const controller of this.controllers) {
+            if (controller.id !== undefined) {
+                this.streamMessageController.toStreamerHandlers.get('GamepadDisconnected')([controller.id]);
             }
         }
         this.controllers = [];
-        this.onGamepadConnected = () => { /* */ };
-        this.onGamepadDisconnected = () => { /* */ };
     }
 
-    /**
-     * Connects the gamepad handler
-     * @param gamePadEvent - the activating gamepad event
-     */
-    gamePadConnectHandler(gamePadEvent: GamepadEvent) {
-        Logger.Log(Logger.GetStackTrace(), 'Gamepad connect handler', 6);
-        const gamepad = gamePadEvent.gamepad;
+    onGamepadResponseReceived(gamepadId: number) {
+        for (const controller of this.controllers) {
+            if (controller.id === undefined) {
+                controller.id = gamepadId;
+                break;
+            }
+        }
+    }
 
-        const temp: Controller = {
-            currentState: gamepad,
-            prevState: gamepad,
+    private onGamepadConnected(event: GamepadEvent) {
+        const gamepad = event.gamepad;
+        const newController: Controller = {
+            currentState: deepCopyGamepad(gamepad),
+            prevState: deepCopyGamepad(gamepad),
             id: undefined
         };
 
-        this.controllers.push(temp);
-        this.controllers[gamepad.index].currentState = gamepad;
-        this.controllers[gamepad.index].prevState = gamepad;
-        Logger.Log(
-            Logger.GetStackTrace(),
-            'gamepad: ' + gamepad.id + ' connected',
-            6
-        );
+        this.controllers[gamepad.index] = newController;
         window.requestAnimationFrame(() => this.updateStatus());
-        this.onGamepadConnected();
+        this.streamMessageController.toStreamerHandlers.get('GamepadConnected')();
     }
 
-    /**
-     * Disconnects the gamepad handler
-     * @param gamePadEvent - the activating gamepad event
-     */
-    gamePadDisconnectHandler(gamePadEvent: GamepadEvent) {
-        Logger.Log(Logger.GetStackTrace(), 'Gamepad disconnect handler', 6);
-        Logger.Log(
-            Logger.GetStackTrace(),
-            'gamepad: ' + gamePadEvent.gamepad.id + ' disconnected',
-            6
-        );
-        const deletedController = this.controllers[gamePadEvent.gamepad.index];
-        delete this.controllers[gamePadEvent.gamepad.index];
-        this.controllers = this.controllers.filter(
-            (controller) => controller !== undefined
-        );
-        this.onGamepadDisconnected(deletedController.id);
+    private onGamepadDisconnected(event: GamepadEvent) {
+        const gamepad = event.gamepad;
+        const deletedController = this.controllers[gamepad.index];
+        delete this.controllers[gamepad.index];
+        this.controllers = this.controllers.filter((controller) => controller !== undefined);
+        this.streamMessageController.toStreamerHandlers.get('GamepadDisconnected')([deletedController.id]);
     }
 
-    /**
-     * Scan for connected gamepads
-     */
-    scanGamePads() {
+    private scanGamepads() {
         const gamepads = navigator.getGamepads
             ? navigator.getGamepads()
             : navigator.webkitGetGamepads
-            ? navigator.webkitGetGamepads()
-            : [];
+              ? navigator.webkitGetGamepads()
+              : [];
         for (let i = 0; i < gamepads.length; i++) {
             if (gamepads[i] && gamepads[i].index in this.controllers) {
                 this.controllers[gamepads[i].index].currentState = gamepads[i];
@@ -144,38 +150,27 @@ export class GamePadController {
         }
     }
 
-    /**
-     * Updates the status of the gamepad and sends the inputs
-     */
-    updateStatus() {
-        this.scanGamePads();
-        const toStreamerHandlers =
-            this.toStreamerMessagesProvider.toStreamerHandlers;
+    private updateStatus() {
+        this.scanGamepads();
+        const toStreamerHandlers = this.streamMessageController.toStreamerHandlers;
 
         // Iterate over multiple controllers in the case the multiple gamepads are connected
         for (const controller of this.controllers) {
             // If we haven't received an id (possible if using an older version of UE), return to original functionality
-            const controllerIndex = (controller.id === undefined) ? this.controllers.indexOf(controller) : controller.id;
+            const controllerIndex =
+                controller.id === undefined ? this.controllers.indexOf(controller) : controller.id;
             const currentState = controller.currentState;
             for (let i = 0; i < controller.currentState.buttons.length; i++) {
                 const currentButton = controller.currentState.buttons[i];
                 const previousButton = controller.prevState.buttons[i];
                 if (currentButton.pressed) {
                     // press
-                    if (i == gamepadLayout.LeftTrigger) {
-                        //                       UEs left analog has a button index of 5
-                        toStreamerHandlers.get('GamepadAnalog')([
-                            controllerIndex,
-                            5,
-                            currentButton.value
-                        ]);
-                    } else if (i == gamepadLayout.RightTrigger) {
-                        //                       UEs right analog has a button index of 6
-                        toStreamerHandlers.get('GamepadAnalog')([
-                            controllerIndex,
-                            6,
-                            currentButton.value
-                        ]);
+                    if (i == GamepadLayout.LeftTrigger) {
+                        // UEs left analog has a button index of 5
+                        toStreamerHandlers.get('GamepadAnalog')([controllerIndex, 5, currentButton.value]);
+                    } else if (i == GamepadLayout.RightTrigger) {
+                        // UEs right analog has a button index of 6
+                        toStreamerHandlers.get('GamepadAnalog')([controllerIndex, 6, currentButton.value]);
                     } else {
                         toStreamerHandlers.get('GamepadButtonPressed')([
                             controllerIndex,
@@ -185,26 +180,14 @@ export class GamePadController {
                     }
                 } else if (!currentButton.pressed && previousButton.pressed) {
                     // release
-                    if (i == gamepadLayout.LeftTrigger) {
-                        //                       UEs left analog has a button index of 5
-                        toStreamerHandlers.get('GamepadAnalog')([
-                            controllerIndex,
-                            5,
-                            0
-                        ]);
-                    } else if (i == gamepadLayout.RightTrigger) {
-                        //                       UEs right analog has a button index of 6
-                        toStreamerHandlers.get('GamepadAnalog')([
-                            controllerIndex,
-                            6,
-                            0
-                        ]);
+                    if (i == GamepadLayout.LeftTrigger) {
+                        // UEs left analog has a button index of 5
+                        toStreamerHandlers.get('GamepadAnalog')([controllerIndex, 5, 0]);
+                    } else if (i == GamepadLayout.RightTrigger) {
+                        // UEs right analog has a button index of 6
+                        toStreamerHandlers.get('GamepadAnalog')([controllerIndex, 6, 0]);
                     } else {
-                        toStreamerHandlers.get('GamepadButtonReleased')([
-                            controllerIndex,
-                            i,
-                            0
-                        ]);
+                        toStreamerHandlers.get('GamepadButtonReleased')([controllerIndex, i, 0]);
                     }
                 }
             }
@@ -218,102 +201,21 @@ export class GamePadController {
                 const y = -parseFloat(currentState.axes[i + 1].toFixed(4));
 
                 // UE's analog axes follow the same order as the browsers, but start at index 1 so we will offset as such
-                toStreamerHandlers.get('GamepadAnalog')([
-                    controllerIndex,
-                    i + 1,
-                    x
-                ]); // Horizontal axes, only offset by 1
-                toStreamerHandlers.get('GamepadAnalog')([
-                    controllerIndex,
-                    i + 2,
-                    y
-                ]); // Vertical axes, offset by two (1 to match UEs axes convention and then another 1 for the vertical axes)
+                toStreamerHandlers.get('GamepadAnalog')([controllerIndex, i + 1, x]); // Horizontal axes, only offset by 1
+                toStreamerHandlers.get('GamepadAnalog')([controllerIndex, i + 2, y]); // Vertical axes, offset by two (1 to match UEs axes convention and then another 1 for the vertical axes)
             }
-            this.controllers[controllerIndex].prevState = currentState;
+            this.controllers[controllerIndex].prevState = deepCopyGamepad(currentState);
         }
         if (this.controllers.length > 0) {
             this.requestAnimationFrame(() => this.updateStatus());
         }
     }
 
-    onGamepadResponseReceived(gamepadId: number) {
-        for(const controller of this.controllers) {
-            if(controller.id === undefined) {
-                controller.id = gamepadId;
-                break;
-            }
-        }
-    }
-
-    /**
-     * Event to send the gamepadconnected message to the application
-     */
-    onGamepadConnected() {
-        // Default Functionality: Do Nothing
-    }
-
-    /**
-     * Event to send the gamepaddisconnected message to the application
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    onGamepadDisconnected(controllerIdx: number) {
-        // Default Functionality: Do Nothing
-    }
-
-    onBeforeUnload(_: Event) {
+    private onBeforeUnload(_: Event) {
         // When a user navigates away from the page, we need to inform UE of all the disconnecting
         // controllers
-        for(const controller of this.controllers) {
-            this.onGamepadDisconnected(controller.id);
+        for (const controller of this.controllers) {
+            this.streamMessageController.toStreamerHandlers.get('GamepadDisconnected')([controller.id]);
         }
     }
 }
-
-
-
-/**
- * Additional types for Window and Navigator
- */
-declare global {
-    interface Window {
-        mozRequestAnimationFrame(callback: FrameRequestCallback): number;
-        webkitRequestAnimationFrame(callback: FrameRequestCallback): number;
-    }
-
-    interface Navigator {
-        webkitGetGamepads(): Gamepad[];
-    }
-}
-
-/* eslint-disable @typescript-eslint/no-duplicate-enum-values */
-
-/**
- * Gamepad layout codes enum
- */
-export enum gamepadLayout {
-    RightClusterBottomButton = 0,
-    RightClusterRightButton = 1,
-    RightClusterLeftButton = 2,
-    RightClusterTopButton = 3,
-    LeftShoulder = 4,
-    RightShoulder = 5,
-    LeftTrigger = 6,
-    RightTrigger = 7,
-    SelectOrBack = 8,
-    StartOrForward = 9,
-    LeftAnalogPress = 10,
-    RightAnalogPress = 11,
-    LeftClusterTopButton = 12,
-    LeftClusterBottomButton = 13,
-    LeftClusterLeftButton = 14,
-    LeftClusterRightButton = 15,
-    CentreButton = 16,
-    // Axes
-    LeftStickHorizontal = 0,
-    LeftStickVertical = 1,
-    RightStickHorizontal = 2,
-    RightStickVertical = 3
-}
-
-/* eslint-enable @typescript-eslint/no-duplicate-enum-values */
-

package/src/Inputs/GamepadTypes.ts

@@ -8,3 +8,26 @@ export interface Controller {
     prevState: Gamepad;
     id: number | undefined;
 }
+
+/**
+ * Deep copies the values from a gamepad by first converting it to a JSON object and then back to a gamepad
+ *
+ * @param gamepad the original gamepad
+ * @returns a new gamepad object, populated with the original gamepads values
+ */
+export function deepCopyGamepad(gamepad: Gamepad): Gamepad {
+    return JSON.parse(
+        JSON.stringify({
+            buttons: gamepad.buttons.map((b) =>
+                JSON.parse(
+                    JSON.stringify({
+                        pressed: b.pressed,
+                        touched: b.touched,
+                        value: b.value
+                    })
+                )
+            ),
+            axes: gamepad.axes
+        })
+    );
+}