@pmndrs/viverse 0.1.20 → 0.2.1

package/dist/input/action.js

@@ -0,0 +1,97 @@
+// no external imports
+export class EventAction {
+    latestTime = -Infinity;
+    subscriptionListeners = new Set();
+    emit(value) {
+        this.latestTime = performance.now() / 1000;
+        for (const listener of this.subscriptionListeners) {
+            listener(value);
+        }
+    }
+    subscribe(callback, options) {
+        const listener = (value) => {
+            if (options?.once === true) {
+                this.subscriptionListeners.delete(listener);
+            }
+            callback(value);
+        };
+        this.subscriptionListeners.add(listener);
+        if (options?.signal != null) {
+            options.signal.addEventListener('abort', () => this.subscriptionListeners.delete(listener), { once: true });
+        }
+    }
+    waitFor(signal) {
+        return new Promise((resolve) => this.subscribe(resolve, { once: true, signal }));
+    }
+    getLatestTime() {
+        return this.latestTime;
+    }
+}
+/**
+ * StateAction keeps the latest state per writer and merges them on read.
+ * Values persist until the writer is disposed (abortSignal aborts).
+ */
+export class StateAction {
+    mergeWriters;
+    neutral;
+    absoluteActions = new Map();
+    constructor(mergeWriters, neutral) {
+        this.mergeWriters = mergeWriters;
+        this.neutral = neutral;
+    }
+    createWriter(abortSignal) {
+        const emitterUuid = globalThis.crypto?.randomUUID?.() ?? Math.random().toString(36).slice(2);
+        abortSignal.addEventListener('abort', () => this.absoluteActions.delete(emitterUuid), { once: true });
+        return {
+            write: (value) => {
+                if (!abortSignal.aborted) {
+                    this.absoluteActions.set(emitterUuid, value);
+                }
+            },
+        };
+    }
+    get() {
+        const values = [...this.absoluteActions.values()];
+        return values.length ? this.mergeWriters(...values) : this.neutral;
+    }
+}
+/**
+ * DeltaAction accumulates transient values each frame and clears them on frame advance.
+ * Multiple writes per frame from any source are combined using combine().
+ */
+export class DeltaAction {
+    combine;
+    neutral;
+    constructor(combine, neutral) {
+        this.combine = combine;
+        this.neutral = neutral;
+    }
+    readers = new Set();
+    write(value) {
+        for (const reader of this.readers) {
+            reader.next.push(value);
+        }
+    }
+    createReader(abortSignal) {
+        const reader = { next: new Array(), current: new Array() };
+        this.readers.add(reader);
+        abortSignal.addEventListener('abort', () => {
+            this.readers.delete(reader);
+        }, { once: true });
+        return {
+            update: () => {
+                reader.current.length = 0;
+                if (reader.next.length) {
+                    reader.current.push(...reader.next);
+                    reader.next.length = 0;
+                }
+            },
+            get: () => {
+                if (reader.current.length === 0) {
+                    return this.neutral;
+                }
+                return this.combine(...reader.current);
+            },
+        };
+    }
+}

package/dist/input/index.d.ts

@@ -1,32 +1,17 @@
-export declare class InputSystem {
-    private readonly inputs;
-    constructor(domElement: HTMLElement, inputs: ReadonlyArray<Input | {
-        new (element: HTMLElement, options?: {}): Input;
-    }>, options?: {});
-    add(input: Input): void;
-    remove(input: Input): void;
-    dispose(): void;
-    get<T>(field: InputField<T>): T;
-}
-export type InputField<T> = {
-    default: T;
-    combine: (v1: any, v2: any) => T;
-};
-export declare const MoveForwardField: InputField<number>;
-export declare const MoveBackwardField: InputField<number>;
-export declare const MoveLeftField: InputField<number>;
-export declare const MoveRightField: InputField<number>;
-export declare const LastTimeJumpPressedField: InputField<number | null>;
-export declare const RunField: InputField<boolean>;
-export declare const DeltaZoomField: InputField<number>;
-export declare const DeltaYawField: InputField<number>;
-export declare const DeltaPitchField: InputField<number>;
-export interface Input {
-    get<T>(field: InputField<T>): T | undefined;
-    dispose?(): void;
-}
+import { EventAction, StateAction, DeltaAction } from './action.js';
+export declare function BooleanOr(...values: Array<boolean>): boolean;
+export declare const MoveForwardAction: StateAction<number>;
+export declare const MoveBackwardAction: StateAction<number>;
+export declare const MoveLeftAction: StateAction<number>;
+export declare const MoveRightAction: StateAction<number>;
+export declare const RunAction: StateAction<boolean>;
+export declare const JumpAction: EventAction<void>;
+export declare const ZoomAction: DeltaAction<number>;
+export declare const RotateYawAction: DeltaAction<number>;
+export declare const RotatePitchAction: DeltaAction<number>;
 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/index.js

@@ -1,76 +1,24 @@
-export class InputSystem {
-    inputs;
-    constructor(domElement, inputs, options) {
-        this.inputs = inputs.map((input) => (typeof input === 'function' ? new input(domElement, options) : input));
-    }
-    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);
-            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,11 +21,19 @@ export type LocomotionKeyboardInputOptions = {
     keyboardRunKeys?: Array<string>;
     keyboardJumpKeys?: Array<string>;
 };
-export declare class LocomotionKeyboardInput implements Input {
-    private readonly options;
-    private readonly abortController;
-    private readonly keyState;
-    constructor(domElement: HTMLElement, options?: LocomotionKeyboardInputOptions);
-    get<T>(field: InputField<T>): T | undefined;
+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);
     dispose(): void;
 }

package/dist/input/keyboard.js

@@ -1,84 +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 {
-    options;
+import { JumpAction, MoveBackwardAction, MoveForwardAction, MoveLeftAction, MoveRightAction, RunAction, } from './index.js';
+export class KeyboardInput {
+    domElement;
     abortController = new AbortController();
-    keyState = new Map();
-    constructor(domElement, options = {}) {
-        this.options = options;
-        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 }));
+    options = {};
+    abortSignal = this.abortController.signal;
+    pressedKeys = new Set();
+    constructor(domElement) {
+        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) {
-        if (field === LastTimeJumpPressedField) {
-            const jumpKeys = this.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 = this.options.keyboardMoveForwardKeys ?? DefaultMoveForwardKeys;
-                break;
-            case MoveBackwardField:
-                keys = this.options.keyboardMoveBackwardKeys ?? DefaultMoveBackwardKeys;
-                break;
-            case MoveLeftField:
-                keys = this.options.keyboardMoveLeftKeys ?? DefaultMoveLeftKeys;
-                break;
-            case MoveRightField:
-                keys = this.options.keyboardMoveRightKeys ?? DefaultMoveRightKeys;
-                break;
-            case RunField:
-                keys = this.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 {
+export declare class PointerCaptureInput {
     private readonly domElement;
     private readonly abortController;
-    private deltaZoom;
-    private deltaYaw;
-    private deltaPitch;
     private activePointers;
     private lastPinchDist;
-    constructor(domElement: HTMLElement, options?: PointerCaptureInputOptions);
-    get<T>(field: InputField<T>): T | undefined;
+    options: {
+        rotationSpeed?: number;
+        zoomSpeed?: number;
+    };
+    constructor(domElement: HTMLElement);
     dispose(): void;
 }

package/dist/input/pointer-capture.js

@@ -1,16 +1,14 @@
-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;
-    constructor(domElement, options = {}) {
+    options = {};
+    constructor(domElement) {
         this.domElement = domElement;
         domElement.addEventListener('pointerdown', (event) => {
             this.domElement.setPointerCapture(event.pointerId);
@@ -31,16 +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);
-                    const zoomSpeed = options.pointerCaptureZoomSpeed ?? 0.0001;
-                    this.deltaZoom += (this.lastPinchDist - d) * zoomSpeed;
+                    const zoomSpeed = this.options.zoomSpeed ?? 0.0001;
+                    ZoomAction.write((this.lastPinchDist - d) * zoomSpeed);
                     this.lastPinchDist = d;
                 }
                 event.preventDefault();
                 return;
             }
-            const rotationSpeed = options.pointerCaptureRotationSpeed ?? 0.4;
-            this.deltaYaw -= (rotationSpeed * event.movementX) / window.innerHeight;
-            this.deltaPitch -= (rotationSpeed * 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,
         });
@@ -64,30 +62,12 @@ export class PointerCaptureInput {
         });
         domElement.addEventListener('wheel', (event) => {
             event.preventDefault();
-            const zoomSpeed = options.pointerCaptureZoomSpeed ?? 0.0001;
-            this.deltaZoom += event.deltaY * zoomSpeed;
+            const zoomSpeed = this.options.zoomSpeed ?? 0.0001;
+            ZoomAction.write(event.deltaY * zoomSpeed);
         }, {
             signal: this.abortController.signal,
         });
     }
-    get(field) {
-        let result;
-        switch (field) {
-            case DeltaPitchField:
-                result = this.deltaPitch;
-                this.deltaPitch = 0;
-                break;
-            case DeltaYawField:
-                result = this.deltaYaw;
-                this.deltaYaw = 0;
-                break;
-            case DeltaZoomField:
-                result = this.deltaZoom;
-                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 {
+export declare class PointerLockInput {
     private readonly abortController;
-    private deltaZoom;
-    private deltaYaw;
-    private deltaPitch;
-    constructor(domElement: HTMLElement, options?: PointerLockInputOptions);
-    get<T>(field: InputField<T>): T | undefined;
+    options: {
+        rotationSpeed?: number;
+        zoomSpeed?: number;
+    };
+    constructor(domElement: HTMLElement);
     dispose(): void;
 }

package/dist/input/pointer-lock.js

@@ -1,22 +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;
-    constructor(domElement, options = {}) {
+    options = {};
+    constructor(domElement) {
         domElement.addEventListener('pointermove', (event) => {
             if (document.pointerLockElement != domElement) {
                 return;
             }
-            const rotationSpeed = options.pointerLockRotationSpeed ?? 0.4;
-            // Compute based on domElement bounds instead of window.innerHeight
             const rect = domElement.getBoundingClientRect();
-            this.deltaYaw -= (rotationSpeed * event.movementX) / rect.height;
-            this.deltaPitch -= (rotationSpeed * 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,
         });
@@ -24,31 +21,13 @@ export class PointerLockInput {
             if (document.pointerLockElement != domElement) {
                 return;
             }
-            const zoomSpeed = options.pointerLockZoomSpeed ?? 0.0001;
-            this.deltaZoom += event.deltaY * zoomSpeed;
+            const zoomSpeed = this.options.zoomSpeed ?? 0.0001;
+            ZoomAction.write(event.deltaY * zoomSpeed);
             event.preventDefault();
         }, {
             signal: this.abortController.signal,
         });
     }
-    get(field) {
-        let result;
-        switch (field) {
-            case DeltaPitchField:
-                result = this.deltaPitch;
-                this.deltaPitch = 0;
-                break;
-            case DeltaYawField:
-                result = this.deltaYaw;
-                this.deltaYaw = 0;
-                break;
-            case DeltaZoomField:
-                result = this.deltaZoom;
-                this.deltaZoom = 0;
-                break;
-        }
-        return result;
-    }
     dispose() {
         this.abortController.abort();
     }