@woosh/meep-engine 2.165.5 → 2.165.7

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

@@ -1,6 +1,8 @@
 import Signal from "../../../../core/events/signal/Signal.js";
-import Vector2 from "../../../../core/geom/Vector2.js";
 import { InputDeviceSwitch } from "../InputDeviceSwitch.js";
+import { GamepadAxes } from "./GamepadAxes.js";
+import { GamepadStick } from "./GamepadStick.js";
+import { GAMEPAD_STANDARD_AXIS_COUNT, GAMEPAD_STANDARD_BUTTON_COUNT } from "./GamepadStandardMapping.js";
 
 /**
  * State of a single physical gamepad.
@@ -38,6 +40,14 @@ export class GamepadHandle {
      */
     connected = false;
 
+    /**
+     * Order in which this pad was connected, used to pick a successor when the active pad is lost.
+     * Lower is older. Meaningless while {@link connected} is false.
+     * Do not modify directly
+     * @type {number}
+     */
+    connectionIndex = -1;
+
     /**
      * @readonly
      */
@@ -62,13 +72,16 @@ export class GamepadHandle {
     /**
      * Individual button switches, indexed by button index.
      * For the standard mapping, see {@link GamepadButtons} for valid indices.
-     * Populated lazily as buttons are observed; use {@link GamepadHandle#getButton} for safe access.
+     *
+     * Every index of the standard mapping is materialized up front, so reads need no guard - a button the
+     * hardware does not have simply never goes down. Hardware exposing more than the standard button count
+     * grows the array during {@link GamepadHandle#update}.
      *
      * @readonly
      * @type {InputDeviceSwitch[]}
      *
      * @example
-     *   const is_jumping = pad.buttons[GamepadButtons.a]?.is_down;
+     *   const is_jumping = pad.buttons[GamepadButtons.a].is_down;
      */
     buttons = [];
 
@@ -81,26 +94,41 @@ export class GamepadHandle {
     buttonValues = [];
 
     /**
-     * Axis values in the range [-1,1], after dead-zone filtering.
+     * Axis values in the range [-1,1], exactly as reported by the hardware.
      * For the standard mapping, see {@link GamepadAxes} for valid indices.
+     *
+     * Uncorrected: a resting stick rarely reads 0 here. Read {@link stickLeft}/{@link stickRight} for values
+     * with the learned rest position removed.
+     *
      * @readonly
      * @type {number[]}
      */
     axes = [];
 
     /**
-     * Convenience accessor for axes 0 and 1 of the standard mapping
+     * Left stick of the standard mapping, axes 0 and 1
      * @readonly
-     * @type {Vector2}
+     * @type {GamepadStick}
      */
-    stickLeft = new Vector2();
+    stickLeft = new GamepadStick(GamepadAxes.left_stick_x, GamepadAxes.left_stick_y);
 
     /**
-     * Convenience accessor for axes 2 and 3 of the standard mapping
+     * Right stick of the standard mapping, axes 2 and 3
      * @readonly
-     * @type {Vector2}
+     * @type {GamepadStick}
      */
-    stickRight = new Vector2();
+    stickRight = new GamepadStick(GamepadAxes.right_stick_x, GamepadAxes.right_stick_y);
+
+    constructor() {
+        for (let i = 0; i < GAMEPAD_STANDARD_BUTTON_COUNT; i++) {
+            this.buttons[i] = new InputDeviceSwitch();
+            this.buttonValues[i] = 0;
+        }
+
+        for (let i = 0; i < GAMEPAD_STANDARD_AXIS_COUNT; i++) {
+            this.axes[i] = 0;
+        }
+    }
 
     /**
      * Returns switch for a given button index, creating it if it doesn't exist yet
@@ -125,9 +153,8 @@ export class GamepadHandle {
      * Refresh state from a native {@link Gamepad} snapshot
      *
      * @param {Gamepad} source native gamepad object
-     * @param {number} [deadZone] axis values with magnitude below this are clamped to 0
      */
-    update(source, deadZone = 0) {
+    update(source) {
 
         this.index = source.index;
         this.id = source.id;
@@ -164,33 +191,20 @@ export class GamepadHandle {
         const axisCount = sourceAxes.length;
 
         for (let i = 0; i < axisCount; i++) {
-            let value = sourceAxes[i];
-
-            if (Math.abs(value) < deadZone) {
-                // inside dead-zone, treat as neutral
-                value = 0;
-            }
+            const value = sourceAxes[i];
 
+            // hardware beyond the standard mapping has not been seen before and reads as neutral
             const oldValue = this.axes[i] !== undefined ? this.axes[i] : 0;
 
-            if (value !== oldValue) {
-                this.axes[i] = value;
+            this.axes[i] = value;
 
+            if (value !== oldValue) {
                 this.on.axis.send3(i, value, oldValue);
-            } else {
-                this.axes[i] = value;
             }
         }
 
-        this.stickLeft.set(
-            this.axes[0] !== undefined ? this.axes[0] : 0,
-            this.axes[1] !== undefined ? this.axes[1] : 0
-        );
-
-        this.stickRight.set(
-            this.axes[2] !== undefined ? this.axes[2] : 0,
-            this.axes[3] !== undefined ? this.axes[3] : 0
-        );
+        this.stickLeft.update(this.axes);
+        this.stickRight.update(this.axes);
     }
 
     /**
@@ -226,7 +240,19 @@ export class GamepadHandle {
             }
         }
 
-        this.stickLeft.set(0, 0);
-        this.stickRight.set(0, 0);
-     }
+        this.stickLeft.reset();
+        this.stickRight.reset();
+    }
+
+    /**
+     * Discard what has been learned about the sticks.
+     * Used when this handle starts representing different hardware, either because a pad was plugged into a
+     * slot another pad used to occupy, or because {@link GamepadDevice#main} moved to a different pad.
+     *
+     * @returns {void}
+     */
+    forgetCalibration() {
+        this.stickLeft.forgetCalibration();
+        this.stickRight.forgetCalibration();
+    }
 }

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

@@ -0,0 +1,20 @@
+/**
+ * Number of buttons defined by the "standard" gamepad mapping
+ * see https://w3c.github.io/gamepad/#remapping
+ *
+ * {@link GamepadHandle} materializes this many button switches up front, so that every index in
+ * {@link GamepadButtons} is safe to read without a guard, before the hardware has ever been polled.
+ *
+ * @readonly
+ * @type {number}
+ */
+export const GAMEPAD_STANDARD_BUTTON_COUNT: number;
+/**
+ * Number of axes defined by the "standard" gamepad mapping
+ * see https://w3c.github.io/gamepad/#remapping
+ *
+ * @readonly
+ * @type {number}
+ */
+export const GAMEPAD_STANDARD_AXIS_COUNT: number;
+//# sourceMappingURL=GamepadStandardMapping.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"GamepadStandardMapping.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/input/devices/gamepad/GamepadStandardMapping.js"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,4CAFU,MAAM,CAEgC;AAEhD;;;;;;GAMG;AACH,0CAFU,MAAM,CAE6B"}

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

@@ -0,0 +1,20 @@
+/**
+ * Number of buttons defined by the "standard" gamepad mapping
+ * see https://w3c.github.io/gamepad/#remapping
+ *
+ * {@link GamepadHandle} materializes this many button switches up front, so that every index in
+ * {@link GamepadButtons} is safe to read without a guard, before the hardware has ever been polled.
+ *
+ * @readonly
+ * @type {number}
+ */
+export const GAMEPAD_STANDARD_BUTTON_COUNT = 17;
+
+/**
+ * Number of axes defined by the "standard" gamepad mapping
+ * see https://w3c.github.io/gamepad/#remapping
+ *
+ * @readonly
+ * @type {number}
+ */
+export const GAMEPAD_STANDARD_AXIS_COUNT = 4;

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

@@ -0,0 +1,93 @@
+/**
+ * An analog stick: a pair of axes, plus what we have learned about the hardware behind them.
+ *
+ * Values are in the hardware frame, +x is right and +y is down, see {@link GamepadAxes}. Converting that into a
+ * game frame depends on the camera and belongs to a controller, not here - the same stick means different world
+ * directions in a top-down game and a third-person one.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class GamepadStick {
+    /**
+     *
+     * @param {number} axisX index into {@link GamepadHandle#axes}
+     * @param {number} axisY index into {@link GamepadHandle#axes}
+     */
+    constructor(axisX: number, axisY: number);
+    /**
+     * Index into {@link GamepadHandle#axes} read as the horizontal component
+     * @type {number}
+     */
+    axisX: number;
+    /**
+     * Index into {@link GamepadHandle#axes} read as the vertical component
+     * @type {number}
+     */
+    axisY: number;
+    /**
+     * Hardware value, exactly as reported.
+     * A resting stick rarely reads (0,0) here, that is what {@link calibration} is for.
+     *
+     * @readonly
+     * @type {Vector2}
+     */
+    readonly raw: Vector2;
+    /**
+     * Calibrated value: {@link raw} with the learned rest position removed, reading exactly neutral while the
+     * stick is within its learned noise radius. This is what gameplay should read.
+     *
+     * Still raw in every other respect - no gameplay dead zone, no response curve, no magnitude clamp. Feed it
+     * to {@link apply_radial_dead_zone} to shape it.
+     *
+     * @readonly
+     * @type {Vector2}
+     */
+    readonly value: Vector2;
+    /**
+     * @readonly
+     * @type {GamepadStickCalibration}
+     */
+    readonly calibration: GamepadStickCalibration;
+    /**
+     * @readonly
+     */
+    readonly on: {
+        /**
+         * Fires when {@link value} changes. A calibrated stick at rest is silent.
+         * @type {Signal<>}
+         */
+        changed: any;
+    };
+    /**
+     * Refresh from raw axis values, feeding the calibrator on the way through.
+     *
+     * @param {number[]} axes raw axis values, indexed as {@link GamepadAxes}
+     * @returns {void}
+     */
+    update(axes: number[]): void;
+    /**
+     * Return to neutral. Used when the pad disconnects, so a deflected stick does not stay deflected.
+     * The calibration is kept, the hardware has not changed.
+     *
+     * @returns {void}
+     */
+    reset(): void;
+    /**
+     * Discard what has been learned, returning the stick to passthrough until it calibrates again.
+     *
+     * Called when the handle starts representing different hardware. Keeping the estimate would apply one
+     * pad's correction to another, and worse, would stop the new pad's own rest position from ever being
+     * adopted whenever it sits further from the origin than the old one - the calibrator only ever moves its
+     * estimate closer in.
+     *
+     * A locked calibration is left alone: it was supplied rather than learned, so it is not ours to discard.
+     *
+     * @returns {void}
+     */
+    forgetCalibration(): void;
+    #private;
+}
+import Vector2 from "../../../../core/geom/Vector2.js";
+import { GamepadStickCalibration } from "./GamepadStickCalibration.js";
+//# sourceMappingURL=GamepadStick.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"GamepadStick.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/input/devices/gamepad/GamepadStick.js"],"names":[],"mappings":"AAKA;;;;;;;;;GASG;AACH;IAyDI;;;;OAIG;IACH,mBAHW,MAAM,SACN,MAAM,EAKhB;IA/DD;;;OAGG;IACH,OAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,OAFU,MAAM,CAEN;IAEV;;;;;;OAMG;IACH,cAFU,OAAO,CAEG;IAEpB;;;;;;;;;OASG;IACH,gBAFU,OAAO,CAEK;IAEtB;;;OAGG;IACH,sBAFU,uBAAuB,CAEW;IAE5C;;OAEG;IACH;QACI;;;WAGG;;MAEL;IAiBF;;;;;OAKG;IACH,aAHW,MAAM,EAAE,GACN,IAAI,CA0BhB;IAED;;;;;OAKG;IACH,SAFa,IAAI,CAMhB;IAED;;;;;;;;;;;OAWG;IACH,qBAFa,IAAI,CAUhB;;CAkBJ;oBAnKmB,kCAAkC;wCACd,8BAA8B"}

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

@@ -0,0 +1,165 @@
+import Signal from "../../../../core/events/signal/Signal.js";
+import Vector2 from "../../../../core/geom/Vector2.js";
+import { GamepadStickCalibration } from "./GamepadStickCalibration.js";
+import { GamepadStickCalibrator } from "./GamepadStickCalibrator.js";
+
+/**
+ * An analog stick: a pair of axes, plus what we have learned about the hardware behind them.
+ *
+ * Values are in the hardware frame, +x is right and +y is down, see {@link GamepadAxes}. Converting that into a
+ * game frame depends on the camera and belongs to a controller, not here - the same stick means different world
+ * directions in a top-down game and a third-person one.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class GamepadStick {
+
+    /**
+     * Index into {@link GamepadHandle#axes} read as the horizontal component
+     * @type {number}
+     */
+    axisX = 0;
+
+    /**
+     * Index into {@link GamepadHandle#axes} read as the vertical component
+     * @type {number}
+     */
+    axisY = 1;
+
+    /**
+     * Hardware value, exactly as reported.
+     * A resting stick rarely reads (0,0) here, that is what {@link calibration} is for.
+     *
+     * @readonly
+     * @type {Vector2}
+     */
+    raw = new Vector2();
+
+    /**
+     * Calibrated value: {@link raw} with the learned rest position removed, reading exactly neutral while the
+     * stick is within its learned noise radius. This is what gameplay should read.
+     *
+     * Still raw in every other respect - no gameplay dead zone, no response curve, no magnitude clamp. Feed it
+     * to {@link apply_radial_dead_zone} to shape it.
+     *
+     * @readonly
+     * @type {Vector2}
+     */
+    value = new Vector2();
+
+    /**
+     * @readonly
+     * @type {GamepadStickCalibration}
+     */
+    calibration = new GamepadStickCalibration();
+
+    /**
+     * @readonly
+     */
+    on = {
+        /**
+         * Fires when {@link value} changes. A calibrated stick at rest is silent.
+         * @type {Signal<>}
+         */
+        changed: new Signal()
+    };
+
+    /**
+     * @type {GamepadStickCalibrator}
+     */
+    #calibrator = new GamepadStickCalibrator();
+
+    /**
+     *
+     * @param {number} axisX index into {@link GamepadHandle#axes}
+     * @param {number} axisY index into {@link GamepadHandle#axes}
+     */
+    constructor(axisX, axisY) {
+        this.axisX = axisX;
+        this.axisY = axisY;
+    }
+
+    /**
+     * Refresh from raw axis values, feeding the calibrator on the way through.
+     *
+     * @param {number[]} axes raw axis values, indexed as {@link GamepadAxes}
+     * @returns {void}
+     */
+    update(axes) {
+        const x = axes[this.axisX];
+        const y = axes[this.axisY];
+
+        this.raw.set(x, y);
+
+        const calibration = this.calibration;
+
+        if (!calibration.locked) {
+            this.#calibrator.sample(calibration, x, y);
+        }
+
+        const center = calibration.center;
+
+        const dx = x - center.x;
+        const dy = y - center.y;
+
+        const noiseRadius = calibration.noiseRadius;
+
+        if (dx * dx + dy * dy <= noiseRadius * noiseRadius) {
+            this.#write(0, 0);
+        } else {
+            this.#write(dx, dy);
+        }
+    }
+
+    /**
+     * Return to neutral. Used when the pad disconnects, so a deflected stick does not stay deflected.
+     * The calibration is kept, the hardware has not changed.
+     *
+     * @returns {void}
+     */
+    reset() {
+        this.raw.set(0, 0);
+
+        this.#write(0, 0);
+    }
+
+    /**
+     * Discard what has been learned, returning the stick to passthrough until it calibrates again.
+     *
+     * Called when the handle starts representing different hardware. Keeping the estimate would apply one
+     * pad's correction to another, and worse, would stop the new pad's own rest position from ever being
+     * adopted whenever it sits further from the origin than the old one - the calibrator only ever moves its
+     * estimate closer in.
+     *
+     * A locked calibration is left alone: it was supplied rather than learned, so it is not ours to discard.
+     *
+     * @returns {void}
+     */
+    forgetCalibration() {
+        if (this.calibration.locked) {
+            return;
+        }
+
+        this.calibration.setIdentity();
+
+        this.#calibrator.reset();
+    }
+
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     */
+    #write(x, y) {
+        const value = this.value;
+
+        if (value.x === x && value.y === y) {
+            return;
+        }
+
+        value.set(x, y);
+
+        this.on.changed.send0();
+    }
+}

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

@@ -0,0 +1,84 @@
+/**
+ * Hardware characterization of a single analog stick.
+ *
+ * This describes what the hardware gets wrong, not what the game wants. Gameplay dead zone, response curve and
+ * frame conversion are policy and belong to the consumer, see {@link apply_radial_dead_zone}. Applying a
+ * gameplay dead zone here as well is how you end up with two dead zones stacked on top of each other and no
+ * precision left.
+ *
+ * Identity ({@link center} at origin, zero {@link noiseRadius}) is a bit-exact passthrough, so opting out of
+ * calibration is expressed by locking an identity calibration rather than by a separate code path.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class GamepadStickCalibration {
+    /**
+     * Where the stick actually rests. Subtracted from the raw value.
+     *
+     * This is what "stick drift" is: an offset center, not symmetric noise. A dead zone responds to an offset
+     * center by widening the dead area asymmetrically, losing range on one side while still drifting on the
+     * other. Subtracting the learned center fixes it instead.
+     *
+     * @readonly
+     * @type {Vector2}
+     */
+    readonly center: Vector2;
+    /**
+     * Learned dispersion around {@link center}: how far the stick wanders while resting there. Deflection
+     * within this radius reads as neutral.
+     *
+     * Distinct from {@link center}, and much smaller. A fixed dead zone has to cover both at once, which is why
+     * the shipped constants are so large - XInput recommends 0.24 - and why they have to be sized for the worst
+     * pad in the population, leaving every good pad paying for it. Splitting them lets each be what it actually
+     * is: an offset that gets subtracted, and a noise floor of a few thousandths on a healthy stick.
+     *
+     * Structurally bounded by the calibrator's spread bound, see {@link NOISE_RADIUS_MAX}.
+     *
+     * @type {number}
+     */
+    noiseRadius: number;
+    /**
+     * When true, learning is suspended and the current values are used as they are.
+     * Set this after writing values from a saved profile or a settings screen.
+     * @type {boolean}
+     */
+    locked: boolean;
+    /**
+     * Restore the passthrough calibration. Does not affect {@link locked}.
+     * @returns {void}
+     */
+    setIdentity(): void;
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {number} noiseRadius
+     * @returns {void}
+     */
+    set(x: number, y: number, noiseRadius: number): void;
+    /**
+     *
+     * @param {GamepadStickCalibration} other
+     * @returns {void}
+     */
+    copy(other: GamepadStickCalibration): void;
+    /**
+     *
+     * @param {GamepadStickCalibration} other
+     * @returns {boolean}
+     */
+    equals(other: GamepadStickCalibration): boolean;
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     */
+    toBinaryBuffer(buffer: BinaryBuffer): void;
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     */
+    fromBinaryBuffer(buffer: BinaryBuffer): void;
+}
+import Vector2 from "../../../../core/geom/Vector2.js";
+//# sourceMappingURL=GamepadStickCalibration.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"GamepadStickCalibration.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/input/devices/gamepad/GamepadStickCalibration.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH;IAEI;;;;;;;;;OASG;IACH,iBAFU,OAAO,CAEM;IAEvB;;;;;;;;;;;;OAYG;IACH,aAFU,MAAM,CAEA;IAEhB;;;;OAIG;IACH,QAFU,OAAO,CAEF;IAEf;;;OAGG;IACH,eAFa,IAAI,CAKhB;IAED;;;;;;OAMG;IACH,OALW,MAAM,KACN,MAAM,eACN,MAAM,GACJ,IAAI,CAKhB;IAED;;;;OAIG;IACH,YAHW,uBAAuB,GACrB,IAAI,CAMhB;IAED;;;;OAIG;IACH,cAHW,uBAAuB,GACrB,OAAO,CAMnB;IAED;;;OAGG;IACH,2CAKC;IAED;;;OAGG;IACH,6CAOC;CACJ;oBAtHmB,kCAAkC"}

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

@@ -0,0 +1,119 @@
+import Vector2 from "../../../../core/geom/Vector2.js";
+
+/**
+ * Hardware characterization of a single analog stick.
+ *
+ * This describes what the hardware gets wrong, not what the game wants. Gameplay dead zone, response curve and
+ * frame conversion are policy and belong to the consumer, see {@link apply_radial_dead_zone}. Applying a
+ * gameplay dead zone here as well is how you end up with two dead zones stacked on top of each other and no
+ * precision left.
+ *
+ * Identity ({@link center} at origin, zero {@link noiseRadius}) is a bit-exact passthrough, so opting out of
+ * calibration is expressed by locking an identity calibration rather than by a separate code path.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class GamepadStickCalibration {
+
+    /**
+     * Where the stick actually rests. Subtracted from the raw value.
+     *
+     * This is what "stick drift" is: an offset center, not symmetric noise. A dead zone responds to an offset
+     * center by widening the dead area asymmetrically, losing range on one side while still drifting on the
+     * other. Subtracting the learned center fixes it instead.
+     *
+     * @readonly
+     * @type {Vector2}
+     */
+    center = new Vector2();
+
+    /**
+     * Learned dispersion around {@link center}: how far the stick wanders while resting there. Deflection
+     * within this radius reads as neutral.
+     *
+     * Distinct from {@link center}, and much smaller. A fixed dead zone has to cover both at once, which is why
+     * the shipped constants are so large - XInput recommends 0.24 - and why they have to be sized for the worst
+     * pad in the population, leaving every good pad paying for it. Splitting them lets each be what it actually
+     * is: an offset that gets subtracted, and a noise floor of a few thousandths on a healthy stick.
+     *
+     * Structurally bounded by the calibrator's spread bound, see {@link NOISE_RADIUS_MAX}.
+     *
+     * @type {number}
+     */
+    noiseRadius = 0;
+
+    /**
+     * When true, learning is suspended and the current values are used as they are.
+     * Set this after writing values from a saved profile or a settings screen.
+     * @type {boolean}
+     */
+    locked = false;
+
+    /**
+     * Restore the passthrough calibration. Does not affect {@link locked}.
+     * @returns {void}
+     */
+    setIdentity() {
+        this.center.set(0, 0);
+        this.noiseRadius = 0;
+    }
+
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {number} noiseRadius
+     * @returns {void}
+     */
+    set(x, y, noiseRadius) {
+        this.center.set(x, y);
+        this.noiseRadius = noiseRadius;
+    }
+
+    /**
+     *
+     * @param {GamepadStickCalibration} other
+     * @returns {void}
+     */
+    copy(other) {
+        this.center.copy(other.center);
+        this.noiseRadius = other.noiseRadius;
+        this.locked = other.locked;
+    }
+
+    /**
+     *
+     * @param {GamepadStickCalibration} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        return this.noiseRadius === other.noiseRadius
+            && this.locked === other.locked
+            && this.center.equals(other.center);
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     */
+    toBinaryBuffer(buffer) {
+        buffer.writeFloat64(this.center.x);
+        buffer.writeFloat64(this.center.y);
+        buffer.writeFloat64(this.noiseRadius);
+        buffer.writeUint8(this.locked ? 1 : 0);
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     */
+    fromBinaryBuffer(buffer) {
+        const x = buffer.readFloat64();
+        const y = buffer.readFloat64();
+
+        this.center.set(x, y);
+        this.noiseRadius = buffer.readFloat64();
+        this.locked = buffer.readUint8() !== 0;
+    }
+}