@woosh/meep-engine 3.35.0 → 3.37.0

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

@@ -0,0 +1,268 @@
+import { assert } from "../../../../core/assert.js";
+import { Vector1 } from "../../../../core/geom/Vector1.js";
+import Vector2 from "../../../../core/geom/Vector2.js";
+import { GamepadStick } from "../gamepad/GamepadStick.js";
+import { XRInputAction } from "./XRInputAction.js";
+import { XRInputButton } from "./XRInputButton.js";
+import { XRInputPose, xr_input_read_pose } from "./XRInputPose.js";
+import { XRInputValueSource } from "./XRInputValueSource.js";
+import { XRHandedness } from "./XRHandedness.js";
+import { XRTargetRayMode } from "./XRTargetRayMode.js";
+import { XRGamepadMapping } from "./XRGamepadMapping.js";
+
+const DEFAULT_METADATA = Object.freeze({
+    handedness: XRHandedness.None,
+    targetRayMode: XRTargetRayMode.Unavailable,
+    profiles: Object.freeze([])
+});
+
+/** @type {import('./XRInputTypes.js').XRGamepad} */
+const DEFAULT_GAMEPAD = Object.freeze({
+    mapping: XRGamepadMapping.Unmapped,
+    buttons: Object.freeze([]),
+    axes: Object.freeze([])
+});
+
+const DEFAULT_BUTTON = Object.freeze({ value: 0, pressed: false, touched: false });
+
+/**
+ * One XR input source, or a persistent handedness slot owned by XRInputDevice.
+ * All control objects survive disconnection. Consumers read them; the device owns mutation.
+ * With xr-standard, select/squeeze read native button amounts. Other mappings remain available through
+ * buttons/axes, while select/squeeze report 0/1 from native events; check their valueSource.
+ *
+ * Button indices 0/1 are select/squeeze; axes 0/1 are touchpad and 2/3 thumbstick in xr-standard.
+ * Placeholder entries are allowed by WebXR: a zero entry does not prove that a control exists.
+ */
+export class XRInputHandle {
+    /** @readonly */
+    select = new XRInputAction();
+
+    /** @readonly */
+    squeeze = new XRInputAction();
+
+    /**
+     * Raw native buttons. Use {@link getButton} for an index that may not exist yet.
+     * @readonly
+     * @type {XRInputButton[]}
+     */
+    buttons = [];
+
+    /**
+     * Raw native axes in [-1, 1]. Use {@link getAxis} for an index that may not exist yet.
+     * @readonly
+     * @type {Vector1[]}
+     */
+    axes = [];
+
+    /**
+     * Calibrated xr-standard thumbstick, +x right and +y down.
+     * @readonly
+     */
+    thumbstick = new GamepadStick(2, 3);
+
+    /**
+     * Uncalibrated xr-standard touchpad coordinates, +x right and +y down.
+     * @readonly
+     */
+    touchpad = new Vector2();
+
+    /** @readonly */
+    targetRay = new XRInputPose();
+
+    /** @readonly */
+    grip = new XRInputPose();
+
+    /**
+     * Native source, or null while disconnected. Set by the device.
+     * @readonly
+     * @type {import('./XRInputTypes.js').XRInputSource|null}
+     */
+    nativeSource = null;
+
+    /** @type {Pick<import('./XRInputTypes.js').XRInputSource, 'handedness'|'targetRayMode'|'profiles'>} */
+    #metadata = DEFAULT_METADATA;
+
+    /** @type {number[]} */
+    #axisValues = [0, 0, 0, 0];
+
+    /** Number of native buttons, excluding controls materialised for bindings. Do not modify directly. */
+    buttonCount = 0;
+
+    /** Number of native axes, excluding controls materialised for bindings. Do not modify directly. */
+    axisCount = 0;
+
+    constructor() {
+        this.getButton(3);
+        this.getAxis(3);
+    }
+
+    get connected() {
+        return this.nativeSource !== null;
+    }
+
+    get handedness() {
+        return this.#metadata.handedness;
+    }
+
+    get targetRayMode() {
+        return this.#metadata.targetRayMode;
+    }
+
+    /** @returns {ReadonlyArray<string>} */
+    get profiles() {
+        return this.#metadata.profiles;
+    }
+
+    /**
+     * Return a stable button, creating neutral entries up to this index if needed.
+     * @param {number} index
+     * @returns {XRInputButton}
+     */
+    getButton(index) {
+        assert.isNonNegativeInteger(index, 'index');
+
+        while (this.buttons.length <= index) {
+            this.buttons.push(new XRInputButton());
+        }
+
+        return this.buttons[index];
+    }
+
+    /**
+     * Return a stable axis, creating neutral entries up to this index if needed.
+     * @param {number} index
+     * @returns {Vector1}
+     */
+    getAxis(index) {
+        assert.isNonNegativeInteger(index, 'index');
+
+        while (this.axes.length <= index) {
+            this.axes.push(new Vector1());
+        }
+
+        return this.axes[index];
+    }
+
+    /**
+     * @internal
+     * @param {import('./XRInputTypes.js').XRInputSource|null} source
+     */
+    bind(source) {
+        assert.defined(source, 'source');
+        assert.isObject(source, 'source');
+
+        if (this.nativeSource === source) {
+            return;
+        }
+        this.nativeSource = null;
+        this.#metadata = DEFAULT_METADATA;
+        this.clear();
+        this.flush();
+        this.thumbstick.forgetCalibration();
+        this.nativeSource = source;
+        this.#metadata = source ?? DEFAULT_METADATA;
+    }
+
+    /**
+     * @internal Sample values and poses before publishing raw switch edges.
+     * @param {import('./XRInputTypes.js').XRFrame|null} frame
+     * @param {EventTarget|null} referenceSpace
+     */
+    sample(frame, referenceSpace) {
+        assert.defined(frame, 'frame');
+        assert.defined(referenceSpace, 'referenceSpace');
+
+        const source = this.nativeSource;
+        if (source === null) {
+            return;
+        }
+        // A source/visibility notification has no pose frame. Preserve the last sample in that case;
+        // only an actual unavailable pose, a reference-space change or cleanup invalidates it.
+        if (frame !== null) {
+            const ray = xr_input_read_pose(frame, source.targetRaySpace, referenceSpace);
+            const grip = xr_input_read_pose(frame, source.gripSpace ?? null, referenceSpace);
+            this.targetRay.update(ray);
+            this.grip.update(grip);
+        }
+
+        const gamepad = source.gamepad ?? DEFAULT_GAMEPAD;
+        const mapped = gamepad.mapping === XRGamepadMapping.Standard;
+        this.buttonCount = gamepad.buttons.length;
+        this.axisCount = gamepad.axes.length;
+        if (this.buttonCount > 0) {
+            this.getButton(this.buttonCount - 1);
+        }
+        if (this.axisCount > 0) {
+            this.getAxis(this.axisCount - 1);
+        }
+        for (let i = 0; i < this.buttons.length; i++) {
+            const button = gamepad.buttons[i] ?? DEFAULT_BUTTON;
+            this.buttons[i].update(button.value, button.pressed, button.touched);
+        }
+        for (let i = 0; i < this.axes.length; i++) {
+            const value = gamepad.axes[i] ?? 0;
+            this.#axisValues[i] = value;
+            this.axes[i].set(value);
+        }
+        if (mapped) {
+            this.touchpad.set(this.#axisValues[0], this.#axisValues[1]);
+            this.thumbstick.update(this.#axisValues);
+        } else {
+            this.touchpad.set(0, 0);
+            this.thumbstick.reset();
+        }
+        this.#sampleAction(this.select, 0, mapped);
+        this.#sampleAction(this.squeeze, 1, mapped);
+    }
+
+    /**
+     * @param {XRInputAction} action
+     * @param {number} buttonIndex
+     * @param {boolean} mapped
+     */
+    #sampleAction(action, buttonIndex, mapped) {
+        if (mapped && buttonIndex < this.buttonCount) {
+            action.update(this.buttons[buttonIndex].x, XRInputValueSource.Gamepad);
+            return;
+        }
+        // Preserve event-driven amounts between native begin/end events. Clear a previous hardware
+        // amount when entering event-only mode.
+        if (action.valueSource !== XRInputValueSource.Action) {
+            action.update(0, XRInputValueSource.Action);
+        }
+    }
+
+    /** @internal Tracking loss does not imply release or cancellation. */
+    invalidatePoses() {
+        this.targetRay.update();
+        this.grip.update();
+    }
+
+    /** @internal Neutralise everything before switch releases and cancellation callbacks. */
+    clear() {
+        this.invalidatePoses();
+        this.buttonCount = 0;
+        this.axisCount = 0;
+        for (let i = 0; i < this.buttons.length; i++) {
+            this.buttons[i].update();
+        }
+        for (let i = 0; i < this.axes.length; i++) {
+            this.axes[i].set(0);
+            this.#axisValues[i] = 0;
+        }
+        this.touchpad.set(0, 0);
+        this.thumbstick.reset();
+        this.select.reset();
+        this.squeeze.reset();
+    }
+
+    /** @internal */
+    flush() {
+        for (let i = 0; i < this.buttons.length; i++) {
+            this.buttons[i].flushSwitches();
+        }
+        this.select.flushCancellation();
+        this.squeeze.flushCancellation();
+    }
+}

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

@@ -0,0 +1,59 @@
+/**
+ * Read a pose relative to the reference space. Returns {@link DEFAULT_POSE} when either space or
+ * the native pose is unavailable.
+ * @param {import('./XRInputTypes.js').XRFrame} frame
+ * @param {EventTarget|null} space
+ * @param {EventTarget|null} referenceSpace
+ * @returns {import('./XRInputTypes.js').XRPose}
+ */
+export function xr_input_read_pose(frame: import('./XRInputTypes.js').XRFrame, space: EventTarget | null, referenceSpace: EventTarget | null): import('./XRInputTypes.js').XRPose;
+/**
+ * Neutral, unavailable pose. Shared immutable data, copied into each handle's own meep vectors.
+ * Identity is significant: a real tracked pose at the origin is still valid.
+ * @readonly
+ */
+export const DEFAULT_POSE: Readonly<{
+    transform: Readonly<{
+        position: Readonly<{
+            x: 0;
+            y: 0;
+            z: 0;
+        }>;
+        orientation: Readonly<{
+            x: 0;
+            y: 0;
+            z: 0;
+            w: 1;
+        }>;
+    }>;
+    emulatedPosition: false;
+}>;
+/**
+ * A copied pose in the device's configured reference space. The device owns mutation.
+ * Check {@link valid} before use. An unavailable pose has zero position and identity rotation.
+ * Target-ray forward is local -Z, regardless of a game's own forward convention.
+ */
+export class XRInputPose {
+    /** @readonly */
+    readonly position: Vector3;
+    /** @readonly */
+    readonly rotation: Quaternion;
+    /**
+     * Whether a pose is available in the current reference space. Do not modify directly.
+     * @type {boolean}
+     */
+    valid: boolean;
+    /**
+     * Whether the browser estimates the position instead of tracking it. Do not modify directly.
+     * @type {boolean}
+     */
+    emulatedPosition: boolean;
+    /**
+     * @internal
+     * @param {import("./XRInputTypes.js").XRPose} [pose=DEFAULT_POSE]
+     */
+    update(pose?: import("./XRInputTypes.js").XRPose): void;
+}
+import Vector3 from "../../../../core/geom/Vector3.js";
+import Quaternion from "../../../../core/geom/Quaternion.js";
+//# sourceMappingURL=XRInputPose.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"XRInputPose.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/input/devices/xr/XRInputPose.js"],"names":[],"mappings":"AAiBA;;;;;;;GAOG;AACH,0CALW,OAAO,mBAAmB,EAAE,OAAO,SACnC,WAAW,GAAC,IAAI,kBAChB,WAAW,GAAC,IAAI,GACd,OAAO,mBAAmB,EAAE,MAAM,CAW9C;AA9BD;;;;GAIG;AACH;;;;;;;;;;;;;;;GAMG;AAqBH;;;;GAIG;AACH;IACI,gBAAgB;IAChB,2BAAyB;IAEzB,gBAAgB;IAChB,8BAA4B;IAE5B;;;OAGG;IACH,OAFU,OAAO,CAEH;IAEd;;;OAGG;IACH,kBAFU,OAAO,CAEQ;IAEzB;;;OAGG;IACH,cAFW,OAAO,mBAAmB,EAAE,MAAM,QAa5C;CACJ;oBA1EmB,kCAAkC;uBAD/B,qCAAqC"}

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

@@ -0,0 +1,77 @@
+import { assert } from "../../../../core/assert.js";
+import Quaternion from "../../../../core/geom/Quaternion.js";
+import Vector3 from "../../../../core/geom/Vector3.js";
+
+/**
+ * Neutral, unavailable pose. Shared immutable data, copied into each handle's own meep vectors.
+ * Identity is significant: a real tracked pose at the origin is still valid.
+ * @readonly
+ */
+export const DEFAULT_POSE = Object.freeze({
+    transform: Object.freeze({
+        position: Object.freeze({ x: 0, y: 0, z: 0 }),
+        orientation: Object.freeze({ x: 0, y: 0, z: 0, w: 1 })
+    }),
+    emulatedPosition: false
+});
+
+/**
+ * Read a pose relative to the reference space. Returns {@link DEFAULT_POSE} when either space or
+ * the native pose is unavailable.
+ * @param {import('./XRInputTypes.js').XRFrame} frame
+ * @param {EventTarget|null} space
+ * @param {EventTarget|null} referenceSpace
+ * @returns {import('./XRInputTypes.js').XRPose}
+ */
+export function xr_input_read_pose(frame, space, referenceSpace) {
+    assert.defined(space, 'space');
+    assert.defined(referenceSpace, 'referenceSpace');
+
+    if (space === null || referenceSpace === null) {
+        return DEFAULT_POSE;
+    }
+
+    return frame.getPose(space, referenceSpace) ?? DEFAULT_POSE;
+}
+
+/**
+ * A copied pose in the device's configured reference space. The device owns mutation.
+ * Check {@link valid} before use. An unavailable pose has zero position and identity rotation.
+ * Target-ray forward is local -Z, regardless of a game's own forward convention.
+ */
+export class XRInputPose {
+    /** @readonly */
+    position = new Vector3();
+
+    /** @readonly */
+    rotation = new Quaternion();
+
+    /**
+     * Whether a pose is available in the current reference space. Do not modify directly.
+     * @type {boolean}
+     */
+    valid = false;
+
+    /**
+     * Whether the browser estimates the position instead of tracking it. Do not modify directly.
+     * @type {boolean}
+     */
+    emulatedPosition = false;
+
+    /**
+     * @internal
+     * @param {import("./XRInputTypes.js").XRPose} [pose=DEFAULT_POSE]
+     */
+    update(pose = DEFAULT_POSE) {
+        assert.notNull(pose, 'pose');
+        assert.isBoolean(pose.emulatedPosition, 'pose.emulatedPosition');
+
+        const p = pose.transform.position;
+        const q = pose.transform.orientation;
+
+        this.valid = pose !== DEFAULT_POSE;
+        this.emulatedPosition = pose.emulatedPosition;
+        this.position.set(p.x, p.y, p.z);
+        this.rotation.set(q.x, q.y, q.z, q.w);
+    }
+}

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

@@ -0,0 +1,76 @@
+/**
+ * WebXR interfaces accepted by meep's input API. Native WebXR objects satisfy these structural types;
+ * applications can use meep's declarations without installing ambient WebXR types.
+ * Only the members consumed by the input device are required.
+ */
+export type XRGamepad = {
+    mapping: string;
+    buttons: ReadonlyArray<{
+        value: number;
+        pressed: boolean;
+        touched: boolean;
+    }>;
+    axes: ReadonlyArray<number>;
+};
+/**
+ * WebXR interfaces accepted by meep's input API. Native WebXR objects satisfy these structural types;
+ * applications can use meep's declarations without installing ambient WebXR types.
+ * Only the members consumed by the input device are required.
+ */
+export type XRInputSource = {
+    handedness: string;
+    targetRayMode: string;
+    profiles: ReadonlyArray<string>;
+    targetRaySpace: EventTarget;
+    gripSpace?: EventTarget | null;
+    gamepad?: XRGamepad | null;
+};
+/**
+ * WebXR interfaces accepted by meep's input API. Native WebXR objects satisfy these structural types;
+ * applications can use meep's declarations without installing ambient WebXR types.
+ * Only the members consumed by the input device are required.
+ */
+export type XRSession = EventTarget & {
+    readonly inputSources: ArrayLike<XRInputSource>;
+    readonly visibilityState: string;
+};
+/**
+ * WebXR interfaces accepted by meep's input API. Native WebXR objects satisfy these structural types;
+ * applications can use meep's declarations without installing ambient WebXR types.
+ * Only the members consumed by the input device are required.
+ */
+export type XRPose = {
+    transform: {
+        position: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        orientation: {
+            x: number;
+            y: number;
+            z: number;
+            w: number;
+        };
+    };
+    emulatedPosition: boolean;
+};
+/**
+ * WebXR interfaces accepted by meep's input API. Native WebXR objects satisfy these structural types;
+ * applications can use meep's declarations without installing ambient WebXR types.
+ * Only the members consumed by the input device are required.
+ */
+export type XRFrame = {
+    session: XRSession;
+    getPose: (space: EventTarget, baseSpace: EventTarget) => XRPose | null | undefined;
+};
+/**
+ * WebXR interfaces accepted by meep's input API. Native WebXR objects satisfy these structural types;
+ * applications can use meep's declarations without installing ambient WebXR types.
+ * Only the members consumed by the input device are required.
+ */
+export type XRSessionInputEvent = Event & {
+    inputSource?: XRInputSource;
+    frame?: XRFrame;
+};
+//# sourceMappingURL=XRInputTypes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"XRInputTypes.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/input/devices/xr/XRInputTypes.js"],"names":[],"mappings":";;;;;;aAMc,MAAM;aACN,cAAc;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,OAAO,CAAC;QAAC,OAAO,EAAE,OAAO,CAAA;KAAC,CAAC;UAClE,cAAc,MAAM,CAAC;;;;;;;;gBAGrB,MAAM;mBACN,MAAM;cACN,cAAc,MAAM,CAAC;oBACrB,WAAW;gBACX,WAAW,GAAC,IAAI;cAChB,SAAS,GAAC,IAAI;;;;;;;wBAEf,WAAW,GAAG;IAAC,QAAQ,CAAC,YAAY,EAAE,UAAU,aAAa,CAAC,CAAC;IAAC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAA;CAAC;;;;;;;eAGhG;QAAC,QAAQ,EAAE;YAAC,CAAC,EAAE,MAAM,CAAC;YAAC,CAAC,EAAE,MAAM,CAAC;YAAC,CAAC,EAAE,MAAM,CAAA;SAAC,CAAC;QAAC,WAAW,EAAE;YAAC,CAAC,EAAE,MAAM,CAAC;YAAC,CAAC,EAAE,MAAM,CAAC;YAAC,CAAC,EAAE,MAAM,CAAC;YAAC,CAAC,EAAE,MAAM,CAAA;SAAC,CAAA;KAAC;sBACxG,OAAO;;;;;;;;aAGP,SAAS;aACT,CAAC,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,WAAW,KAAK,MAAM,GAAC,IAAI,GAAC,SAAS;;;;;;;kCAEtE,KAAK,GAAG;IAAC,WAAW,CAAC,EAAE,aAAa,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAC"}

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

@@ -0,0 +1,31 @@
+/**
+ * WebXR interfaces accepted by meep's input API. Native WebXR objects satisfy these structural types;
+ * applications can use meep's declarations without installing ambient WebXR types.
+ * Only the members consumed by the input device are required.
+ *
+ * @typedef {object} XRGamepad
+ * @property {string} mapping
+ * @property {ReadonlyArray<{value: number, pressed: boolean, touched: boolean}>} buttons
+ * @property {ReadonlyArray<number>} axes
+ *
+ * @typedef {object} XRInputSource
+ * @property {string} handedness
+ * @property {string} targetRayMode
+ * @property {ReadonlyArray<string>} profiles
+ * @property {EventTarget} targetRaySpace
+ * @property {EventTarget|null} [gripSpace]
+ * @property {XRGamepad|null} [gamepad]
+ *
+ * @typedef {EventTarget & {readonly inputSources: ArrayLike<XRInputSource>, readonly visibilityState: string}} XRSession
+ *
+ * @typedef {object} XRPose
+ * @property {{position: {x: number, y: number, z: number}, orientation: {x: number, y: number, z: number, w: number}}} transform
+ * @property {boolean} emulatedPosition
+ *
+ * @typedef {object} XRFrame
+ * @property {XRSession} session
+ * @property {(space: EventTarget, baseSpace: EventTarget) => XRPose|null|undefined} getPose
+ *
+ * @typedef {Event & {inputSource?: XRInputSource, frame?: XRFrame}} XRSessionInputEvent
+ */
+export {};

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

@@ -0,0 +1,11 @@
+/**
+ * Where an XR action's scalar comes from. Gamepad means a native button value, which may itself be
+ * digital. Action means an event-derived 0/1 value, not a measurement of pressure.
+ */
+export type XRInputValueSource = number;
+export namespace XRInputValueSource {
+    let Unavailable: number;
+    let Gamepad: number;
+    let Action: number;
+}
+//# sourceMappingURL=XRInputValueSource.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"XRInputValueSource.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/input/devices/xr/XRInputValueSource.js"],"names":[],"mappings":";;;;iCAIU,MAAM"}

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

@@ -0,0 +1,11 @@
+/**
+ * Where an XR action's scalar comes from. Gamepad means a native button value, which may itself be
+ * digital. Action means an event-derived 0/1 value, not a measurement of pressure.
+ * @readonly
+ * @enum {number}
+ */
+export const XRInputValueSource = {
+    Unavailable: 0,
+    Gamepad: 1,
+    Action: 2
+};

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

@@ -0,0 +1,17 @@
+/**
+ * Native target-ray modes, plus Unavailable for a disconnected handle.
+ */
+export type XRTargetRayMode = string;
+/**
+ * Native target-ray modes, plus Unavailable for a disconnected handle.
+ * @readonly
+ * @enum {string}
+ */
+export const XRTargetRayMode: Readonly<{
+    Unavailable: "";
+    Gaze: "gaze";
+    TrackedPointer: "tracked-pointer";
+    Screen: "screen";
+    TransientPointer: "transient-pointer";
+}>;
+//# sourceMappingURL=XRTargetRayMode.d.ts.map

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

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

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

@@ -0,0 +1,12 @@
+/**
+ * Native target-ray modes, plus Unavailable for a disconnected handle.
+ * @readonly
+ * @enum {string}
+ */
+export const XRTargetRayMode = Object.freeze({
+    Unavailable: '',
+    Gaze: 'gaze',
+    TrackedPointer: 'tracked-pointer',
+    Screen: 'screen',
+    TransientPointer: 'transient-pointer'
+});

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

@@ -0,0 +1,15 @@
+/**
+ * Native XRSession visibility states.
+ */
+export type XRVisibilityState = string;
+/**
+ * Native XRSession visibility states.
+ * @readonly
+ * @enum {string}
+ */
+export const XRVisibilityState: Readonly<{
+    Visible: "visible";
+    VisibleBlurred: "visible-blurred";
+    Hidden: "hidden";
+}>;
+//# sourceMappingURL=XRVisibilityState.d.ts.map

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

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

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

@@ -0,0 +1,10 @@
+/**
+ * Native XRSession visibility states.
+ * @readonly
+ * @enum {string}
+ */
+export const XRVisibilityState = Object.freeze({
+    Visible: 'visible',
+    VisibleBlurred: 'visible-blurred',
+    Hidden: 'hidden'
+});

package/src/engine/input/ecs/ism/coordinate/InputCoordinateChannel.d.ts

@@ -1,3 +1,11 @@
+/**
+ * @typedef {import('./InputCoordinateChannelType.js').InputCoordinateChannelType} InputCoordinateChannelType
+ * @typedef {import('../InputSourceTable.js').InputSourceTable} InputSourceTable
+ * @typedef {import('../device/InputDeviceAdapter.js').InputDeviceAdapter} InputDeviceAdapter
+ * @typedef {import('../InputSource.js').InputSource} InputSource
+ * @typedef {import('../trigger/InputTrigger.js').InputTrigger} InputTrigger
+ * @typedef {import('../../../../../core/binary/BitSet.js').BitSet} BitSet
+ */
 /**
  * An N-dimensional analog channel an action can be bound to.
  *
@@ -16,7 +24,7 @@ export class InputCoordinateChannel {
     /**
      * @returns {InputCoordinateChannelType}
      */
-    get type(): InputCoordinateChannelType;
+    get type(): number;
     /**
      * Component count.
      * @returns {number}
@@ -64,4 +72,10 @@ export class InputCoordinateChannel {
      */
     hash(): number;
 }
+export type InputCoordinateChannelType = import('./InputCoordinateChannelType.js').InputCoordinateChannelType;
+export type InputSourceTable = import('../InputSourceTable.js').InputSourceTable;
+export type InputDeviceAdapter = import('../device/InputDeviceAdapter.js').InputDeviceAdapter;
+export type InputSource = import('../InputSource.js').InputSource;
+export type InputTrigger = import('../trigger/InputTrigger.js').InputTrigger;
+export type BitSet = import('../../../../../core/binary/BitSet.js').BitSet;
 //# sourceMappingURL=InputCoordinateChannel.d.ts.map

package/src/engine/input/ecs/ism/coordinate/InputCoordinateChannel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"InputCoordinateChannel.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/input/ecs/ism/coordinate/InputCoordinateChannel.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH;IAEI;;OAEG;IACH,uCAEC;IAED;;;OAGG;IACH,yBAEC;IAED;;;;;;OAMG;IACH,2CAFW,IAAI,MAAM,qBAAqB,QAIzC;IAED;;OAEG;IACH,uBAFW,aAAa,QAIvB;IAED;;;;;;;;OAQG;IACH,wBAFW,cAAc,QAIxB;IAED;;;;OAIG;IACH,aAJW,MAAM,EAAE,GAAC,YAAY,UACrB,MAAM,sBAKhB;IAED;;OAEG;IACH,SAFa,sBAAsB,CAIlC;IAED;;;OAGG;IACH,cAHW,sBAAsB,GACpB,OAAO,CAInB;IAED;;OAEG;IACH,QAFa,MAAM,CAIlB;CACJ"}
+{"version":3,"file":"InputCoordinateChannel.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/input/ecs/ism/coordinate/InputCoordinateChannel.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;;;;;;;;;;;;GAaG;AACH;IAEI;;OAEG;IACH,mBAEC;IAED;;;OAGG;IACH,yBAEC;IAED;;;;;;OAMG;IACH,eAHW,gBAAgB,YAChB,IAAI,MAAM,EAAE,kBAAkB,CAAC,QAIzC;IAED;;OAEG;IACH,uBAFW,WAAW,EAAE,QAIvB;IAED;;;;;;;;OAQG;IACH,wBAFW,YAAY,EAAE,QAIxB;IAED;;;;OAIG;IACH,aAJW,MAAM,EAAE,GAAC,YAAY,UACrB,MAAM,QACN,MAAM,QAIhB;IAED;;OAEG;IACH,SAFa,sBAAsB,CAIlC;IAED;;;OAGG;IACH,cAHW,sBAAsB,GACpB,OAAO,CAInB;IAED;;OAEG;IACH,QAFa,MAAM,CAIlB;CACJ;yCApGY,OAAO,iCAAiC,EAAE,0BAA0B;+BACpE,OAAO,wBAAwB,EAAE,gBAAgB;iCACjD,OAAO,iCAAiC,EAAE,kBAAkB;0BAC5D,OAAO,mBAAmB,EAAE,WAAW;2BACvC,OAAO,4BAA4B,EAAE,YAAY;qBACjD,OAAO,sCAAsC,EAAE,MAAM"}

package/src/engine/input/ecs/ism/coordinate/InputCoordinateChannel.js

@@ -1,3 +1,12 @@
+/**
+ * @typedef {import('./InputCoordinateChannelType.js').InputCoordinateChannelType} InputCoordinateChannelType
+ * @typedef {import('../InputSourceTable.js').InputSourceTable} InputSourceTable
+ * @typedef {import('../device/InputDeviceAdapter.js').InputDeviceAdapter} InputDeviceAdapter
+ * @typedef {import('../InputSource.js').InputSource} InputSource
+ * @typedef {import('../trigger/InputTrigger.js').InputTrigger} InputTrigger
+ * @typedef {import('../../../../../core/binary/BitSet.js').BitSet} BitSet
+ */
+
 /**
  * An N-dimensional analog channel an action can be bound to.
  *