@woosh/meep-engine 3.35.0 → 3.37.0

package/package.json

@@ -6,7 +6,7 @@
   "description": "Advanced 3D game engine",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "3.35.0",
+  "version": "3.37.0",
   "exports": {
     "./build/*": "./build/*",
     "./src/*": "./src/*",

package/src/engine/Engine.d.ts

@@ -114,6 +114,7 @@ declare class Engine {
         pointer: PointerDevice;
         keyboard: KeyboardDevice;
         gamepad: GamepadDevice;
+        xr: XRInputDevice;
     };
     /**
      * Toggles GraphicsEngine rendering on and off
@@ -179,6 +180,7 @@ import SceneManager from "./scene/SceneManager.js";
 import { PointerDevice } from "./input/devices/PointerDevice.js";
 import KeyboardDevice from "./input/devices/KeyboardDevice.js";
 import { GamepadDevice } from "./input/devices/GamepadDevice.js";
+import { XRInputDevice } from "./input/devices/XRInputDevice.js";
 import EmptyView from "../view/elements/EmptyView.js";
 import { AssetPreloader } from "./asset/preloader/AssetPreloader.js";
 import ObservedBoolean from "../core/model/ObservedBoolean.js";

package/src/engine/Engine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Engine.d.ts","sourceRoot":"","sources":["../../../src/engine/Engine.js"],"names":[],"mappings":";6BAoCa,OAAO,8BAA8B,EAAE,cAAc;AAwClE;IAiGI;;;;;;;;;OASG;IACH,sBARW,cAAc;QAEU,aAAa,GAArC,aAAa;QACK,cAAc,GAAhC,OAAO;QACW,WAAW,GAA7B,OAAO;QACW,KAAK,GAAvB,OAAO;OA+OjB;IApSD;;;OAGG;IACH,UAFU,cAAc,GAAC,IAAI,CAEb;IAEhB;;;OAGG;IACH,OAFU,WAAW,GAAC,IAAI,CAEb;IAEb,qBAA4B;IAE5B;;;;;;;;;OASG;IACH,0BAFU,uBAAuB,CAEe;IAEhD;;;OAGG;IACH,kBAFU,mBAAmB,CAEO;IAEpC;;;;OAIG;IACH,iBAFU,MAAM,CAEM;IAEtB;;;;OAIG;IACH,mBAFU,kBAAkB,CAEa;IAoBrC;;;OAGG;IACH,UAFU,cAAc,CAEA;IAKxB;;;OAGG;IACH,aAFU,gBAAgB,CAEe;IAGzC,yCAAkE;IAK9D,6BAAkC;IAMtC;;;OAGG;IACH,cAFU,aAAa,MAAM,CAAC,CAK5B;IAEF,8CAiCE;IAgCF;;;OAGG;IACH,SAFU,WAAW,CAEoB;IAEzC;;;OAGG;IACH,oCAA0C;IAE1C;;;OAGG;IACH,sCAFU,2BAA2B,CAE+B;IAEpE,yBAAoC;IAGpC;;OAEG;IACH,aAAkB;IAElB;;;OAGG;IACH,SAFU,OAAO,CAEwB;IAGzC,2BAAsC;IAuCtC;;;OAGG;IACH,KAFU,SAAS,CAEO;IAE1B;;;OAGG;IACH,uBAFU,YAAY,CAEqD;IAI3E;;;;MAIC;IA6BD;;;OAGG;IACH,kBAFU,OAAO,CAEW;IAwIhC,wBAgCC;IApBG,oBAAwB;IAsB5B,2BA8CC;IAED,oBAiBC;IAED;;;OAGG;IACH,+CAUC;IAED,eAkDC;IAED;;;OAGG;IACH,sBAuGC;IAqBD;;OAEG;IACH,sBA+DC;IAED,aAEC;IAED;;OAEG;IACH,4BAOC;IAIL;;;OAGG;IACH,mBAFU,OAAO,CAEQ;;CAPxB;+BA94B8B,+BAA+B;wBAUtC,wBAAwB;0BApBtB,0CAA0C;wCAcN,iDAAiD;oCAG3E,iCAAiC;mBAElD,wBAAwB;+BArBZ,gDAAgD;iCAO9C,+CAA+C;8BAGlD,wBAAwB;6BALzB,yBAAyB;uCAIf,6DAA6D;4BASxE,0BAA0B;+BApBvB,iCAAiC;4CAapB,qDAAqD;AAejG;;GAEG;AAGH;IACI,gDAA2D;IAC3D,0BAAkC;IAClC,iCAAyC;CAC5C;6BAtC4B,sCAAsC;sBA2B7C,mBAAmB;yBAJhB,yBAAyB;8BALpB,kCAAkC;2BADrC,mCAAmC;8BADhC,kCAAkC;sBAZ1C,+BAA+B;+BAKtB,qCAAqC;4BAPxC,kCAAkC;oBAH1C,yBAAyB"}
+{"version":3,"file":"Engine.d.ts","sourceRoot":"","sources":["../../../src/engine/Engine.js"],"names":[],"mappings":";6BAqCa,OAAO,8BAA8B,EAAE,cAAc;AAwClE;IAiGI;;;;;;;;;OASG;IACH,sBARW,cAAc;QAEU,aAAa,GAArC,aAAa;QACK,cAAc,GAAhC,OAAO;QACW,WAAW,GAA7B,OAAO;QACW,KAAK,GAAvB,OAAO;OAiPjB;IAtSD;;;OAGG;IACH,UAFU,cAAc,GAAC,IAAI,CAEb;IAEhB;;;OAGG;IACH,OAFU,WAAW,GAAC,IAAI,CAEb;IAEb,qBAA4B;IAE5B;;;;;;;;;OASG;IACH,0BAFU,uBAAuB,CAEe;IAEhD;;;OAGG;IACH,kBAFU,mBAAmB,CAEO;IAEpC;;;;OAIG;IACH,iBAFU,MAAM,CAEM;IAEtB;;;;OAIG;IACH,mBAFU,kBAAkB,CAEa;IAoBrC;;;OAGG;IACH,UAFU,cAAc,CAEA;IAKxB;;;OAGG;IACH,aAFU,gBAAgB,CAEe;IAGzC,yCAAkE;IAK9D,6BAAkC;IAMtC;;;OAGG;IACH,cAFU,aAAa,MAAM,CAAC,CAK5B;IAEF,8CAiCE;IAgCF;;;OAGG;IACH,SAFU,WAAW,CAEoB;IAEzC;;;OAGG;IACH,oCAA0C;IAE1C;;;OAGG;IACH,sCAFU,2BAA2B,CAE+B;IAEpE,yBAAoC;IAGpC;;OAEG;IACH,aAAkB;IAElB;;;OAGG;IACH,SAFU,OAAO,CAEwB;IAGzC,2BAAsC;IAuCtC;;;OAGG;IACH,KAFU,SAAS,CAEO;IAE1B;;;OAGG;IACH,uBAFU,YAAY,CAEqD;IAI3E;;;;;MAKC;IA8BD;;;OAGG;IACH,kBAFU,OAAO,CAEW;IAwIhC,wBAgCC;IApBG,oBAAwB;IAsB5B,2BA8CC;IAED,oBAiBC;IAED;;;OAGG;IACH,+CAUC;IAED,eAkDC;IAED;;;OAGG;IACH,sBAuGC;IAqBD;;OAEG;IACH,sBAgEC;IAED,aAEC;IAED;;OAEG;IACH,4BAOC;IAIL;;;OAGG;IACH,mBAFU,OAAO,CAEQ;;CAPxB;+BAl5B8B,+BAA+B;wBAWtC,wBAAwB;0BArBtB,0CAA0C;wCAeN,iDAAiD;oCAG3E,iCAAiC;mBAElD,wBAAwB;+BAtBZ,gDAAgD;iCAO9C,+CAA+C;8BAGlD,wBAAwB;6BALzB,yBAAyB;uCAIf,6DAA6D;4BAUxE,0BAA0B;+BArBvB,iCAAiC;4CAapB,qDAAqD;AAgBjG;;GAEG;AAGH;IACI,gDAA2D;IAC3D,0BAAkC;IAClC,iCAAyC;CAC5C;6BAvC4B,sCAAsC;sBA4B7C,mBAAmB;yBAJhB,yBAAyB;8BALpB,kCAAkC;2BADrC,mCAAmC;8BAFhC,kCAAkC;8BAClC,kCAAkC;sBAb1C,+BAA+B;+BAKtB,qCAAqC;4BAPxC,kCAAkC;oBAH1C,yBAAyB"}

package/src/engine/Engine.js

@@ -21,6 +21,7 @@ import { EntityManager } from "./ecs/EntityManager.js";
 import { BinarySerializationRegistry } from "./ecs/storage/binary/BinarySerializationRegistry.js";
 import { GraphicsEngine } from './graphics3/GraphicsEngine.js';
 import { GamepadDevice } from "./input/devices/GamepadDevice.js";
+import { XRInputDevice } from "./input/devices/XRInputDevice.js";
 import KeyboardDevice from "./input/devices/KeyboardDevice.js";
 import { PointerDevice } from "./input/devices/PointerDevice.js";
 import { StaticKnowledgeDatabase, StaticKnowledgeState } from "./knowledge/database/StaticKnowledgeDatabase.js";
@@ -379,12 +380,14 @@ class Engine {
         this.devices = {
             pointer: new PointerDevice(this.viewStack.el),
             keyboard: new KeyboardDevice(this.viewStack.el),
-            gamepad: new GamepadDevice()
+            gamepad: new GamepadDevice(),
+            xr: new XRInputDevice()
         };
 
         this.devices.pointer.start();
         this.devices.keyboard.start();
         this.devices.gamepad.start();
+        this.devices.xr.start();
 
         /*
          Only the focused element receives keyboard events. `ViewStack` sets `tabindex` on its
@@ -869,6 +872,7 @@ class Engine {
         this.devices.pointer.stop();
         this.devices.keyboard.stop();
         this.devices.gamepad.stop();
+        this.devices.xr.stop();
 
         // shutdown entity manager
         if (!this.__using_external_entity_manager) {

package/src/engine/input/devices/XRInputDevice.d.ts

@@ -0,0 +1,91 @@
+/**
+ * WebXR input from an application-owned session and frame loop. Construction and {@link start} work
+ * without a browser, XR support, or hardware; all controls remain neutral until a session is attached.
+ * Engine starts this device automatically. Call {@link start} when using it independently.
+ *
+ * {@link left}, {@link right} and {@link none} are stable slots, each retaining the oldest available
+ * source of that handedness. {@link sources} contains a separate handle for every live source.
+ * Control objects retain their identity when a slot changes source, so bindings survive disconnection.
+ *
+ * Removal, session replacement/end, {@link stop}, and a blurred or hidden session clear controls and
+ * cancel unfinished actions. Completed actions are not cancelled. Binding a slot midway through an
+ * action does not replay it. Tracking loss clears poses while preserving controls and action state.
+ *
+ * Lifecycle changes requested inside a signal handler take effect after the current update.
+ * Recursive {@link poll} calls are ignored. Frames are consumed synchronously and never retained.
+ *
+ * @example
+ *   const xr = engine.devices.xr;
+ *   // Bind application callbacks before or after attaching a session.
+ *   xr.right.select.onChanged.add(setToolPressure);
+ *   xr.right.select.completed.add(useTool);
+ *   xr.setSession(session, referenceSpace);
+ *   // In the session's existing requestAnimationFrame callback, before reading input:
+ *   xr.poll(frame);
+ */
+export class XRInputDevice {
+    /** @readonly */
+    readonly left: XRInputHandle;
+    /** @readonly */
+    readonly right: XRInputHandle;
+    /** @readonly */
+    readonly none: XRInputHandle;
+    /**
+     * All connected source handles. Do not modify membership.
+     * @readonly
+     * @type {XRInputHandle[]}
+     */
+    readonly sources: XRInputHandle[];
+    /** @readonly */
+    readonly on: {
+        /**
+         * Dispatches the connected XRInputHandle after its initial sample.
+         * @type {Signal}
+         */
+        connected: Signal;
+        /**
+         * Dispatches the XRInputHandle after its controls are cleared and its source is detached.
+         * @type {Signal}
+         */
+        disconnected: Signal;
+    };
+    /**
+     * Attached session, or null. Change through {@link setSession}.
+     * @readonly
+     * @type {import('./xr/XRInputTypes.js').XRSession|null}
+     */
+    readonly session: import('./xr/XRInputTypes.js').XRSession | null;
+    /**
+     * Space in which poses are reported, or null. Change through {@link setReferenceSpace}.
+     * @readonly
+     * @type {EventTarget|null}
+     */
+    readonly referenceSpace: EventTarget | null;
+    get isRunning(): boolean;
+    /** Start listening to the configured session. Safe to call repeatedly. */
+    start(): void;
+    /** Detach without ending the application's native XRSession. */
+    stop(): void;
+    /**
+     * Attach an existing session. May be called before {@link start}. Pass null to detach.
+     * The application remains responsible for requesting and ending the native session.
+     * @param {import('./xr/XRInputTypes.js').XRSession|null} session
+     * @param {EventTarget|null} [referenceSpace=null] Null still samples controls, with invalid poses.
+     */
+    setSession(session: import('./xr/XRInputTypes.js').XRSession | null, referenceSpace?: EventTarget | null): void;
+    /**
+     * Change the space used for poses. Existing poses become invalid until the next frame.
+     * Pass null to disable pose sampling while continuing to sample controls.
+     * @param {EventTarget|null} referenceSpace
+     */
+    setReferenceSpace(referenceSpace: EventTarget | null): void;
+    /**
+     * No-op without a running session. Otherwise call only within that session's active frame callback.
+     * @param {import('./xr/XRInputTypes.js').XRFrame} [frame]
+     */
+    poll(frame?: import('./xr/XRInputTypes.js').XRFrame): void;
+    #private;
+}
+import { XRInputHandle } from "./xr/XRInputHandle.js";
+import Signal from "../../../core/events/signal/Signal.js";
+//# sourceMappingURL=XRInputDevice.d.ts.map

package/src/engine/input/devices/XRInputDevice.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"XRInputDevice.d.ts","sourceRoot":"","sources":["../../../../../src/engine/input/devices/XRInputDevice.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH;IACI,gBAAgB;IAChB,6BAA2B;IAE3B,gBAAgB;IAChB,8BAA4B;IAE5B,gBAAgB;IAChB,6BAA2B;IAE3B;;;;OAIG;IACH,kBAFU,aAAa,EAAE,CAEZ;IAEb,gBAAgB;IAChB;QACI;;;WAGG;mBADO,MAAM;QAIhB;;;WAGG;sBADO,MAAM;MAGlB;IAUF;;;;OAIG;IACH,kBAFU,OAAO,sBAAsB,EAAE,SAAS,GAAC,IAAI,CAExC;IAEf;;;;OAIG;IACH,yBAFU,WAAW,GAAC,IAAI,CAEJ;IAYtB,yBAEC;IAED,0EAA0E;IAC1E,cAiBC;IAED,gEAAgE;IAChE,aAYC;IAED;;;;;OAKG;IACH,oBAHW,OAAO,sBAAsB,EAAE,SAAS,GAAC,IAAI,mBAC7C,WAAW,GAAC,IAAI,QAwC1B;IAED;;;;OAIG;IACH,kCAFW,WAAW,GAAC,IAAI,QA8B1B;IAED;;;OAGG;IACH,aAFW,OAAO,sBAAsB,EAAE,OAAO,QAkBhD;;CA0OJ;8BA3d6B,uBAAuB;mBADlC,uCAAuC"}

package/src/engine/input/devices/XRInputDevice.js

@@ -0,0 +1,479 @@
+import { assert } from "../../../core/assert.js";
+import { Deque } from "../../../core/collection/queue/Deque.js";
+import Signal from "../../../core/events/signal/Signal.js";
+import { XRInputHandle } from "./xr/XRInputHandle.js";
+import { XRHandedness } from "./xr/XRHandedness.js";
+import { XRVisibilityState } from "./xr/XRVisibilityState.js";
+
+const SESSION_EVENTS = [
+    'inputsourceschange',
+    'selectstart', 'select', 'selectend',
+    'squeezestart', 'squeeze', 'squeezeend',
+    'visibilitychange',
+    'end'
+];
+
+/**
+ * WebXR input from an application-owned session and frame loop. Construction and {@link start} work
+ * without a browser, XR support, or hardware; all controls remain neutral until a session is attached.
+ * Engine starts this device automatically. Call {@link start} when using it independently.
+ *
+ * {@link left}, {@link right} and {@link none} are stable slots, each retaining the oldest available
+ * source of that handedness. {@link sources} contains a separate handle for every live source.
+ * Control objects retain their identity when a slot changes source, so bindings survive disconnection.
+ *
+ * Removal, session replacement/end, {@link stop}, and a blurred or hidden session clear controls and
+ * cancel unfinished actions. Completed actions are not cancelled. Binding a slot midway through an
+ * action does not replay it. Tracking loss clears poses while preserving controls and action state.
+ *
+ * Lifecycle changes requested inside a signal handler take effect after the current update.
+ * Recursive {@link poll} calls are ignored. Frames are consumed synchronously and never retained.
+ *
+ * @example
+ *   const xr = engine.devices.xr;
+ *   // Bind application callbacks before or after attaching a session.
+ *   xr.right.select.onChanged.add(setToolPressure);
+ *   xr.right.select.completed.add(useTool);
+ *   xr.setSession(session, referenceSpace);
+ *   // In the session's existing requestAnimationFrame callback, before reading input:
+ *   xr.poll(frame);
+ */
+export class XRInputDevice {
+    /** @readonly */
+    left = new XRInputHandle();
+
+    /** @readonly */
+    right = new XRInputHandle();
+
+    /** @readonly */
+    none = new XRInputHandle();
+
+    /**
+     * All connected source handles. Do not modify membership.
+     * @readonly
+     * @type {XRInputHandle[]}
+     */
+    sources = [];
+
+    /** @readonly */
+    on = {
+        /**
+         * Dispatches the connected XRInputHandle after its initial sample.
+         * @type {Signal}
+         */
+        connected: new Signal(),
+
+        /**
+         * Dispatches the XRInputHandle after its controls are cleared and its source is detached.
+         * @type {Signal}
+         */
+        disconnected: new Signal()
+    };
+
+    #slots = [this.left, this.right, this.none];
+
+    /** @type {Map<import('./xr/XRInputTypes.js').XRInputSource, XRInputHandle>} */
+    #handles = new Map();
+
+    /** @type {XRInputHandle[]} */
+    #connected = [];
+
+    /**
+     * Attached session, or null. Change through {@link setSession}.
+     * @readonly
+     * @type {import('./xr/XRInputTypes.js').XRSession|null}
+     */
+    session = null;
+
+    /**
+     * Space in which poses are reported, or null. Change through {@link setReferenceSpace}.
+     * @readonly
+     * @type {EventTarget|null}
+     */
+    referenceSpace = null;
+
+    #running = false;
+    #busy = false;
+    #draining = false;
+
+    /**
+     * Configuration changes requested during an update; frames are never queued.
+     * @type {Deque<()=>void>}
+     */
+    #pending = new Deque();
+
+    get isRunning() {
+        return this.#running;
+    }
+
+    /** Start listening to the configured session. Safe to call repeatedly. */
+    start() {
+        if (this.#busy) {
+            this.#pending.addLast(() => this.start());
+            return;
+        }
+        if (this.#running) {
+            return;
+        }
+        this.#busy = true;
+        try {
+            this.#running = true;
+            this.#listen(true);
+            this.#reconcile();
+            this.#sample(null);
+        } finally {
+            this.#finish();
+        }
+    }
+
+    /** Detach without ending the application's native XRSession. */
+    stop() {
+        if (this.#busy) {
+            this.#pending.addLast(() => this.stop());
+            return;
+        }
+        this.#busy = true;
+        try {
+            this.#detach();
+            this.#running = false;
+        } finally {
+            this.#finish();
+        }
+    }
+
+    /**
+     * Attach an existing session. May be called before {@link start}. Pass null to detach.
+     * The application remains responsible for requesting and ending the native session.
+     * @param {import('./xr/XRInputTypes.js').XRSession|null} session
+     * @param {EventTarget|null} [referenceSpace=null] Null still samples controls, with invalid poses.
+     */
+    setSession(session, referenceSpace = null) {
+        assert.defined(session, 'session');
+
+        if (session === null) {
+            referenceSpace = null;
+        } else {
+            assert.isFunction(session.addEventListener, 'session.addEventListener');
+            assert.isFunction(session.removeEventListener, 'session.removeEventListener');
+            assert.isArrayLike(session.inputSources, 'session.inputSources');
+            assert.enum(session.visibilityState, XRVisibilityState, 'session.visibilityState');
+        }
+
+        if (referenceSpace !== null) {
+            assert.isFunction(referenceSpace.addEventListener, 'referenceSpace.addEventListener');
+            assert.isFunction(referenceSpace.removeEventListener, 'referenceSpace.removeEventListener');
+        }
+
+        if (this.#busy) {
+            this.#pending.addLast(() => this.setSession(session, referenceSpace));
+            return;
+        }
+        if (session === this.session) {
+            this.setReferenceSpace(referenceSpace);
+            return;
+        }
+        this.#busy = true;
+        try {
+            this.#detach();
+            this.session = session;
+            this.referenceSpace = referenceSpace;
+            if (this.#running) {
+                this.#listen(true);
+                this.#reconcile();
+                this.#sample(null);
+            }
+        } finally {
+            this.#finish();
+        }
+    }
+
+    /**
+     * Change the space used for poses. Existing poses become invalid until the next frame.
+     * Pass null to disable pose sampling while continuing to sample controls.
+     * @param {EventTarget|null} referenceSpace
+     */
+    setReferenceSpace(referenceSpace) {
+        assert.defined(referenceSpace, 'referenceSpace');
+
+        if (referenceSpace !== null) {
+            assert.isFunction(referenceSpace.addEventListener, 'referenceSpace.addEventListener');
+            assert.isFunction(referenceSpace.removeEventListener, 'referenceSpace.removeEventListener');
+        }
+
+        if (this.#busy) {
+            this.#pending.addLast(() => this.setReferenceSpace(referenceSpace));
+            return;
+        }
+        if (referenceSpace === this.referenceSpace) {
+            return;
+        }
+        this.#busy = true;
+        try {
+            if (this.referenceSpace !== null && this.#running) {
+                this.referenceSpace.removeEventListener('reset', this.#onReset);
+            }
+            this.referenceSpace = referenceSpace;
+            if (referenceSpace !== null && this.#running) {
+                referenceSpace.addEventListener('reset', this.#onReset);
+            }
+            this.#invalidatePoses();
+        } finally {
+            this.#finish();
+        }
+    }
+
+    /**
+     * No-op without a running session. Otherwise call only within that session's active frame callback.
+     * @param {import('./xr/XRInputTypes.js').XRFrame} [frame]
+     */
+    poll(frame) {
+        if (!this.#running || this.session === null || this.#busy) {
+            return;
+        }
+        assert.defined(frame, 'frame');
+        assert.notNull(frame, 'frame');
+        assert.equal(frame.session, this.session, 'frame.session');
+        assert.isFunction(frame.getPose, 'frame.getPose');
+
+        this.#busy = true;
+        try {
+            this.#reconcile();
+            this.#sample(frame);
+        } finally {
+            this.#finish();
+        }
+    }
+
+    /** @param {boolean} add */
+    #listen(add) {
+        const method = add ? 'addEventListener' : 'removeEventListener';
+        if (this.session !== null) {
+            for (let i = 0; i < SESSION_EVENTS.length; i++) {
+                this.session[method](SESSION_EVENTS[i], this.#onEvent);
+            }
+        }
+        if (this.referenceSpace !== null) {
+            this.referenceSpace[method]('reset', this.#onReset);
+        }
+    }
+
+    #detach() {
+        this.#listen(false);
+        this.session = null;
+        this.referenceSpace = null;
+        this.#clear();
+        for (let i = 0; i < this.#slots.length; i++) {
+            this.#slots[i].bind(null);
+        }
+        while (this.sources.length > 0) {
+            const handle = this.sources.pop();
+            this.#handles.delete(handle.nativeSource);
+            handle.bind(null);
+            this.on.disconnected.send1(handle);
+        }
+        this.#connected.length = 0;
+    }
+
+    /** @param {import('./xr/XRInputTypes.js').XRInputSource} source */
+    #contains(source) {
+        const sources = this.session.inputSources;
+        for (let i = 0; i < sources.length; i++) {
+            if (sources[i] === source) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    #reconcile() {
+        if (this.session === null) {
+            return;
+        }
+        for (let i = this.sources.length - 1; i >= 0; i--) {
+            const handle = this.sources[i];
+            const source = handle.nativeSource;
+            if (!this.#contains(source)) {
+                this.sources.splice(i, 1);
+                this.#handles.delete(source);
+                for (let j = 0; j < this.#slots.length; j++) {
+                    if (this.#slots[j].nativeSource === source) {
+                        this.#slots[j].bind(null);
+                    }
+                }
+                handle.bind(null);
+                this.on.disconnected.send1(handle);
+            }
+        }
+        const sources = this.session.inputSources;
+        for (let i = 0; i < sources.length; i++) {
+            const source = sources[i];
+            if (!this.#handles.has(source)) {
+                const handle = new XRInputHandle();
+                handle.bind(source);
+                this.#handles.set(source, handle);
+                this.sources.push(handle);
+                this.#connected.push(handle);
+            }
+        }
+        this.#bindSlot(this.left, XRHandedness.Left);
+        this.#bindSlot(this.right, XRHandedness.Right);
+        this.#bindSlot(this.none, XRHandedness.None);
+    }
+
+    /**
+     * @param {XRInputHandle} slot
+     * @param {string} handedness
+     */
+    #bindSlot(slot, handedness) {
+        if (slot.connected) {
+            return;
+        }
+        for (let i = 0; i < this.sources.length; i++) {
+            const source = this.sources[i].nativeSource;
+            if (source.handedness === handedness) {
+                slot.bind(source);
+                return;
+            }
+        }
+    }
+
+    /** @param {import('./xr/XRInputTypes.js').XRFrame|null} frame */
+    #sample(frame) {
+        if (this.session !== null && this.session.visibilityState === XRVisibilityState.Visible) {
+            for (let i = 0; i < this.sources.length; i++) {
+                this.sources[i].sample(frame, this.referenceSpace);
+            }
+            for (let i = 0; i < this.#slots.length; i++) {
+                this.#slots[i].sample(frame, this.referenceSpace);
+            }
+            this.#flush();
+        } else {
+            this.#clear();
+        }
+        for (let i = 0; i < this.#connected.length; i++) {
+            this.on.connected.send1(this.#connected[i]);
+        }
+        this.#connected.length = 0;
+    }
+
+    #clear() {
+        for (let i = 0; i < this.sources.length; i++) {
+            this.sources[i].clear();
+        }
+        for (let i = 0; i < this.#slots.length; i++) {
+            this.#slots[i].clear();
+        }
+        this.#flush();
+    }
+
+    #flush() {
+        for (let i = 0; i < this.sources.length; i++) {
+            this.sources[i].flush();
+        }
+        for (let i = 0; i < this.#slots.length; i++) {
+            this.#slots[i].flush();
+        }
+    }
+
+    #invalidatePoses() {
+        for (let i = 0; i < this.sources.length; i++) {
+            this.sources[i].invalidatePoses();
+        }
+        for (let i = 0; i < this.#slots.length; i++) {
+            this.#slots[i].invalidatePoses();
+        }
+    }
+
+    #onReset = () => {
+        if (this.#busy) {
+            this.#pending.addLast(() => this.#onReset());
+            return;
+        }
+        this.#busy = true;
+        try {
+            this.#invalidatePoses();
+        } finally {
+            this.#finish();
+        }
+    };
+
+    /** @param {import('./xr/XRInputTypes.js').XRSessionInputEvent} event */
+    #onEvent = (event) => {
+        if (!this.#running || event.currentTarget !== this.session || this.#busy) {
+            return;
+        }
+        this.#busy = true;
+        try {
+            if (event.type === 'end') {
+                this.#detach();
+                return;
+            }
+            this.#reconcile();
+            const frame = event.frame ?? null;
+            const inputSource = event.inputSource ?? null;
+            if (frame !== null && frame.session !== this.session) {
+                return;
+            }
+            this.#sample(frame);
+            if (this.session.visibilityState !== XRVisibilityState.Visible || inputSource === null) {
+                return;
+            }
+            const handle = this.#handles.get(inputSource);
+            if (handle === undefined) {
+                return;
+            }
+            this.#actionEvent(handle, event.type);
+            for (let i = 0; i < this.#slots.length; i++) {
+                const slot = this.#slots[i];
+                if (slot.nativeSource === inputSource) {
+                    this.#actionEvent(slot, event.type);
+                }
+            }
+        } finally {
+            this.#finish();
+        }
+    };
+
+    /**
+     * @param {XRInputHandle} handle
+     * @param {string} type
+     */
+    #actionEvent(handle, type) {
+        switch (type) {
+            case 'selectstart':
+                handle.select.begin();
+                break;
+            case 'select':
+                handle.select.complete();
+                break;
+            case 'selectend':
+                handle.select.end();
+                break;
+            case 'squeezestart':
+                handle.squeeze.begin();
+                break;
+            case 'squeeze':
+                handle.squeeze.complete();
+                break;
+            case 'squeezeend':
+                handle.squeeze.end();
+                break;
+        }
+    }
+
+    #finish() {
+        this.#busy = false;
+        if (this.#draining) {
+            return;
+        }
+        this.#draining = true;
+        try {
+            while (!this.#pending.isEmpty()) {
+                const change = this.#pending.removeFirst();
+                change();
+            }
+        } finally {
+            this.#draining = false;
+        }
+    }
+}

package/src/engine/input/devices/xr/XRGamepadMapping.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Mapping values exposed by an XR input source's gamepad.
+ */
+export type XRGamepadMapping = string;
+/**
+ * Mapping values exposed by an XR input source's gamepad.
+ * @readonly
+ * @enum {string}
+ */
+export const XRGamepadMapping: Readonly<{
+    Unmapped: "";
+    Standard: "xr-standard";
+}>;
+//# sourceMappingURL=XRGamepadMapping.d.ts.map

package/src/engine/input/devices/xr/XRGamepadMapping.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"XRGamepadMapping.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/input/devices/xr/XRGamepadMapping.js"],"names":[],"mappings":";;;+BAGU,MAAM;AAHhB;;;;GAIG;AACH;;;GAGG"}

package/src/engine/input/devices/xr/XRGamepadMapping.js

@@ -0,0 +1,9 @@
+/**
+ * Mapping values exposed by an XR input source's gamepad.
+ * @readonly
+ * @enum {string}
+ */
+export const XRGamepadMapping = Object.freeze({
+    Unmapped: '',
+    Standard: 'xr-standard'
+});

package/src/engine/input/devices/xr/XRHandedness.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Native XRInputSource handedness values.
+ */
+export type XRHandedness = string;
+/**
+ * Native XRInputSource handedness values.
+ * @readonly
+ * @enum {string}
+ */
+export const XRHandedness: Readonly<{
+    None: "none";
+    Left: "left";
+    Right: "right";
+}>;
+//# sourceMappingURL=XRHandedness.d.ts.map