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

package/src/Inputs/LockedMouseEvents.ts

@@ -1,287 +0,0 @@
-// Copyright Epic Games, Inc. All Rights Reserved.
-
-import { MouseController } from './MouseController';
-import { Logger } from '@epicgames-ps/lib-pixelstreamingcommon-ue5.5';
-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 to unregister 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
-            );
-    }
-
-    /**
-     * Unregister 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/Util/CoordinateConverter.ts

@@ -1,290 +0,0 @@
-// Copyright Epic Games, Inc. All Rights Reserved.
-
-import { Logger } from '@epicgames-ps/lib-pixelstreamingcommon-ue5.5';
-import { VideoPlayer } from '../VideoPlayer/VideoPlayer';
-
-/**
- * Converts coordinates from element relative coordinates to values normalized within the value range of a short (and back again)
- */
-export class CoordinateConverter {
-    videoElementProvider: VideoPlayer;
-    videoElementParent: HTMLElement;
-    videoElement: HTMLVideoElement;
-    ratio: number;
-
-    normalizeAndQuantizeUnsignedFunc: (
-        x: number,
-        y: number
-    ) => NormalizedQuantizedUnsignedCoord;
-    normalizeAndQuantizeSignedFunc: (
-        x: number,
-        y: number
-    ) => NormalizedQuantizedSignedCoord;
-    denormalizeAndUnquantizeUnsignedFunc: (
-        x: number,
-        y: number
-    ) => UnquantizedDenormalizedUnsignedCoord;
-
-    /**
-     * @param videoElementProvider - the div element that the video player will be injected into
-     */
-    constructor(videoElementProvider: VideoPlayer) {
-        this.videoElementProvider = videoElementProvider;
-        this.normalizeAndQuantizeUnsignedFunc = () => {
-            throw new Error(
-                'Normalize and quantize unsigned, method not implemented.'
-            );
-        };
-        this.normalizeAndQuantizeSignedFunc = () => {
-            throw new Error(
-                'Normalize and unquantize signed, method not implemented.'
-            );
-        };
-        this.denormalizeAndUnquantizeUnsignedFunc = () => {
-            throw new Error(
-                'Denormalize and unquantize unsigned, method not implemented.'
-            );
-        };
-    }
-
-    /**
-     * The surface method for setterNormalizeAndQuantizeUnsigned
-     * @param x - x axis point
-     * @param y - y axis point
-     */
-    normalizeAndQuantizeUnsigned(
-        x: number,
-        y: number
-    ): NormalizedQuantizedUnsignedCoord {
-        return this.normalizeAndQuantizeUnsignedFunc(x, y);
-    }
-
-    /**
-     * The surface method for setterUnquantizeAndDenormalizeUnsigned
-     * @param x - x axis point
-     * @param y - y axis point
-     */
-    unquantizeAndDenormalizeUnsigned(
-        x: number,
-        y: number
-    ): UnquantizedDenormalizedUnsignedCoord {
-        return this.denormalizeAndUnquantizeUnsignedFunc(x, y);
-    }
-
-    /**
-     * The surface method for setterNormalizeAndQuantizeSigned
-     * @param x - x axis point
-     * @param y - y axis point
-     */
-    normalizeAndQuantizeSigned(
-        x: number,
-        y: number
-    ): NormalizedQuantizedSignedCoord {
-        return this.normalizeAndQuantizeSignedFunc(x, y);
-    }
-
-    /**
-     * set up the Normalize And Quantize methods based on the aspect ratio and the video player ratio
-     */
-    setupNormalizeAndQuantize() {
-        this.videoElementParent =
-            this.videoElementProvider.getVideoParentElement();
-        this.videoElement = this.videoElementProvider.getVideoElement();
-
-        if (this.videoElementParent && this.videoElement) {
-            const playerWidth = this.videoElementParent.clientWidth || 1;
-            const playerHeight = this.videoElementParent.clientHeight || 1;
-            const videoWidth = this.videoElement.videoWidth || 1;
-            const videoHeight = this.videoElement.videoHeight || 1;
-            const playerAspectRatio = playerHeight / playerWidth;
-            const videoAspectRatio = videoHeight / videoWidth;
-            if (playerAspectRatio > videoAspectRatio) {
-                Logger.Log(
-                    Logger.GetStackTrace(),
-                    'Setup Normalize and Quantize for playerAspectRatio > videoAspectRatio',
-                    6
-                );
-                this.ratio = playerAspectRatio / videoAspectRatio;
-                this.normalizeAndQuantizeUnsignedFunc = (
-                    x: number,
-                    y: number
-                ) => this.normalizeAndQuantizeUnsignedPlayerBigger(x, y);
-                this.normalizeAndQuantizeSignedFunc = (x: number, y: number) =>
-                    this.normalizeAndQuantizeSignedPlayerBigger(x, y);
-                this.denormalizeAndUnquantizeUnsignedFunc = (
-                    x: number,
-                    y: number
-                ) => this.denormalizeAndUnquantizeUnsignedPlayerBigger(x, y);
-            } else {
-                Logger.Log(
-                    Logger.GetStackTrace(),
-                    'Setup Normalize and Quantize for playerAspectRatio <= videoAspectRatio',
-                    6
-                );
-                this.ratio = videoAspectRatio / playerAspectRatio;
-                this.normalizeAndQuantizeUnsignedFunc = (
-                    x: number,
-                    y: number
-                ) => this.normalizeAndQuantizeUnsignedPlayerSmaller(x, y);
-                this.normalizeAndQuantizeSignedFunc = (x: number, y: number) =>
-                    this.normalizeAndQuantizeSignedPlayerSmaller(x, y);
-                this.denormalizeAndUnquantizeUnsignedFunc = (
-                    x: number,
-                    y: number
-                ) => this.denormalizeAndUnquantizeUnsignedPlayerSmaller(x, y);
-            }
-        }
-    }
-
-    /**
-     * normalizeAndQuantizeUnsigned for playerAspectRatio > videoAspectRatio
-     * @param x - x axis point
-     * @param y - y axis point
-     */
-    normalizeAndQuantizeUnsignedPlayerBigger(
-        x: number,
-        y: number
-    ): NormalizedQuantizedUnsignedCoord {
-        const normalizedX = x / this.videoElementParent.clientWidth;
-        const normalizedY =
-            this.ratio * (y / this.videoElementParent.clientHeight - 0.5) + 0.5;
-        if (
-            normalizedX < 0.0 ||
-            normalizedX > 1.0 ||
-            normalizedY < 0.0 ||
-            normalizedY > 1.0
-        ) {
-            return new NormalizedQuantizedUnsignedCoord(false, 65535, 65535);
-        } else {
-            return new NormalizedQuantizedUnsignedCoord(
-                true,
-                normalizedX * 65536,
-                normalizedY * 65536
-            );
-        }
-    }
-
-    /**
-     * unquantizeAndDenormalizeUnsigned for playerAspectRatio > videoAspectRatio
-     * @param x - x axis point
-     * @param y - y axis point
-     */
-    denormalizeAndUnquantizeUnsignedPlayerBigger(x: number, y: number) {
-        const normalizedX = x / 65536;
-        const normalizedY = (y / 65536 - 0.5) / this.ratio + 0.5;
-        return new UnquantizedDenormalizedUnsignedCoord(
-            normalizedX * this.videoElementParent.clientWidth,
-            normalizedY * this.videoElementParent.clientHeight
-        );
-    }
-
-    /**
-     * normalizeAndQuantizeSigned for playerAspectRatio > videoAspectRatio
-     * @param x - x axis point
-     * @param y - y axis point
-     */
-    normalizeAndQuantizeSignedPlayerBigger(x: number, y: number) {
-        const normalizedX = x / (0.5 * this.videoElementParent.clientWidth);
-        const normalizedY =
-            (this.ratio * y) / (0.5 * this.videoElementParent.clientHeight);
-        return new NormalizedQuantizedSignedCoord(
-            normalizedX * 32767,
-            normalizedY * 32767
-        );
-    }
-
-    /**
-     * normalizeAndQuantizeUnsigned for playerAspectRatio <= videoAspectRatio
-     * @param x - x axis point
-     * @param y - y axis point
-     */
-    normalizeAndQuantizeUnsignedPlayerSmaller(x: number, y: number) {
-        const normalizedX =
-            this.ratio * (x / this.videoElementParent.clientWidth - 0.5) + 0.5;
-        const normalizedY = y / this.videoElementParent.clientHeight;
-        if (
-            normalizedX < 0.0 ||
-            normalizedX > 1.0 ||
-            normalizedY < 0.0 ||
-            normalizedY > 1.0
-        ) {
-            return new NormalizedQuantizedUnsignedCoord(false, 65535, 65535);
-        } else {
-            return new NormalizedQuantizedUnsignedCoord(
-                true,
-                normalizedX * 65536,
-                normalizedY * 65536
-            );
-        }
-    }
-
-    /**
-     * unquantizeAndDenormalizeUnsigned for playerAspectRatio <= videoAspectRatio
-     * @param x - x axis point
-     * @param y - y axis point
-     */
-    denormalizeAndUnquantizeUnsignedPlayerSmaller(x: number, y: number) {
-        const normalizedX = (x / 65536 - 0.5) / this.ratio + 0.5;
-        const normalizedY = y / 65536;
-        return new UnquantizedDenormalizedUnsignedCoord(
-            normalizedX * this.videoElementParent.clientWidth,
-            normalizedY * this.videoElementParent.clientHeight
-        );
-    }
-
-    /**
-     * normalizeAndQuantizeSigned for playerAspectRatio <= videoAspectRatio
-     * @param x - x axis point
-     * @param y - y axis point
-     */
-    normalizeAndQuantizeSignedPlayerSmaller(x: number, y: number) {
-        const normalizedX =
-            (this.ratio * x) / (0.5 * this.videoElementParent.clientWidth);
-        const normalizedY = y / (0.5 * this.videoElementParent.clientHeight);
-        return new NormalizedQuantizedSignedCoord(
-            normalizedX * 32767,
-            normalizedY * 32767
-        );
-    }
-}
-
-/**
- * A class for NormalizeAndQuantizeUnsigned objects
- */
-export class NormalizedQuantizedUnsignedCoord {
-    inRange: boolean;
-    x: number;
-    y: number;
-
-    constructor(inRange: boolean, x: number, y: number) {
-        this.inRange = inRange;
-        this.x = x;
-        this.y = y;
-    }
-}
-
-/**
- * A class for UnquantizedAndDenormalizeUnsigned objects
- */
-export class UnquantizedDenormalizedUnsignedCoord {
-    x: number;
-    y: number;
-
-    constructor(x: number, y: number) {
-        this.x = x;
-        this.y = y;
-    }
-}
-
-/**
- * A class for NormalizedQuantizedSignedCoord objects
- */
-export class NormalizedQuantizedSignedCoord {
-    x: number;
-    y: number;
-
-    constructor(x: number, y: number) {
-        this.x = x;
-        this.y = y;
-    }
-}

package/src/Util/EventListenerTracker.ts

@@ -1,29 +0,0 @@
-// Copyright Epic Games, Inc. All Rights Reserved.
-
-export type UnregisterFunction = () => void;
-
-export class EventListenerTracker {
-    private unregisterCallbacks: UnregisterFunction[];
-
-    constructor() {
-        this.unregisterCallbacks = [];
-    }
-
-    /**
-     * Add a new callback that is executed when unregisterAll is called.
-     * @param callback 
-     */
-    addUnregisterCallback(callback: UnregisterFunction) {
-        this.unregisterCallbacks.push(callback);
-    }
-
-    /**
-     * Execute all callbacks and clear the list.
-     */
-    unregisterAll() {
-        for (const callback of this.unregisterCallbacks) {
-            callback();
-        }
-        this.unregisterCallbacks = [];
-    }
-}

package/types/Inputs/FakeTouchController.d.ts

@@ -1,61 +0,0 @@
-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);
-}