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

package/{types → dist/types}/DataChannel/LatencyTestResults.d.ts

@@ -1,31 +1,31 @@
-/**
- * Latency Test Results Data
- */
-export declare class LatencyTestResults {
-    ReceiptTimeMs: number;
-    TransmissionTimeMs: number;
-    PreCaptureTimeMs: number;
-    PostCaptureTimeMs: number;
-    PreEncodeTimeMs: number;
-    PostEncodeTimeMs: number;
-    EncodeMs: number;
-    CaptureToSendMs: number;
-    testStartTimeMs: number;
-    browserReceiptTimeMs: number;
-    latencyExcludingDecode: number;
-    testDuration: number;
-    networkLatency: number;
-    browserSendLatency: number;
-    frameDisplayDeltaTimeMs: number;
-    endToEndLatency: number;
-    encodeLatency: number;
-    /**
-     * Sets the Delta Time Milliseconds
-     * @param DeltaTimeMs - Delta Time Milliseconds
-     */
-    setFrameDisplayDeltaTime(DeltaTimeMs: number): void;
-    /**
-     * Process the encoder times and set them
-     */
-    processFields(): void;
-}
+/**
+ * Latency Test Results Data
+ */
+export declare class LatencyTestResults {
+    ReceiptTimeMs: number;
+    TransmissionTimeMs: number;
+    PreCaptureTimeMs: number;
+    PostCaptureTimeMs: number;
+    PreEncodeTimeMs: number;
+    PostEncodeTimeMs: number;
+    EncodeMs: number;
+    CaptureToSendMs: number;
+    testStartTimeMs: number;
+    browserReceiptTimeMs: number;
+    latencyExcludingDecode: number;
+    testDuration: number;
+    networkLatency: number;
+    browserSendLatency: number;
+    frameDisplayDeltaTimeMs: number;
+    endToEndLatency: number;
+    encodeLatency: number;
+    /**
+     * Sets the Delta Time Milliseconds
+     * @param DeltaTimeMs - Delta Time Milliseconds
+     */
+    setFrameDisplayDeltaTime(DeltaTimeMs: number): void;
+    /**
+     * Process the encoder times and set them
+     */
+    processFields(): void;
+}

package/{types → dist/types}/FreezeFrame/FreezeFrame.d.ts

@@ -1,36 +1,36 @@
-/**
- * A class for managing the freeze frame object
- */
-export declare class FreezeFrame {
-    protected rootDiv: HTMLElement;
-    protected rootElement: HTMLDivElement;
-    imageElement: HTMLImageElement;
-    freezeFrameHeight: number;
-    freezeFrameWidth: number;
-    /**
-     * Construct a freeze frame
-     * @param rootDiv the div that a freeze frame element will be injected into
-     */
-    constructor(rootDiv: HTMLElement);
-    /**
-     * Set the freeze frame element for showing
-     */
-    setElementForShow(): void;
-    /**
-     * Set the freeze frame element for hiding
-     */
-    setElementForHide(): void;
-    /**
-     * Update the freeze frames image source
-     * @param jpeg - the freeze frame image as a byte array data
-     */
-    updateImageElementSource(jpeg: Uint8Array): void;
-    /**
-     * Set the dimensions for the freeze frame from the element and resize it
-     */
-    setDimensionsFromElementAndResize(): void;
-    /**
-     * Resize a freeze frame element
-     */
-    resize(): void;
-}
+/**
+ * A class for managing the freeze frame object
+ */
+export declare class FreezeFrame {
+    protected rootDiv: HTMLElement;
+    protected rootElement: HTMLDivElement;
+    imageElement: HTMLImageElement;
+    freezeFrameHeight: number;
+    freezeFrameWidth: number;
+    /**
+     * Construct a freeze frame
+     * @param rootDiv the div that a freeze frame element will be injected into
+     */
+    constructor(rootDiv: HTMLElement);
+    /**
+     * Set the freeze frame element for showing
+     */
+    setElementForShow(): void;
+    /**
+     * Set the freeze frame element for hiding
+     */
+    setElementForHide(): void;
+    /**
+     * Update the freeze frames image source
+     * @param jpeg - the freeze frame image as a byte array data
+     */
+    updateImageElementSource(jpeg: Uint8Array): void;
+    /**
+     * Set the dimensions for the freeze frame from the element and resize it
+     */
+    setDimensionsFromElementAndResize(): void;
+    /**
+     * Resize a freeze frame element
+     */
+    resize(): void;
+}

package/{types → dist/types}/FreezeFrame/FreezeFrameController.d.ts

@@ -1,37 +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;
-}
+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/dist/types/Inputs/GamepadController.d.ts

@@ -0,0 +1,61 @@
+import { StreamMessageController } from '../UeInstanceMessage/StreamMessageController';
+import { IInputController } from './IInputController';
+import { Controller } from './GamepadTypes';
+/**
+ * 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
+}
+/**
+ * Handles gamepad events from the document to send to the streamer.
+ */
+export declare class GamepadController implements IInputController {
+    controllers: Array<Controller>;
+    streamMessageController: StreamMessageController;
+    onGamepadConnectedListener: (event: GamepadEvent) => void;
+    onGamepadDisconnectedListener: (event: GamepadEvent) => void;
+    beforeUnloadListener: (event: Event) => void;
+    requestAnimationFrame: (callback: FrameRequestCallback) => number;
+    constructor(streamMessageController: StreamMessageController);
+    register(): void;
+    unregister(): void;
+    onGamepadResponseReceived(gamepadId: number): void;
+    private onGamepadConnected;
+    private onGamepadDisconnected;
+    private scanGamepads;
+    private updateStatus;
+    private onBeforeUnload;
+}

package/dist/types/Inputs/GamepadTypes.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The interface for controllers
+ */
+export interface Controller {
+    currentState: Gamepad;
+    prevState: Gamepad;
+    id: number | undefined;
+}
+/**
+ * Deep copies the values from a gamepad by first converting it to a JSON object and then back to a gamepad
+ *
+ * @param gamepad the original gamepad
+ * @returns a new gamepad object, populated with the original gamepads values
+ */
+export declare function deepCopyGamepad(gamepad: Gamepad): Gamepad;

package/dist/types/Inputs/IInputController.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The base interface for all input controllers.
+ * Since controllers mostly just register events and handle them the external interface is limited
+ * to register/unregister
+ */
+export interface IInputController {
+    /**
+     * Tells the controller to register itself to the events it needs to operate.
+     */
+    register(): void;
+    /**
+     * Tells the cnotroller to unregister from the events it previously registered to.
+     * No behaviour through the controller should happen past this point until register is called again.
+     */
+    unregister(): void;
+}

package/{types → dist/types}/Inputs/InputClassesFactory.d.ts

@@ -1,54 +1,53 @@
-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[];
-}
+import { KeyboardController } from './KeyboardController';
+import { MouseController } from './MouseController';
+import { GamepadController } from './GamepadController';
+import { Config, ControlSchemeType } from '../Config/Config';
+import { InputCoordTranslator } from '../Util/InputCoordTranslator';
+import { StreamMessageController } from '../UeInstanceMessage/StreamMessageController';
+import { VideoPlayer } from '../VideoPlayer/VideoPlayer';
+import { IInputController } from './IInputController';
+/**
+ * Class for making and setting up input class types
+ */
+export declare class InputClassesFactory {
+    toStreamerMessagesProvider: StreamMessageController;
+    videoElementProvider: VideoPlayer;
+    coordinateConverter: InputCoordTranslator;
+    activeKeys: ActiveKeys;
+    /**
+     * @param toStreamerMessagesProvider - Stream message instance
+     * @param videoElementProvider - Video Player instance
+     * @param coordinateConverter - A coordinateConverter instance
+     */
+    constructor(toStreamerMessagesProvider: StreamMessageController, videoElementProvider: VideoPlayer, coordinateConverter: InputCoordTranslator);
+    /**
+     * 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): IInputController;
+    /**
+     * 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/dist/types/Inputs/KeyCodes.d.ts

@@ -0,0 +1,5 @@
+interface ICodeToKeyCode {
+    [key: string]: number;
+}
+export declare const CodeToKeyCode: ICodeToKeyCode;
+export {};

package/dist/types/Inputs/KeyboardController.d.ts

@@ -0,0 +1,34 @@
+import { ActiveKeys } from './InputClassesFactory';
+import { StreamMessageController } from '../UeInstanceMessage/StreamMessageController';
+import { Config } from '../Config/Config';
+import { IInputController } from './IInputController';
+/**
+ * Handles the Keyboard Inputs for the document
+ */
+export declare class KeyboardController implements IInputController {
+    streamMessageController: StreamMessageController;
+    activeKeys: ActiveKeys;
+    config: Config;
+    onKeyDownListener: (event: KeyboardEvent) => void;
+    onKeyUpListener: (event: KeyboardEvent) => void;
+    onKeyPressListener: (event: KeyboardEvent) => void;
+    onCompositionEndListener: (event: KeyboardEvent) => void;
+    constructor(streamMessageController: StreamMessageController, config: Config, activeKeys: ActiveKeys);
+    register(): void;
+    unregister(): void;
+    private handleOnKeyDown;
+    private handleOnKeyUp;
+    private handleOnKeyPress;
+    private handleOnCompositionEnd;
+    /**
+     * Gets the Keycode of the Key pressed
+     * @param keyboardEvent - Key board Event
+     * @returns - the key code of the Key
+     */
+    private getKeycode;
+    /**
+     * Browser keys do not have a charCode so we only need to test keyCode.
+     * @param keyCode - the browser keycode number
+     */
+    private isKeyCodeBrowserKey;
+}

package/{types → dist/types}/Inputs/MouseButtons.d.ts

@@ -1,22 +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;
-}
+/**
+ * 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/dist/types/Inputs/MouseController.d.ts

@@ -0,0 +1,40 @@
+import { StreamMessageController } from '../UeInstanceMessage/StreamMessageController';
+import { InputCoordTranslator } from '../Util/InputCoordTranslator';
+import { VideoPlayer } from '../VideoPlayer/VideoPlayer';
+import type { ActiveKeys } from './InputClassesFactory';
+import { IInputController } from './IInputController';
+/**
+ * Extra types for Document and WheelEvent
+ */
+declare global {
+    interface Document {
+        mozPointerLockElement: unknown;
+        mozExitPointerLock?(): void;
+    }
+    interface WheelEvent {
+        wheelDelta: number;
+    }
+}
+/**
+ * The base class for mouse controllers. Since there is a bunch of shared behaviour between locked and
+ * hover mouse controllers this is where that shared behaviour lives.
+ */
+export declare class MouseController implements IInputController {
+    videoPlayer: VideoPlayer;
+    streamMessageController: StreamMessageController;
+    coordinateConverter: InputCoordTranslator;
+    activeKeys: ActiveKeys;
+    onEnterListener: (event: MouseEvent) => void;
+    onLeaveListener: (event: MouseEvent) => void;
+    constructor(streamMessageController: StreamMessageController, videoPlayer: VideoPlayer, coordinateConverter: InputCoordTranslator, activeKeys: ActiveKeys);
+    register(): void;
+    unregister(): void;
+    registerMouseEnterAndLeaveEvents(): void;
+    unregisterMouseEnterAndLeaveEvents(): void;
+    private onMouseEnter;
+    private onMouseLeave;
+    private releaseMouseButtons;
+    private pressMouseButtons;
+    private sendMouseDown;
+    private sendMouseUp;
+}

package/dist/types/Inputs/MouseControllerHovering.d.ts

@@ -0,0 +1,26 @@
+import { StreamMessageController } from '../UeInstanceMessage/StreamMessageController';
+import { InputCoordTranslator } from '../Util/InputCoordTranslator';
+import { VideoPlayer } from '../VideoPlayer/VideoPlayer';
+import type { ActiveKeys } from './InputClassesFactory';
+import { MouseController } from './MouseController';
+/**
+ * A mouse controller that allows the mouse to freely float over the video document.
+ */
+export declare class MouseControllerHovering extends MouseController {
+    videoElementParent: HTMLDivElement;
+    onMouseUpListener: (event: MouseEvent) => void;
+    onMouseDownListener: (event: MouseEvent) => void;
+    onMouseDblClickListener: (event: MouseEvent) => void;
+    onMouseWheelListener: (event: WheelEvent) => void;
+    onMouseMoveListener: (event: MouseEvent) => void;
+    onContextMenuListener: (event: MouseEvent) => void;
+    constructor(streamMessageController: StreamMessageController, videoPlayer: VideoPlayer, coordinateConverter: InputCoordTranslator, activeKeys: ActiveKeys);
+    register(): void;
+    unregister(): void;
+    private onMouseDown;
+    private onMouseUp;
+    private onContextMenu;
+    private onMouseMove;
+    private onMouseWheel;
+    private onMouseDblClick;
+}

package/dist/types/Inputs/MouseControllerLocked.d.ts

@@ -0,0 +1,31 @@
+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 declare class MouseControllerLocked extends MouseController {
+    videoElementParent: HTMLDivElement;
+    x: number;
+    y: number;
+    normalizedCoord: TranslatedCoordUnsigned;
+    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);
+    register(): void;
+    unregister(): void;
+    private onRequestLock;
+    private onLockStateChange;
+    private onMouseDown;
+    private onMouseUp;
+    private onMouseMove;
+    private onMouseWheel;
+    private onMouseDblClick;
+}

package/{types → dist/types}/Inputs/SpecialKeyCodes.d.ts

@@ -1,14 +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;
-}
+/**
+ * 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;
+}

package/dist/types/Inputs/TouchController.d.ts

@@ -0,0 +1,28 @@
+import { InputCoordTranslator } from '../Util/InputCoordTranslator';
+import { StreamMessageController } from '../UeInstanceMessage/StreamMessageController';
+import { VideoPlayer } from '../VideoPlayer/VideoPlayer';
+import { IInputController } from './IInputController';
+/**
+ * The basic touch controller that handles the touch events on the document.
+ */
+export declare class TouchController implements IInputController {
+    streamMessageController: StreamMessageController;
+    videoPlayer: VideoPlayer;
+    coordinateConverter: InputCoordTranslator;
+    videoElementParent: HTMLVideoElement;
+    fingers: number[];
+    fingerIds: Map<any, any>;
+    maxByteValue: number;
+    onTouchStartListener: (event: TouchEvent) => void;
+    onTouchEndListener: (event: TouchEvent) => void;
+    onTouchMoveListener: (event: TouchEvent) => void;
+    constructor(streamMessageController: StreamMessageController, videoPlayer: VideoPlayer, coordinateConverter: InputCoordTranslator);
+    register(): void;
+    unregister(): void;
+    private rememberTouch;
+    private forgetTouch;
+    private onTouchStart;
+    private onTouchEnd;
+    private onTouchMove;
+    private emitTouchData;
+}