@pmndrs/viverse 0.2.0 → 0.2.2

package/dist/animation/default.js

@@ -1,18 +1,25 @@
-export async function loadDefaultCharacterAnimationUrl(type) {
-    switch (type) {
-        case 'idle':
+export const IdleAnimationUrl = Symbol('idle-animation-url');
+export const JumpUpAnimationUrl = Symbol('jump-up-animation-url');
+export const JumpDownAnimationUrl = Symbol('jump-down-animation-url');
+export const JumpForwardAnimationUrl = Symbol('jump-forward-animation-url');
+export const JumpLoopAnimationUrl = Symbol('jump-loop-animation-url');
+export const RunAnimationUrl = Symbol('run-animation-url');
+export const WalkAnimationUrl = Symbol('walk-animation-url');
+export async function resolveDefaultCharacterAnimationUrl(url) {
+    switch (url) {
+        case IdleAnimationUrl:
             return (await import('../assets/idle.js')).url;
-        case 'jumpDown':
+        case JumpDownAnimationUrl:
             return (await import('../assets/jump-down.js')).url;
-        case 'jumpForward':
+        case JumpForwardAnimationUrl:
             return (await import('../assets/jump-forward.js')).url;
-        case 'jumpLoop':
+        case JumpLoopAnimationUrl:
             return (await import('../assets/jump-loop.js')).url;
-        case 'jumpUp':
+        case JumpUpAnimationUrl:
             return (await import('../assets/jump-up.js')).url;
-        case 'run':
+        case RunAnimationUrl:
             return (await import('../assets/run.js')).url;
-        case 'walk':
+        case WalkAnimationUrl:
             return (await import('../assets/walk.js')).url;
     }
 }

package/dist/animation/index.d.ts

@@ -1,17 +1,14 @@
 import { VRMHumanBoneName } from '@pixiv/three-vrm';
 import { AnimationClip, Object3D } from 'three';
-import { loadDefaultCharacterAnimationUrl } from './default.js';
-import type { CharacterModel } from '../model/index.js';
-export declare function fixModelAnimationClip(model: CharacterModel, clip: AnimationClip, clipScene: Object3D | undefined, removeXZMovement: boolean, boneMap?: Record<string, VRMHumanBoneName>): void;
-export * from './gltf.js';
-export * from './fbx.js';
-export * from './vrma.js';
+import { DefaultUrl } from './default.js';
+import { type CharacterAnimationMask } from './mask.js';
+import { type CharacterModel } from '../model/index.js';
+export declare function fixModelAnimationClip(model: CharacterModel, clip: AnimationClip, clipScene: Object3D | undefined, removeXZMovement: boolean): void;
 export * from './utils.js';
-export type CharacterAnimationMask = (boneName: VRMHumanBoneName) => boolean;
+export * from './default.js';
+export * from './mask.js';
 export type CharacterAnimationOptions = {
-    url: string | {
-        default: Parameters<typeof loadDefaultCharacterAnimationUrl>[0];
-    };
+    url: string | DefaultUrl;
     type?: 'mixamo' | 'gltf' | 'vrma' | 'fbx' | 'bvh';
     removeXZMovement?: boolean;
     trimTime?: {
@@ -24,8 +21,6 @@ export type CharacterAnimationOptions = {
 };
 export type Tail<T extends any[]> = T extends [any, ...infer Rest] ? Rest : never;
 export declare function flattenCharacterAnimationOptions(options: Exclude<CharacterAnimationOptions, false>): Tail<Parameters<typeof loadCharacterAnimation>>;
-export declare function loadCharacterAnimation(model: CharacterModel, url: string | {
-    default: Parameters<typeof loadDefaultCharacterAnimationUrl>[0];
-}, type?: CharacterAnimationOptions['type'], removeXZMovement?: boolean, trimStartTime?: number | undefined, trimEndTime?: number | undefined, boneMap?: Record<string, VRMHumanBoneName> | undefined, scaleTime?: number | undefined, mask?: CharacterAnimationMask): Promise<AnimationClip>;
+export declare function loadCharacterAnimation(model: CharacterModel, url: string | DefaultUrl, type?: CharacterAnimationOptions['type'], removeXZMovement?: boolean, trimStartTime?: number | undefined, trimEndTime?: number | undefined, boneMap?: Record<string, VRMHumanBoneName> | undefined, scaleTime?: number | undefined, mask?: CharacterAnimationMask): Promise<AnimationClip>;
 export declare const mixamoBoneMap: Record<string, VRMHumanBoneName>;
 export declare const bvhBoneMap: Record<string, VRMHumanBoneName>;

package/dist/animation/index.js

@@ -1,13 +1,15 @@
 import { VRM } from '@pixiv/three-vrm';
 import { Euler, Quaternion, QuaternionKeyframeTrack, Vector3, VectorKeyframeTrack, } from 'three';
+import { BVHLoader } from 'three/examples/jsm/loaders/BVHLoader.js';
+import { FBXLoader } from 'three/examples/jsm/loaders/FBXLoader.js';
+import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js';
+import { applyBoneMap } from './bone-map.js';
 import _bvhBoneMap from './bvh-bone-map.json';
-import { loadVrmModelBvhAnimations } from './bvh.js';
-import { loadDefaultCharacterAnimationUrl } from './default.js';
-import { loadVrmModelFbxAnimations } from './fbx.js';
-import { loadVrmModelGltfAnimations } from './gltf.js';
+import { resolveDefaultCharacterAnimationUrl } from './default.js';
+import { applyMask } from './mask.js';
 import _mixamoBoneMap from './mixamo-bone-map.json';
 import { scaleAnimationClipTime, trimAnimationClip } from './utils.js';
-import { loadVrmModelVrmaAnimations } from './vrma.js';
+import { vrmaLoader } from '../model/index.js';
 //helper variables for the quaternion retargeting
 const baseThisLocalRestRotation_inverse = new Quaternion();
 const baseThisLocalCurrentRotation = new Quaternion();
@@ -21,11 +23,7 @@ const targetThisLocalCurrentRotation = new Quaternion();
 const position = new Vector3();
 const nonVrmRotationOffset = new Quaternion().setFromEuler(new Euler(0, Math.PI, 0));
 //TODO: currently assumes the model is not yet transformed - loaded for the first time
-export function fixModelAnimationClip(model, clip, clipScene, removeXZMovement, boneMap) {
-    const hipsClipBoneName = boneMap == null ? 'hips' : Object.entries(boneMap).find(([, vrmBoneName]) => vrmBoneName === 'hips')?.[0];
-    if (hipsClipBoneName == null) {
-        throw new Error('Failed to determine hips bone name for VRM animation. Please check the bone map or animation file.');
-    }
+export function fixModelAnimationClip(model, clip, clipScene, removeXZMovement) {
     let restRoot;
     let restRootParent;
     if (!(model instanceof VRM)) {
@@ -39,24 +37,22 @@ export function fixModelAnimationClip(model, clip, clipScene, removeXZMovement,
     let positionScale = 1;
     let clipSceneHips;
     if (clipScene != null) {
-        clipSceneHips = clipScene.getObjectByName(hipsClipBoneName);
+        clipSceneHips = clipScene.getObjectByName('hips');
         clipSceneHips?.parent?.updateMatrixWorld();
         const vrmHipsPosition = model instanceof VRM
             ? model.humanoid.normalizedRestPose.hips?.position
             : model.scene.getObjectByName('rest_hips')?.getWorldPosition(new Vector3()).toArray();
-        if (clipSceneHips == null || vrmHipsPosition == null) {
-            throw new Error('Failed to load animation: missing animation hips object or VRM hips position.');
+        if (clipSceneHips != null && vrmHipsPosition != null) {
+            // Adjust with reference to hips height.
+            const motionHipsHeight = clipSceneHips.getWorldPosition(position).y;
+            const [_, vrmHipsHeight] = vrmHipsPosition;
+            positionScale = vrmHipsHeight / motionHipsHeight;
         }
-        // Adjust with reference to hips height.
-        const motionHipsHeight = clipSceneHips.getWorldPosition(position).y;
-        const [_, vrmHipsHeight] = vrmHipsPosition;
-        positionScale = vrmHipsHeight / motionHipsHeight;
     }
     for (const track of clip.tracks) {
         // Convert each tracks for VRM use, and push to `tracks`
         const [clipBoneName, propertyName] = track.name.split('.');
-        const vrmBoneName = (boneMap?.[clipBoneName] ?? clipBoneName);
-        const targetNormalizedBoneName = model instanceof VRM ? model.humanoid.getNormalizedBoneNode(vrmBoneName)?.name : vrmBoneName;
+        const targetNormalizedBoneName = model instanceof VRM ? model.humanoid.getNormalizedBoneNode(clipBoneName)?.name : clipBoneName;
         if (targetNormalizedBoneName == null) {
             continue;
         }
@@ -69,7 +65,7 @@ export function fixModelAnimationClip(model, clip, clipScene, removeXZMovement,
             targetParentWorldBoneTransform = { rotation: [0, 0, 0, 1] };
         }
         else {
-            const targetBone = model.scene.getObjectByName(`rest_${vrmBoneName}`);
+            const targetBone = model.scene.getObjectByName(`rest_${clipBoneName}`);
             if (targetBone != null) {
                 targetLocalBoneTransform = { rotation: targetBone.quaternion.toArray() };
             }
@@ -123,7 +119,7 @@ export function fixModelAnimationClip(model, clip, clipScene, removeXZMovement,
                     targetThisLocalCurrentRotation.x *= -1;
                     targetThisLocalCurrentRotation.z *= -1;
                 }
-                if (!(model instanceof VRM) && vrmBoneName === 'hips') {
+                if (!(model instanceof VRM) && clipBoneName === 'hips') {
                     targetThisLocalCurrentRotation.premultiply(nonVrmRotationOffset);
                 }
                 targetThisLocalCurrentRotation.toArray(track.values, i);
@@ -131,7 +127,7 @@ export function fixModelAnimationClip(model, clip, clipScene, removeXZMovement,
             track.name = trackName;
         }
         else if (track instanceof VectorKeyframeTrack) {
-            if (vrmBoneName != 'hips' && vrmBoneName != 'root') {
+            if (clipBoneName != 'hips' && clipBoneName != 'root') {
                 continue;
             }
             if (propertyName != 'position') {
@@ -140,7 +136,7 @@ export function fixModelAnimationClip(model, clip, clipScene, removeXZMovement,
             for (let i = 0; i < track.values.length; i += 3) {
                 position.fromArray(track.values, i);
                 if (clipSceneHips?.parent != null) {
-                    if (vrmBoneName === 'hips') {
+                    if (clipBoneName === 'hips') {
                         position.applyMatrix4(clipSceneHips.parent.matrixWorld);
                     }
                     else {
@@ -148,7 +144,7 @@ export function fixModelAnimationClip(model, clip, clipScene, removeXZMovement,
                     }
                 }
                 position.multiplyScalar(positionScale);
-                if (!(model instanceof VRM) && vrmBoneName === 'hips') {
+                if (!(model instanceof VRM) && clipBoneName === 'hips') {
                     position.applyQuaternion(nonVrmRotationOffset);
                 }
                 if (model instanceof VRM) {
@@ -157,7 +153,7 @@ export function fixModelAnimationClip(model, clip, clipScene, removeXZMovement,
                         position.y *= -1;
                     }
                 }
-                if (vrmBoneName === 'hips' && removeXZMovement) {
+                if (clipBoneName === 'hips' && removeXZMovement) {
                     position.x = 0;
                     position.z = 0;
                 }
@@ -170,10 +166,9 @@ export function fixModelAnimationClip(model, clip, clipScene, removeXZMovement,
         restRoot.parent = restRootParent;
     }
 }
-export * from './gltf.js';
-export * from './fbx.js';
-export * from './vrma.js';
 export * from './utils.js';
+export * from './default.js';
+export * from './mask.js';
 export function flattenCharacterAnimationOptions(options) {
     return [
         options.url,
@@ -186,12 +181,17 @@ export function flattenCharacterAnimationOptions(options) {
         options.mask,
     ];
 }
+const gltfLoader = new GLTFLoader();
+const fbxLoader = new FBXLoader();
+const bvhLoader = new BVHLoader();
 export async function loadCharacterAnimation(model, url, type, removeXZMovement = false, trimStartTime, trimEndTime, boneMap, scaleTime, mask) {
-    if (typeof url === 'object') {
-        url = await loadDefaultCharacterAnimationUrl(url.default);
+    if (typeof url === 'symbol') {
+        url = await resolveDefaultCharacterAnimationUrl(url);
         type = 'gltf';
     }
     let clips;
+    let clipScene;
+    let defaultBoneMap;
     if (type == null) {
         const lowerCaseUrl = url.toLocaleLowerCase();
         if (lowerCaseUrl.endsWith('.glb') || lowerCaseUrl.endsWith('.gltf')) {
@@ -211,29 +211,51 @@ export async function loadCharacterAnimation(model, url, type, removeXZMovement
         }
     }
     switch (type) {
-        case 'gltf':
-            clips = await loadVrmModelGltfAnimations(model, url, removeXZMovement, boneMap);
+        case 'gltf': {
+            const { animations, scene } = await gltfLoader.loadAsync(url);
+            clips = animations;
+            clipScene = scene;
             break;
-        case 'fbx':
-            clips = await loadVrmModelFbxAnimations(model, url, removeXZMovement, boneMap);
+        }
+        case 'fbx': {
+            const scene = await fbxLoader.loadAsync(url);
+            clips = scene.animations;
+            clipScene = scene;
             break;
-        case 'bvh':
-            clips = await loadVrmModelBvhAnimations(model, url, removeXZMovement, boneMap ?? bvhBoneMap);
+        }
+        case 'bvh': {
+            const { clip, skeleton } = await bvhLoader.loadAsync(url);
+            clips = [clip];
+            boneMap ??= bvhBoneMap;
             break;
-        case 'mixamo':
-            clips = await loadVrmModelFbxAnimations(model, url, removeXZMovement, boneMap ?? mixamoBoneMap);
+        }
+        case 'mixamo': {
+            const scene = await fbxLoader.loadAsync(url);
+            clips = scene.animations;
+            clipScene = scene;
+            boneMap ??= mixamoBoneMap;
             break;
+        }
         case 'vrma':
             if (!(model instanceof VRM)) {
                 throw new Error(`Model must be an instance of VRM to load VRMA animations`);
             }
-            clips = await loadVrmModelVrmaAnimations(model, url, removeXZMovement);
+            clips = (await vrmaLoader.loadAsync(url)).userData.vrmAnimations;
             break;
     }
     if (clips.length != 1) {
         throw new Error(`Expected exactly one animation clip, but got ${clips.length} for url ${url}`);
     }
     const [clip] = clips;
+    if (boneMap != null) {
+        applyBoneMap(clip, clipScene, boneMap);
+    }
+    if (mask != null) {
+        applyMask(clip, mask);
+    }
+    if (type != 'vrma') {
+        fixModelAnimationClip(model, clip, clipScene, removeXZMovement);
+    }
     if (trimStartTime != null || trimEndTime != null) {
         trimAnimationClip(clip, trimStartTime, trimEndTime);
     }

package/dist/animation/mask.d.ts

@@ -1,3 +1,6 @@
-import type { CharacterAnimationMask } from './index.js';
+import type { VRMHumanBoneName } from '@pixiv/three-vrm';
 import type { AnimationClip } from 'three';
+export type CharacterAnimationMask = (boneName: VRMHumanBoneName) => boolean;
 export declare function applyMask(clip: AnimationClip, mask: CharacterAnimationMask): void;
+export declare const upperBody: CharacterAnimationMask;
+export declare const lowerBody: CharacterAnimationMask;

package/dist/animation/mask.js

@@ -1,3 +1,53 @@
 export function applyMask(clip, mask) {
     clip.tracks = clip.tracks.filter((track) => mask(track.name.split('.')[0]));
 }
+const upperBodyParts = [
+    'spine',
+    'chest',
+    'upperChest',
+    'neck',
+    'head',
+    'leftEye',
+    'rightEye',
+    'jaw',
+    'leftShoulder',
+    'leftUpperArm',
+    'leftLowerArm',
+    'leftHand',
+    'rightShoulder',
+    'rightUpperArm',
+    'rightLowerArm',
+    'rightHand',
+    'leftThumbMetacarpal',
+    'leftThumbProximal',
+    'leftThumbDistal',
+    'leftIndexProximal',
+    'leftIndexIntermediate',
+    'leftIndexDistal',
+    'leftMiddleProximal',
+    'leftMiddleIntermediate',
+    'leftMiddleDistal',
+    'leftRingProximal',
+    'leftRingIntermediate',
+    'leftRingDistal',
+    'leftLittleProximal',
+    'leftLittleIntermediate',
+    'leftLittleDistal',
+    'rightThumbMetacarpal',
+    'rightThumbProximal',
+    'rightThumbDistal',
+    'rightIndexProximal',
+    'rightIndexIntermediate',
+    'rightIndexDistal',
+    'rightMiddleProximal',
+    'rightMiddleIntermediate',
+    'rightMiddleDistal',
+    'rightRingProximal',
+    'rightRingIntermediate',
+    'rightRingDistal',
+    'rightLittleProximal',
+    'rightLittleIntermediate',
+    'rightLittleDistal',
+];
+export const upperBody = (name) => upperBodyParts.includes(name);
+export const lowerBody = (name) => !upperBodyParts.includes(name);

package/dist/camera.d.ts

@@ -1,7 +1,6 @@
 import { Object3D, Vector3, Vector3Tuple, Ray } from 'three';
-import { InputSystem } from './input/index.js';
-export declare const FirstPersonCharacterCameraBehavior: SimpleCharacterCameraBehaviorOptions;
-export type SimpleCharacterCameraBehaviorOptions = {
+export declare const FirstPersonCharacterCameraBehavior: CharacterCameraBehaviorOptions;
+export type CharacterCameraBehaviorOptions = {
     /**
      * @default true
      */
@@ -61,6 +60,10 @@ export declare class CharacterCameraBehavior {
     zoomDistance: number;
     private collisionFreeZoomDistance;
     private firstUpdate;
+    private readonly abortController;
+    private readonly yawReader;
+    private readonly pitchReader;
+    private readonly zoomReader;
     private setRotationFromDelta;
     private setDistanceFromDelta;
     private computeCharacterBaseOffset;
@@ -70,5 +73,6 @@ export declare class CharacterCameraBehavior {
     /**
      * @param delta in seconds
      */
-    update(camera: Object3D, target: Object3D, inputSystem: InputSystem, deltaTime: number, raycast?: (ray: Ray, far: number) => number | undefined, options?: SimpleCharacterCameraBehaviorOptions): void;
+    update(camera: Object3D, target: Object3D, deltaTime: number, raycast?: (ray: Ray, far: number) => number | undefined, options?: CharacterCameraBehaviorOptions): void;
+    dispose(): void;
 }

package/dist/camera.js

@@ -1,6 +1,6 @@
-import { Vector3, Euler, Ray } from 'three';
+import { Vector3, Euler, Ray, Quaternion } from 'three';
 import { clamp } from 'three/src/math/MathUtils.js';
-import { DeltaYawField, DeltaPitchField, DeltaZoomField } from './input/index.js';
+import { RotatePitchAction, RotateYawAction, ZoomAction } from './action/index.js';
 export const FirstPersonCharacterCameraBehavior = {
     characterBaseOffset: [0, 1.6, 0],
     zoom: { maxDistance: 0, minDistance: 0 },
@@ -11,6 +11,7 @@ const sphericalOffset = new Vector3();
 const characterWorldPosition = new Vector3();
 const euler = new Euler();
 const rayHelper = new Ray();
+const quaternionHelper = new Quaternion();
 export class CharacterCameraBehavior {
     rotationPitch = (-20 * Math.PI) / 180;
     rotationYaw = 0;
@@ -18,6 +19,10 @@ export class CharacterCameraBehavior {
     //internal state
     collisionFreeZoomDistance = this.zoomDistance;
     firstUpdate = true;
+    abortController = new AbortController();
+    yawReader = RotateYawAction.createReader(this.abortController.signal);
+    pitchReader = RotatePitchAction.createReader(this.abortController.signal);
+    zoomReader = ZoomAction.createReader(this.abortController.signal);
     setRotationFromDelta(camera, delta, rotationOptions) {
         if (delta.lengthSq() < 0.0001) {
             // use current camera rotation if very close to target
@@ -55,7 +60,7 @@ export class CharacterCameraBehavior {
     /**
      * @param delta in seconds
      */
-    update(camera, target, inputSystem, deltaTime, raycast, options = true) {
+    update(camera, target, deltaTime, raycast, options = true) {
         if (options === false) {
             this.firstUpdate = true;
             return;
@@ -66,17 +71,21 @@ export class CharacterCameraBehavior {
         }
         //compute character->camera delta through offset
         this.computeCharacterBaseOffset(chracterBaseOffsetHelper, options.characterBaseOffset);
+        target.getWorldQuaternion(quaternionHelper);
+        chracterBaseOffsetHelper.applyQuaternion(quaternionHelper);
         target.getWorldPosition(characterWorldPosition);
         characterWorldPosition.add(chracterBaseOffsetHelper);
         camera.getWorldPosition(deltaHelper);
         deltaHelper.sub(characterWorldPosition);
-        // apply rotation input to rotationYaw and rotationPitch if not disabled or first update
+        // apply rotation actions to rotationYaw and rotationPitch if not disabled or first update
         let rotationOptions = options.rotation ?? true;
         if (!this.firstUpdate && rotationOptions !== false) {
             rotationOptions = rotationOptions === true ? {} : rotationOptions;
             const rotationSpeed = rotationOptions.speed ?? 1000.0;
-            const deltaYaw = inputSystem.get(DeltaYawField);
-            const deltaPitch = inputSystem.get(DeltaPitchField);
+            this.yawReader.update();
+            this.pitchReader.update();
+            const deltaYaw = this.yawReader.get();
+            const deltaPitch = this.pitchReader.get();
             this.rotationYaw = this.clampYaw(this.rotationYaw + deltaYaw * rotationSpeed * deltaTime, rotationOptions);
             this.rotationPitch = this.clampPitch(this.rotationPitch + deltaPitch * rotationSpeed * deltaTime, rotationOptions);
         }
@@ -87,12 +96,13 @@ export class CharacterCameraBehavior {
         camera.rotation.set(this.rotationPitch, this.rotationYaw, 0, 'YXZ');
         rayHelper.direction.set(0, 0, 1).applyEuler(camera.rotation);
         rayHelper.origin.copy(characterWorldPosition);
-        // apply zoom input to zoomDistance if not disabled or first update
+        // apply zoom action to zoomDistance if not disabled or first update
         let zoomOptions = options.zoom ?? true;
         if (!this.firstUpdate && zoomOptions !== false) {
             zoomOptions = zoomOptions === true ? {} : zoomOptions;
             const zoomSpeed = zoomOptions.speed ?? 1000.0;
-            const deltaZoom = inputSystem.get(DeltaZoomField);
+            this.zoomReader.update();
+            const deltaZoom = this.zoomReader.get();
             const zoomFactor = 1 + deltaZoom * zoomSpeed * deltaTime;
             if (deltaZoom >= 0) {
                 this.zoomDistance *= zoomFactor;
@@ -120,10 +130,15 @@ export class CharacterCameraBehavior {
         sphericalOffset.set(0, 0, this.collisionFreeZoomDistance);
         sphericalOffset.applyEuler(camera.rotation);
         // Get target position with offset (reuse helper vector)
-        target.getWorldPosition(characterWorldPosition);
         this.computeCharacterBaseOffset(chracterBaseOffsetHelper, options.characterBaseOffset);
+        target.getWorldQuaternion(quaternionHelper);
+        chracterBaseOffsetHelper.applyQuaternion(quaternionHelper);
+        target.getWorldPosition(characterWorldPosition);
         characterWorldPosition.add(chracterBaseOffsetHelper);
         // Set camera position relative to target
         camera.position.copy(characterWorldPosition).add(sphericalOffset);
     }
+    dispose() {
+        this.abortController.abort();
+    }
 }

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export * from './utils.js';
-export * from './input/index.js';
+export * from './action/index.js';
 export * from './utils.js';
 export * from './camera.js';
 export * from './physics/index.js';

package/dist/index.js

@@ -1,5 +1,5 @@
 export * from './utils.js';
-export * from './input/index.js';
+export * from './action/index.js';
 export * from './utils.js';
 export * from './camera.js';
 export * from './physics/index.js';

package/dist/model/index.d.ts

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

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

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

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

@@ -0,0 +1,34 @@
+import { DefaultJumpKeys, DefaultMoveBackwardKeys, DefaultMoveForwardKeys, DefaultMoveLeftKeys, DefaultMoveRightKeys, DefaultRunKeys, KeyboardLocomotionActionBindings, } from '../action/keyboard.js';
+import { PointerCaptureRotateZoomActionBindings } from '../action/pointer-capture.js';
+import { PointerLockRotateZoomActionBindings } from '../action/pointer-lock.js';
+import { ScreenJoystickLocomotionActionBindings } from '../action/screen-joystick.js';
+export function applySimpleCharacterActionBindingOptions(actionBindingsList, options) {
+    for (const actionBindings of actionBindingsList) {
+        if (actionBindings instanceof ScreenJoystickLocomotionActionBindings) {
+            actionBindings.deadZonePx = options?.screenJoystickDeadZonePx;
+            actionBindings.runDistancePx = options?.screenJoystickRunDistancePx;
+        }
+        if (actionBindings instanceof PointerCaptureRotateZoomActionBindings) {
+            actionBindings.rotationSpeed = options?.pointerCaptureRotationSpeed;
+            actionBindings.zoomSpeed = options?.pointerCaptureZoomSpeed;
+        }
+        if (actionBindings instanceof PointerLockRotateZoomActionBindings) {
+            actionBindings.rotationSpeed = options?.pointerLockRotationSpeed;
+            actionBindings.zoomSpeed = options?.pointerLockZoomSpeed;
+        }
+        if (actionBindings instanceof KeyboardLocomotionActionBindings) {
+            actionBindings.moveForwardBinding.keys = options?.keyboardMoveForwardKeys ?? DefaultMoveForwardKeys;
+            actionBindings.moveBackwardBinding.requiresPointerLock = options?.keyboardRequiresPointerLock;
+            actionBindings.moveBackwardBinding.keys = options?.keyboardMoveBackwardKeys ?? DefaultMoveBackwardKeys;
+            actionBindings.moveBackwardBinding.requiresPointerLock = options?.keyboardRequiresPointerLock;
+            actionBindings.moveLeftBinding.keys = options?.keyboardMoveLeftKeys ?? DefaultMoveLeftKeys;
+            actionBindings.moveLeftBinding.requiresPointerLock = options?.keyboardRequiresPointerLock;
+            actionBindings.moveRightBinding.keys = options?.keyboardMoveRightKeys ?? DefaultMoveRightKeys;
+            actionBindings.moveRightBinding.requiresPointerLock = options?.keyboardRequiresPointerLock;
+            actionBindings.runBinding.keys = options?.keyboardRunKeys ?? DefaultRunKeys;
+            actionBindings.runBinding.requiresPointerLock = options?.keyboardRequiresPointerLock;
+            actionBindings.jumpBinding.keys = options?.keyboardJumpKeys ?? DefaultJumpKeys;
+            actionBindings.jumpBinding.requiresPointerLock = options?.keyboardRequiresPointerLock;
+        }
+    }
+}

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

@@ -1,14 +1,12 @@
 import { Group, Object3D, Object3DEventMap, AnimationAction } from 'three';
 import { CharacterAnimationOptions } from '../animation/index.js';
-import { CharacterCameraBehavior, SimpleCharacterCameraBehaviorOptions } from '../camera.js';
-import { Input, ScreenJoystickInputOptions, LocomotionKeyboardInputOptions, PointerCaptureInputOptions, PointerLockInputOptions, InputSystem } from '../input/index.js';
+import { CharacterCameraBehavior, CharacterCameraBehaviorOptions } 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;
-    inputSystem: InputSystem;
     lastJump: number;
 };
 export type SimpleCharacterMovementOptions = {
@@ -53,7 +51,7 @@ export type SimpleCharacterAnimationOptions = {
     /**
      * @default "movement"
      */
-    yawRotationBasdOn?: 'camera' | 'movement';
+    yawRotationBasedOn?: 'camera' | 'movement';
     /**
      * @default 10
      */
@@ -63,16 +61,40 @@ export type SimpleCharacterAnimationOptions = {
      */
     crossFadeDuration?: number;
 };
-export type SimpleCharacterInputOptions = ScreenJoystickInputOptions & PointerCaptureInputOptions & PointerLockInputOptions & LocomotionKeyboardInputOptions;
+export type SimpleCharacterActionBindingOptions = {
+    screenJoystickRunDistancePx?: number;
+    screenJoystickDeadZonePx?: number;
+    pointerCaptureRotationSpeed?: number;
+    pointerCaptureZoomSpeed?: number;
+    pointerLockRotationSpeed?: number;
+    pointerLockZoomSpeed?: number;
+    keyboardRequiresPointerLock?: boolean;
+    keyboardMoveForwardKeys?: Array<string>;
+    keyboardMoveBackwardKeys?: Array<string>;
+    keyboardMoveLeftKeys?: Array<string>;
+    keyboardMoveRightKeys?: Array<string>;
+    keyboardRunKeys?: Array<string>;
+    keyboardJumpKeys?: Array<string>;
+};
 export type SimpleCharacterOptions = {
-    readonly input?: ReadonlyArray<Input | {
-        new (domElement: HTMLElement): Input;
+    /**
+     * @deprecated use actionBindings instead
+     */
+    readonly input?: ReadonlyArray<{
+        new (domElement: HTMLElement, abortSignal: AbortSignal): any;
     }>;
-    inputOptions?: SimpleCharacterInputOptions;
+    readonly actionBindings?: ReadonlyArray<{
+        new (domElement: HTMLElement, abortSignal: AbortSignal): any;
+    }>;
+    /**
+     * @deprecated use actionBindingOptions instead
+     */
+    inputOptions?: SimpleCharacterActionBindingOptions;
+    actionBindingOptions?: SimpleCharacterActionBindingOptions;
     movement?: SimpleCharacterMovementOptions;
     readonly model?: CharacterModelOptions | boolean;
     physics?: BvhCharacterPhysicsOptions;
-    cameraBehavior?: SimpleCharacterCameraBehaviorOptions;
+    cameraBehavior?: CharacterCameraBehaviorOptions;
     readonly animation?: SimpleCharacterAnimationOptions;
 };
 export declare class SimpleCharacter extends Group<Object3DEventMap & {
@@ -83,7 +105,6 @@ export declare class SimpleCharacter extends Group<Object3DEventMap & {
     private readonly options;
     readonly cameraBehavior: CharacterCameraBehavior;
     readonly physics: BvhCharacterPhysics;
-    readonly inputSystem: InputSystem;
     readonly currentAnimationRef: {
         current?: AnimationAction;
     };
@@ -92,6 +113,7 @@ export declare class SimpleCharacter extends Group<Object3DEventMap & {
     private readonly graph;
     private readonly abortController;
     lastJump: number;
+    readonly abortSignal: AbortSignal;
     constructor(camera: Object3D, world: BvhPhysicsWorld, domElement: HTMLElement, options?: SimpleCharacterOptions);
     private init;
     update(delta: number): void;
@@ -99,3 +121,4 @@ export declare class SimpleCharacter extends Group<Object3DEventMap & {
 }
 export * from './update-input-velocity.js';
 export * from './update-rotation.js';
+export * from './apply-input-options.js';