@aura3d/input 1.0.6

package/src/InputSnapshot.ts

@@ -0,0 +1,92 @@
+export type ButtonState = Readonly<{
+  down: boolean;
+  pressed: boolean;
+  released: boolean;
+}>;
+
+export interface PointerSnapshot {
+  readonly x: number;
+  readonly y: number;
+  readonly deltaX: number;
+  readonly deltaY: number;
+  readonly wheelX: number;
+  readonly wheelY: number;
+  readonly buttons: ReadonlyMap<number, ButtonState>;
+  readonly touches: readonly PointerTouch[];
+}
+
+export interface PointerTouch {
+  readonly id: number;
+  readonly x: number;
+  readonly y: number;
+}
+
+export interface GamepadSnapshot {
+  readonly id: string;
+  readonly index: number;
+  readonly axes: readonly number[];
+  readonly buttons: readonly ButtonState[];
+}
+
+export interface InputSnapshotOptions {
+  readonly keys?: ReadonlySet<string>;
+  readonly previousKeys?: ReadonlySet<string>;
+  readonly pointer?: Partial<PointerSnapshot>;
+  readonly previousPointerButtons?: ReadonlySet<number>;
+  readonly gamepads?: readonly GamepadSnapshot[];
+}
+
+const EMPTY_SET = new Set<string>();
+const EMPTY_BUTTON_SET = new Set<number>();
+
+export class InputSnapshot {
+  readonly keys: ReadonlySet<string>;
+  readonly pointer: PointerSnapshot;
+  readonly gamepads: readonly GamepadSnapshot[];
+
+  private readonly previousKeys: ReadonlySet<string>;
+
+  constructor(options: InputSnapshotOptions = {}) {
+    this.keys = new Set(options.keys ?? EMPTY_SET);
+    this.previousKeys = new Set(options.previousKeys ?? EMPTY_SET);
+    this.gamepads = Object.freeze([...(options.gamepads ?? [])]);
+
+    const previousButtons = options.previousPointerButtons ?? EMPTY_BUTTON_SET;
+    const currentButtons = new Set(options.pointer?.buttons?.keys() ?? []);
+    const buttons = new Map<number, ButtonState>();
+
+    for (const button of new Set([...previousButtons, ...currentButtons])) {
+      const down = currentButtons.has(button);
+      const wasDown = previousButtons.has(button);
+      buttons.set(button, Object.freeze({ down, pressed: down && !wasDown, released: !down && wasDown }));
+    }
+
+    this.pointer = Object.freeze({
+      x: options.pointer?.x ?? 0,
+      y: options.pointer?.y ?? 0,
+      deltaX: options.pointer?.deltaX ?? 0,
+      deltaY: options.pointer?.deltaY ?? 0,
+      wheelX: options.pointer?.wheelX ?? 0,
+      wheelY: options.pointer?.wheelY ?? 0,
+      buttons,
+      touches: Object.freeze([...(options.pointer?.touches ?? [])])
+    });
+  }
+
+  key(code: string): ButtonState {
+    const down = this.keys.has(code);
+    const wasDown = this.previousKeys.has(code);
+    return Object.freeze({ down, pressed: down && !wasDown, released: !down && wasDown });
+  }
+
+  button(button: number): ButtonState {
+    return this.pointer.buttons.get(button) ?? Object.freeze({ down: false, pressed: false, released: false });
+  }
+
+  gamepadButton(gamepadIndex: number, buttonIndex: number): ButtonState {
+    return (
+      this.gamepads.find((gamepad) => gamepad.index === gamepadIndex)?.buttons[buttonIndex] ??
+      Object.freeze({ down: false, pressed: false, released: false })
+    );
+  }
+}

package/src/InputSystem.ts

@@ -0,0 +1,92 @@
+import { ActionMap } from "./ActionMap";
+import { GamepadDevice, type GamepadLike } from "./GamepadDevice";
+import { InputSnapshot } from "./InputSnapshot";
+import { KeyboardDevice, type KeyboardEventLike } from "./KeyboardDevice";
+import { PointerDevice, type PointerEventLike, type WheelEventLike } from "./PointerDevice";
+
+export interface InputEventTargetLike {
+  addEventListener(type: string, listener: EventListener): void;
+  removeEventListener(type: string, listener: EventListener): void;
+}
+
+export class InputSystem {
+  readonly keyboard = new KeyboardDevice();
+  readonly pointer = new PointerDevice();
+  readonly gamepads = new GamepadDevice();
+  readonly actions = new ActionMap();
+
+  private readonly attachedTargets = new Map<InputEventTargetLike, Array<() => void>>();
+  private snapshotRef = new InputSnapshot();
+
+  constructor(target?: InputEventTargetLike) {
+    if (target) {
+      this.attach(target);
+    }
+  }
+
+  get snapshot(): InputSnapshot {
+    return this.snapshotRef;
+  }
+
+  attach(target: InputEventTargetLike): void {
+    if (this.attachedTargets.has(target)) {
+      return;
+    }
+
+    const onKeyDown = ((event: Event) => this.keyboard.keyDown(event as unknown as KeyboardEventLike)) as EventListener;
+    const onKeyUp = ((event: Event) => this.keyboard.keyUp(event as unknown as KeyboardEventLike)) as EventListener;
+    const onPointerMove = ((event: Event) => this.pointer.move(event as unknown as PointerEventLike)) as EventListener;
+    const onPointerDown = ((event: Event) => this.pointer.down(event as unknown as PointerEventLike)) as EventListener;
+    const onPointerUp = ((event: Event) => this.pointer.up(event as unknown as PointerEventLike)) as EventListener;
+    const onWheel = ((event: Event) => this.pointer.wheel(event as unknown as WheelEventLike)) as EventListener;
+    const onBlur = (() => {
+      this.keyboard.blur();
+      this.pointer.blur();
+    }) as EventListener;
+
+    const listeners: Array<readonly [string, EventListener]> = [
+      ["keydown", onKeyDown],
+      ["keyup", onKeyUp],
+      ["pointermove", onPointerMove],
+      ["pointerdown", onPointerDown],
+      ["pointerup", onPointerUp],
+      ["wheel", onWheel],
+      ["blur", onBlur]
+    ];
+
+    const disposers: Array<() => void> = [];
+    for (const [type, listener] of listeners) {
+      target.addEventListener(type, listener);
+      disposers.push(() => target.removeEventListener(type, listener));
+    }
+    this.attachedTargets.set(target, disposers);
+  }
+
+  update(gamepads: readonly (GamepadLike | null | undefined)[] = []): InputSnapshot {
+    const keyboard = this.keyboard.snapshotSets();
+    const pointer = this.pointer.snapshotData();
+    this.snapshotRef = new InputSnapshot({
+      ...keyboard,
+      ...pointer,
+      gamepads: this.gamepads.poll(gamepads)
+    });
+    this.actions.useSnapshot(this.snapshotRef);
+    return this.snapshotRef;
+  }
+
+  endFrame(): void {
+    this.keyboard.endFrame();
+    this.pointer.endFrame();
+  }
+
+  dispose(): void {
+    for (const disposers of this.attachedTargets.values()) {
+      while (disposers.length > 0) {
+        disposers.pop()?.();
+      }
+    }
+    this.attachedTargets.clear();
+    this.keyboard.blur();
+    this.pointer.blur();
+  }
+}

package/src/InteractionSystem.ts

@@ -0,0 +1,119 @@
+import type { Ray } from "@aura3d/math";
+import type { SceneNode } from "@aura3d/scene";
+import type { InputSnapshot } from "./InputSnapshot";
+
+type Tuple3 = readonly [number, number, number];
+
+export interface InteractionBounds {
+  readonly min: Tuple3;
+  readonly max: Tuple3;
+}
+
+export interface InteractionTarget {
+  readonly id: string;
+  readonly node?: SceneNode;
+  readonly bounds: InteractionBounds;
+}
+
+export interface InteractionHit {
+  readonly target: InteractionTarget;
+  readonly distance: number;
+}
+
+export type InteractionEventType = "hover-enter" | "hover-exit" | "pointer-down" | "drag-start" | "drag" | "drag-end" | "click";
+
+export interface InteractionEvent {
+  readonly type: InteractionEventType;
+  readonly hit?: InteractionHit;
+  readonly target?: InteractionTarget;
+  readonly snapshot: InputSnapshot;
+}
+
+export type InteractionListener = (event: InteractionEvent) => void;
+export type InteractionRayProvider = (snapshot: InputSnapshot) => Ray;
+export type InteractionTargetProvider = () => readonly InteractionTarget[];
+
+export class InteractionSystem {
+  private readonly listeners = new Set<InteractionListener>();
+  private hovered?: InteractionTarget;
+  private pressed?: InteractionTarget;
+  private dragging = false;
+
+  constructor(
+    private readonly rayProvider: InteractionRayProvider,
+    private readonly targetProvider: InteractionTargetProvider
+  ) {}
+
+  subscribe(listener: InteractionListener): () => void {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+
+  update(snapshot: InputSnapshot): InteractionHit | undefined {
+    const hit = this.pick(this.rayProvider(snapshot));
+    const target = hit?.target;
+
+    if (this.hovered?.id !== target?.id) {
+      if (this.hovered) this.emit({ type: "hover-exit", target: this.hovered, snapshot });
+      if (target) this.emit({ type: "hover-enter", hit, target, snapshot });
+      this.hovered = target;
+    }
+
+    if (snapshot.button(0).pressed && target) {
+      this.pressed = target;
+      this.dragging = false;
+      this.emit({ type: "pointer-down", hit, target, snapshot });
+    }
+
+    if (this.pressed && snapshot.button(0).down && (snapshot.pointer.deltaX !== 0 || snapshot.pointer.deltaY !== 0)) {
+      this.emit({ type: this.dragging ? "drag" : "drag-start", hit, target: this.pressed, snapshot });
+      this.dragging = true;
+    }
+
+    if (this.pressed && snapshot.button(0).released) {
+      this.emit({ type: this.dragging ? "drag-end" : "click", hit, target: this.pressed, snapshot });
+      this.pressed = undefined;
+      this.dragging = false;
+    }
+
+    return hit;
+  }
+
+  pick(ray: Ray): InteractionHit | undefined {
+    const hits = this.targetProvider()
+      .map((target) => ({ target, distance: intersectBounds(ray, target.bounds) }))
+      .filter((hit): hit is InteractionHit => hit.distance !== undefined)
+      .sort((a, b) => a.distance - b.distance);
+    return hits[0];
+  }
+
+  private emit(event: InteractionEvent): void {
+    for (const listener of [...this.listeners]) listener(event);
+  }
+}
+
+function intersectBounds(ray: Ray, bounds: InteractionBounds): number | undefined {
+  let tmin = Number.NEGATIVE_INFINITY;
+  let tmax = Number.POSITIVE_INFINITY;
+
+  for (const axis of [0, 1, 2] as const) {
+    const origin = axis === 0 ? ray.origin.x : axis === 1 ? ray.origin.y : ray.origin.z;
+    const direction = axis === 0 ? ray.direction.x : axis === 1 ? ray.direction.y : ray.direction.z;
+    const min = bounds.min[axis];
+    const max = bounds.max[axis];
+    if (Math.abs(direction) < 1e-8) {
+      if (origin < min || origin > max) return undefined;
+      continue;
+    }
+    const invD = 1 / direction;
+    let near = (min - origin) * invD;
+    let far = (max - origin) * invD;
+    if (near > far) [near, far] = [far, near];
+    tmin = Math.max(tmin, near);
+    tmax = Math.min(tmax, far);
+    if (tmin > tmax) return undefined;
+  }
+
+  const distance = tmin >= 0 ? tmin : tmax;
+  return distance >= 0 ? distance : undefined;
+}

package/src/KeyboardDevice.ts

@@ -0,0 +1,32 @@
+export interface KeyboardEventLike {
+  readonly code: string;
+  readonly repeat?: boolean;
+  preventDefault?(): void;
+}
+
+export class KeyboardDevice {
+  private current = new Set<string>();
+  private previous = new Set<string>();
+
+  keyDown(event: KeyboardEventLike): void {
+    if (!event.repeat) {
+      this.current.add(event.code);
+    }
+  }
+
+  keyUp(event: KeyboardEventLike): void {
+    this.current.delete(event.code);
+  }
+
+  blur(): void {
+    this.current.clear();
+  }
+
+  snapshotSets(): { readonly keys: ReadonlySet<string>; readonly previousKeys: ReadonlySet<string> } {
+    return { keys: new Set(this.current), previousKeys: new Set(this.previous) };
+  }
+
+  endFrame(): void {
+    this.previous = new Set(this.current);
+  }
+}

package/src/PickingRay.ts

@@ -0,0 +1,49 @@
+import { Ray, Vector3 } from "@aura3d/math";
+import { invertMat4, type Camera } from "@aura3d/scene";
+
+type Tuple3 = readonly [number, number, number];
+type TupleMat4 = readonly [
+  number, number, number, number,
+  number, number, number, number,
+  number, number, number, number,
+  number, number, number, number
+];
+
+export interface PickingRayViewport {
+  readonly x: number;
+  readonly y: number;
+  readonly width: number;
+  readonly height: number;
+}
+
+export function pickingRayFromCamera(
+  camera: Camera,
+  screenX: number,
+  screenY: number,
+  viewport: PickingRayViewport = camera.viewport
+): Ray {
+  camera.updateCameraMatrices();
+  const ndcX = ((screenX - viewport.x) / viewport.width) * 2 - 1;
+  const ndcY = 1 - ((screenY - viewport.y) / viewport.height) * 2;
+  const inverseViewProjection = invertMat4(camera.viewProjectionMatrix) as TupleMat4;
+  const near = transformClip(inverseViewProjection, [ndcX, ndcY, -1]);
+  const far = transformClip(inverseViewProjection, [ndcX, ndcY, 1]);
+  return new Ray(toVector3(near), toVector3(far).subtract(toVector3(near)));
+}
+
+function transformClip(matrix: TupleMat4, point: Tuple3): Tuple3 {
+  const x = point[0];
+  const y = point[1];
+  const z = point[2];
+  const w = matrix[3] * x + matrix[7] * y + matrix[11] * z + matrix[15];
+  const invW = Math.abs(w) <= 1e-8 ? 1 : 1 / w;
+  return [
+    (matrix[0] * x + matrix[4] * y + matrix[8] * z + matrix[12]) * invW,
+    (matrix[1] * x + matrix[5] * y + matrix[9] * z + matrix[13]) * invW,
+    (matrix[2] * x + matrix[6] * y + matrix[10] * z + matrix[14]) * invW
+  ];
+}
+
+function toVector3(value: Tuple3): Vector3 {
+  return new Vector3(value[0], value[1], value[2]);
+}

package/src/PointerDevice.ts

@@ -0,0 +1,102 @@
+import type { PointerTouch } from "./InputSnapshot";
+
+export interface PointerEventLike {
+  readonly clientX: number;
+  readonly clientY: number;
+  readonly button?: number;
+  readonly buttons?: number;
+  readonly pointerId?: number;
+  preventDefault?(): void;
+}
+
+export interface WheelEventLike {
+  readonly deltaX: number;
+  readonly deltaY: number;
+  preventDefault?(): void;
+}
+
+export class PointerDevice {
+  x = 0;
+  y = 0;
+  deltaX = 0;
+  deltaY = 0;
+  wheelX = 0;
+  wheelY = 0;
+
+  private readonly buttons = new Set<number>();
+  private previousButtons = new Set<number>();
+  private readonly touches = new Map<number, PointerTouch>();
+  private pixelRatio = 1;
+
+  setDevicePixelRatio(value: number): void {
+    if (!Number.isFinite(value) || value <= 0) {
+      throw new Error("Device pixel ratio must be positive");
+    }
+    this.pixelRatio = value;
+  }
+
+  move(event: PointerEventLike): void {
+    const nextX = event.clientX * this.pixelRatio;
+    const nextY = event.clientY * this.pixelRatio;
+    this.deltaX += nextX - this.x;
+    this.deltaY += nextY - this.y;
+    this.x = nextX;
+    this.y = nextY;
+
+    if (event.pointerId !== undefined) {
+      this.touches.set(event.pointerId, { id: event.pointerId, x: this.x, y: this.y });
+    }
+  }
+
+  down(event: PointerEventLike): void {
+    this.move(event);
+    this.buttons.add(event.button ?? 0);
+  }
+
+  up(event: PointerEventLike): void {
+    this.move(event);
+    this.buttons.delete(event.button ?? 0);
+    if (event.pointerId !== undefined) {
+      this.touches.delete(event.pointerId);
+    }
+  }
+
+  wheel(event: WheelEventLike): void {
+    this.wheelX += event.deltaX;
+    this.wheelY += event.deltaY;
+  }
+
+  blur(): void {
+    this.buttons.clear();
+    this.touches.clear();
+  }
+
+  snapshotData() {
+    const buttonMap = new Map<number, { down: boolean; pressed: boolean; released: boolean }>();
+    for (const button of this.buttons) {
+      buttonMap.set(button, { down: true, pressed: false, released: false });
+    }
+
+    return {
+      pointer: {
+        x: this.x,
+        y: this.y,
+        deltaX: this.deltaX,
+        deltaY: this.deltaY,
+        wheelX: this.wheelX,
+        wheelY: this.wheelY,
+        buttons: buttonMap,
+        touches: [...this.touches.values()]
+      },
+      previousPointerButtons: new Set(this.previousButtons)
+    };
+  }
+
+  endFrame(): void {
+    this.previousButtons = new Set(this.buttons);
+    this.deltaX = 0;
+    this.deltaY = 0;
+    this.wheelX = 0;
+    this.wheelY = 0;
+  }
+}

package/src/VirtualTouchControls.ts

@@ -0,0 +1,169 @@
+export interface VirtualJoystickConfig {
+  readonly center: readonly [number, number];
+  readonly radius: number;
+  readonly deadZone?: number;
+  readonly maxDistance?: number;
+  readonly fixed?: boolean;
+  readonly returnToCenter?: boolean;
+}
+
+export interface VirtualTouchPoint {
+  readonly id: number;
+  readonly x: number;
+  readonly y: number;
+}
+
+export interface VirtualTouchJoystickSnapshot {
+  readonly source: "origin-master-touch-joystick-virtual-input-adapted";
+  readonly active: boolean;
+  readonly activeTouchId: number | null;
+  readonly center: readonly [number, number];
+  readonly stick: readonly [number, number];
+  readonly value: readonly [number, number];
+  readonly magnitude: number;
+  readonly deadZone: number;
+  readonly consumedTouches: number;
+  readonly evidence: {
+    readonly oldCodebasePort: true;
+    readonly virtualJoystick: boolean;
+    readonly deadZone: boolean;
+    readonly clampedMagnitude: boolean;
+    readonly returnToCenter: boolean;
+    readonly floatingCenter: boolean;
+  };
+}
+
+export class VirtualTouchJoystick {
+  private readonly initialCenter: readonly [number, number];
+  private readonly radius: number;
+  private readonly deadZone: number;
+  private readonly maxDistance: number;
+  private readonly fixed: boolean;
+  private readonly returnToCenter: boolean;
+  private centerRef: readonly [number, number];
+  private stickRef: readonly [number, number];
+  private valueRef: readonly [number, number] = [0, 0];
+  private activeTouchId: number | null = null;
+  private active = false;
+  private consumedTouches = 0;
+
+  constructor(config: VirtualJoystickConfig) {
+    this.initialCenter = config.center;
+    this.centerRef = config.center;
+    this.stickRef = config.center;
+    this.radius = positive(config.radius, 64);
+    this.deadZone = clamp(config.deadZone ?? 0.15, 0, 0.95);
+    this.maxDistance = positive(config.maxDistance, this.radius * 0.8);
+    this.fixed = config.fixed ?? true;
+    this.returnToCenter = config.returnToCenter ?? true;
+  }
+
+  touchStart(touch: VirtualTouchPoint): boolean {
+    if (this.activeTouchId !== null) return false;
+    if (distance([touch.x, touch.y], this.centerRef) > this.radius) return false;
+    this.activeTouchId = touch.id;
+    this.active = true;
+    this.consumedTouches += 1;
+    if (!this.fixed) this.centerRef = [touch.x, touch.y];
+    this.updateStick([touch.x, touch.y]);
+    return true;
+  }
+
+  touchMove(touch: VirtualTouchPoint): boolean {
+    if (touch.id !== this.activeTouchId) return false;
+    this.updateStick([touch.x, touch.y]);
+    return true;
+  }
+
+  touchEnd(touch: VirtualTouchPoint): boolean {
+    if (touch.id !== this.activeTouchId) return false;
+    this.activeTouchId = null;
+    this.active = false;
+    if (this.returnToCenter) {
+      this.stickRef = this.centerRef;
+      this.valueRef = [0, 0];
+    }
+    if (!this.fixed) this.centerRef = this.initialCenter;
+    return true;
+  }
+
+  snapshot(): VirtualTouchJoystickSnapshot {
+    return {
+      source: "origin-master-touch-joystick-virtual-input-adapted",
+      active: this.active,
+      activeTouchId: this.activeTouchId,
+      center: [round(this.centerRef[0]), round(this.centerRef[1])],
+      stick: [round(this.stickRef[0]), round(this.stickRef[1])],
+      value: [round(this.valueRef[0]), round(this.valueRef[1])],
+      magnitude: round(Math.hypot(this.valueRef[0], this.valueRef[1])),
+      deadZone: this.deadZone,
+      consumedTouches: this.consumedTouches,
+      evidence: {
+        oldCodebasePort: true,
+        virtualJoystick: true,
+        deadZone: true,
+        clampedMagnitude: Math.hypot(this.valueRef[0], this.valueRef[1]) <= 1.0001,
+        returnToCenter: this.returnToCenter,
+        floatingCenter: !this.fixed
+      }
+    };
+  }
+
+  private updateStick(touch: readonly [number, number]): void {
+    const dx = touch[0] - this.centerRef[0];
+    const dy = touch[1] - this.centerRef[1];
+    const rawDistance = Math.hypot(dx, dy);
+    if (rawDistance === 0) {
+      this.stickRef = this.centerRef;
+      this.valueRef = [0, 0];
+      return;
+    }
+    const clampedDistance = Math.min(rawDistance, this.maxDistance);
+    const nx = dx / rawDistance;
+    const ny = dy / rawDistance;
+    this.stickRef = [this.centerRef[0] + nx * clampedDistance, this.centerRef[1] + ny * clampedDistance];
+    const normalized = clampedDistance / this.maxDistance;
+    if (normalized < this.deadZone) {
+      this.valueRef = [0, 0];
+      return;
+    }
+    const remapped = Math.min(1, (normalized - this.deadZone) / (1 - this.deadZone));
+    this.valueRef = [nx * remapped, ny * remapped];
+  }
+}
+
+export function sampleVirtualTouchJoystickFixture(): {
+  readonly active: VirtualTouchJoystickSnapshot;
+  readonly released: VirtualTouchJoystickSnapshot;
+} {
+  const joystick = new VirtualTouchJoystick({
+    center: [96, 420],
+    radius: 72,
+    deadZone: 0.2,
+    maxDistance: 56,
+    fixed: false,
+    returnToCenter: true
+  });
+  joystick.touchStart({ id: 7, x: 90, y: 416 });
+  joystick.touchMove({ id: 7, x: 154, y: 376 });
+  const active = joystick.snapshot();
+  joystick.touchEnd({ id: 7, x: 154, y: 376 });
+  return { active, released: joystick.snapshot() };
+}
+
+function positive(value: unknown, fallback: number): number {
+  const number = Number(value);
+  return Number.isFinite(number) && number > 0 ? number : fallback;
+}
+
+function distance(a: readonly [number, number], b: readonly [number, number]): number {
+  return Math.hypot(a[0] - b[0], a[1] - b[1]);
+}
+
+function clamp(value: number, min: number, max: number): number {
+  return Math.max(min, Math.min(max, value));
+}
+
+function round(value: number): number {
+  return Number(value.toFixed(4));
+}