@pmndrs/viverse 0.2.0 → 0.2.1

package/dist/model/index.d.ts

@@ -1,5 +1,4 @@
 import { AnimationAction, AnimationMixer, Object3D, Quaternion } from 'three';
-import { CharacterAnimationMask } from '../animation/index.js';
 export { VRMHumanBoneName } from '@pixiv/three-vrm';
 export * from './vrm.js';
 export type CharacterModelOptions = {
@@ -23,7 +22,7 @@ export declare function flattenCharacterModelOptions(options: Exclude<CharacterM
 export type CharacterModel = {
     mixer: AnimationMixer;
     scene: Object3D;
-    currentAnimations: Map<CharacterAnimationMask | undefined, AnimationAction>;
+    currentAnimations: Map<string | undefined, AnimationAction>;
     boneRotationOffset?: Quaternion;
 };
 export declare function loadCharacterModel(url?: string, type?: Exclude<CharacterModelOptions, boolean>['type'], boneRotationOffset?: Quaternion, castShadow?: boolean, receiveShadow?: boolean): Promise<CharacterModel>;

package/dist/simple-character/apply-input-options.d.ts

@@ -0,0 +1,2 @@
+import { SimpleCharacterInputOptions } from './index.js';
+export declare function applySimpleCharacterInputOptions(inputs: Array<unknown>, options?: SimpleCharacterInputOptions): void;

package/dist/simple-character/apply-input-options.js

@@ -0,0 +1,28 @@
+import { DefaultJumpKeys, DefaultMoveBackwardKeys, DefaultMoveForwardKeys, DefaultMoveLeftKeys, DefaultMoveRightKeys, DefaultRunKeys, LocomotionKeyboardInput, } from '../input/keyboard.js';
+import { PointerCaptureInput } from '../input/pointer-capture.js';
+import { PointerLockInput } from '../input/pointer-lock.js';
+import { ScreenJoystickInput } from '../input/screen-joystick.js';
+export function applySimpleCharacterInputOptions(inputs, options) {
+    for (const input of inputs) {
+        if (input instanceof ScreenJoystickInput) {
+            input.options.deadZonePx = options?.screenJoystickDeadZonePx;
+            input.options.runDistancePx = options?.screenJoystickRunDistancePx;
+        }
+        if (input instanceof PointerCaptureInput) {
+            input.options.rotationSpeed = options?.pointerCaptureRotationSpeed;
+            input.options.zoomSpeed = options?.pointerCaptureZoomSpeed;
+        }
+        if (input instanceof PointerLockInput) {
+            input.options.rotationSpeed = options?.pointerLockRotationSpeed;
+            input.options.zoomSpeed = options?.pointerLockZoomSpeed;
+        }
+        if (input instanceof LocomotionKeyboardInput) {
+            input.forward.options.keys = options?.keyboardMoveForwardKeys ?? DefaultMoveForwardKeys;
+            input.backward.options.keys = options?.keyboardMoveBackwardKeys ?? DefaultMoveBackwardKeys;
+            input.left.options.keys = options?.keyboardMoveLeftKeys ?? DefaultMoveLeftKeys;
+            input.right.options.keys = options?.keyboardMoveRightKeys ?? DefaultMoveRightKeys;
+            input.run.options.keys = options?.keyboardRunKeys ?? DefaultRunKeys;
+            input.jump.options.keys = options?.keyboardJumpKeys ?? DefaultJumpKeys;
+        }
+    }
+}

package/dist/simple-character/index.d.ts

@@ -1,14 +1,12 @@
 import { Group, Object3D, Object3DEventMap, AnimationAction } from 'three';
 import { CharacterAnimationOptions } from '../animation/index.js';
 import { CharacterCameraBehavior, SimpleCharacterCameraBehaviorOptions } from '../camera.js';
-import { Input, ScreenJoystickInputOptions, LocomotionKeyboardInputOptions, PointerCaptureInputOptions, PointerLockInputOptions, InputSystem } from '../input/index.js';
 import { CharacterModelOptions, CharacterModel } from '../model/index.js';
 import { BvhCharacterPhysicsOptions, BvhCharacterPhysics, BvhPhysicsWorld } from '../physics/index.js';
 export type SimpleCharacterState = {
     camera: Object3D;
     model?: CharacterModel;
     physics: BvhCharacterPhysics;
-    inputSystem: InputSystem;
     lastJump: number;
 };
 export type SimpleCharacterMovementOptions = {
@@ -63,10 +61,25 @@ export type SimpleCharacterAnimationOptions = {
      */
     crossFadeDuration?: number;
 };
-export type SimpleCharacterInputOptions = ScreenJoystickInputOptions & PointerCaptureInputOptions & PointerLockInputOptions & LocomotionKeyboardInputOptions;
+export type SimpleCharacterInputOptions = {
+    screenJoystickRunDistancePx?: number;
+    screenJoystickDeadZonePx?: number;
+    pointerCaptureRotationSpeed?: number;
+    pointerCaptureZoomSpeed?: number;
+    pointerLockRotationSpeed?: number;
+    pointerLockZoomSpeed?: number;
+    keyboardMoveForwardKeys?: Array<string>;
+    keyboardMoveBackwardKeys?: Array<string>;
+    keyboardMoveLeftKeys?: Array<string>;
+    keyboardMoveRightKeys?: Array<string>;
+    keyboardRunKeys?: Array<string>;
+    keyboardJumpKeys?: Array<string>;
+};
 export type SimpleCharacterOptions = {
-    readonly input?: ReadonlyArray<Input | {
-        new (domElement: HTMLElement): Input;
+    readonly input?: ReadonlyArray<{
+        new (domElement: HTMLElement): {
+            dispose(): void;
+        };
     }>;
     inputOptions?: SimpleCharacterInputOptions;
     movement?: SimpleCharacterMovementOptions;
@@ -83,7 +96,6 @@ export declare class SimpleCharacter extends Group<Object3DEventMap & {
     private readonly options;
     readonly cameraBehavior: CharacterCameraBehavior;
     readonly physics: BvhCharacterPhysics;
-    readonly inputSystem: InputSystem;
     readonly currentAnimationRef: {
         current?: AnimationAction;
     };
@@ -91,7 +103,9 @@ export declare class SimpleCharacter extends Group<Object3DEventMap & {
     private readonly updateTimeline;
     private readonly graph;
     private readonly abortController;
+    private readonly inputs;
     lastJump: number;
+    readonly abortSignal: AbortSignal;
     constructor(camera: Object3D, world: BvhPhysicsWorld, domElement: HTMLElement, options?: SimpleCharacterOptions);
     private init;
     update(delta: number): void;
@@ -99,3 +113,4 @@ export declare class SimpleCharacter extends Group<Object3DEventMap & {
 }
 export * from './update-input-velocity.js';
 export * from './update-rotation.js';
+export * from './apply-input-options.js';

package/dist/simple-character/index.js

@@ -2,7 +2,7 @@ import { VRM, VRMUtils } from '@pixiv/three-vrm';
 import { runTimeline, GraphTimeline } from '@pmndrs/timeline';
 import { Group, Vector3 } from 'three';
 import { CharacterCameraBehavior } from '../camera.js';
-import { LocomotionKeyboardInput, PointerCaptureInput, ScreenJoystickInput, ScreenJumpButtonInput, InputSystem, } from '../input/index.js';
+import { LocomotionKeyboardInput, PointerCaptureInput, ScreenJoystickInput, ScreenJumpButtonInput, } from '../input/index.js';
 import { loadCharacterModel, flattenCharacterModelOptions, } from '../model/index.js';
 import { BvhCharacterPhysics } from '../physics/index.js';
 import { loadSimpleCharacterJumpDownState } from './state/jump-down.js';
@@ -14,38 +14,31 @@ import { loadSimpleCharacterMovingState } from './state/movement.js';
 import { updateSimpleCharacterInputVelocity } from './update-input-velocity.js';
 import { updateSimpleCharacterRotation } from './update-rotation.js';
 import { shouldJump } from '../utils.js';
+import { applySimpleCharacterInputOptions } from './apply-input-options.js';
 export class SimpleCharacter extends Group {
     camera;
     world;
     options;
     cameraBehavior;
     physics;
-    inputSystem;
     currentAnimationRef = {};
     //loaded asychronously
     model;
     updateTimeline;
     graph = new GraphTimeline('moving');
     abortController = new AbortController();
+    inputs;
     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);
-        }
+        this.inputs = (options.input ?? [ScreenJoystickInput, ScreenJumpButtonInput, PointerCaptureInput, LocomotionKeyboardInput]).map((Input) => new Input(domElement));
+        applySimpleCharacterInputOptions(this.inputs, options.inputOptions);
         // camera behavior
         this.cameraBehavior = new CharacterCameraBehavior();
-        console.log(this.graph);
         // physics
         this.physics = new BvhCharacterPhysics(world);
         // timeline graph
@@ -81,29 +74,31 @@ 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);
+        updateSimpleCharacterInputVelocity(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.inputs.forEach((input) => input.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 '../../input/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 { IdleAnimationUrl, RunAnimationUrl, WalkAnimationUrl } from '../../animation/default.js';
 import { flattenCharacterAnimationOptions, loadCharacterAnimation } from '../../animation/index.js';
-import { RunField } from '../../input/index.js';
+import { RunAction } 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 updateSimpleCharacterInputVelocity(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 '../input/index.js';
 const cameraEuler = new Euler();
 const cameraRotation = new Quaternion();
-export function updateSimpleCharacterInputVelocity(camera, inputSystem, physics, options) {
+export function updateSimpleCharacterInputVelocity(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/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 './input/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.1",
   "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;
-}