@epicgames-ps/lib-pixelstreamingfrontend-ue5.5 0.0.5

package/src/Inputs/HoveringMouseEvents.ts

@@ -0,0 +1,192 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+import { MouseController } from './MouseController';
+import { Logger } from '@epicgames-ps/lib-pixelstreamingcommon-ue5.5';
+import { IMouseEvents } from './IMouseEvents';
+
+/**
+ * Video Player mouse Hover handler
+ */
+export class HoveringMouseEvents implements IMouseEvents {
+    mouseController: MouseController;
+
+    /**
+     * @param mouseController - Mouse Controller instance
+     */
+    constructor(mouseController: MouseController) {
+        this.mouseController = mouseController;
+    }
+
+    /**
+     * Unregister event handlers
+     */
+    unregisterMouseEvents(): void {
+        // empty for HoveringMouseEvents implementation
+    }
+
+    /**
+     * Handle the mouse move event, sends the mouse data to the UE Instance
+     * @param mouseEvent - Mouse Event
+     */
+    updateMouseMovePosition(mouseEvent: MouseEvent) {
+        if (!this.mouseController.videoElementProvider.isVideoReady()) {
+            return;
+        }
+        Logger.Log(Logger.GetStackTrace(), 'MouseMove', 6);
+        const coord =
+            this.mouseController.coordinateConverter.normalizeAndQuantizeUnsigned(
+                mouseEvent.offsetX,
+                mouseEvent.offsetY
+            );
+        const delta =
+            this.mouseController.coordinateConverter.normalizeAndQuantizeSigned(
+                mouseEvent.movementX,
+                mouseEvent.movementY
+            );
+        const toStreamerHandlers =
+            this.mouseController.toStreamerMessagesProvider.toStreamerHandlers;
+        toStreamerHandlers.get('MouseMove')([
+            coord.x,
+            coord.y,
+            delta.x,
+            delta.y
+        ]);
+        mouseEvent.preventDefault();
+    }
+
+    /**
+     * Handle the mouse Down event, sends the mouse data to the UE Instance
+     * @param mouseEvent - Mouse Event
+     */
+    handleMouseDown(mouseEvent: MouseEvent) {
+        if (!this.mouseController.videoElementProvider.isVideoReady()) {
+            return;
+        }
+        Logger.Log(Logger.GetStackTrace(), 'onMouse Down', 6);
+        const coord =
+            this.mouseController.coordinateConverter.normalizeAndQuantizeUnsigned(
+                mouseEvent.offsetX,
+                mouseEvent.offsetY
+            );
+        const toStreamerHandlers =
+            this.mouseController.toStreamerMessagesProvider.toStreamerHandlers;
+        toStreamerHandlers.get('MouseDown')([
+            mouseEvent.button,
+            coord.x,
+            coord.y
+        ]);
+        mouseEvent.preventDefault();
+    }
+
+    /**
+     * Handle the mouse Up event, sends the mouse data to the UE Instance
+     * @param mouseEvent - Mouse Event
+     */
+    handleMouseUp(mouseEvent: MouseEvent) {
+        if (!this.mouseController.videoElementProvider.isVideoReady()) {
+            return;
+        }
+        Logger.Log(Logger.GetStackTrace(), 'onMouse Up', 6);
+        const coord =
+            this.mouseController.coordinateConverter.normalizeAndQuantizeUnsigned(
+                mouseEvent.offsetX,
+                mouseEvent.offsetY
+            );
+        const toStreamerHandlers =
+            this.mouseController.toStreamerMessagesProvider.toStreamerHandlers;
+        toStreamerHandlers.get('MouseUp')([
+            mouseEvent.button,
+            coord.x,
+            coord.y
+        ]);
+        mouseEvent.preventDefault();
+    }
+
+    /**
+     * Consumes the mouse context event. The UE instance has no equivalent and doesn't need to be informed.
+     * @param mouseEvent - Mouse Event
+     */
+    handleContextMenu(mouseEvent: MouseEvent) {
+        if (!this.mouseController.videoElementProvider.isVideoReady()) {
+            return;
+        }
+        mouseEvent.preventDefault();
+    }
+
+    /**
+     * Handle the mouse wheel event, sends the mouse wheel data to the UE Instance
+     * @param wheelEvent - Mouse Event
+     */
+    handleMouseWheel(wheelEvent: WheelEvent) {
+        if (!this.mouseController.videoElementProvider.isVideoReady()) {
+            return;
+        }
+        const coord =
+            this.mouseController.coordinateConverter.normalizeAndQuantizeUnsigned(
+                wheelEvent.offsetX,
+                wheelEvent.offsetY
+            );
+        const toStreamerHandlers =
+            this.mouseController.toStreamerMessagesProvider.toStreamerHandlers;
+        toStreamerHandlers.get('MouseWheel')([
+            wheelEvent.wheelDelta,
+            coord.x,
+            coord.y
+        ]);
+        wheelEvent.preventDefault();
+    }
+
+    /**
+     * Handle the mouse double click event, sends the mouse data to the UE Instance
+     * @param mouseEvent - Mouse Event
+     */
+    handleMouseDouble(mouseEvent: MouseEvent) {
+        if (!this.mouseController.videoElementProvider.isVideoReady()) {
+            return;
+        }
+        const coord =
+            this.mouseController.coordinateConverter.normalizeAndQuantizeUnsigned(
+                mouseEvent.offsetX,
+                mouseEvent.offsetY
+            );
+        const toStreamerHandlers =
+            this.mouseController.toStreamerMessagesProvider.toStreamerHandlers;
+        toStreamerHandlers.get('MouseDouble')([
+            mouseEvent.button,
+            coord.x,
+            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.mouseController.videoElementProvider.isVideoReady()) {
+            return;
+        }
+        Logger.Log(Logger.GetStackTrace(), 'onMouse press', 6);
+        this.mouseController.pressMouseButtons(
+            mouseEvent.buttons,
+            mouseEvent.offsetX,
+            mouseEvent.offsetY
+        );
+    }
+
+    /**
+     * Handle the release mouse buttons event, sends the mouse data to the UE Instance
+     * @param mouseEvent - Mouse Event
+     */
+    handleReleaseMouseButtons(mouseEvent: MouseEvent) {
+        if (!this.mouseController.videoElementProvider.isVideoReady()) {
+            return;
+        }
+        Logger.Log(Logger.GetStackTrace(), 'onMouse release', 6);
+        this.mouseController.releaseMouseButtons(
+            mouseEvent.buttons,
+            mouseEvent.offsetX,
+            mouseEvent.offsetY
+        );
+    }
+}

package/src/Inputs/IMouseEvents.ts

@@ -0,0 +1,64 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+/**
+ * Interface for Mouse Events
+ */
+export interface IMouseEvents {
+    /**
+     * Handle when the locked state Changed
+     */
+    lockStateChange?(): void;
+
+    /**
+     * Handle when the mouse move
+     * @param mouseEvent - Mouse Event
+     */
+    updateMouseMovePosition?(mouseEvent: MouseEvent): void;
+
+    /**
+     * Handle when the Button Down
+     * @param mouseEvent - Mouse Event
+     */
+    handleMouseDown(mouseEvent: MouseEvent): void;
+
+    /**
+     * Handle when the button up
+     * @param mouseEvent - Mouse Event
+     */
+    handleMouseUp(mouseEvent: MouseEvent): void;
+
+    /**
+     * Handle when the mouse wheel
+     * @param wheelEvent - Mouse wheel
+     */
+    handleMouseWheel(wheelEvent: WheelEvent): void;
+
+    /**
+     * Handle when the button double click
+     * @param mouseEvent - Mouse Event
+     */
+    handleMouseDouble(mouseEvent: MouseEvent): void;
+
+    /**
+     * Handle the press mouse buttons event, sends the mouse data to the UE Instance
+     * @param mouseEvent - Mouse Event
+     */
+    handlePressMouseButtons(mouseEvent: MouseEvent): void;
+
+    /**
+     * Handle the release mouse buttons event, sends the mouse data to the UE Instance
+     * @param mouseEvent - Mouse Event
+     */
+    handleReleaseMouseButtons(mouseEvent: MouseEvent): void;
+
+    /**
+     * Handle the mouse context menu
+     * @param mouseEvent - mouse event
+     */
+    handleContextMenu?(mouseEvent: MouseEvent): void;
+
+    /**
+     * Unregisters any registered mouse event handlers
+     */
+    unregisterMouseEvents(): void;
+}

package/src/Inputs/ITouchController.ts

@@ -0,0 +1,29 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+/**
+ * Interface for Touch Events
+ */
+export interface ITouchController {
+    /**
+     * Fire when a touch event starts
+     * @param touchEvent - Touch Event Data
+     */
+    onTouchStart(touchEvent: TouchEvent): void;
+
+    /**
+     * Fire when a touch event ends
+     * @param touchEvent - Touch Event Data
+     */
+    onTouchEnd(touchEvent: TouchEvent): void;
+
+    /**
+     * Fire when touch moves
+     * @param touchEvent - Touch Event Data
+     */
+    onTouchMove(touchEvent: TouchEvent): void;
+
+    /**
+     * Unregisters all touch event handlers
+     */
+    unregisterTouchEvents(): void;
+}

package/src/Inputs/InputClassesFactory.ts

@@ -0,0 +1,140 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+import { FakeTouchController } from './FakeTouchController';
+import { KeyboardController } from './KeyboardController';
+import { MouseController } from './MouseController';
+import { TouchController } from './TouchController';
+import { GamePadController } from './GamepadController';
+import { Config, ControlSchemeType } from '../Config/Config';
+import { Logger } from '@epicgames-ps/lib-pixelstreamingcommon-ue5.5';
+import { CoordinateConverter } from '../Util/CoordinateConverter';
+import { StreamMessageController } from '../UeInstanceMessage/StreamMessageController';
+import { VideoPlayer } from '../VideoPlayer/VideoPlayer';
+
+/**
+ * Class for making and setting up input class types
+ */
+export class InputClassesFactory {
+    toStreamerMessagesProvider: StreamMessageController;
+    videoElementProvider: VideoPlayer;
+    coordinateConverter: CoordinateConverter;
+    activeKeys: ActiveKeys = new ActiveKeys();
+
+    /**
+     * @param toStreamerMessagesProvider - Stream message instance
+     * @param videoElementProvider - Video Player instance
+     * @param coordinateConverter - A coordinateConverter instance
+     */
+    constructor(
+        toStreamerMessagesProvider: StreamMessageController,
+        videoElementProvider: VideoPlayer,
+        coordinateConverter: CoordinateConverter
+    ) {
+        this.toStreamerMessagesProvider = toStreamerMessagesProvider;
+        this.videoElementProvider = videoElementProvider;
+        this.coordinateConverter = coordinateConverter;
+    }
+
+    /**
+     * Registers browser key events.
+     */
+    registerKeyBoard(config: Config) {
+        Logger.Log(Logger.GetStackTrace(), 'Register Keyboard Events', 7);
+        const keyboardController = new KeyboardController(
+            this.toStreamerMessagesProvider,
+            config,
+            this.activeKeys
+        );
+        keyboardController.registerKeyBoardEvents();
+        return keyboardController;
+    }
+
+    /**
+     * register mouse events based on a control type
+     * @param controlScheme - if the mouse is either hovering or locked
+     */
+    registerMouse(controlScheme: ControlSchemeType) {
+        Logger.Log(Logger.GetStackTrace(), 'Register Mouse Events', 7);
+        const mouseController = new MouseController(
+            this.toStreamerMessagesProvider,
+            this.videoElementProvider,
+            this.coordinateConverter,
+            this.activeKeys
+        );
+
+        switch (controlScheme) {
+            case ControlSchemeType.LockedMouse:
+                mouseController.registerLockedMouseEvents(mouseController);
+                break;
+            case ControlSchemeType.HoveringMouse:
+                mouseController.registerHoveringMouseEvents(mouseController);
+                break;
+            default:
+                Logger.Info(
+                    Logger.GetStackTrace(),
+                    'unknown Control Scheme Type Defaulting to Locked Mouse Events'
+                );
+                mouseController.registerLockedMouseEvents(mouseController);
+                break;
+        }
+
+        return mouseController;
+    }
+
+    /**
+     * register touch events
+     * @param fakeMouseTouch - the faked mouse touch event
+     */
+    registerTouch(
+        fakeMouseTouch: boolean,
+        videoElementParentClientRect: DOMRect
+    ) {
+        Logger.Log(Logger.GetStackTrace(), 'Registering Touch', 6);
+        if (fakeMouseTouch) {
+            const fakeTouchController = new FakeTouchController(
+                this.toStreamerMessagesProvider,
+                this.videoElementProvider,
+                this.coordinateConverter
+            );
+            fakeTouchController.setVideoElementParentClientRect(
+                videoElementParentClientRect
+            );
+            return fakeTouchController;
+        } else {
+            return new TouchController(
+                this.toStreamerMessagesProvider,
+                this.videoElementProvider,
+                this.coordinateConverter
+            );
+        }
+    }
+
+    /**
+     * registers a gamepad
+     */
+    registerGamePad() {
+        Logger.Log(Logger.GetStackTrace(), 'Register Game Pad', 7);
+        const gamePadController = new GamePadController(
+            this.toStreamerMessagesProvider
+        );
+        return gamePadController;
+    }
+}
+
+/**
+ * A class that keeps track of current active keys
+ */
+export class ActiveKeys {
+    activeKeys: Array<number> = [];
+    constructor() {
+        this.activeKeys = [];
+    }
+
+    /**
+     * Get the current array of active keys
+     * @returns - an array of active keys
+     */
+    getActiveKeys(): number[] {
+        return this.activeKeys;
+    }
+}