@babylonjs/core 7.16.0 → 7.16.1

package/Engines/engine.d.ts

@@ -460,2652 +460,2652 @@ export declare class Engine extends ThinEngine {
 
 // Mixins
 declare global{
-/* eslint-disable no-var */
-/* eslint-disable @typescript-eslint/naming-convention */
-// Mixins
-interface Window {
-    mozIndexedDB: IDBFactory;
-    webkitIndexedDB: IDBFactory;
-    msIndexedDB: IDBFactory;
-    webkitURL: typeof URL;
-    mozRequestAnimationFrame(callback: FrameRequestCallback): number;
-    oRequestAnimationFrame(callback: FrameRequestCallback): number;
-    WebGLRenderingContext: WebGLRenderingContext;
-    CANNON: any;
-    AudioContext: AudioContext;
-    webkitAudioContext: AudioContext;
-    PointerEvent: any;
-    Math: Math;
-    Uint8Array: Uint8ArrayConstructor;
-    Float32Array: Float32ArrayConstructor;
-    mozURL: typeof URL;
-    msURL: typeof URL;
-    DracoDecoderModule: any;
-    setImmediate(handler: (...args: any[]) => void): number;
+// 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
+// Babylon React Native: https://github.com/BabylonJS/BabylonReactNative
+
+type XRSceneObjectType = "unknown" | "background" | "wall" | "floor" | "ceiling" | "platform" | "inferred" | "world";
+
+interface XRSceneObject {
+    type: XRSceneObjectType;
 }
 
-interface WorkerGlobalScope {
-    importScripts: (...args: string[]) => void;
+interface XRFieldOfView {
+    angleLeft: number;
+    angleRight: number;
+    angleUp: number;
+    angleDown: number;
 }
 
-type WorkerSelf = WindowOrWorkerGlobalScope & WorkerGlobalScope;
+interface XRFrustum {
+    position: DOMPointReadOnly;
+    orientation: DOMPointReadOnly;
+    fieldOfView: XRFieldOfView;
+    farDistance: number;
+}
 
-interface HTMLCanvasElement {
-    requestPointerLock(): void;
-    msRequestPointerLock?(): void;
-    mozRequestPointerLock?(): void;
-    webkitRequestPointerLock?(): void;
+interface XRPlane {
+    parentSceneObject?: XRSceneObject;
+}
 
-    /** Track whether a record is in progress */
-    isRecording: boolean;
-    /** Capture Stream method defined by some browsers */
-    captureStream(fps?: number): MediaStream;
+// extending the webxr XRMesh with babylon native properties
+interface XRMesh {
+    normals?: Float32Array;
+    parentSceneObject?: XRSceneObject;
+    positions: Float32Array; // Babylon native!
 }
 
-interface CanvasRenderingContext2D {
-    msImageSmoothingEnabled: boolean;
+interface XRFrustumDetectionBoundary {
+    type: "frustum";
+    frustum: XRFrustum;
 }
 
-// Babylon Extension to enable UIEvents to work with our IUIEvents
-interface UIEvent {
-    inputIndex: number;
+interface XRSphereDetectionBoundary {
+    type: "sphere";
+    radius: number;
 }
 
-interface MouseEvent {
-    mozMovementX: number;
-    mozMovementY: number;
-    webkitMovementX: number;
-    webkitMovementY: number;
-    msMovementX: number;
-    msMovementY: number;
+interface XRBoxDetectionBoundary {
+    type: "box";
+    extent: DOMPointReadOnly;
 }
 
-interface Navigator {
-    mozGetVRDevices: (any: any) => any;
-    webkitGetUserMedia(constraints: MediaStreamConstraints, successCallback: any, errorCallback: any): void;
-    mozGetUserMedia(constraints: MediaStreamConstraints, successCallback: any, errorCallback: any): void;
-    msGetUserMedia(constraints: MediaStreamConstraints, successCallback: any, errorCallback: any): void;
+type XRDetectionBoundary = XRFrustumDetectionBoundary | XRSphereDetectionBoundary | XRBoxDetectionBoundary;
 
-    webkitGetGamepads(): Gamepad[];
-    msGetGamepads(): Gamepad[];
-    webkitGamepads(): Gamepad[];
+interface XRGeometryDetectorOptions {
+    detectionBoundary?: XRDetectionBoundary;
+    updateInterval?: number;
 }
 
-interface HTMLVideoElement {
-    mozSrcObject: any;
+interface XRSession {
+    trySetFeaturePointCloudEnabled(enabled: boolean): boolean;
+    trySetPreferredPlaneDetectorOptions(preferredOptions: XRGeometryDetectorOptions): boolean;
+    trySetMeshDetectorEnabled(enabled: boolean): boolean;
+    trySetPreferredMeshDetectorOptions(preferredOptions: XRGeometryDetectorOptions): boolean;
 }
 
-interface Math {
-    fround(x: number): number;
-    imul(a: number, b: number): number;
-    log2(x: number): number;
+interface XRFrame {
+    featurePointCloud?: Array<number> | undefined;
 }
 
-interface OffscreenCanvas extends EventTarget {
-    width: number;
-    height: number;
+interface XRWorldInformation {
+    detectedMeshes?: XRMeshSet;
 }
+
+/* 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
 
-var OffscreenCanvas: {
-    prototype: OffscreenCanvas;
-    new (width: number, height: number): OffscreenCanvas;
-};
-
-// Experimental Pressure API https://wicg.github.io/compute-pressure/
-type PressureSource = "cpu";
-
-type PressureState = "nominal" | "fair" | "serious" | "critical";
-
-type PressureFactor = "thermal" | "power-supply";
+// 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
+//
 
-interface PressureRecord {
-    source: PressureSource;
-    state: PressureState;
-    factors: ReadonlyArray<PressureFactor>;
-    time: number;
+/**
+ * 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;
 }
 
-interface PressureObserver {
-    observe(source: PressureSource): void;
-    unobserve(source: PressureSource): void;
-    disconnect(): void;
-    takeRecords(): Array<PressureRecord>;
+/**
+ * WebGL Context Compatability
+ *
+ * ref: https://immersive-web.github.io/webxr/#contextcompatibility
+ */
+interface WebGLContextAttributes {
+    xrCompatible?: boolean | undefined;
 }
 
-interface PressureObserverOptions {
-    sampleRate?: number;
+interface WebGLRenderingContextBase {
+    makeXRCompatible(): Promise<void>;
 }
 
-type PressureUpdateCallback = (changes: Array<PressureRecord>, observer: PressureObserver) => void;
+/**
+ * Available session modes
+ *
+ * ref: https://immersive-web.github.io/webxr/#xrsessionmode-enum
+ */
+type XRSessionMode = "inline" | "immersive-vr" | "immersive-ar";
 
-const PressureObserver: {
-    prototype: PressureObserver;
-    new (callback: PressureUpdateCallback, options?: PressureObserverOptions): PressureObserver;
+/**
+ * Reference space types
+ */
+type XRReferenceSpaceType = "viewer" | "local" | "local-floor" | "bounded-floor" | "unbounded";
+
+type XREnvironmentBlendMode = "opaque" | "additive" | "alpha-blend";
 
-    knownSources: ReadonlyArray<PressureSource>;
-};
-
 /**
- * TODO: remove this file when we upgrade to TypeScript 5.0
+ * ref: https://immersive-web.github.io/webxr/#xrsession-interface
+ */
+type XRVisibilityState = "visible" | "visible-blurred" | "hidden";
+
+/**
+ * Handedness types
  */
+type XRHandedness = "none" | "left" | "right";
 
-/* eslint-disable no-var */
-/* eslint-disable @typescript-eslint/naming-convention */
-interface OffscreenCanvasEventMap {
-    contextlost: Event;
-    contextrestored: Event;
+/**
+ * InputSource target ray modes
+ */
+type XRTargetRayMode = "gaze" | "tracked-pointer" | "screen" | "transient-pointer";
+
+/**
+ * Eye types
+ */
+type XREye = "none" | "left" | "right";
+
+type XRFrameRequestCallback = (time: DOMHighResTimeStamp, frame: XRFrame) => void;
+
+interface XRSystemDeviceChangeEvent extends Event {
+    type: "devicechange";
 }
 
-interface ImageEncodeOptions {
-    quality?: number;
-    type?: string;
+interface XRSystemDeviceChangeEventHandler {
+    (event: XRSystemDeviceChangeEvent): any;
 }
 
-// These types are only needed for older versions of typescript.
-// The BJS addition is only needed because otherwise it is a type duplicate definition
-type OffscreenRenderingContextIdBJS = "2d" | "bitmaprenderer" | "webgl" | "webgl2" | "webgpu";
-type OffscreenRenderingContextBJS = OffscreenCanvasRenderingContext2D | ImageBitmapRenderingContext | WebGLRenderingContext | WebGL2RenderingContext;
+interface XRSystemEventMap {
+    devicechange: XRSystemDeviceChangeEvent;
+}
 
-interface OffscreenCanvas extends EventTarget {
+/**
+ * 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 {
     /**
-     * These attributes return the dimensions of the OffscreenCanvas object's bitmap.
-     *
-     * They can be set, to replace the bitmap with a new, transparent black bitmap of the specified dimensions (effectively resizing it).
+     * Attempts to initialize an XRSession for the given mode if possible, entering immersive
+     * mode if necessary.
+     * @param mode
+     * @param options
      */
-    height: number;
-    oncontextlost: ((this: OffscreenCanvas, ev: Event) => any) | null;
-    oncontextrestored: ((this: OffscreenCanvas, ev: Event) => any) | null;
+    requestSession(mode: XRSessionMode, options?: XRSessionInit): Promise<XRSession>;
+
     /**
-     * These attributes return the dimensions of the OffscreenCanvas object's bitmap.
-     *
-     * They can be set, to replace the bitmap with a new, transparent black bitmap of the specified dimensions (effectively resizing it).
+     * Queries if a given mode may be supported by the user agent and device capabilities.
+     * @param mode
      */
-    width: number;
-    /**
-     * Returns a promise that will fulfill with a new Blob object representing a file containing the image in the OffscreenCanvas object.
-     *
-     * The argument, if provided, is a dictionary that controls the encoding options of the image file to be created. The type field specifies the file format and has a default value of "image/png"; that type is also used if the requested type isn't supported. If the image format supports variable quality (such as "image/jpeg"), then the quality field is a number in the range 0.0 to 1.0 inclusive indicating the desired quality level for the resulting image.
-     */
-    convertToBlob(options?: ImageEncodeOptions): Promise<Blob>;
-    /**
-     * Returns an object that exposes an API for drawing on the OffscreenCanvas object. contextId specifies the desired API: "2d", "bitmaprenderer", "webgl", or "webgl2". options is handled by that API.
-     *
-     * This specification defines the "2d" context below, which is similar but distinct from the "2d" context that is created from a canvas element. The WebGL specifications define the "webgl" and "webgl2" contexts. [WEBGL]
-     *
-     * Returns null if the canvas has already been initialized with another context type (e.g., trying to get a "2d" context after getting a "webgl" context).
-     */
-    getContext(contextId: "2d", options?: any): OffscreenCanvasRenderingContext2D | null;
-    getContext(contextId: "bitmaprenderer", options?: any): ImageBitmapRenderingContext | null;
-    getContext(contextId: "webgl", options?: any): WebGLRenderingContext | null;
-    getContext(contextId: "webgl2", options?: any): WebGL2RenderingContext | null;
-    getContext(contextId: OffscreenRenderingContextIdBJS, options?: any): OffscreenRenderingContextBJS | null;
-    /** Returns a newly created ImageBitmap object with the image in the OffscreenCanvas object. The image in the OffscreenCanvas object is replaced with a new blank image. */
-    transferToImageBitmap(): ImageBitmap;
-    addEventListener<K extends keyof OffscreenCanvasEventMap>(
-        type: K,
-        listener: (this: OffscreenCanvas, ev: OffscreenCanvasEventMap[K]) => any,
-        options?: boolean | AddEventListenerOptions
-    ): void;
+    isSessionSupported(mode: XRSessionMode): Promise<boolean>;
+
+    ondevicechange: XRSystemDeviceChangeEventHandler | null;
+
+    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 OffscreenCanvasEventMap>(
-        type: K,
-        listener: (this: OffscreenCanvas, ev: OffscreenCanvasEventMap[K]) => any,
-        options?: boolean | EventListenerOptions
-    ): 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;
 }
 
-var OffscreenCanvas: {
-    prototype: OffscreenCanvas;
-    new (width: number, height: number): OffscreenCanvas;
-};
+abstract class XRSystem implements XRSystem {}
 
-interface OffscreenCanvasRenderingContext2D
-    extends CanvasCompositing,
-        CanvasDrawImage,
-        CanvasDrawPath,
-        CanvasFillStrokeStyles,
-        CanvasFilters,
-        CanvasImageData,
-        CanvasImageSmoothing,
-        CanvasPath,
-        CanvasPathDrawingStyles,
-        CanvasRect,
-        CanvasShadowStyles,
-        CanvasState,
-        CanvasText,
-        CanvasTextDrawingStyles,
-        CanvasTransform {
-    readonly canvas: OffscreenCanvas;
-    commit(): void;
+/**
+ * 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;
+    readonly width: number;
+    readonly height: number;
 }
 
-var OffscreenCanvasRenderingContext2D: {
-    prototype: OffscreenCanvasRenderingContext2D;
-    new (): OffscreenCanvasRenderingContext2D;
-};
-
-/* eslint-disable no-var */
-/* eslint-disable @typescript-eslint/naming-convention */
-// Type definitions for WebGL 2 extended with Babylon specific types
-
-interface WebGL2RenderingContext extends WebGL2RenderingContextBase {
-    HALF_FLOAT_OES: number;
-    RGBA16F: typeof WebGL2RenderingContext.RGBA16F;
-    RGBA32F: typeof WebGL2RenderingContext.RGBA32F;
-    DEPTH24_STENCIL8: typeof WebGL2RenderingContext.DEPTH24_STENCIL8;
-    COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR: number;
-    COMPRESSED_SRGB_S3TC_DXT1_EXT: number;
-    COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT: number;
-    COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT: number;
-    COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT: number;
-    COMPRESSED_SRGB8_ETC2: number;
-    COMPRESSED_SRGB8_ALPHA8_ETC2_EAC: number;
-    DRAW_FRAMEBUFFER: typeof WebGL2RenderingContext.DRAW_FRAMEBUFFER;
-    UNSIGNED_INT_24_8: typeof WebGL2RenderingContext.UNSIGNED_INT_24_8;
-    MIN: typeof WebGL2RenderingContext.MIN;
-    MAX: typeof WebGL2RenderingContext.MAX;
-}
+abstract class XRViewport implements XRViewport {}
 
-interface EXT_disjoint_timer_query {
-    QUERY_COUNTER_BITS_EXT: number;
-    TIME_ELAPSED_EXT: number;
-    TIMESTAMP_EXT: number;
-    GPU_DISJOINT_EXT: number;
-    QUERY_RESULT_EXT: number;
-    QUERY_RESULT_AVAILABLE_EXT: number;
-    queryCounterEXT(query: WebGLQuery, target: number): void;
-    createQueryEXT(): WebGLQuery;
-    beginQueryEXT(target: number, query: WebGLQuery): void;
-    endQueryEXT(target: number): void;
-    getQueryObjectEXT(query: WebGLQuery, target: number): any;
-    deleteQueryEXT(query: WebGLQuery): void;
-}
+/**
+ * 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 {}
 
-interface WebGLProgram {
-    __SPECTOR_rebuildProgram?:
-        | ((vertexSourceCode: string, fragmentSourceCode: string, onCompiled: (program: WebGLProgram) => void, onError: (message: string) => void) => void)
-        | null;
-}
+abstract class XRSpace implements XRSpace {}
 
-interface WebGLUniformLocation {
-    _currentState: any;
-}
-
-/* eslint-disable babylonjs/available */
-/* eslint-disable @typescript-eslint/naming-convention */
-interface GPUObjectBase {
-    label: string | undefined;
+interface XRRenderStateInit {
+    baseLayer?: XRWebGLLayer | undefined;
+    depthFar?: number | undefined;
+    depthNear?: number | undefined;
+    inlineVerticalFieldOfView?: number | undefined;
 }
 
-interface GPUObjectDescriptorBase {
-    label?: string;
+interface XRRenderState {
+    readonly baseLayer?: XRWebGLLayer | undefined;
+    readonly depthFar: number;
+    readonly depthNear: number;
+    readonly inlineVerticalFieldOfView?: number | undefined;
 }
 
-interface GPUSupportedLimits {
-    [name: string]: number;
+abstract class XRRenderState implements XRRenderState {}
 
-    readonly maxTextureDimension1D: number;
-    readonly maxTextureDimension2D: number;
-    readonly maxTextureDimension3D: number;
-    readonly maxTextureArrayLayers: number;
-    readonly maxBindGroups: number;
-    readonly maxBindGroupsPlusVertexBuffers: number;
-    readonly maxBindingsPerBindGroup: number;
-    readonly maxDynamicUniformBuffersPerPipelineLayout: number;
-    readonly maxDynamicStorageBuffersPerPipelineLayout: number;
-    readonly maxSampledTexturesPerShaderStage: number;
-    readonly maxSamplersPerShaderStage: number;
-    readonly maxStorageBuffersPerShaderStage: number;
-    readonly maxStorageTexturesPerShaderStage: number;
-    readonly maxUniformBuffersPerShaderStage: number;
-    readonly maxUniformBufferBindingSize: number;
-    readonly maxStorageBufferBindingSize: number;
-    readonly minUniformBufferOffsetAlignment: number;
-    readonly minStorageBufferOffsetAlignment: number;
-    readonly maxVertexBuffers: number;
-    readonly maxBufferSize: number;
-    readonly maxVertexAttributes: number;
-    readonly maxVertexBufferArrayStride: number;
-    readonly maxInterStageShaderComponents: number;
-    readonly maxInterStageShaderVariables: number;
-    readonly maxColorAttachments: number;
-    readonly maxColorAttachmentBytesPerSample: number;
-    readonly maxComputeWorkgroupStorageSize: number;
-    readonly maxComputeInvocationsPerWorkgroup: number;
-    readonly maxComputeWorkgroupSizeX: number;
-    readonly maxComputeWorkgroupSizeY: number;
-    readonly maxComputeWorkgroupSizeZ: number;
-    readonly maxComputeWorkgroupsPerDimension: number;
+interface XRReferenceSpaceEventInit extends EventInit {
+    referenceSpace?: XRReferenceSpace | undefined;
+    transform?: XRRigidTransform | undefined;
 }
 
-type GPUSupportedFeatures = ReadonlySet<string>;
-
-type WGSLLanguageFeatures = ReadonlySet<string>;
+/**
+ * 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 GPUAdapterInfo {
-    readonly vendor: string;
-    readonly architecture: string;
-    readonly device: string;
-    readonly description: string;
+// tslint:disable-next-line no-unnecessary-class
+class XRReferenceSpaceEvent implements XRReferenceSpaceEvent {
+    constructor(type: "reset", eventInitDict?: XRReferenceSpaceEventInit);
 }
 
-interface Navigator {
-    readonly gpu: GPU | undefined;
+interface XRReferenceSpaceEventHandler {
+    (event: XRReferenceSpaceEvent): any;
 }
 
-interface WorkerNavigator {
-    readonly gpu: GPU | undefined;
+interface XRReferenceSpaceEventMap {
+    reset: XRReferenceSpaceEvent;
 }
 
-class GPU {
-    requestAdapter(options?: GPURequestAdapterOptions): Promise<GPUAdapter | undefined>;
-    getPreferredCanvasFormat(): GPUTextureFormat;
+/**
+ * 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: XRReferenceSpaceEventHandler;
 
-    readonly wgslLanguageFeatures: WGSLLanguageFeatures;
+    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 GPURequestAdapterOptions {
-    powerPreference?: GPUPowerPreference;
-    forceFallbackAdapter?: boolean /* default=false */;
+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[];
 }
 
-type GPUPowerPreference = "low-power" | "high-performance";
+abstract class XRBoundedReferenceSpace implements XRBoundedReferenceSpace {}
 
-class GPUAdapter {
-    // https://michalzalecki.com/nominal-typing-in-typescript/#approach-1-class-with-a-private-property
-    readonly name: string;
-    readonly features: GPUSupportedFeatures;
-    readonly limits: GPUSupportedLimits;
-    readonly isFallbackAdapter: boolean;
-
-    requestDevice(descriptor?: GPUDeviceDescriptor): Promise<GPUDevice>;
-    requestAdapterInfo(unmaskHints?: string[]): Promise<GPUAdapterInfo>;
-}
-
-interface GPUDeviceDescriptor extends GPUObjectDescriptorBase {
-    requiredFeatures?: GPUFeatureName[] /* default=[] */;
-    requiredLimits?: { [name: string]: GPUSize64 } /* default={} */;
-    defaultQueue?: GPUQueueDescriptor /* default={} */;
+/**
+ * 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 | undefined;
+    readonly gamepad?: Gamepad | undefined;
+    readonly profiles: string[];
+    readonly hand?: XRHand;
 }
 
-type GPUFeatureName =
-    | "depth-clip-control"
-    | "depth32float-stencil8"
-    | "texture-compression-bc"
-    | "texture-compression-etc2"
-    | "texture-compression-astc"
-    | "timestamp-query"
-    | "indirect-first-instance"
-    | "shader-f16"
-    | "rg11b10ufloat-renderable"
-    | "bgra8unorm-storage"
-    | "float32-filterable";
-
-class GPUDevice extends EventTarget implements GPUObjectBase {
-    label: string | undefined;
+abstract class XRInputSource implements XRInputSource {}
 
-    readonly features: GPUSupportedFeatures;
-    readonly limits: GPUSupportedLimits;
+/**
+ * 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;
 
-    readonly queue: GPUQueue;
+    length: number;
 
-    destroy(): void;
+    entries(): IterableIterator<[number, XRInputSource]>;
+    keys(): IterableIterator<number>;
+    values(): IterableIterator<XRInputSource>;
 
-    createBuffer(descriptor: GPUBufferDescriptor): GPUBuffer;
-    createTexture(descriptor: GPUTextureDescriptor): GPUTexture;
-    createSampler(descriptor?: GPUSamplerDescriptor): GPUSampler;
-    importExternalTexture(descriptor: GPUExternalTextureDescriptor): GPUExternalTexture;
+    forEach(callbackfn: (value: XRInputSource, index: number, array: XRInputSource[]) => void, thisArg?: any): void;
+}
 
-    createBindGroupLayout(descriptor: GPUBindGroupLayoutDescriptor): GPUBindGroupLayout;
-    createPipelineLayout(descriptor: GPUPipelineLayoutDescriptor): GPUPipelineLayout;
-    createBindGroup(descriptor: GPUBindGroupDescriptor): GPUBindGroup;
+abstract class XRInputSourceArray implements XRInputSourceArray {}
 
-    createShaderModule(descriptor: GPUShaderModuleDescriptor): GPUShaderModule;
+/**
+ * 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;
+}
 
-    createComputePipeline(descriptor: GPUComputePipelineDescriptor): GPUComputePipeline;
-    createRenderPipeline(descriptor: GPURenderPipelineDescriptor): GPURenderPipeline;
-    createComputePipelineAsync(descriptor: GPUComputePipelineDescriptor): Promise<GPUComputePipeline>;
-    createRenderPipelineAsync(descriptor: GPURenderPipelineDescriptor): Promise<GPURenderPipeline>;
+abstract class XRPose implements XRPose {}
 
-    createCommandEncoder(descriptor?: GPUCommandEncoderDescriptor): GPUCommandEncoder;
-    createRenderBundleEncoder(descriptor: GPURenderBundleEncoderDescriptor): GPURenderBundleEncoder;
+/**
+ * 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;
 
-    createQuerySet(descriptor: GPUQuerySetDescriptor): GPUQuerySet;
+    /**
+     * 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;
 
-    readonly lost: Promise<GPUDeviceLostInfo>;
-    pushErrorScope(filter: GPUErrorFilter): void;
-    popErrorScope(): Promise<GPUError | undefined>;
-    onuncapturederror: Event | undefined;
+    /**
+     * Provides the pose of the viewer relative to referenceSpace as an XRViewerPose, at the
+     * XRFrame's time.
+     *
+     * @param referenceSpace
+     */
+    getViewerPose(referenceSpace: XRReferenceSpace): XRViewerPose | undefined;
 }
 
-class GPUBuffer implements GPUObjectBase {
-    label: string | undefined;
-
-    readonly size: GPUSize64Out;
-    readonly usage: GPUFlagsConstant;
-    readonly mapState: GPUBufferMapState;
+abstract class XRFrame implements XRFrame {}
 
-    mapAsync(mode: GPUMapModeFlags, offset?: GPUSize64 /*default=0*/, size?: GPUSize64): Promise<void>;
-    getMappedRange(offset?: GPUSize64 /*default=0*/, size?: GPUSize64): ArrayBuffer;
-    unmap(): void;
+/**
+ * Type of XR events available
+ */
+type XRInputSourceEventType = "select" | "selectend" | "selectstart" | "squeeze" | "squeezeend" | "squeezestart";
 
-    destroy(): void;
+interface XRInputSourceEventInit extends EventInit {
+    frame?: XRFrame | undefined;
+    inputSource?: XRInputSource | undefined;
 }
 
-type GPUBufferMapState = "unmapped" | "pending" | "mapped";
+/**
+ * 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;
 
-interface GPUBufferDescriptor extends GPUObjectDescriptorBase {
-    size: GPUSize64;
-    usage: GPUBufferUsageFlags;
-    mappedAtCreation: boolean /* default=false */;
+    constructor(type: XRInputSourceEventType, eventInitDict?: XRInputSourceEventInit);
 }
 
-type GPUBufferUsageFlags = number;
-
-type GPUMapModeFlags = number;
-
-class GPUTexture implements GPUObjectBase {
-    label: string | undefined;
+interface XRInputSourceEventHandler {
+    (evt: XRInputSourceEvent): any;
+}
 
-    createView(descriptor?: GPUTextureViewDescriptor): GPUTextureView;
-    destroy(): void;
+type XRSessionEventType = "end" | "visibilitychange" | "frameratechange";
 
-    readonly width: GPUIntegerCoordinateOut;
-    readonly height: GPUIntegerCoordinateOut;
-    readonly depthOrArrayLayers: GPUIntegerCoordinateOut;
-    readonly mipLevelCount: GPUIntegerCoordinateOut;
-    readonly sampleCount: GPUSize32Out;
-    readonly dimension: GPUTextureDimension;
-    readonly format: GPUTextureFormat;
-    readonly usage: GPUFlagsConstant;
+interface XRSessionEventInit extends EventInit {
+    session: XRSession;
 }
 
-interface GPUTextureDescriptor extends GPUObjectDescriptorBase {
-    size: GPUExtent3D;
-    mipLevelCount?: GPUIntegerCoordinate /* default=1 */;
-    sampleCount?: GPUSize32 /* default=1 */;
-    dimension?: GPUTextureDimension /* default="2d" */;
-    format: GPUTextureFormat;
-    usage: GPUTextureUsageFlags;
-    viewFormats?: GPUTextureFormat[] /* default=[] */;
+/**
+ * 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);
 }
 
-type GPUTextureDimension = "1d" | "2d" | "3d";
-
-type GPUTextureUsageFlags = number;
+interface XRSessionEventHandler {
+    (evt: XRSessionEvent): any;
+}
 
-class GPUTextureView implements GPUObjectBase {
-    label: string | undefined;
+/**
+ * ref: https://immersive-web.github.io/webxr/#feature-dependencies
+ */
+interface XRSessionInit {
+    optionalFeatures?: string[] | undefined;
+    requiredFeatures?: string[] | undefined;
 }
 
-interface GPUTextureViewDescriptor extends GPUObjectDescriptorBase {
-    format: GPUTextureFormat;
-    dimension: GPUTextureViewDimension;
-    aspect?: GPUTextureAspect /* default="all" */;
-    baseMipLevel?: GPUIntegerCoordinate /* default=0 */;
-    mipLevelCount: GPUIntegerCoordinate;
-    baseArrayLayer?: GPUIntegerCoordinate /* default=0*/;
-    arrayLayerCount: GPUIntegerCoordinate;
+interface XRSessionEventMap {
+    inputsourceschange: XRInputSourceChangeEvent;
+    end: XRSessionEvent;
+    visibilitychange: XRSessionEvent;
+    frameratechange: XRSessionEvent;
+    select: XRInputSourceEvent;
+    selectstart: XRInputSourceEvent;
+    selectend: XRInputSourceEvent;
+    squeeze: XRInputSourceEvent;
+    squeezestart: XRInputSourceEvent;
+    squeezeend: XRInputSourceEvent;
+    eyetrackingstart: XREyeTrackingSourceEvent;
+    eyetrackingend: XREyeTrackingSourceEvent;
 }
 
-type GPUTextureViewDimension = "1d" | "2d" | "2d-array" | "cube" | "cube-array" | "3d";
+/**
+ * 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: 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;
 
-type GPUTextureAspect = "all" | "stencil-only" | "depth-only";
+    /**
+     * 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(id: number): void;
 
-type GPUTextureFormat =
-    // 8-bit formats
-    | "r8unorm"
-    | "r8snorm"
-    | "r8uint"
-    | "r8sint"
+    /**
+     * Ends the WebXR session. Returns a promise which resolves when the
+     * session has been shut down.
+     */
+    end(): Promise<void>;
 
-    // 16-bit formats
-    | "r16uint"
-    | "r16sint"
-    | "r16float"
-    | "rg8unorm"
-    | "rg8snorm"
-    | "rg8uint"
-    | "rg8sint"
+    /**
+     * 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(callback: XRFrameRequestCallback): number;
 
-    // 32-bit formats
-    | "r32uint"
-    | "r32sint"
-    | "r32float"
-    | "rg16uint"
-    | "rg16sint"
-    | "rg16float"
-    | "rgba8unorm"
-    | "rgba8unorm-srgb"
-    | "rgba8snorm"
-    | "rgba8uint"
-    | "rgba8sint"
-    | "bgra8unorm"
-    | "bgra8unorm-srgb"
-    // Packed 32-bit formats
-    | "rgb9e5ufloat"
-    | "rgb10a2uint"
-    | "rgb10a2unorm"
-    | "rg11b10ufloat"
+    /**
+     * 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>;
 
-    // 64-bit formats
-    | "rg32uint"
-    | "rg32sint"
-    | "rg32float"
-    | "rgba16uint"
-    | "rgba16sint"
-    | "rgba16float"
+    updateRenderState(renderStateInit?: XRRenderStateInit): Promise<void>;
 
-    // 128-bit formats
-    | "rgba32uint"
-    | "rgba32sint"
-    | "rgba32float"
+    updateTargetFrameRate(rate: number): Promise<void>;
 
-    // Depth and stencil formats
-    | "stencil8"
-    | "depth16unorm"
-    | "depth24plus"
-    | "depth24plus-stencil8"
-    | "depth32float"
+    onend: XRSessionEventHandler;
+    oninputsourceschange: XRInputSourceChangeEventHandler;
+    onselect: XRInputSourceEventHandler;
+    onselectstart: XRInputSourceEventHandler;
+    onselectend: XRInputSourceEventHandler;
+    onsqueeze: XRInputSourceEventHandler;
+    onsqueezestart: XRInputSourceEventHandler;
+    onsqueezeend: XRInputSourceEventHandler;
+    onvisibilitychange: XRSessionEventHandler;
+    onframeratechange: XRSessionEventHandler;
 
-    // "depth32float-stencil8" feature
-    | "depth32float-stencil8"
+    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;
+}
 
-    // BC compressed formats usable if "texture-compression-bc" is both
-    // supported by the device/user agent and enabled in requestDevice.
-    | "bc1-rgba-unorm"
-    | "bc1-rgba-unorm-srgb"
-    | "bc2-rgba-unorm"
-    | "bc2-rgba-unorm-srgb"
-    | "bc3-rgba-unorm"
-    | "bc3-rgba-unorm-srgb"
-    | "bc4-r-unorm"
-    | "bc4-r-snorm"
-    | "bc5-rg-unorm"
-    | "bc5-rg-snorm"
-    | "bc6h-rgb-ufloat"
-    | "bc6h-rgb-float"
-    | "bc7-rgba-unorm"
-    | "bc7-rgba-unorm-srgb"
+abstract class XRSession implements XRSession {}
 
-    // ETC2 compressed formats usable if "texture-compression-etc2" is both
-    // supported by the device/user agent and enabled in requestDevice.
-    | "etc2-rgb8unorm"
-    | "etc2-rgb8unorm-srgb"
-    | "etc2-rgb8a1unorm"
-    | "etc2-rgb8a1unorm-srgb"
-    | "etc2-rgba8unorm"
-    | "etc2-rgba8unorm-srgb"
-    | "eac-r11unorm"
-    | "eac-r11snorm"
-    | "eac-rg11unorm"
-    | "eac-rg11snorm"
+/**
+ * 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: ReadonlyArray<XRView>;
+}
 
-    // ASTC compressed formats usable if "texture-compression-astc" is both
-    // supported by the device/user agent and enabled in requestDevice.
-    | "astc-4x4-unorm"
-    | "astc-4x4-unorm-srgb"
-    | "astc-5x4-unorm"
-    | "astc-5x4-unorm-srgb"
-    | "astc-5x5-unorm"
-    | "astc-5x5-unorm-srgb"
-    | "astc-6x5-unorm"
-    | "astc-6x5-unorm-srgb"
-    | "astc-6x6-unorm"
-    | "astc-6x6-unorm-srgb"
-    | "astc-8x5-unorm"
-    | "astc-8x5-unorm-srgb"
-    | "astc-8x6-unorm"
-    | "astc-8x6-unorm-srgb"
-    | "astc-8x8-unorm"
-    | "astc-8x8-unorm-srgb"
-    | "astc-10x5-unorm"
-    | "astc-10x5-unorm-srgb"
-    | "astc-10x6-unorm"
-    | "astc-10x6-unorm-srgb"
-    | "astc-10x8-unorm"
-    | "astc-10x8-unorm-srgb"
-    | "astc-10x10-unorm"
-    | "astc-10x10-unorm-srgb"
-    | "astc-12x10-unorm"
-    | "astc-12x10-unorm-srgb"
-    | "astc-12x12-unorm"
-    | "astc-12x12-unorm-srgb";
+abstract class XRViewerPose implements XRViewerPose {}
 
-class GPUExternalTexture implements GPUObjectBase {
-    label: string | undefined;
+/**
+ * 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);
 }
 
-interface GPUExternalTextureDescriptor extends GPUObjectDescriptorBase {
-    source: HTMLVideoElement | VideoFrame;
-    colorSpace?: PredefinedColorSpace /* default="srgb" */;
+/**
+ * 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 | undefined;
+    requestViewportScale(scale: number): void;
 }
 
-class GPUSampler implements GPUObjectBase {
-    label: string | undefined;
+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 GPUSamplerDescriptor extends GPUObjectDescriptorBase {
-    addressModeU?: GPUAddressMode /* default="clamp-to-edge" */;
-    addressModeV?: GPUAddressMode /* default="clamp-to-edge" */;
-    addressModeW?: GPUAddressMode /* default="clamp-to-edge" */;
-    magFilter?: GPUFilterMode /* default="nearest" */;
-    minFilter?: GPUFilterMode /* default="nearest" */;
-    mipmapFilter?: GPUMipmapFilterMode /* default="nearest" */;
-    lodMinClamp?: number /* default=0 */;
-    lodMaxClamp?: number /* default=32 */;
-    compare?: GPUCompareFunction;
-    maxAnisotropy?: number /* default=1 */;
+interface XRInputSourceChangeEventHandler {
+    (evt: XRInputSourceChangeEvent): any;
 }
 
-type GPUAddressMode = "clamp-to-edge" | "repeat" | "mirror-repeat";
+// Experimental/Draft features
 
-type GPUFilterMode = "nearest" | "linear";
+// Anchors
+type XRAnchorSet = Set<XRAnchor>;
 
-type GPUMipmapFilterMode = "nearest" | "linear";
+interface XRAnchor {
+    anchorSpace: XRSpace;
+    delete(): void;
+}
 
-type GPUCompareFunction = "never" | "less" | "equal" | "less-equal" | "greater" | "not-equal" | "greater-equal" | "always";
+abstract class XRAnchor implements XRAnchor {}
 
-class GPUBindGroupLayout implements GPUObjectBase {
-    label: string | undefined;
+interface XRFrame {
+    trackedAnchors?: XRAnchorSet | undefined;
+    createAnchor?: (pose: XRRigidTransform, space: XRSpace) => Promise<XRAnchor>;
 }
 
-interface GPUBindGroupLayoutDescriptor extends GPUObjectDescriptorBase {
-    entries: GPUBindGroupLayoutEntry[];
+// AR Hit testing
+class XRRay {
+    readonly origin: DOMPointReadOnly;
+    readonly direction: DOMPointReadOnly;
+    readonly matrix: Float32Array;
+
+    constructor(transformOrOrigin?: XRRigidTransform | DOMPointInit, direction?: DOMPointInit);
 }
 
-interface GPUBindGroupLayoutEntry {
-    binding: GPUIndex32;
-    visibility: GPUShaderStageFlags;
+type XRHitTestTrackableType = "point" | "plane" | "mesh";
 
-    buffer?: GPUBufferBindingLayout;
-    sampler?: GPUSamplerBindingLayout;
-    texture?: GPUTextureBindingLayout;
-    storageTexture?: GPUStorageTextureBindingLayout;
-    externalTexture?: GPUExternalTextureBindingLayout;
+interface XRTransientInputHitTestResult {
+    readonly inputSource: XRInputSource;
+    readonly results: ReadonlyArray<XRHitTestResult>;
 }
 
-type GPUShaderStageFlags = number;
-
-type GPUBufferBindingType = "uniform" | "storage" | "read-only-storage";
-
-interface GPUBufferBindingLayout {
-    type?: GPUBufferBindingType /* default="uniform" */;
-    hasDynamicOffset?: boolean /* default=false */;
-    minBindingSize?: GPUSize64 /* default=0 */;
+class XRTransientInputHitTestResult {
+    prototype: XRTransientInputHitTestResult;
 }
 
-type GPUSamplerBindingType = "filtering" | "non-filtering" | "comparison";
-
-interface GPUSamplerBindingLayout {
-    type?: GPUSamplerBindingType /* default="filtering" */;
+interface XRHitTestResult {
+    getPose(baseSpace: XRSpace): XRPose | undefined;
+    // When anchor system is enabled
+    createAnchor?: (pose: XRRigidTransform) => Promise<XRAnchor> | undefined;
 }
 
-type GPUTextureSampleType = "float" | "unfilterable-float" | "depth" | "sint" | "uint";
+abstract class XRHitTestResult implements XRHitTestResult {}
 
-interface GPUTextureBindingLayout {
-    sampleType?: GPUTextureSampleType /* default="float" */;
-    viewDimension?: GPUTextureViewDimension /* default="2d" */;
-    multisampled?: boolean /* default=false */;
+interface XRHitTestSource {
+    cancel(): void;
 }
 
-type GPUStorageTextureAccess = "write-only" | "read-only" | "read-write";
+abstract class XRHitTestSource implements XRHitTestSource {}
 
-interface GPUStorageTextureBindingLayout {
-    access?: GPUStorageTextureAccess /* default=write-only */;
-    format: GPUTextureFormat;
-    viewDimension?: GPUTextureViewDimension /* default="2d" */;
+interface XRTransientInputHitTestSource {
+    cancel(): void;
 }
 
-interface GPUExternalTextureBindingLayout {}
+abstract class XRTransientInputHitTestSource implements XRTransientInputHitTestSource {}
 
-class GPUBindGroup implements GPUObjectBase {
-    label: string | undefined;
+interface XRHitTestOptionsInit {
+    space: XRSpace;
+    entityTypes?: XRHitTestTrackableType[] | undefined;
+    offsetRay?: XRRay | undefined;
 }
 
-interface GPUBindGroupDescriptor extends GPUObjectDescriptorBase {
-    layout: GPUBindGroupLayout;
-    entries: GPUBindGroupEntry[];
+interface XRTransientInputHitTestOptionsInit {
+    profile: string;
+    entityTypes?: XRHitTestTrackableType[] | undefined;
+    offsetRay?: XRRay | undefined;
 }
 
-type GPUBindingResource = GPUSampler | GPUTextureView | GPUBufferBinding | GPUExternalTexture;
+interface XRSession {
+    requestHitTestSource?: (options: XRHitTestOptionsInit) => Promise<XRHitTestSource>;
+    requestHitTestSourceForTransientInput?: (options: XRTransientInputHitTestOptionsInit) => Promise<XRTransientInputHitTestSource>;
 
-interface GPUBindGroupEntry {
-    binding: GPUIndex32;
-    resource: GPUBindingResource;
+    // Legacy
+    requestHitTest?: (ray: XRRay, referenceSpace: XRReferenceSpace) => Promise<XRHitResult[]>;
 }
 
-interface GPUBufferBinding {
-    buffer: GPUBuffer;
-    offset?: GPUSize64 /* default=0 */;
-    size?: GPUSize64 /* default=size_of_buffer - offset */;
+interface XRFrame {
+    getHitTestResults(hitTestSource: XRHitTestSource): XRHitTestResult[];
+    getHitTestResultsForTransientInput(hitTestSource: XRTransientInputHitTestSource): XRTransientInputHitTestResult[];
 }
 
-class GPUPipelineLayout implements GPUObjectBase {
-    label: string | undefined;
+// Legacy
+interface XRHitResult {
+    hitMatrix: Float32Array;
 }
 
-interface GPUPipelineLayoutDescriptor extends GPUObjectDescriptorBase {
-    bindGroupLayouts: GPUBindGroupLayout[];
-}
+// Plane detection
+type XRPlaneSet = Set<XRPlane>;
 
-class GPUShaderModule implements GPUObjectBase {
-    label: string | undefined;
+type XRPlaneOrientation = "horizontal" | "vertical";
 
-    getCompilationInfo(): Promise<GPUCompilationInfo>;
+interface XRPlane {
+    orientation: XRPlaneOrientation;
+    planeSpace: XRSpace;
+    polygon: DOMPointReadOnly[];
+    lastChangedTime: number;
 }
 
-interface GPUShaderModuleDescriptor extends GPUObjectDescriptorBase {
-    code: string | Uint32Array;
-    sourceMap?: object;
-    compilationHints?: GPUShaderModuleCompilationHint[] /* default=[] */;
-}
+abstract class XRPlane implements XRPlane {}
 
-interface GPUShaderModuleCompilationHint {
-    entryPoint: string | Uint32Array;
-    layout: GPUPipelineLayout | GPUAutoLayoutMode;
+interface XRSession {
+    // Legacy
+    updateWorldTrackingState?: (options: { planeDetectionState?: { enabled: boolean } | undefined }) => void | undefined;
 }
 
-type GPUCompilationMessageType = "error" | "warning" | "info";
+// interface XRFrame {
+//     worldInformation?:
+//         | {
+//               detectedPlanes?: XRPlaneSet | undefined;
+//           }
+//         | undefined;
+// }
 
-interface GPUCompilationMessage {
-    readonly message: string;
-    readonly type: GPUCompilationMessageType;
-    readonly lineNum: number;
-    readonly linePos: number;
-    readonly offset: number;
-    readonly length: number;
-}
+// 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 GPUCompilationInfo {
-    readonly messages: readonly GPUCompilationMessage[];
+interface XRJointSpace extends XRSpace {
+    readonly jointName: XRHandJoint;
 }
 
-class GPUPipelineError extends DOMException {
-    constructor(message: string | undefined, options: GPUPipelineErrorInit);
-    readonly reason: GPUPipelineErrorReason;
-}
+abstract class XRJointSpace implements XRJointSpace {}
 
-interface GPUPipelineErrorInit {
-    reason: GPUPipelineErrorReason;
+interface XRJointPose extends XRPose {
+    readonly radius: number | undefined;
 }
 
-type GPUPipelineErrorReason = "validation" | "internal";
-
-type GPUAutoLayoutMode = "auto";
-
-interface GPUPipelineDescriptorBase extends GPUObjectDescriptorBase {
-    layout: GPUPipelineLayout | GPUAutoLayoutMode;
-}
+abstract class XRJointPose implements XRJointPose {}
 
-interface GPUPipelineBase {
-    getBindGroupLayout(index: number): GPUBindGroupLayout;
-}
+interface XRHand extends Map<XRHandJoint, XRJointSpace> {
+    readonly WRIST: number;
 
-interface GPUProgrammableStage {
-    module: GPUShaderModule;
-    entryPoint: string | Uint32Array;
-    constants?: { [name: string]: GPUPipelineConstantValue };
-}
+    readonly THUMB_METACARPAL: number;
+    readonly THUMB_PHALANX_PROXIMAL: number;
+    readonly THUMB_PHALANX_DISTAL: number;
+    readonly THUMB_PHALANX_TIP: number;
 
-type GPUPipelineConstantValue = number; // May represent WGSL’s bool, f32, i32, u32, and f16 if enabled.
+    readonly INDEX_METACARPAL: number;
+    readonly INDEX_PHALANX_PROXIMAL: number;
+    readonly INDEX_PHALANX_INTERMEDIATE: number;
+    readonly INDEX_PHALANX_DISTAL: number;
+    readonly INDEX_PHALANX_TIP: number;
 
-class GPUComputePipeline implements GPUObjectBase, GPUPipelineBase {
-    label: string | undefined;
+    readonly MIDDLE_METACARPAL: number;
+    readonly MIDDLE_PHALANX_PROXIMAL: number;
+    readonly MIDDLE_PHALANX_INTERMEDIATE: number;
+    readonly MIDDLE_PHALANX_DISTAL: number;
+    readonly MIDDLE_PHALANX_TIP: number;
 
-    getBindGroupLayout(index: number): GPUBindGroupLayout;
-}
+    readonly RING_METACARPAL: number;
+    readonly RING_PHALANX_PROXIMAL: number;
+    readonly RING_PHALANX_INTERMEDIATE: number;
+    readonly RING_PHALANX_DISTAL: number;
+    readonly RING_PHALANX_TIP: number;
 
-interface GPUComputePipelineDescriptor extends GPUPipelineDescriptorBase {
-    compute: GPUProgrammableStage;
+    readonly LITTLE_METACARPAL: number;
+    readonly LITTLE_PHALANX_PROXIMAL: number;
+    readonly LITTLE_PHALANX_INTERMEDIATE: number;
+    readonly LITTLE_PHALANX_DISTAL: number;
+    readonly LITTLE_PHALANX_TIP: number;
 }
 
-class GPURenderPipeline implements GPUObjectBase, GPUPipelineBase {
-    label: string | undefined;
+abstract class XRHand extends Map<XRHandJoint, XRJointSpace> implements XRHand {}
 
-    getBindGroupLayout(index: number): GPUBindGroupLayout;
-}
+// WebXR Layers
 
-interface GPURenderPipelineDescriptor extends GPUPipelineDescriptorBase {
-    vertex: GPUVertexState;
-    primitive?: GPUPrimitiveState /* default={} */;
-    depthStencil?: GPUDepthStencilState;
-    multisample?: GPUMultisampleState /* default={} */;
-    fragment?: GPUFragmentState;
-}
+/**
+ * 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 {}
 
-interface GPUPrimitiveState {
-    topology?: GPUPrimitiveTopology /* default="triangle-list" */;
-    stripIndexFormat?: GPUIndexFormat;
-    frontFace?: GPUFrontFace /* default="ccw" */;
-    cullMode?: GPUCullMode /* default="none" */;
+abstract class XRLayer implements XRLayer {}
 
-    // Requires "depth-clip-control" feature.
-    unclippedDepth?: boolean /* default=false */;
+interface XRWebGLLayerInit {
+    antialias?: boolean | undefined;
+    depth?: boolean | undefined;
+    stencil?: boolean | undefined;
+    alpha?: boolean | undefined;
+    ignoreDepthValues?: boolean | undefined;
+    framebufferScaleFactor?: number | undefined;
 }
 
-type GPUPrimitiveTopology = "point-list" | "line-list" | "line-strip" | "triangle-list" | "triangle-strip";
+/**
+ * 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;
 
-type GPUFrontFace = "ccw" | "cw";
+    constructor(session: XRSession, context: WebGLRenderingContext | WebGL2RenderingContext, layerInit?: XRWebGLLayerInit);
 
-type GPUCullMode = "none" | "front" | "back";
+    readonly antialias: boolean;
+    readonly ignoreDepthValues: boolean;
+    fixedFoveation?: number | undefined;
 
-interface GPUMultisampleState {
-    count?: GPUSize32 /* default=1 */;
-    mask?: GPUSampleMask /* default=0xFFFFFFFF */;
-    alphaToCoverageEnabled?: boolean /* default=false */;
+    readonly framebuffer: WebGLFramebuffer;
+    readonly framebufferWidth: number;
+    readonly framebufferHeight: number;
+
+    getViewport(view: XRView): XRViewport | undefined;
 }
 
-interface GPUFragmentState extends GPUProgrammableStage {
-    targets: (GPUColorTargetState | null)[];
+interface XRRenderStateInit {
+    layers?: XRLayer[] | undefined;
 }
 
-interface GPUColorTargetState {
-    format: GPUTextureFormat;
+interface XRRenderState {
+    readonly layers?: XRLayer[] | undefined;
+}
 
-    blend?: GPUBlendState;
-    writeMask?: GPUColorWriteFlags /* default=0xF - GPUColorWrite.ALL */;
+type XRLayerEventType = "redraw";
+
+interface XRLayerEvent extends Event {
+    readonly type: XRLayerEventType;
+    readonly layer: XRLayer;
 }
 
-interface GPUBlendState {
-    color: GPUBlendComponent;
-    alpha: GPUBlendComponent;
+interface XRCompositionLayerEventMap {
+    redraw: XRLayerEvent;
 }
 
-type GPUColorWriteFlags = number;
+interface XRCompositionLayer extends XRLayer {
+    readonly layout: XRLayerLayout;
+    blendTextureSourceAlpha: boolean;
+    chromaticAberrationCorrection?: boolean | undefined;
+    readonly mipLevels: number;
+    readonly needsRedraw: boolean;
+    destroy(): void;
 
-interface GPUBlendComponent {
-    operation?: GPUBlendOperation /* default="add" */;
-    srcFactor?: GPUBlendFactor /* default="one" */;
-    dstFactor?: GPUBlendFactor /* default="zero" */;
-}
+    space: XRSpace;
 
-type GPUBlendFactor =
-    | "zero"
-    | "one"
-    | "src"
-    | "one-minus-src"
-    | "src-alpha"
-    | "one-minus-src-alpha"
-    | "dst"
-    | "one-minus-dst"
-    | "dst-alpha"
-    | "one-minus-dst-alpha"
-    | "src-alpha-saturated"
-    | "constant"
-    | "one-minus-constant";
+    // Events
+    onredraw: (evt: XRCompositionLayerEventMap["redraw"]) => any;
 
-type GPUBlendOperation = "add" | "subtract" | "reverse-subtract" | "min" | "max";
+    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;
 
-interface GPUDepthStencilState {
-    format: GPUTextureFormat;
+    removeEventListener<K extends keyof XRCompositionLayerEventMap>(this: XRCompositionLayer, type: K, callback: (evt: XRCompositionLayerEventMap[K]) => any): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
 
-    depthWriteEnabled?: boolean /* default=false */;
-    depthCompare?: GPUCompareFunction /* default="always" */;
+abstract class XRCompositionLayer implements XRCompositionLayer {}
 
-    stencilFront?: GPUStencilFaceState /* default={} */;
-    stencilBack?: GPUStencilFaceState /* default={} */;
+type XRTextureType = "texture" | "texture-array";
 
-    stencilReadMask?: GPUStencilValue /* default=0xFFFFFFFF */;
-    stencilWriteMask?: GPUStencilValue /* default=0xFFFFFFFF */;
+type XRLayerLayout = "default" | "mono" | "stereo" | "stereo-left-right" | "stereo-top-bottom";
 
-    depthBias?: GPUDepthBias /* default=0 */;
-    depthBiasSlopeScale?: number /* default= 0 */;
-    depthBiasClamp?: number /* default=0 */;
+interface XRProjectionLayerInit {
+    scaleFactor?: number | undefined;
+    textureType?: XRTextureType | undefined;
+    colorFormat?: GLenum | undefined;
+    depthFormat?: GLenum | undefined;
+    clearOnAccess?: boolean | undefined;
 }
 
-interface GPUStencilFaceState {
-    compare?: GPUCompareFunction /* default="always" */;
-    failOp?: GPUStencilOperation /* default="keep" */;
-    depthFailOp?: GPUStencilOperation /* default="keep" */;
-    passOp?: GPUStencilOperation /* default="keep" */;
+interface XRProjectionLayer extends XRCompositionLayer {
+    readonly textureWidth: number;
+    readonly textureHeight: number;
+    readonly textureArrayLength: number;
+    readonly ignoreDepthValues: number;
+    fixedFoveation: number;
 }
 
-type GPUStencilOperation = "keep" | "zero" | "replace" | "invert" | "increment-clamp" | "decrement-clamp" | "increment-wrap" | "decrement-wrap";
-
-type GPUIndexFormat = "uint16" | "uint32";
-
-type GPUVertexFormat =
-    | "uint8x2"
-    | "uint8x4"
-    | "sint8x2"
-    | "sint8x4"
-    | "unorm8x2"
-    | "unorm8x4"
-    | "snorm8x2"
-    | "snorm8x4"
-    | "uint16x2"
-    | "uint16x4"
-    | "sint16x2"
-    | "sint16x4"
-    | "unorm16x2"
-    | "unorm16x4"
-    | "snorm16x2"
-    | "snorm16x4"
-    | "float16x2"
-    | "float16x4"
-    | "float32"
-    | "float32x2"
-    | "float32x3"
-    | "float32x4"
-    | "uint32"
-    | "uint32x2"
-    | "uint32x3"
-    | "uint32x4"
-    | "sint32"
-    | "sint32x2"
-    | "sint32x3"
-    | "sint32x4"
-    | "unorm10-10-10-2";
+abstract class XRProjectionLayer implements XRProjectionLayer {}
 
-type GPUVertexStepMode = "vertex" | "instance";
+interface XRLayerInit {
+    mipLevels?: number | undefined;
+    viewPixelWidth: number;
+    viewPixelHeight: number;
+    isStatic?: boolean | undefined;
+    colorFormat?: GLenum | undefined;
+    depthFormat?: GLenum | undefined;
+    space: XRSpace;
+    layout?: XRLayerLayout | undefined;
+    clearOnAccess?: boolean | undefined;
+}
 
-interface GPUVertexState extends GPUProgrammableStage {
-    buffers?: GPUVertexBufferLayout[] /* default=[] */;
+interface XRMediaLayerInit {
+    invertStereo?: boolean | undefined;
+    space: XRSpace;
+    layout?: XRLayerLayout | undefined;
 }
 
-interface GPUVertexBufferLayout {
-    arrayStride: GPUSize64;
-    stepMode?: GPUVertexStepMode /* default="vertex" */;
-    attributes: GPUVertexAttribute[];
+interface XRCylinderLayerInit extends XRLayerInit {
+    textureType?: XRTextureType | undefined;
+    transform: XRRigidTransform;
+    radius?: number | undefined;
+    centralAngle?: number | undefined;
+    aspectRatio?: number | undefined;
 }
 
-interface GPUVertexAttribute {
-    format: GPUVertexFormat;
-    offset: GPUSize64;
-    shaderLocation: GPUIndex32;
+interface XRMediaCylinderLayerInit extends XRMediaLayerInit {
+    transform?: XRRigidTransform | undefined;
+    radius?: number | undefined;
+    centralAngle?: number | undefined;
+    aspectRatio?: number | undefined;
 }
 
-interface GPUImageDataLayout {
-    offset?: GPUSize64 /* default=0 */;
-    bytesPerRow: GPUSize32;
-    rowsPerImage?: GPUSize32;
+interface XRCylinderLayer extends XRCompositionLayer {
+    transform: XRRigidTransform;
+    radius: number;
+    centralAngle: number;
+    aspectRatio: number;
 }
 
-interface GPUImageCopyBuffer extends GPUImageDataLayout {
-    buffer: GPUBuffer;
+abstract class XRCylinderLayer implements XRCylinderLayer {}
+
+interface XRQuadLayerInit extends XRLayerInit {
+    textureType?: XRTextureType | undefined;
+    transform?: XRRigidTransform | undefined;
+    width?: number | undefined;
+    height?: number | undefined;
 }
 
-interface GPUImageCopyTexture {
-    texture: GPUTexture;
-    mipLevel?: GPUIntegerCoordinate /* default=0 */;
-    origin?: GPUOrigin3D /* default={} */;
-    aspect?: GPUTextureAspect /* default="all" */;
+interface XRMediaQuadLayerInit extends XRMediaLayerInit {
+    transform?: XRRigidTransform | undefined;
+    width?: number | undefined;
+    height?: number | undefined;
 }
 
-interface GPUImageCopyTextureTagged extends GPUImageCopyTexture {
-    colorSpace?: PredefinedColorSpace /* default="srgb" */;
-    premultipliedAlpha?: boolean /* default=false */;
+interface XRQuadLayer extends XRCompositionLayer {
+    transform: XRRigidTransform;
+    width: number;
+    height: number;
 }
 
-type GPUImageCopyExternalImageSource = ImageBitmap | ImageData | HTMLImageElement | HTMLVideoElement | VideoFrame | HTMLCanvasElement | OffscreenCanvas;
+abstract class XRQuadLayer implements XRQuadLayer {}
 
-interface GPUImageCopyExternalImage {
-    source: GPUImageCopyExternalImageSource;
-    origin?: GPUOrigin2D /* default={} */;
-    flipY?: boolean /* default=false */;
+interface XREquirectLayerInit extends XRLayerInit {
+    textureType?: XRTextureType | undefined;
+    transform?: XRRigidTransform | undefined;
+    radius?: number | undefined;
+    centralHorizontalAngle?: number | undefined;
+    upperVerticalAngle?: number | undefined;
+    lowerVerticalAngle?: number | undefined;
 }
 
-class GPUCommandBuffer implements GPUObjectBase {
-    label: string | undefined;
+interface XRMediaEquirectLayerInit extends XRMediaLayerInit {
+    transform?: XRRigidTransform | undefined;
+    radius?: number | undefined;
+    centralHorizontalAngle?: number | undefined;
+    upperVerticalAngle?: number | undefined;
+    lowerVerticalAngle?: number | undefined;
 }
 
-interface GPUCommandBufferDescriptor extends GPUObjectDescriptorBase {}
-
-interface GPUCommandsMixin {}
+interface XREquirectLayer extends XRCompositionLayer {
+    transform: XRRigidTransform;
+    radius: number;
+    centralHorizontalAngle: number;
+    upperVerticalAngle: number;
+    lowerVerticalAngle: number;
+}
 
-class GPUCommandEncoder implements GPUObjectBase, GPUCommandsMixin, GPUDebugCommandsMixin {
-    label: string | undefined;
+abstract class XREquirectLayer implements XREquirectLayer {}
 
-    beginRenderPass(descriptor: GPURenderPassDescriptor): GPURenderPassEncoder;
-    beginComputePass(descriptor?: GPUComputePassDescriptor): GPUComputePassEncoder;
+interface XRCubeLayerInit extends XRLayerInit {
+    orientation?: DOMPointReadOnly | undefined;
+}
 
-    copyBufferToBuffer(source: GPUBuffer, sourceOffset: GPUSize64, destination: GPUBuffer, destinationOffset: GPUSize64, size: GPUSize64): void;
-    copyBufferToTexture(source: GPUImageCopyBuffer, destination: GPUImageCopyTexture, copySize: GPUExtent3D): void;
-    copyTextureToBuffer(source: GPUImageCopyTexture, destination: GPUImageCopyBuffer, copySize: GPUExtent3D): void;
-    copyTextureToTexture(source: GPUImageCopyTexture, destination: GPUImageCopyTexture, copySize: GPUExtent3D): void;
-    clearBuffer(buffer: GPUBuffer, offset?: GPUSize64 /* default=0 */, size?: GPUSize64): void;
+interface XRCubeLayer extends XRCompositionLayer {
+    orientation: DOMPointReadOnly;
+}
 
-    writeTimestamp?(querySet: GPUQuerySet, queryIndex: GPUSize32): void; // not in the spec anymore, but may come back later, so keep it here for now
+abstract class XRCubeLayer implements XRCubeLayer {}
 
-    resolveQuerySet(querySet: GPUQuerySet, firstQuery: GPUSize32, queryCount: GPUSize32, destination: GPUBuffer, destinationOffset: GPUSize64): void;
+interface XRSubImage {
+    readonly viewport: XRViewport;
+}
 
-    finish(descriptor?: GPUCommandBufferDescriptor): GPUCommandBuffer;
+abstract class XRSubImage implements XRSubImage {}
 
-    pushDebugGroup(groupLabel: string): void;
-    popDebugGroup(): void;
-    insertDebugMarker(markerLabel: string): void;
+interface XRWebGLSubImage extends XRSubImage {
+    readonly colorTexture: WebGLTexture;
+    readonly depthStencilTexture?: WebGLTexture;
+    readonly motionVectorTexture?: WebGLTexture;
+    readonly imageIndex: number;
+    readonly textureWidth: number;
+    readonly textureHeight: number;
+    readonly colorTextureWidth?: number;
+    readonly colorTextureHeight?: number;
+    readonly depthStencilTextureWidth?: number;
+    readonly depthStencilTextureHeight?: number;
+    readonly motionVectorTextureWidth?: number;
+    readonly motionVectorTextureHeight?: number;
 }
 
-interface GPUCommandEncoderDescriptor extends GPUObjectDescriptorBase {}
+abstract class XRWebGLSubImage implements XRWebGLSubImage {}
 
-interface GPUBindingCommandsMixin {
-    setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup, dynamicOffsets?: GPUBufferDynamicOffset[]): void;
-    setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup, dynamicOffsetData: Uint32Array, dynamicOffsetsDataStart: GPUSize64, dynamicOffsetsDataLength: GPUSize32): void;
-}
+class XRWebGLBinding {
+    readonly nativeProjectionScaleFactor: number;
 
-interface GPUDebugCommandsMixin {
-    pushDebugGroup(groupLabel: string): void;
-    popDebugGroup(): void;
-    insertDebugMarker(markerLabel: string): void;
-}
+    constructor(session: XRSession, context: WebGLRenderingContext);
 
-class GPUComputePassEncoder implements GPUObjectBase, GPUCommandsMixin, GPUDebugCommandsMixin, GPUBindingCommandsMixin {
-    label: string | undefined;
+    createProjectionLayer(init?: XRProjectionLayerInit): XRProjectionLayer;
+    createQuadLayer(init?: XRQuadLayerInit): XRQuadLayer;
+    createCylinderLayer(init?: XRCylinderLayerInit): XRCylinderLayer;
+    createEquirectLayer(init?: XREquirectLayerInit): XREquirectLayer;
+    createCubeLayer(init?: XRCubeLayerInit): XRCubeLayer;
 
-    setBindGroup(index: number, bindGroup: GPUBindGroup, dynamicOffsets?: GPUBufferDynamicOffset[]): void;
-    setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup, dynamicOffsetData: Uint32Array, dynamicOffsetsDataStart: GPUSize64, dynamicOffsetsDataLength: GPUSize32): void;
+    getSubImage(layer: XRCompositionLayer, frame: XRFrame, eye?: XREye): XRWebGLSubImage;
+    getViewSubImage(layer: XRProjectionLayer, view: XRView): XRWebGLSubImage;
 
-    pushDebugGroup(groupLabel: string): void;
-    popDebugGroup(): void;
-    insertDebugMarker(markerLabel: string): void;
+    // BABYLON addition
+    getReflectionCubeMap: (lightProbe: XRLightProbe) => WebGLTexture;
+}
 
-    setPipeline(pipeline: GPUComputePipeline): void;
-    dispatchWorkgroups(workgroupCountX: GPUSize32, workgroupCountY?: GPUSize32 /* default=1 */, workgroupCountZ?: GPUSize32 /* default=1 */): void;
-    dispatchWorkgroupsIndirect(indirectBuffer: GPUBuffer, indirectOffset: GPUSize64): void;
+class XRMediaBinding {
+    constructor(sesion: XRSession);
 
-    end(): void;
+    createQuadLayer(video: HTMLVideoElement, init?: XRMediaQuadLayerInit): XRQuadLayer;
+    createCylinderLayer(video: HTMLVideoElement, init?: XRMediaCylinderLayerInit): XRCylinderLayer;
+    createEquirectLayer(video: HTMLVideoElement, init?: XRMediaEquirectLayerInit): XREquirectLayer;
 }
 
-interface GPUComputePassTimestampWrites {
-    querySet: GPUQuerySet;
-    beginningOfPassWriteIndex: GPUSize32;
-    endOfPassWriteIndex: GPUSize32;
+// WebGL extensions
+interface WebGLRenderingContextBase {
+    getExtension(extensionName: "OCULUS_multiview"): OCULUS_multiview | null;
 }
 
-interface GPUComputePassDescriptor extends GPUObjectDescriptorBase {
-    timestampWrites?: GPUComputePassTimestampWrites;
+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,
 }
 
-class GPURenderPassEncoder implements GPUObjectBase, GPUCommandsMixin, GPUDebugCommandsMixin, GPUBindingCommandsMixin, GPURenderCommandsMixin {
-    label: string | undefined;
+// Oculus extensions
+interface XRSessionGrant {
+    mode: XRSessionMode;
+}
 
-    setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup, dynamicOffsets?: GPUBufferDynamicOffset[]): void;
-    setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup, dynamicOffsetData: Uint32Array, dynamicOffsetsDataStart: GPUSize64, dynamicOffsetsDataLength: GPUSize32): void;
+interface XRSystemSessionGrantedEvent extends Event {
+    type: "sessiongranted";
+    session: XRSessionGrant;
+}
 
-    pushDebugGroup(groupLabel: string): void;
-    popDebugGroup(): void;
-    insertDebugMarker(markerLabel: string): void;
+interface XRSystemSessionGrantedEventHandler {
+    (event: XRSystemSessionGrantedEvent): any;
+}
 
-    setPipeline(pipeline: GPURenderPipeline): void;
+interface XRSystemEventMap {
+    // Session Grant events are an Meta Oculus Browser extension
+    sessiongranted: XRSystemSessionGrantedEvent;
+}
 
-    setIndexBuffer(buffer: GPUBuffer, indexFormat: GPUIndexFormat, offset?: GPUSize64 /* default=0 */, size?: GPUSize64 /* default=0 */): void;
-    setVertexBuffer(slot: GPUIndex32, buffer: GPUBuffer, offset?: GPUSize64 /* default=0 */, size?: GPUSize64 /* default=0 */): void;
+interface XRSystem {
+    onsessiongranted: XRSystemSessionGrantedEventHandler | null;
+}
 
-    draw(vertexCount: GPUSize32, instanceCount?: GPUSize32 /* default=1 */, firstVertex?: GPUSize32 /* default=0 */, firstInstance?: GPUSize32 /* default=0 */): void;
-    drawIndexed(
-        indexCount: GPUSize32,
-        instanceCount?: GPUSize32 /* default=1 */,
-        firstIndex?: GPUSize32 /* default=0 */,
-        baseVertex?: GPUSignedOffset32 /* default=0 */,
-        firstInstance?: GPUSize32 /* default=0 */
+interface OCULUS_multiview extends OVR_multiview2 {
+    framebufferTextureMultisampleMultiviewOVR(
+        target: GLenum,
+        attachment: GLenum,
+        texture: WebGLTexture | null,
+        level: GLint,
+        samples: GLsizei,
+        baseViewIndex: GLint,
+        numViews: GLsizei
     ): void;
+}
 
-    drawIndirect(indirectBuffer: GPUBuffer, indirectOffset: GPUSize64): void;
-    drawIndexedIndirect(indirectBuffer: GPUBuffer, indirectOffset: GPUSize64): void;
+abstract class OCULUS_multiview implements OCULUS_multiview {}
 
-    setViewport(x: number, y: number, width: number, height: number, minDepth: number, maxDepth: number): void;
+/**
+ * BEGIN: WebXR DOM Overlays Module
+ * https://immersive-web.github.io/dom-overlays/
+ */
 
-    setScissorRect(x: GPUIntegerCoordinate, y: GPUIntegerCoordinate, width: GPUIntegerCoordinate, height: GPUIntegerCoordinate): void;
+interface GlobalEventHandlersEventMap {
+    beforexrselect: XRSessionEvent;
+}
 
-    setBlendConstant(color: GPUColor): void;
-    setStencilReference(reference: GPUStencilValue): void;
+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;
+}
 
-    beginOcclusionQuery(queryIndex: GPUSize32): void;
-    endOcclusionQuery(): void;
+interface XRDOMOverlayInit {
+    root: Element;
+}
 
-    executeBundles(bundles: GPURenderBundle[]): void;
-    end(): void;
+interface XRSessionInit {
+    domOverlay?: XRDOMOverlayInit | undefined;
 }
 
-interface GPURenderPassTimestampWrites {
-    querySet: GPUQuerySet;
-    beginningOfPassWriteIndex: GPUSize32;
-    endOfPassWriteIndex: GPUSize32;
+type XRDOMOverlayType = "screen" | "floating" | "head-locked";
+
+interface XRDOMOverlayState {
+    type: XRDOMOverlayType;
 }
 
-interface GPURenderPassDescriptor extends GPUObjectDescriptorBase {
-    colorAttachments: (GPURenderPassColorAttachment | null)[];
-    depthStencilAttachment?: GPURenderPassDepthStencilAttachment;
-    occlusionQuerySet?: GPUQuerySet;
-    timestampWrites?: GPURenderPassTimestampWrites;
-    maxDrawCount?: GPUSize64 /* default=50000000 */;
+interface XRSession {
+    readonly domOverlayState?: XRDOMOverlayState | undefined;
 }
 
-interface GPURenderPassColorAttachment {
-    view: GPUTextureView;
-    depthSlice?: GPUIntegerCoordinate;
-    resolveTarget?: GPUTextureView;
+/// BABYLON EDITS
+interface XREyeTrackingSourceEvent extends XRSessionEvent {
+    readonly gazeSpace: XRSpace;
+}
 
-    clearValue?: GPUColor;
-    loadOp: GPULoadOp;
-    storeOp: GPUStoreOp;
+interface XRFrame {
+    fillPoses?(spaces: XRSpace[], baseSpace: XRSpace, transforms: Float32Array): boolean;
+    // Anchors
+    trackedAnchors?: XRAnchorSet;
+    // World geometries. DEPRECATED
+    worldInformation?: XRWorldInformation | undefined;
+    detectedPlanes?: XRPlaneSet | undefined;
+    // Hand tracking
+    getJointPose?(joint: XRJointSpace, baseSpace: XRSpace): XRJointPose;
+    fillJointRadii?(jointSpaces: XRJointSpace[], radii: Float32Array): boolean;
+    // Image tracking
+    getImageTrackingResults?(): Array<XRImageTrackingResult>;
+    getLightEstimate(xrLightProbe: XRLightProbe): XRLightEstimate;
 }
 
-interface GPURenderPassDepthStencilAttachment {
-    view: GPUTextureView;
+// Plane detection
+interface XRSession {
+    initiateRoomCapture?(): Promise<void>;
+}
 
-    depthClearValue?: number /* default=0 */;
-    depthLoadOp: GPULoadOp;
-    depthStoreOp: GPUStoreOp;
-    depthReadOnly?: boolean /* default=false */;
+type XREventType = keyof XRSessionEventMap;
 
-    stencilClearValue?: GPUStencilValue /* default=0 */;
-    stencilLoadOp?: GPULoadOp;
-    stencilStoreOp?: GPUStoreOp;
-    stencilReadOnly?: boolean /* default=false */;
-}
+type XRImageTrackingState = "tracked" | "emulated";
+type XRImageTrackingScore = "untrackable" | "trackable";
 
-type GPULoadOp = "load" | "clear";
+interface XRTrackedImageInit {
+    image: ImageBitmap;
+    widthInMeters: number;
+}
 
-type GPUStoreOp = "store" | "discard";
+interface XRImageTrackingResult {
+    readonly imageSpace: XRSpace;
+    readonly index: number;
+    readonly trackingState: XRImageTrackingState;
+    readonly measuredWidthInMeters: number;
+}
 
-interface GPURenderPassLayout extends GPUObjectDescriptorBase {
-    colorFormats: (GPUTextureFormat | null)[];
-    depthStencilFormat?: GPUTextureFormat;
-    sampleCount?: GPUSize32 /* default=1 */;
+interface XRPose {
+    readonly linearVelocity?: DOMPointReadOnly;
+    readonly angularVelocity?: DOMPointReadOnly;
 }
 
-interface GPURenderCommandsMixin {
-    setPipeline(pipeline: GPURenderPipeline): void;
+type XRLightProbeInit = {
+    reflectionFormat: XRReflectionFormat;
+};
 
-    setIndexBuffer(buffer: GPUBuffer, indexFormat: GPUIndexFormat, offset?: GPUSize64 /* default=0 */, size?: GPUSize64 /* default=0 */): void;
-    setVertexBuffer(slot: GPUIndex32, buffer: GPUBuffer, offset?: GPUSize64 /* default=0 */, size?: GPUSize64): void;
+type XRReflectionFormat = "srgba8" | "rgba16f";
 
-    draw(vertexCount: GPUSize32, instanceCount?: GPUSize32 /* default=1 */, firstVertex?: GPUSize32 /* default=0 */, firstInstance?: GPUSize32 /* default=0 */): void;
-    drawIndexed(
-        indexCount: GPUSize32,
-        instanceCount?: GPUSize32 /* default=1 */,
-        firstIndex?: GPUSize32 /* default=0 */,
-        baseVertex?: GPUSignedOffset32 /* default=0 */,
-        firstInstance?: GPUSize32 /* default=0 */
-    ): void;
+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>;
 
-    drawIndirect(indirectBuffer: GPUBuffer, indirectOffset: GPUSize64): void;
-    drawIndexedIndirect(indirectBuffer: GPUBuffer, indirectOffset: GPUSize64): void;
+    getTrackedImageScores?(): Promise<XRImageTrackingScore[]>;
 }
 
-class GPURenderBundle implements GPUObjectBase {
-    label: string | undefined;
+interface XRWorldInformation {
+    detectedPlanes?: XRPlaneSet;
 }
 
-interface GPURenderBundleDescriptor extends GPUObjectDescriptorBase {}
+interface XRSessionInit {
+    trackedImages?: XRTrackedImageInit[];
+}
 
-class GPURenderBundleEncoder implements GPUObjectBase, GPUCommandsMixin, GPUDebugCommandsMixin, GPUBindingCommandsMixin, GPURenderCommandsMixin {
-    label: string | undefined;
+interface XRLightEstimate {
+    readonly sphericalHarmonicsCoefficients: Float32Array;
+    readonly primaryLightDirection: DOMPointReadOnly;
+    readonly primaryLightIntensity: DOMPointReadOnly;
+}
 
-    setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup, dynamicOffsets?: GPUBufferDynamicOffset[]): void;
-    setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup, dynamicOffsetData: Uint32Array, dynamicOffsetsDataStart: GPUSize64, dynamicOffsetsDataLength: GPUSize32): void;
+interface XREventHandler {
+    (evt: Event): any;
+}
 
-    pushDebugGroup(groupLabel: string): void;
-    popDebugGroup(): void;
-    insertDebugMarker(markerLabel: string): void;
+interface XRLightProbe extends EventTarget {
+    readonly probeSpace: XRSpace;
+    onreflectionchange: XREventHandler;
+}
 
-    setPipeline(pipeline: GPURenderPipeline): void;
+/**
+ * END: WebXR DOM Overlays Module
+ * https://immersive-web.github.io/dom-overlays/
+ */
 
-    setIndexBuffer(buffer: GPUBuffer, indexFormat: GPUIndexFormat, offset?: GPUSize64 /* default=0 */, size?: GPUSize64 /* default=0 */): void;
-    setVertexBuffer(slot: GPUIndex32, buffer: GPUBuffer, offset?: GPUSize64 /* default=0 */, size?: GPUSize64 /* default=0 */): void;
+/**
+ * BEGIN: WebXR Depth Sensing Moudle
+ * https://www.w3.org/TR/webxr-depth-sensing-1/
+ */
 
-    draw(vertexCount: GPUSize32, instanceCount?: GPUSize32 /* default=1 */, firstVertex?: GPUSize32 /* default=0 */, firstInstance?: GPUSize32 /* default=0 */): void;
-    drawIndexed(
-        indexCount: GPUSize32,
-        instanceCount?: GPUSize32 /* default=1 */,
-        firstIndex?: GPUSize32 /* default=0 */,
-        baseVertex?: GPUSignedOffset32 /* default=0 */,
-        firstInstance?: GPUSize32 /* default=0 */
-    ): void;
+type XRDepthUsage = "cpu-optimized" | "gpu-optimized";
+type XRDepthDataFormat = "luminance-alpha" | "float32";
 
-    drawIndirect(indirectBuffer: GPUBuffer, indirectOffset: GPUSize64): void;
-    drawIndexedIndirect(indirectBuffer: GPUBuffer, indirectOffset: GPUSize64): void;
+type XRDepthStateInit = {
+    readonly usagePreference: XRDepthUsage[];
+    readonly dataFormatPreference: XRDepthDataFormat[];
+};
 
-    finish(descriptor?: GPURenderBundleDescriptor): GPURenderBundle;
+interface XRSessionInit {
+    depthSensing?: XRDepthStateInit;
 }
 
-interface GPURenderBundleEncoderDescriptor extends GPURenderPassLayout {
-    depthReadOnly?: boolean /* default=false */;
-    stencilReadOnly?: boolean /* default=false */;
+interface XRSession {
+    readonly depthUsage: XRDepthUsage;
+    readonly depthDataFormat: XRDepthDataFormat;
 }
 
-interface GPUQueueDescriptor extends GPUObjectDescriptorBase {}
+interface XRDepthInformation {
+    readonly width: number;
+    readonly height: number;
 
-class GPUQueue implements GPUObjectBase {
-    label: string | undefined;
+    readonly normDepthBufferFromNormView: XRRigidTransform;
+    readonly rawValueToMeters: number;
+}
 
-    submit(commandBuffers: GPUCommandBuffer[]): void;
+interface XRCPUDepthInformation extends XRDepthInformation {
+    readonly data: ArrayBuffer;
 
-    onSubmittedWorkDone(): Promise<void>;
+    getDepthInMeters(x: number, y: number): number;
+}
 
-    writeBuffer(buffer: GPUBuffer, bufferOffset: GPUSize64, data: BufferSource, dataOffset?: GPUSize64 /* default=0 */, size?: GPUSize64): void;
+interface XRFrame {
+    getDepthInformation(view: XRView): XRCPUDepthInformation | undefined;
+}
 
-    writeTexture(destination: GPUImageCopyTexture, data: BufferSource, dataLayout: GPUImageDataLayout, size: GPUExtent3D): void;
+interface XRWebGLDepthInformation extends XRDepthInformation {
+    readonly texture: WebGLTexture;
+}
 
-    copyExternalImageToTexture(source: GPUImageCopyExternalImage, destination: GPUImageCopyTextureTagged, copySize: GPUExtent3D): void;
+interface XRWebGLBinding {
+    getDepthInformation(view: XRView): XRWebGLDepthInformation | undefined;
 }
 
-class GPUQuerySet implements GPUObjectBase {
-    label: string | undefined;
+// enabledFeatures
+interface XRSession {
+    enabledFeatures: string[];
+}
 
-    destroy(): void;
+// Raw camera access
 
-    readonly type: GPUQueryType;
-    readonly count: GPUSize32Out;
+interface XRView {
+    readonly camera: XRCamera | undefined;
 }
 
-interface GPUQuerySetDescriptor extends GPUObjectDescriptorBase {
-    type: GPUQueryType;
-    count: GPUSize32;
+interface XRCamera {
+    readonly width: number;
+    readonly height: number;
 }
 
-type GPUQueryType = "occlusion" | "timestamp";
-
-class GPUCanvasContext {
-    readonly canvas: HTMLCanvasElement | OffscreenCanvas;
+interface XRWebGLBinding {
+    getCameraImage(camera: XRCamera): WebGLTexture | undefined;
+}
 
-    configure(configuration?: GPUCanvasConfiguration): void;
-    unconfigure(): void;
+// Mesh Detection
 
-    getCurrentTexture(): GPUTexture;
+interface XRMesh {
+    meshSpace: XRSpace;
+    vertices: Float32Array;
+    indices: Uint32Array;
+    lastChangedTime: DOMHighResTimeStamp;
 }
 
-type GPUCanvasAlphaMode = "opaque" | "premultiplied";
+type XRMeshSet = Set<XRMesh>;
 
-interface GPUCanvasConfiguration extends GPUObjectDescriptorBase {
-    device: GPUDevice;
-    format: GPUTextureFormat;
-    usage?: GPUTextureUsageFlags /* default=0x10 - GPUTextureUsage.RENDER_ATTACHMENT */;
-    viewFormats?: GPUTextureFormat[] /* default=[] */;
-    colorSpace?: PredefinedColorSpace /* default="srgb" */;
-    alphaMode?: GPUCanvasAlphaMode /* default="opaque" */;
+interface XRFrame {
+    detectedMeshes?: XRMeshSet;
+}
+
+/* eslint-disable babylonjs/available */
+/* eslint-disable @typescript-eslint/naming-convention */
+interface GPUObjectBase {
+    label: string | undefined;
 }
 
-type GPUDeviceLostReason = "unknown" | "destroyed";
-
-class GPUDeviceLostInfo {
-    readonly reason?: GPUDeviceLostReason;
-    readonly message: string;
+interface GPUObjectDescriptorBase {
+    label?: string;
 }
 
-class GPUError {
-    readonly message: string;
+interface GPUSupportedLimits {
+    [name: string]: number;
+
+    readonly maxTextureDimension1D: number;
+    readonly maxTextureDimension2D: number;
+    readonly maxTextureDimension3D: number;
+    readonly maxTextureArrayLayers: number;
+    readonly maxBindGroups: number;
+    readonly maxBindGroupsPlusVertexBuffers: number;
+    readonly maxBindingsPerBindGroup: number;
+    readonly maxDynamicUniformBuffersPerPipelineLayout: number;
+    readonly maxDynamicStorageBuffersPerPipelineLayout: number;
+    readonly maxSampledTexturesPerShaderStage: number;
+    readonly maxSamplersPerShaderStage: number;
+    readonly maxStorageBuffersPerShaderStage: number;
+    readonly maxStorageTexturesPerShaderStage: number;
+    readonly maxUniformBuffersPerShaderStage: number;
+    readonly maxUniformBufferBindingSize: number;
+    readonly maxStorageBufferBindingSize: number;
+    readonly minUniformBufferOffsetAlignment: number;
+    readonly minStorageBufferOffsetAlignment: number;
+    readonly maxVertexBuffers: number;
+    readonly maxBufferSize: number;
+    readonly maxVertexAttributes: number;
+    readonly maxVertexBufferArrayStride: number;
+    readonly maxInterStageShaderComponents: number;
+    readonly maxInterStageShaderVariables: number;
+    readonly maxColorAttachments: number;
+    readonly maxColorAttachmentBytesPerSample: number;
+    readonly maxComputeWorkgroupStorageSize: number;
+    readonly maxComputeInvocationsPerWorkgroup: number;
+    readonly maxComputeWorkgroupSizeX: number;
+    readonly maxComputeWorkgroupSizeY: number;
+    readonly maxComputeWorkgroupSizeZ: number;
+    readonly maxComputeWorkgroupsPerDimension: number;
 }
 
-class GPUValidationError extends GPUError {
-    constructor(message: string);
-    readonly message: string;
+type GPUSupportedFeatures = ReadonlySet<string>;
+
+type WGSLLanguageFeatures = ReadonlySet<string>;
+
+interface GPUAdapterInfo {
+    readonly vendor: string;
+    readonly architecture: string;
+    readonly device: string;
+    readonly description: string;
 }
 
-class GPUOutOfMemoryError extends GPUError {
-    constructor(message: string);
-    readonly message: string;
+interface Navigator {
+    readonly gpu: GPU | undefined;
 }
 
-class GPUInternalError extends GPUError {
-    constructor(message: string);
-    readonly message: string;
+interface WorkerNavigator {
+    readonly gpu: GPU | undefined;
 }
 
-type GPUErrorFilter = "validation" | "out-of-memory" | "internal";
+class GPU {
+    requestAdapter(options?: GPURequestAdapterOptions): Promise<GPUAdapter | undefined>;
+    getPreferredCanvasFormat(): GPUTextureFormat;
 
-class GPUUncapturedErrorEvent extends Event {
-    constructor(type: string, gpuUncapturedErrorEventInitDict: GPUUncapturedErrorEventInit);
-    readonly error: GPUError;
+    readonly wgslLanguageFeatures: WGSLLanguageFeatures;
 }
 
-interface GPUUncapturedErrorEventInit extends EventInit {
-    error: GPUError;
+interface GPURequestAdapterOptions {
+    powerPreference?: GPUPowerPreference;
+    forceFallbackAdapter?: boolean /* default=false */;
 }
 
-type GPUBufferDynamicOffset = number; /* unsigned long */
-type GPUStencilValue = number; /* unsigned long */
-type GPUSampleMask = number; /* unsigned long */
-type GPUDepthBias = number; /* long */
-
-type GPUSize64 = number; /* unsigned long long */
-type GPUIntegerCoordinate = number; /* unsigned long */
-type GPUIndex32 = number; /* unsigned long */
-type GPUSize32 = number; /* unsigned long */
-type GPUSignedOffset32 = number; /* long */
-
-type GPUSize64Out = number; /* unsigned long long */
-type GPUIntegerCoordinateOut = number; /* unsigned long */
-type GPUSize32Out = number; /* unsigned long */
+type GPUPowerPreference = "low-power" | "high-performance";
 
-type GPUFlagsConstant = number; /* unsigned long */
+class GPUAdapter {
+    // https://michalzalecki.com/nominal-typing-in-typescript/#approach-1-class-with-a-private-property
+    readonly name: string;
+    readonly features: GPUSupportedFeatures;
+    readonly limits: GPUSupportedLimits;
+    readonly isFallbackAdapter: boolean;
 
-interface GPUColorDict {
-    r: number;
-    g: number;
-    b: number;
-    a: number;
+    requestDevice(descriptor?: GPUDeviceDescriptor): Promise<GPUDevice>;
+    requestAdapterInfo(unmaskHints?: string[]): Promise<GPUAdapterInfo>;
 }
-type GPUColor = [number, number, number, number] | GPUColorDict;
 
-interface GPUOrigin2DDict {
-    x?: GPUIntegerCoordinate /* default=0 */;
-    y?: GPUIntegerCoordinate /* default=0 */;
+interface GPUDeviceDescriptor extends GPUObjectDescriptorBase {
+    requiredFeatures?: GPUFeatureName[] /* default=[] */;
+    requiredLimits?: { [name: string]: GPUSize64 } /* default={} */;
+    defaultQueue?: GPUQueueDescriptor /* default={} */;
 }
-type GPUOrigin2D = [GPUIntegerCoordinate, GPUIntegerCoordinate] | GPUOrigin2DDict;
 
-interface GPUOrigin3DDict {
-    x?: GPUIntegerCoordinate /* default=0 */;
-    y?: GPUIntegerCoordinate /* default=0 */;
-    z?: GPUIntegerCoordinate /* default=0 */;
-}
-type GPUOrigin3D = [GPUIntegerCoordinate, GPUIntegerCoordinate, GPUIntegerCoordinate] | GPUOrigin3DDict;
+type GPUFeatureName =
+    | "depth-clip-control"
+    | "depth32float-stencil8"
+    | "texture-compression-bc"
+    | "texture-compression-etc2"
+    | "texture-compression-astc"
+    | "timestamp-query"
+    | "indirect-first-instance"
+    | "shader-f16"
+    | "rg11b10ufloat-renderable"
+    | "bgra8unorm-storage"
+    | "float32-filterable";
 
-interface GPUExtent3DDict {
-    width: GPUIntegerCoordinate;
-    height?: GPUIntegerCoordinate /* default=1 */;
-    depthOrArrayLayers?: GPUIntegerCoordinate /* default=1 */;
-}
-type GPUExtent3D = [GPUIntegerCoordinate, GPUIntegerCoordinate, GPUIntegerCoordinate] | GPUExtent3DDict;
-
-/* 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
+class GPUDevice extends EventTarget implements GPUObjectBase {
+    label: string | undefined;
 
-// 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
-//
+    readonly features: GPUSupportedFeatures;
+    readonly limits: GPUSupportedLimits;
 
-/**
- * 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;
-}
+    readonly queue: GPUQueue;
 
-/**
- * WebGL Context Compatability
- *
- * ref: https://immersive-web.github.io/webxr/#contextcompatibility
- */
-interface WebGLContextAttributes {
-    xrCompatible?: boolean | undefined;
-}
+    destroy(): void;
 
-interface WebGLRenderingContextBase {
-    makeXRCompatible(): Promise<void>;
-}
+    createBuffer(descriptor: GPUBufferDescriptor): GPUBuffer;
+    createTexture(descriptor: GPUTextureDescriptor): GPUTexture;
+    createSampler(descriptor?: GPUSamplerDescriptor): GPUSampler;
+    importExternalTexture(descriptor: GPUExternalTextureDescriptor): GPUExternalTexture;
 
-/**
- * Available session modes
- *
- * ref: https://immersive-web.github.io/webxr/#xrsessionmode-enum
- */
-type XRSessionMode = "inline" | "immersive-vr" | "immersive-ar";
+    createBindGroupLayout(descriptor: GPUBindGroupLayoutDescriptor): GPUBindGroupLayout;
+    createPipelineLayout(descriptor: GPUPipelineLayoutDescriptor): GPUPipelineLayout;
+    createBindGroup(descriptor: GPUBindGroupDescriptor): GPUBindGroup;
 
-/**
- * Reference space types
- */
-type XRReferenceSpaceType = "viewer" | "local" | "local-floor" | "bounded-floor" | "unbounded";
+    createShaderModule(descriptor: GPUShaderModuleDescriptor): GPUShaderModule;
 
-type XREnvironmentBlendMode = "opaque" | "additive" | "alpha-blend";
+    createComputePipeline(descriptor: GPUComputePipelineDescriptor): GPUComputePipeline;
+    createRenderPipeline(descriptor: GPURenderPipelineDescriptor): GPURenderPipeline;
+    createComputePipelineAsync(descriptor: GPUComputePipelineDescriptor): Promise<GPUComputePipeline>;
+    createRenderPipelineAsync(descriptor: GPURenderPipelineDescriptor): Promise<GPURenderPipeline>;
 
-/**
- * ref: https://immersive-web.github.io/webxr/#xrsession-interface
- */
-type XRVisibilityState = "visible" | "visible-blurred" | "hidden";
+    createCommandEncoder(descriptor?: GPUCommandEncoderDescriptor): GPUCommandEncoder;
+    createRenderBundleEncoder(descriptor: GPURenderBundleEncoderDescriptor): GPURenderBundleEncoder;
 
-/**
- * Handedness types
- */
-type XRHandedness = "none" | "left" | "right";
+    createQuerySet(descriptor: GPUQuerySetDescriptor): GPUQuerySet;
 
-/**
- * InputSource target ray modes
- */
-type XRTargetRayMode = "gaze" | "tracked-pointer" | "screen" | "transient-pointer";
+    readonly lost: Promise<GPUDeviceLostInfo>;
+    pushErrorScope(filter: GPUErrorFilter): void;
+    popErrorScope(): Promise<GPUError | undefined>;
+    onuncapturederror: Event | undefined;
+}
 
-/**
- * Eye types
- */
-type XREye = "none" | "left" | "right";
+class GPUBuffer implements GPUObjectBase {
+    label: string | undefined;
 
-type XRFrameRequestCallback = (time: DOMHighResTimeStamp, frame: XRFrame) => void;
+    readonly size: GPUSize64Out;
+    readonly usage: GPUFlagsConstant;
+    readonly mapState: GPUBufferMapState;
 
-interface XRSystemDeviceChangeEvent extends Event {
-    type: "devicechange";
-}
+    mapAsync(mode: GPUMapModeFlags, offset?: GPUSize64 /*default=0*/, size?: GPUSize64): Promise<void>;
+    getMappedRange(offset?: GPUSize64 /*default=0*/, size?: GPUSize64): ArrayBuffer;
+    unmap(): void;
 
-interface XRSystemDeviceChangeEventHandler {
-    (event: XRSystemDeviceChangeEvent): any;
+    destroy(): void;
 }
 
-interface XRSystemEventMap {
-    devicechange: XRSystemDeviceChangeEvent;
-}
+type GPUBufferMapState = "unmapped" | "pending" | "mapped";
 
-/**
- * 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 {
-    /**
-     * Attempts to initialize an XRSession for the given mode if possible, entering immersive
-     * mode if necessary.
-     * @param mode
-     * @param options
-     */
-    requestSession(mode: XRSessionMode, options?: XRSessionInit): Promise<XRSession>;
+interface GPUBufferDescriptor extends GPUObjectDescriptorBase {
+    size: GPUSize64;
+    usage: GPUBufferUsageFlags;
+    mappedAtCreation: boolean /* default=false */;
+}
 
-    /**
-     * Queries if a given mode may be supported by the user agent and device capabilities.
-     * @param mode
-     */
-    isSessionSupported(mode: XRSessionMode): Promise<boolean>;
+type GPUBufferUsageFlags = number;
 
-    ondevicechange: XRSystemDeviceChangeEventHandler | null;
+type GPUMapModeFlags = number;
 
-    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;
-}
+class GPUTexture implements GPUObjectBase {
+    label: string | undefined;
 
-abstract class XRSystem implements XRSystem {}
+    createView(descriptor?: GPUTextureViewDescriptor): GPUTextureView;
+    destroy(): void;
 
-/**
- * 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;
-    readonly width: number;
-    readonly height: number;
+    readonly width: GPUIntegerCoordinateOut;
+    readonly height: GPUIntegerCoordinateOut;
+    readonly depthOrArrayLayers: GPUIntegerCoordinateOut;
+    readonly mipLevelCount: GPUIntegerCoordinateOut;
+    readonly sampleCount: GPUSize32Out;
+    readonly dimension: GPUTextureDimension;
+    readonly format: GPUTextureFormat;
+    readonly usage: GPUFlagsConstant;
 }
 
-abstract class XRViewport implements XRViewport {}
+interface GPUTextureDescriptor extends GPUObjectDescriptorBase {
+    size: GPUExtent3D;
+    mipLevelCount?: GPUIntegerCoordinate /* default=1 */;
+    sampleCount?: GPUSize32 /* default=1 */;
+    dimension?: GPUTextureDimension /* default="2d" */;
+    format: GPUTextureFormat;
+    usage: GPUTextureUsageFlags;
+    viewFormats?: GPUTextureFormat[] /* default=[] */;
+}
 
-/**
- * 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 {}
+type GPUTextureDimension = "1d" | "2d" | "3d";
 
-abstract class XRSpace implements XRSpace {}
+type GPUTextureUsageFlags = number;
 
-interface XRRenderStateInit {
-    baseLayer?: XRWebGLLayer | undefined;
-    depthFar?: number | undefined;
-    depthNear?: number | undefined;
-    inlineVerticalFieldOfView?: number | undefined;
+class GPUTextureView implements GPUObjectBase {
+    label: string | undefined;
 }
 
-interface XRRenderState {
-    readonly baseLayer?: XRWebGLLayer | undefined;
-    readonly depthFar: number;
-    readonly depthNear: number;
-    readonly inlineVerticalFieldOfView?: number | undefined;
+interface GPUTextureViewDescriptor extends GPUObjectDescriptorBase {
+    format: GPUTextureFormat;
+    dimension: GPUTextureViewDimension;
+    aspect?: GPUTextureAspect /* default="all" */;
+    baseMipLevel?: GPUIntegerCoordinate /* default=0 */;
+    mipLevelCount: GPUIntegerCoordinate;
+    baseArrayLayer?: GPUIntegerCoordinate /* default=0*/;
+    arrayLayerCount: GPUIntegerCoordinate;
 }
 
-abstract class XRRenderState implements XRRenderState {}
+type GPUTextureViewDimension = "1d" | "2d" | "2d-array" | "cube" | "cube-array" | "3d";
 
-interface XRReferenceSpaceEventInit extends EventInit {
-    referenceSpace?: XRReferenceSpace | undefined;
-    transform?: XRRigidTransform | undefined;
-}
+type GPUTextureAspect = "all" | "stencil-only" | "depth-only";
 
-/**
- * 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;
-}
+type GPUTextureFormat =
+    // 8-bit formats
+    | "r8unorm"
+    | "r8snorm"
+    | "r8uint"
+    | "r8sint"
 
-// tslint:disable-next-line no-unnecessary-class
-class XRReferenceSpaceEvent implements XRReferenceSpaceEvent {
-    constructor(type: "reset", eventInitDict?: XRReferenceSpaceEventInit);
-}
+    // 16-bit formats
+    | "r16uint"
+    | "r16sint"
+    | "r16float"
+    | "rg8unorm"
+    | "rg8snorm"
+    | "rg8uint"
+    | "rg8sint"
 
-interface XRReferenceSpaceEventHandler {
-    (event: XRReferenceSpaceEvent): any;
-}
+    // 32-bit formats
+    | "r32uint"
+    | "r32sint"
+    | "r32float"
+    | "rg16uint"
+    | "rg16sint"
+    | "rg16float"
+    | "rgba8unorm"
+    | "rgba8unorm-srgb"
+    | "rgba8snorm"
+    | "rgba8uint"
+    | "rgba8sint"
+    | "bgra8unorm"
+    | "bgra8unorm-srgb"
+    // Packed 32-bit formats
+    | "rgb9e5ufloat"
+    | "rgb10a2uint"
+    | "rgb10a2unorm"
+    | "rg11b10ufloat"
 
-interface XRReferenceSpaceEventMap {
-    reset: XRReferenceSpaceEvent;
-}
+    // 64-bit formats
+    | "rg32uint"
+    | "rg32sint"
+    | "rg32float"
+    | "rgba16uint"
+    | "rgba16sint"
+    | "rgba16float"
 
-/**
- * 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: XRReferenceSpaceEventHandler;
+    // 128-bit formats
+    | "rgba32uint"
+    | "rgba32sint"
+    | "rgba32float"
 
-    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;
-}
+    // Depth and stencil formats
+    | "stencil8"
+    | "depth16unorm"
+    | "depth24plus"
+    | "depth24plus-stencil8"
+    | "depth32float"
 
-abstract class XRReferenceSpace implements XRReferenceSpace {}
+    // "depth32float-stencil8" feature
+    | "depth32float-stencil8"
 
-/**
- * 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[];
+    // BC compressed formats usable if "texture-compression-bc" is both
+    // supported by the device/user agent and enabled in requestDevice.
+    | "bc1-rgba-unorm"
+    | "bc1-rgba-unorm-srgb"
+    | "bc2-rgba-unorm"
+    | "bc2-rgba-unorm-srgb"
+    | "bc3-rgba-unorm"
+    | "bc3-rgba-unorm-srgb"
+    | "bc4-r-unorm"
+    | "bc4-r-snorm"
+    | "bc5-rg-unorm"
+    | "bc5-rg-snorm"
+    | "bc6h-rgb-ufloat"
+    | "bc6h-rgb-float"
+    | "bc7-rgba-unorm"
+    | "bc7-rgba-unorm-srgb"
+
+    // ETC2 compressed formats usable if "texture-compression-etc2" is both
+    // supported by the device/user agent and enabled in requestDevice.
+    | "etc2-rgb8unorm"
+    | "etc2-rgb8unorm-srgb"
+    | "etc2-rgb8a1unorm"
+    | "etc2-rgb8a1unorm-srgb"
+    | "etc2-rgba8unorm"
+    | "etc2-rgba8unorm-srgb"
+    | "eac-r11unorm"
+    | "eac-r11snorm"
+    | "eac-rg11unorm"
+    | "eac-rg11snorm"
+
+    // ASTC compressed formats usable if "texture-compression-astc" is both
+    // supported by the device/user agent and enabled in requestDevice.
+    | "astc-4x4-unorm"
+    | "astc-4x4-unorm-srgb"
+    | "astc-5x4-unorm"
+    | "astc-5x4-unorm-srgb"
+    | "astc-5x5-unorm"
+    | "astc-5x5-unorm-srgb"
+    | "astc-6x5-unorm"
+    | "astc-6x5-unorm-srgb"
+    | "astc-6x6-unorm"
+    | "astc-6x6-unorm-srgb"
+    | "astc-8x5-unorm"
+    | "astc-8x5-unorm-srgb"
+    | "astc-8x6-unorm"
+    | "astc-8x6-unorm-srgb"
+    | "astc-8x8-unorm"
+    | "astc-8x8-unorm-srgb"
+    | "astc-10x5-unorm"
+    | "astc-10x5-unorm-srgb"
+    | "astc-10x6-unorm"
+    | "astc-10x6-unorm-srgb"
+    | "astc-10x8-unorm"
+    | "astc-10x8-unorm-srgb"
+    | "astc-10x10-unorm"
+    | "astc-10x10-unorm-srgb"
+    | "astc-12x10-unorm"
+    | "astc-12x10-unorm-srgb"
+    | "astc-12x12-unorm"
+    | "astc-12x12-unorm-srgb";
+
+class GPUExternalTexture implements GPUObjectBase {
+    label: string | undefined;
 }
 
-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 | undefined;
-    readonly gamepad?: Gamepad | undefined;
-    readonly profiles: string[];
-    readonly hand?: XRHand;
+interface GPUExternalTextureDescriptor extends GPUObjectDescriptorBase {
+    source: HTMLVideoElement | VideoFrame;
+    colorSpace?: PredefinedColorSpace /* default="srgb" */;
 }
 
-abstract class XRInputSource implements XRInputSource {}
+class GPUSampler implements GPUObjectBase {
+    label: string | undefined;
+}
 
-/**
- * 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;
+interface GPUSamplerDescriptor extends GPUObjectDescriptorBase {
+    addressModeU?: GPUAddressMode /* default="clamp-to-edge" */;
+    addressModeV?: GPUAddressMode /* default="clamp-to-edge" */;
+    addressModeW?: GPUAddressMode /* default="clamp-to-edge" */;
+    magFilter?: GPUFilterMode /* default="nearest" */;
+    minFilter?: GPUFilterMode /* default="nearest" */;
+    mipmapFilter?: GPUMipmapFilterMode /* default="nearest" */;
+    lodMinClamp?: number /* default=0 */;
+    lodMaxClamp?: number /* default=32 */;
+    compare?: GPUCompareFunction;
+    maxAnisotropy?: number /* default=1 */;
+}
 
-    length: number;
+type GPUAddressMode = "clamp-to-edge" | "repeat" | "mirror-repeat";
 
-    entries(): IterableIterator<[number, XRInputSource]>;
-    keys(): IterableIterator<number>;
-    values(): IterableIterator<XRInputSource>;
+type GPUFilterMode = "nearest" | "linear";
 
-    forEach(callbackfn: (value: XRInputSource, index: number, array: XRInputSource[]) => void, thisArg?: any): void;
-}
+type GPUMipmapFilterMode = "nearest" | "linear";
 
-abstract class XRInputSourceArray implements XRInputSourceArray {}
+type GPUCompareFunction = "never" | "less" | "equal" | "less-equal" | "greater" | "not-equal" | "greater-equal" | "always";
 
-/**
- * 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;
+class GPUBindGroupLayout implements GPUObjectBase {
+    label: string | undefined;
 }
 
-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;
+interface GPUBindGroupLayoutDescriptor extends GPUObjectDescriptorBase {
+    entries: GPUBindGroupLayoutEntry[];
+}
 
-    /**
-     * 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;
+interface GPUBindGroupLayoutEntry {
+    binding: GPUIndex32;
+    visibility: GPUShaderStageFlags;
 
-    /**
-     * Provides the pose of the viewer relative to referenceSpace as an XRViewerPose, at the
-     * XRFrame's time.
-     *
-     * @param referenceSpace
-     */
-    getViewerPose(referenceSpace: XRReferenceSpace): XRViewerPose | undefined;
+    buffer?: GPUBufferBindingLayout;
+    sampler?: GPUSamplerBindingLayout;
+    texture?: GPUTextureBindingLayout;
+    storageTexture?: GPUStorageTextureBindingLayout;
+    externalTexture?: GPUExternalTextureBindingLayout;
 }
 
-abstract class XRFrame implements XRFrame {}
+type GPUShaderStageFlags = number;
 
-/**
- * Type of XR events available
- */
-type XRInputSourceEventType = "select" | "selectend" | "selectstart" | "squeeze" | "squeezeend" | "squeezestart";
+type GPUBufferBindingType = "uniform" | "storage" | "read-only-storage";
 
-interface XRInputSourceEventInit extends EventInit {
-    frame?: XRFrame | undefined;
-    inputSource?: XRInputSource | undefined;
+interface GPUBufferBindingLayout {
+    type?: GPUBufferBindingType /* default="uniform" */;
+    hasDynamicOffset?: boolean /* default=false */;
+    minBindingSize?: GPUSize64 /* default=0 */;
 }
 
-/**
- * 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;
+type GPUSamplerBindingType = "filtering" | "non-filtering" | "comparison";
 
-    constructor(type: XRInputSourceEventType, eventInitDict?: XRInputSourceEventInit);
+interface GPUSamplerBindingLayout {
+    type?: GPUSamplerBindingType /* default="filtering" */;
 }
 
-interface XRInputSourceEventHandler {
-    (evt: XRInputSourceEvent): any;
+type GPUTextureSampleType = "float" | "unfilterable-float" | "depth" | "sint" | "uint";
+
+interface GPUTextureBindingLayout {
+    sampleType?: GPUTextureSampleType /* default="float" */;
+    viewDimension?: GPUTextureViewDimension /* default="2d" */;
+    multisampled?: boolean /* default=false */;
 }
 
-type XRSessionEventType = "end" | "visibilitychange" | "frameratechange";
+type GPUStorageTextureAccess = "write-only" | "read-only" | "read-write";
 
-interface XRSessionEventInit extends EventInit {
-    session: XRSession;
+interface GPUStorageTextureBindingLayout {
+    access?: GPUStorageTextureAccess /* default=write-only */;
+    format: GPUTextureFormat;
+    viewDimension?: GPUTextureViewDimension /* default="2d" */;
 }
 
-/**
- * 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 GPUExternalTextureBindingLayout {}
+
+class GPUBindGroup implements GPUObjectBase {
+    label: string | undefined;
 }
 
-interface XRSessionEventHandler {
-    (evt: XRSessionEvent): any;
+interface GPUBindGroupDescriptor extends GPUObjectDescriptorBase {
+    layout: GPUBindGroupLayout;
+    entries: GPUBindGroupEntry[];
 }
 
-/**
- * ref: https://immersive-web.github.io/webxr/#feature-dependencies
- */
-interface XRSessionInit {
-    optionalFeatures?: string[] | undefined;
-    requiredFeatures?: string[] | undefined;
+type GPUBindingResource = GPUSampler | GPUTextureView | GPUBufferBinding | GPUExternalTexture;
+
+interface GPUBindGroupEntry {
+    binding: GPUIndex32;
+    resource: GPUBindingResource;
 }
 
-interface XRSessionEventMap {
-    inputsourceschange: XRInputSourceChangeEvent;
-    end: XRSessionEvent;
-    visibilitychange: XRSessionEvent;
-    frameratechange: XRSessionEvent;
-    select: XRInputSourceEvent;
-    selectstart: XRInputSourceEvent;
-    selectend: XRInputSourceEvent;
-    squeeze: XRInputSourceEvent;
-    squeezestart: XRInputSourceEvent;
-    squeezeend: XRInputSourceEvent;
-    eyetrackingstart: XREyeTrackingSourceEvent;
-    eyetrackingend: XREyeTrackingSourceEvent;
+interface GPUBufferBinding {
+    buffer: GPUBuffer;
+    offset?: GPUSize64 /* default=0 */;
+    size?: GPUSize64 /* default=size_of_buffer - offset */;
 }
 
-/**
- * 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: 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;
+class GPUPipelineLayout implements GPUObjectBase {
+    label: string | 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(id: number): void;
+interface GPUPipelineLayoutDescriptor extends GPUObjectDescriptorBase {
+    bindGroupLayouts: GPUBindGroupLayout[];
+}
 
-    /**
-     * Ends the WebXR session. Returns a promise which resolves when the
-     * session has been shut down.
-     */
-    end(): Promise<void>;
+class GPUShaderModule implements GPUObjectBase {
+    label: string | undefined;
 
-    /**
-     * 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(callback: XRFrameRequestCallback): number;
+    getCompilationInfo(): Promise<GPUCompilationInfo>;
+}
 
-    /**
-     * 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>;
+interface GPUShaderModuleDescriptor extends GPUObjectDescriptorBase {
+    code: string | Uint32Array;
+    sourceMap?: object;
+    compilationHints?: GPUShaderModuleCompilationHint[] /* default=[] */;
+}
 
-    updateRenderState(renderStateInit?: XRRenderStateInit): Promise<void>;
+interface GPUShaderModuleCompilationHint {
+    entryPoint: string | Uint32Array;
+    layout: GPUPipelineLayout | GPUAutoLayoutMode;
+}
 
-    updateTargetFrameRate(rate: number): Promise<void>;
+type GPUCompilationMessageType = "error" | "warning" | "info";
 
-    onend: XRSessionEventHandler;
-    oninputsourceschange: XRInputSourceChangeEventHandler;
-    onselect: XRInputSourceEventHandler;
-    onselectstart: XRInputSourceEventHandler;
-    onselectend: XRInputSourceEventHandler;
-    onsqueeze: XRInputSourceEventHandler;
-    onsqueezestart: XRInputSourceEventHandler;
-    onsqueezeend: XRInputSourceEventHandler;
-    onvisibilitychange: XRSessionEventHandler;
-    onframeratechange: XRSessionEventHandler;
+interface GPUCompilationMessage {
+    readonly message: string;
+    readonly type: GPUCompilationMessageType;
+    readonly lineNum: number;
+    readonly linePos: number;
+    readonly offset: number;
+    readonly length: number;
+}
 
-    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;
+interface GPUCompilationInfo {
+    readonly messages: readonly GPUCompilationMessage[];
 }
 
-abstract class XRSession implements XRSession {}
+class GPUPipelineError extends DOMException {
+    constructor(message: string | undefined, options: GPUPipelineErrorInit);
+    readonly reason: GPUPipelineErrorReason;
+}
 
-/**
- * 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: ReadonlyArray<XRView>;
+interface GPUPipelineErrorInit {
+    reason: GPUPipelineErrorReason;
 }
 
-abstract class XRViewerPose implements XRViewerPose {}
+type GPUPipelineErrorReason = "validation" | "internal";
 
-/**
- * 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;
+type GPUAutoLayoutMode = "auto";
 
-    constructor(position?: DOMPointInit, direction?: DOMPointInit);
+interface GPUPipelineDescriptorBase extends GPUObjectDescriptorBase {
+    layout: GPUPipelineLayout | GPUAutoLayoutMode;
 }
 
-/**
- * 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 | undefined;
-    requestViewportScale(scale: number): void;
+interface GPUPipelineBase {
+    getBindGroupLayout(index: number): GPUBindGroupLayout;
 }
 
-abstract class XRView implements XRView {}
+interface GPUProgrammableStage {
+    module: GPUShaderModule;
+    entryPoint: string | Uint32Array;
+    constants?: { [name: string]: GPUPipelineConstantValue };
+}
 
-/**
- * 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>;
+type GPUPipelineConstantValue = number; // May represent WGSL’s bool, f32, i32, u32, and f16 if enabled.
+
+class GPUComputePipeline implements GPUObjectBase, GPUPipelineBase {
+    label: string | undefined;
+
+    getBindGroupLayout(index: number): GPUBindGroupLayout;
 }
 
-interface XRInputSourceChangeEventHandler {
-    (evt: XRInputSourceChangeEvent): any;
+interface GPUComputePipelineDescriptor extends GPUPipelineDescriptorBase {
+    compute: GPUProgrammableStage;
 }
 
-// Experimental/Draft features
+class GPURenderPipeline implements GPUObjectBase, GPUPipelineBase {
+    label: string | undefined;
 
-// Anchors
-type XRAnchorSet = Set<XRAnchor>;
+    getBindGroupLayout(index: number): GPUBindGroupLayout;
+}
 
-interface XRAnchor {
-    anchorSpace: XRSpace;
-    delete(): void;
+interface GPURenderPipelineDescriptor extends GPUPipelineDescriptorBase {
+    vertex: GPUVertexState;
+    primitive?: GPUPrimitiveState /* default={} */;
+    depthStencil?: GPUDepthStencilState;
+    multisample?: GPUMultisampleState /* default={} */;
+    fragment?: GPUFragmentState;
 }
 
-abstract class XRAnchor implements XRAnchor {}
+interface GPUPrimitiveState {
+    topology?: GPUPrimitiveTopology /* default="triangle-list" */;
+    stripIndexFormat?: GPUIndexFormat;
+    frontFace?: GPUFrontFace /* default="ccw" */;
+    cullMode?: GPUCullMode /* default="none" */;
 
-interface XRFrame {
-    trackedAnchors?: XRAnchorSet | undefined;
-    createAnchor?: (pose: XRRigidTransform, space: XRSpace) => Promise<XRAnchor>;
+    // Requires "depth-clip-control" feature.
+    unclippedDepth?: boolean /* default=false */;
 }
 
-// AR Hit testing
-class XRRay {
-    readonly origin: DOMPointReadOnly;
-    readonly direction: DOMPointReadOnly;
-    readonly matrix: Float32Array;
+type GPUPrimitiveTopology = "point-list" | "line-list" | "line-strip" | "triangle-list" | "triangle-strip";
 
-    constructor(transformOrOrigin?: XRRigidTransform | DOMPointInit, direction?: DOMPointInit);
-}
+type GPUFrontFace = "ccw" | "cw";
 
-type XRHitTestTrackableType = "point" | "plane" | "mesh";
+type GPUCullMode = "none" | "front" | "back";
 
-interface XRTransientInputHitTestResult {
-    readonly inputSource: XRInputSource;
-    readonly results: ReadonlyArray<XRHitTestResult>;
+interface GPUMultisampleState {
+    count?: GPUSize32 /* default=1 */;
+    mask?: GPUSampleMask /* default=0xFFFFFFFF */;
+    alphaToCoverageEnabled?: boolean /* default=false */;
 }
 
-class XRTransientInputHitTestResult {
-    prototype: XRTransientInputHitTestResult;
+interface GPUFragmentState extends GPUProgrammableStage {
+    targets: (GPUColorTargetState | null)[];
 }
 
-interface XRHitTestResult {
-    getPose(baseSpace: XRSpace): XRPose | undefined;
-    // When anchor system is enabled
-    createAnchor?: (pose: XRRigidTransform) => Promise<XRAnchor> | undefined;
+interface GPUColorTargetState {
+    format: GPUTextureFormat;
+
+    blend?: GPUBlendState;
+    writeMask?: GPUColorWriteFlags /* default=0xF - GPUColorWrite.ALL */;
 }
 
-abstract class XRHitTestResult implements XRHitTestResult {}
+interface GPUBlendState {
+    color: GPUBlendComponent;
+    alpha: GPUBlendComponent;
+}
 
-interface XRHitTestSource {
-    cancel(): void;
+type GPUColorWriteFlags = number;
+
+interface GPUBlendComponent {
+    operation?: GPUBlendOperation /* default="add" */;
+    srcFactor?: GPUBlendFactor /* default="one" */;
+    dstFactor?: GPUBlendFactor /* default="zero" */;
 }
 
-abstract class XRHitTestSource implements XRHitTestSource {}
+type GPUBlendFactor =
+    | "zero"
+    | "one"
+    | "src"
+    | "one-minus-src"
+    | "src-alpha"
+    | "one-minus-src-alpha"
+    | "dst"
+    | "one-minus-dst"
+    | "dst-alpha"
+    | "one-minus-dst-alpha"
+    | "src-alpha-saturated"
+    | "constant"
+    | "one-minus-constant";
 
-interface XRTransientInputHitTestSource {
-    cancel(): void;
+type GPUBlendOperation = "add" | "subtract" | "reverse-subtract" | "min" | "max";
+
+interface GPUDepthStencilState {
+    format: GPUTextureFormat;
+
+    depthWriteEnabled?: boolean /* default=false */;
+    depthCompare?: GPUCompareFunction /* default="always" */;
+
+    stencilFront?: GPUStencilFaceState /* default={} */;
+    stencilBack?: GPUStencilFaceState /* default={} */;
+
+    stencilReadMask?: GPUStencilValue /* default=0xFFFFFFFF */;
+    stencilWriteMask?: GPUStencilValue /* default=0xFFFFFFFF */;
+
+    depthBias?: GPUDepthBias /* default=0 */;
+    depthBiasSlopeScale?: number /* default= 0 */;
+    depthBiasClamp?: number /* default=0 */;
+}
+
+interface GPUStencilFaceState {
+    compare?: GPUCompareFunction /* default="always" */;
+    failOp?: GPUStencilOperation /* default="keep" */;
+    depthFailOp?: GPUStencilOperation /* default="keep" */;
+    passOp?: GPUStencilOperation /* default="keep" */;
 }
 
-abstract class XRTransientInputHitTestSource implements XRTransientInputHitTestSource {}
+type GPUStencilOperation = "keep" | "zero" | "replace" | "invert" | "increment-clamp" | "decrement-clamp" | "increment-wrap" | "decrement-wrap";
+
+type GPUIndexFormat = "uint16" | "uint32";
+
+type GPUVertexFormat =
+    | "uint8x2"
+    | "uint8x4"
+    | "sint8x2"
+    | "sint8x4"
+    | "unorm8x2"
+    | "unorm8x4"
+    | "snorm8x2"
+    | "snorm8x4"
+    | "uint16x2"
+    | "uint16x4"
+    | "sint16x2"
+    | "sint16x4"
+    | "unorm16x2"
+    | "unorm16x4"
+    | "snorm16x2"
+    | "snorm16x4"
+    | "float16x2"
+    | "float16x4"
+    | "float32"
+    | "float32x2"
+    | "float32x3"
+    | "float32x4"
+    | "uint32"
+    | "uint32x2"
+    | "uint32x3"
+    | "uint32x4"
+    | "sint32"
+    | "sint32x2"
+    | "sint32x3"
+    | "sint32x4"
+    | "unorm10-10-10-2";
+
+type GPUVertexStepMode = "vertex" | "instance";
 
-interface XRHitTestOptionsInit {
-    space: XRSpace;
-    entityTypes?: XRHitTestTrackableType[] | undefined;
-    offsetRay?: XRRay | undefined;
+interface GPUVertexState extends GPUProgrammableStage {
+    buffers?: GPUVertexBufferLayout[] /* default=[] */;
 }
 
-interface XRTransientInputHitTestOptionsInit {
-    profile: string;
-    entityTypes?: XRHitTestTrackableType[] | undefined;
-    offsetRay?: XRRay | undefined;
+interface GPUVertexBufferLayout {
+    arrayStride: GPUSize64;
+    stepMode?: GPUVertexStepMode /* default="vertex" */;
+    attributes: GPUVertexAttribute[];
 }
 
-interface XRSession {
-    requestHitTestSource?: (options: XRHitTestOptionsInit) => Promise<XRHitTestSource>;
-    requestHitTestSourceForTransientInput?: (options: XRTransientInputHitTestOptionsInit) => Promise<XRTransientInputHitTestSource>;
-
-    // Legacy
-    requestHitTest?: (ray: XRRay, referenceSpace: XRReferenceSpace) => Promise<XRHitResult[]>;
+interface GPUVertexAttribute {
+    format: GPUVertexFormat;
+    offset: GPUSize64;
+    shaderLocation: GPUIndex32;
 }
 
-interface XRFrame {
-    getHitTestResults(hitTestSource: XRHitTestSource): XRHitTestResult[];
-    getHitTestResultsForTransientInput(hitTestSource: XRTransientInputHitTestSource): XRTransientInputHitTestResult[];
+interface GPUImageDataLayout {
+    offset?: GPUSize64 /* default=0 */;
+    bytesPerRow: GPUSize32;
+    rowsPerImage?: GPUSize32;
 }
 
-// Legacy
-interface XRHitResult {
-    hitMatrix: Float32Array;
+interface GPUImageCopyBuffer extends GPUImageDataLayout {
+    buffer: GPUBuffer;
 }
 
-// Plane detection
-type XRPlaneSet = Set<XRPlane>;
-
-type XRPlaneOrientation = "horizontal" | "vertical";
-
-interface XRPlane {
-    orientation: XRPlaneOrientation;
-    planeSpace: XRSpace;
-    polygon: DOMPointReadOnly[];
-    lastChangedTime: number;
+interface GPUImageCopyTexture {
+    texture: GPUTexture;
+    mipLevel?: GPUIntegerCoordinate /* default=0 */;
+    origin?: GPUOrigin3D /* default={} */;
+    aspect?: GPUTextureAspect /* default="all" */;
 }
 
-abstract class XRPlane implements XRPlane {}
-
-interface XRSession {
-    // Legacy
-    updateWorldTrackingState?: (options: { planeDetectionState?: { enabled: boolean } | undefined }) => void | undefined;
+interface GPUImageCopyTextureTagged extends GPUImageCopyTexture {
+    colorSpace?: PredefinedColorSpace /* default="srgb" */;
+    premultipliedAlpha?: boolean /* default=false */;
 }
 
-// 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";
+type GPUImageCopyExternalImageSource = ImageBitmap | ImageData | HTMLImageElement | HTMLVideoElement | VideoFrame | HTMLCanvasElement | OffscreenCanvas;
 
-interface XRJointSpace extends XRSpace {
-    readonly jointName: XRHandJoint;
+interface GPUImageCopyExternalImage {
+    source: GPUImageCopyExternalImageSource;
+    origin?: GPUOrigin2D /* default={} */;
+    flipY?: boolean /* default=false */;
 }
 
-abstract class XRJointSpace implements XRJointSpace {}
-
-interface XRJointPose extends XRPose {
-    readonly radius: number | undefined;
+class GPUCommandBuffer implements GPUObjectBase {
+    label: string | undefined;
 }
 
-abstract class XRJointPose implements XRJointPose {}
-
-interface XRHand extends Map<XRHandJoint, XRJointSpace> {
-    readonly WRIST: number;
+interface GPUCommandBufferDescriptor extends GPUObjectDescriptorBase {}
 
-    readonly THUMB_METACARPAL: number;
-    readonly THUMB_PHALANX_PROXIMAL: number;
-    readonly THUMB_PHALANX_DISTAL: number;
-    readonly THUMB_PHALANX_TIP: number;
+interface GPUCommandsMixin {}
 
-    readonly INDEX_METACARPAL: number;
-    readonly INDEX_PHALANX_PROXIMAL: number;
-    readonly INDEX_PHALANX_INTERMEDIATE: number;
-    readonly INDEX_PHALANX_DISTAL: number;
-    readonly INDEX_PHALANX_TIP: number;
+class GPUCommandEncoder implements GPUObjectBase, GPUCommandsMixin, GPUDebugCommandsMixin {
+    label: string | undefined;
 
-    readonly MIDDLE_METACARPAL: number;
-    readonly MIDDLE_PHALANX_PROXIMAL: number;
-    readonly MIDDLE_PHALANX_INTERMEDIATE: number;
-    readonly MIDDLE_PHALANX_DISTAL: number;
-    readonly MIDDLE_PHALANX_TIP: number;
+    beginRenderPass(descriptor: GPURenderPassDescriptor): GPURenderPassEncoder;
+    beginComputePass(descriptor?: GPUComputePassDescriptor): GPUComputePassEncoder;
 
-    readonly RING_METACARPAL: number;
-    readonly RING_PHALANX_PROXIMAL: number;
-    readonly RING_PHALANX_INTERMEDIATE: number;
-    readonly RING_PHALANX_DISTAL: number;
-    readonly RING_PHALANX_TIP: number;
+    copyBufferToBuffer(source: GPUBuffer, sourceOffset: GPUSize64, destination: GPUBuffer, destinationOffset: GPUSize64, size: GPUSize64): void;
+    copyBufferToTexture(source: GPUImageCopyBuffer, destination: GPUImageCopyTexture, copySize: GPUExtent3D): void;
+    copyTextureToBuffer(source: GPUImageCopyTexture, destination: GPUImageCopyBuffer, copySize: GPUExtent3D): void;
+    copyTextureToTexture(source: GPUImageCopyTexture, destination: GPUImageCopyTexture, copySize: GPUExtent3D): void;
+    clearBuffer(buffer: GPUBuffer, offset?: GPUSize64 /* default=0 */, size?: GPUSize64): void;
 
-    readonly LITTLE_METACARPAL: number;
-    readonly LITTLE_PHALANX_PROXIMAL: number;
-    readonly LITTLE_PHALANX_INTERMEDIATE: number;
-    readonly LITTLE_PHALANX_DISTAL: number;
-    readonly LITTLE_PHALANX_TIP: number;
-}
+    writeTimestamp?(querySet: GPUQuerySet, queryIndex: GPUSize32): void; // not in the spec anymore, but may come back later, so keep it here for now
 
-abstract class XRHand extends Map<XRHandJoint, XRJointSpace> implements XRHand {}
+    resolveQuerySet(querySet: GPUQuerySet, firstQuery: GPUSize32, queryCount: GPUSize32, destination: GPUBuffer, destinationOffset: GPUSize64): void;
 
-// WebXR Layers
+    finish(descriptor?: GPUCommandBufferDescriptor): GPUCommandBuffer;
 
-/**
- * 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 {}
+    pushDebugGroup(groupLabel: string): void;
+    popDebugGroup(): void;
+    insertDebugMarker(markerLabel: string): void;
+}
 
-abstract class XRLayer implements XRLayer {}
+interface GPUCommandEncoderDescriptor extends GPUObjectDescriptorBase {}
 
-interface XRWebGLLayerInit {
-    antialias?: boolean | undefined;
-    depth?: boolean | undefined;
-    stencil?: boolean | undefined;
-    alpha?: boolean | undefined;
-    ignoreDepthValues?: boolean | undefined;
-    framebufferScaleFactor?: number | undefined;
+interface GPUBindingCommandsMixin {
+    setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup, dynamicOffsets?: GPUBufferDynamicOffset[]): void;
+    setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup, dynamicOffsetData: Uint32Array, dynamicOffsetsDataStart: GPUSize64, dynamicOffsetsDataLength: GPUSize32): void;
 }
 
-/**
- * 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);
+interface GPUDebugCommandsMixin {
+    pushDebugGroup(groupLabel: string): void;
+    popDebugGroup(): void;
+    insertDebugMarker(markerLabel: string): void;
+}
 
-    readonly antialias: boolean;
-    readonly ignoreDepthValues: boolean;
-    fixedFoveation?: number | undefined;
+class GPUComputePassEncoder implements GPUObjectBase, GPUCommandsMixin, GPUDebugCommandsMixin, GPUBindingCommandsMixin {
+    label: string | undefined;
 
-    readonly framebuffer: WebGLFramebuffer;
-    readonly framebufferWidth: number;
-    readonly framebufferHeight: number;
+    setBindGroup(index: number, bindGroup: GPUBindGroup, dynamicOffsets?: GPUBufferDynamicOffset[]): void;
+    setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup, dynamicOffsetData: Uint32Array, dynamicOffsetsDataStart: GPUSize64, dynamicOffsetsDataLength: GPUSize32): void;
 
-    getViewport(view: XRView): XRViewport | undefined;
-}
+    pushDebugGroup(groupLabel: string): void;
+    popDebugGroup(): void;
+    insertDebugMarker(markerLabel: string): void;
 
-interface XRRenderStateInit {
-    layers?: XRLayer[] | undefined;
-}
+    setPipeline(pipeline: GPUComputePipeline): void;
+    dispatchWorkgroups(workgroupCountX: GPUSize32, workgroupCountY?: GPUSize32 /* default=1 */, workgroupCountZ?: GPUSize32 /* default=1 */): void;
+    dispatchWorkgroupsIndirect(indirectBuffer: GPUBuffer, indirectOffset: GPUSize64): void;
 
-interface XRRenderState {
-    readonly layers?: XRLayer[] | undefined;
+    end(): void;
 }
 
-type XRLayerEventType = "redraw";
-
-interface XRLayerEvent extends Event {
-    readonly type: XRLayerEventType;
-    readonly layer: XRLayer;
+interface GPUComputePassTimestampWrites {
+    querySet: GPUQuerySet;
+    beginningOfPassWriteIndex: GPUSize32;
+    endOfPassWriteIndex: GPUSize32;
 }
 
-interface XRCompositionLayerEventMap {
-    redraw: XRLayerEvent;
+interface GPUComputePassDescriptor extends GPUObjectDescriptorBase {
+    timestampWrites?: GPUComputePassTimestampWrites;
 }
 
-interface XRCompositionLayer extends XRLayer {
-    readonly layout: XRLayerLayout;
-    blendTextureSourceAlpha: boolean;
-    chromaticAberrationCorrection?: boolean | undefined;
-    readonly mipLevels: number;
-    readonly needsRedraw: boolean;
-    destroy(): void;
+class GPURenderPassEncoder implements GPUObjectBase, GPUCommandsMixin, GPUDebugCommandsMixin, GPUBindingCommandsMixin, GPURenderCommandsMixin {
+    label: string | undefined;
 
-    space: XRSpace;
+    setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup, dynamicOffsets?: GPUBufferDynamicOffset[]): void;
+    setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup, dynamicOffsetData: Uint32Array, dynamicOffsetsDataStart: GPUSize64, dynamicOffsetsDataLength: GPUSize32): void;
 
-    // Events
-    onredraw: (evt: XRCompositionLayerEventMap["redraw"]) => any;
+    pushDebugGroup(groupLabel: string): void;
+    popDebugGroup(): void;
+    insertDebugMarker(markerLabel: string): void;
 
-    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;
+    setPipeline(pipeline: GPURenderPipeline): 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;
-}
+    setIndexBuffer(buffer: GPUBuffer, indexFormat: GPUIndexFormat, offset?: GPUSize64 /* default=0 */, size?: GPUSize64 /* default=0 */): void;
+    setVertexBuffer(slot: GPUIndex32, buffer: GPUBuffer, offset?: GPUSize64 /* default=0 */, size?: GPUSize64 /* default=0 */): void;
 
-abstract class XRCompositionLayer implements XRCompositionLayer {}
+    draw(vertexCount: GPUSize32, instanceCount?: GPUSize32 /* default=1 */, firstVertex?: GPUSize32 /* default=0 */, firstInstance?: GPUSize32 /* default=0 */): void;
+    drawIndexed(
+        indexCount: GPUSize32,
+        instanceCount?: GPUSize32 /* default=1 */,
+        firstIndex?: GPUSize32 /* default=0 */,
+        baseVertex?: GPUSignedOffset32 /* default=0 */,
+        firstInstance?: GPUSize32 /* default=0 */
+    ): void;
 
-type XRTextureType = "texture" | "texture-array";
+    drawIndirect(indirectBuffer: GPUBuffer, indirectOffset: GPUSize64): void;
+    drawIndexedIndirect(indirectBuffer: GPUBuffer, indirectOffset: GPUSize64): void;
 
-type XRLayerLayout = "default" | "mono" | "stereo" | "stereo-left-right" | "stereo-top-bottom";
+    setViewport(x: number, y: number, width: number, height: number, minDepth: number, maxDepth: number): void;
 
-interface XRProjectionLayerInit {
-    scaleFactor?: number | undefined;
-    textureType?: XRTextureType | undefined;
-    colorFormat?: GLenum | undefined;
-    depthFormat?: GLenum | undefined;
-    clearOnAccess?: boolean | undefined;
-}
+    setScissorRect(x: GPUIntegerCoordinate, y: GPUIntegerCoordinate, width: GPUIntegerCoordinate, height: GPUIntegerCoordinate): void;
 
-interface XRProjectionLayer extends XRCompositionLayer {
-    readonly textureWidth: number;
-    readonly textureHeight: number;
-    readonly textureArrayLength: number;
-    readonly ignoreDepthValues: number;
-    fixedFoveation: number;
-}
+    setBlendConstant(color: GPUColor): void;
+    setStencilReference(reference: GPUStencilValue): void;
 
-abstract class XRProjectionLayer implements XRProjectionLayer {}
+    beginOcclusionQuery(queryIndex: GPUSize32): void;
+    endOcclusionQuery(): void;
 
-interface XRLayerInit {
-    mipLevels?: number | undefined;
-    viewPixelWidth: number;
-    viewPixelHeight: number;
-    isStatic?: boolean | undefined;
-    colorFormat?: GLenum | undefined;
-    depthFormat?: GLenum | undefined;
-    space: XRSpace;
-    layout?: XRLayerLayout | undefined;
-    clearOnAccess?: boolean | undefined;
+    executeBundles(bundles: GPURenderBundle[]): void;
+    end(): void;
 }
 
-interface XRMediaLayerInit {
-    invertStereo?: boolean | undefined;
-    space: XRSpace;
-    layout?: XRLayerLayout | undefined;
+interface GPURenderPassTimestampWrites {
+    querySet: GPUQuerySet;
+    beginningOfPassWriteIndex: GPUSize32;
+    endOfPassWriteIndex: GPUSize32;
 }
 
-interface XRCylinderLayerInit extends XRLayerInit {
-    textureType?: XRTextureType | undefined;
-    transform: XRRigidTransform;
-    radius?: number | undefined;
-    centralAngle?: number | undefined;
-    aspectRatio?: number | undefined;
+interface GPURenderPassDescriptor extends GPUObjectDescriptorBase {
+    colorAttachments: (GPURenderPassColorAttachment | null)[];
+    depthStencilAttachment?: GPURenderPassDepthStencilAttachment;
+    occlusionQuerySet?: GPUQuerySet;
+    timestampWrites?: GPURenderPassTimestampWrites;
+    maxDrawCount?: GPUSize64 /* default=50000000 */;
 }
 
-interface XRMediaCylinderLayerInit extends XRMediaLayerInit {
-    transform?: XRRigidTransform | undefined;
-    radius?: number | undefined;
-    centralAngle?: number | undefined;
-    aspectRatio?: number | undefined;
-}
+interface GPURenderPassColorAttachment {
+    view: GPUTextureView;
+    depthSlice?: GPUIntegerCoordinate;
+    resolveTarget?: GPUTextureView;
 
-interface XRCylinderLayer extends XRCompositionLayer {
-    transform: XRRigidTransform;
-    radius: number;
-    centralAngle: number;
-    aspectRatio: number;
+    clearValue?: GPUColor;
+    loadOp: GPULoadOp;
+    storeOp: GPUStoreOp;
 }
 
-abstract class XRCylinderLayer implements XRCylinderLayer {}
+interface GPURenderPassDepthStencilAttachment {
+    view: GPUTextureView;
 
-interface XRQuadLayerInit extends XRLayerInit {
-    textureType?: XRTextureType | undefined;
-    transform?: XRRigidTransform | undefined;
-    width?: number | undefined;
-    height?: number | undefined;
-}
+    depthClearValue?: number /* default=0 */;
+    depthLoadOp: GPULoadOp;
+    depthStoreOp: GPUStoreOp;
+    depthReadOnly?: boolean /* default=false */;
 
-interface XRMediaQuadLayerInit extends XRMediaLayerInit {
-    transform?: XRRigidTransform | undefined;
-    width?: number | undefined;
-    height?: number | undefined;
+    stencilClearValue?: GPUStencilValue /* default=0 */;
+    stencilLoadOp?: GPULoadOp;
+    stencilStoreOp?: GPUStoreOp;
+    stencilReadOnly?: boolean /* default=false */;
 }
 
-interface XRQuadLayer extends XRCompositionLayer {
-    transform: XRRigidTransform;
-    width: number;
-    height: number;
-}
+type GPULoadOp = "load" | "clear";
 
-abstract class XRQuadLayer implements XRQuadLayer {}
+type GPUStoreOp = "store" | "discard";
 
-interface XREquirectLayerInit extends XRLayerInit {
-    textureType?: XRTextureType | undefined;
-    transform?: XRRigidTransform | undefined;
-    radius?: number | undefined;
-    centralHorizontalAngle?: number | undefined;
-    upperVerticalAngle?: number | undefined;
-    lowerVerticalAngle?: number | undefined;
+interface GPURenderPassLayout extends GPUObjectDescriptorBase {
+    colorFormats: (GPUTextureFormat | null)[];
+    depthStencilFormat?: GPUTextureFormat;
+    sampleCount?: GPUSize32 /* default=1 */;
 }
 
-interface XRMediaEquirectLayerInit extends XRMediaLayerInit {
-    transform?: XRRigidTransform | undefined;
-    radius?: number | undefined;
-    centralHorizontalAngle?: number | undefined;
-    upperVerticalAngle?: number | undefined;
-    lowerVerticalAngle?: number | undefined;
-}
+interface GPURenderCommandsMixin {
+    setPipeline(pipeline: GPURenderPipeline): void;
 
-interface XREquirectLayer extends XRCompositionLayer {
-    transform: XRRigidTransform;
-    radius: number;
-    centralHorizontalAngle: number;
-    upperVerticalAngle: number;
-    lowerVerticalAngle: number;
-}
+    setIndexBuffer(buffer: GPUBuffer, indexFormat: GPUIndexFormat, offset?: GPUSize64 /* default=0 */, size?: GPUSize64 /* default=0 */): void;
+    setVertexBuffer(slot: GPUIndex32, buffer: GPUBuffer, offset?: GPUSize64 /* default=0 */, size?: GPUSize64): void;
 
-abstract class XREquirectLayer implements XREquirectLayer {}
+    draw(vertexCount: GPUSize32, instanceCount?: GPUSize32 /* default=1 */, firstVertex?: GPUSize32 /* default=0 */, firstInstance?: GPUSize32 /* default=0 */): void;
+    drawIndexed(
+        indexCount: GPUSize32,
+        instanceCount?: GPUSize32 /* default=1 */,
+        firstIndex?: GPUSize32 /* default=0 */,
+        baseVertex?: GPUSignedOffset32 /* default=0 */,
+        firstInstance?: GPUSize32 /* default=0 */
+    ): void;
 
-interface XRCubeLayerInit extends XRLayerInit {
-    orientation?: DOMPointReadOnly | undefined;
+    drawIndirect(indirectBuffer: GPUBuffer, indirectOffset: GPUSize64): void;
+    drawIndexedIndirect(indirectBuffer: GPUBuffer, indirectOffset: GPUSize64): void;
 }
 
-interface XRCubeLayer extends XRCompositionLayer {
-    orientation: DOMPointReadOnly;
+class GPURenderBundle implements GPUObjectBase {
+    label: string | undefined;
 }
 
-abstract class XRCubeLayer implements XRCubeLayer {}
-
-interface XRSubImage {
-    readonly viewport: XRViewport;
-}
+interface GPURenderBundleDescriptor extends GPUObjectDescriptorBase {}
 
-abstract class XRSubImage implements XRSubImage {}
+class GPURenderBundleEncoder implements GPUObjectBase, GPUCommandsMixin, GPUDebugCommandsMixin, GPUBindingCommandsMixin, GPURenderCommandsMixin {
+    label: string | undefined;
 
-interface XRWebGLSubImage extends XRSubImage {
-    readonly colorTexture: WebGLTexture;
-    readonly depthStencilTexture?: WebGLTexture;
-    readonly motionVectorTexture?: WebGLTexture;
-    readonly imageIndex: number;
-    readonly textureWidth: number;
-    readonly textureHeight: number;
-    readonly colorTextureWidth?: number;
-    readonly colorTextureHeight?: number;
-    readonly depthStencilTextureWidth?: number;
-    readonly depthStencilTextureHeight?: number;
-    readonly motionVectorTextureWidth?: number;
-    readonly motionVectorTextureHeight?: number;
-}
+    setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup, dynamicOffsets?: GPUBufferDynamicOffset[]): void;
+    setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup, dynamicOffsetData: Uint32Array, dynamicOffsetsDataStart: GPUSize64, dynamicOffsetsDataLength: GPUSize32): void;
 
-abstract class XRWebGLSubImage implements XRWebGLSubImage {}
+    pushDebugGroup(groupLabel: string): void;
+    popDebugGroup(): void;
+    insertDebugMarker(markerLabel: string): void;
 
-class XRWebGLBinding {
-    readonly nativeProjectionScaleFactor: number;
+    setPipeline(pipeline: GPURenderPipeline): void;
 
-    constructor(session: XRSession, context: WebGLRenderingContext);
+    setIndexBuffer(buffer: GPUBuffer, indexFormat: GPUIndexFormat, offset?: GPUSize64 /* default=0 */, size?: GPUSize64 /* default=0 */): void;
+    setVertexBuffer(slot: GPUIndex32, buffer: GPUBuffer, offset?: GPUSize64 /* default=0 */, size?: GPUSize64 /* default=0 */): void;
 
-    createProjectionLayer(init?: XRProjectionLayerInit): XRProjectionLayer;
-    createQuadLayer(init?: XRQuadLayerInit): XRQuadLayer;
-    createCylinderLayer(init?: XRCylinderLayerInit): XRCylinderLayer;
-    createEquirectLayer(init?: XREquirectLayerInit): XREquirectLayer;
-    createCubeLayer(init?: XRCubeLayerInit): XRCubeLayer;
+    draw(vertexCount: GPUSize32, instanceCount?: GPUSize32 /* default=1 */, firstVertex?: GPUSize32 /* default=0 */, firstInstance?: GPUSize32 /* default=0 */): void;
+    drawIndexed(
+        indexCount: GPUSize32,
+        instanceCount?: GPUSize32 /* default=1 */,
+        firstIndex?: GPUSize32 /* default=0 */,
+        baseVertex?: GPUSignedOffset32 /* default=0 */,
+        firstInstance?: GPUSize32 /* default=0 */
+    ): void;
 
-    getSubImage(layer: XRCompositionLayer, frame: XRFrame, eye?: XREye): XRWebGLSubImage;
-    getViewSubImage(layer: XRProjectionLayer, view: XRView): XRWebGLSubImage;
+    drawIndirect(indirectBuffer: GPUBuffer, indirectOffset: GPUSize64): void;
+    drawIndexedIndirect(indirectBuffer: GPUBuffer, indirectOffset: GPUSize64): void;
 
-    // BABYLON addition
-    getReflectionCubeMap: (lightProbe: XRLightProbe) => WebGLTexture;
+    finish(descriptor?: GPURenderBundleDescriptor): GPURenderBundle;
 }
 
-class XRMediaBinding {
-    constructor(sesion: XRSession);
-
-    createQuadLayer(video: HTMLVideoElement, init?: XRMediaQuadLayerInit): XRQuadLayer;
-    createCylinderLayer(video: HTMLVideoElement, init?: XRMediaCylinderLayerInit): XRCylinderLayer;
-    createEquirectLayer(video: HTMLVideoElement, init?: XRMediaEquirectLayerInit): XREquirectLayer;
+interface GPURenderBundleEncoderDescriptor extends GPURenderPassLayout {
+    depthReadOnly?: boolean /* default=false */;
+    stencilReadOnly?: boolean /* default=false */;
 }
 
-// WebGL extensions
-interface WebGLRenderingContextBase {
-    getExtension(extensionName: "OCULUS_multiview"): OCULUS_multiview | null;
-}
+interface GPUQueueDescriptor extends GPUObjectDescriptorBase {}
 
-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,
-}
+class GPUQueue implements GPUObjectBase {
+    label: string | undefined;
 
-// Oculus extensions
-interface XRSessionGrant {
-    mode: XRSessionMode;
-}
+    submit(commandBuffers: GPUCommandBuffer[]): void;
 
-interface XRSystemSessionGrantedEvent extends Event {
-    type: "sessiongranted";
-    session: XRSessionGrant;
-}
+    onSubmittedWorkDone(): Promise<void>;
 
-interface XRSystemSessionGrantedEventHandler {
-    (event: XRSystemSessionGrantedEvent): any;
-}
+    writeBuffer(buffer: GPUBuffer, bufferOffset: GPUSize64, data: BufferSource, dataOffset?: GPUSize64 /* default=0 */, size?: GPUSize64): void;
 
-interface XRSystemEventMap {
-    // Session Grant events are an Meta Oculus Browser extension
-    sessiongranted: XRSystemSessionGrantedEvent;
+    writeTexture(destination: GPUImageCopyTexture, data: BufferSource, dataLayout: GPUImageDataLayout, size: GPUExtent3D): void;
+
+    copyExternalImageToTexture(source: GPUImageCopyExternalImage, destination: GPUImageCopyTextureTagged, copySize: GPUExtent3D): void;
 }
 
-interface XRSystem {
-    onsessiongranted: XRSystemSessionGrantedEventHandler | null;
+class GPUQuerySet implements GPUObjectBase {
+    label: string | undefined;
+
+    destroy(): void;
+
+    readonly type: GPUQueryType;
+    readonly count: GPUSize32Out;
 }
 
-interface OCULUS_multiview extends OVR_multiview2 {
-    framebufferTextureMultisampleMultiviewOVR(
-        target: GLenum,
-        attachment: GLenum,
-        texture: WebGLTexture | null,
-        level: GLint,
-        samples: GLsizei,
-        baseViewIndex: GLint,
-        numViews: GLsizei
-    ): void;
+interface GPUQuerySetDescriptor extends GPUObjectDescriptorBase {
+    type: GPUQueryType;
+    count: GPUSize32;
 }
 
-abstract class OCULUS_multiview implements OCULUS_multiview {}
+type GPUQueryType = "occlusion" | "timestamp";
 
-/**
- * BEGIN: WebXR DOM Overlays Module
- * https://immersive-web.github.io/dom-overlays/
- */
+class GPUCanvasContext {
+    readonly canvas: HTMLCanvasElement | OffscreenCanvas;
 
-interface GlobalEventHandlersEventMap {
-    beforexrselect: XRSessionEvent;
-}
+    configure(configuration?: GPUCanvasConfiguration): void;
+    unconfigure(): void;
 
-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;
+    getCurrentTexture(): GPUTexture;
 }
 
-interface XRDOMOverlayInit {
-    root: Element;
-}
+type GPUCanvasAlphaMode = "opaque" | "premultiplied";
 
-interface XRSessionInit {
-    domOverlay?: XRDOMOverlayInit | undefined;
+interface GPUCanvasConfiguration extends GPUObjectDescriptorBase {
+    device: GPUDevice;
+    format: GPUTextureFormat;
+    usage?: GPUTextureUsageFlags /* default=0x10 - GPUTextureUsage.RENDER_ATTACHMENT */;
+    viewFormats?: GPUTextureFormat[] /* default=[] */;
+    colorSpace?: PredefinedColorSpace /* default="srgb" */;
+    alphaMode?: GPUCanvasAlphaMode /* default="opaque" */;
 }
 
-type XRDOMOverlayType = "screen" | "floating" | "head-locked";
+type GPUDeviceLostReason = "unknown" | "destroyed";
 
-interface XRDOMOverlayState {
-    type: XRDOMOverlayType;
+class GPUDeviceLostInfo {
+    readonly reason?: GPUDeviceLostReason;
+    readonly message: string;
 }
 
-interface XRSession {
-    readonly domOverlayState?: XRDOMOverlayState | undefined;
+class GPUError {
+    readonly message: string;
 }
 
-/// BABYLON EDITS
-interface XREyeTrackingSourceEvent extends XRSessionEvent {
-    readonly gazeSpace: XRSpace;
+class GPUValidationError extends GPUError {
+    constructor(message: string);
+    readonly message: string;
 }
 
-interface XRFrame {
-    fillPoses?(spaces: XRSpace[], baseSpace: XRSpace, transforms: Float32Array): boolean;
-    // Anchors
-    trackedAnchors?: XRAnchorSet;
-    // World geometries. DEPRECATED
-    worldInformation?: XRWorldInformation | undefined;
-    detectedPlanes?: XRPlaneSet | undefined;
-    // Hand tracking
-    getJointPose?(joint: XRJointSpace, baseSpace: XRSpace): XRJointPose;
-    fillJointRadii?(jointSpaces: XRJointSpace[], radii: Float32Array): boolean;
-    // Image tracking
-    getImageTrackingResults?(): Array<XRImageTrackingResult>;
-    getLightEstimate(xrLightProbe: XRLightProbe): XRLightEstimate;
+class GPUOutOfMemoryError extends GPUError {
+    constructor(message: string);
+    readonly message: string;
 }
 
-// Plane detection
-interface XRSession {
-    initiateRoomCapture?(): Promise<void>;
+class GPUInternalError extends GPUError {
+    constructor(message: string);
+    readonly message: string;
 }
 
-type XREventType = keyof XRSessionEventMap;
-
-type XRImageTrackingState = "tracked" | "emulated";
-type XRImageTrackingScore = "untrackable" | "trackable";
+type GPUErrorFilter = "validation" | "out-of-memory" | "internal";
 
-interface XRTrackedImageInit {
-    image: ImageBitmap;
-    widthInMeters: number;
+class GPUUncapturedErrorEvent extends Event {
+    constructor(type: string, gpuUncapturedErrorEventInitDict: GPUUncapturedErrorEventInit);
+    readonly error: GPUError;
 }
 
-interface XRImageTrackingResult {
-    readonly imageSpace: XRSpace;
-    readonly index: number;
-    readonly trackingState: XRImageTrackingState;
-    readonly measuredWidthInMeters: number;
+interface GPUUncapturedErrorEventInit extends EventInit {
+    error: GPUError;
 }
 
-interface XRPose {
-    readonly linearVelocity?: DOMPointReadOnly;
-    readonly angularVelocity?: DOMPointReadOnly;
-}
+type GPUBufferDynamicOffset = number; /* unsigned long */
+type GPUStencilValue = number; /* unsigned long */
+type GPUSampleMask = number; /* unsigned long */
+type GPUDepthBias = number; /* long */
 
-type XRLightProbeInit = {
-    reflectionFormat: XRReflectionFormat;
-};
+type GPUSize64 = number; /* unsigned long long */
+type GPUIntegerCoordinate = number; /* unsigned long */
+type GPUIndex32 = number; /* unsigned long */
+type GPUSize32 = number; /* unsigned long */
+type GPUSignedOffset32 = number; /* long */
 
-type XRReflectionFormat = "srgba8" | "rgba16f";
+type GPUSize64Out = number; /* unsigned long long */
+type GPUIntegerCoordinateOut = number; /* unsigned long */
+type GPUSize32Out = number; /* unsigned long */
 
-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>;
+type GPUFlagsConstant = number; /* unsigned long */
 
-    getTrackedImageScores?(): Promise<XRImageTrackingScore[]>;
+interface GPUColorDict {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
 }
+type GPUColor = [number, number, number, number] | GPUColorDict;
 
-interface XRWorldInformation {
-    detectedPlanes?: XRPlaneSet;
+interface GPUOrigin2DDict {
+    x?: GPUIntegerCoordinate /* default=0 */;
+    y?: GPUIntegerCoordinate /* default=0 */;
 }
+type GPUOrigin2D = [GPUIntegerCoordinate, GPUIntegerCoordinate] | GPUOrigin2DDict;
 
-interface XRSessionInit {
-    trackedImages?: XRTrackedImageInit[];
+interface GPUOrigin3DDict {
+    x?: GPUIntegerCoordinate /* default=0 */;
+    y?: GPUIntegerCoordinate /* default=0 */;
+    z?: GPUIntegerCoordinate /* default=0 */;
 }
+type GPUOrigin3D = [GPUIntegerCoordinate, GPUIntegerCoordinate, GPUIntegerCoordinate] | GPUOrigin3DDict;
 
-interface XRLightEstimate {
-    readonly sphericalHarmonicsCoefficients: Float32Array;
-    readonly primaryLightDirection: DOMPointReadOnly;
-    readonly primaryLightIntensity: DOMPointReadOnly;
+interface GPUExtent3DDict {
+    width: GPUIntegerCoordinate;
+    height?: GPUIntegerCoordinate /* default=1 */;
+    depthOrArrayLayers?: GPUIntegerCoordinate /* default=1 */;
 }
+type GPUExtent3D = [GPUIntegerCoordinate, GPUIntegerCoordinate, GPUIntegerCoordinate] | GPUExtent3DDict;
+
+/* eslint-disable no-var */
+/* eslint-disable @typescript-eslint/naming-convention */
+// Type definitions for WebGL 2 extended with Babylon specific types
 
-interface XREventHandler {
-    (evt: Event): any;
+interface WebGL2RenderingContext extends WebGL2RenderingContextBase {
+    HALF_FLOAT_OES: number;
+    RGBA16F: typeof WebGL2RenderingContext.RGBA16F;
+    RGBA32F: typeof WebGL2RenderingContext.RGBA32F;
+    DEPTH24_STENCIL8: typeof WebGL2RenderingContext.DEPTH24_STENCIL8;
+    COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR: number;
+    COMPRESSED_SRGB_S3TC_DXT1_EXT: number;
+    COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT: number;
+    COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT: number;
+    COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT: number;
+    COMPRESSED_SRGB8_ETC2: number;
+    COMPRESSED_SRGB8_ALPHA8_ETC2_EAC: number;
+    DRAW_FRAMEBUFFER: typeof WebGL2RenderingContext.DRAW_FRAMEBUFFER;
+    UNSIGNED_INT_24_8: typeof WebGL2RenderingContext.UNSIGNED_INT_24_8;
+    MIN: typeof WebGL2RenderingContext.MIN;
+    MAX: typeof WebGL2RenderingContext.MAX;
 }
 
-interface XRLightProbe extends EventTarget {
-    readonly probeSpace: XRSpace;
-    onreflectionchange: XREventHandler;
+interface EXT_disjoint_timer_query {
+    QUERY_COUNTER_BITS_EXT: number;
+    TIME_ELAPSED_EXT: number;
+    TIMESTAMP_EXT: number;
+    GPU_DISJOINT_EXT: number;
+    QUERY_RESULT_EXT: number;
+    QUERY_RESULT_AVAILABLE_EXT: number;
+    queryCounterEXT(query: WebGLQuery, target: number): void;
+    createQueryEXT(): WebGLQuery;
+    beginQueryEXT(target: number, query: WebGLQuery): void;
+    endQueryEXT(target: number): void;
+    getQueryObjectEXT(query: WebGLQuery, target: number): any;
+    deleteQueryEXT(query: WebGLQuery): void;
 }
 
-/**
- * END: WebXR DOM Overlays Module
- * https://immersive-web.github.io/dom-overlays/
- */
+interface WebGLProgram {
+    __SPECTOR_rebuildProgram?:
+        | ((vertexSourceCode: string, fragmentSourceCode: string, onCompiled: (program: WebGLProgram) => void, onError: (message: string) => void) => void)
+        | null;
+}
 
+interface WebGLUniformLocation {
+    _currentState: any;
+}
+
 /**
- * BEGIN: WebXR Depth Sensing Moudle
- * https://www.w3.org/TR/webxr-depth-sensing-1/
+ * TODO: remove this file when we upgrade to TypeScript 5.0
  */
 
-type XRDepthUsage = "cpu-optimized" | "gpu-optimized";
-type XRDepthDataFormat = "luminance-alpha" | "float32";
-
-type XRDepthStateInit = {
-    readonly usagePreference: XRDepthUsage[];
-    readonly dataFormatPreference: XRDepthDataFormat[];
-};
-
-interface XRSessionInit {
-    depthSensing?: XRDepthStateInit;
-}
-
-interface XRSession {
-    readonly depthUsage: XRDepthUsage;
-    readonly depthDataFormat: XRDepthDataFormat;
+/* eslint-disable no-var */
+/* eslint-disable @typescript-eslint/naming-convention */
+interface OffscreenCanvasEventMap {
+    contextlost: Event;
+    contextrestored: Event;
 }
 
-interface XRDepthInformation {
-    readonly width: number;
-    readonly height: number;
-
-    readonly normDepthBufferFromNormView: XRRigidTransform;
-    readonly rawValueToMeters: number;
+interface ImageEncodeOptions {
+    quality?: number;
+    type?: string;
 }
 
-interface XRCPUDepthInformation extends XRDepthInformation {
-    readonly data: ArrayBuffer;
+// These types are only needed for older versions of typescript.
+// The BJS addition is only needed because otherwise it is a type duplicate definition
+type OffscreenRenderingContextIdBJS = "2d" | "bitmaprenderer" | "webgl" | "webgl2" | "webgpu";
+type OffscreenRenderingContextBJS = OffscreenCanvasRenderingContext2D | ImageBitmapRenderingContext | WebGLRenderingContext | WebGL2RenderingContext;
 
-    getDepthInMeters(x: number, y: number): number;
+interface OffscreenCanvas extends EventTarget {
+    /**
+     * These attributes return the dimensions of the OffscreenCanvas object's bitmap.
+     *
+     * They can be set, to replace the bitmap with a new, transparent black bitmap of the specified dimensions (effectively resizing it).
+     */
+    height: number;
+    oncontextlost: ((this: OffscreenCanvas, ev: Event) => any) | null;
+    oncontextrestored: ((this: OffscreenCanvas, ev: Event) => any) | null;
+    /**
+     * These attributes return the dimensions of the OffscreenCanvas object's bitmap.
+     *
+     * They can be set, to replace the bitmap with a new, transparent black bitmap of the specified dimensions (effectively resizing it).
+     */
+    width: number;
+    /**
+     * Returns a promise that will fulfill with a new Blob object representing a file containing the image in the OffscreenCanvas object.
+     *
+     * The argument, if provided, is a dictionary that controls the encoding options of the image file to be created. The type field specifies the file format and has a default value of "image/png"; that type is also used if the requested type isn't supported. If the image format supports variable quality (such as "image/jpeg"), then the quality field is a number in the range 0.0 to 1.0 inclusive indicating the desired quality level for the resulting image.
+     */
+    convertToBlob(options?: ImageEncodeOptions): Promise<Blob>;
+    /**
+     * Returns an object that exposes an API for drawing on the OffscreenCanvas object. contextId specifies the desired API: "2d", "bitmaprenderer", "webgl", or "webgl2". options is handled by that API.
+     *
+     * This specification defines the "2d" context below, which is similar but distinct from the "2d" context that is created from a canvas element. The WebGL specifications define the "webgl" and "webgl2" contexts. [WEBGL]
+     *
+     * Returns null if the canvas has already been initialized with another context type (e.g., trying to get a "2d" context after getting a "webgl" context).
+     */
+    getContext(contextId: "2d", options?: any): OffscreenCanvasRenderingContext2D | null;
+    getContext(contextId: "bitmaprenderer", options?: any): ImageBitmapRenderingContext | null;
+    getContext(contextId: "webgl", options?: any): WebGLRenderingContext | null;
+    getContext(contextId: "webgl2", options?: any): WebGL2RenderingContext | null;
+    getContext(contextId: OffscreenRenderingContextIdBJS, options?: any): OffscreenRenderingContextBJS | null;
+    /** Returns a newly created ImageBitmap object with the image in the OffscreenCanvas object. The image in the OffscreenCanvas object is replaced with a new blank image. */
+    transferToImageBitmap(): ImageBitmap;
+    addEventListener<K extends keyof OffscreenCanvasEventMap>(
+        type: K,
+        listener: (this: OffscreenCanvas, ev: OffscreenCanvasEventMap[K]) => any,
+        options?: boolean | AddEventListenerOptions
+    ): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof OffscreenCanvasEventMap>(
+        type: K,
+        listener: (this: OffscreenCanvas, ev: OffscreenCanvasEventMap[K]) => any,
+        options?: boolean | EventListenerOptions
+    ): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
 }
 
-interface XRFrame {
-    getDepthInformation(view: XRView): XRCPUDepthInformation | undefined;
-}
+var OffscreenCanvas: {
+    prototype: OffscreenCanvas;
+    new (width: number, height: number): OffscreenCanvas;
+};
 
-interface XRWebGLDepthInformation extends XRDepthInformation {
-    readonly texture: WebGLTexture;
+interface OffscreenCanvasRenderingContext2D
+    extends CanvasCompositing,
+        CanvasDrawImage,
+        CanvasDrawPath,
+        CanvasFillStrokeStyles,
+        CanvasFilters,
+        CanvasImageData,
+        CanvasImageSmoothing,
+        CanvasPath,
+        CanvasPathDrawingStyles,
+        CanvasRect,
+        CanvasShadowStyles,
+        CanvasState,
+        CanvasText,
+        CanvasTextDrawingStyles,
+        CanvasTransform {
+    readonly canvas: OffscreenCanvas;
+    commit(): void;
 }
 
-interface XRWebGLBinding {
-    getDepthInformation(view: XRView): XRWebGLDepthInformation | undefined;
+var OffscreenCanvasRenderingContext2D: {
+    prototype: OffscreenCanvasRenderingContext2D;
+    new (): OffscreenCanvasRenderingContext2D;
+};
+
+/* eslint-disable no-var */
+/* eslint-disable @typescript-eslint/naming-convention */
+// Mixins
+interface Window {
+    mozIndexedDB: IDBFactory;
+    webkitIndexedDB: IDBFactory;
+    msIndexedDB: IDBFactory;
+    webkitURL: typeof URL;
+    mozRequestAnimationFrame(callback: FrameRequestCallback): number;
+    oRequestAnimationFrame(callback: FrameRequestCallback): number;
+    WebGLRenderingContext: WebGLRenderingContext;
+    CANNON: any;
+    AudioContext: AudioContext;
+    webkitAudioContext: AudioContext;
+    PointerEvent: any;
+    Math: Math;
+    Uint8Array: Uint8ArrayConstructor;
+    Float32Array: Float32ArrayConstructor;
+    mozURL: typeof URL;
+    msURL: typeof URL;
+    DracoDecoderModule: any;
+    setImmediate(handler: (...args: any[]) => void): number;
 }
 
-// enabledFeatures
-interface XRSession {
-    enabledFeatures: string[];
+interface WorkerGlobalScope {
+    importScripts: (...args: string[]) => void;
 }
 
-// Raw camera access
+type WorkerSelf = WindowOrWorkerGlobalScope & WorkerGlobalScope;
 
-interface XRView {
-    readonly camera: XRCamera | undefined;
-}
+interface HTMLCanvasElement {
+    requestPointerLock(): void;
+    msRequestPointerLock?(): void;
+    mozRequestPointerLock?(): void;
+    webkitRequestPointerLock?(): void;
 
-interface XRCamera {
-    readonly width: number;
-    readonly height: number;
+    /** Track whether a record is in progress */
+    isRecording: boolean;
+    /** Capture Stream method defined by some browsers */
+    captureStream(fps?: number): MediaStream;
 }
 
-interface XRWebGLBinding {
-    getCameraImage(camera: XRCamera): WebGLTexture | undefined;
+interface CanvasRenderingContext2D {
+    msImageSmoothingEnabled: boolean;
 }
 
-// Mesh Detection
-
-interface XRMesh {
-    meshSpace: XRSpace;
-    vertices: Float32Array;
-    indices: Uint32Array;
-    lastChangedTime: DOMHighResTimeStamp;
+// Babylon Extension to enable UIEvents to work with our IUIEvents
+interface UIEvent {
+    inputIndex: number;
 }
 
-type XRMeshSet = Set<XRMesh>;
-
-interface XRFrame {
-    detectedMeshes?: XRMeshSet;
+interface MouseEvent {
+    mozMovementX: number;
+    mozMovementY: number;
+    webkitMovementX: number;
+    webkitMovementY: number;
+    msMovementX: number;
+    msMovementY: number;
 }
-
-// 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
-// Babylon React Native: https://github.com/BabylonJS/BabylonReactNative
-
-type XRSceneObjectType = "unknown" | "background" | "wall" | "floor" | "ceiling" | "platform" | "inferred" | "world";
 
-interface XRSceneObject {
-    type: XRSceneObjectType;
-}
+interface Navigator {
+    mozGetVRDevices: (any: any) => any;
+    webkitGetUserMedia(constraints: MediaStreamConstraints, successCallback: any, errorCallback: any): void;
+    mozGetUserMedia(constraints: MediaStreamConstraints, successCallback: any, errorCallback: any): void;
+    msGetUserMedia(constraints: MediaStreamConstraints, successCallback: any, errorCallback: any): void;
 
-interface XRFieldOfView {
-    angleLeft: number;
-    angleRight: number;
-    angleUp: number;
-    angleDown: number;
+    webkitGetGamepads(): Gamepad[];
+    msGetGamepads(): Gamepad[];
+    webkitGamepads(): Gamepad[];
 }
 
-interface XRFrustum {
-    position: DOMPointReadOnly;
-    orientation: DOMPointReadOnly;
-    fieldOfView: XRFieldOfView;
-    farDistance: number;
+interface HTMLVideoElement {
+    mozSrcObject: any;
 }
 
-interface XRPlane {
-    parentSceneObject?: XRSceneObject;
+interface Math {
+    fround(x: number): number;
+    imul(a: number, b: number): number;
+    log2(x: number): number;
 }
 
-// extending the webxr XRMesh with babylon native properties
-interface XRMesh {
-    normals?: Float32Array;
-    parentSceneObject?: XRSceneObject;
-    positions: Float32Array; // Babylon native!
+interface OffscreenCanvas extends EventTarget {
+    width: number;
+    height: number;
 }
 
-interface XRFrustumDetectionBoundary {
-    type: "frustum";
-    frustum: XRFrustum;
-}
+var OffscreenCanvas: {
+    prototype: OffscreenCanvas;
+    new (width: number, height: number): OffscreenCanvas;
+};
 
-interface XRSphereDetectionBoundary {
-    type: "sphere";
-    radius: number;
-}
+// Experimental Pressure API https://wicg.github.io/compute-pressure/
+type PressureSource = "cpu";
 
-interface XRBoxDetectionBoundary {
-    type: "box";
-    extent: DOMPointReadOnly;
-}
+type PressureState = "nominal" | "fair" | "serious" | "critical";
 
-type XRDetectionBoundary = XRFrustumDetectionBoundary | XRSphereDetectionBoundary | XRBoxDetectionBoundary;
+type PressureFactor = "thermal" | "power-supply";
 
-interface XRGeometryDetectorOptions {
-    detectionBoundary?: XRDetectionBoundary;
-    updateInterval?: number;
+interface PressureRecord {
+    source: PressureSource;
+    state: PressureState;
+    factors: ReadonlyArray<PressureFactor>;
+    time: number;
 }
 
-interface XRSession {
-    trySetFeaturePointCloudEnabled(enabled: boolean): boolean;
-    trySetPreferredPlaneDetectorOptions(preferredOptions: XRGeometryDetectorOptions): boolean;
-    trySetMeshDetectorEnabled(enabled: boolean): boolean;
-    trySetPreferredMeshDetectorOptions(preferredOptions: XRGeometryDetectorOptions): boolean;
+interface PressureObserver {
+    observe(source: PressureSource): void;
+    unobserve(source: PressureSource): void;
+    disconnect(): void;
+    takeRecords(): Array<PressureRecord>;
 }
 
-interface XRFrame {
-    featurePointCloud?: Array<number> | undefined;
+interface PressureObserverOptions {
+    sampleRate?: number;
 }
 
-interface XRWorldInformation {
-    detectedMeshes?: XRMeshSet;
-}
+type PressureUpdateCallback = (changes: Array<PressureRecord>, observer: PressureObserver) => void;
+
+const PressureObserver: {
+    prototype: PressureObserver;
+    new (callback: PressureUpdateCallback, options?: PressureObserverOptions): PressureObserver;
+
+    knownSources: ReadonlyArray<PressureSource>;
+};
 
 }