@pmndrs/viverse 0.2.0 → 0.2.1

package/dist/animation/default.js

@@ -1,18 +1,25 @@
-export async function loadDefaultCharacterAnimationUrl(type) {
-    switch (type) {
-        case 'idle':
+export const IdleAnimationUrl = Symbol('idle-animation-url');
+export const JumpUpAnimationUrl = Symbol('jump-up-animation-url');
+export const JumpDownAnimationUrl = Symbol('jump-down-animation-url');
+export const JumpForwardAnimationUrl = Symbol('jump-forward-animation-url');
+export const JumpLoopAnimationUrl = Symbol('jump-loop-animation-url');
+export const RunAnimationUrl = Symbol('run-animation-url');
+export const WalkAnimationUrl = Symbol('walk-animation-url');
+export async function resolveDefaultCharacterAnimationUrl(url) {
+    switch (url) {
+        case IdleAnimationUrl:
             return (await import('../assets/idle.js')).url;
-        case 'jumpDown':
+        case JumpDownAnimationUrl:
             return (await import('../assets/jump-down.js')).url;
-        case 'jumpForward':
+        case JumpForwardAnimationUrl:
             return (await import('../assets/jump-forward.js')).url;
-        case 'jumpLoop':
+        case JumpLoopAnimationUrl:
             return (await import('../assets/jump-loop.js')).url;
-        case 'jumpUp':
+        case JumpUpAnimationUrl:
             return (await import('../assets/jump-up.js')).url;
-        case 'run':
+        case RunAnimationUrl:
             return (await import('../assets/run.js')).url;
-        case 'walk':
+        case WalkAnimationUrl:
             return (await import('../assets/walk.js')).url;
     }
 }

package/dist/animation/index.d.ts

@@ -1,17 +1,14 @@
 import { VRMHumanBoneName } from '@pixiv/three-vrm';
 import { AnimationClip, Object3D } from 'three';
-import { loadDefaultCharacterAnimationUrl } from './default.js';
-import type { CharacterModel } from '../model/index.js';
-export declare function fixModelAnimationClip(model: CharacterModel, clip: AnimationClip, clipScene: Object3D | undefined, removeXZMovement: boolean, boneMap?: Record<string, VRMHumanBoneName>): void;
-export * from './gltf.js';
-export * from './fbx.js';
-export * from './vrma.js';
+import { DefaultUrl } from './default.js';
+import { type CharacterAnimationMask } from './mask.js';
+import { type CharacterModel } from '../model/index.js';
+export declare function fixModelAnimationClip(model: CharacterModel, clip: AnimationClip, clipScene: Object3D | undefined, removeXZMovement: boolean): void;
 export * from './utils.js';
-export type CharacterAnimationMask = (boneName: VRMHumanBoneName) => boolean;
+export * from './default.js';
+export * from './mask.js';
 export type CharacterAnimationOptions = {
-    url: string | {
-        default: Parameters<typeof loadDefaultCharacterAnimationUrl>[0];
-    };
+    url: string | DefaultUrl;
     type?: 'mixamo' | 'gltf' | 'vrma' | 'fbx' | 'bvh';
     removeXZMovement?: boolean;
     trimTime?: {
@@ -24,8 +21,6 @@ export type CharacterAnimationOptions = {
 };
 export type Tail<T extends any[]> = T extends [any, ...infer Rest] ? Rest : never;
 export declare function flattenCharacterAnimationOptions(options: Exclude<CharacterAnimationOptions, false>): Tail<Parameters<typeof loadCharacterAnimation>>;
-export declare function loadCharacterAnimation(model: CharacterModel, url: string | {
-    default: Parameters<typeof loadDefaultCharacterAnimationUrl>[0];
-}, type?: CharacterAnimationOptions['type'], removeXZMovement?: boolean, trimStartTime?: number | undefined, trimEndTime?: number | undefined, boneMap?: Record<string, VRMHumanBoneName> | undefined, scaleTime?: number | undefined, mask?: CharacterAnimationMask): Promise<AnimationClip>;
+export declare function loadCharacterAnimation(model: CharacterModel, url: string | DefaultUrl, type?: CharacterAnimationOptions['type'], removeXZMovement?: boolean, trimStartTime?: number | undefined, trimEndTime?: number | undefined, boneMap?: Record<string, VRMHumanBoneName> | undefined, scaleTime?: number | undefined, mask?: CharacterAnimationMask): Promise<AnimationClip>;
 export declare const mixamoBoneMap: Record<string, VRMHumanBoneName>;
 export declare const bvhBoneMap: Record<string, VRMHumanBoneName>;

package/dist/animation/index.js

@@ -1,13 +1,15 @@
 import { VRM } from '@pixiv/three-vrm';
 import { Euler, Quaternion, QuaternionKeyframeTrack, Vector3, VectorKeyframeTrack, } from 'three';
+import { BVHLoader } from 'three/examples/jsm/loaders/BVHLoader.js';
+import { FBXLoader } from 'three/examples/jsm/loaders/FBXLoader.js';
+import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js';
+import { applyBoneMap } from './bone-map.js';
 import _bvhBoneMap from './bvh-bone-map.json';
-import { loadVrmModelBvhAnimations } from './bvh.js';
-import { loadDefaultCharacterAnimationUrl } from './default.js';
-import { loadVrmModelFbxAnimations } from './fbx.js';
-import { loadVrmModelGltfAnimations } from './gltf.js';
+import { resolveDefaultCharacterAnimationUrl } from './default.js';
+import { applyMask } from './mask.js';
 import _mixamoBoneMap from './mixamo-bone-map.json';
 import { scaleAnimationClipTime, trimAnimationClip } from './utils.js';
-import { loadVrmModelVrmaAnimations } from './vrma.js';
+import { vrmaLoader } from '../model/index.js';
 //helper variables for the quaternion retargeting
 const baseThisLocalRestRotation_inverse = new Quaternion();
 const baseThisLocalCurrentRotation = new Quaternion();
@@ -21,11 +23,7 @@ const targetThisLocalCurrentRotation = new Quaternion();
 const position = new Vector3();
 const nonVrmRotationOffset = new Quaternion().setFromEuler(new Euler(0, Math.PI, 0));
 //TODO: currently assumes the model is not yet transformed - loaded for the first time
-export function fixModelAnimationClip(model, clip, clipScene, removeXZMovement, boneMap) {
-    const hipsClipBoneName = boneMap == null ? 'hips' : Object.entries(boneMap).find(([, vrmBoneName]) => vrmBoneName === 'hips')?.[0];
-    if (hipsClipBoneName == null) {
-        throw new Error('Failed to determine hips bone name for VRM animation. Please check the bone map or animation file.');
-    }
+export function fixModelAnimationClip(model, clip, clipScene, removeXZMovement) {
     let restRoot;
     let restRootParent;
     if (!(model instanceof VRM)) {
@@ -39,24 +37,22 @@ export function fixModelAnimationClip(model, clip, clipScene, removeXZMovement,
     let positionScale = 1;
     let clipSceneHips;
     if (clipScene != null) {
-        clipSceneHips = clipScene.getObjectByName(hipsClipBoneName);
+        clipSceneHips = clipScene.getObjectByName('hips');
         clipSceneHips?.parent?.updateMatrixWorld();
         const vrmHipsPosition = model instanceof VRM
             ? model.humanoid.normalizedRestPose.hips?.position
             : model.scene.getObjectByName('rest_hips')?.getWorldPosition(new Vector3()).toArray();
-        if (clipSceneHips == null || vrmHipsPosition == null) {
-            throw new Error('Failed to load animation: missing animation hips object or VRM hips position.');
+        if (clipSceneHips != null && vrmHipsPosition != null) {
+            // Adjust with reference to hips height.
+            const motionHipsHeight = clipSceneHips.getWorldPosition(position).y;
+            const [_, vrmHipsHeight] = vrmHipsPosition;
+            positionScale = vrmHipsHeight / motionHipsHeight;
         }
-        // Adjust with reference to hips height.
-        const motionHipsHeight = clipSceneHips.getWorldPosition(position).y;
-        const [_, vrmHipsHeight] = vrmHipsPosition;
-        positionScale = vrmHipsHeight / motionHipsHeight;
     }
     for (const track of clip.tracks) {
         // Convert each tracks for VRM use, and push to `tracks`
         const [clipBoneName, propertyName] = track.name.split('.');
-        const vrmBoneName = (boneMap?.[clipBoneName] ?? clipBoneName);
-        const targetNormalizedBoneName = model instanceof VRM ? model.humanoid.getNormalizedBoneNode(vrmBoneName)?.name : vrmBoneName;
+        const targetNormalizedBoneName = model instanceof VRM ? model.humanoid.getNormalizedBoneNode(clipBoneName)?.name : clipBoneName;
         if (targetNormalizedBoneName == null) {
             continue;
         }
@@ -69,7 +65,7 @@ export function fixModelAnimationClip(model, clip, clipScene, removeXZMovement,
             targetParentWorldBoneTransform = { rotation: [0, 0, 0, 1] };
         }
         else {
-            const targetBone = model.scene.getObjectByName(`rest_${vrmBoneName}`);
+            const targetBone = model.scene.getObjectByName(`rest_${clipBoneName}`);
             if (targetBone != null) {
                 targetLocalBoneTransform = { rotation: targetBone.quaternion.toArray() };
             }
@@ -123,7 +119,7 @@ export function fixModelAnimationClip(model, clip, clipScene, removeXZMovement,
                     targetThisLocalCurrentRotation.x *= -1;
                     targetThisLocalCurrentRotation.z *= -1;
                 }
-                if (!(model instanceof VRM) && vrmBoneName === 'hips') {
+                if (!(model instanceof VRM) && clipBoneName === 'hips') {
                     targetThisLocalCurrentRotation.premultiply(nonVrmRotationOffset);
                 }
                 targetThisLocalCurrentRotation.toArray(track.values, i);
@@ -131,7 +127,7 @@ export function fixModelAnimationClip(model, clip, clipScene, removeXZMovement,
             track.name = trackName;
         }
         else if (track instanceof VectorKeyframeTrack) {
-            if (vrmBoneName != 'hips' && vrmBoneName != 'root') {
+            if (clipBoneName != 'hips' && clipBoneName != 'root') {
                 continue;
             }
             if (propertyName != 'position') {
@@ -140,7 +136,7 @@ export function fixModelAnimationClip(model, clip, clipScene, removeXZMovement,
             for (let i = 0; i < track.values.length; i += 3) {
                 position.fromArray(track.values, i);
                 if (clipSceneHips?.parent != null) {
-                    if (vrmBoneName === 'hips') {
+                    if (clipBoneName === 'hips') {
                         position.applyMatrix4(clipSceneHips.parent.matrixWorld);
                     }
                     else {
@@ -148,7 +144,7 @@ export function fixModelAnimationClip(model, clip, clipScene, removeXZMovement,
                     }
                 }
                 position.multiplyScalar(positionScale);
-                if (!(model instanceof VRM) && vrmBoneName === 'hips') {
+                if (!(model instanceof VRM) && clipBoneName === 'hips') {
                     position.applyQuaternion(nonVrmRotationOffset);
                 }
                 if (model instanceof VRM) {
@@ -157,7 +153,7 @@ export function fixModelAnimationClip(model, clip, clipScene, removeXZMovement,
                         position.y *= -1;
                     }
                 }
-                if (vrmBoneName === 'hips' && removeXZMovement) {
+                if (clipBoneName === 'hips' && removeXZMovement) {
                     position.x = 0;
                     position.z = 0;
                 }
@@ -170,10 +166,9 @@ export function fixModelAnimationClip(model, clip, clipScene, removeXZMovement,
         restRoot.parent = restRootParent;
     }
 }
-export * from './gltf.js';
-export * from './fbx.js';
-export * from './vrma.js';
 export * from './utils.js';
+export * from './default.js';
+export * from './mask.js';
 export function flattenCharacterAnimationOptions(options) {
     return [
         options.url,
@@ -186,12 +181,17 @@ export function flattenCharacterAnimationOptions(options) {
         options.mask,
     ];
 }
+const gltfLoader = new GLTFLoader();
+const fbxLoader = new FBXLoader();
+const bvhLoader = new BVHLoader();
 export async function loadCharacterAnimation(model, url, type, removeXZMovement = false, trimStartTime, trimEndTime, boneMap, scaleTime, mask) {
-    if (typeof url === 'object') {
-        url = await loadDefaultCharacterAnimationUrl(url.default);
+    if (typeof url === 'symbol') {
+        url = await resolveDefaultCharacterAnimationUrl(url);
         type = 'gltf';
     }
     let clips;
+    let clipScene;
+    let defaultBoneMap;
     if (type == null) {
         const lowerCaseUrl = url.toLocaleLowerCase();
         if (lowerCaseUrl.endsWith('.glb') || lowerCaseUrl.endsWith('.gltf')) {
@@ -211,29 +211,51 @@ export async function loadCharacterAnimation(model, url, type, removeXZMovement
         }
     }
     switch (type) {
-        case 'gltf':
-            clips = await loadVrmModelGltfAnimations(model, url, removeXZMovement, boneMap);
+        case 'gltf': {
+            const { animations, scene } = await gltfLoader.loadAsync(url);
+            clips = animations;
+            clipScene = scene;
             break;
-        case 'fbx':
-            clips = await loadVrmModelFbxAnimations(model, url, removeXZMovement, boneMap);
+        }
+        case 'fbx': {
+            const scene = await fbxLoader.loadAsync(url);
+            clips = scene.animations;
+            clipScene = scene;
             break;
-        case 'bvh':
-            clips = await loadVrmModelBvhAnimations(model, url, removeXZMovement, boneMap ?? bvhBoneMap);
+        }
+        case 'bvh': {
+            const { clip, skeleton } = await bvhLoader.loadAsync(url);
+            clips = [clip];
+            boneMap ??= bvhBoneMap;
             break;
-        case 'mixamo':
-            clips = await loadVrmModelFbxAnimations(model, url, removeXZMovement, boneMap ?? mixamoBoneMap);
+        }
+        case 'mixamo': {
+            const scene = await fbxLoader.loadAsync(url);
+            clips = scene.animations;
+            clipScene = scene;
+            boneMap ??= mixamoBoneMap;
             break;
+        }
         case 'vrma':
             if (!(model instanceof VRM)) {
                 throw new Error(`Model must be an instance of VRM to load VRMA animations`);
             }
-            clips = await loadVrmModelVrmaAnimations(model, url, removeXZMovement);
+            clips = (await vrmaLoader.loadAsync(url)).userData.vrmAnimations;
             break;
     }
     if (clips.length != 1) {
         throw new Error(`Expected exactly one animation clip, but got ${clips.length} for url ${url}`);
     }
     const [clip] = clips;
+    if (boneMap != null) {
+        applyBoneMap(clip, clipScene, boneMap);
+    }
+    if (mask != null) {
+        applyMask(clip, mask);
+    }
+    if (type != 'vrma') {
+        fixModelAnimationClip(model, clip, clipScene, removeXZMovement);
+    }
     if (trimStartTime != null || trimEndTime != null) {
         trimAnimationClip(clip, trimStartTime, trimEndTime);
     }

package/dist/animation/mask.d.ts

@@ -1,3 +1,6 @@
-import type { CharacterAnimationMask } from './index.js';
+import type { VRMHumanBoneName } from '@pixiv/three-vrm';
 import type { AnimationClip } from 'three';
+export type CharacterAnimationMask = (boneName: VRMHumanBoneName) => boolean;
 export declare function applyMask(clip: AnimationClip, mask: CharacterAnimationMask): void;
+export declare const upperBody: CharacterAnimationMask;
+export declare const lowerBody: CharacterAnimationMask;

package/dist/animation/mask.js

@@ -1,3 +1,53 @@
 export function applyMask(clip, mask) {
     clip.tracks = clip.tracks.filter((track) => mask(track.name.split('.')[0]));
 }
+const upperBodyParts = [
+    'spine',
+    'chest',
+    'upperChest',
+    'neck',
+    'head',
+    'leftEye',
+    'rightEye',
+    'jaw',
+    'leftShoulder',
+    'leftUpperArm',
+    'leftLowerArm',
+    'leftHand',
+    'rightShoulder',
+    'rightUpperArm',
+    'rightLowerArm',
+    'rightHand',
+    'leftThumbMetacarpal',
+    'leftThumbProximal',
+    'leftThumbDistal',
+    'leftIndexProximal',
+    'leftIndexIntermediate',
+    'leftIndexDistal',
+    'leftMiddleProximal',
+    'leftMiddleIntermediate',
+    'leftMiddleDistal',
+    'leftRingProximal',
+    'leftRingIntermediate',
+    'leftRingDistal',
+    'leftLittleProximal',
+    'leftLittleIntermediate',
+    'leftLittleDistal',
+    'rightThumbMetacarpal',
+    'rightThumbProximal',
+    'rightThumbDistal',
+    'rightIndexProximal',
+    'rightIndexIntermediate',
+    'rightIndexDistal',
+    'rightMiddleProximal',
+    'rightMiddleIntermediate',
+    'rightMiddleDistal',
+    'rightRingProximal',
+    'rightRingIntermediate',
+    'rightRingDistal',
+    'rightLittleProximal',
+    'rightLittleIntermediate',
+    'rightLittleDistal',
+];
+export const upperBody = (name) => upperBodyParts.includes(name);
+export const lowerBody = (name) => !upperBodyParts.includes(name);

package/dist/camera.d.ts

@@ -1,5 +1,4 @@
 import { Object3D, Vector3, Vector3Tuple, Ray } from 'three';
-import { InputSystem } from './input/index.js';
 export declare const FirstPersonCharacterCameraBehavior: SimpleCharacterCameraBehaviorOptions;
 export type SimpleCharacterCameraBehaviorOptions = {
     /**
@@ -61,6 +60,10 @@ export declare class CharacterCameraBehavior {
     zoomDistance: number;
     private collisionFreeZoomDistance;
     private firstUpdate;
+    private readonly abortController;
+    private readonly yawReader;
+    private readonly pitchReader;
+    private readonly zoomReader;
     private setRotationFromDelta;
     private setDistanceFromDelta;
     private computeCharacterBaseOffset;
@@ -70,5 +73,6 @@ export declare class CharacterCameraBehavior {
     /**
      * @param delta in seconds
      */
-    update(camera: Object3D, target: Object3D, inputSystem: InputSystem, deltaTime: number, raycast?: (ray: Ray, far: number) => number | undefined, options?: SimpleCharacterCameraBehaviorOptions): void;
+    update(camera: Object3D, target: Object3D, deltaTime: number, raycast?: (ray: Ray, far: number) => number | undefined, options?: SimpleCharacterCameraBehaviorOptions): void;
+    dispose(): void;
 }

package/dist/camera.js

@@ -1,6 +1,6 @@
-import { Vector3, Euler, Ray } from 'three';
+import { Vector3, Euler, Ray, Quaternion } from 'three';
 import { clamp } from 'three/src/math/MathUtils.js';
-import { DeltaYawField, DeltaPitchField, DeltaZoomField } from './input/index.js';
+import { RotatePitchAction, RotateYawAction, ZoomAction } from './input/index.js';
 export const FirstPersonCharacterCameraBehavior = {
     characterBaseOffset: [0, 1.6, 0],
     zoom: { maxDistance: 0, minDistance: 0 },
@@ -11,6 +11,7 @@ const sphericalOffset = new Vector3();
 const characterWorldPosition = new Vector3();
 const euler = new Euler();
 const rayHelper = new Ray();
+const quaternionHelper = new Quaternion();
 export class CharacterCameraBehavior {
     rotationPitch = (-20 * Math.PI) / 180;
     rotationYaw = 0;
@@ -18,6 +19,10 @@ export class CharacterCameraBehavior {
     //internal state
     collisionFreeZoomDistance = this.zoomDistance;
     firstUpdate = true;
+    abortController = new AbortController();
+    yawReader = RotateYawAction.createReader(this.abortController.signal);
+    pitchReader = RotatePitchAction.createReader(this.abortController.signal);
+    zoomReader = ZoomAction.createReader(this.abortController.signal);
     setRotationFromDelta(camera, delta, rotationOptions) {
         if (delta.lengthSq() < 0.0001) {
             // use current camera rotation if very close to target
@@ -55,7 +60,7 @@ export class CharacterCameraBehavior {
     /**
      * @param delta in seconds
      */
-    update(camera, target, inputSystem, deltaTime, raycast, options = true) {
+    update(camera, target, deltaTime, raycast, options = true) {
         if (options === false) {
             this.firstUpdate = true;
             return;
@@ -66,6 +71,8 @@ export class CharacterCameraBehavior {
         }
         //compute character->camera delta through offset
         this.computeCharacterBaseOffset(chracterBaseOffsetHelper, options.characterBaseOffset);
+        target.getWorldQuaternion(quaternionHelper);
+        chracterBaseOffsetHelper.applyQuaternion(quaternionHelper);
         target.getWorldPosition(characterWorldPosition);
         characterWorldPosition.add(chracterBaseOffsetHelper);
         camera.getWorldPosition(deltaHelper);
@@ -75,8 +82,10 @@ export class CharacterCameraBehavior {
         if (!this.firstUpdate && rotationOptions !== false) {
             rotationOptions = rotationOptions === true ? {} : rotationOptions;
             const rotationSpeed = rotationOptions.speed ?? 1000.0;
-            const deltaYaw = inputSystem.get(DeltaYawField);
-            const deltaPitch = inputSystem.get(DeltaPitchField);
+            this.yawReader.update();
+            this.pitchReader.update();
+            const deltaYaw = this.yawReader.get();
+            const deltaPitch = this.pitchReader.get();
             this.rotationYaw = this.clampYaw(this.rotationYaw + deltaYaw * rotationSpeed * deltaTime, rotationOptions);
             this.rotationPitch = this.clampPitch(this.rotationPitch + deltaPitch * rotationSpeed * deltaTime, rotationOptions);
         }
@@ -92,7 +101,8 @@ export class CharacterCameraBehavior {
         if (!this.firstUpdate && zoomOptions !== false) {
             zoomOptions = zoomOptions === true ? {} : zoomOptions;
             const zoomSpeed = zoomOptions.speed ?? 1000.0;
-            const deltaZoom = inputSystem.get(DeltaZoomField);
+            this.zoomReader.update();
+            const deltaZoom = this.zoomReader.get();
             const zoomFactor = 1 + deltaZoom * zoomSpeed * deltaTime;
             if (deltaZoom >= 0) {
                 this.zoomDistance *= zoomFactor;
@@ -120,10 +130,15 @@ export class CharacterCameraBehavior {
         sphericalOffset.set(0, 0, this.collisionFreeZoomDistance);
         sphericalOffset.applyEuler(camera.rotation);
         // Get target position with offset (reuse helper vector)
-        target.getWorldPosition(characterWorldPosition);
         this.computeCharacterBaseOffset(chracterBaseOffsetHelper, options.characterBaseOffset);
+        target.getWorldQuaternion(quaternionHelper);
+        chracterBaseOffsetHelper.applyQuaternion(quaternionHelper);
+        target.getWorldPosition(characterWorldPosition);
         characterWorldPosition.add(chracterBaseOffsetHelper);
         // Set camera position relative to target
         camera.position.copy(characterWorldPosition).add(sphericalOffset);
     }
+    dispose() {
+        this.abortController.abort();
+    }
 }

package/dist/input/action.d.ts

@@ -0,0 +1,41 @@
+export declare class EventAction<T = void> {
+    private latestTime;
+    private readonly subscriptionListeners;
+    emit(value: T): void;
+    subscribe(callback: (value: T) => void, options?: {
+        once?: true;
+        signal?: AbortSignal;
+    }): void;
+    waitFor(signal?: AbortSignal): Promise<T>;
+    getLatestTime(): number;
+}
+export type StateActionWriter<T> = {
+    write(value: T): void;
+};
+/**
+ * StateAction keeps the latest state per writer and merges them on read.
+ * Values persist until the writer is disposed (abortSignal aborts).
+ */
+export declare class StateAction<T> {
+    private readonly mergeWriters;
+    private readonly neutral;
+    private readonly absoluteActions;
+    constructor(mergeWriters: (...values: Array<T>) => T, neutral: T);
+    createWriter(abortSignal: AbortSignal): StateActionWriter<T>;
+    get(): T;
+}
+/**
+ * DeltaAction accumulates transient values each frame and clears them on frame advance.
+ * Multiple writes per frame from any source are combined using combine().
+ */
+export declare class DeltaAction<T> {
+    private readonly combine;
+    private readonly neutral;
+    constructor(combine: (...values: Array<T>) => T, neutral: T);
+    private readonly readers;
+    write(value: T): void;
+    createReader(abortSignal: AbortSignal): {
+        update(): void;
+        get(): T;
+    };
+}

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,31 +1,17 @@
-export declare class InputSystem<T extends {} = {}> {
-    options: T;
-    readonly inputs: Array<Input>;
-    constructor(options?: T);
-    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<O = {}> {
-    get<T>(field: InputField<T>, options: O): 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';