@babylonjs/core 5.27.1 → 5.28.0

package/Engines/engine.d.ts

@@ -2299,20 +2299,64 @@ interface Gamepad {
 
 var VRFrameData: any;
 
-/* eslint-disable @typescript-eslint/naming-convention */
+// Type definitions for non-npm package webxr 0.5
+// Project: https://www.w3.org/TR/webxr/
+// Definitions by: Rob Rohan <https://github.com/robrohan>
+//                 Raanan Weber <https://github.com/RaananW>
+//                 Sean T. McBeth <https://github.com/capnmidnight>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// Minimum TypeScript Version: 3.7
+
+// Most of this was hand written and... more or less copied from the following
+// sites:
+//  https://www.w3.org/TR/webxr/
+//  https://developer.mozilla.org/en-US/docs/Web/API/WebXR_Device_API
+//  https://www.w3.org/immersive-web/
+//  https://github.com/immersive-web
+//
+
+/**
+ * ref: https://immersive-web.github.io/webxr/#navigator-xr-attribute
+ */
+interface Navigator {
+    /**
+     * An XRSystem object is the entry point to the API, used to query for XR features
+     * available to the user agent and initiate communication with XR hardware via the
+     * creation of XRSessions.
+     */
+    xr?: XRSystem | undefined;
+}
+
+/**
+ * WebGL Context Compatability
+ *
+ * ref: https://immersive-web.github.io/webxr/#contextcompatibility
+ */
+interface WebGLContextAttributes {
+    xrCompatible?: boolean | undefined;
+}
+
+interface WebGLRenderingContextBase {
+    makeXRCompatible(): Promise<void>;
+}
+
 /**
  * Available session modes
+ *
+ * ref: https://immersive-web.github.io/webxr/#xrsessionmode-enum
  */
 type XRSessionMode = "inline" | "immersive-vr" | "immersive-ar";
 
 /**
  * Reference space types
  */
-type XRReferenceSpaceType = "viewer" | "local" | "local-floor" | "unbounded";
-type XRBoundedReferenceSpaceType = "bounded-floor";
+type XRReferenceSpaceType = "viewer" | "local" | "local-floor" | "bounded-floor" | "unbounded";
 
 type XREnvironmentBlendMode = "opaque" | "additive" | "alpha-blend";
 
+/**
+ * ref: https://immersive-web.github.io/webxr/#xrsession-interface
+ */
 type XRVisibilityState = "visible" | "visible-blurred" | "hidden";
 
 /**
@@ -2330,67 +2374,57 @@ type XRTargetRayMode = "gaze" | "tracked-pointer" | "screen";
  */
 type XREye = "none" | "left" | "right";
 
-/**
- * Type of XR events available
- */
-type XREventType =
-    | "devicechange"
-    | "visibilitychange"
-    | "end"
-    | "inputsourceschange"
-    | "select"
-    | "selectstart"
-    | "selectend"
-    | "squeeze"
-    | "squeezestart"
-    | "squeezeend"
-    | "reset"
-    | "eyetrackingstart"
-    | "eyetrackingend";
-
-type XRDOMOverlayType = "screen" | "floating" | "head-locked";
-
-type XRReflectionFormat = "srgba8" | "rgba16f";
-
 type XRFrameRequestCallback = (time: DOMHighResTimeStamp, frame: XRFrame) => void;
 
-type XRPlaneSet = Set<XRPlane>;
-type XRAnchorSet = Set<XRAnchor>;
+interface XRSystemDeviceChangeEvent extends Event {
+    type: "devicechange";
+}
 
-type XREventHandler = (callback: any) => void;
+interface XRSystemDeviceChangeEventHandler {
+    (event: XRSystemDeviceChangeEvent): any;
+}
 
-interface XRLayer extends EventTarget {}
+interface XRSystemEventMap {
+    devicechange: XRSystemDeviceChangeEvent;
+}
 
-type XRDOMOverlayInit = {
+/**
+ * An XRSystem object is the entry point to the API, used to query for XR features available
+ * to the user agent and initiate communication with XR hardware via the creation of
+ * XRSessions.
+ *
+ * ref: https://immersive-web.github.io/webxr/#xrsystem-interface
+ */
+interface XRSystem extends EventTarget {
     /**
-     * The root attribute specifies the overlay element that will be displayed to the user as the content of the DOM overlay. This is a required attribute, there is no default.
+     * Attempts to initialize an XRSession for the given mode if possible, entering immersive
+     * mode if necessary.
+     * @param mode
+     * @param options
      */
-    root: Element;
-};
-
-type XRLightProbeInit = {
-    reflectionFormat: XRReflectionFormat;
-};
+    requestSession(mode: XRSessionMode, options?: XRSessionInit): Promise<XRSession>;
 
-interface XRSessionInit {
-    optionalFeatures?: string[];
-    requiredFeatures?: string[];
-    trackedImages?: XRTrackedImageInit[];
     /**
-     * When 'dom-overly' is (optionally) requested the application MUST provide configuration for the DOM overlay
+     * Queries if a given mode may be supported by the user agent and device capabilities.
+     * @param mode
      */
-    domOverlay?: XRDOMOverlayInit;
-}
+    isSessionSupported(mode: XRSessionMode): Promise<boolean>;
 
-interface XRSessionEvent extends Event {
-    readonly session: XRSession;
-}
+    ondevicechange: XRSystemDeviceChangeEventHandler | null;
 
-interface XRSystem {
-    isSessionSupported: (sessionMode: XRSessionMode) => Promise<boolean>;
-    requestSession: (sessionMode: XRSessionMode, sessionInit?: any) => Promise<XRSession>;
+    addEventListener<K extends keyof XRSystemEventMap>(type: K, listener: (this: XRSystem, ev: XRSystemEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof XRSystemEventMap>(type: K, listener: (this: XRSystem, ev: XRSystemEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
 }
 
+abstract class XRSystem implements XRSystem {}
+
+/**
+ * Describes a viewport, or rectangular region, of a graphics surface.
+ *
+ * ref: https://immersive-web.github.io/webxr/#xrviewport-interface
+ */
 interface XRViewport {
     readonly x: number;
     readonly y: number;
@@ -2398,215 +2432,296 @@ interface XRViewport {
     readonly height: number;
 }
 
-interface XRWebGLLayerInit {
-    antialias?: boolean;
-    depth?: boolean;
-    stencil?: boolean;
-    alpha?: boolean;
-    multiview?: boolean;
-    framebufferScaleFactor?: number;
-}
-
-// https://www.w3.org/TR/webxrlayers-1/#XRWebGLBindingtype
-class XRWebGLBinding {
-    constructor(xrSession: XRSession, context: WebGLRenderingContext | WebGL2RenderingContext);
-    getReflectionCubeMap: (lightProbe: XRLightProbe) => WebGLTexture;
-
-    // https://immersive-web.github.io/layers/#XRWebGLBindingtype
-    createProjectionLayer(init: XRProjectionLayerInit): XRProjectionLayer;
-    getSubImage(layer: XRCompositionLayer, frame: XRFrame, eye?: XREye): XRWebGLSubImage;
-    getViewSubImage(layer: XRProjectionLayer, view: XRView): XRWebGLSubImage;
-}
-
-class XRWebGLLayer implements XRLayer {
-    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;
-    fixedFoveation?: number | null;
-    getViewport: (view: XRView) => XRViewport;
-
-    // Methods for EventTarget required through XRLayer
-    addEventListener(): void;
-    dispatchEvent(): boolean;
-    removeEventListener(): void;
-}
-
-type XRLayerLayout = "default" | "mono" | "stereo" | "stereo-left-right" | "stereo-top-bottom";
-
-// https://immersive-web.github.io/layers/#xrcompositionlayertype
-interface XRCompositionLayer extends XRLayer {
-    layout: XRLayerLayout;
+abstract class XRViewport implements XRViewport {}
 
-    blendTextureSourceAlpha: boolean;
-    chromaticAberrationCorrection: boolean;
-    mipLevels: number;
+/**
+ * Represents a virtual coordinate system with an origin that corresponds to a physical location.
+ * Spatial data that is requested from the API or given to the API is always expressed in relation
+ * to a specific XRSpace at the time of a specific XRFrame. Numeric values such as pose positions
+ * are coordinates in that space relative to its origin. The interface is intentionally opaque.
+ *
+ * ref: https://immersive-web.github.io/webxr/#xrspace-interface
+ */
+// tslint:disable-next-line no-empty-interface
+interface XRSpace extends EventTarget {}
 
-    needsRedraw: boolean;
+abstract class XRSpace implements XRSpace {}
 
-    destroy(): void;
+interface XRRenderStateInit {
+    baseLayer?: XRWebGLLayer | undefined;
+    depthFar?: number | undefined;
+    depthNear?: number | undefined;
+    inlineVerticalFieldOfView?: number | undefined;
 }
 
-type XRTextureType = "texture" | "texture-array";
-
-interface XRProjectionLayerInit {
-    textureType: XRTextureType; //  Default  "texture";
-    colorFormat: GLenum; //  Default 0x1908, RGBA
-    depthFormat: GLenum; //  Default 0x1902, DEPTH_COMPONENT
-    scaleFactor: number; //  Default 1.0;
+interface XRRenderState {
+    readonly baseLayer?: XRWebGLLayer | undefined;
+    readonly depthFar: number;
+    readonly depthNear: number;
+    readonly inlineVerticalFieldOfView?: number | undefined;
 }
 
-interface XRProjectionLayer extends XRCompositionLayer {
-    textureWidth: number;
-    textureHeight: number;
-    textureArrayLength: number;
+abstract class XRRenderState implements XRRenderState {}
 
-    ignoreDepthValues: boolean;
-    fixedFoveation?: number;
+interface XRReferenceSpaceEventInit extends EventInit {
+    referenceSpace?: XRReferenceSpace | undefined;
+    transform?: XRRigidTransform | undefined;
 }
 
-interface XRSubImage {
-    viewport: XRViewport;
+/**
+ * XRReferenceSpaceEvents are fired to indicate changes to the state of an XRReferenceSpace.
+ *
+ * ref: https://immersive-web.github.io/webxr/#xrreferencespaceevent-interface
+ */
+interface XRReferenceSpaceEvent extends Event {
+    readonly type: "reset";
+    readonly referenceSpace: XRReferenceSpace;
+    readonly transform?: XRRigidTransform | undefined;
 }
 
-interface XRWebGLSubImage extends XRSubImage {
-    colorTexture: WebGLTexture;
-    depthStencilTexture?: WebGLTexture;
-    imageIndex?: number;
-    textureWidth: number;
-    textureHeight: number;
+// tslint:disable-next-line no-unnecessary-class
+class XRReferenceSpaceEvent implements XRReferenceSpaceEvent {
+    constructor(type: "reset", eventInitDict?: XRReferenceSpaceEventInit);
 }
 
-// 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;
-    readonly layers?: XRLayer[];
+interface XRReferenceSpaceEventHandler {
+    (event: XRReferenceSpaceEvent): any;
 }
 
-// https://immersive-web.github.io/webxr/#dictdef-xrrenderstateinit
-interface XRRenderStateInit {
-    baseLayer?: XRWebGLLayer;
-    depthFar: number;
-    depthNear: number;
-    inlineVerticalFieldOfView?: number;
-    layers?: XRLayer[];
+interface XRReferenceSpaceEventMap {
+    reset: XRReferenceSpaceEvent;
 }
 
+/**
+ * One of several common XRSpaces that applications can use to establish a spatial relationship
+ * with the user's physical environment.
+ *
+ * ref: https://immersive-web.github.io/webxr/#xrreferencespace-interface
+ */
 interface XRReferenceSpace extends XRSpace {
     getOffsetReferenceSpace(originOffset: XRRigidTransform): XRReferenceSpace;
-    onreset: XREventHandler;
+    onreset: XRReferenceSpaceEventHandler;
+
+    addEventListener<K extends keyof XRReferenceSpaceEventMap>(
+        type: K,
+        listener: (this: XRReferenceSpace, ev: XRReferenceSpaceEventMap[K]) => any,
+        options?: boolean | AddEventListenerOptions
+    ): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof XRReferenceSpaceEventMap>(
+        type: K,
+        listener: (this: XRReferenceSpace, ev: XRReferenceSpaceEventMap[K]) => any,
+        options?: boolean | EventListenerOptions
+    ): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
 }
 
-interface XRBoundedReferenceSpace extends XRSpace {
+abstract class XRReferenceSpace implements XRReferenceSpace {}
+
+/**
+ * Extends XRReferenceSpace to include boundsGeometry, indicating the pre-configured boundaries
+ * of the user's space.
+ *
+ * ref: https://immersive-web.github.io/webxr/#xrboundedreferencespace-interface
+ */
+interface XRBoundedReferenceSpace extends XRReferenceSpace {
     readonly boundsGeometry: DOMPointReadOnly[];
 }
 
+abstract class XRBoundedReferenceSpace implements XRBoundedReferenceSpace {}
+
+/**
+ * Represents an XR input source, which is any input mechanism which allows the user to perform
+ * targeted actions in the same virtual space as the viewer. Example XR input sources include,
+ * but are not limited to, handheld controllers, optically tracked hands, and gaze-based input
+ * methods that operate on the viewer's pose. Input mechanisms which are not explicitly associated
+ * with the XR device, such as traditional gamepads, mice, or keyboards SHOULD NOT be considered
+ * XR input sources.
+ * ref: https://immersive-web.github.io/webxr/#xrinputsource-interface
+ */
 interface XRInputSource {
     readonly handedness: XRHandedness;
     readonly targetRayMode: XRTargetRayMode;
     readonly targetRaySpace: XRSpace;
-    readonly gripSpace?: XRSpace;
-    readonly gamepad?: Gamepad;
-    readonly profiles: Array<string>;
-    readonly hand?: XRHand;
+    readonly gripSpace?: XRSpace | undefined;
+    readonly gamepad?: Gamepad | undefined;
+    readonly profiles: string[];
+    readonly hand?: XRHand | undefined;
 }
 
-interface XRLightEstimate {
-    readonly sphericalHarmonicsCoefficients: Float32Array;
-    readonly primaryLightDirection: DOMPointReadOnly;
-    readonly primaryLightIntensity: DOMPointReadOnly;
+abstract class XRInputSource implements XRInputSource {}
+
+/**
+ * Represents a list of XRInputSources. It is used in favor of a frozen array type when the contents
+ * of the list are expected to change over time, such as with the XRSession inputSources attribute.
+ * ref: https://immersive-web.github.io/webxr/#xrinputsourcearray-interface
+ */
+interface XRInputSourceArray {
+    [Symbol.iterator](): IterableIterator<XRInputSource>;
+    [n: number]: XRInputSource;
+
+    length: number;
+
+    entries(): IterableIterator<[number, XRInputSource]>;
+    keys(): IterableIterator<number>;
+    values(): IterableIterator<XRInputSource>;
+
+    forEach(callbackfn: (value: XRInputSource, index: number, array: XRInputSource[]) => void, thisArg?: any): void;
 }
 
+abstract class XRInputSourceArray implements XRInputSourceArray {}
+
+/**
+ * Describes a position and orientation in space relative to an XRSpace.
+ *
+ * ref: https://immersive-web.github.io/webxr/#xrpose-interface
+ */
 interface XRPose {
     readonly transform: XRRigidTransform;
     readonly emulatedPosition: boolean;
-    readonly linearVelocity?: DOMPointReadOnly;
-    readonly angularVelocity?: DOMPointReadOnly;
 }
 
-interface XRWorldInformation {
-    detectedPlanes?: XRPlaneSet;
-}
+abstract class XRPose implements XRPose {}
 
+/**
+ * Represents a snapshot of the state of all of the tracked objects for an XRSession. Applications
+ * can acquire an XRFrame by calling requestAnimationFrame() on an XRSession with an
+ * XRFrameRequestCallback. When the callback is called it will be passed an XRFrame.
+ * Events which need to communicate tracking state, such as the select event, will also provide an
+ * XRFrame.
+ *
+ * ref: https://immersive-web.github.io/webxr/#xrframe-interface
+ */
 interface XRFrame {
     readonly session: XRSession;
+    // BABYLON CHANGE - switched to optional
+    readonly predictedDisplayTime?: DOMHighResTimeStamp;
+
+    /**
+     * Provides the pose of space relative to baseSpace as an XRPose, at the time represented by
+     * the XRFrame.
+     *
+     * @param space
+     * @param baseSpace
+     */
     getPose(space: XRSpace, baseSpace: XRSpace): XRPose | undefined;
-    fillPoses?(spaces: XRSpace[], baseSpace: XRSpace, transforms: Float32Array): boolean;
+
+    /**
+     * Provides the pose of the viewer relative to referenceSpace as an XRViewerPose, at the
+     * XRFrame's time.
+     *
+     * @param referenceSpace
+     */
     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>;
-    // World geometries. DEPRECATED
-    worldInformation?: XRWorldInformation;
-    detectedPlanes?: XRPlaneSet;
-    // Hand tracking
-    getJointPose?(joint: XRJointSpace, baseSpace: XRSpace): XRJointPose;
-    fillJointRadii?(jointSpaces: XRJointSpace[], radii: Float32Array): boolean;
-    // Image tracking
-    getImageTrackingResults?(): Array<XRImageTrackingResult>;
-    getLightEstimate(xrLightProbe: XRLightProbe): XRLightEstimate;
+abstract class XRFrame implements XRFrame {}
+
+/**
+ * Type of XR events available
+ */
+type XRInputSourceEventType = "select" | "selectend" | "selectstart" | "squeeze" | "squeezeend" | "squeezestart";
+
+interface XRInputSourceEventInit extends EventInit {
+    frame?: XRFrame | undefined;
+    inputSource?: XRInputSource | undefined;
 }
 
-interface XRInputSourceEvent extends Event {
+/**
+ * XRInputSourceEvents are fired to indicate changes to the state of an XRInputSource.
+ * ref: https://immersive-web.github.io/webxr/#xrinputsourceevent-interface
+ */
+class XRInputSourceEvent extends Event {
+    readonly type: XRInputSourceEventType;
     readonly frame: XRFrame;
     readonly inputSource: XRInputSource;
+
+    constructor(type: XRInputSourceEventType, eventInitDict?: XRInputSourceEventInit);
 }
 
-interface XREyeTrackingSourceEvent extends Event {
-    readonly gazeSpace: XRSpace;
+interface XRInputSourceEventHandler {
+    (evt: XRInputSourceEvent): any;
 }
 
-type XRInputSourceArray = XRInputSource[];
+type XRSessionEventType = "end" | "visibilitychange" | "frameratechange";
 
-type XRDOMOverlayState = {
-    /**
-     * set if supported, or is null if the feature is not supported
-     */
-    type: XRDOMOverlayType | null;
-};
+interface XRSessionEventInit extends EventInit {
+    session: XRSession;
+}
 
-interface XRLightProbe extends EventTarget {
-    readonly probeSpace: XRSpace;
-    onreflectionchange: XREventHandler;
+/**
+ * XRSessionEvents are fired to indicate changes to the state of an XRSession.
+ * ref: https://immersive-web.github.io/webxr/#xrsessionevent-interface
+ */
+class XRSessionEvent extends Event {
+    readonly session: XRSession;
+    constructor(type: XRSessionEventType, eventInitDict?: XRSessionEventInit);
 }
 
-interface XRSession {
-    addEventListener(type: XREventType, listener: XREventHandler, options?: boolean | AddEventListenerOptions): void;
-    removeEventListener(type: XREventType, listener: XREventHandler, options?: boolean | EventListenerOptions): void;
+interface XRSessionEventHandler {
+    (evt: XRSessionEvent): any;
+}
+
+/**
+ * ref: https://immersive-web.github.io/webxr/#feature-dependencies
+ */
+interface XRSessionInit {
+    optionalFeatures?: string[] | undefined;
+    requiredFeatures?: string[] | undefined;
+}
+
+interface XRSessionEventMap {
+    inputsourceschange: XRInputSourceChangeEvent;
+    end: XRSessionEvent;
+    visibilitychange: XRSessionEvent;
+    frameratechange: XRSessionEvent;
+    select: XRInputSourceEvent;
+    selectstart: XRInputSourceEvent;
+    selectend: XRInputSourceEvent;
+    squeeze: XRInputSourceEvent;
+    squeezestart: XRInputSourceEvent;
+    squeezeend: XRInputSourceEvent;
+    eyetrackingstart: XREyeTrackingEvent;
+    eyetrackingend: XREyeTrackingEvent;
+}
+
+/**
+ * Any interaction with XR hardware is done via an XRSession object, which can only be
+ * retrieved by calling requestSession() on the XRSystem object. Once a session has been
+ * successfully acquired, it can be used to poll the viewer pose, query information about
+ * the user's environment, and present imagery to the user.
+ *
+ * ref: https://immersive-web.github.io/webxr/#xrsession-interface
+ */
+interface XRSession extends EventTarget {
     /**
      * 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>;
+    readonly inputSources: XRInputSourceArray;
     /**
      * 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 environmentBlendMode: XREnvironmentBlendMode;
     readonly visibilityState: XRVisibilityState;
+    readonly frameRate?: number | undefined;
+    readonly supportedFrameRates?: Float32Array | undefined;
+
     /**
      * 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;
+    cancelAnimationFrame(id: 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
@@ -2614,168 +2729,255 @@ interface XRSession {
      * canceling the callback using cancelAnimationFrame(). This method is comparable
      * to the Window.requestAnimationFrame() method.
      */
-    requestAnimationFrame: (callback: XRFrameRequestCallback) => number;
+    requestAnimationFrame(callback: XRFrameRequestCallback): number;
+
     /**
      * 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>;
-    requestReferenceSpace(type: XRBoundedReferenceSpaceType): Promise<XRBoundedReferenceSpace>;
-
-    /**
-     * The XRSession interface is extended with the ability to create new XRLightProbe instances.
-     * XRLightProbe instances have a session object, which is the XRSession that created this XRLightProbe.
-     *
-     * Can reject with with a "NotSupportedError" DOMException
-     */
-    requestLightProbe(options?: XRLightProbeInit): Promise<XRLightProbe>;
-
-    updateRenderState(state: XRRenderStateInit): void;
-
-    onend: XREventHandler;
-    oneyetrackingstart: XREventHandler;
-    oneyetrackingend: 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[]>;
+    requestReferenceSpace(type: XRReferenceSpaceType): Promise<XRReferenceSpace | XRBoundedReferenceSpace>;
 
-    // legacy plane detection
-    updateWorldTrackingState?(options: { planeDetectionState?: { enabled: boolean } }): void;
+    updateRenderState(renderStateInit?: XRRenderStateInit): Promise<void>;
 
-    // image tracking
-    getTrackedImageScores?(): Promise<XRImageTrackingScore[]>;
+    updateTargetFrameRate(rate: number): Promise<void>;
 
-    /**
-     * Provided when the optional 'dom-overlay' feature is requested.
-     */
-    readonly domOverlayState?: XRDOMOverlayState;
-    /**
-     * Indicates the XRReflectionFormat most closely supported by the underlying XR device
-     */
-    readonly preferredReflectionFormat?: XRReflectionFormat;
+    onend: XRSessionEventHandler;
+    oninputsourceschange: XRInputSourceChangeEventHandler;
+    onselect: XRInputSourceEventHandler;
+    onselectstart: XRInputSourceEventHandler;
+    onselectend: XRInputSourceEventHandler;
+    onsqueeze: XRInputSourceEventHandler;
+    onsqueezestart: XRInputSourceEventHandler;
+    onsqueezeend: XRInputSourceEventHandler;
+    onvisibilitychange: XRSessionEventHandler;
+    onframeratechange: XRSessionEventHandler;
 
-    readonly frameRate?: number;
-    readonly supportedFrameRates?: Float32Array;
-    updateTargetFrameRate(rate: number): Promise<void>;
+    addEventListener<K extends keyof XRSessionEventMap>(type: K, listener: (this: XRSession, ev: XRSessionEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof XRSessionEventMap>(type: K, listener: (this: XRSession, ev: XRSessionEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
 }
 
+abstract class XRSession implements XRSession {}
+
+/**
+ * An XRPose describing the state of a viewer of the XR scene as tracked by the XR
+ * device. A viewer may represent a tracked piece of hardware, the observed position
+ * of a user's head relative to the hardware, or some other means of computing a series
+ * of viewpoints into the XR scene. XRViewerPoses can only be queried relative to an
+ * XRReferenceSpace. It provides, in addition to the XRPose values, an array of views
+ * which include rigid transforms to indicate the viewpoint and projection matrices.
+ * These values should be used by the application when rendering a frame of an XR scene.
+ *
+ * ref: https://immersive-web.github.io/webxr/#xrviewerpose-interface
+ */
 interface XRViewerPose extends XRPose {
-    readonly views: Array<XRView>;
+    readonly views: ReadonlyArray<XRView>;
 }
 
+abstract class XRViewerPose implements XRViewerPose {}
+
+/**
+ * A transform described by a position and orientation. When interpreting an
+ * XRRigidTransform the orientation is always applied prior to the position.
+ *
+ * ref: https://immersive-web.github.io/webxr/#xrrigidtransform-interface
+ */
 class XRRigidTransform {
+    readonly position: DOMPointReadOnly;
+    readonly orientation: DOMPointReadOnly;
+    readonly matrix: Float32Array;
+    readonly inverse: XRRigidTransform;
+
     constructor(position?: DOMPointInit, direction?: DOMPointInit);
-    position: DOMPointReadOnly;
-    orientation: DOMPointReadOnly;
-    matrix: Float32Array;
-    inverse: XRRigidTransform;
 }
 
+/**
+ * Describes a single view into an XR scene for a given frame.
+ *
+ * ref: https://immersive-web.github.io/webxr/#xrview-interface
+ */
 interface XRView {
     readonly eye: XREye;
     readonly projectionMatrix: Float32Array;
     readonly transform: XRRigidTransform;
-    readonly recommendedViewportScale?: number;
+    readonly recommendedViewportScale?: number | undefined;
     requestViewportScale(scale: number): void;
 }
 
-interface XRInputSourceChangeEvent extends Event {
-    session: XRSession;
-    removed: Array<XRInputSource>;
-    added: Array<XRInputSource>;
+abstract class XRView implements XRView {}
+
+/**
+ * XRInputSourcesChangeEvents are fired to indicate changes to the XRInputSources that are
+ * available to an XRSession.
+ * ref: https://immersive-web.github.io/webxr/#xrinputsourceschangeevent-interface
+ */
+interface XRInputSourceChangeEvent extends XRSessionEvent {
+    readonly removed: ReadonlyArray<XRInputSource>;
+    readonly added: ReadonlyArray<XRInputSource>;
+}
+
+interface XRInputSourceChangeEventHandler {
+    (evt: XRInputSourceChangeEvent): any;
 }
 
 // Experimental/Draft features
-class XRRay {
-    constructor(transformOrOrigin: XRRigidTransform | DOMPointInit, direction?: DOMPointInit);
-    origin: DOMPointReadOnly;
-    direction: DOMPointReadOnly;
-    matrix: Float32Array;
+
+// Anchors
+type XRAnchorSet = Set<XRAnchor>;
+
+interface XRAnchor {
+    anchorSpace: XRSpace;
+    delete(): void;
 }
 
-enum XRHitTestTrackableType {
-    "point",
-    "plane",
-    "mesh",
+abstract class XRAnchor implements XRAnchor {}
+
+interface XRFrame {
+    trackedAnchors?: XRAnchorSet | undefined;
+    createAnchor?: (pose: XRRigidTransform, space: XRSpace) => Promise<XRAnchor> | undefined;
 }
 
-interface XRHitResult {
-    hitMatrix: Float32Array;
+// AR Hit testing
+class XRRay {
+    readonly origin: DOMPointReadOnly;
+    readonly direction: DOMPointReadOnly;
+    readonly matrix: Float32Array;
+
+    constructor(transformOrOrigin?: XRRigidTransform | DOMPointInit, direction?: DOMPointInit);
 }
 
+type XRHitTestTrackableType = "point" | "plane" | "mesh";
+
 interface XRTransientInputHitTestResult {
     readonly inputSource: XRInputSource;
-    readonly results: Array<XRHitTestResult>;
+    readonly results: ReadonlyArray<XRHitTestResult>;
+}
+
+class XRTransientInputHitTestResult {
+    prototype: XRTransientInputHitTestResult;
 }
 
 interface XRHitTestResult {
     getPose(baseSpace: XRSpace): XRPose | undefined;
     // When anchor system is enabled
-    createAnchor?(pose: XRRigidTransform): Promise<XRAnchor>;
+    createAnchor?: (pose: XRRigidTransform) => Promise<XRAnchor> | undefined;
 }
 
+abstract class XRHitTestResult implements XRHitTestResult {}
+
 interface XRHitTestSource {
     cancel(): void;
 }
 
+abstract class XRHitTestSource implements XRHitTestSource {}
+
 interface XRTransientInputHitTestSource {
     cancel(): void;
 }
 
+abstract class XRTransientInputHitTestSource implements XRTransientInputHitTestSource {}
+
 interface XRHitTestOptionsInit {
     space: XRSpace;
-    entityTypes?: Array<XRHitTestTrackableType>;
-    offsetRay?: XRRay;
+    entityTypes?: XRHitTestTrackableType[] | undefined;
+    offsetRay?: XRRay | undefined;
 }
 
 interface XRTransientInputHitTestOptionsInit {
     profile: string;
-    entityTypes?: Array<XRHitTestTrackableType>;
-    offsetRay?: XRRay;
+    entityTypes?: XRHitTestTrackableType[] | undefined;
+    offsetRay?: XRRay | undefined;
 }
 
-interface XRAnchor {
-    anchorSpace: XRSpace;
-    delete(): void;
+interface XRSession {
+    requestHitTestSource?: (options: XRHitTestOptionsInit) => Promise<XRHitTestSource>;
+    requestHitTestSourceForTransientInput?: (options: XRTransientInputHitTestOptionsInit) => Promise<XRTransientInputHitTestSource>;
+
+    // Legacy
+    requestHitTest?: (ray: XRRay, referenceSpace: XRReferenceSpace) => Promise<XRHitResult[]>;
+}
+
+interface XRFrame {
+    getHitTestResults(hitTestSource: XRHitTestSource): XRHitTestResult[];
+    getHitTestResultsForTransientInput(hitTestSource: XRTransientInputHitTestSource): XRTransientInputHitTestResult[];
+}
+
+// Legacy
+interface XRHitResult {
+    hitMatrix: Float32Array;
 }
 
+// Plane detection
+type XRPlaneSet = Set<XRPlane>;
+
+type XRPlaneOrientation = "horizontal" | "vertical";
+
 interface XRPlane {
-    orientation: "Horizontal" | "Vertical";
+    orientation: XRPlaneOrientation;
     planeSpace: XRSpace;
-    polygon: Array<DOMPointReadOnly>;
+    polygon: DOMPointReadOnly[];
     lastChangedTime: number;
 }
 
-interface XRJointSpace extends XRSpace {}
+abstract class XRPlane implements XRPlane {}
+
+interface XRSession {
+    // Legacy
+    updateWorldTrackingState?: (options: { planeDetectionState?: { enabled: boolean } | undefined }) => void | undefined;
+}
+
+// interface XRFrame {
+//     worldInformation?:
+//         | {
+//               detectedPlanes?: XRPlaneSet | undefined;
+//           }
+//         | undefined;
+// }
+
+// Hand Tracking
+type XRHandJoint =
+    | "wrist"
+    | "thumb-metacarpal"
+    | "thumb-phalanx-proximal"
+    | "thumb-phalanx-distal"
+    | "thumb-tip"
+    | "index-finger-metacarpal"
+    | "index-finger-phalanx-proximal"
+    | "index-finger-phalanx-intermediate"
+    | "index-finger-phalanx-distal"
+    | "index-finger-tip"
+    | "middle-finger-metacarpal"
+    | "middle-finger-phalanx-proximal"
+    | "middle-finger-phalanx-intermediate"
+    | "middle-finger-phalanx-distal"
+    | "middle-finger-tip"
+    | "ring-finger-metacarpal"
+    | "ring-finger-phalanx-proximal"
+    | "ring-finger-phalanx-intermediate"
+    | "ring-finger-phalanx-distal"
+    | "ring-finger-tip"
+    | "pinky-finger-metacarpal"
+    | "pinky-finger-phalanx-proximal"
+    | "pinky-finger-phalanx-intermediate"
+    | "pinky-finger-phalanx-distal"
+    | "pinky-finger-tip";
+
+interface XRJointSpace extends XRSpace {
+    readonly jointName: XRHandJoint;
+}
+
+abstract class XRJointSpace implements XRJointSpace {}
 
 interface XRJointPose extends XRPose {
-    radius: number | undefined;
+    readonly radius: number | undefined;
 }
 
-// to be extended
-type XRHandJoint = string;
-
-interface XRHand extends Iterable<XRJointSpace> {
-    readonly size: number;
-
-    [index: number]: XRJointSpace;
-
-    get(joint: XRHandJoint): XRJointSpace;
+abstract class XRJointPose implements XRJointPose {}
 
+interface XRHand extends Map<number, XRJointSpace> {
     readonly WRIST: number;
 
     readonly THUMB_METACARPAL: number;
@@ -2808,6 +3010,381 @@ interface XRHand extends Iterable<XRJointSpace> {
     readonly LITTLE_PHALANX_TIP: number;
 }
 
+abstract class XRHand extends Map implements XRHand {}
+
+interface XRFrame {
+    getJointPose?: (joint: XRJointSpace, baseSpace: XRSpace) => XRJointPose | undefined;
+}
+
+// WebXR Layers
+
+/**
+ * The base class for XRWebGLLayer and other layer types introduced by future extensions.
+ * ref: https://immersive-web.github.io/webxr/#xrlayer-interface
+ */
+// tslint:disable-next-line no-empty-interface
+interface XRLayer extends EventTarget {}
+
+abstract class XRLayer implements XRLayer {}
+
+interface XRWebGLLayerInit {
+    antialias?: boolean | undefined;
+    depth?: boolean | undefined;
+    stencil?: boolean | undefined;
+    alpha?: boolean | undefined;
+    ignoreDepthValues?: boolean | undefined;
+    framebufferScaleFactor?: number | undefined;
+}
+
+/**
+ * A layer which provides a WebGL framebuffer to render into, enabling hardware accelerated
+ * rendering of 3D graphics to be presented on the XR device. *
+ * ref: https://immersive-web.github.io/webxr/#xrwebgllayer-interface
+ */
+class XRWebGLLayer extends XRLayer {
+    static getNativeFramebufferScaleFactor(session: XRSession): number;
+
+    constructor(session: XRSession, context: WebGLRenderingContext | WebGL2RenderingContext, layerInit?: XRWebGLLayerInit);
+
+    readonly antialias: boolean;
+    readonly ignoreDepthValues: boolean;
+    fixedFoveation?: number | undefined;
+
+    readonly framebuffer: WebGLFramebuffer;
+    readonly framebufferWidth: number;
+    readonly framebufferHeight: number;
+
+    getViewport(view: XRView): XRViewport | undefined;
+}
+
+interface XRRenderStateInit {
+    layers?: XRLayer[] | undefined;
+}
+
+interface XRRenderState {
+    readonly layers?: XRLayer[] | undefined;
+}
+
+type XRLayerEventType = "redraw";
+
+interface XRLayerEvent extends Event {
+    readonly type: XRLayerEventType;
+    readonly layer: XRLayer;
+}
+
+interface XRCompositionLayerEventMap {
+    redraw: XRLayerEvent;
+}
+
+interface XRCompositionLayer extends XRLayer {
+    readonly layout: XRLayerLayout;
+    blendTextureSourceAlpha: boolean;
+    chromaticAberrationCorrection?: boolean | undefined;
+    readonly mipLevels: number;
+    readonly needsRedraw: boolean;
+    destroy(): void;
+
+    space: XRSpace;
+
+    // Events
+    onredraw: (evt: XRCompositionLayerEventMap["redraw"]) => any;
+
+    addEventListener<K extends keyof XRCompositionLayerEventMap>(
+        this: XRCompositionLayer,
+        type: K,
+        callback: (evt: XRCompositionLayerEventMap[K]) => any,
+        options?: boolean | AddEventListenerOptions
+    ): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+
+    removeEventListener<K extends keyof XRCompositionLayerEventMap>(this: XRCompositionLayer, type: K, callback: (evt: XRCompositionLayerEventMap[K]) => any): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
+
+abstract class XRCompositionLayer implements XRCompositionLayer {}
+
+type XRTextureType = "texture" | "texture-array";
+
+type XRLayerLayout = "default" | "mono" | "stereo" | "stereo-left-right" | "stereo-top-bottom";
+
+interface XRProjectionLayerInit {
+    scaleFactor?: number | undefined;
+    textureType?: XRTextureType | undefined;
+    colorFormat?: GLenum | undefined;
+    depthFormat?: GLenum | undefined;
+}
+
+interface XRProjectionLayer extends XRCompositionLayer {
+    readonly textureWidth: number;
+    readonly textureHeight: number;
+    readonly textureArrayLength: number;
+    readonly ignoreDepthValues: number;
+    fixedFoveation: number;
+}
+
+abstract class XRProjectionLayer implements XRProjectionLayer {}
+
+interface XRLayerInit {
+    mipLevels?: number | undefined;
+    viewPixelWidth: number;
+    viewPixelHeight: number;
+    isStatic?: boolean | undefined;
+    colorFormat?: GLenum | undefined;
+    depthFormat?: GLenum | undefined;
+    space: XRSpace;
+    layout?: XRLayerLayout | undefined;
+}
+
+interface XRMediaLayerInit {
+    invertStereo?: boolean | undefined;
+    space: XRSpace;
+    layout?: XRLayerLayout | undefined;
+}
+
+interface XRCylinderLayerInit extends XRLayerInit {
+    textureType?: XRTextureType | undefined;
+    transform: XRRigidTransform;
+    radius?: number | undefined;
+    centralAngle?: number | undefined;
+    aspectRatio?: number | undefined;
+}
+
+interface XRMediaCylinderLayerInit extends XRMediaLayerInit {
+    transform?: XRRigidTransform | undefined;
+    radius?: number | undefined;
+    centralAngle?: number | undefined;
+    aspectRatio?: number | undefined;
+}
+
+interface XRCylinderLayer extends XRCompositionLayer {
+    transform: XRRigidTransform;
+    radius: number;
+    centralAngle: number;
+    aspectRatio: number;
+}
+
+abstract class XRCylinderLayer implements XRCylinderLayer {}
+
+interface XRQuadLayerInit extends XRLayerInit {
+    textureType?: XRTextureType | undefined;
+    transform?: XRRigidTransform | undefined;
+    width?: number | undefined;
+    height?: number | undefined;
+}
+
+interface XRMediaQuadLayerInit extends XRMediaLayerInit {
+    transform?: XRRigidTransform | undefined;
+    width?: number | undefined;
+    height?: number | undefined;
+}
+
+interface XRQuadLayer extends XRCompositionLayer {
+    transform: XRRigidTransform;
+    width: number;
+    height: number;
+}
+
+abstract class XRQuadLayer implements XRQuadLayer {}
+
+interface XREquirectLayerInit extends XRLayerInit {
+    textureType?: XRTextureType | undefined;
+    transform?: XRRigidTransform | undefined;
+    radius?: number | undefined;
+    centralHorizontalAngle?: number | undefined;
+    upperVerticalAngle?: number | undefined;
+    lowerVerticalAngle?: number | undefined;
+}
+
+interface XRMediaEquirectLayerInit extends XRMediaLayerInit {
+    transform?: XRRigidTransform | undefined;
+    radius?: number | undefined;
+    centralHorizontalAngle?: number | undefined;
+    upperVerticalAngle?: number | undefined;
+    lowerVerticalAngle?: number | undefined;
+}
+
+interface XREquirectLayer extends XRCompositionLayer {
+    transform: XRRigidTransform;
+    radius: number;
+    centralHorizontalAngle: number;
+    upperVerticalAngle: number;
+    lowerVerticalAngle: number;
+}
+
+abstract class XREquirectLayer implements XREquirectLayer {}
+
+interface XRCubeLayerInit extends XRLayerInit {
+    orientation?: DOMPointReadOnly | undefined;
+}
+
+interface XRCubeLayer extends XRCompositionLayer {
+    orientation: DOMPointReadOnly;
+}
+
+abstract class XRCubeLayer implements XRCubeLayer {}
+
+interface XRSubImage {
+    readonly viewport: XRViewport;
+}
+
+abstract class XRSubImage implements XRSubImage {}
+
+interface XRWebGLSubImage extends XRSubImage {
+    readonly colorTexture: WebGLTexture;
+    readonly depthStencilTexture: WebGLTexture;
+    readonly imageIndex: number;
+    readonly textureWidth: number;
+    readonly textureHeight: number;
+}
+
+abstract class XRWebGLSubImage implements XRWebGLSubImage {}
+
+class XRWebGLBinding {
+    readonly nativeProjectionScaleFactor: number;
+
+    constructor(session: XRSession, context: WebGLRenderingContext);
+
+    createProjectionLayer(init?: XRProjectionLayerInit): XRProjectionLayer;
+    createQuadLayer(init?: XRQuadLayerInit): XRQuadLayer;
+    createCylinderLayer(init?: XRCylinderLayerInit): XRCylinderLayer;
+    createEquirectLayer(init?: XREquirectLayerInit): XREquirectLayer;
+    createCubeLayer(init?: XRCubeLayerInit): XRCubeLayer;
+
+    getSubImage(layer: XRCompositionLayer, frame: XRFrame, eye?: XREye): XRWebGLSubImage;
+    getViewSubImage(layer: XRProjectionLayer, view: XRView): XRWebGLSubImage;
+
+    // BABYLON addition
+    getReflectionCubeMap: (lightProbe: XRLightProbe) => WebGLTexture;
+}
+
+class XRMediaBinding {
+    constructor(sesion: XRSession);
+
+    createQuadLayer(video: HTMLVideoElement, init?: XRMediaQuadLayerInit): XRQuadLayer;
+    createCylinderLayer(video: HTMLVideoElement, init?: XRMediaCylinderLayerInit): XRCylinderLayer;
+    createEquirectLayer(video: HTMLVideoElement, init?: XRMediaEquirectLayerInit): XREquirectLayer;
+}
+
+// WebGL extensions
+interface WebGLRenderingContextBase {
+    getExtension(extensionName: "OCULUS_multiview"): OCULUS_multiview | null;
+}
+
+enum XOVR_multiview2 {
+    FRAMEBUFFER_ATTACHMENT_TEXTURE_NUM_VIEWS_OVR = 0x9630,
+    FRAMEBUFFER_ATTACHMENT_TEXTURE_BASE_VIEW_INDEX_OVR = 0x9632,
+    MAX_VIEWS_OVR = 0x9631,
+    FRAMEBUFFER_INCOMPLETE_VIEW_TARGETS_OVR = 0x9633,
+}
+
+interface OVR_multiview2 {
+    readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_NUM_VIEWS_OVR: number;
+    readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_BASE_VIEW_INDEX_OVR: number;
+    readonly MAX_VIEWS_OVR: number;
+    readonly FRAMEBUFFER_INCOMPLETE_VIEW_TARGETS_OVR: number;
+
+    framebufferTextureMultiviewOVR(target: GLenum, attachment: GLenum, texture: WebGLTexture, level: number, baseViewIndex: number, numViews: number): WebGLRenderbuffer;
+}
+
+abstract class OVR_multiview2 implements OVR_multiview2 {}
+
+// Oculus extensions
+interface XRSessionGrant {
+    mode: XRSessionMode;
+}
+
+interface XRSystemSessionGrantedEvent extends Event {
+    type: "sessiongranted";
+    session: XRSessionGrant;
+}
+
+interface XRSystemSessionGrantedEventHandler {
+    (event: XRSystemSessionGrantedEvent): any;
+}
+
+interface XRSystemEventMap {
+    // Session Grant events are an Meta Oculus Browser extension
+    sessiongranted: XRSystemSessionGrantedEvent;
+}
+
+interface XRSystem {
+    onsessiongranted: XRSystemSessionGrantedEventHandler | null;
+}
+
+interface OCULUS_multiview extends OVR_multiview2 {
+    framebufferTextureMultisampleMultiviewOVR(
+        target: GLenum,
+        attachment: GLenum,
+        texture: WebGLTexture | null,
+        level: GLint,
+        samples: GLsizei,
+        baseViewIndex: GLint,
+        numViews: GLsizei
+    ): void;
+}
+
+abstract class OCULUS_multiview implements OCULUS_multiview {}
+
+/**
+ * BEGIN: WebXR DOM Overlays Module
+ * https://immersive-web.github.io/dom-overlays/
+ */
+
+interface GlobalEventHandlersEventMap {
+    beforexrselect: XRSessionEvent;
+}
+
+interface GlobalEventHandlers {
+    /**
+     * An XRSessionEvent of type beforexrselect is dispatched on the DOM overlay
+     * element before generating a WebXR selectstart input event if the -Z axis
+     * of the input source's targetRaySpace intersects the DOM overlay element
+     * at the time the input device's primary action is triggered.
+     */
+    onbeforexrselect: ((this: GlobalEventHandlers, ev: XRSessionEvent) => any) | null;
+}
+
+interface XRDOMOverlayInit {
+    root: Element;
+}
+
+interface XRSessionInit {
+    domOverlay?: XRDOMOverlayInit | undefined;
+}
+
+type XRDOMOverlayType = "screen" | "floating" | "head-locked";
+
+interface XRDOMOverlayState {
+    type: XRDOMOverlayType;
+}
+
+interface XRSession {
+    readonly domOverlayState?: XRDOMOverlayState | undefined;
+}
+
+/// BABYLON EDITS
+interface XREyeTrackingSourceEvent extends Event {
+    readonly gazeSpace: XRSpace;
+}
+
+interface XRFrame {
+    fillPoses?(spaces: XRSpace[], baseSpace: XRSpace, transforms: Float32Array): boolean;
+    // Anchors
+    trackedAnchors?: XRAnchorSet;
+    createAnchor?(pose: XRRigidTransform, space: XRSpace): Promise<XRAnchor>;
+    // World geometries. DEPRECATED
+    worldInformation?: XRWorldInformation;
+    detectedPlanes?: XRPlaneSet;
+    // Hand tracking
+    getJointPose?(joint: XRJointSpace, baseSpace: XRSpace): XRJointPose;
+    fillJointRadii?(jointSpaces: XRJointSpace[], radii: Float32Array): boolean;
+    // Image tracking
+    getImageTrackingResults?(): Array<XRImageTrackingResult>;
+    getLightEstimate(xrLightProbe: XRLightProbe): XRLightEstimate;
+}
+
+type XREventType = keyof XRSessionEventMap;
+
 type XRImageTrackingState = "tracked" | "emulated";
 type XRImageTrackingScore = "untrackable" | "trackable";
 
@@ -2822,6 +3399,54 @@ interface XRImageTrackingResult {
     readonly trackingState: XRImageTrackingState;
     readonly measuredWidthInMeters: number;
 }
+
+interface XRPose {
+    readonly linearVelocity?: DOMPointReadOnly;
+    readonly angularVelocity?: DOMPointReadOnly;
+}
+
+type XRLightProbeInit = {
+    reflectionFormat: XRReflectionFormat;
+};
+
+type XRReflectionFormat = "srgba8" | "rgba16f";
+
+interface XRSession {
+    readonly preferredReflectionFormat?: XRReflectionFormat;
+    /**
+     * The XRSession interface is extended with the ability to create new XRLightProbe instances.
+     * XRLightProbe instances have a session object, which is the XRSession that created this XRLightProbe.
+     *
+     * Can reject with with a "NotSupportedError" DOMException
+     */
+    requestLightProbe(options?: XRLightProbeInit): Promise<XRLightProbe>;
+
+    getTrackedImageScores?(): Promise<XRImageTrackingScore[]>;
+}
+
+interface XRWorldInformation {
+    detectedPlanes?: XRPlaneSet;
+}
+
+interface XRSessionInit {
+    trackedImages?: XRTrackedImageInit[];
+}
+
+interface XRLightEstimate {
+    readonly sphericalHarmonicsCoefficients: Float32Array;
+    readonly primaryLightDirection: DOMPointReadOnly;
+    readonly primaryLightIntensity: DOMPointReadOnly;
+}
+
+interface XRLightProbe extends EventTarget {
+    readonly probeSpace: XRSpace;
+    onreflectionchange: XREventHandler;
+}
+
+/**
+ * END: WebXR DOM Overlays Module
+ * https://immersive-web.github.io/dom-overlays/
+ */
 
 // This file contains native only extensions for WebXR. These APIs are not supported in the browser yet.
 // They are intended for use with either Babylon Native https://github.com/BabylonJS/BabylonNative or