@yang__yj/pixelstreaming-core 1.0.0 → 1.0.2

package/src/Inputs/LockedMouseEvents.ts

@@ -0,0 +1,287 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+import { MouseController } from './MouseController';
+import { Logger } from '../Logger/Logger';
+import { IMouseEvents } from './IMouseEvents';
+import { NormalizedQuantizedUnsignedCoord } from '../Util/CoordinateConverter';
+import { ActiveKeys } from './InputClassesFactory';
+import { VideoPlayer } from '../VideoPlayer/VideoPlayer';
+import { EventListenerTracker } from '../Util/EventListenerTracker';
+
+/**
+ * Handle the mouse locked events
+ */
+export class LockedMouseEvents implements IMouseEvents {
+    x = 0;
+    y = 0;
+    coord: NormalizedQuantizedUnsignedCoord;
+    videoElementProvider: VideoPlayer;
+    mouseController: MouseController;
+    activeKeysProvider: ActiveKeys;
+    updateMouseMovePositionEvent = (mouseEvent: MouseEvent) => {
+        this.updateMouseMovePosition(mouseEvent);
+    };
+
+    // Utility for keeping track of event handlers and unregistering them
+    private mouseEventListenerTracker = new EventListenerTracker();
+
+    /**
+     * @param videoElementProvider - Video Player instance
+     * @param mouseController - Mouse controller instance
+     * @param activeKeysProvider - Active keys provider instance
+     * @param playerStyleAttributesProvider - Player style attributes instance
+     */
+    constructor(
+        videoElementProvider: VideoPlayer,
+        mouseController: MouseController,
+        activeKeysProvider: ActiveKeys
+    ) {
+        this.videoElementProvider = videoElementProvider;
+        this.mouseController = mouseController;
+        this.activeKeysProvider = activeKeysProvider;
+        const videoElementParent =
+            this.videoElementProvider.getVideoParentElement();
+        this.x = videoElementParent.getBoundingClientRect().width / 2;
+        this.y = videoElementParent.getBoundingClientRect().height / 2;
+        this.coord =
+            this.mouseController.coordinateConverter.normalizeAndQuantizeUnsigned(
+                this.x,
+                this.y
+            );
+    }
+
+    /**
+     * Unregisters all event handlers
+     */
+    unregisterMouseEvents() {
+        this.mouseEventListenerTracker.unregisterAll();
+    }
+
+    /**
+     * Handle when the locked state Changed
+     */
+    lockStateChange() {
+        const videoElementParent =
+            this.videoElementProvider.getVideoParentElement();
+        const toStreamerHandlers =
+            this.mouseController.toStreamerMessagesProvider.toStreamerHandlers;
+
+        if (
+            document.pointerLockElement === videoElementParent ||
+            document.mozPointerLockElement === videoElementParent
+        ) {
+            Logger.Log(Logger.GetStackTrace(), 'Pointer locked', 6);
+            document.addEventListener(
+                'mousemove',
+                this.updateMouseMovePositionEvent,
+                false
+            );
+            this.mouseEventListenerTracker.addUnregisterCallback(
+                () => document.removeEventListener(
+                    'mousemove',
+                    this.updateMouseMovePositionEvent,
+                    false
+                )
+            );
+        } else {
+            Logger.Log(
+                Logger.GetStackTrace(),
+                'The pointer lock status is now unlocked',
+                6
+            );
+            // !a new arrow function must not be used here as it will be counted as a new function that cannot be removed
+            document.removeEventListener(
+                'mousemove',
+                this.updateMouseMovePositionEvent,
+                false
+            );
+
+            // 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
+            let activeKeys = this.activeKeysProvider.getActiveKeys();
+            const setKeys = new Set(activeKeys);
+            const newKeysIterable: Array<number> = [];
+
+            setKeys.forEach((setKey: number) => {
+                newKeysIterable[setKey];
+            });
+
+            newKeysIterable.forEach((uniqueKeycode) => {
+                toStreamerHandlers.get('KeyUp')([uniqueKeycode]);
+            });
+            // Reset the active keys back to nothing
+            activeKeys = [];
+        }
+    }
+
+    /**
+     * Handle the mouse move event, sends the mouse data to the UE Instance
+     * @param mouseEvent - Mouse Event
+     */
+    updateMouseMovePosition(mouseEvent: MouseEvent) {
+        if (!this.videoElementProvider.isVideoReady()) {
+            return;
+        }
+        const toStreamerHandlers =
+            this.mouseController.toStreamerMessagesProvider.toStreamerHandlers;
+        const styleWidth =
+            this.videoElementProvider.getVideoParentElement().clientWidth;
+        const styleHeight =
+            this.videoElementProvider.getVideoParentElement().clientHeight;
+
+        this.x += mouseEvent.movementX;
+        this.y += mouseEvent.movementY;
+
+        if (this.x > styleWidth) {
+            this.x -= styleWidth;
+        }
+        if (this.y > styleHeight) {
+            this.y -= styleHeight;
+        }
+        if (this.x < 0) {
+            this.x = styleWidth + this.x;
+        }
+        if (this.y < 0) {
+            this.y = styleHeight - this.y;
+        }
+
+        this.coord =
+            this.mouseController.coordinateConverter.normalizeAndQuantizeUnsigned(
+                this.x,
+                this.y
+            );
+        const delta =
+            this.mouseController.coordinateConverter.normalizeAndQuantizeSigned(
+                mouseEvent.movementX,
+                mouseEvent.movementY
+            );
+        toStreamerHandlers.get('MouseMove')([
+            this.coord.x,
+            this.coord.y,
+            delta.x,
+            delta.y
+        ]);
+    }
+
+    /**
+     * Handle the mouse Down event, sends the mouse data to the UE Instance
+     * @param mouseEvent - Mouse Event
+     */
+    handleMouseDown(mouseEvent: MouseEvent) {
+        if (!this.videoElementProvider.isVideoReady()) {
+            return;
+        }
+
+        const toStreamerHandlers =
+            this.mouseController.toStreamerMessagesProvider.toStreamerHandlers;
+        toStreamerHandlers.get('MouseDown')([
+            mouseEvent.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.coord.x,
+            this.coord.y
+        ]);
+    }
+
+    /**
+     * Handle the mouse Up event, sends the mouse data to the UE Instance
+     * @param mouseEvent - Mouse Event
+     */
+    handleMouseUp(mouseEvent: MouseEvent) {
+        if (!this.videoElementProvider.isVideoReady()) {
+            return;
+        }
+        const toStreamerHandlers =
+            this.mouseController.toStreamerMessagesProvider.toStreamerHandlers;
+        toStreamerHandlers.get('MouseUp')([
+            mouseEvent.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.coord.x,
+            this.coord.y
+        ]);
+    }
+
+    /**
+     * Handle the mouse wheel event, sends the mouse wheel data to the UE Instance
+     * @param wheelEvent - Mouse Event
+     */
+    handleMouseWheel(wheelEvent: WheelEvent) {
+        if (!this.videoElementProvider.isVideoReady()) {
+            return;
+        }
+        const toStreamerHandlers =
+            this.mouseController.toStreamerMessagesProvider.toStreamerHandlers;
+        toStreamerHandlers.get('MouseWheel')([
+            wheelEvent.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.coord.x,
+            this.coord.y
+        ]);
+    }
+
+    /**
+     * Handle the mouse double click event, sends the mouse data to the UE Instance
+     * @param mouseEvent - Mouse Event
+     */
+    handleMouseDouble(mouseEvent: MouseEvent) {
+        if (!this.videoElementProvider.isVideoReady()) {
+            return;
+        }
+        const toStreamerHandlers =
+            this.mouseController.toStreamerMessagesProvider.toStreamerHandlers;
+        toStreamerHandlers.get('MouseDouble')([
+            mouseEvent.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.coord.x,
+            this.coord.y
+        ]);
+    }
+
+    /**
+     * Handle the press mouse buttons event, sends the mouse data to the UE Instance
+     * @param mouseEvent - Mouse Event
+     */
+    handlePressMouseButtons(mouseEvent: MouseEvent) {
+        if (!this.videoElementProvider.isVideoReady()) {
+            return;
+        }
+        this.mouseController.pressMouseButtons(
+            mouseEvent.buttons,
+            this.x,
+            this.y
+        );
+    }
+
+    /**
+     * Handle the release mouse buttons event, sends the mouse data to the UE Instance
+     * @param mouseEvent - Mouse Event
+     */
+    handleReleaseMouseButtons(mouseEvent: MouseEvent) {
+        if (!this.videoElementProvider.isVideoReady()) {
+            return;
+        }
+        this.mouseController.releaseMouseButtons(
+            mouseEvent.buttons,
+            this.x,
+            this.y
+        );
+    }
+}
+
+/**
+ * Extra types for Document and WheelEvent
+ */
+declare global {
+    interface Document {
+        mozPointerLockElement: unknown;
+        mozExitPointerLock?(): void;
+    }
+
+    interface WheelEvent {
+        wheelDelta: number;
+    }
+}

package/src/Inputs/MouseButtons.ts

@@ -0,0 +1,25 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+/**
+ * Mouse Button Data
+ * {@link https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/button}
+ */
+export class MouseButton {
+    static mainButton = 0; // Left button.
+    static auxiliaryButton = 1; // Wheel button.
+    static secondaryButton = 2; // Right button.
+    static fourthButton = 3; // Browser Back button.
+    static fifthButton = 4; // Browser Forward button.
+}
+
+/**
+ * Mouse Button Mask Data
+ * {@link https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/buttons}
+ */
+export class MouseButtonsMask {
+    static primaryButton = 1; // Left button.
+    static secondaryButton = 2; // Right button.
+    static auxiliaryButton = 4; // Wheel button.
+    static fourthButton = 8; // Browser Back button.
+    static fifthButton = 16; // Browser Forward button.
+}

package/src/Inputs/MouseController.ts

@@ -0,0 +1,362 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+import { MouseButtonsMask, MouseButton } from './MouseButtons';
+import { Logger } from '../Logger/Logger';
+import { StreamMessageController } from '../UeInstanceMessage/StreamMessageController';
+import { CoordinateConverter } from '../Util/CoordinateConverter';
+import { VideoPlayer } from '../VideoPlayer/VideoPlayer';
+import { IMouseEvents } from './IMouseEvents';
+import { LockedMouseEvents } from './LockedMouseEvents';
+import { HoveringMouseEvents } from './HoveringMouseEvents';
+import type { ActiveKeys } from './InputClassesFactory';
+import { EventListenerTracker } from '../Util/EventListenerTracker';
+
+/**
+ * Handles the Mouse Inputs for the document
+ */
+export class MouseController {
+    videoElementProvider: VideoPlayer;
+    toStreamerMessagesProvider: StreamMessageController;
+    coordinateConverter: CoordinateConverter;
+    activeKeysProvider: ActiveKeys;
+
+    // Utility for keeping track of event handlers and unregistering them
+    private mouseEventListenerTracker = new EventListenerTracker();
+
+    /**
+     * @param toStreamerMessagesProvider - Stream message instance
+     * @param videoElementProvider - Video Player instance
+     * @param normalizeAndQuantize - A normalize and quantize instance
+     */
+    constructor(
+        toStreamerMessagesProvider: StreamMessageController,
+        videoElementProvider: VideoPlayer,
+        coordinateConverter: CoordinateConverter,
+        activeKeysProvider: ActiveKeys
+    ) {
+        this.toStreamerMessagesProvider = toStreamerMessagesProvider;
+        this.coordinateConverter = coordinateConverter;
+        this.videoElementProvider = videoElementProvider;
+        this.activeKeysProvider = activeKeysProvider;
+        this.registerMouseEnterAndLeaveEvents();
+    }
+
+    /**
+     * Clears all the click events on the current video element parent div
+     */
+    unregisterMouseEvents() {
+        this.mouseEventListenerTracker.unregisterAll();
+    }
+
+    /**
+     * Register a locked mouse class
+     * @param mouseController - a mouse controller instance
+     * @param playerStyleAttributesProvider - a player style attributes instance
+     */
+    registerLockedMouseEvents(mouseController: MouseController) {
+        const videoElementParent =
+            this.videoElementProvider.getVideoParentElement() as HTMLDivElement;
+        const lockedMouseEvents: IMouseEvents = new LockedMouseEvents(
+            this.videoElementProvider,
+            mouseController,
+            this.activeKeysProvider
+        );
+
+        videoElementParent.requestPointerLock =
+            videoElementParent.requestPointerLock ||
+            videoElementParent.mozRequestPointerLock;
+        document.exitPointerLock =
+            document.exitPointerLock || document.mozExitPointerLock;
+
+        // minor hack to alleviate ios not supporting pointerlock
+        if (videoElementParent.requestPointerLock) {
+            const onclick = () => {
+                videoElementParent.requestPointerLock();
+            };
+            videoElementParent.addEventListener('click', onclick);
+            this.mouseEventListenerTracker.addUnregisterCallback(
+                () => videoElementParent.removeEventListener('click', onclick)
+            );
+        }
+
+        const lockStateChangeListener = () =>
+            lockedMouseEvents.lockStateChange();
+        document.addEventListener(
+            'pointerlockchange',
+            lockStateChangeListener,
+            false
+        );
+        document.addEventListener(
+            'mozpointerlockchange',
+            lockStateChangeListener,
+            false
+        );
+        this.mouseEventListenerTracker.addUnregisterCallback(
+            () => document.removeEventListener(
+                'pointerlockchange',
+                lockStateChangeListener,
+                false
+            )
+        );
+        this.mouseEventListenerTracker.addUnregisterCallback(
+            () => document.removeEventListener(
+                'mozpointerlockchange',
+                lockStateChangeListener,
+                false
+            )
+        );
+
+        const onmousedown = (mouseEvent: MouseEvent) =>
+            lockedMouseEvents.handleMouseDown(mouseEvent);
+        const onmouseup = (mouseEvent: MouseEvent) =>
+            lockedMouseEvents.handleMouseUp(mouseEvent);
+        const onwheel = (wheelEvent: WheelEvent) =>
+            lockedMouseEvents.handleMouseWheel(wheelEvent);
+        const ondblclick = (mouseEvent: MouseEvent) =>
+            lockedMouseEvents.handleMouseDouble(mouseEvent);
+        videoElementParent.addEventListener('mousedown', onmousedown);
+        videoElementParent.addEventListener('mouseup', onmouseup);
+        videoElementParent.addEventListener('wheel', onwheel);
+        videoElementParent.addEventListener('dblclick', ondblclick);
+
+        this.mouseEventListenerTracker.addUnregisterCallback(
+            () => videoElementParent.removeEventListener('mousedown', onmousedown)
+        );
+        this.mouseEventListenerTracker.addUnregisterCallback(
+            () => videoElementParent.removeEventListener('mouseup', onmouseup)
+        );
+        this.mouseEventListenerTracker.addUnregisterCallback(
+            () => videoElementParent.removeEventListener('wheel', onwheel)
+        );
+        this.mouseEventListenerTracker.addUnregisterCallback(
+            () => videoElementParent.removeEventListener('dblclick', ondblclick)
+        );
+        this.mouseEventListenerTracker.addUnregisterCallback(
+            () => lockedMouseEvents.unregisterMouseEvents()
+        );
+        this.mouseEventListenerTracker.addUnregisterCallback(() => {
+            if (
+                document.exitPointerLock &&
+                (document.pointerLockElement === videoElementParent ||
+                    document.mozPointerLockElement === videoElementParent)
+            ) {
+                document.exitPointerLock();
+            }
+        });
+    }
+
+    /**
+     * Register a hovering mouse class
+     * @param mouseController - A mouse controller object
+     */
+    registerHoveringMouseEvents(mouseController: MouseController) {
+        const videoElementParent =
+            this.videoElementProvider.getVideoParentElement() as HTMLDivElement;
+        const hoveringMouseEvents = new HoveringMouseEvents(mouseController);
+
+        const onmousemove = (mouseEvent: MouseEvent) =>
+            hoveringMouseEvents.updateMouseMovePosition(mouseEvent);
+        const onmousedown = (mouseEvent: MouseEvent) =>
+            hoveringMouseEvents.handleMouseDown(mouseEvent);
+        const onmouseup = (mouseEvent: MouseEvent) =>
+            hoveringMouseEvents.handleMouseUp(mouseEvent);
+        const oncontextmenu = (mouseEvent: MouseEvent) =>
+            hoveringMouseEvents.handleContextMenu(mouseEvent);
+        const onwheel = (wheelEvent: WheelEvent) =>
+            hoveringMouseEvents.handleMouseWheel(wheelEvent);
+        const ondblclick = (mouseEvent: MouseEvent) =>
+            hoveringMouseEvents.handleMouseDouble(mouseEvent);
+        videoElementParent.addEventListener('mousemove', onmousemove);
+        videoElementParent.addEventListener('mousedown', onmousedown);
+        videoElementParent.addEventListener('mouseup', onmouseup);
+        videoElementParent.addEventListener('contextmenu', oncontextmenu);
+        videoElementParent.addEventListener('wheel', onwheel);
+        videoElementParent.addEventListener('dblclick', ondblclick);
+
+        this.mouseEventListenerTracker.addUnregisterCallback(
+            () => videoElementParent.removeEventListener('mousemove', onmousemove)
+        );
+        this.mouseEventListenerTracker.addUnregisterCallback(
+            () => videoElementParent.removeEventListener('mousedown', onmousedown)
+        );
+        this.mouseEventListenerTracker.addUnregisterCallback(
+            () => videoElementParent.removeEventListener('mouseup', onmouseup)
+        );
+        this.mouseEventListenerTracker.addUnregisterCallback(
+            () => videoElementParent.removeEventListener('contextmenu', oncontextmenu)
+        );
+        this.mouseEventListenerTracker.addUnregisterCallback(
+            () => videoElementParent.removeEventListener('wheel', onwheel)
+        );
+        this.mouseEventListenerTracker.addUnregisterCallback(
+            () => videoElementParent.removeEventListener('dblclick', ondblclick)
+        );
+        this.mouseEventListenerTracker.addUnregisterCallback(
+            () => hoveringMouseEvents.unregisterMouseEvents()
+        );
+    }
+
+    /**
+     * Set the mouse enter and mouse leave events
+     */
+    registerMouseEnterAndLeaveEvents() {
+        const videoElementParent =
+            this.videoElementProvider.getVideoParentElement() as HTMLDivElement;
+
+        // Handle when the Mouse has entered the element
+        const onmouseenter = (event: MouseEvent) => {
+            if (!this.videoElementProvider.isVideoReady()) {
+                return;
+            }
+            Logger.Log(Logger.GetStackTrace(), 'Mouse Entered', 6);
+            this.sendMouseEnter();
+            this.pressMouseButtons(event.buttons, event.x, event.y);
+        };
+
+        // Handles when the mouse has left the element
+        const onmouseleave = (event: MouseEvent) => {
+            if (!this.videoElementProvider.isVideoReady()) {
+                return;
+            }
+            Logger.Log(Logger.GetStackTrace(), 'Mouse Left', 6);
+            this.sendMouseLeave();
+            this.releaseMouseButtons(event.buttons, event.x, event.y);
+        };
+        videoElementParent.addEventListener('mouseenter', onmouseenter);
+        videoElementParent.addEventListener('mouseleave', onmouseleave);
+
+        this.mouseEventListenerTracker.addUnregisterCallback(
+            () => videoElementParent.removeEventListener('mouseenter', onmouseenter)
+        );
+        this.mouseEventListenerTracker.addUnregisterCallback(
+            () => videoElementParent.removeEventListener('mouseleave', onmouseleave)
+        );
+    }
+
+    /**
+     * Handle when a mouse button is released
+     * @param buttons - Mouse Button
+     * @param X - Mouse pointer X coordinate
+     * @param Y - Mouse pointer Y coordinate
+     */
+    releaseMouseButtons(buttons: number, X: number, Y: number) {
+        const coord = this.coordinateConverter.normalizeAndQuantizeUnsigned(
+            X,
+            Y
+        );
+        if (buttons & MouseButtonsMask.primaryButton) {
+            this.sendMouseUp(MouseButton.mainButton, coord.x, coord.y);
+        }
+        if (buttons & MouseButtonsMask.secondaryButton) {
+            this.sendMouseUp(MouseButton.secondaryButton, coord.x, coord.y);
+        }
+        if (buttons & MouseButtonsMask.auxiliaryButton) {
+            this.sendMouseUp(MouseButton.auxiliaryButton, coord.x, coord.y);
+        }
+        if (buttons & MouseButtonsMask.fourthButton) {
+            this.sendMouseUp(MouseButton.fourthButton, coord.x, coord.y);
+        }
+        if (buttons & MouseButtonsMask.fifthButton) {
+            this.sendMouseUp(MouseButton.fifthButton, coord.x, coord.y);
+        }
+    }
+
+    /**
+     * Handle when a mouse button is pressed
+     * @param buttons - Mouse Button
+     * @param X - Mouse pointer X coordinate
+     * @param Y - Mouse pointer Y coordinate
+     */
+    pressMouseButtons(buttons: number, X: number, Y: number) {
+        if (!this.videoElementProvider.isVideoReady()) {
+            return;
+        }
+        const coord = this.coordinateConverter.normalizeAndQuantizeUnsigned(
+            X,
+            Y
+        );
+        if (buttons & MouseButtonsMask.primaryButton) {
+            this.sendMouseDown(MouseButton.mainButton, coord.x, coord.y);
+        }
+        if (buttons & MouseButtonsMask.secondaryButton) {
+            this.sendMouseDown(MouseButton.secondaryButton, coord.x, coord.y);
+        }
+        if (buttons & MouseButtonsMask.auxiliaryButton) {
+            this.sendMouseDown(MouseButton.auxiliaryButton, coord.x, coord.y);
+        }
+        if (buttons & MouseButtonsMask.fourthButton) {
+            this.sendMouseDown(MouseButton.fourthButton, coord.x, coord.y);
+        }
+        if (buttons & MouseButtonsMask.fifthButton) {
+            this.sendMouseDown(MouseButton.fifthButton, coord.x, coord.y);
+        }
+    }
+
+    /**
+     * Handles mouse enter
+     */
+    sendMouseEnter() {
+        if (!this.videoElementProvider.isVideoReady()) {
+            return;
+        }
+        const toStreamerHandlers =
+            this.toStreamerMessagesProvider.toStreamerHandlers;
+        toStreamerHandlers.get('MouseEnter')();
+    }
+
+    /**
+     * Handles mouse Leave
+     */
+    sendMouseLeave() {
+        if (!this.videoElementProvider.isVideoReady()) {
+            return;
+        }
+        const toStreamerHandlers =
+            this.toStreamerMessagesProvider.toStreamerHandlers;
+        toStreamerHandlers.get('MouseLeave')();
+    }
+
+    /**
+     * Handles when a mouse button is pressed down
+     * @param button - Mouse Button Pressed
+     * @param X  - Mouse X Coordinate
+     * @param Y  - Mouse Y Coordinate
+     */
+    sendMouseDown(button: number, X: number, Y: number) {
+        if (!this.videoElementProvider.isVideoReady()) {
+            return;
+        }
+        Logger.Log(
+            Logger.GetStackTrace(),
+            `mouse button ${button} down at (${X}, ${Y})`,
+            6
+        );
+        const toStreamerHandlers =
+            this.toStreamerMessagesProvider.toStreamerHandlers;
+        toStreamerHandlers.get('MouseDown')([button, X, Y]);
+    }
+
+    /**
+     * Handles when a mouse button is pressed up
+     * @param button - Mouse Button Pressed
+     * @param X  - Mouse X Coordinate
+     * @param Y  - Mouse Y Coordinate
+     */
+    sendMouseUp(button: number, X: number, Y: number) {
+        if (!this.videoElementProvider.isVideoReady()) {
+            return;
+        }
+        Logger.Log(
+            Logger.GetStackTrace(),
+            `mouse button ${button} up at (${X}, ${Y})`,
+            6
+        );
+        const coord = this.coordinateConverter.normalizeAndQuantizeUnsigned(
+            X,
+            Y
+        );
+        const toStreamerHandlers =
+            this.toStreamerMessagesProvider.toStreamerHandlers;
+        toStreamerHandlers.get('MouseUp')([button, coord.x, coord.y]);
+    }
+}

package/src/Inputs/SpecialKeyCodes.ts

@@ -0,0 +1,16 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+/**
+ * Registers the Special Key codes
+ *  Must be kept in sync with JavaScriptKeyCodeToFKey C++ array.
+ * The index of the entry in the array is the special key code given below.
+ */
+export class SpecialKeyCodes {
+    static backSpace = 8;
+    static shift = 16;
+    static control = 17;
+    static alt = 18;
+    static rightShift = 253;
+    static rightControl = 254;
+    static rightAlt = 255;
+}