Merge pull request #9152 from RaananW/webxrTypeDef

[XR] Update type def

src/LibDeclarations/webxr.d.ts

@@ -1,122 +1,225 @@
+/**
+ * Available session modes
+ */
 type XRSessionMode = "inline" | "immersive-vr" | "immersive-ar";
 
+/**
+ * Reference space 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 XR events available
+ */
 type XREventType = "devicechange" | "visibilitychange" | "end" | "inputsourceschange" | "select" | "selectstart" | "selectend" | "squeeze" | "squeezestart" | "squeezeend" | "reset";
 
-interface XRSpace extends EventTarget {}
+type XRFrameRequestCallback = (time: DOMHighResTimeStamp, frame: XRFrame) => void;
 
-interface XRRenderState {
-    depthNear?: number;
-    depthFar?: number;
-    inlineVerticalFieldOfView?: number;
-    baseLayer?: XRWebGLLayer;
-}
+type XRPlaneSet = Set<XRPlane>;
+type XRAnchorSet = Set<XRAnchor>;
 
-interface XRInputSource {
-    handedness: XRHandedness;
-    targetRayMode: XRTargetRayMode;
-    targetRaySpace: XRSpace;
-    gripSpace: XRSpace | undefined;
-    gamepad: Gamepad | undefined;
-    profiles: Array<string>;
-    hand: XRHand | undefined;
-}
+type XREventHandler = (callback: any) => void;
+
+interface XRLayer extends EventTarget {}
 
 interface XRSessionInit {
     optionalFeatures?: string[];
     requiredFeatures?: string[];
 }
 
-interface XRSession {
-    addEventListener: Function;
-    removeEventListener: Function;
-    requestReferenceSpace(type: XRReferenceSpaceType): Promise<XRReferenceSpace>;
-    updateRenderState(XRRenderStateInit: XRRenderState): Promise<void>;
-    requestAnimationFrame: Function;
-    end(): Promise<void>;
-    renderState: XRRenderState;
-    inputSources: Array<XRInputSource>;
+interface XRSessionEvent extends Event {
+    readonly session: XRSession;
+}
 
-    // hit test
-    requestHitTestSource(options: XRHitTestOptionsInit): Promise<XRHitTestSource>;
-    requestHitTestSourceForTransientInput(options: XRTransientInputHitTestOptionsInit): Promise<XRTransientInputHitTestSource>;
+interface XRSystem {
+    isSessionSupported: (sessionMode: XRSessionMode) => Promise<boolean>;
+    requestSession: (sessionMode: XRSessionMode, sessionInit?: any) => Promise<XRSession>;
+}
 
-    // legacy AR hit test
-    requestHitTest(ray: XRRay, referenceSpace: XRReferenceSpace): Promise<XRHitResult[]>;
+interface XRViewport {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+}
 
-    // legacy plane detection
-    updateWorldTrackingState(options: { planeDetectionState?: { enabled: boolean } }): void;
+interface XRWebGLLayerInit {
+    antialias?: boolean;
+    depth?: boolean;
+    stencil?: boolean;
+    alpha?: boolean;
+    multiview?: boolean;
+    framebufferScaleFactor?: number;
+}
+
+declare class XRWebGLLayer {
+    static getNativeFramebufferScaleFactor(session: XRSession): number;
+    constructor(session: XRSession, context: WebGLRenderingContext | WebGL2RenderingContext, layerInit?: XRWebGLLayerInit);
+    readonly antialias: boolean;
+    readonly framebuffer: WebGLFramebuffer;
+    readonly framebufferWidth: number;
+    readonly framebufferHeight: number;
+    readonly ignoreDepthValues: boolean;
+    getViewport: (view: XRView) => XRViewport;
+}
+
+// tslint:disable-next-line no-empty-interface
+interface XRSpace extends EventTarget {}
+
+interface XRRenderState {
+    readonly baseLayer?: XRWebGLLayer;
+    readonly depthFar: number;
+    readonly depthNear: number;
+    readonly inlineVerticalFieldOfView?: number;
+}
+
+interface XRRenderStateInit extends XRRenderState {
+    baseLayer: XRWebGLLayer;
+    depthFar: number;
+    depthNear: number;
+    inlineVerticalFieldOfView?: number;
+    layers?: XRLayer[];
 }
 
 interface XRReferenceSpace extends XRSpace {
     getOffsetReferenceSpace(originOffset: XRRigidTransform): XRReferenceSpace;
-    onreset: any;
+    onreset: XREventHandler;
 }
 
-type XRPlaneSet = Set<XRPlane>;
-type XRAnchorSet = Set<XRAnchor>;
+interface XRBoundedReferenceSpace extends XRSpace {
+    readonly boundsGeometry: DOMPointReadOnly[];
+}
+
+interface XRInputSource {
+    readonly handedness: XRHandedness;
+    readonly targetRayMode: XRTargetRayMode;
+    readonly targetRaySpace: XRSpace;
+    readonly gripSpace?: XRSpace;
+    readonly gamepad?: Gamepad;
+    readonly profiles: Array<string>;
+    readonly hand?: XRHand;
+}
+
+interface XRPose {
+    readonly transform: XRRigidTransform;
+    readonly emulatedPosition: boolean;
+}
 
 interface XRFrame {
-    session: XRSession;
-    getViewerPose(referenceSpace: XRReferenceSpace): XRViewerPose | undefined;
+    readonly session: XRSession;
     getPose(space: XRSpace, baseSpace: XRSpace): XRPose | undefined;
+    getViewerPose(referenceSpace: XRReferenceSpace): XRViewerPose | undefined;
 
     // AR
     getHitTestResults(hitTestSource: XRHitTestSource): Array<XRHitTestResult>;
     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 {
-    views: Array<XRView>;
+interface XRInputSourceEvent extends Event {
+    readonly frame: XRFrame;
+    readonly inputSource: XRInputSource;
 }
 
-interface XRPose {
-    transform: XRRigidTransform;
-    emulatedPosition: boolean;
-}
+type XRInputSourceArray = XRInputSource[];
 
-interface XRWebGLLayerOptions {
-    antialias?: boolean;
-    depth?: boolean;
-    stencil?: boolean;
-    alpha?: boolean;
-    multiview?: boolean;
-    framebufferScaleFactor?: number;
+interface XRSession {
+    addEventListener(type: XREventType, listener: XREventHandler, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener(type: XREventType, listener: XREventHandler, options?: boolean | EventListenerOptions): void;
+    /**
+     * Returns a list of this session's XRInputSources, each representing an input device
+     * used to control the camera and/or scene.
+     */
+    readonly inputSources: Array<XRInputSource>;
+    /**
+     * object which contains options affecting how the imagery is rendered.
+     * This includes things such as the near and far clipping planes
+     */
+    readonly renderState: XRRenderState;
+    readonly visibilityState: XRVisibilityState;
+    /**
+     * Removes a callback from the animation frame painting callback from
+     * XRSession's set of animation frame rendering callbacks, given the
+     * identifying handle returned by a previous call to requestAnimationFrame().
+     */
+    cancelAnimationFrame: (handle: number) => void;
+    /**
+     * Ends the WebXR session. Returns a promise which resolves when the
+     * session has been shut down.
+     */
+    end(): Promise<void>;
+    /**
+     * Schedules the specified method to be called the next time the user agent
+     * is working on rendering an animation frame for the WebXR device. Returns an
+     * integer value which can be used to identify the request for the purposes of
+     * canceling the callback using cancelAnimationFrame(). This method is comparable
+     * to the Window.requestAnimationFrame() method.
+     */
+    requestAnimationFrame: XRFrameRequestCallback;
+    /**
+     * Requests that a new XRReferenceSpace of the specified type be created.
+     * Returns a promise which resolves with the XRReferenceSpace or
+     * XRBoundedReferenceSpace which was requested, or throws a NotSupportedError if
+     * the requested space type isn't supported by the device.
+     */
+    requestReferenceSpace(type: XRReferenceSpaceType): Promise<XRReferenceSpace | XRBoundedReferenceSpace>;
+
+    updateRenderState(XRRenderStateInit: XRRenderState): Promise<void>;
+
+    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>;
+
+    // legacy AR hit test
+    requestHitTest?(ray: XRRay, referenceSpace: XRReferenceSpace): Promise<XRHitResult[]>;
+
+    // legacy plane detection
+    updateWorldTrackingState?(options: { planeDetectionState?: { enabled: boolean } }): void;
 }
 
-declare var XRWebGLLayer: {
-    prototype: XRWebGLLayer;
-    new (session: XRSession, context: WebGLRenderingContext | undefined, options?: XRWebGLLayerOptions): XRWebGLLayer;
-};
-interface XRWebGLLayer {
-    framebuffer: WebGLFramebuffer;
-    framebufferWidth: number;
-    framebufferHeight: number;
-    getViewport: Function;
+interface XRViewerPose extends XRPose {
+    readonly views: Array<XRView>;
 }
 
 declare class XRRigidTransform {
-    constructor(matrix: Float32Array | DOMPointInit, direction?: DOMPointInit);
+    constructor(position?: DOMPointInit, direction?: DOMPointInit);
     position: DOMPointReadOnly;
     orientation: DOMPointReadOnly;
     matrix: Float32Array;
@@ -124,23 +227,20 @@ declare class XRRigidTransform {
 }
 
 interface XRView {
-    eye: XREye;
-    projectionMatrix: Float32Array;
-    transform: XRRigidTransform;
+    readonly eye: XREye;
+    readonly projectionMatrix: Float32Array;
+    readonly transform: XRRigidTransform;
+    readonly recommendedViewportScale?: number;
+    requestViewportScale(scale: number): void;
 }
 
-interface XRInputSourceChangeEvent {
+interface XRInputSourceChangeEvent extends Event {
     session: XRSession;
     removed: Array<XRInputSource>;
     added: Array<XRInputSource>;
 }
 
-interface XRInputSourceEvent extends Event {
-    readonly frame: XRFrame;
-    readonly inputSource: XRInputSource;
-}
-
-// Experimental(er) features
+// Experimental/Draft features
 declare class XRRay {
     constructor(transformOrOrigin: XRRigidTransform | DOMPointInit, direction?: DOMPointInit);
     origin: DOMPointReadOnly;
@@ -207,13 +307,11 @@ interface XRJointPose extends XRPose {
     radius: number | undefined;
 }
 
-interface XRHand /*extends Iterablele<XRJointSpace>*/ {
+interface XRHand extends Iterable<XRJointSpace> {
     readonly length: number;
 
     [index: number]: XRJointSpace;
 
-    // Specs have the function 'joint(idx: number)', but chrome doesn't support it yet.
-
     readonly WRIST: number;
 
     readonly THUMB_METACARPAL: number;

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))

src/XR/webXRManagedOutputCanvas.ts

@@ -16,7 +16,7 @@ export class WebXRManagedOutputCanvasOptions {
     /**
      * Options for this XR Layer output
      */
-    public canvasOptions?: XRWebGLLayerOptions;
+    public canvasOptions?: XRWebGLLayerInit;
     /**
      * CSS styling for a newly created canvas (if not provided)
      */

src/XR/webXRSessionManager.ts

@@ -259,8 +259,8 @@ export class WebXRSessionManager implements IDisposable {
         return this.session
             .requestReferenceSpace(referenceSpaceType)
             .then(
-                (referenceSpace: XRReferenceSpace) => {
-                    return referenceSpace;
+                (referenceSpace) => {
+                    return referenceSpace as XRReferenceSpace;
                 },
                 (rejectionReason) => {
                     Logger.Error("XR.requestReferenceSpace failed for the following reason: ");
@@ -268,9 +268,9 @@ export class WebXRSessionManager implements IDisposable {
                     Logger.Log('Defaulting to universally-supported "viewer" reference space type.');
 
                     return this.session.requestReferenceSpace("viewer").then(
-                        (referenceSpace: XRReferenceSpace) => {
+                        (referenceSpace) => {
                             const heightCompensation = new XRRigidTransform({ x: 0, y: -this.defaultHeightCompensation, z: 0 });
-                            return referenceSpace.getOffsetReferenceSpace(heightCompensation);
+                            return (referenceSpace as XRReferenceSpace).getOffsetReferenceSpace(heightCompensation);
                         },
                         (rejectionReason) => {
                             Logger.Error(rejectionReason);
@@ -281,8 +281,8 @@ export class WebXRSessionManager implements IDisposable {
             )
             .then((referenceSpace) => {
                 // create viewer reference space before setting the first reference space
-                return this.session.requestReferenceSpace("viewer").then((viewerReferenceSpace: XRReferenceSpace) => {
-                    this.viewerReferenceSpace = viewerReferenceSpace;
+                return this.session.requestReferenceSpace("viewer").then((viewerReferenceSpace) => {
+                    this.viewerReferenceSpace = viewerReferenceSpace as XRReferenceSpace;
                     return referenceSpace;
                 });
             })