@pmndrs/viverse 0.1.20 → 0.2.1

package/dist/input/screen-joystick.d.ts

@@ -1,21 +1,22 @@
-import { Input, InputField } from './index.js';
 export type ScreenJoystickInputOptions = {
     screenJoystickRunDistancePx?: number;
     screenJoystickDeadZonePx?: number;
 };
-export declare class ScreenJoystickInput implements Input {
-    private readonly options;
+export declare class ScreenJoystickInput {
+    private readonly abortController;
     readonly root: HTMLDivElement;
     private readonly handle;
-    private moveX;
-    private moveY;
-    private running;
-    private readonly joystickRadius;
-    private joyCenterX;
-    private joyCenterY;
     private pointerId;
-    constructor(domElement: HTMLElement, options?: ScreenJoystickInputOptions);
-    get<T>(field: InputField<T>): T | undefined;
+    private forwardWriter;
+    private backwardWriter;
+    private leftWriter;
+    private rightWriter;
+    private runWriter;
+    options: {
+        runDistancePx?: number;
+        deadZonePx?: number;
+    };
+    constructor(domElement: HTMLElement);
     dispose(): void;
     private updateHandle;
     private resetHandle;

package/dist/input/screen-joystick.js

@@ -1,19 +1,19 @@
-import { MoveForwardField, MoveBackwardField, MoveLeftField, MoveRightField, RunField, } from './index.js';
+import { MoveForwardAction, MoveBackwardAction, MoveLeftAction, MoveRightAction, RunAction } from './index.js';
 const DefaultDeadZonePx = 24;
 const DefaultRunDistancePx = 46;
+const JoystickRadius = 56;
 export class ScreenJoystickInput {
-    options;
+    abortController = new AbortController();
     root;
     handle;
-    moveX = 0;
-    moveY = 0;
-    running = false;
-    joystickRadius = 56;
-    joyCenterX = 0;
-    joyCenterY = 0;
     pointerId;
-    constructor(domElement, options = {}) {
-        this.options = options;
+    forwardWriter = MoveForwardAction.createWriter(this.abortController.signal);
+    backwardWriter = MoveBackwardAction.createWriter(this.abortController.signal);
+    leftWriter = MoveLeftAction.createWriter(this.abortController.signal);
+    rightWriter = MoveRightAction.createWriter(this.abortController.signal);
+    runWriter = RunAction.createWriter(this.abortController.signal);
+    options = {};
+    constructor(domElement) {
         const parent = domElement.parentElement ?? domElement;
         const joy = document.createElement('div');
         joy.className = 'viverse-joystick mobile-only';
@@ -58,9 +58,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 +68,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) {
@@ -79,49 +82,36 @@ export class ScreenJoystickInput {
             e.preventDefault();
             this.resetHandle();
         };
-        joy.addEventListener('pointerdown', onPointerDown);
-        joy.addEventListener('pointermove', onPointerMove);
-        joy.addEventListener('pointerup', onPointerEnd);
-        joy.addEventListener('pointercancel', onPointerEnd);
-    }
-    get(field) {
-        switch (field) {
-            case MoveForwardField:
-                return Math.max(0, this.moveY);
-            case MoveBackwardField:
-                return Math.max(0, -this.moveY);
-            case MoveLeftField:
-                return Math.max(0, -this.moveX);
-            case MoveRightField:
-                return Math.max(0, this.moveX);
-            case RunField:
-                return this.running;
-        }
-        return undefined;
+        joy.addEventListener('pointerdown', onPointerDown, { signal: this.abortController.signal });
+        joy.addEventListener('pointermove', onPointerMove, { signal: this.abortController.signal });
+        joy.addEventListener('pointerup', onPointerEnd, { signal: this.abortController.signal });
+        joy.addEventListener('pointercancel', onPointerEnd, { signal: this.abortController.signal });
     }
     dispose() {
+        this.abortController.abort();
         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);
+        const distanceToCenter = Math.hypot(dx, dy) || 1;
+        const clampedX = (dx / distanceToCenter) * Math.min(distanceToCenter, JoystickRadius);
+        const clampedY = (dy / distanceToCenter) * Math.min(distanceToCenter, JoystickRadius);
         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);
+        const deadZone = this.options.deadZonePx ?? DefaultDeadZonePx;
+        const runDistance = this.options.runDistancePx ?? DefaultRunDistancePx;
+        const moveY = distanceToCenter <= deadZone ? 0 : -clampedY / JoystickRadius;
+        const moveX = distanceToCenter <= deadZone ? 0 : clampedX / JoystickRadius;
+        this.forwardWriter.write(Math.max(0, moveY));
+        this.backwardWriter.write(Math.max(0, -moveY));
+        this.leftWriter.write(Math.max(0, -moveX));
+        this.rightWriter.write(Math.max(0, moveX));
+        this.runWriter.write(distanceToCenter > runDistance);
     }
     resetHandle() {
         this.handle.style.transform = 'translate(-50%,-50%)';
-        this.moveX = 0;
-        this.moveY = 0;
-        this.running = false;
+        this.forwardWriter.write(0);
+        this.backwardWriter.write(0);
+        this.leftWriter.write(0);
+        this.rightWriter.write(0);
+        this.runWriter.write(false);
     }
 }

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

@@ -1,8 +1,6 @@
-import { Input, InputField } from './index.js';
-export declare class ScreenJumpButtonInput implements Input {
+export declare class ScreenJumpButtonInput {
+    private readonly abortController;
     readonly root: HTMLDivElement;
-    private lastJumpTime;
     constructor(domElement: HTMLElement);
-    get<T>(field: InputField<T>): T | undefined;
     dispose(): void;
 }

package/dist/input/screen-jump-button.js

@@ -1,7 +1,7 @@
-import { LastTimeJumpPressedField } from './index.js';
+import { JumpAction } from './index.js';
 export class ScreenJumpButtonInput {
+    abortController = new AbortController();
     root;
-    lastJumpTime = null;
     constructor(domElement) {
         const parent = domElement.parentElement ?? domElement;
         const btn = document.createElement('div');
@@ -27,23 +27,18 @@ export class ScreenJumpButtonInput {
         const onPress = (e) => {
             e.preventDefault();
             e.stopPropagation();
-            this.lastJumpTime = performance.now() / 1000;
+            JumpAction.emit();
         };
         const stopPropagation = (e) => {
             e.stopPropagation();
             e.preventDefault();
         };
-        this.root.addEventListener('pointerdown', onPress);
-        this.root.addEventListener('pointermove', stopPropagation);
-        this.root.addEventListener('pointerup', stopPropagation);
-    }
-    get(field) {
-        if (field === LastTimeJumpPressedField) {
-            return this.lastJumpTime;
-        }
-        return undefined;
+        this.root.addEventListener('pointerdown', onPress, { signal: this.abortController.signal });
+        this.root.addEventListener('pointermove', stopPropagation, { signal: this.abortController.signal });
+        this.root.addEventListener('pointerup', stopPropagation, { signal: this.abortController.signal });
     }
     dispose() {
+        this.abortController.abort();
         this.root.remove();
     }
 }

package/dist/model/index.d.ts

@@ -1,4 +1,4 @@
-import { Quaternion } from 'three';
+import { AnimationAction, AnimationMixer, Object3D, Quaternion } from 'three';
 export { VRMHumanBoneName } from '@pixiv/three-vrm';
 export * from './vrm.js';
 export type CharacterModelOptions = {
@@ -17,16 +17,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<string | 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/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/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,116 @@
+import { Group, Object3D, Object3DEventMap, AnimationAction } from 'three';
+import { CharacterAnimationOptions } from '../animation/index.js';
+import { CharacterCameraBehavior, SimpleCharacterCameraBehaviorOptions } from '../camera.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;
+    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 = {
+    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<{
+        new (domElement: HTMLElement): {
+            dispose(): void;
+        };
+    }>;
+    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 currentAnimationRef: {
+        current?: AnimationAction;
+    };
+    model?: CharacterModel;
+    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;
+    dispose(): void;
+}
+export * from './update-input-velocity.js';
+export * from './update-rotation.js';
+export * from './apply-input-options.js';

package/dist/simple-character/index.js

@@ -0,0 +1,104 @@
+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, } 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';
+import { applySimpleCharacterInputOptions } from './apply-input-options.js';
+export class SimpleCharacter extends Group {
+    camera;
+    world;
+    options;
+    cameraBehavior;
+    physics;
+    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.inputs = (options.input ?? [ScreenJoystickInput, ScreenJumpButtonInput, PointerCaptureInput, LocomotionKeyboardInput]).map((Input) => new Input(domElement));
+        applySimpleCharacterInputOptions(this.inputs, options.inputOptions);
+        // camera behavior
+        this.cameraBehavior = new CharacterCameraBehavior();
+        // 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.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.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, 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.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';