iwer 0.0.1

package/lib/device/XRController.d.ts

@@ -0,0 +1,24 @@
+import { GamepadConfig } from '../gamepad/Gamepad';
+import { GlobalSpace } from '../spaces/XRSpace';
+import { XRTrackedInput } from './XRTrackedInput';
+import { XRHandedness } from '../input/XRInputSource';
+import { mat4 } from 'gl-matrix';
+export interface XRControllerConfig {
+    profileId: string;
+    fallbackProfileIds: string[];
+    layout: {
+        [handedness in XRHandedness]?: {
+            gamepad: GamepadConfig;
+            gripOffsetMatrix?: mat4;
+            numHapticActuators: number;
+        };
+    };
+}
+export declare class XRController extends XRTrackedInput {
+    constructor(controllerConfig: XRControllerConfig, handedness: XRHandedness, globalSpace: GlobalSpace);
+    updateButtonValue(id: string, value: number): void;
+    updateButtonTouch(id: string, touched: boolean): void;
+    updateAxis(id: string, type: 'x-axis' | 'y-axis', value: number): void;
+    updateAxes(id: string, x: number, y: number): void;
+}
+//# sourceMappingURL=XRController.d.ts.map

package/lib/device/XRController.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"XRController.d.ts","sourceRoot":"","sources":["../../src/device/XRController.ts"],"names":[],"mappings":"AAAA,OAAO,EAGN,aAAa,EACb,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,WAAW,EAAW,MAAM,mBAAmB,CAAC;AACzD,OAAO,EAAW,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAC3D,OAAO,EACN,YAAY,EAGZ,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEjC,MAAM,WAAW,kBAAkB;IAClC,SAAS,EAAE,MAAM,CAAC;IAClB,kBAAkB,EAAE,MAAM,EAAE,CAAC;IAC7B,MAAM,EAAE;SACN,UAAU,IAAI,YAAY,CAAC,CAAC,EAAE;YAC9B,OAAO,EAAE,aAAa,CAAC;YACvB,gBAAgB,CAAC,EAAE,IAAI,CAAC;YACxB,kBAAkB,EAAE,MAAM,CAAC;SAC3B;KACD,CAAC;CACF;AAED,qBAAa,YAAa,SAAQ,cAAc;gBAE9C,gBAAgB,EAAE,kBAAkB,EACpC,UAAU,EAAE,YAAY,EACxB,WAAW,EAAE,WAAW;IA4BzB,iBAAiB,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;IAwB3C,iBAAiB,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO;IAU9C,UAAU,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,GAAG,QAAQ,EAAE,KAAK,EAAE,MAAM;IAkB/D,UAAU,CAAC,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM;CAgB3C"}

package/lib/device/XRController.js

@@ -0,0 +1,82 @@
+import { PRIVATE as GAMEPAD_PRIVATE, Gamepad, } from '../gamepad/Gamepad';
+import { XRSpace } from '../spaces/XRSpace';
+import { PRIVATE, XRTrackedInput } from './XRTrackedInput';
+import { XRInputSource, XRTargetRayMode, } from '../input/XRInputSource';
+export class XRController extends XRTrackedInput {
+    constructor(controllerConfig, handedness, globalSpace) {
+        if (!controllerConfig.layout[handedness]) {
+            throw new DOMException('Handedness not supported', 'InvalidStateError');
+        }
+        const targetRaySpace = new XRSpace(globalSpace);
+        const gripSpace = controllerConfig.layout[handedness].gripOffsetMatrix
+            ? new XRSpace(targetRaySpace, controllerConfig.layout[handedness].gripOffsetMatrix)
+            : undefined;
+        const profiles = [
+            controllerConfig.profileId,
+            ...controllerConfig.fallbackProfileIds,
+        ];
+        const inputSource = new XRInputSource(handedness, XRTargetRayMode.TrackedPointer, profiles, targetRaySpace, new Gamepad(controllerConfig.layout[handedness].gamepad), gripSpace);
+        super(inputSource);
+    }
+    updateButtonValue(id, value) {
+        if (value > 1 || value < 0) {
+            console.warn(`Out-of-range value ${value} provided for button ${id}.`);
+            return;
+        }
+        const gamepadButton = this[PRIVATE].inputSource.gamepad[GAMEPAD_PRIVATE].buttonsMap[id];
+        if (gamepadButton) {
+            if (gamepadButton[GAMEPAD_PRIVATE].type === 'binary' &&
+                value != 1 &&
+                value != 0) {
+                console.warn(`Non-binary value ${value} provided for binary button ${id}.`);
+                return;
+            }
+            gamepadButton[GAMEPAD_PRIVATE].pendingValue = value;
+        }
+        else {
+            console.warn(`Current controller does not have button ${id}.`);
+        }
+    }
+    updateButtonTouch(id, touched) {
+        const gamepadButton = this[PRIVATE].inputSource.gamepad[GAMEPAD_PRIVATE].buttonsMap[id];
+        if (gamepadButton) {
+            gamepadButton[GAMEPAD_PRIVATE].touched = touched;
+        }
+        else {
+            console.warn(`Current controller does not have button ${id}.`);
+        }
+    }
+    updateAxis(id, type, value) {
+        if (value > 1 || value < -1) {
+            console.warn(`Out-of-range value ${value} provided for ${id} axes.`);
+            return;
+        }
+        const axesById = this[PRIVATE].inputSource.gamepad[GAMEPAD_PRIVATE].axesMap[id];
+        if (axesById) {
+            if (type === 'x-axis') {
+                axesById.x = value;
+            }
+            else if (type === 'y-axis') {
+                axesById.y = value;
+            }
+        }
+        else {
+            console.warn(`Current controller does not have ${id} axes.`);
+        }
+    }
+    updateAxes(id, x, y) {
+        if (x > 1 || x < -1 || y > 1 || y < -1) {
+            console.warn(`Out-of-range value x:${x}, y:${y} provided for ${id} axes.`);
+            return;
+        }
+        const axesById = this[PRIVATE].inputSource.gamepad[GAMEPAD_PRIVATE].axesMap[id];
+        if (axesById) {
+            axesById.x = x;
+            axesById.y = y;
+        }
+        else {
+            console.warn(`Current controller does not have ${id} axes.`);
+        }
+    }
+}
+//# sourceMappingURL=XRController.js.map

package/lib/device/XRController.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"XRController.js","sourceRoot":"","sources":["../../src/device/XRController.ts"],"names":[],"mappings":"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"}

package/lib/device/XRDevice.d.ts

@@ -0,0 +1,142 @@
+import { GlobalSpace, XRSpace } from '../spaces/XRSpace';
+import { Quaternion, Vector3 } from '../utils/Math';
+import { XRController, XRControllerConfig } from './XRController';
+import { XREye, XRView } from '../views/XRView';
+import { XRHandInput } from './XRHandInput';
+import { XRHandedness, XRInputSource } from '../input/XRInputSource';
+import { XRWebGLLayer } from '../layers/XRWebGLLayer';
+import { XRReferenceSpace } from '../spaces/XRReferenceSpace';
+import { XRSessionMode, XRVisibilityState } from '../session/XRSession';
+import { mat4 } from 'gl-matrix';
+import { ActionPlayer } from '../action/ActionPlayer';
+import { InputSchema } from '../action/ActionRecorder';
+import { XRFrame } from '../frameloop/XRFrame';
+import { XRTrackedInput } from './XRTrackedInput';
+import { XRViewport } from '../views/XRViewport';
+export declare enum WebXRFeatures {
+    Viewer = "viewer",
+    Local = "local",
+    LocalFloor = "local-floor",
+    BoundedFloor = "bounded-floor",
+    Unbounded = "unbounded",
+    DomOverlay = "dom-overlay",
+    Anchors = "anchors",
+    PlaneDetection = "plane-detection",
+    MeshDetection = "mesh-detection",
+    HitTest = "hit-test",
+    HandTracking = "hand-tracking",
+    DepthSensing = "depth-sensing"
+}
+export interface XRDeviceConfig {
+    name: string;
+    controllerConfig: XRControllerConfig | undefined;
+    supportedSessionModes: XRSessionMode[];
+    supportedFeatures: WebXRFeatures[];
+    supportedFrameRates: number[];
+    isSystemKeyboardSupported: boolean;
+    internalNominalFrameRate: number;
+}
+export interface XRDeviceOptions {
+    ipd: number;
+    fovy: number;
+    stereoEnabled: boolean;
+    headsetPosition: Vector3;
+    headsetQuaternion: Quaternion;
+    canvasContainer: HTMLDivElement;
+}
+export declare const PRIVATE: unique symbol;
+/**
+ * XRDevice is not a standard API class outlined in the WebXR Device API Specifications
+ * Instead, it serves as an user-facing interface to control the emulated XR Device
+ */
+export declare class XRDevice {
+    [PRIVATE]: {
+        name: string;
+        supportedSessionModes: string[];
+        supportedFeatures: string[];
+        supportedFrameRates: number[];
+        isSystemKeyboardSupported: boolean;
+        internalNominalFrameRate: number;
+        position: Vector3;
+        quaternion: Quaternion;
+        stereoEnabled: boolean;
+        ipd: number;
+        fovy: number;
+        controllers: {
+            [key in XRHandedness]?: XRController;
+        };
+        hands: {
+            [key in XRHandedness]?: XRHandInput;
+        };
+        primaryInputMode: 'controller' | 'hand';
+        pendingReferenceSpaceReset: boolean;
+        visibilityState: XRVisibilityState;
+        pendingVisibilityState: XRVisibilityState | null;
+        matrix: mat4;
+        globalSpace: GlobalSpace;
+        viewerSpace: XRReferenceSpace;
+        viewSpaces: {
+            [key in XREye]: XRSpace;
+        };
+        canvasData?: {
+            canvas: HTMLCanvasElement;
+            parent: HTMLElement | null;
+            width: number;
+            height: number;
+        };
+        canvasContainer: HTMLDivElement;
+        getViewport: (layer: XRWebGLLayer, view: XRView) => XRViewport;
+        updateViews: () => void;
+        onBaseLayerSet: (baseLayer: XRWebGLLayer | null) => void;
+        onSessionEnd: () => void;
+        onFrameStart: (frame: XRFrame) => void;
+        actionPlayer?: ActionPlayer;
+    };
+    constructor(deviceConfig: XRDeviceConfig, deviceOptions?: Partial<XRDeviceOptions>);
+    installRuntime(globalObject?: any): void;
+    get supportedSessionModes(): string[];
+    get supportedFeatures(): string[];
+    get supportedFrameRates(): number[];
+    get isSystemKeyboardSupported(): boolean;
+    get internalNominalFrameRate(): number;
+    get stereoEnabled(): boolean;
+    set stereoEnabled(value: boolean);
+    get ipd(): number;
+    set ipd(value: number);
+    get fovy(): number;
+    set fovy(value: number);
+    get position(): Vector3;
+    get quaternion(): Quaternion;
+    get viewerSpace(): XRReferenceSpace;
+    get viewSpaces(): {
+        none: XRSpace;
+        left: XRSpace;
+        right: XRSpace;
+    };
+    get controllers(): {
+        none?: XRController | undefined;
+        left?: XRController | undefined;
+        right?: XRController | undefined;
+    };
+    get hands(): {
+        none?: XRHandInput | undefined;
+        left?: XRHandInput | undefined;
+        right?: XRHandInput | undefined;
+    };
+    get primaryInputMode(): 'controller' | 'hand';
+    set primaryInputMode(mode: 'controller' | 'hand');
+    get activeInputs(): XRTrackedInput[];
+    get inputSources(): XRInputSource[];
+    get canvasContainer(): HTMLDivElement;
+    recenter(): void;
+    get visibilityState(): XRVisibilityState;
+    updateVisibilityState(state: XRVisibilityState): void;
+    createActionPlayer(refSpace: XRReferenceSpace, recording: {
+        schema: {
+            0: number;
+            1: InputSchema;
+        }[];
+        frames: any[];
+    }): ActionPlayer;
+}
+//# sourceMappingURL=XRDevice.d.ts.map

package/lib/device/XRDevice.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"XRDevice.d.ts","sourceRoot":"","sources":["../../src/device/XRDevice.ts"],"names":[],"mappings":"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"}

package/lib/device/XRDevice.js

@@ -0,0 +1,370 @@
+import { GlobalSpace, PRIVATE as XRSPACE_PRIVATE, XRSpace, } from '../spaces/XRSpace';
+import { Quaternion, Vector3 } from '../utils/Math';
+import { XRController } from './XRController';
+import { XREye, XRView } from '../views/XRView';
+import { XRHandInput, oculusHandConfig } from './XRHandInput';
+import { XRHandedness, XRInputSource, XRInputSourceArray, } from '../input/XRInputSource';
+import { XRLayer, XRWebGLLayer } from '../layers/XRWebGLLayer';
+import { PRIVATE as XRREFERENCESPACE_PRIVATE, XRReferenceSpace, XRReferenceSpaceType, } from '../spaces/XRReferenceSpace';
+import { PRIVATE as XRSESSION_PRIVATE, XRSession, XRVisibilityState, } from '../session/XRSession';
+import { mat4, vec3 } from 'gl-matrix';
+import { ActionPlayer } from '../action/ActionPlayer';
+import { VERSION } from '../version';
+import { XRFrame } from '../frameloop/XRFrame';
+import { XRHand } from '../input/XRHand';
+import { XRInputSourceEvent } from '../events/XRInputSourceEvent';
+import { XRInputSourcesChangeEvent } from '../events/XRInputSourcesChangeEvent';
+import { XRJointPose } from '../pose/XRJointPose';
+import { XRJointSpace } from '../spaces/XRJointSpace';
+import { XRPose } from '../pose/XRPose';
+import { XRReferenceSpaceEvent } from '../events/XRReferenceSpaceEvent';
+import { XRRenderState } from '../session/XRRenderState';
+import { XRRigidTransform } from '../primitives/XRRigidTransform';
+import { XRSessionEvent } from '../events/XRSessionEvent';
+import { XRSystem } from '../initialization/XRSystem';
+import { XRViewerPose } from '../pose/XRViewerPose';
+import { XRViewport } from '../views/XRViewport';
+export var WebXRFeatures;
+(function (WebXRFeatures) {
+    WebXRFeatures["Viewer"] = "viewer";
+    WebXRFeatures["Local"] = "local";
+    WebXRFeatures["LocalFloor"] = "local-floor";
+    WebXRFeatures["BoundedFloor"] = "bounded-floor";
+    WebXRFeatures["Unbounded"] = "unbounded";
+    WebXRFeatures["DomOverlay"] = "dom-overlay";
+    WebXRFeatures["Anchors"] = "anchors";
+    WebXRFeatures["PlaneDetection"] = "plane-detection";
+    WebXRFeatures["MeshDetection"] = "mesh-detection";
+    WebXRFeatures["HitTest"] = "hit-test";
+    WebXRFeatures["HandTracking"] = "hand-tracking";
+    WebXRFeatures["DepthSensing"] = "depth-sensing";
+})(WebXRFeatures || (WebXRFeatures = {}));
+export const PRIVATE = Symbol('@immersive-web-emulation-runtime/xr-device');
+const DEFAULTS = {
+    ipd: 0.063,
+    fovy: Math.PI / 2,
+    headsetPosition: new Vector3(0, 1.6, 0),
+    headsetQuaternion: new Quaternion(),
+    stereoEnabled: false,
+};
+/**
+ * XRDevice is not a standard API class outlined in the WebXR Device API Specifications
+ * Instead, it serves as an user-facing interface to control the emulated XR Device
+ */
+export class XRDevice {
+    constructor(deviceConfig, deviceOptions = {}) {
+        var _a, _b, _c, _d, _e, _f;
+        const globalSpace = new GlobalSpace();
+        const viewerSpace = new XRReferenceSpace(XRReferenceSpaceType.Viewer, globalSpace);
+        const viewSpaces = {
+            [XREye.Left]: new XRSpace(viewerSpace),
+            [XREye.Right]: new XRSpace(viewerSpace),
+            [XREye.None]: new XRSpace(viewerSpace),
+        };
+        const controllerConfig = deviceConfig.controllerConfig;
+        const controllers = {};
+        if (controllerConfig) {
+            Object.values(XRHandedness).forEach((handedness) => {
+                if (controllerConfig.layout[handedness]) {
+                    controllers[handedness] = new XRController(controllerConfig, handedness, globalSpace);
+                }
+            });
+        }
+        const hands = {
+            [XRHandedness.Left]: new XRHandInput(oculusHandConfig, XRHandedness.Left, globalSpace),
+            [XRHandedness.Right]: new XRHandInput(oculusHandConfig, XRHandedness.Right, globalSpace),
+        };
+        const canvasContainer = (_a = deviceOptions.canvasContainer) !== null && _a !== void 0 ? _a : document.createElement('div');
+        canvasContainer.dataset.webxr_runtime = `Immersive Web Emulation Runtime v${VERSION}`;
+        canvasContainer.style.position = 'fixed';
+        canvasContainer.style.width = '100%';
+        canvasContainer.style.height = '100%';
+        canvasContainer.style.top = '0';
+        canvasContainer.style.left = '0';
+        canvasContainer.style.display = 'flex';
+        canvasContainer.style.justifyContent = 'center';
+        canvasContainer.style.alignItems = 'center';
+        canvasContainer.style.overflow = 'hidden';
+        canvasContainer.style.zIndex = '999';
+        this[PRIVATE] = {
+            name: deviceConfig.name,
+            supportedSessionModes: deviceConfig.supportedSessionModes,
+            supportedFeatures: deviceConfig.supportedFeatures,
+            supportedFrameRates: deviceConfig.supportedFrameRates,
+            isSystemKeyboardSupported: deviceConfig.isSystemKeyboardSupported,
+            internalNominalFrameRate: deviceConfig.internalNominalFrameRate,
+            position: (_b = deviceOptions.headsetPosition) !== null && _b !== void 0 ? _b : DEFAULTS.headsetPosition.clone(),
+            quaternion: (_c = deviceOptions.headsetQuaternion) !== null && _c !== void 0 ? _c : DEFAULTS.headsetQuaternion.clone(),
+            stereoEnabled: (_d = deviceOptions.stereoEnabled) !== null && _d !== void 0 ? _d : DEFAULTS.stereoEnabled,
+            ipd: (_e = deviceOptions.ipd) !== null && _e !== void 0 ? _e : DEFAULTS.ipd,
+            fovy: (_f = deviceOptions.fovy) !== null && _f !== void 0 ? _f : DEFAULTS.fovy,
+            controllers,
+            hands,
+            primaryInputMode: 'controller',
+            pendingReferenceSpaceReset: false,
+            visibilityState: XRVisibilityState.Visible,
+            pendingVisibilityState: null,
+            matrix: mat4.create(),
+            globalSpace,
+            viewerSpace,
+            viewSpaces,
+            canvasContainer,
+            getViewport: (layer, view) => {
+                const canvas = layer.context.canvas;
+                const { width, height } = canvas;
+                switch (view.eye) {
+                    case XREye.None:
+                        return new XRViewport(0, 0, width, height);
+                    case XREye.Left:
+                        return new XRViewport(0, 0, this[PRIVATE].stereoEnabled ? width / 2 : width, height);
+                    case XREye.Right:
+                        return new XRViewport(width / 2, 0, this[PRIVATE].stereoEnabled ? width / 2 : 0, height);
+                }
+            },
+            updateViews: () => {
+                // update viewerSpace
+                const viewerSpace = this[PRIVATE].viewerSpace;
+                mat4.fromRotationTranslation(viewerSpace[XRSPACE_PRIVATE].offsetMatrix, this[PRIVATE].quaternion.quat, this[PRIVATE].position.vec3);
+                // update viewSpaces
+                mat4.fromTranslation(this[PRIVATE].viewSpaces[XREye.Left][XRSPACE_PRIVATE].offsetMatrix, vec3.fromValues(-this[PRIVATE].ipd / 2, 0, 0));
+                mat4.fromTranslation(this[PRIVATE].viewSpaces[XREye.Right][XRSPACE_PRIVATE].offsetMatrix, vec3.fromValues(this[PRIVATE].ipd / 2, 0, 0));
+            },
+            onBaseLayerSet: (baseLayer) => {
+                if (!baseLayer)
+                    return;
+                // backup canvas data
+                const canvas = baseLayer.context.canvas;
+                if (canvas.parentElement !== this[PRIVATE].canvasContainer) {
+                    this[PRIVATE].canvasData = {
+                        canvas,
+                        parent: canvas.parentElement,
+                        width: canvas.width,
+                        height: canvas.height,
+                    };
+                    this[PRIVATE].canvasContainer.appendChild(canvas);
+                    document.body.appendChild(this[PRIVATE].canvasContainer);
+                }
+                canvas.width = window.innerWidth;
+                canvas.height = window.innerHeight;
+            },
+            onSessionEnd: () => {
+                if (this[PRIVATE].canvasData) {
+                    const { canvas, parent, width, height } = this[PRIVATE].canvasData;
+                    canvas.width = width;
+                    canvas.height = height;
+                    if (parent) {
+                        parent.appendChild(canvas);
+                    }
+                    else {
+                        this[PRIVATE].canvasContainer.removeChild(canvas);
+                    }
+                    document.body.removeChild(this[PRIVATE].canvasContainer);
+                    window.dispatchEvent(new Event('resize'));
+                }
+            },
+            onFrameStart: (frame) => {
+                var _a;
+                if ((_a = this[PRIVATE].actionPlayer) === null || _a === void 0 ? void 0 : _a.playing) {
+                    this[PRIVATE].actionPlayer.playFrame();
+                }
+                else {
+                    const session = frame.session;
+                    this[PRIVATE].updateViews();
+                    if (this[PRIVATE].pendingVisibilityState) {
+                        this[PRIVATE].visibilityState =
+                            this[PRIVATE].pendingVisibilityState;
+                        this[PRIVATE].pendingVisibilityState = null;
+                        session.dispatchEvent(new XRSessionEvent('visibilitychange', { session }));
+                    }
+                    if (this[PRIVATE].visibilityState === XRVisibilityState.Visible) {
+                        this.activeInputs.forEach((activeInput) => {
+                            activeInput.onFrameStart(frame);
+                        });
+                    }
+                    if (this[PRIVATE].pendingReferenceSpaceReset) {
+                        session[XRSESSION_PRIVATE].referenceSpaces.forEach((referenceSpace) => {
+                            switch (referenceSpace[XRREFERENCESPACE_PRIVATE].type) {
+                                case XRReferenceSpaceType.Local:
+                                case XRReferenceSpaceType.LocalFloor:
+                                case XRReferenceSpaceType.BoundedFloor:
+                                case XRReferenceSpaceType.Unbounded:
+                                    referenceSpace.dispatchEvent(new XRReferenceSpaceEvent('reset', { referenceSpace }));
+                                    break;
+                            }
+                        });
+                        this[PRIVATE].pendingReferenceSpaceReset = false;
+                    }
+                }
+                this[PRIVATE].updateViews();
+            },
+        };
+        this[PRIVATE].updateViews();
+        globalThis;
+    }
+    installRuntime(globalObject = globalThis) {
+        Object.defineProperty(WebGL2RenderingContext.prototype, 'makeXRCompatible', {
+            value: function () {
+                return new Promise((resolve, _reject) => {
+                    resolve(true);
+                });
+            },
+            configurable: true,
+        });
+        Object.defineProperty(globalThis.navigator, 'xr', {
+            value: new XRSystem(this),
+            configurable: true,
+        });
+        globalObject['XRSystem'] = XRSystem;
+        globalObject['XRSession'] = XRSession;
+        globalObject['XRRenderState'] = XRRenderState;
+        globalObject['XRFrame'] = XRFrame;
+        globalObject['XRSpace'] = XRSpace;
+        globalObject['XRReferenceSpace'] = XRReferenceSpace;
+        globalObject['XRJointSpace'] = XRJointSpace;
+        globalObject['XRView'] = XRView;
+        globalObject['XRViewport'] = XRViewport;
+        globalObject['XRRigidTransform'] = XRRigidTransform;
+        globalObject['XRPose'] = XRPose;
+        globalObject['XRViewerPose'] = XRViewerPose;
+        globalObject['XRJointPose'] = XRJointPose;
+        globalObject['XRInputSource'] = XRInputSource;
+        globalObject['XRInputSourceArray'] = XRInputSourceArray;
+        globalObject['XRHand'] = XRHand;
+        globalObject['XRLayer'] = XRLayer;
+        globalObject['XRWebGLLayer'] = XRWebGLLayer;
+        globalObject['XRSessionEvent'] = XRSessionEvent;
+        globalObject['XRInputSourceEvent'] = XRInputSourceEvent;
+        globalObject['XRInputSourcesChangeEvent'] = XRInputSourcesChangeEvent;
+        globalObject['XRReferenceSpaceEvent'] = XRReferenceSpaceEvent;
+    }
+    get supportedSessionModes() {
+        return this[PRIVATE].supportedSessionModes;
+    }
+    get supportedFeatures() {
+        return this[PRIVATE].supportedFeatures;
+    }
+    get supportedFrameRates() {
+        return this[PRIVATE].supportedFrameRates;
+    }
+    get isSystemKeyboardSupported() {
+        return this[PRIVATE].isSystemKeyboardSupported;
+    }
+    get internalNominalFrameRate() {
+        return this[PRIVATE].internalNominalFrameRate;
+    }
+    get stereoEnabled() {
+        return this[PRIVATE].stereoEnabled;
+    }
+    set stereoEnabled(value) {
+        this[PRIVATE].stereoEnabled = value;
+    }
+    get ipd() {
+        return this[PRIVATE].ipd;
+    }
+    set ipd(value) {
+        this[PRIVATE].ipd = value;
+    }
+    get fovy() {
+        return this[PRIVATE].fovy;
+    }
+    set fovy(value) {
+        this[PRIVATE].fovy = value;
+    }
+    get position() {
+        return this[PRIVATE].position;
+    }
+    get quaternion() {
+        return this[PRIVATE].quaternion;
+    }
+    get viewerSpace() {
+        var _a;
+        if ((_a = this[PRIVATE].actionPlayer) === null || _a === void 0 ? void 0 : _a.playing) {
+            return this[PRIVATE].actionPlayer.viewerSpace;
+        }
+        else {
+            return this[PRIVATE].viewerSpace;
+        }
+    }
+    get viewSpaces() {
+        var _a;
+        if ((_a = this[PRIVATE].actionPlayer) === null || _a === void 0 ? void 0 : _a.playing) {
+            return this[PRIVATE].actionPlayer.viewSpaces;
+        }
+        else {
+            return this[PRIVATE].viewSpaces;
+        }
+    }
+    get controllers() {
+        return this[PRIVATE].controllers;
+    }
+    get hands() {
+        return this[PRIVATE].hands;
+    }
+    get primaryInputMode() {
+        return this[PRIVATE].primaryInputMode;
+    }
+    set primaryInputMode(mode) {
+        if (mode !== 'controller' && mode !== 'hand') {
+            console.warn('primary input mode can only be "controller" or "hand"');
+            return;
+        }
+        this[PRIVATE].primaryInputMode = mode;
+    }
+    get activeInputs() {
+        if (this[PRIVATE].visibilityState !== XRVisibilityState.Visible) {
+            return [];
+        }
+        const activeInputs = this[PRIVATE].primaryInputMode === 'controller'
+            ? Object.values(this[PRIVATE].controllers)
+            : Object.values(this[PRIVATE].hands);
+        return activeInputs.filter((input) => input.connected);
+    }
+    get inputSources() {
+        var _a;
+        if ((_a = this[PRIVATE].actionPlayer) === null || _a === void 0 ? void 0 : _a.playing) {
+            return this[PRIVATE].actionPlayer.inputSources;
+        }
+        else {
+            return this.activeInputs.map((input) => input.inputSource);
+        }
+    }
+    get canvasContainer() {
+        return this[PRIVATE].canvasContainer;
+    }
+    recenter() {
+        const deltaVec = new Vector3(-this.position.x, 0, -this.position.z);
+        const forward = new Vector3(0, 0, -1).applyQuaternion(this.quaternion);
+        forward.y = 0;
+        forward.normalize();
+        const angle = Math.atan2(forward.x, -forward.z);
+        const deltaQuat = new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), angle);
+        this.position.add(deltaVec);
+        this.quaternion.multiply(deltaQuat);
+        [
+            ...Object.values(this[PRIVATE].controllers),
+            ...Object.values(this[PRIVATE].hands),
+        ].forEach((activeInput) => {
+            activeInput.position.add(deltaVec);
+            activeInput.quaternion.multiply(deltaQuat);
+            activeInput.position.applyQuaternion(deltaQuat);
+        });
+        this[PRIVATE].pendingReferenceSpaceReset = true;
+    }
+    get visibilityState() {
+        return this[PRIVATE].visibilityState;
+    }
+    // visibility state updates are queued until the XRSession produces frames
+    updateVisibilityState(state) {
+        if (!Object.values(XRVisibilityState).includes(state)) {
+            throw new DOMException('Invalid XRVisibilityState value', 'NotSupportedError');
+        }
+        if (state !== this[PRIVATE].visibilityState) {
+            this[PRIVATE].pendingVisibilityState = state;
+        }
+    }
+    createActionPlayer(refSpace, recording) {
+        this[PRIVATE].actionPlayer = new ActionPlayer(refSpace, recording, this[PRIVATE].ipd);
+        return this[PRIVATE].actionPlayer;
+    }
+}
+//# sourceMappingURL=XRDevice.js.map