dualsense-ts 2.2.48 → 3.1.3

package/src/elements/analog.ts

@@ -1,16 +1,23 @@
-import { Axis } from "./axis";
+import { Axis, AxisParams } from "./axis";
 import { Momentary } from "./momentary";
 import { Input, InputParams } from "../input";
 import { Radians, Degrees, Magnitude, Force } from "../math";
 
 /**
- * Configuration for an analog joystick and its basic inputs.
+ * Configuration for an analog joystick and its component inputs.
  */
 export interface AnalogParams extends InputParams {
+  // Configuration for the input's button
   button?: InputParams;
-  x?: InputParams;
-  y?: InputParams;
-  threshold?: Magnitude;
+
+  // Configuration for the input's x axis
+  x?: AxisParams;
+
+  // Configuration for the input's y axis
+  y?: AxisParams;
+
+  // Ignore input of magnitude less than or equal to this value
+  deadzone?: Magnitude;
 }
 
 /**
@@ -22,7 +29,7 @@ export interface AnalogParams extends InputParams {
  * - Pushed all the way down and to the left, the stick's coordinates are [-1, -1]
  */
 export class Analog extends Input<Analog> {
-  public readonly state: Analog = this;
+  public readonly state: this = this;
 
   /**
    * The left/right position of the input.
@@ -36,25 +43,36 @@ export class Analog extends Input<Analog> {
    * Button triggered by pressing the stick.
    */
   public readonly button: Momentary;
+  /**
+   * Ignores stick movement below this value (0 to 1).
+   */
+  public deadzone: Magnitude = 0.05;
 
   constructor(params?: AnalogParams) {
     super(params);
-    const { button, x, y, threshold } = params || {};
-
-    this.button = new Momentary(button || { icon: "3", name: "Button" });
-    this.x = new Axis(
-      x || { icon: "↔", name: "X", threshold: threshold || 0.07 }
-    );
-    this.y = new Axis(
-      y || { icon: "↕", name: "Y", threshold: threshold || 0.07 }
-    );
+    const { button, x, y, deadzone } = params || {};
+
+    if (deadzone) this.deadzone = deadzone;
+    this.button = new Momentary({ icon: "3", name: "Button", ...button });
+    this.x = new Axis({
+      icon: "↔",
+      name: "X",
+      ...params,
+      ...x,
+    });
+    this.y = new Axis({
+      icon: "↕",
+      name: "Y",
+      ...params,
+      ...y,
+    });
   }
 
   /**
    * Returns true if the stick is away from the idle position, or the button is pressed.
    */
   public get active(): boolean {
-    return this.x.active || this.y.active || this.button.active;
+    return this.magnitude > 0 || this.button.active;
   }
 
   /**
@@ -65,26 +83,27 @@ export class Analog extends Input<Analog> {
   }
 
   /**
-   * Returns an force from the stick's position.
+   * Returns a force from the stick's position.
+   * This ignores the deadzone value.
    */
   public get force(): Force {
-    return this.active
-      ? Math.max(Math.min(Math.hypot(this.x.state, this.y.state), 1), -1)
-      : 0;
+    return Math.max(Math.min(Math.hypot(this.x.force, this.y.force), 1), -1);
   }
 
   /**
    * Returns a magnitude from the stick's position.
    */
   public get magnitude(): Magnitude {
-    return Math.abs(this.force);
+    const magnitude = Math.abs(this.force);
+    if (magnitude < this.deadzone) return 0;
+    return (magnitude - this.deadzone) / (1 - this.deadzone);
   }
 
   /**
    * Returns the stick's angle in radians.
    */
   public get direction(): Radians {
-    return Math.atan2(this.y.state, this.x.state);
+    return Math.atan2(this.y.force, this.x.force);
   }
 
   /**

package/src/elements/axis.ts

@@ -1,18 +1,50 @@
-import { Input } from "../input";
+import { Input, InputParams } from "../input";
 import { Force, Magnitude } from "../math";
 
+/**
+ * Configuration for an Axis input.
+ */
+export interface AxisParams extends InputParams {
+  // Ignore input of magnitude less than or equal to this value
+  deadzone?: Magnitude;
+}
+
+/**
+ * Represents a simple ranged input. For example, one axis of an analog
+ * joystick or touchpad, the pull of a trigger, or the movement of a gyroscope.
+ */
 export class Axis extends Input<Force> {
   public state: Force = 0;
 
+  /**
+   * Ignores inputs of magnitude less than this value (0 to 1).
+   */
+  public deadzone: Magnitude = 0.05;
+
+  constructor(params?: AxisParams) {
+    super(params);
+    const { deadzone } = params || {};
+
+    if (deadzone) this.deadzone = deadzone;
+  }
+
   public get active(): boolean {
-    return Math.abs(this.state) > this.threshold;
+    return Math.abs(this.state) > this.deadzone;
   }
 
+  /**
+   * Returns the axis position, ignoring the deadzone value.
+   */
   public get force(): Force {
     return this.active ? this.state : 0;
   }
 
+  /**
+   * Returns an absolute axis position.
+   */
   public get magnitude(): Magnitude {
-    return Math.abs(this.force);
+    const magnitude = Math.abs(this.force);
+    if (magnitude < this.deadzone) return 0;
+    return (magnitude - this.deadzone) / (1 - this.deadzone);
   }
 }

package/src/elements/dpad.ts

@@ -9,20 +9,21 @@ export interface DpadParams extends InputParams {
 }
 
 export class Dpad extends Input<Dpad> {
-  public readonly state: Dpad = this;
+  public readonly state: this = this;
 
   public readonly up: Momentary;
   public readonly down: Momentary;
   public readonly left: Momentary;
   public readonly right: Momentary;
 
-  constructor(params?: DpadParams) {
+  constructor(params: DpadParams = {}) {
     super(params);
+    const { up, down, left, right } = params
 
-    this.up = new Momentary(params?.up || { icon: "⮉", name: "Up" });
-    this.down = new Momentary(params?.down || { icon: "⮋", name: "Down" });
-    this.left = new Momentary(params?.left || { icon: "⮈", name: "Left" });
-    this.right = new Momentary(params?.right || { icon: "⮊", name: "Right" });
+    this.up = new Momentary(params?.up || { icon: "⮉", name: "Up", ...up});
+    this.down = new Momentary(params?.down || { icon: "⮋", name: "Down", ...down});
+    this.left = new Momentary(params?.left || { icon: "⮈", name: "Left", ...left });
+    this.right = new Momentary(params?.right || { icon: "⮊", name: "Right", ...right });
   }
 
   public get active(): boolean {

package/src/elements/touch.ts

@@ -6,9 +6,10 @@ import { Increment } from "./increment";
  * with [0,0] representing the center of the touchpad.
  */
 export class Touch extends Analog {
-  public readonly state: Touch = this;
+  public readonly state: this = this;
   public readonly contact = this.button;
   public readonly tracker: Increment = new Increment();
+  public deadzone = 0;
 
   public get active(): boolean {
     return this.contact.active;

package/src/elements/touchpad.ts

@@ -3,7 +3,7 @@ import { Touch } from "./touch";
 import { Input, InputParams } from "../input";
 
 export class Touchpad extends Input<Touchpad> {
-  public readonly state: Touchpad = this;
+  public readonly state: this = this;
 
   public get active(): boolean {
     return this.left.contact.active;

package/src/elements/trigger.ts

@@ -6,7 +6,7 @@ import { Momentary } from "./momentary";
 export class Trigger extends Input<Magnitude> {
   public state: Magnitude = 0;
 
-  public button: Momentary = new Momentary({});
+  public button: Momentary = new Momentary();
 
   public get active(): boolean {
     return this.state > 0;

package/src/elements/unisense.ts

@@ -1,40 +1,42 @@
 import { Trigger } from "./trigger";
 import { Momentary } from "./momentary";
-import { Analog } from "./analog";
+import { Analog, AnalogParams } from "./analog";
 import { Haptic } from "../haptics";
 import { Input, InputParams } from "../input";
 
 export interface UnisenseParams extends InputParams {
   trigger?: InputParams;
   bumper?: InputParams;
-  analog?: InputParams;
+  analog?: AnalogParams;
 }
 
 // The name "Dualsense" clearly implies a composition of two Unisense elements 🤔
 export class Unisense extends Input<Unisense> {
-  public readonly state: Unisense = this;
+  public readonly state: this = this;
 
   public readonly trigger: Trigger;
   public readonly bumper: Momentary;
   public readonly analog: Analog;
   public readonly haptic: Haptic;
 
-  constructor(params?: UnisenseParams) {
+  constructor(params: UnisenseParams = {}) {
     super(params);
+    const { trigger, bumper, analog } = params;
 
-    this.trigger = new Trigger(
-      params?.trigger || {
-        icon: "2",
-        name: "Trigger",
-        threshold: (1 / 255) * 3,
-      }
-    );
-    this.bumper = new Momentary(
-      params?.bumper || { icon: "1", name: "Bumper" }
-    );
-    this.analog = new Analog(
-      params?.analog || { icon: "⨁", name: "Analog", threshold: 0.07 }
-    );
+    this.trigger = new Trigger({
+      icon: "2",
+      name: "Trigger",
+      threshold: 1 / 255,
+      ...trigger,
+    });
+    this.bumper = new Momentary({ icon: "1", name: "Bumper", ...bumper });
+    this.analog = new Analog({
+      icon: "⨁",
+      name: "Analog",
+      threshold: 1 / 128,
+      deadzone: 8 / 128,
+      ...analog,
+    });
     this.haptic = new Haptic();
   }
 

package/src/hid/dualsense_hid.ts

@@ -1,63 +1,13 @@
-import { HID, devices } from "node-hid";
-import { EventEmitter } from "events";
+import { HIDProvider, DualsenseHIDState, InputId } from "./hid_provider";
 
-import { InputId } from "./ids";
+export type HIDCallback = (state: DualsenseHIDState) => void;
 
-export interface DualsenseHIDState {
-  [InputId.LeftAnalogX]: number;
-  [InputId.LeftAnalogY]: number;
-  [InputId.RightAnalogX]: number;
-  [InputId.RightAnalogY]: number;
-  [InputId.LeftTrigger]: number;
-  [InputId.RightTrigger]: number;
-  [InputId.Triangle]: boolean;
-  [InputId.Circle]: boolean;
-  [InputId.Cross]: boolean;
-  [InputId.Square]: boolean;
-  [InputId.Dpad]: number;
-  [InputId.Up]: boolean;
-  [InputId.Down]: boolean;
-  [InputId.Left]: boolean;
-  [InputId.Right]: boolean;
-  [InputId.RightAnalogButton]: boolean;
-  [InputId.LeftAnalogButton]: boolean;
-  [InputId.Options]: boolean;
-  [InputId.Create]: boolean;
-  [InputId.RightTriggerButton]: boolean;
-  [InputId.LeftTriggerButton]: boolean;
-  [InputId.RightBumper]: boolean;
-  [InputId.LeftBumper]: boolean;
-  [InputId.Playstation]: boolean;
-  [InputId.TouchButton]: boolean;
-  [InputId.Mute]: boolean;
-  [InputId.Status]: boolean;
-  [InputId.TouchX0]: number;
-  [InputId.TouchY0]: number;
-  [InputId.TouchContact0]: boolean;
-  [InputId.TouchId0]: number;
-  [InputId.TouchX1]: number;
-  [InputId.TouchY1]: number;
-  [InputId.TouchContact1]: boolean;
-  [InputId.TouchId1]: number;
-  [InputId.GyroX]: number;
-  [InputId.GyroY]: number;
-  [InputId.GyroZ]: number;
-  [InputId.AccelX]: number;
-  [InputId.AccelY]: number;
-  [InputId.AccelZ]: number;
-}
-
-// Maps a HID input of 0...n to -1...1
-export function mapAxis(value: number, max: number = 255): number {
-  return (2 / max) * Math.max(0, Math.min(max, value)) - 1;
-}
-
-// Maps a HID input of 0...255 to 0...1
-export function mapTrigger(value: number): number {
-  return (1 / 255) * Math.max(0, Math.min(255, value));
-}
+/**
+ * Coordinates a HIDProvider and tracks the latest HID state.
+ */
+export class DualsenseHID {
+  private readonly subscribers = new Set<HIDCallback>();
 
-export class DualsenseHID extends EventEmitter {
   public state: DualsenseHIDState = {
     [InputId.LeftAnalogX]: 0,
     [InputId.LeftAnalogY]: 0,
@@ -102,116 +52,35 @@ export class DualsenseHID extends EventEmitter {
     [InputId.AccelZ]: 0,
   };
 
-  private device: HID;
-  private wireless: boolean = false;
-
-  static readonly vendorId: number = 1356;
-  static readonly productId: number = 3302;
-
-  constructor() {
-    super();
-    this.device = this.connect();
+  constructor(readonly provider: HIDProvider) {
+    provider.onData = this.set.bind(this);
+    provider.onError = this.handleError.bind(this);
   }
 
   /**
-   * Unpacks a Dualsense HID report.
+   * Register a handler for HID state updates.
    */
-  private process(buffer: Buffer): void {
-    // Bluetooth buffer starts with an extra byte
-    const report = buffer.subarray(this.wireless ? 2 : 1);
+  public register(callback: (state: DualsenseHIDState) => void): void {
+    this.subscribers.add(callback);
+  }
 
-    const { state } = this;
-    state[InputId.LeftAnalogX] = mapAxis(report.readUint8(0));
-    state[InputId.LeftAnalogY] = -mapAxis(report.readUint8(1));
-    state[InputId.RightAnalogX] = mapAxis(report.readUint8(2));
-    state[InputId.RightAnalogY] = -mapAxis(report.readUint8(3));
-    state[InputId.LeftTrigger] = mapTrigger(report.readUint8(4));
-    state[InputId.RightTrigger] = mapTrigger(report.readUint8(5));
-    // 6 is a sequence byte
-    const mainButtons = report.readUint8(7);
-    state[InputId.Triangle] = (mainButtons & 128) > 0;
-    state[InputId.Circle] = (mainButtons & 64) > 0;
-    state[InputId.Cross] = (mainButtons & 32) > 0;
-    state[InputId.Square] = (mainButtons & 16) > 0;
-    state[InputId.Dpad] = (mainButtons << 4) >> 4;
-    state[InputId.Up] = state[InputId.Dpad] < 2 || state[InputId.Dpad] === 7;
-    state[InputId.Down] = state[InputId.Dpad] > 2 && state[InputId.Dpad] < 6;
-    state[InputId.Left] = state[InputId.Dpad] > 4 && state[InputId.Dpad] < 8;
-    state[InputId.Right] = state[InputId.Dpad] > 0 && state[InputId.Dpad] < 4;
-    const miscButtons = report.readUint8(8);
-    state[InputId.LeftTriggerButton] = (miscButtons & 4) > 0;
-    state[InputId.RightTriggerButton] = (miscButtons & 8) > 0;
-    state[InputId.LeftBumper] = (miscButtons & 1) > 0;
-    state[InputId.RightBumper] = (miscButtons & 2) > 0;
-    state[InputId.Create] = (miscButtons & 16) > 0;
-    state[InputId.Options] = (miscButtons & 32) > 0;
-    state[InputId.LeftAnalogButton] = (miscButtons & 64) > 0;
-    state[InputId.RightAnalogButton] = (miscButtons & 128) > 0;
-    const lastButtons = report.readUint8(9);
-    state[InputId.Playstation] = (lastButtons & 1) > 0;
-    state[InputId.TouchButton] = (lastButtons & 2) > 0;
-    state[InputId.Mute] = (lastButtons & 4) > 0;
-    // The other 5 bits are unused
-    // 5 reserved bytes
-    state[InputId.GyroX] = report.readUint16LE(15);
-    state[InputId.GyroY] = report.readUint16LE(17);
-    state[InputId.GyroZ] = report.readUint16LE(19);
-    state[InputId.AccelX] = report.readUint16LE(21);
-    state[InputId.AccelY] = report.readUint16LE(23);
-    state[InputId.AccelZ] = report.readUint16LE(25);
-    // 4 bytes for sensor timestamp (32LE)
-    // 1 reserved byte
-    state[InputId.TouchId0] = report.readUint8(32) & 0x7f;
-    state[InputId.TouchContact0] = (report.readUint8(32) & 0x80) === 0;
-    state[InputId.TouchX0] = mapAxis(
-      (report.readUint16LE(33) << 20) >> 20,
-      1920
-    );
-    state[InputId.TouchY0] = mapAxis(report.readUint16LE(34) >> 4, 1080);
-    state[InputId.TouchId1] = report.readUint8(36) & 0x7f;
-    state[InputId.TouchContact1] = (report.readUint8(36) & 0x80) === 0;
-    state[InputId.TouchX1] = mapAxis(
-      (report.readUint16LE(37) << 20) >> 20,
-      1920
-    );
-    state[InputId.TouchY1] = mapAxis(report.readUint16LE(38) >> 4, 1080);
-    // 12 reserved bytes
-    state[InputId.Status] = (report.readUint8(53) & 4) > 0;
+  /**
+   * Cancel a previously registered handler.
+   */
+  public unregister(callback: (state: DualsenseHIDState) => void): void {
+    this.subscribers.delete(callback);
+  }
 
-    this.emit("input", state);
+  private set(state: DualsenseHIDState): void {
+    this.state = state;
+    this.subscribers.forEach((callback) => callback(state));
   }
 
   private handleError(error: unknown): void {
     console.error(error);
     setTimeout(() => {
-      this.device = this.connect();
+      this.provider.disconnect();
+      this.provider.connect();
     }, 50);
   }
-
-  private disconnect(): void {
-    if (this.device) {
-      try {
-        this.device.removeAllListeners();
-        this.device.close();
-      } catch (e) {
-        console.error(e);
-      }
-    }
-  }
-
-  private connect(): HID {
-    this.disconnect();
-
-    const controllers = devices(DualsenseHID.vendorId, DualsenseHID.productId);
-    if (controllers.length === 0 || !controllers[0].path) {
-      throw new Error(`No controllers (${devices().length} other devices)`);
-    }
-
-    if (controllers[0].interface === -1) this.wireless = true;
-
-    const controller = new HID(controllers[0].path);
-    controller.on("data", this.process.bind(this));
-    controller.on("error", this.handleError.bind(this));
-    return controller;
-  }
 }

package/src/hid/{dualsense_hid.spec.ts → hid_provider.spec.ts}

@@ -1,4 +1,4 @@
-import { mapAxis, mapTrigger } from "./dualsense_hid";
+import { mapAxis, mapTrigger } from "./hid_provider";
 
 describe("Dualsense HID", () => {
   it("should map axis values betwen -1 and 1", () => {

package/src/hid/hid_provider.ts

@@ -0,0 +1,100 @@
+import { InputId } from "../id";
+
+export * from "../id";
+
+/**
+ * Maps a HID input of 0...n to -1...1
+ */
+export function mapAxis(value: number, max: number = 255): number {
+  return (2 / max) * Math.max(0, Math.min(max, value)) - 1;
+}
+
+/**
+ * Maps a HID input of 0...255 to 0...1
+ */
+export function mapTrigger(value: number): number {
+  return (1 / 255) * Math.max(0, Math.min(255, value));
+}
+
+/**
+ * Describes an observation of the input state of a Dualsense controller.
+ */
+export interface DualsenseHIDState {
+  [InputId.LeftAnalogX]: number;
+  [InputId.LeftAnalogY]: number;
+  [InputId.RightAnalogX]: number;
+  [InputId.RightAnalogY]: number;
+  [InputId.LeftTrigger]: number;
+  [InputId.RightTrigger]: number;
+  [InputId.Triangle]: boolean;
+  [InputId.Circle]: boolean;
+  [InputId.Cross]: boolean;
+  [InputId.Square]: boolean;
+  [InputId.Dpad]: number;
+  [InputId.Up]: boolean;
+  [InputId.Down]: boolean;
+  [InputId.Left]: boolean;
+  [InputId.Right]: boolean;
+  [InputId.RightAnalogButton]: boolean;
+  [InputId.LeftAnalogButton]: boolean;
+  [InputId.Options]: boolean;
+  [InputId.Create]: boolean;
+  [InputId.RightTriggerButton]: boolean;
+  [InputId.LeftTriggerButton]: boolean;
+  [InputId.RightBumper]: boolean;
+  [InputId.LeftBumper]: boolean;
+  [InputId.Playstation]: boolean;
+  [InputId.TouchButton]: boolean;
+  [InputId.Mute]: boolean;
+  [InputId.Status]: boolean;
+  [InputId.TouchX0]: number;
+  [InputId.TouchY0]: number;
+  [InputId.TouchContact0]: boolean;
+  [InputId.TouchId0]: number;
+  [InputId.TouchX1]: number;
+  [InputId.TouchY1]: number;
+  [InputId.TouchContact1]: boolean;
+  [InputId.TouchId1]: number;
+  [InputId.GyroX]: number;
+  [InputId.GyroY]: number;
+  [InputId.GyroZ]: number;
+  [InputId.AccelX]: number;
+  [InputId.AccelY]: number;
+  [InputId.AccelZ]: number;
+}
+
+/**
+ * Supports a connection to a physical or logical Dualsense device.
+ */
+export abstract class HIDProvider {
+  static readonly vendorId: number = 1356;
+  static readonly productId: number = 3302;
+
+  public onData: (state: DualsenseHIDState) => void = () => {};
+  public onError: (error: Error) => void = () => {};
+
+  /**
+   * Search for a controller and connect to it.
+   */
+  abstract connect(): void;
+
+  /**
+   * Stop accepting input from the controller.
+   */
+  abstract disconnect(): void;
+
+  /**
+   * Returns true if a device is currently connected and working.
+   */
+  abstract get connected(): boolean;
+
+  /**
+   * Returns true if a device is connected wirelessly.
+   */
+  abstract get wireless(): boolean;
+
+  /**
+   * Converts the HID report to a usable state entity.
+   */
+  abstract process(input: unknown): DualsenseHIDState;
+}

package/src/hid/index.ts

@@ -4,4 +4,7 @@
 
 export * from "./command";
 export * from "./dualsense_hid";
-export * from "./ids";
+export * from "./hid_provider";
+export * from "./node_hid_provider";
+export * from "./platform_hid_provider";
+export * from "./web_hid_provider";