@woosh/meep-engine 2.169.0 → 2.169.2

package/src/engine/input/devices/gamepad/GamepadDeviceLayout.js

@@ -0,0 +1,323 @@
+import { GamepadButtons } from "./GamepadButtons.js";
+import { GAMEPAD_LAYOUT_ABSENT, GamepadLayout } from "./GamepadLayout.js";
+import { gamepad_read_hat_axis, GamepadHatDirection } from "./gamepad_read_hat_axis.js";
+import { GAMEPAD_STANDARD_AXIS_COUNT, GAMEPAD_STANDARD_BUTTON_COUNT } from "./GamepadStandardMapping.js";
+
+/**
+ * Travel at which a button driven by an axis counts as pressed.
+ *
+ * The browsers use a half-press for the same conversion when they map a trigger axis onto a standard button,
+ * so matching it is what makes a pad behave the same whether it arrived over a connection the browser
+ * recognised or one it did not. Analog consumers read {@link GamepadHandle#buttonValues} and never see this.
+ *
+ * @type {number}
+ */
+const AXIS_BUTTON_PRESSED_THRESHOLD = 0.5;
+
+/**
+ * Standard button index -> hat direction that presses it, {@link GamepadHatDirection.none} for every button
+ * that is not part of the D-pad
+ * @readonly
+ * @type {number[]}
+ */
+const DPAD_DIRECTION_BY_BUTTON = new Array(GAMEPAD_STANDARD_BUTTON_COUNT).fill(GamepadHatDirection.none);
+
+DPAD_DIRECTION_BY_BUTTON[GamepadButtons.dpad_up] = GamepadHatDirection.up;
+DPAD_DIRECTION_BY_BUTTON[GamepadButtons.dpad_right] = GamepadHatDirection.right;
+DPAD_DIRECTION_BY_BUTTON[GamepadButtons.dpad_down] = GamepadHatDirection.down;
+DPAD_DIRECTION_BY_BUTTON[GamepadButtons.dpad_left] = GamepadHatDirection.left;
+
+/**
+ * Analog travel of a button the device reports as an axis.
+ *
+ * Such an axis rests at -1 and reaches +1 at full press, which is the same convention the browsers convert
+ * from when they recognise the pad themselves.
+ *
+ * @param {number} value raw axis value in [-1,1]
+ * @returns {number} travel in [0,1]
+ */
+function axis_to_button_value(value) {
+    return (value + 1) / 2;
+}
+
+/**
+ * A layout for one piece of hardware the browser did not recognise.
+ *
+ * Starts with every standard input unsourced and is filled in with what is known about the device, so a layout
+ * only ever claims what someone actually established. Unsourced inputs read as neutral and never fire, which
+ * is what the standard mapping already does for hardware that lacks a button - see {@link GamepadHandle#buttons}.
+ *
+ * A standard input has at most one source: the builders clear the alternatives, so a button cannot be driven
+ * by a device button and a device axis at the same time and there is no precedence rule to get wrong.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class GamepadDeviceLayout extends GamepadLayout {
+
+    /**
+     * Standard axis index -> device axis index
+     * @type {number[]}
+     */
+    #axes = new Array(GAMEPAD_STANDARD_AXIS_COUNT).fill(GAMEPAD_LAYOUT_ABSENT);
+
+    /**
+     * Standard button index -> device button index
+     * @type {number[]}
+     */
+    #buttons = new Array(GAMEPAD_STANDARD_BUTTON_COUNT).fill(GAMEPAD_LAYOUT_ABSENT);
+
+    /**
+     * Standard button index -> device axis index carrying that button's travel
+     * @type {number[]}
+     */
+    #buttonAxes = new Array(GAMEPAD_STANDARD_BUTTON_COUNT).fill(GAMEPAD_LAYOUT_ABSENT);
+
+    /**
+     * @type {number}
+     */
+    #hatAxis = GAMEPAD_LAYOUT_ABSENT;
+
+    /**
+     *
+     * @param {string} name
+     */
+    constructor(name) {
+        super();
+
+        this.name = name;
+    }
+
+    /**
+     *
+     * @param {number} standardAxis see {@link GamepadAxes}
+     * @param {number} deviceAxis index into the device's axis list
+     * @returns {GamepadDeviceLayout} this, for chaining
+     */
+    readsAxisFrom(standardAxis, deviceAxis) {
+        this.#axes[standardAxis] = deviceAxis;
+
+        return this;
+    }
+
+    /**
+     *
+     * @param {number} standardButton see {@link GamepadButtons}
+     * @param {number} deviceButton index into the device's button list
+     * @returns {GamepadDeviceLayout} this, for chaining
+     */
+    readsButtonFrom(standardButton, deviceButton) {
+        this.#buttons[standardButton] = deviceButton;
+        this.#buttonAxes[standardButton] = GAMEPAD_LAYOUT_ABSENT;
+
+        return this;
+    }
+
+    /**
+     * Drive a standard button from a device axis. This is how a non-standard pad reports its triggers.
+     *
+     * @param {number} standardButton see {@link GamepadButtons}
+     * @param {number} deviceAxis index into the device's axis list, resting at -1 and reaching +1 at full press
+     * @returns {GamepadDeviceLayout} this, for chaining
+     */
+    readsButtonFromAxis(standardButton, deviceAxis) {
+        this.#buttonAxes[standardButton] = deviceAxis;
+        this.#buttons[standardButton] = GAMEPAD_LAYOUT_ABSENT;
+
+        return this;
+    }
+
+    /**
+     * Drive the four D-pad buttons from a device axis carrying a HID hat switch, see
+     * {@link gamepad_read_hat_axis}.
+     *
+     * @param {number} deviceAxis index into the device's axis list
+     * @returns {GamepadDeviceLayout} this, for chaining
+     */
+    readsDpadFromHatAxis(deviceAxis) {
+        this.#hatAxis = deviceAxis;
+
+        this.#clearButtonSource(GamepadButtons.dpad_up);
+        this.#clearButtonSource(GamepadButtons.dpad_right);
+        this.#clearButtonSource(GamepadButtons.dpad_down);
+        this.#clearButtonSource(GamepadButtons.dpad_left);
+
+        return this;
+    }
+
+    /**
+     *
+     * @param {number} standardButton
+     */
+    #clearButtonSource(standardButton) {
+        this.#buttons[standardButton] = GAMEPAD_LAYOUT_ABSENT;
+        this.#buttonAxes[standardButton] = GAMEPAD_LAYOUT_ABSENT;
+    }
+
+    /**
+     *
+     * @param {number} index standard button index
+     * @param {Gamepad} source
+     * @returns {boolean} whether the hat presses this button
+     */
+    #isPressedByHat(index, source) {
+        if (this.#hatAxis === GAMEPAD_LAYOUT_ABSENT) {
+            return false;
+        }
+
+        const direction = DPAD_DIRECTION_BY_BUTTON[index];
+
+        if (direction === GamepadHatDirection.none) {
+            return false;
+        }
+
+        return (gamepad_read_hat_axis(source.axes[this.#hatAxis]) & direction) !== 0;
+    }
+
+    /**
+     *
+     * @param {Gamepad} source
+     * @returns {number}
+     */
+    presentedButtonCount(source) {
+        return GAMEPAD_STANDARD_BUTTON_COUNT;
+    }
+
+    /**
+     *
+     * @param {Gamepad} source
+     * @returns {number}
+     */
+    presentedAxisCount(source) {
+        return GAMEPAD_STANDARD_AXIS_COUNT;
+    }
+
+    /**
+     *
+     * @param {number} index standard button index
+     * @param {Gamepad} source
+     * @returns {number}
+     */
+    readButtonValue(index, source) {
+        const button = this.#buttons[index];
+
+        if (button !== GAMEPAD_LAYOUT_ABSENT) {
+            return source.buttons[button].value;
+        }
+
+        const axis = this.#buttonAxes[index];
+
+        if (axis !== GAMEPAD_LAYOUT_ABSENT) {
+            return axis_to_button_value(source.axes[axis]);
+        }
+
+        return this.#isPressedByHat(index, source) ? 1 : 0;
+    }
+
+    /**
+     *
+     * @param {number} index standard button index
+     * @param {Gamepad} source
+     * @returns {boolean}
+     */
+    isButtonPressed(index, source) {
+        const button = this.#buttons[index];
+
+        if (button !== GAMEPAD_LAYOUT_ABSENT) {
+            return source.buttons[button].pressed;
+        }
+
+        const axis = this.#buttonAxes[index];
+
+        if (axis !== GAMEPAD_LAYOUT_ABSENT) {
+            return axis_to_button_value(source.axes[axis]) > AXIS_BUTTON_PRESSED_THRESHOLD;
+        }
+
+        return this.#isPressedByHat(index, source);
+    }
+
+    /**
+     *
+     * @param {number} index standard axis index
+     * @param {Gamepad} source
+     * @returns {number}
+     */
+    readAxis(index, source) {
+        const axis = this.#axes[index];
+
+        if (axis === GAMEPAD_LAYOUT_ABSENT) {
+            return 0;
+        }
+
+        return source.axes[axis];
+    }
+
+    /**
+     *
+     * @param {number} index standard axis index
+     * @returns {number}
+     */
+    axisSource(index) {
+        return this.#axes[index];
+    }
+
+    /**
+     *
+     * @param {number} index standard button index
+     * @returns {number}
+     */
+    buttonSource(index) {
+        return this.#buttons[index];
+    }
+
+    /**
+     *
+     * @param {number} index standard button index
+     * @returns {number}
+     */
+    buttonAxisSource(index) {
+        return this.#buttonAxes[index];
+    }
+
+    /**
+     *
+     * @returns {number}
+     */
+    get hatAxis() {
+        return this.#hatAxis;
+    }
+
+    /**
+     *
+     * @param {Gamepad} source
+     * @returns {boolean}
+     */
+    describes(source) {
+        const axisCount = source.axes.length;
+        const buttonCount = source.buttons.length;
+
+        // an unsourced input is GAMEPAD_LAYOUT_ABSENT, which is below every count and so never trips these
+
+        if (this.#hatAxis >= axisCount) {
+            return false;
+        }
+
+        for (let i = 0; i < GAMEPAD_STANDARD_AXIS_COUNT; i++) {
+            if (this.#axes[i] >= axisCount) {
+                return false;
+            }
+        }
+
+        for (let i = 0; i < GAMEPAD_STANDARD_BUTTON_COUNT; i++) {
+            if (this.#buttons[i] >= buttonCount) {
+                return false;
+            }
+
+            if (this.#buttonAxes[i] >= axisCount) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+}

package/src/engine/input/devices/gamepad/GamepadHandle.d.ts

@@ -3,6 +3,10 @@
  * Native {@link Gamepad} objects are immutable snapshots in most browsers, this class provides a stable, observable
  * representation that is refreshed from those snapshots via {@link GamepadHandle#update}.
  *
+ * State is always presented in the standard mapping, so {@link GamepadButtons} and {@link GamepadAxes} are
+ * valid indices whatever the hardware is. A pad the browser declined to map reports its inputs in its own
+ * order, and {@link layout} is the translation back to the standard one - see {@link GamepadLayout}.
+ *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
  */
@@ -23,6 +27,18 @@ export class GamepadHandle {
      * @type {string}
      */
     mapping: string;
+    /**
+     * How this handle reaches the device's inputs.
+     *
+     * Resolved from the hardware whenever {@link id} changes, and only ever anything other than a passthrough
+     * for a device the browser declined to map that is also known to {@link gamepad_layout_for_device}. Read
+     * it to find out how a pad is being interpreted, for a settings screen or when a pad misbehaves.
+     *
+     * Do not modify directly
+     *
+     * @type {GamepadLayout}
+     */
+    layout: GamepadLayout;
     /**
      * Whether the gamepad is currently connected
      * Do not modify directly
@@ -79,8 +95,11 @@ export class GamepadHandle {
      */
     readonly buttonValues: number[];
     /**
-     * Axis values in the range [-1,1], exactly as reported by the hardware.
-     * For the standard mapping, see {@link GamepadAxes} for valid indices.
+     * Axis values in the range [-1,1], indexed as {@link GamepadAxes}.
+     *
+     * Values are exactly as the hardware reported them, placed in the slot the standard mapping puts them in.
+     * On a pad the browser mapped itself those are the same thing; on one it did not, {@link layout} says
+     * which device axis each slot came from, and slots the device has no axis for read 0.
      *
      * Uncorrected: a resting stick rarely reads 0 here. Read {@link stickLeft}/{@link stickRight} for values
      * with the learned rest position removed.

package/src/engine/input/devices/gamepad/GamepadHandle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GamepadHandle.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/input/devices/gamepad/GamepadHandle.js"],"names":[],"mappings":"AAMA;;;;;;;GAOG;AACH;IAEI;;;OAGG;IACH,OAFU,MAAM,CAEL;IAEX;;;OAGG;IACH,IAFU,MAAM,CAER;IAER;;;;OAIG;IACH,SAFU,MAAM,CAEH;IAEb;;;;OAIG;IACH,WAFU,OAAO,CAEC;IAElB;;;;;OAKG;IACH,iBAFU,MAAM,CAEK;IAErB;;OAEG;IACH;QACI;;;WAGG;;QAEH;;;WAGG;;QAEH;;;WAGG;;MAEL;IAEF;;;;;;;;;;;;;OAaG;IACH,kBALU,iBAAiB,EAAE,CAKhB;IAEb;;;;;OAKG;IACH,uBAFU,MAAM,EAAE,CAEA;IAElB;;;;;;;;;OASG;IACH,eAFU,MAAM,EAAE,CAER;IAEV;;;;OAIG;IACH,oBAFU,YAAY,CAE2D;IAEjF;;;;OAIG;IACH,qBAFU,YAAY,CAE8D;IAapF;;;;;OAKG;IACH,iBAHW,MAAM,GACJ,iBAAiB,CAa7B;IAED;;;;OAIG;IACH,eAFW,OAAO,QAqDjB;IAED;;;OAGG;IACH,cA+BC;IAED;;;;;;OAMG;IACH,qBAFa,IAAI,CAKhB;CACJ;kCAhQiC,yBAAyB;6BAE9B,mBAAmB"}
+{"version":3,"file":"GamepadHandle.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/input/devices/gamepad/GamepadHandle.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;GAWG;AACH;IAEI;;;OAGG;IACH,OAFU,MAAM,CAEL;IAEX;;;OAGG;IACH,IAFU,MAAM,CAER;IAER;;;;OAIG;IACH,SAFU,MAAM,CAEH;IAEb;;;;;;;;;;OAUG;IACH,sBAAiC;IAEjC;;;;OAIG;IACH,WAFU,OAAO,CAEC;IAElB;;;;;OAKG;IACH,iBAFU,MAAM,CAEK;IAErB;;OAEG;IACH;QACI;;;WAGG;;QAEH;;;WAGG;;QAEH;;;WAGG;;MAEL;IAEF;;;;;;;;;;;;;OAaG;IACH,kBALU,iBAAiB,EAAE,CAKhB;IAEb;;;;;OAKG;IACH,uBAFU,MAAM,EAAE,CAEA;IAElB;;;;;;;;;;;;OAYG;IACH,eAFU,MAAM,EAAE,CAER;IAEV;;;;OAIG;IACH,oBAFU,YAAY,CAE2D;IAEjF;;;;OAIG;IACH,qBAFU,YAAY,CAE8D;IAapF;;;;;OAKG;IACH,iBAHW,MAAM,GACJ,iBAAiB,CAa7B;IAED;;;;OAIG;IACH,eAFW,OAAO,QA2DjB;IAED;;;OAGG;IACH,cA+BC;IAED;;;;;;OAMG;IACH,qBAFa,IAAI,CAKhB;CACJ;kCA5RiC,yBAAyB;6BAI9B,mBAAmB"}

package/src/engine/input/devices/gamepad/GamepadHandle.js

@@ -1,6 +1,8 @@
 import Signal from "../../../../core/events/signal/Signal.js";
 import { InputDeviceSwitch } from "../InputDeviceSwitch.js";
 import { GamepadAxes } from "./GamepadAxes.js";
+import { gamepad_layout_for_device } from "./gamepad_layout_database.js";
+import { GAMEPAD_STANDARD_LAYOUT } from "./GamepadLayout.js";
 import { GamepadStick } from "./GamepadStick.js";
 import { GAMEPAD_STANDARD_AXIS_COUNT, GAMEPAD_STANDARD_BUTTON_COUNT } from "./GamepadStandardMapping.js";
 
@@ -9,6 +11,10 @@ import { GAMEPAD_STANDARD_AXIS_COUNT, GAMEPAD_STANDARD_BUTTON_COUNT } from "./Ga
  * Native {@link Gamepad} objects are immutable snapshots in most browsers, this class provides a stable, observable
  * representation that is refreshed from those snapshots via {@link GamepadHandle#update}.
  *
+ * State is always presented in the standard mapping, so {@link GamepadButtons} and {@link GamepadAxes} are
+ * valid indices whatever the hardware is. A pad the browser declined to map reports its inputs in its own
+ * order, and {@link layout} is the translation back to the standard one - see {@link GamepadLayout}.
+ *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
  */
@@ -33,6 +39,19 @@ export class GamepadHandle {
      */
     mapping = "";
 
+    /**
+     * How this handle reaches the device's inputs.
+     *
+     * Resolved from the hardware whenever {@link id} changes, and only ever anything other than a passthrough
+     * for a device the browser declined to map that is also known to {@link gamepad_layout_for_device}. Read
+     * it to find out how a pad is being interpreted, for a settings screen or when a pad misbehaves.
+     *
+     * Do not modify directly
+     *
+     * @type {GamepadLayout}
+     */
+    layout = GAMEPAD_STANDARD_LAYOUT;
+
     /**
      * Whether the gamepad is currently connected
      * Do not modify directly
@@ -94,8 +113,11 @@ export class GamepadHandle {
     buttonValues = [];
 
     /**
-     * Axis values in the range [-1,1], exactly as reported by the hardware.
-     * For the standard mapping, see {@link GamepadAxes} for valid indices.
+     * Axis values in the range [-1,1], indexed as {@link GamepadAxes}.
+     *
+     * Values are exactly as the hardware reported them, placed in the slot the standard mapping puts them in.
+     * On a pad the browser mapped itself those are the same thing; on one it did not, {@link layout} says
+     * which device axis each slot came from, and slots the device has no axis for read 0.
      *
      * Uncorrected: a resting stick rarely reads 0 here. Read {@link stickLeft}/{@link stickRight} for values
      * with the learned rest position removed.
@@ -156,22 +178,29 @@ export class GamepadHandle {
      */
     update(source) {
 
+        /*
+        Which device an id names cannot change without the id changing, so the layout is resolved on that edge
+        rather than on every poll
+         */
+        if (source.id !== this.id) {
+            this.layout = gamepad_layout_for_device(source);
+        }
+
         this.index = source.index;
         this.id = source.id;
         this.mapping = source.mapping;
 
+        const layout = this.layout;
+
         // buttons
-        const sourceButtons = source.buttons;
-        const buttonCount = sourceButtons.length;
+        const buttonCount = layout.presentedButtonCount(source);
 
         for (let i = 0; i < buttonCount; i++) {
-            const sourceButton = sourceButtons[i];
-
             const button = this.getButton(i);
 
-            this.buttonValues[i] = sourceButton.value;
+            this.buttonValues[i] = layout.readButtonValue(i, source);
 
-            if (sourceButton.pressed) {
+            if (layout.isButtonPressed(i, source)) {
 
                 if (button.is_up) {
                     button.press();
@@ -187,11 +216,10 @@ export class GamepadHandle {
         }
 
         // axes
-        const sourceAxes = source.axes;
-        const axisCount = sourceAxes.length;
+        const axisCount = layout.presentedAxisCount(source);
 
         for (let i = 0; i < axisCount; i++) {
-            const value = sourceAxes[i];
+            const value = layout.readAxis(i, source);
 
             // hardware beyond the standard mapping has not been seen before and reads as neutral
             const oldValue = this.axes[i] !== undefined ? this.axes[i] : 0;

package/src/engine/input/devices/gamepad/GamepadLayout.d.ts

@@ -0,0 +1,128 @@
+/**
+ * Where each input of the standard mapping is found on a specific piece of hardware.
+ *
+ * The Gamepad API only promises the standard layout when {@link Gamepad#mapping} is `"standard"`. When it is
+ * anything else the browser is telling us it did not recognise the device, and the indices in `axes` and
+ * `buttons` mean whatever the device's HID report happens to say - a stick where the standard mapping expects a
+ * trigger, a trigger resting at -1 where it expects a released button. Reading such a device as though it were
+ * standard is not a small inaccuracy: a trigger axis read as an axis of the right stick pins that stick to full
+ * deflection forever.
+ *
+ * A layout is the translation, and it sits in the device layer for the same reason
+ * {@link GamepadStickCalibration} does - it describes what the hardware is, not what the game wants. It is the
+ * work the browser would have done had it recognised the pad.
+ *
+ * This class is that translation for a pad the browser already put in the standard layout: identity, a
+ * bit-exact passthrough. Opting out of translation is therefore not a mode, it is this layout - the same shape
+ * as an identity calibration. {@link GamepadDeviceLayout} is the translating one.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class GamepadLayout {
+    /**
+     * Human-readable name, for a settings screen that wants to say how a pad is being read
+     * @readonly
+     * @type {string}
+     */
+    readonly name: string;
+    /**
+     * How many standard buttons this layout presents for the given device.
+     *
+     * Passthrough presents every button the device reports, including any beyond the standard mapping - a pad
+     * the browser mapped to standard is free to report more, and dropping them would lose hardware that works.
+     *
+     * @param {Gamepad} source native gamepad snapshot
+     * @returns {number}
+     */
+    presentedButtonCount(source: Gamepad): number;
+    /**
+     *
+     * @param {Gamepad} source native gamepad snapshot
+     * @returns {number}
+     */
+    presentedAxisCount(source: Gamepad): number;
+    /**
+     * Analog travel of a standard button, in [0,1]
+     *
+     * @param {number} index standard button index, see {@link GamepadButtons}
+     * @param {Gamepad} source native gamepad snapshot
+     * @returns {number}
+     */
+    readButtonValue(index: number, source: Gamepad): number;
+    /**
+     *
+     * @param {number} index standard button index, see {@link GamepadButtons}
+     * @param {Gamepad} source native gamepad snapshot
+     * @returns {boolean}
+     */
+    isButtonPressed(index: number, source: Gamepad): boolean;
+    /**
+     * Value of a standard axis, in [-1,1]
+     *
+     * @param {number} index standard axis index, see {@link GamepadAxes}
+     * @param {Gamepad} source native gamepad snapshot
+     * @returns {number}
+     */
+    readAxis(index: number, source: Gamepad): number;
+    /**
+     * Index of the device axis read as a standard axis, or {@link GAMEPAD_LAYOUT_ABSENT}.
+     * For diagnostics and layout UI - reading values goes through {@link readAxis}.
+     *
+     * @param {number} index standard axis index, see {@link GamepadAxes}
+     * @returns {number}
+     */
+    axisSource(index: number): number;
+    /**
+     * Index of the device button read as a standard button, or {@link GAMEPAD_LAYOUT_ABSENT}
+     *
+     * @param {number} index standard button index, see {@link GamepadButtons}
+     * @returns {number}
+     */
+    buttonSource(index: number): number;
+    /**
+     * Index of the device axis whose travel drives a standard button, or {@link GAMEPAD_LAYOUT_ABSENT}.
+     * This is how a non-standard pad reports its triggers.
+     *
+     * @param {number} index standard button index, see {@link GamepadButtons}
+     * @returns {number}
+     */
+    buttonAxisSource(index: number): number;
+    /**
+     * Index of the device axis carrying a D-pad hat, or {@link GAMEPAD_LAYOUT_ABSENT}
+     * @returns {number}
+     */
+    get hatAxis(): number;
+    /**
+     * Whether this layout can be applied to the given device.
+     *
+     * Checked once when a pad connects rather than on every read. The same vendor and product can ship report
+     * descriptors that differ between firmware revisions - the browsers carry several layouts for the Xbox
+     * wireless pad alone for exactly this reason - and a layout that reaches past the end of what a device
+     * reports would otherwise write undefined into an axis and poison a stick with NaN.
+     *
+     * @param {Gamepad} source native gamepad snapshot
+     * @returns {boolean}
+     */
+    describes(source: Gamepad): boolean;
+}
+/**
+ * No device input drives this standard input, so it reads as neutral and never fires.
+ *
+ * That is the same answer the standard mapping already gives for hardware that lacks a button, see
+ * {@link GamepadHandle#buttons} - absence is uniform rather than expressive.
+ *
+ * @readonly
+ * @type {number}
+ */
+export const GAMEPAD_LAYOUT_ABSENT: number;
+/**
+ * The layout of a pad the browser has already put in the standard mapping: a bit-exact passthrough.
+ *
+ * Shared by every handle reading such a pad, and carries no state, so it must not be modified.
+ *
+ * @readonly
+ * @type {GamepadLayout}
+ */
+export const GAMEPAD_STANDARD_LAYOUT: GamepadLayout;
+//# sourceMappingURL=GamepadLayout.d.ts.map

package/src/engine/input/devices/gamepad/GamepadLayout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GamepadLayout.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/input/devices/gamepad/GamepadLayout.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IAEI;;;;OAIG;IACH,eAFU,MAAM,CAEE;IAElB;;;;;;;;OAQG;IACH,6BAHW,OAAO,GACL,MAAM,CAIlB;IAED;;;;OAIG;IACH,2BAHW,OAAO,GACL,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,uBAJW,MAAM,UACN,OAAO,GACL,MAAM,CAIlB;IAED;;;;;OAKG;IACH,uBAJW,MAAM,UACN,OAAO,GACL,OAAO,CAInB;IAED;;;;;;OAMG;IACH,gBAJW,MAAM,UACN,OAAO,GACL,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,kBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;OAKG;IACH,oBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,wBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,sBAEC;IAED;;;;;;;;;;OAUG;IACH,kBAHW,OAAO,GACL,OAAO,CAInB;CACJ;AAED;;;;;;;;GAQG;AACH,oCAFU,MAAM,CAEwB;AAExC;;;;;;;GAOG;AACH,sCAFU,aAAa,CAEoC"}