@pmndrs/viverse 0.2.0 → 0.2.2

package/dist/simple-character/index.js

@@ -1,26 +1,26 @@
 import { VRM, VRMUtils } from '@pixiv/three-vrm';
 import { runTimeline, GraphTimeline } from '@pmndrs/timeline';
 import { Group, Vector3 } from 'three';
+import { applySimpleCharacterActionBindingOptions } from './apply-input-options.js';
+import { KeyboardLocomotionActionBindings, PointerCaptureRotateZoomActionBindings, ScreenJoystickLocomotionActionBindings, ScreenButtonJumpActionBindings, } from '../action/index.js';
 import { CharacterCameraBehavior } from '../camera.js';
-import { LocomotionKeyboardInput, PointerCaptureInput, ScreenJoystickInput, ScreenJumpButtonInput, InputSystem, } from '../input/index.js';
 import { loadCharacterModel, flattenCharacterModelOptions, } from '../model/index.js';
 import { BvhCharacterPhysics } from '../physics/index.js';
+import { shouldJump } from '../utils.js';
 import { loadSimpleCharacterJumpDownState } from './state/jump-down.js';
 import { loadSimpleCharacterJumpForwardAction, loadSimpleCharacterJumpForwardState } from './state/jump-forward.js';
 import { loadSimpleCharacterJumpLoopState } from './state/jump-loop.js';
 import { loadSimpleCharacterJumpStartState } from './state/jump-start.js';
 import { loadSimpleCharacterJumpUpAction, loadSimpleCharacterJumpUpState } from './state/jump-up.js';
 import { loadSimpleCharacterMovingState } from './state/movement.js';
-import { updateSimpleCharacterInputVelocity } from './update-input-velocity.js';
+import { updateSimpleCharacterVelocity } from './update-input-velocity.js';
 import { updateSimpleCharacterRotation } from './update-rotation.js';
-import { shouldJump } from '../utils.js';
 export class SimpleCharacter extends Group {
     camera;
     world;
     options;
     cameraBehavior;
     physics;
-    inputSystem;
     currentAnimationRef = {};
     //loaded asychronously
     model;
@@ -28,24 +28,22 @@ export class SimpleCharacter extends Group {
     graph = new GraphTimeline('moving');
     abortController = new AbortController();
     lastJump = 0;
+    abortSignal = this.abortController.signal;
     constructor(camera, world, domElement, options = {}) {
         super();
         this.camera = camera;
         this.world = world;
         this.options = options;
-        this.inputSystem = new InputSystem();
-        const inputOptions = options.input ?? [
-            ScreenJoystickInput,
-            ScreenJumpButtonInput,
-            PointerCaptureInput,
-            LocomotionKeyboardInput,
-        ];
-        for (let input of inputOptions) {
-            this.inputSystem.add(typeof input === 'function' ? new input(domElement) : input);
-        }
+        const actionBindingsList = (options.actionBindings ??
+            options.input ?? [
+            ScreenJoystickLocomotionActionBindings,
+            ScreenButtonJumpActionBindings,
+            PointerCaptureRotateZoomActionBindings,
+            KeyboardLocomotionActionBindings,
+        ]).map((ActionBindings) => new ActionBindings(domElement, this.abortController.signal));
+        applySimpleCharacterActionBindingOptions(actionBindingsList, options.actionBindingOptions ?? options.inputOptions);
         // camera behavior
         this.cameraBehavior = new CharacterCameraBehavior();
-        console.log(this.graph);
         // physics
         this.physics = new BvhCharacterPhysics(world);
         // timeline graph
@@ -81,29 +79,30 @@ export class SimpleCharacter extends Group {
         const jumpOptions = this.options.movement?.jump;
         if (jumpOptions != false &&
             this.model == null &&
-            shouldJump(this.physics, this.inputSystem, this.lastJump, jumpOptions == true ? undefined : jumpOptions?.bufferTime)) {
+            shouldJump(this.physics, this.lastJump, jumpOptions == true ? undefined : jumpOptions?.bufferTime)) {
             this.physics.applyVelocity(new Vector3(0, (typeof this.options.movement?.jump === 'object' ? this.options.movement?.jump.speed : undefined) ?? 8, 0));
             this.lastJump = performance.now() / 1000;
         }
         if (this.model != null) {
             updateSimpleCharacterRotation(delta, this.physics, this.camera, this.model, this.options.animation);
         }
-        updateSimpleCharacterInputVelocity(this.camera, this.inputSystem, this.physics, this.options.movement);
+        updateSimpleCharacterVelocity(this.camera, this.physics, this.options.movement);
         this.updateTimeline?.(undefined, delta);
         this.model?.mixer.update(delta);
         if (this.model instanceof VRM) {
             this.model.update(delta);
         }
         this.physics.update(this, delta, this.options.physics);
-        this.cameraBehavior.update(this.camera, this, this.inputSystem, delta, this.world.raycast.bind(this.world), this.options.cameraBehavior);
+        this.cameraBehavior.update(this.camera, this, delta, this.world.raycast.bind(this.world), this.options.cameraBehavior);
     }
     dispose() {
         this.abortController.abort();
         this.parent?.remove(this);
         this.model?.scene.dispatchEvent({ type: 'dispose' });
-        this.inputSystem.dispose();
+        this.cameraBehavior.dispose();
         VRMUtils.deepDispose(this);
     }
 }
 export * from './update-input-velocity.js';
 export * from './update-rotation.js';
+export * from './apply-input-options.js';

package/dist/simple-character/state/jump-down.js

@@ -1,5 +1,6 @@
 import { action, timePassed } from '@pmndrs/timeline';
 import { LoopOnce } from 'three';
+import { JumpDownAnimationUrl } from '../../animation/default.js';
 import { flattenCharacterAnimationOptions, loadCharacterAnimation } from '../../animation/index.js';
 import { startAnimation } from '../../utils.js';
 import { DefaultCrossFadeDuration } from '../defaults.js';
@@ -8,7 +9,7 @@ export async function loadSimpleCharacterJumpDownState(state, options) {
     if (model == null) {
         throw new Error(`Unable to load animation without existing model`);
     }
-    const jumpDown = model.mixer.clipAction(await loadCharacterAnimation(model, ...flattenCharacterAnimationOptions(options.animation?.jumpDown ?? { url: { default: 'jumpDown' } })));
+    const jumpDown = model.mixer.clipAction(await loadCharacterAnimation(model, ...flattenCharacterAnimationOptions({ url: JumpDownAnimationUrl, ...options.animation?.jumpDown })));
     jumpDown.loop = LoopOnce;
     jumpDown.clampWhenFinished = true;
     return {

package/dist/simple-character/state/jump-forward.js

@@ -1,5 +1,6 @@
 import { action, animationFinished } from '@pmndrs/timeline';
 import { LoopOnce, Vector3 } from 'three';
+import { JumpForwardAnimationUrl } from '../../animation/default.js';
 import { flattenCharacterAnimationOptions, loadCharacterAnimation } from '../../animation/index.js';
 import { startAnimation } from '../../utils.js';
 import { DefaultCrossFadeDuration } from '../defaults.js';
@@ -8,9 +9,10 @@ export async function loadSimpleCharacterJumpForwardAction(state, options) {
     if (model == null) {
         throw new Error(`Unable to load animation without existing model`);
     }
-    const jumpForward = model.mixer.clipAction(await loadCharacterAnimation(model, ...flattenCharacterAnimationOptions(options.animation?.jumpForward ?? {
-        url: { default: 'jumpForward' },
+    const jumpForward = model.mixer.clipAction(await loadCharacterAnimation(model, ...flattenCharacterAnimationOptions({
+        url: JumpForwardAnimationUrl,
         scaleTime: 0.9,
+        ...options.animation?.jumpForward,
     })));
     jumpForward.loop = LoopOnce;
     jumpForward.clampWhenFinished = true;

package/dist/simple-character/state/jump-loop.js

@@ -1,4 +1,5 @@
 import { action } from '@pmndrs/timeline';
+import { JumpLoopAnimationUrl } from '../../animation/default.js';
 import { flattenCharacterAnimationOptions, loadCharacterAnimation } from '../../animation/index.js';
 import { startAnimation } from '../../utils.js';
 import { DefaultCrossFadeDuration } from '../defaults.js';
@@ -7,7 +8,7 @@ export async function loadSimpleCharacterJumpLoopState(state, options) {
     if (model == null) {
         throw new Error(`Unable to load animation without existing model`);
     }
-    const jumpLoop = model.mixer.clipAction(await loadCharacterAnimation(model, ...flattenCharacterAnimationOptions(options.animation?.jumpLoop ?? { url: { default: 'jumpLoop' } })));
+    const jumpLoop = model.mixer.clipAction(await loadCharacterAnimation(model, ...flattenCharacterAnimationOptions({ url: JumpLoopAnimationUrl, ...options.animation?.jumpLoop })));
     return {
         timeline: () => action({
             init: () => {

package/dist/simple-character/state/jump-start.js

@@ -1,5 +1,5 @@
 import { action, timePassed } from '@pmndrs/timeline';
-import { RunField } from '../../input/index.js';
+import { RunAction } from '../../action/index.js';
 import { startAnimation } from '../../utils.js';
 import { DefaultCrossFadeDuration, DefaultJumDelay } from '../defaults.js';
 export async function loadSimpleCharacterJumpStartState(jumpUp, jumpForward, state, options) {
@@ -24,7 +24,7 @@ export async function loadSimpleCharacterJumpStartState(jumpUp, jumpForward, sta
         }),
         transitionTo: {
             jumpDown: { whenUpdate: () => !state.physics.isGrounded },
-            finally: () => (state.inputSystem.get(RunField) ? 'jumpForward' : 'jumpUp'),
+            finally: () => (RunAction.get() ? 'jumpForward' : 'jumpUp'),
         },
     };
 }

package/dist/simple-character/state/jump-up.js

@@ -1,5 +1,6 @@
 import { action, animationFinished } from '@pmndrs/timeline';
 import { LoopOnce, Vector3 } from 'three';
+import { JumpUpAnimationUrl } from '../../animation/default.js';
 import { flattenCharacterAnimationOptions, loadCharacterAnimation } from '../../animation/index.js';
 import { startAnimation } from '../../utils.js';
 export async function loadSimpleCharacterJumpUpAction(state, options) {
@@ -7,8 +8,9 @@ export async function loadSimpleCharacterJumpUpAction(state, options) {
     if (model == null) {
         throw new Error(`Unable to load animation without existing model`);
     }
-    const jumpUp = model.mixer.clipAction(await loadCharacterAnimation(model, ...flattenCharacterAnimationOptions(options.animation?.jumpUp ?? {
-        url: { default: 'jumpUp' },
+    const jumpUp = model.mixer.clipAction(await loadCharacterAnimation(model, ...flattenCharacterAnimationOptions({
+        url: JumpUpAnimationUrl,
+        ...options.animation?.jumpUp,
     })));
     jumpUp.loop = LoopOnce;
     jumpUp.clampWhenFinished = true;

package/dist/simple-character/state/movement.js

@@ -1,6 +1,7 @@
 import { action } from '@pmndrs/timeline';
+import { RunAction } from '../../action/index.js';
+import { IdleAnimationUrl, RunAnimationUrl, WalkAnimationUrl } from '../../animation/default.js';
 import { flattenCharacterAnimationOptions, loadCharacterAnimation } from '../../animation/index.js';
-import { RunField } from '../../input/index.js';
 import { shouldJump, startAnimation } from '../../utils.js';
 import { DefaultCrossFadeDuration } from '../defaults.js';
 export async function loadSimpleCharacterMovingState(state, options) {
@@ -8,16 +9,19 @@ export async function loadSimpleCharacterMovingState(state, options) {
     if (model == null) {
         throw new Error(`Unable to load animation without existing model`);
     }
-    const idle = model.mixer.clipAction(await loadCharacterAnimation(model, ...flattenCharacterAnimationOptions(options.animation?.idle ?? {
-        url: { default: 'idle' },
+    const idle = model.mixer.clipAction(await loadCharacterAnimation(model, ...flattenCharacterAnimationOptions({
+        url: IdleAnimationUrl,
+        ...options.animation?.idle,
     })));
     const run = model.mixer.clipAction(await loadCharacterAnimation(model, ...flattenCharacterAnimationOptions({
-        url: { default: 'run' },
+        url: RunAnimationUrl,
         scaleTime: 0.8,
+        ...options.animation?.run,
     })));
-    const walk = model.mixer.clipAction(await loadCharacterAnimation(model, ...flattenCharacterAnimationOptions(options.animation?.walk ?? {
+    const walk = model.mixer.clipAction(await loadCharacterAnimation(model, ...flattenCharacterAnimationOptions({
         scaleTime: 0.5,
-        url: { default: 'walk' },
+        url: WalkAnimationUrl,
+        ...options.animation?.walk,
     })));
     return {
         timeline: () => {
@@ -28,7 +32,7 @@ export async function loadSimpleCharacterMovingState(state, options) {
                     if (state.physics.inputVelocity.lengthSq() === 0) {
                         nextAnimation = idle;
                     }
-                    else if (state.inputSystem.get(RunField) && options.movement?.run != false) {
+                    else if (RunAction.get() && options.movement?.run != false) {
                         nextAnimation = run;
                     }
                     else if (options.movement?.walk != false) {
@@ -51,7 +55,7 @@ export async function loadSimpleCharacterMovingState(state, options) {
         transitionTo: {
             jumpStart: {
                 whenUpdate: () => options.movement?.jump !== false &&
-                    shouldJump(state.physics, state.inputSystem, state.lastJump, options.movement?.jump === true ? undefined : options.movement?.jump?.bufferTime),
+                    shouldJump(state.physics, state.lastJump, options.movement?.jump === true ? undefined : options.movement?.jump?.bufferTime),
             },
             jumpLoop: { whenUpdate: () => !state.physics.isGrounded },
         },

package/dist/simple-character/update-input-velocity.d.ts

@@ -1,5 +1,4 @@
 import { Object3D } from 'three';
-import { InputSystem } from '../input/index.js';
 import type { SimpleCharacterMovementOptions } from './index.js';
 import type { BvhCharacterPhysics } from '../physics/index.js';
-export declare function updateSimpleCharacterInputVelocity(camera: Object3D, inputSystem: InputSystem, physics: BvhCharacterPhysics, options?: SimpleCharacterMovementOptions): void;
+export declare function updateSimpleCharacterVelocity(camera: Object3D, physics: BvhCharacterPhysics, options?: SimpleCharacterMovementOptions): void;

package/dist/simple-character/update-input-velocity.js

@@ -1,14 +1,14 @@
 import { Euler, Quaternion } from 'three';
-import { RunField, MoveLeftField, MoveRightField, MoveForwardField, MoveBackwardField, } from '../input/index.js';
+import { RunAction, MoveLeftAction, MoveRightAction, MoveForwardAction, MoveBackwardAction } from '../action/index.js';
 const cameraEuler = new Euler();
 const cameraRotation = new Quaternion();
-export function updateSimpleCharacterInputVelocity(camera, inputSystem, physics, options) {
+export function updateSimpleCharacterVelocity(camera, physics, options) {
     cameraEuler.setFromQuaternion(camera.getWorldQuaternion(cameraRotation), 'YXZ');
     cameraEuler.x = 0;
     cameraEuler.z = 0;
     let inputSpeed = 0;
     let runOptions = options?.run ?? true;
-    if (inputSystem.get(RunField) && runOptions !== false) {
+    if (RunAction.get() && runOptions !== false) {
         runOptions = runOptions === true ? {} : runOptions;
         inputSpeed = runOptions.speed ?? 6;
     }
@@ -18,7 +18,7 @@ export function updateSimpleCharacterInputVelocity(camera, inputSystem, physics,
         inputSpeed = walkOptions.speed ?? 3;
     }
     physics.inputVelocity
-        .set(-inputSystem.get(MoveLeftField) + inputSystem.get(MoveRightField), 0, -inputSystem.get(MoveForwardField) + inputSystem.get(MoveBackwardField))
+        .set(-MoveLeftAction.get() + MoveRightAction.get(), 0, -MoveForwardAction.get() + MoveBackwardAction.get())
         .normalize()
         .applyEuler(cameraEuler)
         .multiplyScalar(inputSpeed);

package/dist/simple-character/update-rotation.js

@@ -7,7 +7,7 @@ const inputDirection = new Vector3();
 const quaternion = new Quaternion();
 export function updateSimpleCharacterRotation(delta, physics, camera, model, options) {
     // Character yaw rotation logic
-    const basedOn = options?.yawRotationBasdOn ?? 'movement';
+    const basedOn = options?.yawRotationBasedOn ?? 'movement';
     // compute goalTargetEuler
     if (basedOn === 'camera') {
         goalTargetEuler.setFromQuaternion(camera.getWorldQuaternion(quaternion), 'YXZ');

package/dist/utils.d.ts

@@ -1,5 +1,3 @@
-import { type InputSystem } from './input/index.js';
-import type { CharacterAnimationMask } from './animation/index.js';
 import type { CharacterModel } from './model/index.js';
 import type { BvhCharacterPhysics } from './physics/index.js';
 import type { AnimationAction } from 'three';
@@ -7,8 +5,10 @@ export declare function getIsMobileMediaQuery(): MediaQueryList | undefined;
 export declare function isMobile(): boolean;
 export type StartAnimationOptions = {
     fadeDuration?: number;
+    sync?: boolean;
     paused?: boolean;
-    mask?: CharacterAnimationMask;
+    crossFade?: boolean;
+    layer?: string;
 };
-export declare function startAnimation(animation: AnimationAction, currentAnimations: CharacterModel['currentAnimations'], { fadeDuration, paused, mask }: StartAnimationOptions): void;
-export declare function shouldJump(physics: BvhCharacterPhysics, inputSystem: InputSystem, lastJump: number, bufferTime?: number): boolean;
+export declare function startAnimation(animation: AnimationAction, currentAnimations: CharacterModel['currentAnimations'], { crossFade, layer, fadeDuration, paused, sync }: StartAnimationOptions): (() => void) | undefined;
+export declare function shouldJump(physics: BvhCharacterPhysics, lastJump: number, bufferTime?: number): boolean;

package/dist/utils.js

@@ -1,4 +1,4 @@
-import { LastTimeJumpPressedField } from './input/index.js';
+import { JumpAction } from './action/index.js';
 export function getIsMobileMediaQuery() {
     if (typeof window === 'undefined' || typeof window.matchMedia !== 'function') {
         return undefined;
@@ -8,24 +8,33 @@ export function getIsMobileMediaQuery() {
 export function isMobile() {
     return getIsMobileMediaQuery()?.matches ?? false;
 }
-export function startAnimation(animation, currentAnimations, { fadeDuration = 0.1, paused = false, mask }) {
+export function startAnimation(animation, currentAnimations, { crossFade = true, layer, fadeDuration = 0.1, paused = false, sync = false }) {
     animation.reset();
     animation.play();
     animation.paused = paused;
-    const currentAnimation = currentAnimations.get(mask);
+    if (!crossFade) {
+        animation.fadeIn(fadeDuration);
+        return () => {
+            animation.fadeOut(fadeDuration);
+        };
+    }
+    const currentAnimation = currentAnimations.get(layer);
+    if (currentAnimation != null && sync) {
+        animation.syncWith(currentAnimation);
+    }
     if (currentAnimation != null) {
         animation.crossFadeFrom(currentAnimation, fadeDuration);
     }
     else {
         animation.fadeIn(fadeDuration);
     }
-    currentAnimations.set(mask, animation);
+    currentAnimations.set(layer, animation);
 }
-export function shouldJump(physics, inputSystem, lastJump, bufferTime = 0.1) {
+export function shouldJump(physics, lastJump, bufferTime = 0.1) {
     if (!physics.isGrounded) {
         return false;
     }
-    const lastTimePressed = inputSystem.get(LastTimeJumpPressedField);
+    const lastTimePressed = JumpAction.getLatestTime();
     if (lastTimePressed == null || lastJump > lastTimePressed) {
         return false;
     }

package/package.json

@@ -21,12 +21,12 @@
   "peerDependencies": {
     "three": "*"
   },
-  "version": "0.2.0",
+  "version": "0.2.2",
   "type": "module",
   "dependencies": {
     "@pixiv/three-vrm": "^3.4.2",
     "@pixiv/three-vrm-animation": "^3.4.2",
-    "@pmndrs/timeline": "^0.3.5",
+    "@pmndrs/timeline": "^0.3.7",
     "@viverse/sdk": "1.2.10-alpha.0",
     "three-mesh-bvh": "^0.9.1"
   },

package/dist/animation/bvh.d.ts

@@ -1,4 +0,0 @@
-import { AnimationClip } from 'three';
-import type { CharacterModel } from '../model/index.js';
-import type { VRMHumanBoneName } from '@pixiv/three-vrm';
-export declare function loadVrmModelBvhAnimations(model: CharacterModel, url: string, removeXZMovement: boolean, boneMap?: Record<string, VRMHumanBoneName>): Promise<Array<AnimationClip>>;

package/dist/animation/bvh.js

@@ -1,8 +0,0 @@
-import { BVHLoader } from 'three/examples/jsm/Addons.js';
-import { bvhBoneMap, fixModelAnimationClip } from './index.js';
-const loader = new BVHLoader();
-export async function loadVrmModelBvhAnimations(model, url, removeXZMovement, boneMap) {
-    const clipScene = await loader.loadAsync(url);
-    fixModelAnimationClip(model, clipScene.clip, undefined, removeXZMovement, boneMap ?? bvhBoneMap);
-    return [clipScene.clip];
-}

package/dist/animation/fbx.d.ts

@@ -1,4 +0,0 @@
-import { AnimationClip } from 'three';
-import type { CharacterModel } from '../model/index.js';
-import type { VRMHumanBoneName } from '@pixiv/three-vrm';
-export declare function loadVrmModelFbxAnimations(model: CharacterModel, url: string, removeXZMovement: boolean, boneMap?: Record<string, VRMHumanBoneName>): Promise<Array<AnimationClip>>;

package/dist/animation/fbx.js

@@ -1,8 +0,0 @@
-import { FBXLoader } from 'three/examples/jsm/Addons.js';
-import { fixModelAnimationClip } from './index.js';
-const loader = new FBXLoader();
-export async function loadVrmModelFbxAnimations(model, url, removeXZMovement, boneMap) {
-    const clipScene = await loader.loadAsync(url);
-    clipScene.animations.forEach((clip) => fixModelAnimationClip(model, clip, clipScene, removeXZMovement, boneMap));
-    return clipScene.animations;
-}

package/dist/animation/gltf.d.ts

@@ -1,3 +0,0 @@
-import { AnimationClip } from 'three';
-import type { CharacterModel, VRMHumanBoneName } from '../model/index.js';
-export declare function loadVrmModelGltfAnimations(model: CharacterModel, url: string, removeXZMovement: boolean, boneMap?: Record<string, VRMHumanBoneName>): Promise<Array<AnimationClip>>;

package/dist/animation/gltf.js

@@ -1,8 +0,0 @@
-import { GLTFLoader } from 'three/examples/jsm/Addons.js';
-import { fixModelAnimationClip } from './index.js';
-const loader = new GLTFLoader();
-export async function loadVrmModelGltfAnimations(model, url, removeXZMovement, boneMap) {
-    const { animations, scene: clipScene } = await loader.loadAsync(url);
-    animations.forEach((clip) => fixModelAnimationClip(model, clip, clipScene, removeXZMovement, boneMap));
-    return animations;
-}

package/dist/animation/vrma.d.ts

@@ -1,3 +0,0 @@
-import { VRM } from '@pixiv/three-vrm';
-import { AnimationClip } from 'three';
-export declare function loadVrmModelVrmaAnimations(vrm: VRM, url: string, removeXZMovement: boolean): Promise<Array<AnimationClip>>;

package/dist/animation/vrma.js

@@ -1,8 +0,0 @@
-import { createVRMAnimationClip } from '@pixiv/three-vrm-animation';
-import { vrmaLoader } from '../index.js';
-export async function loadVrmModelVrmaAnimations(vrm, url, removeXZMovement) {
-    const animations = await vrmaLoader.loadAsync(url);
-    const vrmAnimations = animations.userData.vrmAnimations;
-    const clips = vrmAnimations.map((vrmAnimation) => createVRMAnimationClip(vrmAnimation, vrm));
-    return clips;
-}

package/dist/input/index.d.ts

@@ -1,31 +0,0 @@
-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;
-}
-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';

package/dist/input/index.js

@@ -1,77 +0,0 @@
-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;
-    }
-}
-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,
-};
-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';

package/dist/input/keyboard.d.ts

@@ -1,16 +0,0 @@
-import { Input, InputField } from './index.js';
-export type LocomotionKeyboardInputOptions = {
-    keyboardMoveForwardKeys?: Array<string>;
-    keyboardMoveBackwardKeys?: Array<string>;
-    keyboardMoveLeftKeys?: Array<string>;
-    keyboardMoveRightKeys?: Array<string>;
-    keyboardRunKeys?: Array<string>;
-    keyboardJumpKeys?: Array<string>;
-};
-export declare class LocomotionKeyboardInput implements Input<LocomotionKeyboardInputOptions> {
-    private readonly abortController;
-    private readonly keyState;
-    constructor(domElement: HTMLElement);
-    get<T>(field: InputField<T>, options: LocomotionKeyboardInputOptions): T | undefined;
-    dispose(): void;
-}

package/dist/input/keyboard.js

@@ -1,82 +0,0 @@
-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 {
-    abortController = new AbortController();
-    keyState = new Map();
-    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 }));
-            }
-            else {
-                state.pressTime = now;
-            }
-        }, {
-            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 }));
-            }
-            else {
-                state.releaseTime = now;
-            }
-        }, {
-            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;
-            }
-            return state.releaseTime == null || state.pressTime > state.releaseTime;
-        });
-    }
-    dispose() {
-        this.abortController.abort();
-    }
-}