@woosh/meep-engine 2.169.1 → 2.169.2

package/src/engine/graphics/texture/channel_count_to_format_prefix.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Maps a channel count onto the leading component letters of a WebGL2 sized internal format
+ * (`R`, `RG`, `RGB`, `RGBA`) - the part that comes before the bit-depth/type suffix.
+ *
+ * The suffix legitimately differs between the integer/float spelling
+ * ({@link computeThreeTextureInternalFormatFromDataType}) and the normalized spelling
+ * ({@link normalized_internal_format}); this prefix does not, and used to be an 18-line switch
+ * duplicated byte-for-byte in both, error message included.
+ *
+ * @param {number} channel_count
+ * @returns {string}
+ */
+export function channel_count_to_format_prefix(channel_count: number): string;
+//# sourceMappingURL=channel_count_to_format_prefix.d.ts.map

package/src/engine/graphics/texture/channel_count_to_format_prefix.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"channel_count_to_format_prefix.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/texture/channel_count_to_format_prefix.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,8DAHW,MAAM,GACJ,MAAM,CAelB"}

package/src/engine/graphics/texture/channel_count_to_format_prefix.js

@@ -0,0 +1,26 @@
+/**
+ * Maps a channel count onto the leading component letters of a WebGL2 sized internal format
+ * (`R`, `RG`, `RGB`, `RGBA`) - the part that comes before the bit-depth/type suffix.
+ *
+ * The suffix legitimately differs between the integer/float spelling
+ * ({@link computeThreeTextureInternalFormatFromDataType}) and the normalized spelling
+ * ({@link normalized_internal_format}); this prefix does not, and used to be an 18-line switch
+ * duplicated byte-for-byte in both, error message included.
+ *
+ * @param {number} channel_count
+ * @returns {string}
+ */
+export function channel_count_to_format_prefix(channel_count) {
+    switch (channel_count) {
+        case 1:
+            return 'R';
+        case 2:
+            return 'RG';
+        case 3:
+            return 'RGB';
+        case 4:
+            return 'RGBA';
+        default:
+            throw new Error(`Unsupported channel count '${channel_count}'`);
+    }
+}

package/src/engine/graphics/texture/computeThreeTextureInternalFormatFromDataType.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"computeThreeTextureInternalFormatFromDataType.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/texture/computeThreeTextureInternalFormatFromDataType.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,kEAJW,cAAc,iBACd,MAAM,GACJ,MAAM,GAAC,MAAM,cAAc,CAwDvC;+BA9D8B,6CAA6C"}
+{"version":3,"file":"computeThreeTextureInternalFormatFromDataType.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/texture/computeThreeTextureInternalFormatFromDataType.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,kEAJW,cAAc,iBACd,MAAM,GACJ,MAAM,GAAC,MAAM,cAAc,CAqCvC;+BA5C8B,6CAA6C"}

package/src/engine/graphics/texture/computeThreeTextureInternalFormatFromDataType.js

@@ -1,4 +1,5 @@
 import { BinaryDataType } from "../../../core/binary/type/BinaryDataType.js";
+import { channel_count_to_format_prefix } from "./channel_count_to_format_prefix.js";
 
 /**
  *
@@ -40,24 +41,5 @@ export function computeThreeTextureInternalFormatFromDataType(dt, channel_count)
             throw new Error(`Unsupported data type '${dt}'`);
     }
 
-    let prefix = '';
-
-    switch (channel_count) {
-        case 1:
-            prefix = 'R';
-            break;
-        case 2:
-            prefix = 'RG';
-            break;
-        case 3:
-            prefix = 'RGB';
-            break;
-        case 4:
-            prefix = 'RGBA';
-            break;
-        default:
-            throw new Error(`Unsupported channel count '${channel_count}'`);
-    }
-
-    return prefix + suffix;
+    return channel_count_to_format_prefix(channel_count) + suffix;
 }

package/src/engine/graphics/texture/normalized_internal_format.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"normalized_internal_format.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/texture/normalized_internal_format.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,+CAHW,cAAc,iBACd,MAAM,GAFJ,MAAM,CA0ClB;+BA/C8B,6CAA6C"}
+{"version":3,"file":"normalized_internal_format.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/texture/normalized_internal_format.js"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,+CAHW,cAAc,iBACd,MAAM,GAFJ,MAAM,CAuBlB;+BA7B8B,6CAA6C"}

package/src/engine/graphics/texture/normalized_internal_format.js

@@ -1,5 +1,6 @@
 import { BinaryDataType } from "../../../core/binary/type/BinaryDataType.js";
 import { assert } from "../../../core/assert.js";
+import { channel_count_to_format_prefix } from "./channel_count_to_format_prefix.js";
 
 /**
  *
@@ -25,24 +26,5 @@ export function normalized_internal_format(dt, channel_count) {
             throw new Error(`Unsupported data type '${dt}'`);
     }
 
-    let prefix = '';
-
-    switch (channel_count) {
-        case 1:
-            prefix = 'R';
-            break;
-        case 2:
-            prefix = 'RG';
-            break;
-        case 3:
-            prefix = 'RGB';
-            break;
-        case 4:
-            prefix = 'RGBA';
-            break;
-        default:
-            throw new Error(`Unsupported channel count '${channel_count}'`);
-    }
-
-    return prefix + suffix;
+    return channel_count_to_format_prefix(channel_count) + suffix;
 }

package/src/engine/graphics/texture/sampler/convertTexture2Sampler2D.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"convertTexture2Sampler2D.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/sampler/convertTexture2Sampler2D.js"],"names":[],"mappings":"AAwEA;;;;;;;GAOG;AACH,mEALW,MAAM,WACN,MAAM,UACN,OAAO,GACN,SAAS,CAyFpB;0BA9JyB,gBAAgB"}
+{"version":3,"file":"convertTexture2Sampler2D.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/sampler/convertTexture2Sampler2D.js"],"names":[],"mappings":"AA8EA;;;;;;;GAOG;AACH,mEALW,MAAM,WACN,MAAM,UACN,OAAO,GACN,SAAS,CAyFpB;0BApKyB,gBAAgB"}

package/src/engine/graphics/texture/sampler/convertTexture2Sampler2D.js

@@ -1,8 +1,8 @@
 import { assert } from "../../../../core/assert.js";
 import ImageFilter from "../../filter/ImageFilter.js";
 import { sampler2d_flipY_in_place } from "../../filter/sampler2d_flipY_in_place.js";
-import CopyShader from "../../postprocess/threejs/shaders/CopyShader.js";
 import { WebGLRendererPool } from "../../render/RendererPool.js";
+import CopyShader from "../../shaders/CopyShader.js";
 
 import { canvasDataToSampler } from "../canvasDataToSampler.js";
 import { formatToChannelCount } from "../formatToChannelCount.js";
@@ -14,6 +14,12 @@ import { sampler2d_ensure_uint8_RGBA } from "./sampler2d_ensure_uint8_RGBA.js";
 const DEFAULT_TEXTURE_WIDTH = 512;
 const DEFAULT_TEXTURE_HEIGHT = 512;
 
+/**
+ * Source of the full-screen copy pass used to read a GPU texture back into a sampler
+ * @type {{uniforms:Object, vertexShader:string, fragmentShader:string}}
+ */
+const COPY_SHADER = CopyShader();
+
 /**
  *
  * @param {THREE.DataTexture} texture
@@ -144,8 +150,8 @@ export function convertTexture2Sampler2D(
             ctx.getExtension("WEBGL_compressed_texture_s3tc");
 
             return ImageFilter(renderer, _width, _height, {
-                vertexShader: CopyShader.vertexShader,
-                fragmentShader: CopyShader.fragmentShader,
+                vertexShader: COPY_SHADER.vertexShader,
+                fragmentShader: COPY_SHADER.fragmentShader,
                 uniforms: {
                     tDiffuse: {
                         value: texture,

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

@@ -0,0 +1,54 @@
+/**
+ * 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 {
+    /**
+     *
+     * @param {string} name
+     */
+    constructor(name: string);
+    name: string;
+    /**
+     *
+     * @param {number} standardAxis see {@link GamepadAxes}
+     * @param {number} deviceAxis index into the device's axis list
+     * @returns {GamepadDeviceLayout} this, for chaining
+     */
+    readsAxisFrom(standardAxis: number, deviceAxis: number): GamepadDeviceLayout;
+    /**
+     *
+     * @param {number} standardButton see {@link GamepadButtons}
+     * @param {number} deviceButton index into the device's button list
+     * @returns {GamepadDeviceLayout} this, for chaining
+     */
+    readsButtonFrom(standardButton: number, deviceButton: number): GamepadDeviceLayout;
+    /**
+     * 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: number, deviceAxis: number): GamepadDeviceLayout;
+    /**
+     * 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: number): GamepadDeviceLayout;
+    #private;
+}
+import { GamepadLayout } from "./GamepadLayout.js";
+//# sourceMappingURL=GamepadDeviceLayout.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"GamepadDeviceLayout.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/input/devices/gamepad/GamepadDeviceLayout.js"],"names":[],"mappings":"AA0CA;;;;;;;;;;;;GAYG;AACH;IAyBI;;;OAGG;IACH,kBAFW,MAAM,EAMhB;IADG,aAAgB;IAGpB;;;;;OAKG;IACH,4BAJW,MAAM,cACN,MAAM,GACJ,mBAAmB,CAM/B;IAED;;;;;OAKG;IACH,gCAJW,MAAM,gBACN,MAAM,GACJ,mBAAmB,CAO/B;IAED;;;;;;OAMG;IACH,oCAJW,MAAM,cACN,MAAM,GACJ,mBAAmB,CAO/B;IAED;;;;;;OAMG;IACH,iCAHW,MAAM,GACJ,mBAAmB,CAW/B;;CAiLJ;8BAjUoD,oBAAoB"}

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"}