@pmndrs/viverse 0.1.19 → 0.2.0

package/dist/simple-character/index.js

@@ -0,0 +1,109 @@
+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 { loadCharacterModel, flattenCharacterModelOptions, } from '../model/index.js';
+import { BvhCharacterPhysics } from '../physics/index.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 { 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;
+    updateTimeline;
+    graph = new GraphTimeline('moving');
+    abortController = new AbortController();
+    lastJump = 0;
+    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);
+        }
+        // camera behavior
+        this.cameraBehavior = new CharacterCameraBehavior();
+        console.log(this.graph);
+        // physics
+        this.physics = new BvhCharacterPhysics(world);
+        // timeline graph
+        this.updateTimeline = runTimeline(this.graph.run(), this.abortController.signal);
+        //init resource loading
+        this.init(this.options).catch(console.error);
+    }
+    async init(options) {
+        if (options.model === false) {
+            return;
+        }
+        this.model = await loadCharacterModel(...flattenCharacterModelOptions(options.model === true ? undefined : options.model));
+        this.add(this.model.scene);
+        const [jumpForwardAction, jumpUpAction] = await Promise.all([
+            loadSimpleCharacterJumpForwardAction(this, options),
+            loadSimpleCharacterJumpUpAction(this, options),
+        ]);
+        await Promise.all([
+            loadSimpleCharacterJumpDownState(this, options).then((state) => this.graph.attach('jumpDown', state.timeline, state.transitionTo)),
+            loadSimpleCharacterJumpLoopState(this, options).then((state) => this.graph.attach('jumpLoop', state.timeline, state.transitionTo)),
+            ,
+            loadSimpleCharacterJumpForwardState(jumpForwardAction, this, options).then((state) => this.graph.attach('jumpForward', state.timeline, state.transitionTo)),
+            ,
+            loadSimpleCharacterJumpUpState(jumpUpAction, this, options).then((state) => this.graph.attach('jumpUp', state.timeline, state.transitionTo)),
+            ,
+            loadSimpleCharacterJumpStartState(jumpUpAction, jumpForwardAction, this, options).then((state) => this.graph.attach('jumpStart', state.timeline, state.transitionTo)),
+            ,
+            loadSimpleCharacterMovingState(this, options).then((state) => this.graph.attach('moving', state.timeline, state.transitionTo)),
+            ,
+        ]);
+    }
+    update(delta) {
+        const jumpOptions = this.options.movement?.jump;
+        if (jumpOptions != false &&
+            this.model == null &&
+            shouldJump(this.physics, this.inputSystem, 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);
+        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);
+    }
+    dispose() {
+        this.abortController.abort();
+        this.parent?.remove(this);
+        this.model?.scene.dispatchEvent({ type: 'dispose' });
+        this.inputSystem.dispose();
+        VRMUtils.deepDispose(this);
+    }
+}
+export * from './update-input-velocity.js';
+export * from './update-rotation.js';

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

@@ -0,0 +1,6 @@
+export * from './jump-down.js';
+export * from './jump-loop.js';
+export * from './jump-start.js';
+export * from './jump-forward.js';
+export * from './jump-up.js';
+export * from './movement.js';

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

@@ -0,0 +1,6 @@
+export * from './jump-down.js';
+export * from './jump-loop.js';
+export * from './jump-start.js';
+export * from './jump-forward.js';
+export * from './jump-up.js';
+export * from './movement.js';

package/dist/simple-character/state/jump-down.d.ts

@@ -0,0 +1,3 @@
+import { type GraphTimelineState } from '@pmndrs/timeline';
+import type { SimpleCharacterState, SimpleCharacterOptions } from '../index.js';
+export declare function loadSimpleCharacterJumpDownState<T>(state: SimpleCharacterState, options: SimpleCharacterOptions): Promise<GraphTimelineState<T>>;

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

@@ -0,0 +1,25 @@
+import { action, timePassed } from '@pmndrs/timeline';
+import { LoopOnce } from 'three';
+import { flattenCharacterAnimationOptions, loadCharacterAnimation } from '../../animation/index.js';
+import { startAnimation } from '../../utils.js';
+import { DefaultCrossFadeDuration } from '../defaults.js';
+export async function loadSimpleCharacterJumpDownState(state, options) {
+    const model = state.model;
+    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' } })));
+    jumpDown.loop = LoopOnce;
+    jumpDown.clampWhenFinished = true;
+    return {
+        timeline: () => action({
+            init: () => {
+                startAnimation(jumpDown, model.currentAnimations, {
+                    fadeDuration: options.animation?.crossFadeDuration ?? DefaultCrossFadeDuration,
+                });
+            },
+            until: timePassed(150, 'milliseconds'),
+        }),
+        transitionTo: { finally: 'moving' },
+    };
+}

package/dist/simple-character/state/jump-forward.d.ts

@@ -0,0 +1,5 @@
+import { type GraphTimelineState } from '@pmndrs/timeline';
+import { AnimationAction } from 'three';
+import { SimpleCharacterState, SimpleCharacterOptions } from '../index.js';
+export declare function loadSimpleCharacterJumpForwardAction(state: SimpleCharacterState, options: SimpleCharacterOptions): Promise<AnimationAction>;
+export declare function loadSimpleCharacterJumpForwardState<T>(jumpForward: AnimationAction, state: SimpleCharacterState, options: SimpleCharacterOptions): Promise<GraphTimelineState<T>>;

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

@@ -0,0 +1,39 @@
+import { action, animationFinished } from '@pmndrs/timeline';
+import { LoopOnce, Vector3 } from 'three';
+import { flattenCharacterAnimationOptions, loadCharacterAnimation } from '../../animation/index.js';
+import { startAnimation } from '../../utils.js';
+import { DefaultCrossFadeDuration } from '../defaults.js';
+export async function loadSimpleCharacterJumpForwardAction(state, options) {
+    const model = state.model;
+    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' },
+        scaleTime: 0.9,
+    })));
+    jumpForward.loop = LoopOnce;
+    jumpForward.clampWhenFinished = true;
+    return jumpForward;
+}
+export async function loadSimpleCharacterJumpForwardState(jumpForward, state, options) {
+    const model = state.model;
+    if (model == null) {
+        throw new Error(`Unable to load animation state without existing model`);
+    }
+    return {
+        timeline: () => action({
+            init: () => {
+                startAnimation(jumpForward, model.currentAnimations, {
+                    fadeDuration: options.animation?.crossFadeDuration ?? DefaultCrossFadeDuration,
+                });
+                state.lastJump = performance.now() / 1000;
+                state.physics.applyVelocity(new Vector3(0, (typeof options.movement?.jump === 'object' ? options.movement?.jump.speed : undefined) ?? 8, 0));
+            },
+            until: animationFinished(jumpForward),
+        }),
+        transitionTo: {
+            finally: () => (state.physics.isGrounded ? 'moving' : 'jumpLoop'),
+        },
+    };
+}

package/dist/simple-character/state/jump-loop.d.ts

@@ -0,0 +1,3 @@
+import { type GraphTimelineState } from '@pmndrs/timeline';
+import type { SimpleCharacterOptions, SimpleCharacterState } from '../index.js';
+export declare function loadSimpleCharacterJumpLoopState<T>(state: SimpleCharacterState, options: SimpleCharacterOptions): Promise<GraphTimelineState<T>>;

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

@@ -0,0 +1,23 @@
+import { action } from '@pmndrs/timeline';
+import { flattenCharacterAnimationOptions, loadCharacterAnimation } from '../../animation/index.js';
+import { startAnimation } from '../../utils.js';
+import { DefaultCrossFadeDuration } from '../defaults.js';
+export async function loadSimpleCharacterJumpLoopState(state, options) {
+    const model = state.model;
+    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' } })));
+    return {
+        timeline: () => action({
+            init: () => {
+                startAnimation(jumpLoop, model.currentAnimations, {
+                    fadeDuration: options.animation?.crossFadeDuration ?? DefaultCrossFadeDuration,
+                });
+            },
+        }),
+        transitionTo: {
+            jumpDown: { whenUpdate: () => state.physics.isGrounded },
+        },
+    };
+}

package/dist/simple-character/state/jump-start.d.ts

@@ -0,0 +1,4 @@
+import { GraphTimelineState } from '@pmndrs/timeline';
+import { AnimationAction } from 'three';
+import type { SimpleCharacterOptions, SimpleCharacterState } from '../index.js';
+export declare function loadSimpleCharacterJumpStartState<T>(jumpUp: AnimationAction, jumpForward: AnimationAction, state: SimpleCharacterState, options: SimpleCharacterOptions): Promise<GraphTimelineState<T>>;

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

@@ -0,0 +1,30 @@
+import { action, timePassed } from '@pmndrs/timeline';
+import { RunField } from '../../input/index.js';
+import { startAnimation } from '../../utils.js';
+import { DefaultCrossFadeDuration, DefaultJumDelay } from '../defaults.js';
+export async function loadSimpleCharacterJumpStartState(jumpUp, jumpForward, state, options) {
+    const model = state.model;
+    if (model == null) {
+        throw new Error(`Unable to load animation state without existing model`);
+    }
+    return {
+        timeline: () => action({
+            init() {
+                startAnimation(jumpUp, model.currentAnimations, {
+                    fadeDuration: options.animation?.crossFadeDuration ?? DefaultCrossFadeDuration,
+                    paused: true,
+                });
+                startAnimation(jumpForward, model.currentAnimations, {
+                    fadeDuration: options.animation?.crossFadeDuration ?? DefaultCrossFadeDuration,
+                    paused: true,
+                });
+            },
+            update: () => void state.physics.inputVelocity.multiplyScalar(0.3),
+            until: timePassed((typeof options.movement?.jump === 'object' ? options.movement?.jump.delay : undefined) ?? DefaultJumDelay, 'seconds'),
+        }),
+        transitionTo: {
+            jumpDown: { whenUpdate: () => !state.physics.isGrounded },
+            finally: () => (state.inputSystem.get(RunField) ? 'jumpForward' : 'jumpUp'),
+        },
+    };
+}

package/dist/simple-character/state/jump-up.d.ts

@@ -0,0 +1,5 @@
+import { GraphTimelineState } from '@pmndrs/timeline';
+import { AnimationAction } from 'three';
+import { SimpleCharacterState, SimpleCharacterOptions } from '../index.js';
+export declare function loadSimpleCharacterJumpUpAction(state: SimpleCharacterState, options: SimpleCharacterOptions): Promise<AnimationAction>;
+export declare function loadSimpleCharacterJumpUpState<T>(jumpUp: AnimationAction, state: SimpleCharacterState, options: SimpleCharacterOptions): Promise<GraphTimelineState<T>>;

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

@@ -0,0 +1,38 @@
+import { action, animationFinished } from '@pmndrs/timeline';
+import { LoopOnce, Vector3 } from 'three';
+import { flattenCharacterAnimationOptions, loadCharacterAnimation } from '../../animation/index.js';
+import { startAnimation } from '../../utils.js';
+export async function loadSimpleCharacterJumpUpAction(state, options) {
+    const model = state.model;
+    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' },
+    })));
+    jumpUp.loop = LoopOnce;
+    jumpUp.clampWhenFinished = true;
+    return jumpUp;
+}
+export async function loadSimpleCharacterJumpUpState(jumpUp, state, options) {
+    const model = state.model;
+    if (model == null) {
+        throw new Error(`Unable to load animation state without existing model`);
+    }
+    return {
+        timeline: () => action({
+            init: () => {
+                startAnimation(jumpUp, model.currentAnimations, { fadeDuration: 0.1 });
+                state.lastJump = performance.now() / 1000;
+                state.physics.applyVelocity(new Vector3(0, (typeof options.movement?.jump === 'object' ? options.movement?.jump.speed : undefined) ?? 8, 0));
+            },
+            until: animationFinished(jumpUp),
+        }),
+        transitionTo: {
+            jumpDown: {
+                whenUpdate: (_, _clock, actionTime) => actionTime > 0.3 && state.physics.isGrounded,
+            },
+            finally: 'jumpLoop',
+        },
+    };
+}

package/dist/simple-character/state/movement.d.ts

@@ -0,0 +1,3 @@
+import { type GraphTimelineState } from '@pmndrs/timeline';
+import type { SimpleCharacterOptions, SimpleCharacterState } from '../index.js';
+export declare function loadSimpleCharacterMovingState<T>(state: SimpleCharacterState, options: SimpleCharacterOptions): Promise<GraphTimelineState<T>>;

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

@@ -0,0 +1,59 @@
+import { action } from '@pmndrs/timeline';
+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) {
+    const model = state.model;
+    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 run = model.mixer.clipAction(await loadCharacterAnimation(model, ...flattenCharacterAnimationOptions({
+        url: { default: 'run' },
+        scaleTime: 0.8,
+    })));
+    const walk = model.mixer.clipAction(await loadCharacterAnimation(model, ...flattenCharacterAnimationOptions(options.animation?.walk ?? {
+        scaleTime: 0.5,
+        url: { default: 'walk' },
+    })));
+    return {
+        timeline: () => {
+            let currentAnimation;
+            return action({
+                update: () => {
+                    let nextAnimation;
+                    if (state.physics.inputVelocity.lengthSq() === 0) {
+                        nextAnimation = idle;
+                    }
+                    else if (state.inputSystem.get(RunField) && options.movement?.run != false) {
+                        nextAnimation = run;
+                    }
+                    else if (options.movement?.walk != false) {
+                        nextAnimation = walk;
+                    }
+                    else {
+                        nextAnimation = idle;
+                    }
+                    if (nextAnimation === currentAnimation) {
+                        return;
+                    }
+                    currentAnimation?.fadeOut(options.animation?.crossFadeDuration ?? DefaultCrossFadeDuration);
+                    startAnimation(nextAnimation, model.currentAnimations, {
+                        fadeDuration: options.animation?.crossFadeDuration ?? DefaultCrossFadeDuration,
+                    });
+                    currentAnimation = nextAnimation;
+                },
+            });
+        },
+        transitionTo: {
+            jumpStart: {
+                whenUpdate: () => options.movement?.jump !== false &&
+                    shouldJump(state.physics, state.inputSystem, 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

@@ -0,0 +1,5 @@
+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;

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

@@ -0,0 +1,25 @@
+import { Euler, Quaternion } from 'three';
+import { RunField, MoveLeftField, MoveRightField, MoveForwardField, MoveBackwardField, } from '../input/index.js';
+const cameraEuler = new Euler();
+const cameraRotation = new Quaternion();
+export function updateSimpleCharacterInputVelocity(camera, inputSystem, 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) {
+        runOptions = runOptions === true ? {} : runOptions;
+        inputSpeed = runOptions.speed ?? 6;
+    }
+    let walkOptions = options?.walk ?? true;
+    if (inputSpeed === 0 && walkOptions !== false) {
+        walkOptions = walkOptions === true ? {} : walkOptions;
+        inputSpeed = walkOptions.speed ?? 3;
+    }
+    physics.inputVelocity
+        .set(-inputSystem.get(MoveLeftField) + inputSystem.get(MoveRightField), 0, -inputSystem.get(MoveForwardField) + inputSystem.get(MoveBackwardField))
+        .normalize()
+        .applyEuler(cameraEuler)
+        .multiplyScalar(inputSpeed);
+}

package/dist/simple-character/update-rotation.d.ts

@@ -0,0 +1,6 @@
+import { Object3D } from 'three';
+import { BvhCharacterPhysics } from '../physics/index.js';
+import type { SimpleCharacterAnimationOptions } from './index.js';
+export declare function updateSimpleCharacterRotation(delta: number, physics: BvhCharacterPhysics, camera: Object3D, model: {
+    scene: Object3D;
+}, options?: SimpleCharacterAnimationOptions): true | undefined;

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

@@ -0,0 +1,40 @@
+import { Euler, Quaternion, Vector3 } from 'three';
+const NegZAxis = new Vector3(0, 0, -1);
+const _2MathPI = 2 * Math.PI;
+const characterTargetEuler = new Euler();
+const goalTargetEuler = new Euler();
+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';
+    // compute goalTargetEuler
+    if (basedOn === 'camera') {
+        goalTargetEuler.setFromQuaternion(camera.getWorldQuaternion(quaternion), 'YXZ');
+    }
+    else {
+        //don't rotate if not moving
+        if (physics.inputVelocity.lengthSq() === 0) {
+            // run forever
+            return true;
+        }
+        inputDirection.copy(physics.inputVelocity).normalize();
+        quaternion.setFromUnitVectors(NegZAxis, inputDirection);
+        goalTargetEuler.setFromQuaternion(quaternion, 'YXZ');
+    }
+    // compute currentTargetEuler
+    model.scene.getWorldQuaternion(quaternion);
+    characterTargetEuler.setFromQuaternion(quaternion, 'YXZ');
+    // apply delta yaw rotation
+    let deltaYaw = (goalTargetEuler.y - characterTargetEuler.y + _2MathPI) % _2MathPI;
+    if (deltaYaw > Math.PI) {
+        deltaYaw = deltaYaw - _2MathPI;
+    }
+    const absDeltaYaw = Math.abs(deltaYaw);
+    if (absDeltaYaw < 0.001) {
+        // run forever
+        return true;
+    }
+    const yawRotationDirection = deltaYaw / absDeltaYaw;
+    model.scene.rotation.y += Math.min((options?.maxYawRotationSpeed ?? 10) * delta, absDeltaYaw) * yawRotationDirection;
+}

package/dist/utils.d.ts

@@ -1,7 +1,14 @@
-export declare function cached<D extends ReadonlyArray<unknown>, T>(fn: (...deps: D) => Promise<T>, dependencies: D): Promise<T>;
-export declare function clearCache(fn: Function, dependencies: Array<unknown>): void;
-export declare function extractProxy<K extends string, T extends {
-    [key in K]?: {};
-}>(value: T, key: K): Partial<Exclude<T[K], undefined>>;
+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';
 export declare function getIsMobileMediaQuery(): MediaQueryList | undefined;
 export declare function isMobile(): boolean;
+export type StartAnimationOptions = {
+    fadeDuration?: number;
+    paused?: boolean;
+    mask?: CharacterAnimationMask;
+};
+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;

package/dist/utils.js

@@ -1,42 +1,4 @@
-function shallowEqual(a, b) {
-    if (a.length !== b.length)
-        return false;
-    for (let i = 0; i < a.length; i++) {
-        if (a[i] !== b[i])
-            return false;
-    }
-    return true;
-}
-const cacheMap = new Map();
-export function cached(fn, dependencies) {
-    let cache = cacheMap.get(fn);
-    if (cache == null) {
-        cacheMap.set(fn, (cache = []));
-    }
-    const entry = cache.find(({ deps }) => shallowEqual(deps, dependencies));
-    if (entry != null) {
-        return entry.result;
-    }
-    const result = fn(...dependencies);
-    cache.push({ deps: dependencies, result });
-    return result;
-}
-export function clearCache(fn, dependencies) {
-    const cache = cacheMap.get(fn);
-    if (cache == null) {
-        return;
-    }
-    const index = cache.findIndex(({ deps }) => shallowEqual(deps, dependencies));
-    if (index === -1) {
-        return;
-    }
-    cache.splice(index, 1);
-}
-export function extractProxy(value, key) {
-    return new Proxy({}, {
-        get: (_, p) => value[key]?.[p],
-    });
-}
+import { LastTimeJumpPressedField } from './input/index.js';
 export function getIsMobileMediaQuery() {
     if (typeof window === 'undefined' || typeof window.matchMedia !== 'function') {
         return undefined;
@@ -46,3 +8,30 @@ export function getIsMobileMediaQuery() {
 export function isMobile() {
     return getIsMobileMediaQuery()?.matches ?? false;
 }
+export function startAnimation(animation, currentAnimations, { fadeDuration = 0.1, paused = false, mask }) {
+    animation.reset();
+    animation.play();
+    animation.paused = paused;
+    const currentAnimation = currentAnimations.get(mask);
+    if (currentAnimation != null) {
+        animation.crossFadeFrom(currentAnimation, fadeDuration);
+    }
+    else {
+        animation.fadeIn(fadeDuration);
+    }
+    currentAnimations.set(mask, animation);
+}
+export function shouldJump(physics, inputSystem, lastJump, bufferTime = 0.1) {
+    if (!physics.isGrounded) {
+        return false;
+    }
+    const lastTimePressed = inputSystem.get(LastTimeJumpPressedField);
+    if (lastTimePressed == null || lastJump > lastTimePressed) {
+        return false;
+    }
+    //last jump must be more then 0.3 second ago, if not, we dont jump, this is to give the character time to get off the ground
+    if (lastJump > performance.now() / 1000 - 0.3) {
+        return false;
+    }
+    return performance.now() / 1000 - lastTimePressed < bufferTime;
+}

package/package.json

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