@pmndrs/viverse 0.1.19 → 0.2.0

package/dist/input/pointer-capture.d.ts

@@ -6,7 +6,7 @@ export type PointerCaptureInputOptions = {
 /**
  * @requires to manually execute `domElement.setPointerCapture(pointerId)` on pointerdown
  */
-export declare class PointerCaptureInput implements Input {
+export declare class PointerCaptureInput implements Input<PointerCaptureInputOptions> {
     private readonly domElement;
     private readonly abortController;
     private deltaZoom;
@@ -14,7 +14,7 @@ export declare class PointerCaptureInput implements Input {
     private deltaPitch;
     private activePointers;
     private lastPinchDist;
-    constructor(domElement: HTMLElement, options?: PointerCaptureInputOptions);
-    get<T>(field: InputField<T>): T | undefined;
+    constructor(domElement: HTMLElement);
+    get<T>(field: InputField<T>, options: PointerCaptureInputOptions): T | undefined;
     dispose(): void;
 }

package/dist/input/pointer-capture.js

@@ -10,7 +10,7 @@ export class PointerCaptureInput {
     deltaPitch = 0;
     activePointers = new Map();
     lastPinchDist = null;
-    constructor(domElement, options = {}) {
+    constructor(domElement) {
         this.domElement = domElement;
         domElement.addEventListener('pointerdown', (event) => {
             this.domElement.setPointerCapture(event.pointerId);
@@ -31,16 +31,14 @@ export class PointerCaptureInput {
                 const pts = Array.from(this.activePointers.values());
                 if (this.lastPinchDist != null) {
                     const d = Math.hypot(pts[0].x - pts[1].x, pts[0].y - pts[1].y);
-                    const zoomSpeed = options.pointerCaptureZoomSpeed ?? 0.0001;
-                    this.deltaZoom += (this.lastPinchDist - d) * zoomSpeed;
+                    this.deltaZoom += this.lastPinchDist - d;
                     this.lastPinchDist = d;
                 }
                 event.preventDefault();
                 return;
             }
-            const rotationSpeed = options.pointerCaptureRotationSpeed ?? 0.4;
-            this.deltaYaw -= (rotationSpeed * event.movementX) / window.innerHeight;
-            this.deltaPitch -= (rotationSpeed * event.movementY) / window.innerHeight;
+            this.deltaYaw -= event.movementX / window.innerHeight;
+            this.deltaPitch -= event.movementY / window.innerHeight;
         }, {
             signal: this.abortController.signal,
         });
@@ -64,25 +62,26 @@ export class PointerCaptureInput {
         });
         domElement.addEventListener('wheel', (event) => {
             event.preventDefault();
-            const zoomSpeed = options.pointerCaptureZoomSpeed ?? 0.0001;
-            this.deltaZoom += event.deltaY * zoomSpeed;
+            this.deltaZoom += event.deltaY;
         }, {
             signal: this.abortController.signal,
         });
     }
-    get(field) {
+    get(field, options) {
+        const rotationSpeed = options.pointerCaptureRotationSpeed ?? 0.4;
+        const zoomSpeed = options.pointerCaptureZoomSpeed ?? 0.0001;
         let result;
         switch (field) {
             case DeltaPitchField:
-                result = this.deltaPitch;
+                result = (this.deltaPitch * rotationSpeed);
                 this.deltaPitch = 0;
                 break;
             case DeltaYawField:
-                result = this.deltaYaw;
+                result = (this.deltaYaw * rotationSpeed);
                 this.deltaYaw = 0;
                 break;
             case DeltaZoomField:
-                result = this.deltaZoom;
+                result = (this.deltaZoom * zoomSpeed);
                 this.deltaZoom = 0;
                 break;
         }

package/dist/input/pointer-lock.d.ts

@@ -6,12 +6,12 @@ export type PointerLockInputOptions = {
 /**
  * @requires to manually execute `domElement.requestPointerLock()`
  */
-export declare class PointerLockInput implements Input {
+export declare class PointerLockInput implements Input<PointerLockInputOptions> {
     private readonly abortController;
     private deltaZoom;
     private deltaYaw;
     private deltaPitch;
-    constructor(domElement: HTMLElement, options?: PointerLockInputOptions);
-    get<T>(field: InputField<T>): T | undefined;
+    constructor(domElement: HTMLElement);
+    get<T>(field: InputField<T>, options: PointerLockInputOptions): T | undefined;
     dispose(): void;
 }

package/dist/input/pointer-lock.js

@@ -7,16 +7,15 @@ export class PointerLockInput {
     deltaZoom = 0;
     deltaYaw = 0;
     deltaPitch = 0;
-    constructor(domElement, options = {}) {
+    constructor(domElement) {
         domElement.addEventListener('pointermove', (event) => {
             if (document.pointerLockElement != domElement) {
                 return;
             }
-            const rotationSpeed = options.pointerLockRotationSpeed ?? 0.4;
             // Compute based on domElement bounds instead of window.innerHeight
             const rect = domElement.getBoundingClientRect();
-            this.deltaYaw -= (rotationSpeed * event.movementX) / rect.height;
-            this.deltaPitch -= (rotationSpeed * event.movementY) / rect.height;
+            this.deltaYaw -= event.movementX / rect.height;
+            this.deltaPitch -= event.movementY / rect.height;
         }, {
             signal: this.abortController.signal,
         });
@@ -24,26 +23,27 @@ export class PointerLockInput {
             if (document.pointerLockElement != domElement) {
                 return;
             }
-            const zoomSpeed = options.pointerLockZoomSpeed ?? 0.0001;
-            this.deltaZoom += event.deltaY * zoomSpeed;
+            this.deltaZoom += event.deltaY;
             event.preventDefault();
         }, {
             signal: this.abortController.signal,
         });
     }
-    get(field) {
+    get(field, options) {
+        const rotationSpeed = options.pointerLockRotationSpeed ?? 0.4;
+        const zoomSpeed = options.pointerLockZoomSpeed ?? 0.0001;
         let result;
         switch (field) {
             case DeltaPitchField:
-                result = this.deltaPitch;
+                result = (this.deltaPitch * rotationSpeed);
                 this.deltaPitch = 0;
                 break;
             case DeltaYawField:
-                result = this.deltaYaw;
+                result = (this.deltaYaw * rotationSpeed);
                 this.deltaYaw = 0;
                 break;
             case DeltaZoomField:
-                result = this.deltaZoom;
+                result = (this.deltaZoom * zoomSpeed);
                 this.deltaZoom = 0;
                 break;
         }

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

@@ -3,19 +3,15 @@ export type ScreenJoystickInputOptions = {
     screenJoystickRunDistancePx?: number;
     screenJoystickDeadZonePx?: number;
 };
-export declare class ScreenJoystickInput implements Input {
-    private readonly options;
+export declare class ScreenJoystickInput implements Input<ScreenJoystickInputOptions> {
     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 distanceToCenter;
+    private clampedX;
+    private clampedY;
+    constructor(domElement: HTMLElement);
+    get<T>(field: InputField<T>, options: ScreenJoystickInputOptions): T | undefined;
     dispose(): void;
     private updateHandle;
     private resetHandle;

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,17 +1,33 @@
-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 (type == null || url == null) {
+    if (url == null) {
         //prepare loading the default model
         type = 'gltf';
         url = (await import('../assets/mannequin.js')).url;
         boneRotationOffset = new Quaternion().setFromEuler(new Euler(Math.PI, 0, Math.PI / 2, 'ZYX'));
     }
+    if (type == null) {
+        if (url.endsWith('.gltf') || url.endsWith('.glb')) {
+            type = 'gltf';
+        }
+        if (url.endsWith('.vrm')) {
+            type = 'vrm';
+        }
+        if (type == null) {
+            throw new Error(`Unable to infer model type from url "${url}. Please specify the type of the model manually."`);
+        }
+    }
     switch (type) {
         case 'vrm':
             result = await loadVrmCharacterModel(url);
@@ -30,28 +46,9 @@ async function uncachedLoadCharacterModel(type, url, boneRotationOffset, castSha
             obj.receiveShadow = true;
         }
     });
-    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);
+    const restPose = result.scene.clone();
+    restPose.visible = false;
+    restPose.traverse((object) => (object.name = `rest_${object.name}`));
+    result.scene.add(restPose);
+    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';