WebXR declaration update

src/LibDeclarations/webxr.d.ts

@@ -1,19 +1,42 @@
+/**
+ * The session modes available
+ */
 type XRSessionMode = "inline" | "immersive-vr" | "immersive-ar";
 
+/**
+ * The different reference types
+ */
 type XRReferenceSpaceType = "viewer" | "local" | "local-floor" | "bounded-floor" | "unbounded";
 
 type XREnvironmentBlendMode = "opaque" | "additive" | "alpha-blend";
 
 type XRVisibilityState = "visible" | "visible-blurred" | "hidden";
 
+/**
+ * Handedness types
+ */
 type XRHandedness = "none" | "left" | "right";
 
+/**
+ * InputSOurce target ray modes
+ */
 type XRTargetRayMode = "gaze" | "tracked-pointer" | "screen";
 
+/**
+ * Eye types
+ */
 type XREye = "none" | "left" | "right";
 
+/**
+ * Type of events available to eh XR session
+ */
 type XREventType = "devicechange" | "visibilitychange" | "end" | "inputsourceschange" | "select" | "selectstart" | "selectend" | "squeeze" | "squeezestart" | "squeezeend" | "reset";
 
+type XRPlaneSet = Set<XRPlane>;
+type XRAnchorSet = Set<XRAnchor>;
+
+type XREventHandler = (callback: T) => void;
+
 interface XRSpace extends EventTarget {}
 
 interface XRRenderState {
@@ -24,13 +47,13 @@ interface XRRenderState {
 }
 
 interface XRInputSource {
-    handedness: XRHandedness;
-    targetRayMode: XRTargetRayMode;
-    targetRaySpace: XRSpace;
-    gripSpace: XRSpace | undefined;
-    gamepad: Gamepad | undefined;
-    profiles: Array<string>;
-    hand: XRHand | undefined;
+    readonly handedness: XRHandedness;
+    readonly targetRayMode: XRTargetRayMode;
+    readonly targetRaySpace: XRSpace;
+    readonly gripSpace?: XRSpace;
+    readonly gamepad?: Gamepad;
+    readonly profiles: Array<string>;
+    readonly hand?: XRHand;
 }
 
 interface XRSessionInit {
@@ -39,8 +62,8 @@ interface XRSessionInit {
 }
 
 interface XRSession {
-    addEventListener: Function;
-    removeEventListener: Function;
+    addEventListener<T extends Event>(type: XREventType, listener: XREventHandler, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<T extends Event>(type: XREventType, listener: XREventHandler, options?: boolean | EventListenerOptions): void;
     requestReferenceSpace(type: XRReferenceSpaceType): Promise<XRReferenceSpace>;
     updateRenderState(XRRenderStateInit: XRRenderState): Promise<void>;
     requestAnimationFrame: Function;
@@ -48,15 +71,25 @@ interface XRSession {
     renderState: XRRenderState;
     inputSources: Array<XRInputSource>;
 
+    onend: XREventHandler;
+    oninputsourceschange: XREventHandler;
+    onselect: XREventHandler;
+    onselectstart: XREventHandler;
+    onselectend: XREventHandler;
+    onsqueeze: XREventHandler;
+    onsqueezestart: XREventHandler;
+    onsqueezeend: XREventHandler;
+    onvisibilitychange: XREventHandler;
+
     // hit test
-    requestHitTestSource(options: XRHitTestOptionsInit): Promise<XRHitTestSource>;
-    requestHitTestSourceForTransientInput(options: XRTransientInputHitTestOptionsInit): Promise<XRTransientInputHitTestSource>;
+    requestHitTestSource?(options: XRHitTestOptionsInit): Promise<XRHitTestSource>;
+    requestHitTestSourceForTransientInput?(options: XRTransientInputHitTestOptionsInit): Promise<XRTransientInputHitTestSource>;
 
     // legacy AR hit test
-    requestHitTest(ray: XRRay, referenceSpace: XRReferenceSpace): Promise<XRHitResult[]>;
+    requestHitTest?(ray: XRRay, referenceSpace: XRReferenceSpace): Promise<XRHitResult[]>;
 
     // legacy plane detection
-    updateWorldTrackingState(options: { planeDetectionState?: { enabled: boolean } }): void;
+    updateWorldTrackingState?(options: { planeDetectionState?: { enabled: boolean } }): void;
 }
 
 interface XRReferenceSpace extends XRSpace {
@@ -64,9 +97,6 @@ interface XRReferenceSpace extends XRSpace {
     onreset: any;
 }
 
-type XRPlaneSet = Set<XRPlane>;
-type XRAnchorSet = Set<XRAnchor>;
-
 interface XRFrame {
     session: XRSession;
     getViewerPose(referenceSpace: XRReferenceSpace): XRViewerPose | undefined;
@@ -77,13 +107,13 @@ interface XRFrame {
     getHitTestResultsForTransientInput(hitTestSource: XRTransientInputHitTestSource): Array<XRTransientInputHitTestResult>;
     // Anchors
     trackedAnchors?: XRAnchorSet;
-    createAnchor(pose: XRRigidTransform, space: XRSpace): Promise<XRAnchor>;
+    createAnchor?(pose: XRRigidTransform, space: XRSpace): Promise<XRAnchor>;
     // Planes
-    worldInformation: {
+    worldInformation?: {
         detectedPlanes?: XRPlaneSet;
     };
     // Hand tracking
-    getJointPose(joint: XRJointSpace, baseSpace: XRSpace): XRJointPose;
+    getJointPose?(joint: XRJointSpace, baseSpace: XRSpace): XRJointPose;
 }
 
 interface XRViewerPose extends XRPose {
@@ -92,7 +122,14 @@ interface XRViewerPose extends XRPose {
 
 interface XRPose {
     transform: XRRigidTransform;
-    emulatedPosition: boolean;
+    readonly emulatedPosition: boolean;
+}
+
+interface XRViewport {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
 }
 
 interface XRWebGLLayerOptions {
@@ -107,12 +144,16 @@ interface XRWebGLLayerOptions {
 declare var XRWebGLLayer: {
     prototype: XRWebGLLayer;
     new (session: XRSession, context: WebGLRenderingContext | undefined, options?: XRWebGLLayerOptions): XRWebGLLayer;
+    static getNativeFramebufferScaleFactor(session: XRSession);
 };
 interface XRWebGLLayer {
     framebuffer: WebGLFramebuffer;
     framebufferWidth: number;
     framebufferHeight: number;
     getViewport: Function;
+    readonly antialias: boolean;
+    readonly ignoreDepthValues: boolean;
+    getViewport(view: XRView): XRViewport;
 }
 
 declare class XRRigidTransform {
@@ -127,6 +168,8 @@ interface XRView {
     eye: XREye;
     projectionMatrix: Float32Array;
     transform: XRRigidTransform;
+    recommendedViewportScale?: number;
+    requestViewportScale?(scale: number);
 }
 
 interface XRInputSourceChangeEvent {
@@ -140,7 +183,7 @@ interface XRInputSourceEvent extends Event {
     readonly inputSource: XRInputSource;
 }
 
-// Experimental(er) features
+// Experimental/Draft features
 declare class XRRay {
     constructor(transformOrOrigin: XRRigidTransform | DOMPointInit, direction?: DOMPointInit);
     origin: DOMPointReadOnly;
@@ -207,7 +250,7 @@ interface XRJointPose extends XRPose {
     radius: number | undefined;
 }
 
-interface XRHand /*extends Iterablele<XRJointSpace>*/ {
+interface XRHand extends Iterable<XRJointSpace> {
     readonly length: number;
 
     [index: number]: XRJointSpace;

src/XR/features/WebXRControllerPointerSelection.ts

@@ -607,7 +607,7 @@ export class WebXRControllerPointerSelection extends WebXRAbstractFeature {
             Object.keys(controllerData.eventListeners).forEach((eventName: string) => {
                 const func = controllerData.eventListeners && controllerData.eventListeners[eventName as XREventType];
                 if (func) {
-                    this._xrSessionManager.session.removeEventListener(eventName, func);
+                    this._xrSessionManager.session.removeEventListener(eventName as XREventType, func);
                 }
             });
         }

src/XR/features/WebXRHandTracking.ts

@@ -151,7 +151,7 @@ export class WebXRHand implements IDisposable {
         this.trackedMeshes.forEach((mesh, idx) => {
             const xrJoint = hand[idx];
             if (xrJoint) {
-                let pose = xrFrame.getJointPose(xrJoint, referenceSpace);
+                let pose = xrFrame.getJointPose!(xrJoint, referenceSpace);
                 if (!pose || !pose.transform) {
                     return;
                 }

src/XR/features/WebXRHitTest.ts

@@ -96,7 +96,7 @@ export class WebXRHitTest extends WebXRAbstractFeature implements IWebXRHitTestF
             Tools.Warn("waiting for viewer reference space to initialize");
             return;
         }
-        this._xrSessionManager.session.requestHitTestSource(hitTestOptions).then((hitTestSource) => {
+        this._xrSessionManager.session.requestHitTestSource!(hitTestOptions).then((hitTestSource) => {
             if (this._xrHitTestSource) {
                 this._xrHitTestSource.cancel();
             }
@@ -173,7 +173,7 @@ export class WebXRHitTest extends WebXRAbstractFeature implements IWebXRHitTestF
         if (this.options.enableTransientHitTest) {
             const offsetRay = new XRRay(this.options.transientOffsetRay || {});
             this._xrSessionManager.session
-                .requestHitTestSourceForTransientInput({
+                .requestHitTestSourceForTransientInput!({
                     profile: "generic-touchscreen",
                     offsetRay,
                     entityTypes: this.options.entityTypes,

src/XR/features/WebXRHitTestLegacy.ts

@@ -105,7 +105,7 @@ export class WebXRHitTestLegacy extends WebXRAbstractFeature implements IWebXRHi
      * @returns a promise that resolves with an array of native XR hit result in xr coordinates system
      */
     public static XRHitTestWithRay(xrSession: XRSession, xrRay: XRRay, referenceSpace: XRReferenceSpace, filter?: (result: XRHitResult) => boolean): Promise<XRHitResult[]> {
-        return xrSession.requestHitTest(xrRay, referenceSpace).then((results) => {
+        return xrSession.requestHitTest!(xrRay, referenceSpace).then((results) => {
             const filterFunction = filter || ((result) => !!result.hitMatrix);
             return results.filter(filterFunction);
         });

src/XR/features/WebXRPlaneDetector.ts

@@ -138,7 +138,7 @@ export class WebXRPlaneDetector extends WebXRAbstractFeature {
         }
         // const timestamp = this.xrSessionManager.currentTimestamp;
 
-        const detectedPlanes = frame.worldInformation.detectedPlanes;
+        const detectedPlanes = frame.worldInformation!.detectedPlanes;
         if (detectedPlanes) {
             const toRemove = this._detectedPlanes
                 .filter((plane) => !detectedPlanes.has(plane.xrPlane))