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

package/types/FreezeFrame/FreezeFrameController.d.ts

@@ -0,0 +1,37 @@
+import { FreezeFrame } from './FreezeFrame';
+/**
+ * A class for controlling freeze frame functionality
+ */
+export declare class FreezeFrameController {
+    freezeFrame: FreezeFrame;
+    receiving: boolean;
+    size: number;
+    jpeg: Uint8Array;
+    valid: boolean;
+    freezeFrameDelay: number;
+    /**
+     * Construct a freeze frame controller
+     * @param rootDiv - the div that a freeze frame element will be injected into
+     */
+    constructor(rootDiv: HTMLElement);
+    /**
+     * Show the freeze frame if it is valid
+     */
+    showFreezeFrame(): void;
+    /**
+     * Hide the freeze frame and set the validity to false
+     */
+    hideFreezeFrame(): void;
+    /**
+     * Update the freeze frames image source and load it
+     * @param jpeg - the freeze frame image as a byte array data
+     * @param onLoadCallBack - a call back for managing if the play overlay needs to be shown or not
+     */
+    updateFreezeFrameAndShow(jpeg: Uint8Array, onLoadCallBack: () => void): void;
+    /**
+     * Process the new freeze frame image and update it
+     * @param view - the freeze frame image as a byte array data
+     * @param onLoadCallBack - a call back for managing if the play overlay needs to be shown or not
+     */
+    processFreezeFrameMessage(view: Uint8Array, onLoadCallBack: () => void): void;
+}

package/types/Inputs/FakeTouchController.d.ts

@@ -0,0 +1,61 @@
+import { CoordinateConverter } from '../Util/CoordinateConverter';
+import { StreamMessageController } from '../UeInstanceMessage/StreamMessageController';
+import { VideoPlayer } from '../VideoPlayer/VideoPlayer';
+import { ITouchController } from './ITouchController';
+/**
+ * Allows for the usage of fake touch events and implements ITouchController
+ * @param dataChannelController - The controller for the Data channel
+ * @param videoElementParent - The video player DOM element
+ */
+export declare class FakeTouchController implements ITouchController {
+    fakeTouchFinger: FakeTouchFinger;
+    toStreamerMessagesProvider: StreamMessageController;
+    videoElementProvider: VideoPlayer;
+    coordinateConverter: CoordinateConverter;
+    videoElementParentClientRect: DOMRect;
+    private touchEventListenerTracker;
+    /**
+     * @param toStreamerMessagesProvider - Stream message instance
+     * @param videoElementProvider - Video element instance
+     * @param coordinateConverter - A coordinate converter instance
+     */
+    constructor(toStreamerMessagesProvider: StreamMessageController, videoElementProvider: VideoPlayer, coordinateConverter: CoordinateConverter);
+    /**
+     * Unregister all touch events
+     */
+    unregisterTouchEvents(): void;
+    /**
+     * Sets the video Element Parent Client Rect numbers for this class
+     * @param videoElementParentClientRect - a html ElementParentClientRect object
+     */
+    setVideoElementParentClientRect(videoElementParentClientRect: DOMRect): void;
+    /**
+     * When a touch event begins
+     * @param touch - the activating touch event
+     */
+    onTouchStart(touch: TouchEvent): void;
+    /**
+     * When a touch event ends
+     * @param touchEvent - the activating touch event
+     */
+    onTouchEnd(touchEvent: TouchEvent): void;
+    /**
+     * On a Move touch event
+     * @param touchEvent - the activating touch event
+     */
+    onTouchMove(touchEvent: TouchEvent): void;
+}
+/**
+ * The interface for finger position mapping
+ */
+export declare class FakeTouchFinger {
+    id: number;
+    x: number;
+    y: number;
+    /**
+     * @param id - the button id
+     * @param x - the x axis value
+     * @param y - the y axis value
+     */
+    constructor(id: number, x: number, y: number);
+}

package/types/Inputs/GamepadController.d.ts

@@ -0,0 +1,85 @@
+import { StreamMessageController } from '../UeInstanceMessage/StreamMessageController';
+import { Controller } from './GamepadTypes';
+/**
+ * The class that handles the functionality of gamepads and controllers
+ */
+export declare class GamePadController {
+    controllers: Array<Controller>;
+    requestAnimationFrame: (callback: FrameRequestCallback) => number;
+    toStreamerMessagesProvider: StreamMessageController;
+    private gamePadEventListenerTracker;
+    /**
+     * @param toStreamerMessagesProvider - Stream message instance
+     */
+    constructor(toStreamerMessagesProvider: StreamMessageController);
+    /**
+     * Unregisters all event handlers
+     */
+    unregisterGamePadEvents(): void;
+    /**
+     * Connects the gamepad handler
+     * @param gamePadEvent - the activating gamepad event
+     */
+    gamePadConnectHandler(gamePadEvent: GamepadEvent): void;
+    /**
+     * Disconnects the gamepad handler
+     * @param gamePadEvent - the activating gamepad event
+     */
+    gamePadDisconnectHandler(gamePadEvent: GamepadEvent): void;
+    /**
+     * Scan for connected gamepads
+     */
+    scanGamePads(): void;
+    /**
+     * Updates the status of the gamepad and sends the inputs
+     */
+    updateStatus(): void;
+    onGamepadResponseReceived(gamepadId: number): void;
+    /**
+     * Event to send the gamepadconnected message to the application
+     */
+    onGamepadConnected(): void;
+    /**
+     * Event to send the gamepaddisconnected message to the application
+     */
+    onGamepadDisconnected(controllerIdx: number): void;
+    onBeforeUnload(ev: Event): void;
+}
+/**
+ * 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
+ */
+export declare 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,
+    LeftStickHorizontal = 0,
+    LeftStickVertical = 1,
+    RightStickHorizontal = 2,
+    RightStickVertical = 3
+}

package/types/Inputs/GamepadTypes.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The interface for controllers
+ */
+export interface Controller {
+    currentState: Gamepad;
+    prevState: Gamepad;
+    id: number | undefined;
+}

package/types/Inputs/HoveringMouseEvents.d.ts

@@ -0,0 +1,56 @@
+import { MouseController } from './MouseController';
+import { IMouseEvents } from './IMouseEvents';
+/**
+ * Video Player mouse Hover handler
+ */
+export declare class HoveringMouseEvents implements IMouseEvents {
+    mouseController: MouseController;
+    /**
+     * @param mouseController - Mouse Controller instance
+     */
+    constructor(mouseController: MouseController);
+    /**
+     * Unregister event handlers
+     */
+    unregisterMouseEvents(): void;
+    /**
+     * Handle the mouse move event, sends the mouse data to the UE Instance
+     * @param mouseEvent - Mouse Event
+     */
+    updateMouseMovePosition(mouseEvent: MouseEvent): void;
+    /**
+     * Handle the mouse Down event, sends the mouse data to the UE Instance
+     * @param mouseEvent - Mouse Event
+     */
+    handleMouseDown(mouseEvent: MouseEvent): void;
+    /**
+     * Handle the mouse Up event, sends the mouse data to the UE Instance
+     * @param mouseEvent - Mouse Event
+     */
+    handleMouseUp(mouseEvent: MouseEvent): void;
+    /**
+     * 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): void;
+    /**
+     * Handle the mouse wheel event, sends the mouse wheel data to the UE Instance
+     * @param wheelEvent - Mouse Event
+     */
+    handleMouseWheel(wheelEvent: WheelEvent): void;
+    /**
+     * Handle the mouse double click event, sends the mouse data to the UE Instance
+     * @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;
+}

package/types/Inputs/IMouseEvents.d.ts

@@ -0,0 +1,53 @@
+/**
+ * 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/types/Inputs/ITouchController.d.ts

@@ -0,0 +1,24 @@
+/**
+ * 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/types/Inputs/InputClassesFactory.d.ts

@@ -0,0 +1,54 @@
+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 { CoordinateConverter } from '../Util/CoordinateConverter';
+import { StreamMessageController } from '../UeInstanceMessage/StreamMessageController';
+import { VideoPlayer } from '../VideoPlayer/VideoPlayer';
+/**
+ * Class for making and setting up input class types
+ */
+export declare class InputClassesFactory {
+    toStreamerMessagesProvider: StreamMessageController;
+    videoElementProvider: VideoPlayer;
+    coordinateConverter: CoordinateConverter;
+    activeKeys: ActiveKeys;
+    /**
+     * @param toStreamerMessagesProvider - Stream message instance
+     * @param videoElementProvider - Video Player instance
+     * @param coordinateConverter - A coordinateConverter instance
+     */
+    constructor(toStreamerMessagesProvider: StreamMessageController, videoElementProvider: VideoPlayer, coordinateConverter: CoordinateConverter);
+    /**
+     * Registers browser key events.
+     */
+    registerKeyBoard(config: Config): KeyboardController;
+    /**
+     * register mouse events based on a control type
+     * @param controlScheme - if the mouse is either hovering or locked
+     */
+    registerMouse(controlScheme: ControlSchemeType): MouseController;
+    /**
+     * register touch events
+     * @param fakeMouseTouch - the faked mouse touch event
+     */
+    registerTouch(fakeMouseTouch: boolean, videoElementParentClientRect: DOMRect): FakeTouchController | TouchController;
+    /**
+     * registers a gamepad
+     */
+    registerGamePad(): GamePadController;
+}
+/**
+ * A class that keeps track of current active keys
+ */
+export declare class ActiveKeys {
+    activeKeys: Array<number>;
+    constructor();
+    /**
+     * Get the current array of active keys
+     * @returns - an array of active keys
+     */
+    getActiveKeys(): number[];
+}

package/types/Inputs/KeyboardController.d.ts

@@ -0,0 +1,62 @@
+import { ActiveKeys } from './InputClassesFactory';
+import { StreamMessageController } from '../UeInstanceMessage/StreamMessageController';
+import { Config } from '../Config/Config';
+interface ICodeToKeyCode {
+    [key: string]: number;
+}
+/**
+ * Handles the Keyboard Inputs for the document
+ */
+export declare class KeyboardController {
+    toStreamerMessagesProvider: StreamMessageController;
+    activeKeysProvider: ActiveKeys;
+    config: Config;
+    private keyboardEventListenerTracker;
+    CodeToKeyCode: ICodeToKeyCode;
+    /**
+     * @param toStreamerMessagesProvider Stream message provider class object
+     * @param config The applications configuration. We're interested in the suppress browser keys option
+     * @param activeKeysProvider Active keys provider class object
+     */
+    constructor(toStreamerMessagesProvider: StreamMessageController, config: Config, activeKeysProvider: ActiveKeys);
+    /**
+     * Registers document keyboard events with the controller
+     */
+    registerKeyBoardEvents(): void;
+    /**
+     * Unregisters document keyboard events
+     */
+    unregisterKeyBoardEvents(): void;
+    /**
+     * Handles When a key is down
+     * @param keyboardEvent - Keyboard event
+     */
+    handleOnKeyDown(keyboardEvent: KeyboardEvent): void;
+    /**
+     * handles when a key is up
+     * @param keyboardEvent - Keyboard event
+     */
+    handleOnKeyUp(keyboardEvent: KeyboardEvent): void;
+    /**
+     * Handles when a key is press
+     * @param keyboard - Keyboard Event
+     */
+    handleOnKeyPress(keyboard: KeyboardEvent): void;
+    /**
+     * Handle whenever composition ends (eg chinese simplified)
+     * @param compositionEvent - the composition event
+     */
+    handleOnCompositionEnd(compositionEvent: CompositionEvent): void;
+    /**
+     * Gets the Keycode of the Key pressed
+     * @param keyboardEvent - Key board Event
+     * @returns - the key code of the Key
+     */
+    getKeycode(keyboardEvent: KeyboardEvent): number;
+    /**
+     * Browser keys do not have a charCode so we only need to test keyCode.
+     * @param keyCode - the browser keycode number
+     */
+    isKeyCodeBrowserKey(keyCode: number): boolean;
+}
+export {};

package/types/Inputs/LockedMouseEvents.d.ts

@@ -0,0 +1,80 @@
+import { MouseController } from './MouseController';
+import { IMouseEvents } from './IMouseEvents';
+import { NormalizedQuantizedUnsignedCoord } from '../Util/CoordinateConverter';
+import { ActiveKeys } from './InputClassesFactory';
+import { VideoPlayer } from '../VideoPlayer/VideoPlayer';
+/**
+ * Handle the mouse locked events
+ */
+export declare class LockedMouseEvents implements IMouseEvents {
+    x: number;
+    y: number;
+    coord: NormalizedQuantizedUnsignedCoord;
+    videoElementProvider: VideoPlayer;
+    mouseController: MouseController;
+    activeKeysProvider: ActiveKeys;
+    updateMouseMovePositionEvent: (mouseEvent: MouseEvent) => void;
+    private mouseEventListenerTracker;
+    /**
+     * @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);
+    /**
+     * Unregisters all event handlers
+     */
+    unregisterMouseEvents(): void;
+    /**
+     * Handle when the locked state Changed
+     */
+    lockStateChange(): void;
+    /**
+     * Handle the mouse move event, sends the mouse data to the UE Instance
+     * @param mouseEvent - Mouse Event
+     */
+    updateMouseMovePosition(mouseEvent: MouseEvent): void;
+    /**
+     * Handle the mouse Down event, sends the mouse data to the UE Instance
+     * @param mouseEvent - Mouse Event
+     */
+    handleMouseDown(mouseEvent: MouseEvent): void;
+    /**
+     * Handle the mouse Up event, sends the mouse data to the UE Instance
+     * @param mouseEvent - Mouse Event
+     */
+    handleMouseUp(mouseEvent: MouseEvent): void;
+    /**
+     * Handle the mouse wheel event, sends the mouse wheel data to the UE Instance
+     * @param wheelEvent - Mouse Event
+     */
+    handleMouseWheel(wheelEvent: WheelEvent): void;
+    /**
+     * Handle the mouse double click event, sends the mouse data to the UE Instance
+     * @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;
+}
+/**
+ * Extra types for Document and WheelEvent
+ */
+declare global {
+    interface Document {
+        mozPointerLockElement: unknown;
+        mozExitPointerLock?(): void;
+    }
+    interface WheelEvent {
+        wheelDelta: number;
+    }
+}

package/types/Inputs/MouseButtons.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Mouse Button Data
+ * {@link https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/button}
+ */
+export declare class MouseButton {
+    static mainButton: number;
+    static auxiliaryButton: number;
+    static secondaryButton: number;
+    static fourthButton: number;
+    static fifthButton: number;
+}
+/**
+ * Mouse Button Mask Data
+ * {@link https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/buttons}
+ */
+export declare class MouseButtonsMask {
+    static primaryButton: number;
+    static secondaryButton: number;
+    static auxiliaryButton: number;
+    static fourthButton: number;
+    static fifthButton: number;
+}

package/types/Inputs/MouseController.d.ts

@@ -0,0 +1,75 @@
+import { StreamMessageController } from '../UeInstanceMessage/StreamMessageController';
+import { CoordinateConverter } from '../Util/CoordinateConverter';
+import { VideoPlayer } from '../VideoPlayer/VideoPlayer';
+import type { ActiveKeys } from './InputClassesFactory';
+/**
+ * Handles the Mouse Inputs for the document
+ */
+export declare class MouseController {
+    videoElementProvider: VideoPlayer;
+    toStreamerMessagesProvider: StreamMessageController;
+    coordinateConverter: CoordinateConverter;
+    activeKeysProvider: ActiveKeys;
+    private mouseEventListenerTracker;
+    /**
+     * @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);
+    /**
+     * Clears all the click events on the current video element parent div
+     */
+    unregisterMouseEvents(): void;
+    /**
+     * Register a locked mouse class
+     * @param mouseController - a mouse controller instance
+     * @param playerStyleAttributesProvider - a player style attributes instance
+     */
+    registerLockedMouseEvents(mouseController: MouseController): void;
+    /**
+     * Register a hovering mouse class
+     * @param mouseController - A mouse controller object
+     */
+    registerHoveringMouseEvents(mouseController: MouseController): void;
+    /**
+     * Set the mouse enter and mouse leave events
+     */
+    registerMouseEnterAndLeaveEvents(): void;
+    /**
+     * 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): void;
+    /**
+     * 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): void;
+    /**
+     * Handles mouse enter
+     */
+    sendMouseEnter(): void;
+    /**
+     * Handles mouse Leave
+     */
+    sendMouseLeave(): void;
+    /**
+     * 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): void;
+    /**
+     * 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): void;
+}

package/types/Inputs/SpecialKeyCodes.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 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 declare class SpecialKeyCodes {
+    static backSpace: number;
+    static shift: number;
+    static control: number;
+    static alt: number;
+    static rightShift: number;
+    static rightControl: number;
+    static rightAlt: number;
+}