@epicgames-ps/lib-pixelstreamingfrontend-ue5.5 0.1.3 → 0.2.1

package/src/Inputs/MouseControllerLocked.ts

@@ -0,0 +1,194 @@
+import { Logger } from '@epicgames-ps/lib-pixelstreamingcommon-ue5.5';
+import { StreamMessageController } from '../UeInstanceMessage/StreamMessageController';
+import { InputCoordTranslator, TranslatedCoordUnsigned } from '../Util/InputCoordTranslator';
+import { VideoPlayer } from '../VideoPlayer/VideoPlayer';
+import type { ActiveKeys } from './InputClassesFactory';
+import { MouseController } from './MouseController';
+
+/**
+ * A mouse controller that locks the mouse to the video document and prevents it from leaving the window
+ */
+export class MouseControllerLocked extends MouseController {
+    videoElementParent: HTMLDivElement;
+    x: number;
+    y: number;
+    normalizedCoord: TranslatedCoordUnsigned;
+
+    // bound listeners
+    onRequestLockListener: () => void;
+    onLockStateChangeListener: () => void;
+    onMouseUpListener: (event: MouseEvent) => void;
+    onMouseDownListener: (event: MouseEvent) => void;
+    onMouseDblClickListener: (event: MouseEvent) => void;
+    onMouseWheelListener: (event: WheelEvent) => void;
+    onMouseMoveListener: (event: MouseEvent) => void;
+
+    constructor(
+        streamMessageController: StreamMessageController,
+        videoPlayer: VideoPlayer,
+        coordinateConverter: InputCoordTranslator,
+        activeKeys: ActiveKeys
+    ) {
+        super(streamMessageController, videoPlayer, coordinateConverter, activeKeys);
+        this.videoElementParent = videoPlayer.getVideoParentElement() as HTMLDivElement;
+        this.x = this.videoElementParent.getBoundingClientRect().width / 2;
+        this.y = this.videoElementParent.getBoundingClientRect().height / 2;
+        this.normalizedCoord = this.coordinateConverter.translateUnsigned(this.x, this.y);
+
+        this.onRequestLockListener = this.onRequestLock.bind(this);
+        this.onLockStateChangeListener = this.onLockStateChange.bind(this);
+        this.onMouseUpListener = this.onMouseUp.bind(this);
+        this.onMouseDownListener = this.onMouseDown.bind(this);
+        this.onMouseDblClickListener = this.onMouseDblClick.bind(this);
+        this.onMouseWheelListener = this.onMouseWheel.bind(this);
+        this.onMouseMoveListener = this.onMouseMove.bind(this);
+    }
+
+    register() {
+        super.register();
+
+        this.videoElementParent.requestPointerLock =
+            this.videoElementParent.requestPointerLock || this.videoElementParent.mozRequestPointerLock;
+        document.exitPointerLock = document.exitPointerLock || document.mozExitPointerLock;
+
+        if (this.videoElementParent.requestPointerLock) {
+            this.videoElementParent.addEventListener('click', this.onRequestLockListener);
+        }
+
+        document.addEventListener('pointerlockchange', this.onLockStateChangeListener);
+        document.addEventListener('mozpointerlockchange', this.onLockStateChangeListener);
+
+        this.videoElementParent.addEventListener('mousedown', this.onMouseDownListener);
+        this.videoElementParent.addEventListener('mouseup', this.onMouseUpListener);
+        this.videoElementParent.addEventListener('wheel', this.onMouseWheelListener);
+        this.videoElementParent.addEventListener('dblclick', this.onMouseDblClickListener);
+    }
+
+    unregister() {
+        const pointerLockElement = document.pointerLockElement || document.mozPointerLockElement;
+        if (document.exitPointerLock && pointerLockElement === this.videoElementParent) {
+            document.exitPointerLock();
+        }
+
+        this.videoElementParent.removeEventListener('click', this.onRequestLockListener);
+        document.removeEventListener('pointerlockchange', this.onLockStateChangeListener);
+        document.removeEventListener('mozpointerlockchange', this.onLockStateChangeListener);
+        document.removeEventListener('mousemove', this.onMouseMoveListener);
+
+        this.videoElementParent.removeEventListener('mousedown', this.onMouseDownListener);
+        this.videoElementParent.removeEventListener('mouseup', this.onMouseUpListener);
+        this.videoElementParent.removeEventListener('wheel', this.onMouseWheelListener);
+        this.videoElementParent.removeEventListener('dblclick', this.onMouseDblClickListener);
+
+        super.unregister();
+    }
+
+    private onRequestLock() {
+        this.videoElementParent.requestPointerLock();
+    }
+
+    private onLockStateChange() {
+        const pointerLockElement = document.pointerLockElement || document.mozPointerLockElement;
+        if (pointerLockElement === this.videoElementParent) {
+            Logger.Info('Pointer locked');
+            document.addEventListener('mousemove', this.onMouseMoveListener);
+        } else {
+            Logger.Info('The pointer lock status is now unlocked');
+            document.removeEventListener('mousemove', this.onMouseMoveListener);
+
+            // If mouse loses focus, send a key up for all of the currently held-down keys
+            // This is necessary as when the mouse loses focus, the windows stops listening for events and as such
+            // the keyup listener won't get fired
+            const activeKeys = this.activeKeys.getActiveKeys();
+            activeKeys.forEach((key: number) => {
+                this.streamMessageController.toStreamerHandlers.get('KeyUp')([key]);
+            });
+        }
+    }
+
+    private onMouseDown(event: MouseEvent) {
+        if (!this.videoPlayer.isVideoReady()) {
+            return;
+        }
+
+        this.streamMessageController.toStreamerHandlers.get('MouseDown')([
+            event.button,
+            // We use the store value of this.coord as opposed to the mouseEvent.x/y as the mouseEvent location
+            // uses the system cursor location which hasn't moved
+            this.normalizedCoord.x,
+            this.normalizedCoord.y
+        ]);
+    }
+
+    private onMouseUp(event: MouseEvent) {
+        if (!this.videoPlayer.isVideoReady()) {
+            return;
+        }
+        this.streamMessageController.toStreamerHandlers.get('MouseUp')([
+            event.button,
+            // We use the store value of this.coord as opposed to the mouseEvent.x/y as the mouseEvent location
+            // uses the system cursor location which hasn't moved
+            this.normalizedCoord.x,
+            this.normalizedCoord.y
+        ]);
+    }
+
+    private onMouseMove(event: MouseEvent) {
+        if (!this.videoPlayer.isVideoReady()) {
+            return;
+        }
+        const styleWidth = this.videoPlayer.getVideoParentElement().clientWidth;
+        const styleHeight = this.videoPlayer.getVideoParentElement().clientHeight;
+
+        this.x += event.movementX;
+        this.y += event.movementY;
+
+        while (this.x > styleWidth) {
+            this.x -= styleWidth;
+        }
+        while (this.y > styleHeight) {
+            this.y -= styleHeight;
+        }
+        while (this.x < 0) {
+            this.x += styleWidth;
+        }
+        while (this.y < 0) {
+            this.y += styleHeight;
+        }
+
+        this.normalizedCoord = this.coordinateConverter.translateUnsigned(this.x, this.y);
+        const delta = this.coordinateConverter.translateSigned(event.movementX, event.movementY);
+        this.streamMessageController.toStreamerHandlers.get('MouseMove')([
+            this.normalizedCoord.x,
+            this.normalizedCoord.y,
+            delta.x,
+            delta.y
+        ]);
+    }
+
+    private onMouseWheel(event: WheelEvent) {
+        if (!this.videoPlayer.isVideoReady()) {
+            return;
+        }
+        this.streamMessageController.toStreamerHandlers.get('MouseWheel')([
+            event.wheelDelta,
+            // We use the store value of this.coord as opposed to the mouseEvent.x/y as the mouseEvent location
+            // uses the system cursor location which hasn't moved
+            this.normalizedCoord.x,
+            this.normalizedCoord.y
+        ]);
+    }
+
+    private onMouseDblClick(event: MouseEvent) {
+        if (!this.videoPlayer.isVideoReady()) {
+            return;
+        }
+        this.streamMessageController.toStreamerHandlers.get('MouseDouble')([
+            event.button,
+            // We use the store value of this.coord as opposed to the mouseEvent.x/y as the mouseEvent location
+            // uses the system cursor location which hasn't moved
+            this.normalizedCoord.x,
+            this.normalizedCoord.y
+        ]);
+    }
+}

package/src/Inputs/TouchController.ts

@@ -1,98 +1,65 @@
 // Copyright Epic Games, Inc. All Rights Reserved.
 
 import { Logger } from '@epicgames-ps/lib-pixelstreamingcommon-ue5.5';
-import { CoordinateConverter } from '../Util/CoordinateConverter';
+import { InputCoordTranslator } from '../Util/InputCoordTranslator';
 import { StreamMessageController } from '../UeInstanceMessage/StreamMessageController';
 import { VideoPlayer } from '../VideoPlayer/VideoPlayer';
-import { ITouchController } from './ITouchController';
-import { EventListenerTracker } from '../Util/EventListenerTracker';
+import { IInputController } from './IInputController';
+
 /**
- * Handles the Touch input Events
+ * The basic touch controller that handles the touch events on the document.
  */
-export class TouchController implements ITouchController {
-    toStreamerMessagesProvider: StreamMessageController;
-    videoElementProvider: VideoPlayer;
-    coordinateConverter: CoordinateConverter;
+export class TouchController implements IInputController {
+    streamMessageController: StreamMessageController;
+    videoPlayer: VideoPlayer;
+    coordinateConverter: InputCoordTranslator;
+
     videoElementParent: HTMLVideoElement;
     fingers = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0];
     fingerIds = new Map();
     maxByteValue = 255;
 
-    // Utility for keeping track of event handlers and to unregister them.
-    private touchEventListenerTracker = new EventListenerTracker();
+    onTouchStartListener: (event: TouchEvent) => void;
+    onTouchEndListener: (event: TouchEvent) => void;
+    onTouchMoveListener: (event: TouchEvent) => void;
 
-    /**
-     * @param toStreamerMessagesProvider - Stream message instance
-     * @param videoElementProvider - Video Player instance
-     * @param coordinateConverter - A coordinate converter instance
-     */
     constructor(
-        toStreamerMessagesProvider: StreamMessageController,
-        videoElementProvider: VideoPlayer,
-        coordinateConverter: CoordinateConverter
+        streamMessageController: StreamMessageController,
+        videoPlayer: VideoPlayer,
+        coordinateConverter: InputCoordTranslator
     ) {
-        this.toStreamerMessagesProvider = toStreamerMessagesProvider;
-        this.videoElementProvider = videoElementProvider;
+        this.streamMessageController = streamMessageController;
+        this.videoPlayer = videoPlayer;
         this.coordinateConverter = coordinateConverter;
-        this.videoElementParent = videoElementProvider.getVideoElement();
-        const ontouchstart = (ev: TouchEvent) =>
-            this.onTouchStart(ev);
-        const ontouchend = (ev: TouchEvent) =>
-            this.onTouchEnd(ev);
-        const ontouchmove = (ev: TouchEvent) =>
-            this.onTouchMove(ev);
-        this.videoElementParent.addEventListener('touchstart', ontouchstart);
-        this.videoElementParent.addEventListener('touchend', ontouchend);
-        this.videoElementParent.addEventListener('touchmove', ontouchmove);
-        this.touchEventListenerTracker.addUnregisterCallback(
-            () => this.videoElementParent.removeEventListener('touchstart', ontouchstart)
-        );
-        this.touchEventListenerTracker.addUnregisterCallback(
-            () => this.videoElementParent.removeEventListener('touchend', ontouchend)
-        );
-        this.touchEventListenerTracker.addUnregisterCallback(
-            () => this.videoElementParent.removeEventListener('touchmove', ontouchmove)
-        );
-        Logger.Log(Logger.GetStackTrace(), 'Touch Events Registered', 6);
-
-        // is this strictly necessary?
-        const preventOnTouchMove = (event: TouchEvent) => {
-            event.preventDefault();
-        };
-        document.addEventListener('touchmove', preventOnTouchMove);
-        this.touchEventListenerTracker.addUnregisterCallback(
-            () => document.removeEventListener('touchmove', preventOnTouchMove)
-        );
+
+        this.videoElementParent = videoPlayer.getVideoElement();
+
+        this.onTouchStartListener = this.onTouchStart.bind(this);
+        this.onTouchEndListener = this.onTouchEnd.bind(this);
+        this.onTouchMoveListener = this.onTouchMove.bind(this);
     }
 
-    /**
-     * Unregister all touch events
-     */
-    unregisterTouchEvents() {
-        this.touchEventListenerTracker.unregisterAll();
+    register() {
+        this.videoElementParent.addEventListener('touchstart', this.onTouchStartListener);
+        this.videoElementParent.addEventListener('touchend', this.onTouchEndListener);
+        this.videoElementParent.addEventListener('touchmove', this.onTouchMoveListener);
     }
 
-    /**
-     * Remember a touch command
-     * @param touch - the touch command
-     */
-    rememberTouch(touch: Touch) {
+    unregister() {
+        this.videoElementParent.addEventListener('touchstart', this.onTouchStartListener);
+        this.videoElementParent.addEventListener('touchend', this.onTouchEndListener);
+        this.videoElementParent.addEventListener('touchmove', this.onTouchMoveListener);
+    }
+
+    private rememberTouch(touch: Touch) {
         const finger = this.fingers.pop();
         if (finger === undefined) {
-            Logger.Log(
-                Logger.GetStackTrace(),
-                'exhausted touch identifiers',
-                6
-            );
+            Logger.Info('exhausted touch identifiers');
         }
         this.fingerIds.set(touch.identifier, finger);
     }
 
-    /**
-     * Forgets a touch command
-     * @param touch - the touch command
-     */
-    forgetTouch(touch: Touch) {
+    private forgetTouch(touch: Touch) {
         this.fingers.push(this.fingerIds.get(touch.identifier));
         // Sort array back into descending order. This means if finger '1' were to lift after finger '0', we would ensure that 0 will be the first index to pop
         this.fingers.sort(function (a, b) {
@@ -101,32 +68,22 @@ export class TouchController implements ITouchController {
         this.fingerIds.delete(touch.identifier);
     }
 
-    /**
-     * When a touch event starts
-     * @param touchEvent - the touch event being intercepted
-     */
-    onTouchStart(touchEvent: TouchEvent) {
-        if (!this.videoElementProvider.isVideoReady()) {
+    private onTouchStart(touchEvent: TouchEvent) {
+        if (!this.videoPlayer.isVideoReady()) {
             return;
         }
         for (let t = 0; t < touchEvent.changedTouches.length; t++) {
             this.rememberTouch(touchEvent.changedTouches[t]);
         }
-        Logger.Log(Logger.GetStackTrace(), 'touch start', 6);
 
         this.emitTouchData('TouchStart', touchEvent.changedTouches);
         touchEvent.preventDefault();
     }
 
-    /**
-     * When a touch event ends
-     * @param touchEvent - the touch event being intercepted
-     */
-    onTouchEnd(touchEvent: TouchEvent) {
-        if (!this.videoElementProvider.isVideoReady()) {
+    private onTouchEnd(touchEvent: TouchEvent) {
+        if (!this.videoPlayer.isVideoReady()) {
             return;
         }
-        Logger.Log(Logger.GetStackTrace(), 'touch end', 6);
         this.emitTouchData('TouchEnd', touchEvent.changedTouches);
         // Re-cycle unique identifiers previously assigned to each touch.
         for (let t = 0; t < touchEvent.changedTouches.length; t++) {
@@ -135,42 +92,29 @@ export class TouchController implements ITouchController {
         touchEvent.preventDefault();
     }
 
-    /**
-     * when a moving touch event occurs
-     * @param touchEvent - the touch event being intercepted
-     */
-    onTouchMove(touchEvent: TouchEvent) {
-        if (!this.videoElementProvider.isVideoReady()) {
+    private onTouchMove(touchEvent: TouchEvent) {
+        if (!this.videoPlayer.isVideoReady()) {
             return;
         }
-        Logger.Log(Logger.GetStackTrace(), 'touch move', 6);
         this.emitTouchData('TouchMove', touchEvent.touches);
         touchEvent.preventDefault();
     }
 
-    emitTouchData(type: string, touches: TouchList) {
-        if (!this.videoElementProvider.isVideoReady()) {
+    private emitTouchData(type: string, touches: TouchList) {
+        if (!this.videoPlayer.isVideoReady()) {
             return;
         }
-        const offset = this.videoElementProvider.getVideoParentElement().getBoundingClientRect();
-        const toStreamerHandlers =
-            this.toStreamerMessagesProvider.toStreamerHandlers;
+        const offset = this.videoPlayer.getVideoParentElement().getBoundingClientRect();
+        const toStreamerHandlers = this.streamMessageController.toStreamerHandlers;
 
         for (let t = 0; t < touches.length; t++) {
             const numTouches = 1; // the number of touches to be sent this message
             const touch = touches[t];
             const x = touch.clientX - offset.left;
             const y = touch.clientY - offset.top;
-            Logger.Log(
-                Logger.GetStackTrace(),
-                `F${this.fingerIds.get(touch.identifier)}=(${x}, ${y})`,
-                6
-            );
-
-            const coord = this.coordinateConverter.normalizeAndQuantizeUnsigned(
-                x,
-                y
-            );
+            Logger.Info(`F${this.fingerIds.get(touch.identifier)}=(${x}, ${y})`);
+
+            const coord = this.coordinateConverter.translateUnsigned(x, y);
             switch (type) {
                 case 'TouchStart':
                     toStreamerHandlers.get('TouchStart')([

package/src/Inputs/TouchControllerFake.ts

@@ -0,0 +1,132 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+import { InputCoordTranslator } from '../Util/InputCoordTranslator';
+import { StreamMessageController } from '../UeInstanceMessage/StreamMessageController';
+import { VideoPlayer } from '../VideoPlayer/VideoPlayer';
+import { MouseButton } from './MouseButtons';
+import { IInputController } from './IInputController';
+
+interface FakeTouchFinger {
+    id: number;
+    x: number;
+    y: number;
+}
+
+/**
+ * Allows for the usage of fake touch events
+ */
+export class TouchControllerFake implements IInputController {
+    streamMessageController: StreamMessageController;
+    videoPlayer: VideoPlayer;
+    coordinateConverter: InputCoordTranslator;
+
+    fakeTouchFinger: FakeTouchFinger;
+    videoElementParentClientRect: DOMRect;
+
+    onTouchStartListener: (event: TouchEvent) => void;
+    onTouchEndListener: (event: TouchEvent) => void;
+    onTouchMoveListener: (event: TouchEvent) => void;
+
+    constructor(
+        streamMessageController: StreamMessageController,
+        videoPlayer: VideoPlayer,
+        coordinateConverter: InputCoordTranslator
+    ) {
+        this.streamMessageController = streamMessageController;
+        this.videoPlayer = videoPlayer;
+        this.coordinateConverter = coordinateConverter;
+
+        this.onTouchStartListener = this.onTouchStart.bind(this);
+        this.onTouchEndListener = this.onTouchEnd.bind(this);
+        this.onTouchMoveListener = this.onTouchMove.bind(this);
+
+        this.videoElementParentClientRect = this.videoPlayer.getVideoParentElement().getBoundingClientRect();
+    }
+
+    register() {
+        document.addEventListener('touchstart', this.onTouchStartListener);
+        document.addEventListener('touchend', this.onTouchEndListener);
+        document.addEventListener('touchmove', this.onTouchMoveListener);
+    }
+
+    unregister() {
+        document.removeEventListener('touchstart', this.onTouchStartListener);
+        document.removeEventListener('touchend', this.onTouchEndListener);
+        document.removeEventListener('touchmove', this.onTouchMoveListener);
+    }
+
+    private onTouchStart(touch: TouchEvent): void {
+        if (!this.videoPlayer.isVideoReady() || touch.target !== this.videoPlayer.getVideoElement()) {
+            return;
+        }
+        if (this.fakeTouchFinger == null) {
+            const first_touch = touch.changedTouches[0];
+            this.fakeTouchFinger = {
+                id: first_touch.identifier,
+                x: first_touch.clientX - this.videoElementParentClientRect.left,
+                y: first_touch.clientY - this.videoElementParentClientRect.top
+            };
+
+            const videoElementParent = this.videoPlayer.getVideoParentElement() as HTMLDivElement;
+            const mouseEvent = new MouseEvent('mouseenter', first_touch);
+            videoElementParent.dispatchEvent(mouseEvent);
+
+            const coord = this.coordinateConverter.translateUnsigned(
+                this.fakeTouchFinger.x,
+                this.fakeTouchFinger.y
+            );
+            const toStreamerHandlers = this.streamMessageController.toStreamerHandlers;
+            toStreamerHandlers.get('MouseDown')([MouseButton.mainButton, coord.x, coord.y]);
+        }
+        touch.preventDefault();
+    }
+
+    private onTouchEnd(touchEvent: TouchEvent): void {
+        if (!this.videoPlayer.isVideoReady() || this.fakeTouchFinger == null) {
+            return;
+        }
+        const videoElementParent = this.videoPlayer.getVideoParentElement();
+        const toStreamerHandlers = this.streamMessageController.toStreamerHandlers;
+
+        for (let t = 0; t < touchEvent.changedTouches.length; t++) {
+            const touch = touchEvent.changedTouches[t];
+            if (touch.identifier === this.fakeTouchFinger.id) {
+                const x = touch.clientX - this.videoElementParentClientRect.left;
+                const y = touch.clientY - this.videoElementParentClientRect.top;
+                const coord = this.coordinateConverter.translateUnsigned(x, y);
+                toStreamerHandlers.get('MouseUp')([MouseButton.mainButton, coord.x, coord.y]);
+
+                const mouseEvent = new MouseEvent('mouseleave', touch);
+                videoElementParent.dispatchEvent(mouseEvent);
+                this.fakeTouchFinger = null;
+                break;
+            }
+        }
+        touchEvent.preventDefault();
+    }
+
+    private onTouchMove(touchEvent: TouchEvent): void {
+        if (!this.videoPlayer.isVideoReady() || this.fakeTouchFinger == null) {
+            return;
+        }
+        const toStreamerHandlers = this.streamMessageController.toStreamerHandlers;
+
+        for (let t = 0; t < touchEvent.touches.length; t++) {
+            const touch = touchEvent.touches[t];
+            if (touch.identifier === this.fakeTouchFinger.id) {
+                const x = touch.clientX - this.videoElementParentClientRect.left;
+                const y = touch.clientY - this.videoElementParentClientRect.top;
+                const coord = this.coordinateConverter.translateUnsigned(x, y);
+                const delta = this.coordinateConverter.translateSigned(
+                    x - this.fakeTouchFinger.x,
+                    y - this.fakeTouchFinger.y
+                );
+                toStreamerHandlers.get('MouseMove')([coord.x, coord.y, delta.x, delta.y]);
+                this.fakeTouchFinger.x = x;
+                this.fakeTouchFinger.y = y;
+                break;
+            }
+        }
+        touchEvent.preventDefault();
+    }
+}

package/src/Inputs/XRGamepadController.ts

@@ -1,7 +1,7 @@
 // Copyright Epic Games, Inc. All Rights Reserved.
 
 import { StreamMessageController } from '../UeInstanceMessage/StreamMessageController';
-import { Controller } from './GamepadTypes';
+import { Controller, deepCopyGamepad } from './GamepadTypes';
 
 /**
  * The class that handles the functionality of XR gamepads and controllers.
@@ -18,34 +18,7 @@ export class XRGamepadController {
         this.controllers = [];
     }
 
-    /**
-     * 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
-     */
-    static 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
-            })
-        );
-    }
-
-    updateStatus(
-        source: XRInputSource,
-        frame: XRFrame,
-        refSpace: XRReferenceSpace
-    ) {
+    updateStatus(source: XRInputSource, frame: XRFrame, refSpace: XRReferenceSpace) {
         if (source.gamepad) {
             const gamepadPose = frame.getPose(source.gripSpace, refSpace);
             if (!gamepadPose) {
@@ -59,9 +32,7 @@ export class XRGamepadController {
                 system = 2;
             }
             // TODO (william.belcher): Add other profiles (Quest, Microsoft Mixed Reality, etc)
-            this.toStreamerMessagesProvider.toStreamerHandlers.get('XRSystem')([
-                system
-            ]);
+            this.toStreamerMessagesProvider.toStreamerHandlers.get('XRSystem')([system]);
 
             // Default: AnyHand (2)
             let handedness = 2;
@@ -95,12 +66,12 @@ export class XRGamepadController {
                 this.controllers[handedness] = {
                     prevState: undefined,
                     currentState: undefined,
-					id: undefined
+                    id: undefined
                 };
-                this.controllers[handedness].prevState = XRGamepadController.deepCopyGamepad(source.gamepad);
+                this.controllers[handedness].prevState = deepCopyGamepad(source.gamepad);
             }
 
-            this.controllers[handedness].currentState = XRGamepadController.deepCopyGamepad(source.gamepad);
+            this.controllers[handedness].currentState = deepCopyGamepad(source.gamepad);
 
             const controller = this.controllers[handedness];
             const currState = controller.currentState;
@@ -113,18 +84,34 @@ export class XRGamepadController {
                 if (currButton.pressed) {
                     // press
                     const isRepeat = prevButton.pressed ? 1 : 0;
-                    this.toStreamerMessagesProvider.toStreamerHandlers.get('XRButtonPressed')([handedness, i, isRepeat, currButton.value]);
+                    this.toStreamerMessagesProvider.toStreamerHandlers.get('XRButtonPressed')([
+                        handedness,
+                        i,
+                        isRepeat,
+                        currButton.value
+                    ]);
                 } else if (prevButton.pressed) {
-                    this.toStreamerMessagesProvider.toStreamerHandlers.get('XRButtonReleased')([handedness, i, 0]);
+                    this.toStreamerMessagesProvider.toStreamerHandlers.get('XRButtonReleased')([
+                        handedness,
+                        i,
+                        0
+                    ]);
                 }
 
                 if (currButton.touched) {
                     // touched
                     const isRepeat = prevButton.touched ? 1 : 0;
-                    this.toStreamerMessagesProvider.toStreamerHandlers.get('XRButtonTouched')([handedness, i, isRepeat]);
-                }
-                else if (prevButton.touched) {
-                    this.toStreamerMessagesProvider.toStreamerHandlers.get('XRButtonTouchReleased')([handedness, i, 0]);
+                    this.toStreamerMessagesProvider.toStreamerHandlers.get('XRButtonTouched')([
+                        handedness,
+                        i,
+                        isRepeat
+                    ]);
+                } else if (prevButton.touched) {
+                    this.toStreamerMessagesProvider.toStreamerHandlers.get('XRButtonTouchReleased')([
+                        handedness,
+                        i,
+                        0
+                    ]);
                 }
             }
 
@@ -133,12 +120,16 @@ export class XRGamepadController {
                 const curAxisValue = currState.axes[i];
                 const prevAxisValue = prevState.axes[i];
                 // Only send axis update if there is a change
-                if(curAxisValue != prevAxisValue) {
-                    this.toStreamerMessagesProvider.toStreamerHandlers.get('XRAnalog')([handedness, i, curAxisValue]);
+                if (curAxisValue != prevAxisValue) {
+                    this.toStreamerMessagesProvider.toStreamerHandlers.get('XRAnalog')([
+                        handedness,
+                        i,
+                        curAxisValue
+                    ]);
                 }
             }
 
             this.controllers[handedness].prevState = currState;
         }
     }
-}
+}