@downdraft/engine 0.1.1 → 0.1.2-alpha.5

package/dist/core/src/input/local-player-manager.js

@@ -0,0 +1,145 @@
+/** Inert default — reports no devices until a real source is installed
+ *  via setGamepadSource(). */
+const NULL_GAMEPAD_SOURCE = {
+    listConnected: () => [],
+    read: () => null,
+    onConnect: () => { },
+    onDisconnect: () => { },
+};
+export class LocalPlayerManager {
+    maxPlayers;
+    activePlayerCount = 1;
+    deviceMap = new Map();
+    writer = null;
+    keyState = new Set();
+    mouseX = 0;
+    mouseY = 0;
+    mouseDeltaX = 0;
+    mouseDeltaY = 0;
+    mouseButtons = [0, 0, 0];
+    wheelDelta = 0;
+    connectCallbacks = [];
+    disconnectCallbacks = [];
+    gamepadSource = null;
+    listening = false;
+    constructor(maxPlayers = 8) {
+        this.maxPlayers = maxPlayers;
+    }
+    setWriter(writer) {
+        this.writer = writer;
+    }
+    /**
+     * Install a gamepad producer (e.g. `SabGamepadSource` from
+     * libraries/gamepad). Until one is installed, an inert source reporting
+     * no devices is used.
+     */
+    setGamepadSource(source) {
+        this.gamepadSource?.dispose?.();
+        this.gamepadSource = source;
+        if (this.listening) {
+            source.onConnect((i) => this.emitConnect({ type: "gamepad", gamepadIndex: i }));
+            source.onDisconnect((i) => this.emitDisconnect({ type: "gamepad", gamepadIndex: i }));
+        }
+    }
+    getGamepadSource() {
+        if (!this.gamepadSource) {
+            this.gamepadSource = NULL_GAMEPAD_SOURCE;
+        }
+        return this.gamepadSource;
+    }
+    getActivePlayerCount() {
+        return this.activePlayerCount;
+    }
+    setActivePlayerCount(n) {
+        this.activePlayerCount = Math.max(1, Math.min(n, this.maxPlayers));
+    }
+    getMaxPlayers() {
+        return this.maxPlayers;
+    }
+    assignDevice(playerIdx, device) {
+        if (playerIdx < 0 || playerIdx >= this.maxPlayers)
+            return;
+        this.deviceMap.set(playerIdx, device);
+    }
+    autoAssign() {
+        this.deviceMap.clear();
+        this.assignDevice(0, { type: "keyboard-mouse" });
+        let playerIdx = 1;
+        for (const index of this.getGamepadSource().listConnected()) {
+            if (playerIdx >= this.maxPlayers)
+                break;
+            this.assignDevice(playerIdx, { type: "gamepad", gamepadIndex: index });
+            playerIdx++;
+        }
+        this.activePlayerCount = Math.max(1, playerIdx);
+    }
+    getDevice(playerIdx) {
+        return this.deviceMap.get(playerIdx);
+    }
+    getDeviceMap() {
+        return this.deviceMap;
+    }
+    onDeviceConnect(cb) {
+        this.connectCallbacks.push(cb);
+    }
+    onDeviceDisconnect(cb) {
+        this.disconnectCallbacks.push(cb);
+    }
+    emitConnect(device) {
+        for (const cb of this.connectCallbacks)
+            cb(device);
+    }
+    emitDisconnect(device) {
+        for (const cb of this.disconnectCallbacks)
+            cb(device);
+    }
+    startListening() {
+        if (this.listening)
+            return;
+        this.listening = true;
+        const src = this.getGamepadSource();
+        src.onConnect((i) => this.emitConnect({ type: "gamepad", gamepadIndex: i }));
+        src.onDisconnect((i) => this.emitDisconnect({ type: "gamepad", gamepadIndex: i }));
+    }
+    stopListening() {
+        // Sources own their listeners; LocalPlayerManager only flips its flag so
+        // a later setGamepadSource() re-wires. Sources are cheap to re-create.
+        this.listening = false;
+    }
+    setKeyboardState(keys) {
+        this.keyState = keys;
+    }
+    setMouseState(x, y, deltaX, deltaY, buttons, wheel) {
+        this.mouseX = x;
+        this.mouseY = y;
+        this.mouseDeltaX = deltaX;
+        this.mouseDeltaY = deltaY;
+        this.mouseButtons = buttons;
+        this.wheelDelta = wheel;
+    }
+    poll() {
+        if (!this.writer)
+            return;
+        for (let p = 0; p < this.activePlayerCount; p++) {
+            const device = this.deviceMap.get(p);
+            if (!device)
+                continue;
+            if (device.type === "keyboard-mouse") {
+                const keys = [];
+                for (const k of this.keyState.values())
+                    keys.push(k);
+                this.writer.writePlayerInput(p, keys, this.mouseX, this.mouseY, this.mouseDeltaX, this.mouseDeltaY, this.mouseButtons, this.wheelDelta, [], []);
+            }
+            else if (device.type === "gamepad") {
+                const src = this.getGamepadSource();
+                const snap = device.gamepadIndex !== undefined ? src.read(device.gamepadIndex) : null;
+                if (!snap)
+                    continue;
+                this.writer.writePlayerInput(p, [], 0, 0, 0, 0, [0, 0, 0], 0, [snap.buttonsLo, snap.buttonsHi], snap.axes, device.gamepadIndex);
+            }
+        }
+        this.mouseDeltaX = 0;
+        this.mouseDeltaY = 0;
+        this.wheelDelta = 0;
+    }
+}

package/dist/core/src/input/mapping.js

@@ -0,0 +1,36 @@
+export class InputMapping {
+    bindings = new Map();
+    state;
+    constructor(state) {
+        this.state = state;
+    }
+    bind(action, codes) {
+        this.bindings.set(action, codes);
+    }
+    unbind(action) {
+        this.bindings.delete(action);
+    }
+    isActionDown(action) {
+        const codes = this.bindings.get(action);
+        if (!codes)
+            return false;
+        for (let i = 0; i < codes.length; i++) {
+            if (this.state.isKeyDown(codes[i]))
+                return true;
+        }
+        return false;
+    }
+    wasActionPressed(action) {
+        const codes = this.bindings.get(action);
+        if (!codes)
+            return false;
+        for (let i = 0; i < codes.length; i++) {
+            if (this.state.wasKeyPressed(codes[i]))
+                return true;
+        }
+        return false;
+    }
+    getBindings() {
+        return this.bindings;
+    }
+}

package/dist/core/src/input/multi-sab-bridge.js

@@ -0,0 +1,224 @@
+import { MultiInputChannel, createMultiInputChannel } from "../sab/multi-input-channel.js";
+function extractFieldIndices(sectionLayout) {
+    const f = (name) => 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 {
+    reader;
+    state;
+    maxPlayers;
+    prevKeys;
+    indices;
+    constructor(sab, state, channel) {
+        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() {
+        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);
+        }
+    }
+    pollKeys(slot, state, playerIdx) {
+        const { keysIdx, keysCount } = this.indices;
+        const keysView = slot.i32;
+        const incoming = new Set();
+        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);
+    }
+    pollMouse(slot, state) {
+        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);
+            }
+        }
+    }
+    pollGamepad(slot, state) {
+        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();
+        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 {
+    writer;
+    maxPlayers;
+    indices;
+    constructor(sab, channel) {
+        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, keys, mouseX, mouseY, mouseDeltaX, mouseDeltaY, mouseButtons, wheelDelta, gamepadButtons, gamepadAxes, gamepadSlot = 0xff) {
+        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) {
+        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() {
+        this.writer.bumpSequence();
+    }
+}
+export function createMultiInputBridge(sab, state, channel) {
+    return new MultiInputSABBridge(sab, state, channel);
+}
+export function createMultiInputWriter(sab, channel) {
+    return new MultiInputSABWriter(sab, channel);
+}
+export { createMultiInputChannel };

package/dist/core/src/input/multi-state.js

@@ -0,0 +1,48 @@
+import { InputState } from "./state.js";
+export class MultiInputState {
+    states;
+    maxPlayers;
+    constructor(maxPlayers = 8) {
+        this.maxPlayers = maxPlayers;
+        this.states = [];
+        for (let i = 0; i < maxPlayers; i++) {
+            this.states.push(new InputState());
+        }
+    }
+    getPlayerState(idx) {
+        if (idx < 0 || idx >= this.maxPlayers) {
+            return this.states[0];
+        }
+        return this.states[idx];
+    }
+    getMaxPlayers() {
+        return this.maxPlayers;
+    }
+    endFrame() {
+        for (let i = 0; i < this.states.length; i++) {
+            this.states[i].endFrame();
+        }
+    }
+    resetPlayer(idx) {
+        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() {
+        for (let i = 0; i < this.maxPlayers; i++) {
+            this.resetPlayer(i);
+        }
+    }
+}

package/dist/core/src/input/sab-bridge.js

@@ -0,0 +1,66 @@
+import { CoreInputChannel } from "../sab/core-input-channel.js";
+export class InputSABBridge {
+    reader;
+    state;
+    constructor(sab, state) {
+        this.reader = CoreInputChannel.reader(sab);
+        this.state = state;
+    }
+    poll() {
+        const data = this.reader.snapshot();
+        if (!data)
+            return;
+        const keys = data.keys;
+        const mouseX = data.mouseX;
+        const mouseY = data.mouseY;
+        const mouseDeltaX = data.mouseDeltaX;
+        const mouseDeltaY = data.mouseDeltaY;
+        const mouseButtons = data.mouseButtons;
+        const wheelDelta = data.wheelDelta;
+        const gamepadButtons = data.gamepadButtons;
+        const gamepadAxes = data.gamepadAxes;
+        // 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();
+        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/dist/core/src/input/state.js

@@ -0,0 +1,108 @@
+export var InputContext;
+(function (InputContext) {
+    InputContext[InputContext["Editor"] = 0] = "Editor";
+    InputContext[InputContext["Game"] = 1] = "Game";
+    InputContext[InputContext["UI"] = 2] = "UI";
+})(InputContext || (InputContext = {}));
+export class InputState {
+    keys = new Set();
+    keysPressed = new Set();
+    keysReleased = new Set();
+    mouseX = 0;
+    mouseY = 0;
+    mouseDeltaX = 0;
+    mouseDeltaY = 0;
+    mouseButtons = new Set();
+    mouseButtonsPressed = new Set();
+    mouseButtonsReleased = new Set();
+    wheelDelta = 0;
+    gamepadButtons = new Set();
+    /** lx ly rx ry lt rt dpadX dpadY (triggers are 0..1). */
+    gamepadAxes = [0, 0, 0, 0, 0, 0, 0, 0];
+    xrControllers = [];
+    context = InputContext.Editor;
+    contextLocked = false;
+    setContext(ctx) {
+        if (!this.contextLocked) {
+            this.context = ctx;
+        }
+    }
+    getContext() {
+        return this.context;
+    }
+    lockContext(locked) {
+        this.contextLocked = locked;
+    }
+    isKeyDown(code) {
+        return this.keys.has(code);
+    }
+    wasKeyPressed(code) {
+        return this.keysPressed.has(code);
+    }
+    wasKeyReleased(code) {
+        return this.keysReleased.has(code);
+    }
+    isMouseDown(button) {
+        return this.mouseButtons.has(button);
+    }
+    wasMousePressed(button) {
+        return this.mouseButtonsPressed.has(button);
+    }
+    wasMouseReleased(button) {
+        return this.mouseButtonsReleased.has(button);
+    }
+    action(mapping) {
+        return (action) => {
+            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() {
+        this.keysPressed.clear();
+        this.keysReleased.clear();
+        this.mouseButtonsPressed.clear();
+        this.mouseButtonsReleased.clear();
+        this.mouseDeltaX = 0;
+        this.mouseDeltaY = 0;
+        this.wheelDelta = 0;
+    }
+    keyDown(code) {
+        if (!this.keys.has(code)) {
+            this.keysPressed.add(code);
+        }
+        this.keys.add(code);
+    }
+    keyUp(code) {
+        if (this.keys.has(code)) {
+            this.keysReleased.add(code);
+        }
+        this.keys.delete(code);
+    }
+    mouseMove(x, y, deltaX, deltaY) {
+        this.mouseX = x;
+        this.mouseY = y;
+        this.mouseDeltaX += deltaX;
+        this.mouseDeltaY += deltaY;
+    }
+    mouseDown(button) {
+        if (!this.mouseButtons.has(button)) {
+            this.mouseButtonsPressed.add(button);
+        }
+        this.mouseButtons.add(button);
+    }
+    mouseUp(button) {
+        if (this.mouseButtons.has(button)) {
+            this.mouseButtonsReleased.add(button);
+        }
+        this.mouseButtons.delete(button);
+    }
+    wheel(delta) {
+        this.wheelDelta += delta;
+    }
+}

package/dist/core/src/input/ui-router.js

@@ -0,0 +1,76 @@
+// ============================================================================
+// 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).
+// ============================================================================
+export class UIInputRouter {
+    inputState = null;
+    lastMouseX = -1;
+    lastMouseY = -1;
+    /** Optional live input state — when set, update() syncs pointer tracking. */
+    setInputState(state) {
+        this.inputState = state;
+    }
+    /** Last known pointer position in CSS pixels (-1,-1 before first event). */
+    getPointerPos() {
+        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() {
+        return this.lastMouseX >= 0 && this.hitTest(this.lastMouseX, this.lastMouseY);
+    }
+    /** Hit-test hook — override to consult the live UI document. */
+    hitTest(_x, _y) {
+        return false;
+    }
+    /** Per-frame sync from InputState (used by InputContextRouter). */
+    update() {
+        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) { }
+    handleKeyUp(_code) { }
+    /** Printable character (text inputs). */
+    handleCharInput(_char) { }
+    /**
+     * Wheel routing. Returns true when the UI consumed the event (suppresses
+     * page/canvas scroll handlers behind a scrollable panel).
+     */
+    handleWheel(_dx, _dy) {
+        return false;
+    }
+    handleMouseMove(mx, my) {
+        this.lastMouseX = mx;
+        this.lastMouseY = my;
+    }
+    handleMouseDown(mx, my) {
+        this.lastMouseX = mx;
+        this.lastMouseY = my;
+    }
+    handleMouseUp(mx, my) {
+        this.lastMouseX = mx;
+        this.lastMouseY = my;
+    }
+    /** Pointer left the canvas — clears pointer tracking. */
+    handlePointerLeave() {
+        this.lastMouseX = -1;
+        this.lastMouseY = -1;
+    }
+}