@woosh/meep-engine 2.159.0 → 2.161.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"GamepadHandle.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/input/devices/gamepad/GamepadHandle.js"],"names":[],"mappings":"AAIA;;;;;;;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;;OAEG;IACH;QACI;;;WAGG;cADO,OAAO,MAAM,CAAC;QAGxB;;;WAGG;YADO,OAAO,MAAM,CAAC;QAGxB;;;WAGG;cADO,OAAO,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC;MAG1C;IAEF;;;;;;;;;;OAUG;IACH,kBALU,iBAAiB,EAAE,CAKhB;IAEb;;;;;OAKG;IACH,uBAFU,MAAM,EAAE,CAEA;IAElB;;;;;OAKG;IACH,eAFU,MAAM,EAAE,CAER;IAEV;;;;OAIG;IACH,oBAFU,OAAO,CAES;IAE1B;;;;OAIG;IACH,qBAFU,OAAO,CAEU;IAE3B;;;;;OAKG;IACH,iBAHW,MAAM,GACJ,iBAAiB,CAa7B;IAED;;;;;OAKG;IACH,eAHW,OAAO,aACP,MAAM,QAkEhB;IAED;;;OAGG;IACH,cA+BE;CACL;mBAvOkB,0CAA0C;kCAE3B,yBAAyB;oBADvC,kCAAkC"}

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

@@ -0,0 +1,232 @@
+import Signal from "../../../../core/events/signal/Signal.js";
+import Vector2 from "../../../../core/geom/Vector2.js";
+import { InputDeviceSwitch } from "../InputDeviceSwitch.js";
+
+/**
+ * State of a single physical gamepad.
+ * 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}.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class GamepadHandle {
+
+    /**
+     * Index of the gamepad within {@link Navigator.getGamepads} list
+     * @type {number}
+     */
+    index = -1;
+
+    /**
+     * Identification string of the hardware, contents are browser-specific
+     * @type {string}
+     */
+    id = "";
+
+    /**
+     * Button/axis layout, "standard" for the standard mapping
+     * see https://w3c.github.io/gamepad/#remapping
+     * @type {string}
+     */
+    mapping = "";
+
+    /**
+     * Whether the gamepad is currently connected
+     * Do not modify directly
+     * @type {boolean}
+     */
+    connected = false;
+
+    /**
+     * @readonly
+     */
+    on = {
+        /**
+         * Fires when any button is pressed, dispatches button index
+         * @type {Signal<number>}
+         */
+        down: new Signal(),
+        /**
+         * Fires when any button is released, dispatches button index
+         * @type {Signal<number>}
+         */
+        up: new Signal(),
+        /**
+         * Fires when an axis value changes, dispatches (axisIndex, value, previousValue)
+         * @type {Signal<number, number, number>}
+         */
+        axis: new Signal()
+    };
+
+    /**
+     * 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.
+     *
+     * @readonly
+     * @type {InputDeviceSwitch[]}
+     *
+     * @example
+     *   const is_jumping = pad.buttons[GamepadButtons.a]?.is_down;
+     */
+    buttons = [];
+
+    /**
+     * Analog values of the buttons in the range [0,1], indexed by button index.
+     * Useful for analog triggers.
+     * @readonly
+     * @type {number[]}
+     */
+    buttonValues = [];
+
+    /**
+     * Axis values in the range [-1,1], after dead-zone filtering.
+     * For the standard mapping, see {@link GamepadAxes} for valid indices.
+     * @readonly
+     * @type {number[]}
+     */
+    axes = [];
+
+    /**
+     * Convenience accessor for axes 0 and 1 of the standard mapping
+     * @readonly
+     * @type {Vector2}
+     */
+    stickLeft = new Vector2();
+
+    /**
+     * Convenience accessor for axes 2 and 3 of the standard mapping
+     * @readonly
+     * @type {Vector2}
+     */
+    stickRight = new Vector2();
+
+    /**
+     * Returns switch for a given button index, creating it if it doesn't exist yet
+     *
+     * @param {number} index
+     * @returns {InputDeviceSwitch}
+     */
+    getButton(index) {
+        let button = this.buttons[index];
+
+        if (button === undefined) {
+            button = new InputDeviceSwitch();
+
+            this.buttons[index] = button;
+            this.buttonValues[index] = 0;
+        }
+
+        return button;
+    }
+
+    /**
+     * 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) {
+
+        this.index = source.index;
+        this.id = source.id;
+        this.mapping = source.mapping;
+
+        // buttons
+        const sourceButtons = source.buttons;
+        const buttonCount = sourceButtons.length;
+
+        for (let i = 0; i < buttonCount; i++) {
+            const sourceButton = sourceButtons[i];
+
+            const button = this.getButton(i);
+
+            this.buttonValues[i] = sourceButton.value;
+
+            if (sourceButton.pressed) {
+
+                if (button.is_up) {
+                    button.press();
+
+                    this.on.down.send1(i);
+                }
+
+            } else if (button.is_down) {
+                button.release();
+
+                this.on.up.send1(i);
+            }
+        }
+
+        // axes
+        const sourceAxes = source.axes;
+        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 oldValue = this.axes[i] !== undefined ? this.axes[i] : 0;
+
+            if (value !== oldValue) {
+                this.axes[i] = value;
+
+                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
+        );
+    }
+
+    /**
+     * Release all buttons and reset axes to neutral.
+     * Used when the gamepad disconnects, to avoid inputs getting "stuck" in pressed state.
+     */
+    reset() {
+        const buttons = this.buttons;
+        const n = buttons.length;
+
+        for (let i = 0; i < n; i++) {
+            const button = buttons[i];
+
+            if (button !== undefined && button.is_down) {
+                button.release();
+
+                this.on.up.send1(i);
+            }
+
+            this.buttonValues[i] = 0;
+        }
+
+        const axes = this.axes;
+        const m = axes.length;
+
+        for (let i = 0; i < m; i++) {
+            const oldValue = axes[i];
+
+            if (oldValue !== 0) {
+                axes[i] = 0;
+
+                this.on.axis.send3(i, 0, oldValue);
+            }
+        }
+
+        this.stickLeft.set(0, 0);
+        this.stickRight.set(0, 0);
+     }
+}

package/src/engine/physics/fluid/ecs/FluidObstacleSystem.d.ts

@@ -64,11 +64,11 @@ export class FluidObstacleSystem extends System<any, any, any, any, any> {
     /**
      * @param {FluidComponent} fluid
      */
-    static "__#143@#refresh_masks"(fluid: FluidComponent): void;
+    static "__#144@#refresh_masks"(fluid: FluidComponent): void;
     /**
      * @param {FluidComponent} fluid
      */
-    static "__#143@#clear_field"(fluid: FluidComponent): void;
+    static "__#144@#clear_field"(fluid: FluidComponent): void;
     /**
      * Mark every cell of `fluid` whose centre lies within `inflation` of the
      * posed shape as solid. Iteration is clipped to the shape's world AABB
@@ -80,7 +80,7 @@ export class FluidObstacleSystem extends System<any, any, any, any, any> {
      * @param {number} inflation       world-units SDF threshold
      * @param {Float64Array} point     length-3 scratch
      */
-    static "__#143@#voxelize"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array): void;
+    static "__#144@#voxelize"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array): void;
     /**
      * Write the obstacle's translation velocity onto every face of every cell
      * it voxelized — the moving-wall boundary condition. Runs AFTER the mask
@@ -100,7 +100,7 @@ export class FluidObstacleSystem extends System<any, any, any, any, any> {
      * @param {number} wvy
      * @param {number} wvz
      */
-    static "__#143@#stamp_wall_velocity"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array, wvx: number, wvy: number, wvz: number): void;
+    static "__#144@#stamp_wall_velocity"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array, wvx: number, wvy: number, wvz: number): void;
     constructor();
     dependencies: (typeof FluidObstacle)[];
     components_used: (ResourceAccessSpecification<typeof RigidBody> | ResourceAccessSpecification<typeof Collider> | ResourceAccessSpecification<typeof Transform> | ResourceAccessSpecification<typeof FluidComponent> | ResourceAccessSpecification<typeof FluidObstacle>)[];

package/src/engine/physics/fluid/ecs/FluidSystem.d.ts

@@ -38,7 +38,7 @@ export class FluidSystem extends System<any, any, any, any, any> {
      * @param {FluidEffectorsComponent} effectors_component
      * @param {Transform} transform
      */
-    static "__#142@#sync_effectors_from_transform"(effectors_component: FluidEffectorsComponent, transform: Transform): void;
+    static "__#143@#sync_effectors_from_transform"(effectors_component: FluidEffectorsComponent, transform: Transform): void;
     /**
      * Visitor for the (FluidComponent, Transform) traversal — keeps the field's
      * grid origin locked to a cell-aligned position near the transform.
@@ -61,7 +61,7 @@ export class FluidSystem extends System<any, any, any, any, any> {
      * @param {FluidComponent} component
      * @param {Transform} transform
      */
-    static "__#142@#reanchor_field"(component: FluidComponent, transform: Transform): void;
+    static "__#143@#reanchor_field"(component: FluidComponent, transform: Transform): void;
     /**
      * Write the world-to-grid affine for a FluidComponent into `out`. Axis-aligned,
      * uniform-scale, so the matrix is sparse:
@@ -76,7 +76,7 @@ export class FluidSystem extends System<any, any, any, any, any> {
      * @param {Float32Array} out  length-16
      * @param {FluidComponent} component
      */
-    static "__#142@#build_world_to_grid"(out: Float32Array, component: FluidComponent): void;
+    static "__#143@#build_world_to_grid"(out: Float32Array, component: FluidComponent): void;
     constructor();
     dependencies: (typeof FluidComponent)[];
     /**