Added XR events: xrSessionStarted, xrSessionEnded, xrFrame

Frontend/library/src/PixelStreaming/PixelStreaming.ts

@@ -6,11 +6,7 @@ import { AggregatedStats } from '../PeerConnectionController/AggregatedStats';
 import { WebRtcPlayerController } from '../WebRtcPlayer/WebRtcPlayerController';
 import { Flags, NumericParameters } from '../Config/Config';
 import { Logger } from '../Logger/Logger';
-import {
-    InitialSettings,
-    EncoderSettings,
-    WebRTCSettings
-} from '../DataChannel/InitialSettings';
+import { InitialSettings } from '../DataChannel/InitialSettings';
 import { OnScreenKeyboard } from '../UI/OnScreenKeyboard';
 import {
     EventEmitter,

Frontend/library/src/Util/EventEmitter.ts

@@ -401,6 +401,45 @@ export class SettingsChangedEvent extends Event {
     }
 }
 
+/**
+ * Event emitted when an XR Session starts
+ */
+export class XrSessionStartedEvent extends Event {
+    readonly type: 'xrSessionStarted';
+    constructor() {
+        super('xrSessionStarted');
+    }
+}
+
+/**
+ * Event emitted when an XR Session ends
+ */
+export class XrSessionEndedEvent extends Event {
+    readonly type: 'xrSessionEnded';
+    constructor() {
+        super('xrSessionEnded');
+    }
+}
+
+export type XrFrameData = {
+    /** The frame timestamp  */
+    time: DOMHighResTimeStamp;
+    /** The XRFrame */
+    frame: XRFrame;
+};
+
+/**
+ * Event emitted when an XR Frame is complete
+ */
+export class XrFrameEvent extends Event {
+    readonly type: 'xrFrame';
+    readonly data: XrFrameData
+    constructor(data: XrFrameEvent['data']) {
+        super('xrFrame');
+        this.data = data;
+    }
+}
+
 export type PixelStreamingEvent =
     | AfkWarningActivateEvent
     | AfkWarningUpdateEvent
@@ -427,7 +466,10 @@ export type PixelStreamingEvent =
     | StreamerListMessageEvent
     | LatencyTestResultEvent
     | InitialSettingsEvent
-    | SettingsChangedEvent;
+    | SettingsChangedEvent
+    | XrSessionStartedEvent
+    | XrSessionEndedEvent
+    | XrFrameEvent;
 
 export class EventEmitter extends EventTarget {
     /**

Frontend/library/src/WebXR/WebXRController.ts

@@ -1,27 +1,32 @@
 // Copyright Epic Games, Inc. All Rights Reserved.
 
 import { Logger } from '../Logger/Logger';
-import { WebRtcPlayerController } from '../pixelstreamingfrontend';
+import { WebRtcPlayerController } from '../WebRtcPlayer/WebRtcPlayerController';
 import { WebGLUtils } from '../Util/WebGLUtils';
 import { Controller } from '../Inputs/GamepadTypes';
 import { XRGamepadController } from '../Inputs/XRGamepadController';
+import { XrFrameEvent } from '../Util/EventEmitter'
 
 export class WebXRController {
-    xrSession: XRSession;
-    xrRefSpace: XRReferenceSpace;
-    gl: WebGL2RenderingContext;
+    private xrSession: XRSession;
+    private xrRefSpace: XRReferenceSpace;
+    private gl: WebGL2RenderingContext;
 
-    positionLocation: number;
-    texcoordLocation: number;
-    resolutionLocation: WebGLUniformLocation;
-    offsetLocation: WebGLUniformLocation;
+    private positionLocation: number;
+    private texcoordLocation: number;
+    private resolutionLocation: WebGLUniformLocation;
+    private offsetLocation: WebGLUniformLocation;
 
-    positionBuffer: WebGLBuffer;
-    texcoordBuffer: WebGLBuffer;
+    private positionBuffer: WebGLBuffer;
+    private texcoordBuffer: WebGLBuffer;
 
-    webRtcController: WebRtcPlayerController;
-    xrGamepadController: XRGamepadController;
-    xrControllers: Array<Controller>;
+    private webRtcController: WebRtcPlayerController;
+    private xrGamepadController: XRGamepadController;
+    private xrControllers: Array<Controller>;
+
+    onSessionStarted: EventTarget;
+    onSessionEnded: EventTarget;
+    onFrame: EventTarget;
 
     constructor(webRtcPlayerController: WebRtcPlayerController) {
         this.xrSession = null;
@@ -30,6 +35,9 @@ export class WebXRController {
         this.xrGamepadController = new XRGamepadController(
             this.webRtcController.streamMessageController
         );
+        this.onSessionEnded = new EventTarget();
+        this.onSessionStarted = new EventTarget();
+        this.onFrame = new EventTarget();
     }
 
     public xrClicked() {
@@ -47,6 +55,7 @@ export class WebXRController {
     onXrSessionEnded() {
         Logger.Log(Logger.GetStackTrace(), 'XR Session ended');
         this.xrSession = null;
+        this.onSessionEnded.dispatchEvent(new Event('xrSessionEnded'));
     }
 
     onXrSessionStarted(session: XRSession) {
@@ -142,6 +151,8 @@ export class WebXRController {
                     this.onXrFrame(time, frame)
             );
         });
+
+        this.onSessionStarted.dispatchEvent(new Event('xrSessionStarted'));
     }
 
     onXrFrame(time: DOMHighResTimeStamp, frame: XRFrame) {
@@ -194,6 +205,11 @@ export class WebXRController {
             (time: DOMHighResTimeStamp, frame: XRFrame) =>
                 this.onXrFrame(time, frame)
         );
+
+        this.onFrame.dispatchEvent(new XrFrameEvent({
+            time,
+            frame
+        }));
     }
 
     private render(videoElement: HTMLVideoElement) {