@pmndrs/viverse 0.1.20 → 0.2.0

package/dist/input/screen-joystick.js

@@ -1,19 +1,15 @@
 import { MoveForwardField, MoveBackwardField, MoveLeftField, MoveRightField, RunField, } from './index.js';
 const DefaultDeadZonePx = 24;
 const DefaultRunDistancePx = 46;
+const JoystickRadius = 56;
 export class ScreenJoystickInput {
-    options;
     root;
     handle;
-    moveX = 0;
-    moveY = 0;
-    running = false;
-    joystickRadius = 56;
-    joyCenterX = 0;
-    joyCenterY = 0;
     pointerId;
-    constructor(domElement, options = {}) {
-        this.options = options;
+    distanceToCenter = 0;
+    clampedX = 0;
+    clampedY = 0;
+    constructor(domElement) {
         const parent = domElement.parentElement ?? domElement;
         const joy = document.createElement('div');
         joy.className = 'viverse-joystick mobile-only';
@@ -58,9 +54,9 @@ export class ScreenJoystickInput {
             joy.setPointerCapture(e.pointerId);
             this.pointerId = e.pointerId;
             const rect = joy.getBoundingClientRect();
-            this.joyCenterX = rect.left + rect.width / 2;
-            this.joyCenterY = rect.top + rect.height / 2;
-            this.updateHandle(e.clientX - this.joyCenterX, e.clientY - this.joyCenterY);
+            const joyCenterX = rect.left + rect.width / 2;
+            const joyCenterY = rect.top + rect.height / 2;
+            this.updateHandle(e.clientX - joyCenterX, e.clientY - joyCenterY);
         };
         const onPointerMove = (e) => {
             if (this.pointerId == null) {
@@ -68,7 +64,10 @@ export class ScreenJoystickInput {
             }
             e.preventDefault();
             e.stopPropagation();
-            this.updateHandle(e.clientX - this.joyCenterX, e.clientY - this.joyCenterY);
+            const rect = joy.getBoundingClientRect();
+            const joyCenterX = rect.left + rect.width / 2;
+            const joyCenterY = rect.top + rect.height / 2;
+            this.updateHandle(e.clientX - joyCenterX, e.clientY - joyCenterY);
         };
         const onPointerEnd = (e) => {
             if (this.pointerId != e.pointerId) {
@@ -84,18 +83,22 @@ export class ScreenJoystickInput {
         joy.addEventListener('pointerup', onPointerEnd);
         joy.addEventListener('pointercancel', onPointerEnd);
     }
-    get(field) {
+    get(field, options) {
         switch (field) {
             case MoveForwardField:
-                return Math.max(0, this.moveY);
             case MoveBackwardField:
-                return Math.max(0, -this.moveY);
+                const moveY = this.distanceToCenter <= (options.screenJoystickDeadZonePx ?? DefaultDeadZonePx)
+                    ? 0
+                    : -this.clampedY / JoystickRadius;
+                return field === MoveForwardField ? Math.max(0, moveY) : Math.max(0, -moveY);
             case MoveLeftField:
-                return Math.max(0, -this.moveX);
             case MoveRightField:
-                return Math.max(0, this.moveX);
+                const moveX = this.distanceToCenter <= (options.screenJoystickDeadZonePx ?? DefaultDeadZonePx)
+                    ? 0
+                    : this.clampedX / JoystickRadius;
+                return field === MoveLeftField ? Math.max(0, moveX) : Math.max(0, moveX);
             case RunField:
-                return this.running;
+                return (this.distanceToCenter > (options.screenJoystickRunDistancePx ?? DefaultRunDistancePx));
         }
         return undefined;
     }
@@ -103,25 +106,15 @@ export class ScreenJoystickInput {
         this.root.remove();
     }
     updateHandle(dx, dy) {
-        const len = Math.hypot(dx, dy) || 1;
-        const max = this.joystickRadius;
-        const clampedX = (dx / len) * Math.min(len, max);
-        const clampedY = (dy / len) * Math.min(len, max);
-        this.handle.style.transform = `translate(-50%,-50%) translate(${clampedX}px, ${clampedY}px)`;
-        if (len <= (this.options.screenJoystickDeadZonePx ?? DefaultDeadZonePx)) {
-            this.moveX = 0;
-            this.moveY = 0;
-        }
-        else {
-            this.moveX = clampedX / max;
-            this.moveY = -clampedY / max;
-        }
-        this.running = len > (this.options.screenJoystickRunDistancePx ?? DefaultRunDistancePx);
+        this.distanceToCenter = Math.hypot(dx, dy) || 1;
+        this.clampedX = (dx / this.distanceToCenter) * Math.min(this.distanceToCenter, JoystickRadius);
+        this.clampedY = (dy / this.distanceToCenter) * Math.min(this.distanceToCenter, JoystickRadius);
+        this.handle.style.transform = `translate(-50%,-50%) translate(${this.clampedX}px, ${this.clampedY}px)`;
     }
     resetHandle() {
         this.handle.style.transform = 'translate(-50%,-50%)';
-        this.moveX = 0;
-        this.moveY = 0;
-        this.running = false;
+        this.distanceToCenter = 0;
+        this.clampedX = 0;
+        this.clampedY = 0;
     }
 }

package/dist/input/screen-jump-button.d.ts

@@ -1,5 +1,5 @@
 import { Input, InputField } from './index.js';
-export declare class ScreenJumpButtonInput implements Input {
+export declare class ScreenJumpButtonInput implements Input<{}> {
     readonly root: HTMLDivElement;
     private lastJumpTime;
     constructor(domElement: HTMLElement);

package/dist/model/index.d.ts

@@ -1,4 +1,5 @@
-import { Quaternion } from 'three';
+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 = {
@@ -17,16 +18,12 @@ export type CharacterModelOptions = {
      * @default true
      */
     readonly receiveShadow?: boolean;
-} | boolean;
-export declare function clearCharacterModelCache(options?: CharacterModelOptions): void;
-export declare function loadCharacterModel(options?: CharacterModelOptions): Promise<((import("@pixiv/three-vrm").VRM & {
-    scene: import("three").Object3D<import("three").Object3DEventMap & {
-        dispose: {};
-    }>;
-}) | (import("three/examples/jsm/Addons.js").GLTF & {
-    scene: import("three").Object3D<import("three").Object3DEventMap & {
-        dispose: {};
-    }>;
-})) & {
+};
+export declare function flattenCharacterModelOptions(options: Exclude<CharacterModelOptions, false> | undefined): Parameters<typeof loadCharacterModel>;
+export type CharacterModel = {
+    mixer: AnimationMixer;
+    scene: Object3D;
+    currentAnimations: Map<CharacterAnimationMask | undefined, AnimationAction>;
     boneRotationOffset?: Quaternion;
-}> | undefined;
+};
+export declare function loadCharacterModel(url?: string, type?: Exclude<CharacterModelOptions, boolean>['type'], boneRotationOffset?: Quaternion, castShadow?: boolean, receiveShadow?: boolean): Promise<CharacterModel>;

package/dist/model/index.js

@@ -1,10 +1,15 @@
-import { Euler, Quaternion } from 'three';
-import { loadVrmCharacterModel } from './vrm.js';
-import { cached, clearCache } from '../utils.js';
+import { AnimationMixer, Euler, Quaternion } from 'three';
 import { loadGltfCharacterModel } from './gltf.js';
+import { loadVrmCharacterModel } from './vrm.js';
 export { VRMHumanBoneName } from '@pixiv/three-vrm';
 export * from './vrm.js';
-async function uncachedLoadCharacterModel(type, url, boneRotationOffset, castShadow = true, receiveShadow = true) {
+export function flattenCharacterModelOptions(options) {
+    if (options == null) {
+        return [];
+    }
+    return [options.url, options.type, options.boneRotationOffset, options.castShadow, options.receiveShadow];
+}
+export async function loadCharacterModel(url, type, boneRotationOffset, castShadow = true, receiveShadow = true) {
     let result;
     if (url == null) {
         //prepare loading the default model
@@ -41,36 +46,9 @@ async function uncachedLoadCharacterModel(type, url, boneRotationOffset, castSha
             obj.receiveShadow = true;
         }
     });
-    const rootBone = result.scene.getObjectByName('root');
-    if (rootBone == null) {
-        throw new Error(`unable to load model - missing root bone`);
-    }
-    const restPose = rootBone.clone();
+    const restPose = result.scene.clone();
     restPose.visible = false;
-    restPose.traverse((bone) => (bone.name = `rest_${bone.name}`));
+    restPose.traverse((object) => (object.name = `rest_${object.name}`));
     result.scene.add(restPose);
-    return result;
-}
-function getCharacterModelDependencies(options = true) {
-    if (options === false) {
-        return undefined;
-    }
-    if (options === true) {
-        return [undefined, undefined, undefined, undefined, undefined];
-    }
-    return [options.type, options.url, options.boneRotationOffset, options.castShadow, options.receiveShadow];
-}
-export function clearCharacterModelCache(options) {
-    const dependencies = getCharacterModelDependencies(options);
-    if (dependencies == null) {
-        return;
-    }
-    clearCache(uncachedLoadCharacterModel, dependencies);
-}
-export function loadCharacterModel(options) {
-    const dependencies = getCharacterModelDependencies(options);
-    if (dependencies == null) {
-        return undefined;
-    }
-    return cached(uncachedLoadCharacterModel, dependencies);
+    return Object.assign(result, { mixer: new AnimationMixer(result.scene), currentAnimations: new Map() });
 }

package/dist/physics/index.d.ts

@@ -32,9 +32,7 @@ export type BvhCharacterPhysicsOptions = {
  * assumes the target object origin is at its bottom
  */
 export declare class BvhCharacterPhysics {
-    private readonly character;
     private readonly world;
-    private disposed;
     private readonly stateVelocity;
     readonly inputVelocity: Vector3;
     private notGroundedSeconds;
@@ -42,14 +40,13 @@ export declare class BvhCharacterPhysics {
     private readonly aabbox;
     private radius;
     get isGrounded(): boolean;
-    constructor(character: Object3D, world: BvhPhysicsWorld);
+    constructor(world: BvhPhysicsWorld);
     applyVelocity(velocity: Vector3): void;
     /**
      * @param delta in seconds
      */
-    update(fullDelta: number, options?: BvhCharacterPhysicsOptions): void;
+    update(model: Object3D, fullDelta: number, options?: BvhCharacterPhysicsOptions): void;
     private updateBoundingShapes;
-    dispose(): void;
     shapecastCapsule(position: Vector3, maxGroundSlope: number, options: Exclude<BvhCharacterPhysicsOptions, boolean>): boolean;
 }
 export * from './world.js';

package/dist/physics/index.js

@@ -11,9 +11,7 @@ const YAxis = new Vector3(0, 1, 0);
  * assumes the target object origin is at its bottom
  */
 export class BvhCharacterPhysics {
-    character;
     world;
-    disposed = false;
     stateVelocity = new Vector3();
     inputVelocity = new Vector3();
     notGroundedSeconds = 0;
@@ -23,8 +21,7 @@ export class BvhCharacterPhysics {
     get isGrounded() {
         return this.notGroundedSeconds < 0.2;
     }
-    constructor(character, world) {
-        this.character = character;
+    constructor(world) {
         this.world = world;
     }
     applyVelocity(velocity) {
@@ -33,16 +30,13 @@ export class BvhCharacterPhysics {
     /**
      * @param delta in seconds
      */
-    update(fullDelta, options = true) {
+    update(model, fullDelta, options = true) {
         if (options === false) {
             return;
         }
         if (options === true) {
             options = {};
         }
-        if (this.disposed) {
-            return;
-        }
         //at max catch up to 1 second of physics in one update call (running at less then 1fps is unplayable anyways)
         fullDelta = Math.min(1, fullDelta);
         const updatesPerSecond = options.updatesPerSecond ?? 60;
@@ -52,10 +46,10 @@ export class BvhCharacterPhysics {
             const partialDelta = Math.min(fullDelta, physicsDelta);
             fullDelta -= physicsDelta;
             //compute global position and inverted parent matrix so that we can compute the position in global space and re-assign it to the local chracter space
-            if (this.character.parent != null) {
-                this.character.parent.updateWorldMatrix(true, false);
-                position.copy(this.character.position).applyMatrix4(this.character.parent.matrixWorld);
-                invertedParentMatrix.copy(this.character.parent.matrixWorld).invert();
+            if (model.parent != null) {
+                model.parent.updateWorldMatrix(true, false);
+                position.copy(model.position).applyMatrix4(model.parent.matrixWorld);
+                invertedParentMatrix.copy(model.parent.matrixWorld).invert();
             }
             else {
                 invertedParentMatrix.identity();
@@ -70,7 +64,7 @@ export class BvhCharacterPhysics {
                 this.notGroundedSeconds = 0;
             }
             if (!isGrounded || this.inputVelocity.lengthSq() > 0) {
-                this.character.position.copy(collisionFreePosition).applyMatrix4(invertedParentMatrix);
+                model.position.copy(collisionFreePosition).applyMatrix4(invertedParentMatrix);
             }
             //compute new velocity
             //  apply gravity
@@ -101,9 +95,6 @@ export class BvhCharacterPhysics {
         this.aabbox.min.addScalar(-this.radius);
         this.aabbox.max.addScalar(this.radius);
     }
-    dispose() {
-        this.disposed = true;
-    }
     shapecastCapsule(position, maxGroundSlope, options) {
         this.updateBoundingShapes(options);
         let grounded = false;

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

@@ -0,0 +1,2 @@
+export declare const DefaultCrossFadeDuration = 0.1;
+export declare const DefaultJumDelay = 0.2;

package/dist/simple-character/defaults.js

@@ -0,0 +1,2 @@
+export const DefaultCrossFadeDuration = 0.1;
+export const DefaultJumDelay = 0.2;

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

@@ -0,0 +1,101 @@
+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 = {
+    /**
+     * @default true
+     */
+    jump?: {
+        /**
+         * @default 0.2
+         */
+        delay?: number;
+        /**
+         * @default 0.1
+         */
+        bufferTime?: number;
+        /**
+         * @default 8
+         */
+        speed?: number;
+    } | boolean;
+    /**
+     * @default true
+     */
+    walk?: {
+        speed?: number;
+    } | boolean;
+    /**
+     * @default true
+     */
+    run?: {
+        speed?: number;
+    } | boolean;
+};
+export type SimpleCharacterAnimationOptions = {
+    readonly walk?: CharacterAnimationOptions;
+    readonly run?: CharacterAnimationOptions;
+    readonly idle?: CharacterAnimationOptions;
+    readonly jumpUp?: CharacterAnimationOptions;
+    readonly jumpLoop?: CharacterAnimationOptions;
+    readonly jumpDown?: CharacterAnimationOptions;
+    readonly jumpForward?: CharacterAnimationOptions;
+    /**
+     * @default "movement"
+     */
+    yawRotationBasdOn?: 'camera' | 'movement';
+    /**
+     * @default 10
+     */
+    maxYawRotationSpeed?: number;
+    /**
+     * @default 0.1
+     */
+    crossFadeDuration?: number;
+};
+export type SimpleCharacterInputOptions = ScreenJoystickInputOptions & PointerCaptureInputOptions & PointerLockInputOptions & LocomotionKeyboardInputOptions;
+export type SimpleCharacterOptions = {
+    readonly input?: ReadonlyArray<Input | {
+        new (domElement: HTMLElement): Input;
+    }>;
+    inputOptions?: SimpleCharacterInputOptions;
+    movement?: SimpleCharacterMovementOptions;
+    readonly model?: CharacterModelOptions | boolean;
+    physics?: BvhCharacterPhysicsOptions;
+    cameraBehavior?: SimpleCharacterCameraBehaviorOptions;
+    readonly animation?: SimpleCharacterAnimationOptions;
+};
+export declare class SimpleCharacter extends Group<Object3DEventMap & {
+    loaded: {};
+}> implements SimpleCharacterState {
+    readonly camera: Object3D;
+    private readonly world;
+    private readonly options;
+    readonly cameraBehavior: CharacterCameraBehavior;
+    readonly physics: BvhCharacterPhysics;
+    readonly inputSystem: InputSystem;
+    readonly currentAnimationRef: {
+        current?: AnimationAction;
+    };
+    model?: CharacterModel;
+    private readonly updateTimeline;
+    private readonly graph;
+    private readonly abortController;
+    lastJump: number;
+    constructor(camera: Object3D, world: BvhPhysicsWorld, domElement: HTMLElement, options?: SimpleCharacterOptions);
+    private init;
+    update(delta: number): void;
+    dispose(): void;
+}
+export * from './update-input-velocity.js';
+export * from './update-rotation.js';

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>>;