@pmndrs/viverse 0.2.0 → 0.2.1

package/dist/input/index.js

@@ -1,77 +1,24 @@
-export class InputSystem {
-    options;
-    inputs = [];
-    constructor(options = {}) {
-        this.options = options;
-    }
-    add(input) {
-        this.inputs.push(input);
-    }
-    remove(input) {
-        const index = this.inputs.indexOf(input);
-        if (index === -1) {
-            return;
-        }
-        this.inputs.splice(index, 1);
-    }
-    dispose() {
-        this.inputs.forEach((input) => input.dispose?.());
-        this.inputs.length = 0;
-    }
-    get(field) {
-        let current;
-        for (const input of this.inputs) {
-            const result = input.get(field, this.options);
-            if (result == null) {
-                continue;
-            }
-            if (current == undefined) {
-                current = result;
-                continue;
-            }
-            current = field.combine(current, result);
-        }
-        return current ?? field.default;
+import { EventAction, StateAction, DeltaAction } from './action.js';
+export function BooleanOr(...values) {
+    let value = false;
+    for (let i = 0; i < values.length; i++) {
+        value ||= values[i];
     }
+    return value;
 }
-export const MoveForwardField = {
-    default: 0,
-    combine: Math.max,
-};
-export const MoveBackwardField = {
-    default: 0,
-    combine: Math.max,
-};
-export const MoveLeftField = {
-    default: 0,
-    combine: Math.max,
-};
-export const MoveRightField = {
-    default: 0,
-    combine: Math.max,
-};
-export const LastTimeJumpPressedField = {
-    default: null,
-    combine: (v1, v2) => (v1 == null && v2 == null ? null : Math.min(v1 ?? Infinity, v2 ?? Infinity)),
-};
-export const RunField = {
-    default: false,
-    combine: (v1, v2) => v1 || v2,
-};
-export const DeltaZoomField = {
-    default: 0,
-    combine: Math.max,
-};
-export const DeltaYawField = {
-    default: 0,
-    combine: Math.max,
-};
-export const DeltaPitchField = {
-    default: 0,
-    combine: Math.max,
-};
+const sum = (...values) => values.reduce((a, b) => a + b, 0);
+export const MoveForwardAction = new StateAction(Math.max, 0);
+export const MoveBackwardAction = new StateAction(Math.max, 0);
+export const MoveLeftAction = new StateAction(Math.max, 0);
+export const MoveRightAction = new StateAction(Math.max, 0);
+export const RunAction = new StateAction(BooleanOr, false);
+export const JumpAction = new EventAction();
+export const ZoomAction = new DeltaAction(sum, 0);
+export const RotateYawAction = new DeltaAction(sum, 0);
+export const RotatePitchAction = new DeltaAction(sum, 0);
 export * from './pointer-lock.js';
 export * from './pointer-capture.js';
 export * from './keyboard.js';
 export * from './screen-joystick.js';
 export * from './screen-jump-button.js';
+export * from './action.js';

package/dist/input/keyboard.d.ts

@@ -1,4 +1,18 @@
-import { Input, InputField } from './index.js';
+import { EventAction, StateAction } from './index.js';
+export declare class KeyboardInput {
+    private readonly domElement;
+    private readonly abortController;
+    options: Partial<{
+        keys: Array<string>;
+    }>;
+    abortSignal: AbortSignal;
+    private readonly pressedKeys;
+    constructor(domElement: HTMLElement);
+    bindEvent(action: EventAction): void;
+    bindValue(action: StateAction<boolean>): void;
+    bindValue<T>(action: StateAction<T>, map: (value: boolean) => T): void;
+    dispose(): void;
+}
 export type LocomotionKeyboardInputOptions = {
     keyboardMoveForwardKeys?: Array<string>;
     keyboardMoveBackwardKeys?: Array<string>;
@@ -7,10 +21,19 @@ export type LocomotionKeyboardInputOptions = {
     keyboardRunKeys?: Array<string>;
     keyboardJumpKeys?: Array<string>;
 };
-export declare class LocomotionKeyboardInput implements Input<LocomotionKeyboardInputOptions> {
-    private readonly abortController;
-    private readonly keyState;
+export declare const DefaultMoveForwardKeys: string[];
+export declare const DefaultMoveBackwardKeys: string[];
+export declare const DefaultMoveLeftKeys: string[];
+export declare const DefaultMoveRightKeys: string[];
+export declare const DefaultRunKeys: string[];
+export declare const DefaultJumpKeys: string[];
+export declare class LocomotionKeyboardInput {
+    forward: KeyboardInput;
+    left: KeyboardInput;
+    right: KeyboardInput;
+    backward: KeyboardInput;
+    jump: KeyboardInput;
+    run: KeyboardInput;
     constructor(domElement: HTMLElement);
-    get<T>(field: InputField<T>, options: LocomotionKeyboardInputOptions): T | undefined;
     dispose(): void;
 }

package/dist/input/keyboard.js

@@ -1,82 +1,96 @@
-import { MoveForwardField, MoveBackwardField, MoveLeftField, MoveRightField, LastTimeJumpPressedField, RunField, } from './index.js';
-const DefaultMoveForwardKeys = ['KeyW'];
-const DefaultMoveBackwardKeys = ['KeyS'];
-const DefaultMoveLeftKeys = ['KeyA'];
-const DefaultMoveRightKeys = ['KeyD'];
-const DefaultRunKeys = ['ShiftRight', 'ShiftLeft'];
-const DefaultJumpKeys = ['Space'];
-export class LocomotionKeyboardInput {
+import { JumpAction, MoveBackwardAction, MoveForwardAction, MoveLeftAction, MoveRightAction, RunAction, } from './index.js';
+export class KeyboardInput {
+    domElement;
     abortController = new AbortController();
-    keyState = new Map();
+    options = {};
+    abortSignal = this.abortController.signal;
+    pressedKeys = new Set();
     constructor(domElement) {
-        domElement.tabIndex = 0;
-        domElement.addEventListener('keydown', (event) => {
-            let state = this.keyState.get(event.code);
-            const now = performance.now() / 1000;
-            if (state == null) {
-                this.keyState.set(event.code, (state = { pressTime: now }));
+        this.domElement = domElement;
+    }
+    bindEvent(action) {
+        const isWatched = (e) => this.options.keys == null || this.options.keys.length === 0 || this.options.keys.includes(e.code);
+        this.domElement.addEventListener('keydown', (e) => {
+            if (!isWatched(e) || e.repeat) {
+                return;
+            }
+            action.emit({});
+        }, { signal: this.abortController.signal });
+    }
+    bindValue(action, map) {
+        const writer = action.createWriter(this.abortSignal);
+        const isWatched = (e) => this.options.keys == null || this.options.keys.length === 0 || this.options.keys.includes(e.code);
+        let isPressed = false;
+        const write = (value) => {
+            if (isPressed === value) {
+                return;
+            }
+            isPressed = value;
+            writer.write(map?.(value) ?? value);
+        };
+        this.domElement.tabIndex = 0;
+        this.domElement.addEventListener('keydown', (e) => {
+            if (!isWatched(e)) {
+                return;
             }
-            else {
-                state.pressTime = now;
+            const wasEmpty = this.pressedKeys.size === 0;
+            this.pressedKeys.add(e.code);
+            if (wasEmpty && this.pressedKeys.size > 0) {
+                write(true);
             }
-        }, {
-            signal: this.abortController.signal,
-        });
-        domElement.addEventListener('keyup', (event) => {
-            let state = this.keyState.get(event.code);
-            const now = performance.now() / 1000;
-            if (state == null) {
-                this.keyState.set(event.code, (state = { releaseTime: now }));
+        }, { signal: this.abortController.signal });
+        this.domElement.addEventListener('keyup', (e) => {
+            if (!isWatched(e)) {
+                return;
             }
-            else {
-                state.releaseTime = now;
+            if (this.pressedKeys.delete(e.code) && this.pressedKeys.size === 0) {
+                write(false);
             }
-        }, {
-            signal: this.abortController.signal,
-        });
+        }, { signal: this.abortController.signal });
         // Handle focus loss to clear pressed keys
-        domElement.addEventListener('blur', () => this.keyState.clear(), {
-            signal: this.abortController.signal,
-        });
-    }
-    get(field, options) {
-        if (field === LastTimeJumpPressedField) {
-            const jumpKeys = options.keyboardJumpKeys ?? DefaultJumpKeys;
-            const pressed = jumpKeys
-                .map((key) => this.keyState.get(key)?.pressTime ?? null)
-                .filter((t) => t != null);
-            return (pressed.length > 0 ? Math.max(...pressed) : null);
-        }
-        let keys;
-        switch (field) {
-            case MoveForwardField:
-                keys = options.keyboardMoveForwardKeys ?? DefaultMoveForwardKeys;
-                break;
-            case MoveBackwardField:
-                keys = options.keyboardMoveBackwardKeys ?? DefaultMoveBackwardKeys;
-                break;
-            case MoveLeftField:
-                keys = options.keyboardMoveLeftKeys ?? DefaultMoveLeftKeys;
-                break;
-            case MoveRightField:
-                keys = options.keyboardMoveRightKeys ?? DefaultMoveRightKeys;
-                break;
-            case RunField:
-                keys = options.keyboardRunKeys ?? DefaultRunKeys;
-                break;
-        }
-        if (keys == null) {
-            return undefined;
-        }
-        return keys.some((key) => {
-            const state = this.keyState.get(key);
-            if (state?.pressTime == null) {
-                return false;
+        this.domElement.addEventListener('blur', () => {
+            if (this.pressedKeys.size > 0) {
+                this.pressedKeys.clear();
+                write(false);
             }
-            return state.releaseTime == null || state.pressTime > state.releaseTime;
-        });
+        }, { signal: this.abortController.signal });
     }
     dispose() {
         this.abortController.abort();
     }
 }
+export const DefaultMoveForwardKeys = ['KeyW'];
+export const DefaultMoveBackwardKeys = ['KeyS'];
+export const DefaultMoveLeftKeys = ['KeyA'];
+export const DefaultMoveRightKeys = ['KeyD'];
+export const DefaultRunKeys = ['ShiftRight', 'ShiftLeft'];
+export const DefaultJumpKeys = ['Space'];
+export class LocomotionKeyboardInput {
+    forward;
+    left;
+    right;
+    backward;
+    jump;
+    run;
+    constructor(domElement) {
+        this.forward = new KeyboardInput(domElement);
+        this.forward.options.keys = DefaultMoveForwardKeys;
+        this.forward.bindValue(MoveForwardAction, (isPressed) => (isPressed ? 1 : 0));
+        this.left = new KeyboardInput(domElement);
+        this.left.options.keys = DefaultMoveLeftKeys;
+        this.left.bindValue(MoveLeftAction, (isPressed) => (isPressed ? 1 : 0));
+        this.right = new KeyboardInput(domElement);
+        this.right.options.keys = DefaultMoveRightKeys;
+        this.right.bindValue(MoveRightAction, (isPressed) => (isPressed ? 1 : 0));
+        this.backward = new KeyboardInput(domElement);
+        this.backward.options.keys = DefaultMoveBackwardKeys;
+        this.backward.bindValue(MoveBackwardAction, (isPressed) => (isPressed ? 1 : 0));
+        this.jump = new KeyboardInput(domElement);
+        this.jump.options.keys = DefaultJumpKeys;
+        this.jump.bindEvent(JumpAction);
+        this.run = new KeyboardInput(domElement);
+        this.run.options.keys = DefaultRunKeys;
+        this.run.bindValue(RunAction);
+    }
+    dispose() { }
+}

package/dist/input/pointer-capture.d.ts

@@ -1,20 +1,15 @@
-import { Input, InputField } from './index.js';
-export type PointerCaptureInputOptions = {
-    pointerCaptureRotationSpeed?: number;
-    pointerCaptureZoomSpeed?: number;
-};
 /**
  * @requires to manually execute `domElement.setPointerCapture(pointerId)` on pointerdown
  */
-export declare class PointerCaptureInput implements Input<PointerCaptureInputOptions> {
+export declare class PointerCaptureInput {
     private readonly domElement;
     private readonly abortController;
-    private deltaZoom;
-    private deltaYaw;
-    private deltaPitch;
     private activePointers;
     private lastPinchDist;
+    options: {
+        rotationSpeed?: number;
+        zoomSpeed?: number;
+    };
     constructor(domElement: HTMLElement);
-    get<T>(field: InputField<T>, options: PointerCaptureInputOptions): T | undefined;
     dispose(): void;
 }

package/dist/input/pointer-capture.js

@@ -1,15 +1,13 @@
-import { DeltaPitchField, DeltaYawField, DeltaZoomField } from './index.js';
+import { RotatePitchAction, RotateYawAction, ZoomAction } from './index.js';
 /**
  * @requires to manually execute `domElement.setPointerCapture(pointerId)` on pointerdown
  */
 export class PointerCaptureInput {
     domElement;
     abortController = new AbortController();
-    deltaZoom = 0;
-    deltaYaw = 0;
-    deltaPitch = 0;
     activePointers = new Map();
     lastPinchDist = null;
+    options = {};
     constructor(domElement) {
         this.domElement = domElement;
         domElement.addEventListener('pointerdown', (event) => {
@@ -31,14 +29,16 @@ export class PointerCaptureInput {
                 const pts = Array.from(this.activePointers.values());
                 if (this.lastPinchDist != null) {
                     const d = Math.hypot(pts[0].x - pts[1].x, pts[0].y - pts[1].y);
-                    this.deltaZoom += this.lastPinchDist - d;
+                    const zoomSpeed = this.options.zoomSpeed ?? 0.0001;
+                    ZoomAction.write((this.lastPinchDist - d) * zoomSpeed);
                     this.lastPinchDist = d;
                 }
                 event.preventDefault();
                 return;
             }
-            this.deltaYaw -= event.movementX / window.innerHeight;
-            this.deltaPitch -= event.movementY / window.innerHeight;
+            const rotationSpeed = this.options.rotationSpeed ?? 0.4;
+            RotateYawAction.write(-(event.movementX / window.innerHeight) * rotationSpeed);
+            RotatePitchAction.write(-(event.movementY / window.innerHeight) * rotationSpeed);
         }, {
             signal: this.abortController.signal,
         });
@@ -62,31 +62,12 @@ export class PointerCaptureInput {
         });
         domElement.addEventListener('wheel', (event) => {
             event.preventDefault();
-            this.deltaZoom += event.deltaY;
+            const zoomSpeed = this.options.zoomSpeed ?? 0.0001;
+            ZoomAction.write(event.deltaY * zoomSpeed);
         }, {
             signal: this.abortController.signal,
         });
     }
-    get(field, options) {
-        const rotationSpeed = options.pointerCaptureRotationSpeed ?? 0.4;
-        const zoomSpeed = options.pointerCaptureZoomSpeed ?? 0.0001;
-        let result;
-        switch (field) {
-            case DeltaPitchField:
-                result = (this.deltaPitch * rotationSpeed);
-                this.deltaPitch = 0;
-                break;
-            case DeltaYawField:
-                result = (this.deltaYaw * rotationSpeed);
-                this.deltaYaw = 0;
-                break;
-            case DeltaZoomField:
-                result = (this.deltaZoom * zoomSpeed);
-                this.deltaZoom = 0;
-                break;
-        }
-        return result;
-    }
     dispose() {
         this.abortController.abort();
     }

package/dist/input/pointer-lock.d.ts

@@ -1,17 +1,12 @@
-import { Input, InputField } from './index.js';
-export type PointerLockInputOptions = {
-    pointerLockRotationSpeed?: number;
-    pointerLockZoomSpeed?: number;
-};
 /**
  * @requires to manually execute `domElement.requestPointerLock()`
  */
-export declare class PointerLockInput implements Input<PointerLockInputOptions> {
+export declare class PointerLockInput {
     private readonly abortController;
-    private deltaZoom;
-    private deltaYaw;
-    private deltaPitch;
+    options: {
+        rotationSpeed?: number;
+        zoomSpeed?: number;
+    };
     constructor(domElement: HTMLElement);
-    get<T>(field: InputField<T>, options: PointerLockInputOptions): T | undefined;
     dispose(): void;
 }

package/dist/input/pointer-lock.js

@@ -1,21 +1,19 @@
-import { DeltaPitchField, DeltaYawField, DeltaZoomField } from './index.js';
+import { RotatePitchAction, RotateYawAction, ZoomAction } from './index.js';
 /**
  * @requires to manually execute `domElement.requestPointerLock()`
  */
 export class PointerLockInput {
     abortController = new AbortController();
-    deltaZoom = 0;
-    deltaYaw = 0;
-    deltaPitch = 0;
+    options = {};
     constructor(domElement) {
         domElement.addEventListener('pointermove', (event) => {
             if (document.pointerLockElement != domElement) {
                 return;
             }
-            // Compute based on domElement bounds instead of window.innerHeight
             const rect = domElement.getBoundingClientRect();
-            this.deltaYaw -= event.movementX / rect.height;
-            this.deltaPitch -= event.movementY / rect.height;
+            const rotationSpeed = this.options.rotationSpeed ?? 0.4;
+            RotateYawAction.write(-(event.movementX / rect.height) * rotationSpeed);
+            RotatePitchAction.write(-(event.movementY / rect.height) * rotationSpeed);
         }, {
             signal: this.abortController.signal,
         });
@@ -23,32 +21,13 @@ export class PointerLockInput {
             if (document.pointerLockElement != domElement) {
                 return;
             }
-            this.deltaZoom += event.deltaY;
+            const zoomSpeed = this.options.zoomSpeed ?? 0.0001;
+            ZoomAction.write(event.deltaY * zoomSpeed);
             event.preventDefault();
         }, {
             signal: this.abortController.signal,
         });
     }
-    get(field, options) {
-        const rotationSpeed = options.pointerLockRotationSpeed ?? 0.4;
-        const zoomSpeed = options.pointerLockZoomSpeed ?? 0.0001;
-        let result;
-        switch (field) {
-            case DeltaPitchField:
-                result = (this.deltaPitch * rotationSpeed);
-                this.deltaPitch = 0;
-                break;
-            case DeltaYawField:
-                result = (this.deltaYaw * rotationSpeed);
-                this.deltaYaw = 0;
-                break;
-            case DeltaZoomField:
-                result = (this.deltaZoom * zoomSpeed);
-                this.deltaZoom = 0;
-                break;
-        }
-        return result;
-    }
     dispose() {
         this.abortController.abort();
     }

package/dist/input/screen-joystick.d.ts

@@ -1,17 +1,22 @@
-import { Input, InputField } from './index.js';
 export type ScreenJoystickInputOptions = {
     screenJoystickRunDistancePx?: number;
     screenJoystickDeadZonePx?: number;
 };
-export declare class ScreenJoystickInput implements Input<ScreenJoystickInputOptions> {
+export declare class ScreenJoystickInput {
+    private readonly abortController;
     readonly root: HTMLDivElement;
     private readonly handle;
     private pointerId;
-    private distanceToCenter;
-    private clampedX;
-    private clampedY;
+    private forwardWriter;
+    private backwardWriter;
+    private leftWriter;
+    private rightWriter;
+    private runWriter;
+    options: {
+        runDistancePx?: number;
+        deadZonePx?: number;
+    };
     constructor(domElement: HTMLElement);
-    get<T>(field: InputField<T>, options: ScreenJoystickInputOptions): T | undefined;
     dispose(): void;
     private updateHandle;
     private resetHandle;

package/dist/input/screen-joystick.js

@@ -1,14 +1,18 @@
-import { MoveForwardField, MoveBackwardField, MoveLeftField, MoveRightField, RunField, } from './index.js';
+import { MoveForwardAction, MoveBackwardAction, MoveLeftAction, MoveRightAction, RunAction } from './index.js';
 const DefaultDeadZonePx = 24;
 const DefaultRunDistancePx = 46;
 const JoystickRadius = 56;
 export class ScreenJoystickInput {
+    abortController = new AbortController();
     root;
     handle;
     pointerId;
-    distanceToCenter = 0;
-    clampedX = 0;
-    clampedY = 0;
+    forwardWriter = MoveForwardAction.createWriter(this.abortController.signal);
+    backwardWriter = MoveBackwardAction.createWriter(this.abortController.signal);
+    leftWriter = MoveLeftAction.createWriter(this.abortController.signal);
+    rightWriter = MoveRightAction.createWriter(this.abortController.signal);
+    runWriter = RunAction.createWriter(this.abortController.signal);
+    options = {};
     constructor(domElement) {
         const parent = domElement.parentElement ?? domElement;
         const joy = document.createElement('div');
@@ -78,43 +82,36 @@ export class ScreenJoystickInput {
             e.preventDefault();
             this.resetHandle();
         };
-        joy.addEventListener('pointerdown', onPointerDown);
-        joy.addEventListener('pointermove', onPointerMove);
-        joy.addEventListener('pointerup', onPointerEnd);
-        joy.addEventListener('pointercancel', onPointerEnd);
-    }
-    get(field, options) {
-        switch (field) {
-            case MoveForwardField:
-            case MoveBackwardField:
-                const moveY = this.distanceToCenter <= (options.screenJoystickDeadZonePx ?? DefaultDeadZonePx)
-                    ? 0
-                    : -this.clampedY / JoystickRadius;
-                return field === MoveForwardField ? Math.max(0, moveY) : Math.max(0, -moveY);
-            case MoveLeftField:
-            case MoveRightField:
-                const moveX = this.distanceToCenter <= (options.screenJoystickDeadZonePx ?? DefaultDeadZonePx)
-                    ? 0
-                    : this.clampedX / JoystickRadius;
-                return field === MoveLeftField ? Math.max(0, moveX) : Math.max(0, moveX);
-            case RunField:
-                return (this.distanceToCenter > (options.screenJoystickRunDistancePx ?? DefaultRunDistancePx));
-        }
-        return undefined;
+        joy.addEventListener('pointerdown', onPointerDown, { signal: this.abortController.signal });
+        joy.addEventListener('pointermove', onPointerMove, { signal: this.abortController.signal });
+        joy.addEventListener('pointerup', onPointerEnd, { signal: this.abortController.signal });
+        joy.addEventListener('pointercancel', onPointerEnd, { signal: this.abortController.signal });
     }
     dispose() {
+        this.abortController.abort();
         this.root.remove();
     }
     updateHandle(dx, dy) {
-        this.distanceToCenter = Math.hypot(dx, dy) || 1;
-        this.clampedX = (dx / this.distanceToCenter) * Math.min(this.distanceToCenter, JoystickRadius);
-        this.clampedY = (dy / this.distanceToCenter) * Math.min(this.distanceToCenter, JoystickRadius);
-        this.handle.style.transform = `translate(-50%,-50%) translate(${this.clampedX}px, ${this.clampedY}px)`;
+        const distanceToCenter = Math.hypot(dx, dy) || 1;
+        const clampedX = (dx / distanceToCenter) * Math.min(distanceToCenter, JoystickRadius);
+        const clampedY = (dy / distanceToCenter) * Math.min(distanceToCenter, JoystickRadius);
+        this.handle.style.transform = `translate(-50%,-50%) translate(${clampedX}px, ${clampedY}px)`;
+        const deadZone = this.options.deadZonePx ?? DefaultDeadZonePx;
+        const runDistance = this.options.runDistancePx ?? DefaultRunDistancePx;
+        const moveY = distanceToCenter <= deadZone ? 0 : -clampedY / JoystickRadius;
+        const moveX = distanceToCenter <= deadZone ? 0 : clampedX / JoystickRadius;
+        this.forwardWriter.write(Math.max(0, moveY));
+        this.backwardWriter.write(Math.max(0, -moveY));
+        this.leftWriter.write(Math.max(0, -moveX));
+        this.rightWriter.write(Math.max(0, moveX));
+        this.runWriter.write(distanceToCenter > runDistance);
     }
     resetHandle() {
         this.handle.style.transform = 'translate(-50%,-50%)';
-        this.distanceToCenter = 0;
-        this.clampedX = 0;
-        this.clampedY = 0;
+        this.forwardWriter.write(0);
+        this.backwardWriter.write(0);
+        this.leftWriter.write(0);
+        this.rightWriter.write(0);
+        this.runWriter.write(false);
     }
 }

package/dist/input/screen-jump-button.d.ts

@@ -1,8 +1,6 @@
-import { Input, InputField } from './index.js';
-export declare class ScreenJumpButtonInput implements Input<{}> {
+export declare class ScreenJumpButtonInput {
+    private readonly abortController;
     readonly root: HTMLDivElement;
-    private lastJumpTime;
     constructor(domElement: HTMLElement);
-    get<T>(field: InputField<T>): T | undefined;
     dispose(): void;
 }

package/dist/input/screen-jump-button.js

@@ -1,7 +1,7 @@
-import { LastTimeJumpPressedField } from './index.js';
+import { JumpAction } from './index.js';
 export class ScreenJumpButtonInput {
+    abortController = new AbortController();
     root;
-    lastJumpTime = null;
     constructor(domElement) {
         const parent = domElement.parentElement ?? domElement;
         const btn = document.createElement('div');
@@ -27,23 +27,18 @@ export class ScreenJumpButtonInput {
         const onPress = (e) => {
             e.preventDefault();
             e.stopPropagation();
-            this.lastJumpTime = performance.now() / 1000;
+            JumpAction.emit();
         };
         const stopPropagation = (e) => {
             e.stopPropagation();
             e.preventDefault();
         };
-        this.root.addEventListener('pointerdown', onPress);
-        this.root.addEventListener('pointermove', stopPropagation);
-        this.root.addEventListener('pointerup', stopPropagation);
-    }
-    get(field) {
-        if (field === LastTimeJumpPressedField) {
-            return this.lastJumpTime;
-        }
-        return undefined;
+        this.root.addEventListener('pointerdown', onPress, { signal: this.abortController.signal });
+        this.root.addEventListener('pointermove', stopPropagation, { signal: this.abortController.signal });
+        this.root.addEventListener('pointerup', stopPropagation, { signal: this.abortController.signal });
     }
     dispose() {
+        this.abortController.abort();
         this.root.remove();
     }
 }