@downdraft/engine 0.0.0 → 0.1.0

package/core/src/input/multi-sab-bridge.ts

@@ -0,0 +1,276 @@
+import { MultiInputChannel, type MultiInputChannelInstance, createMultiInputChannel } from "../sab/multi-input-channel";
+import type { FieldLayout, SlotSectionLayout } from "../sab/types";
+import { MultiInputState } from "./multi-state";
+import { InputState } from "./state";
+
+interface FieldIndices {
+  keysIdx: number;
+  keysCount: number;
+  mouseXIdx: number;
+  mouseYIdx: number;
+  mouseDeltaXIdx: number;
+  mouseDeltaYIdx: number;
+  mouseButtonsIdx: number;
+  wheelDeltaIdx: number;
+  gamepadButtonsIdx: number;
+  gamepadAxesIdx: number;
+  gamepadSlotIdx: number;
+  flagsIdx: number;
+}
+
+function extractFieldIndices(sectionLayout: SlotSectionLayout): FieldIndices {
+  const f = (name: string): FieldLayout => sectionLayout.fields[name];
+  return {
+    keysIdx: f("keys").index,
+    keysCount: f("keys").count,
+    mouseXIdx: f("mouseX").index,
+    mouseYIdx: f("mouseY").index,
+    mouseDeltaXIdx: f("mouseDeltaX").index,
+    mouseDeltaYIdx: f("mouseDeltaY").index,
+    mouseButtonsIdx: f("mouseButtons").index,
+    wheelDeltaIdx: f("wheelDelta").index,
+    gamepadButtonsIdx: f("gamepadButtons").index,
+    gamepadAxesIdx: f("gamepadAxes").index,
+    gamepadSlotIdx: f("gamepadSlot").index,
+    flagsIdx: f("flags").index,
+  };
+}
+
+export class MultiInputSABBridge {
+  private reader: ReturnType<MultiInputChannelInstance["reader"]>;
+  private state: MultiInputState;
+  private maxPlayers: number;
+  private prevKeys: Set<number>[];
+  private indices: FieldIndices;
+
+  constructor(sab: SharedArrayBuffer, state: MultiInputState, channel?: MultiInputChannelInstance) {
+    const ch = channel ?? MultiInputChannel;
+    this.reader = ch.reader(sab);
+    this.state = state;
+    this.maxPlayers = state.getMaxPlayers();
+    this.prevKeys = [];
+    for (let i = 0; i < this.maxPlayers; i++) {
+      this.prevKeys.push(new Set());
+    }
+    const sectionLayout = ch.layout.sections?.[0];
+    if (!sectionLayout) throw new Error("MultiInputChannel has no sections");
+    this.indices = extractFieldIndices(sectionLayout);
+  }
+
+  poll(): void {
+    const sections = this.reader.sections;
+    if (!sections) return;
+    const players = sections["players"];
+    if (!players) return;
+
+    for (let p = 0; p < this.maxPlayers; p++) {
+      const slot = players.slot(p);
+      const playerState = this.state.getPlayerState(p);
+
+      this.pollKeys(slot, playerState, p);
+      this.pollMouse(slot, playerState);
+      this.pollGamepad(slot, playerState);
+    }
+  }
+
+  private pollKeys(slot: { i32: Int32Array }, state: InputState, playerIdx: number): void {
+    const { keysIdx, keysCount } = this.indices;
+    const keysView = slot.i32;
+    const incoming = new Set<number>();
+    for (let i = 0; i < keysCount; i++) {
+      const val = Atomics.load(keysView, keysIdx + i);
+      if (val !== 0) {
+        for (let bit = 0; bit < 32; bit++) {
+          if (val & (1 << bit)) {
+            incoming.add(i * 32 + bit);
+          }
+        }
+      }
+    }
+
+    const prev = this.prevKeys[playerIdx];
+    for (const code of incoming.values()) {
+      if (!prev.has(code)) {
+        state.keyDown(code);
+      }
+    }
+    for (const code of prev.values()) {
+      if (!incoming.has(code)) {
+        state.keyUp(code);
+      }
+    }
+    prev.clear();
+    for (const code of incoming.values()) prev.add(code);
+  }
+
+  private pollMouse(slot: { f32: Float32Array; i32: Int32Array }, state: InputState): void {
+    const f32 = slot.f32;
+    const i32 = slot.i32;
+    const idx = this.indices;
+
+    const mouseX = f32[idx.mouseXIdx];
+    const mouseY = f32[idx.mouseYIdx];
+    const mouseDeltaX = f32[idx.mouseDeltaXIdx];
+    const mouseDeltaY = f32[idx.mouseDeltaYIdx];
+    state.mouseMove(mouseX, mouseY, mouseDeltaX, mouseDeltaY);
+
+    const wheelDelta = f32[idx.wheelDeltaIdx];
+    if (wheelDelta !== 0) {
+      state.wheel(wheelDelta);
+    }
+
+    for (let i = 0; i < 3; i++) {
+      const pressed = Atomics.load(i32, idx.mouseButtonsIdx + i) !== 0;
+      if (pressed && !state.mouseButtons.has(i)) {
+        state.mouseDown(i);
+      } else if (!pressed && state.mouseButtons.has(i)) {
+        state.mouseUp(i);
+      }
+    }
+  }
+
+  private pollGamepad(slot: { i32: Int32Array; u32: Uint32Array; f32: Float32Array }, state: InputState): void {
+    const u32 = slot.u32;
+    const f32 = slot.f32;
+    const idx = this.indices;
+
+    // gamepadButtons is a u32 pair [lo, hi] — W3C standard button order.
+    const lo = Atomics.load(u32, idx.gamepadButtonsIdx) >>> 0;
+    const hi = Atomics.load(u32, idx.gamepadButtonsIdx + 1) >>> 0;
+    const incomingGamepad = new Set<number>();
+    for (let b = 0; b < 32; b++) {
+      if (lo & (1 << b)) incomingGamepad.add(b);
+      if (hi & (1 << b)) incomingGamepad.add(32 + b);
+    }
+    for (const btn of incomingGamepad.values()) {
+      state.gamepadButtons.add(btn);
+    }
+    for (const btn of state.gamepadButtons.values()) {
+      if (!incomingGamepad.has(btn)) {
+        state.gamepadButtons.delete(btn);
+      }
+    }
+
+    const axes = f32.subarray(idx.gamepadAxesIdx, idx.gamepadAxesIdx + 8);
+    for (let i = 0; i < axes.length && i < state.gamepadAxes.length; i++) {
+      state.gamepadAxes[i] = axes[i];
+    }
+  }
+}
+
+export class MultiInputSABWriter {
+  private writer: ReturnType<MultiInputChannelInstance["writer"]>;
+  private maxPlayers: number;
+  private indices: FieldIndices;
+
+  constructor(sab: SharedArrayBuffer, channel?: MultiInputChannelInstance) {
+    const ch = channel ?? MultiInputChannel;
+    this.writer = ch.writer(sab);
+    this.maxPlayers = ch.def.sections?.[0]?.maxSlots ?? 8;
+    const sectionLayout = ch.layout.sections?.[0];
+    if (!sectionLayout) throw new Error("MultiInputChannel has no sections");
+    this.indices = extractFieldIndices(sectionLayout);
+  }
+
+  /**
+   * Write one player's input snapshot.
+   *
+   * `gamepadButtons` is the u32 bitmask pair `[lo, hi]` (W3C standard button
+   * order, see GP_BTN_* in ../sab/gamepad-devices.ts) — NOT a per-button 0/1
+   * array. `gamepadAxes` is the 8-axis state (lx ly rx ry lt rt dpadX dpadY).
+   * `gamepadSlot` binds the player to a slot in the 'gamepad-devices'
+   * channel (0xFF = unbound).
+   */
+  writePlayerInput(
+    playerIdx: number,
+    keys: number[],
+    mouseX: number,
+    mouseY: number,
+    mouseDeltaX: number,
+    mouseDeltaY: number,
+    mouseButtons: number[],
+    wheelDelta: number,
+    gamepadButtons: number[],
+    gamepadAxes: number[],
+    gamepadSlot = 0xff,
+  ): void {
+    if (playerIdx < 0 || playerIdx >= this.maxPlayers) return;
+    const sections = this.writer.sections;
+    if (!sections) return;
+    const players = sections["players"];
+    if (!players) return;
+
+    const slot = players.slot(playerIdx);
+    const i32 = slot.i32;
+    const f32 = slot.f32;
+    const idx = this.indices;
+
+    const fillEnd = idx.keysIdx + idx.keysCount;
+    if (idx.keysIdx < 0 || fillEnd > i32.length) {
+      throw new RangeError(`MultiInputSABWriter: keys range [${idx.keysIdx}, ${fillEnd}) exceeds i32 buffer length ${i32.length}`);
+    }
+    i32.fill(0, idx.keysIdx, fillEnd);
+    for (let _i = 0, _it = keys, _n = _it.length; _i < _n; _i++) { const key = _it[_i];
+      if (key < 0 || !Number.isInteger(key)) continue;
+      const wordIdx = Math.floor(key / 32);
+      const bitIdx = key % 32;
+      if (wordIdx >= 0 && wordIdx < idx.keysCount) {
+        i32[idx.keysIdx + wordIdx] |= (1 << bitIdx);
+      }
+    }
+
+    f32[idx.mouseXIdx] = mouseX;
+    f32[idx.mouseYIdx] = mouseY;
+    f32[idx.mouseDeltaXIdx] = mouseDeltaX;
+    f32[idx.mouseDeltaYIdx] = mouseDeltaY;
+
+    for (let i = 0; i < 3; i++) {
+      Atomics.store(i32, idx.mouseButtonsIdx + i, i < mouseButtons.length ? mouseButtons[i] : 0);
+    }
+
+    f32[idx.wheelDeltaIdx] = wheelDelta;
+
+    Atomics.store(i32, idx.gamepadButtonsIdx, gamepadButtons[0] ?? 0);
+    Atomics.store(i32, idx.gamepadButtonsIdx + 1, gamepadButtons[1] ?? 0);
+    for (let i = 0; i < 8; i++) {
+      f32[idx.gamepadAxesIdx + i] = i < gamepadAxes.length ? gamepadAxes[i] : 0;
+    }
+    slot.u32[idx.gamepadSlotIdx] = gamepadSlot;
+
+    this.writer.bumpSequence();
+  }
+
+  clearPlayer(playerIdx: number): void {
+    if (playerIdx < 0 || playerIdx >= this.maxPlayers) return;
+    const sections = this.writer.sections;
+    if (!sections) return;
+    const players = sections["players"];
+    if (!players) return;
+
+    const slot = players.slot(playerIdx);
+    slot.i32.fill(0);
+    slot.f32.fill(0);
+    this.writer.bumpSequence();
+  }
+
+  bumpSequence(): void {
+    this.writer.bumpSequence();
+  }
+}
+
+export function createMultiInputBridge(
+  sab: SharedArrayBuffer,
+  state: MultiInputState,
+  channel?: MultiInputChannelInstance,
+): MultiInputSABBridge {
+  return new MultiInputSABBridge(sab, state, channel);
+}
+
+export function createMultiInputWriter(
+  sab: SharedArrayBuffer,
+  channel?: MultiInputChannelInstance,
+): MultiInputSABWriter {
+  return new MultiInputSABWriter(sab, channel);
+}
+
+export { createMultiInputChannel };

package/core/src/input/multi-state.ts

@@ -0,0 +1,54 @@
+import { InputState } from "./state";
+
+export class MultiInputState {
+  private states: InputState[];
+  private maxPlayers: number;
+
+  constructor(maxPlayers: number = 8) {
+    this.maxPlayers = maxPlayers;
+    this.states = [];
+    for (let i = 0; i < maxPlayers; i++) {
+      this.states.push(new InputState());
+    }
+  }
+
+  getPlayerState(idx: number): InputState {
+    if (idx < 0 || idx >= this.maxPlayers) {
+      return this.states[0];
+    }
+    return this.states[idx];
+  }
+
+  getMaxPlayers(): number {
+    return this.maxPlayers;
+  }
+
+  endFrame(): void {
+    for (let i = 0; i < this.states.length; i++) {
+      this.states[i].endFrame();
+    }
+  }
+
+  resetPlayer(idx: number): void {
+    if (idx >= 0 && idx < this.maxPlayers) {
+      const s = this.states[idx];
+      s.keys.clear();
+      s.keysPressed.clear();
+      s.keysReleased.clear();
+      s.mouseButtons.clear();
+      s.mouseButtonsPressed.clear();
+      s.mouseButtonsReleased.clear();
+      s.gamepadButtons.clear();
+      s.mouseDeltaX = 0;
+      s.mouseDeltaY = 0;
+      s.wheelDelta = 0;
+      for (let i = 0; i < s.gamepadAxes.length; i++) s.gamepadAxes[i] = 0;
+    }
+  }
+
+  resetAll(): void {
+    for (let i = 0; i < this.maxPlayers; i++) {
+      this.resetPlayer(i);
+    }
+  }
+}

package/core/src/input/sab-bridge.ts

@@ -0,0 +1,71 @@
+import { CoreInputChannel } from "../sab/core-input-channel";
+import { InputState } from "./state";
+
+export class InputSABBridge {
+  private reader: ReturnType<typeof CoreInputChannel.reader>;
+  private state: InputState;
+
+  constructor(sab: SharedArrayBuffer, state: InputState) {
+    this.reader = CoreInputChannel.reader(sab);
+    this.state = state;
+  }
+
+  poll(): void {
+    const data = this.reader.snapshot();
+    if (!data) return;
+
+    const keys = data.keys as number[];
+    const mouseX = data.mouseX as number;
+    const mouseY = data.mouseY as number;
+    const mouseDeltaX = data.mouseDeltaX as number;
+    const mouseDeltaY = data.mouseDeltaY as number;
+    const mouseButtons = data.mouseButtons as number[];
+    const wheelDelta = data.wheelDelta as number;
+    const gamepadButtons = data.gamepadButtons as number[];
+    const gamepadAxes = data.gamepadAxes as number[];
+
+    // Process keyboard — diff against current state
+    const incomingKeys = new Set(keys.filter((k) => k !== 0));
+    for (const code of incomingKeys.values()) {
+      if (!this.state.isKeyDown(code)) {
+        this.state.keyDown(code);
+      }
+    }
+    for (const code of this.state.keys.values()) {
+      if (!incomingKeys.has(code)) {
+        this.state.keyUp(code);
+      }
+    }
+
+    this.state.mouseMove(mouseX, mouseY, mouseDeltaX, mouseDeltaY);
+    this.state.wheel(wheelDelta);
+
+    for (let i = 0; i < mouseButtons.length; i++) {
+      if (mouseButtons[i] && !this.state.mouseButtons.has(i)) {
+        this.state.mouseDown(i);
+      } else if (!mouseButtons[i] && this.state.mouseButtons.has(i)) {
+        this.state.mouseUp(i);
+      }
+    }
+
+    // gamepadButtons is the u32 bitmask pair [lo, hi] (W3C standard order).
+    const lo = (gamepadButtons[0] ?? 0) >>> 0;
+    const hi = (gamepadButtons[1] ?? 0) >>> 0;
+    const incomingGamepad = new Set<number>();
+    for (let b = 0; b < 32; b++) {
+      if (lo & (1 << b)) incomingGamepad.add(b);
+      if (hi & (1 << b)) incomingGamepad.add(32 + b);
+    }
+    for (const btn of incomingGamepad.values()) {
+      this.state.gamepadButtons.add(btn);
+    }
+    for (const btn of this.state.gamepadButtons.values()) {
+      if (!incomingGamepad.has(btn)) {
+        this.state.gamepadButtons.delete(btn);
+      }
+    }
+    for (let i = 0; i < gamepadAxes.length && i < this.state.gamepadAxes.length; i++) {
+      this.state.gamepadAxes[i] = gamepadAxes[i];
+    }
+  }
+}

package/core/src/input/state.ts

@@ -0,0 +1,132 @@
+export enum InputContext {
+  Editor = 0,
+  Game = 1,
+  UI = 2,
+}
+
+export interface XRControllerState {
+  aimPosition: [number, number, number];
+  aimQuaternion: [number, number, number, number];
+  gripPosition: [number, number, number];
+  gripQuaternion: [number, number, number, number];
+  handedness: "left" | "right" | "none";
+}
+
+export class InputState {
+  keys: Set<number> = new Set();
+  keysPressed: Set<number> = new Set();
+  keysReleased: Set<number> = new Set();
+  mouseX: number = 0;
+  mouseY: number = 0;
+  mouseDeltaX: number = 0;
+  mouseDeltaY: number = 0;
+  mouseButtons: Set<number> = new Set();
+  mouseButtonsPressed: Set<number> = new Set();
+  mouseButtonsReleased: Set<number> = new Set();
+  wheelDelta: number = 0;
+  gamepadButtons: Set<number> = new Set();
+  /** lx ly rx ry lt rt dpadX dpadY (triggers are 0..1). */
+  gamepadAxes: number[] = [0, 0, 0, 0, 0, 0, 0, 0];
+  xrControllers: XRControllerState[] = [];
+
+  private context: InputContext = InputContext.Editor;
+  private contextLocked: boolean = false;
+
+  setContext(ctx: InputContext): void {
+    if (!this.contextLocked) {
+      this.context = ctx;
+    }
+  }
+
+  getContext(): InputContext {
+    return this.context;
+  }
+
+  lockContext(locked: boolean): void {
+    this.contextLocked = locked;
+  }
+
+  isKeyDown(code: number): boolean {
+    return this.keys.has(code);
+  }
+
+  wasKeyPressed(code: number): boolean {
+    return this.keysPressed.has(code);
+  }
+
+  wasKeyReleased(code: number): boolean {
+    return this.keysReleased.has(code);
+  }
+
+  isMouseDown(button: number): boolean {
+    return this.mouseButtons.has(button);
+  }
+
+  wasMousePressed(button: number): boolean {
+    return this.mouseButtonsPressed.has(button);
+  }
+
+  wasMouseReleased(button: number): boolean {
+    return this.mouseButtonsReleased.has(button);
+  }
+
+  action(mapping: Map<string, number[]>): (action: string) => boolean {
+    return (action: string) => {
+      const codes = mapping.get(action);
+      if (!codes) return false;
+      for (let i = 0; i < codes.length; i++) {
+        if (this.keys.has(codes[i])) return true;
+      }
+      return false;
+    };
+  }
+
+  endFrame(): void {
+    this.keysPressed.clear();
+    this.keysReleased.clear();
+    this.mouseButtonsPressed.clear();
+    this.mouseButtonsReleased.clear();
+    this.mouseDeltaX = 0;
+    this.mouseDeltaY = 0;
+    this.wheelDelta = 0;
+  }
+
+  keyDown(code: number): void {
+    if (!this.keys.has(code)) {
+      this.keysPressed.add(code);
+    }
+    this.keys.add(code);
+  }
+
+  keyUp(code: number): void {
+    if (this.keys.has(code)) {
+      this.keysReleased.add(code);
+    }
+    this.keys.delete(code);
+  }
+
+  mouseMove(x: number, y: number, deltaX: number, deltaY: number): void {
+    this.mouseX = x;
+    this.mouseY = y;
+    this.mouseDeltaX += deltaX;
+    this.mouseDeltaY += deltaY;
+  }
+
+  mouseDown(button: number): void {
+    if (!this.mouseButtons.has(button)) {
+      this.mouseButtonsPressed.add(button);
+    }
+    this.mouseButtons.add(button);
+  }
+
+  mouseUp(button: number): void {
+    if (this.mouseButtons.has(button)) {
+      this.mouseButtonsReleased.add(button);
+    }
+    this.mouseButtons.delete(button);
+  }
+
+  wheel(delta: number): void {
+    this.wheelDelta += delta;
+  }
+}

package/core/src/input/ui-router.ts

@@ -0,0 +1,87 @@
+// ============================================================================
+// UIInputRouter — UI-agnostic input router contract.
+//
+// The InputManager delivers window-level pointer/wheel/key events (already
+// converted to canvas backing-pixel coordinates) to the active UI router.
+// Concrete UI stacks subclass this: the Blitz/html-ui router forwards into the
+// wasm document; a stack with no pointer-interactive UI can use the base class
+// (which only tracks the pointer position).
+// ============================================================================
+
+import type { InputState } from "./state";
+
+export class UIInputRouter {
+  protected inputState: InputState | null = null;
+  protected lastMouseX = -1;
+  protected lastMouseY = -1;
+
+  /** Optional live input state — when set, update() syncs pointer tracking. */
+  setInputState(state: InputState | null): void {
+    this.inputState = state;
+  }
+
+  /** Last known pointer position in CSS pixels (-1,-1 before first event). */
+  getPointerPos(): [number, number] {
+    return [this.lastMouseX, this.lastMouseY];
+  }
+
+  /**
+   * True when the pointer is currently over an interactive UI element.
+   * Stacks override `hitTest`; the base class reports no hit.
+   */
+  isPointerOverUI(): boolean {
+    return this.lastMouseX >= 0 && this.hitTest(this.lastMouseX, this.lastMouseY);
+  }
+
+  /** Hit-test hook — override to consult the live UI document. */
+  protected hitTest(_x: number, _y: number): boolean {
+    return false;
+  }
+
+  /** Per-frame sync from InputState (used by InputContextRouter). */
+  update(): void {
+    const s = this.inputState;
+    if (!s) return;
+    const mx = s.mouseX;
+    const my = s.mouseY;
+    if (mx !== this.lastMouseX || my !== this.lastMouseY) {
+      this.handleMouseMove(mx, my);
+    }
+    if (s.wasMousePressed(0)) this.handleMouseDown(mx, my);
+    if (s.wasMouseReleased(0)) this.handleMouseUp(mx, my);
+  }
+
+  handleKeyDown(_code: number): void {}
+  handleKeyUp(_code: number): void {}
+  /** Printable character (text inputs). */
+  handleCharInput(_char: string): void {}
+
+  /**
+   * Wheel routing. Returns true when the UI consumed the event (suppresses
+   * page/canvas scroll handlers behind a scrollable panel).
+   */
+  handleWheel(_dx: number, _dy: number): boolean {
+    return false;
+  }
+
+  handleMouseMove(mx: number, my: number): void {
+    this.lastMouseX = mx;
+    this.lastMouseY = my;
+  }
+
+  handleMouseDown(mx: number, my: number): void {
+    this.lastMouseX = mx;
+    this.lastMouseY = my;
+  }
+
+  handleMouseUp(mx: number, my: number): void {
+    this.lastMouseX = mx;
+    this.lastMouseY = my;
+  }
+
+  /** Pointer left the canvas — clears pointer tracking. */
+  handlePointerLeave(): void {
+    this.lastMouseX = -1;
+    this.lastMouseY = -1;
+  }
+}