@pmndrs/viverse 0.1.19 → 0.2.0

package/dist/animation/default.js

@@ -0,0 +1,18 @@
+export async function loadDefaultCharacterAnimationUrl(type) {
+    switch (type) {
+        case 'idle':
+            return (await import('../assets/idle.js')).url;
+        case 'jumpDown':
+            return (await import('../assets/jump-down.js')).url;
+        case 'jumpForward':
+            return (await import('../assets/jump-forward.js')).url;
+        case 'jumpLoop':
+            return (await import('../assets/jump-loop.js')).url;
+        case 'jumpUp':
+            return (await import('../assets/jump-up.js')).url;
+        case 'run':
+            return (await import('../assets/run.js')).url;
+        case 'walk':
+            return (await import('../assets/walk.js')).url;
+    }
+}

package/dist/animation/fbx.d.ts

@@ -1,4 +1,4 @@
 import { AnimationClip } from 'three';
-import { loadCharacterModel } from '../model/index.js';
+import type { CharacterModel } from '../model/index.js';
 import type { VRMHumanBoneName } from '@pixiv/three-vrm';
-export declare function loadVrmModelFbxAnimations(model: Exclude<Awaited<ReturnType<typeof loadCharacterModel>>, undefined>, url: string, removeXZMovement: boolean, boneMap?: Record<string, VRMHumanBoneName>): Promise<Array<AnimationClip>>;
+export declare function loadVrmModelFbxAnimations(model: CharacterModel, url: string, removeXZMovement: boolean, boneMap?: Record<string, VRMHumanBoneName>): Promise<Array<AnimationClip>>;

package/dist/animation/gltf.d.ts

@@ -1,3 +1,3 @@
 import { AnimationClip } from 'three';
-import { loadCharacterModel, VRMHumanBoneName } from '../model/index.js';
-export declare function loadVrmModelGltfAnimations(model: Exclude<Awaited<ReturnType<typeof loadCharacterModel>>, undefined>, url: string, removeXZMovement: boolean, boneMap?: Record<string, VRMHumanBoneName>): Promise<Array<AnimationClip>>;
+import type { CharacterModel, VRMHumanBoneName } from '../model/index.js';
+export declare function loadVrmModelGltfAnimations(model: CharacterModel, url: string, removeXZMovement: boolean, boneMap?: Record<string, VRMHumanBoneName>): Promise<Array<AnimationClip>>;

package/dist/animation/index.d.ts

@@ -1,14 +1,18 @@
 import { VRMHumanBoneName } from '@pixiv/three-vrm';
 import { AnimationClip, Object3D } from 'three';
-import { loadCharacterModel } from '../model/index.js';
-export declare function fixModelAnimationClip(model: Exclude<Awaited<ReturnType<typeof loadCharacterModel>>, undefined>, clip: AnimationClip, clipScene: Object3D, removeXZMovement: boolean, boneMap?: Record<string, VRMHumanBoneName>): void;
+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';
 export * from './utils.js';
-export type ModelAnimationOptions = {
-    type: 'mixamo' | 'gltf' | 'vrma' | 'fbx';
-    url: string;
+export type CharacterAnimationMask = (boneName: VRMHumanBoneName) => boolean;
+export type CharacterAnimationOptions = {
+    url: string | {
+        default: Parameters<typeof loadDefaultCharacterAnimationUrl>[0];
+    };
+    type?: 'mixamo' | 'gltf' | 'vrma' | 'fbx' | 'bvh';
     removeXZMovement?: boolean;
     trimTime?: {
         start?: number;
@@ -16,17 +20,12 @@ export type ModelAnimationOptions = {
     };
     boneMap?: Record<string, VRMHumanBoneName>;
     scaleTime?: number;
+    mask?: CharacterAnimationMask;
 };
-export declare function loadCharacterModelAnimation(model: Exclude<Awaited<ReturnType<typeof loadCharacterModel>>, undefined>, options: ModelAnimationOptions): Promise<AnimationClip>;
-declare const simpleCharacterAnimationUrls: {
-    walk: () => Promise<typeof import("../assets/walk.js")>;
-    run: () => Promise<typeof import("../assets/run.js")>;
-    idle: () => Promise<typeof import("../assets/idle.js")>;
-    jumpUp: () => Promise<typeof import("../assets/jump-up.js")>;
-    jumpLoop: () => Promise<typeof import("../assets/jump-loop.js")>;
-    jumpDown: () => Promise<typeof import("../assets/jump-down.js")>;
-    jumpForward: () => Promise<typeof import("../assets/jump-forward.js")>;
-};
-export declare const simpleCharacterAnimationNames: Array<keyof typeof simpleCharacterAnimationUrls>;
-export declare function getSimpleCharacterModelAnimationOptions(animationName: keyof typeof simpleCharacterAnimationUrls): Promise<ModelAnimationOptions>;
+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 const mixamoBoneMap: Record<string, VRMHumanBoneName>;
+export declare const bvhBoneMap: Record<string, VRMHumanBoneName>;

package/dist/animation/index.js

@@ -1,11 +1,13 @@
 import { VRM } from '@pixiv/three-vrm';
 import { Euler, Quaternion, QuaternionKeyframeTrack, Vector3, VectorKeyframeTrack, } from 'three';
+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 _mixamoBoneMap from './mixamo-bone-map.json';
 import { scaleAnimationClipTime, trimAnimationClip } from './utils.js';
 import { loadVrmModelVrmaAnimations } from './vrma.js';
-import { cached } from '../utils.js';
-import _mixamoBoneMap from './mixamo-bone-map.json';
 //helper variables for the quaternion retargeting
 const baseThisLocalRestRotation_inverse = new Quaternion();
 const baseThisLocalCurrentRotation = new Quaternion();
@@ -20,41 +22,77 @@ 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 hipsBoneName = boneMap == null ? 'hips' : Object.entries(boneMap).find(([, vrmBoneName]) => vrmBoneName === 'hips')?.[0];
-    if (hipsBoneName == null) {
+    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.');
     }
-    const clipSceneHips = clipScene.getObjectByName(hipsBoneName);
-    clipSceneHips?.parent?.updateMatrixWorld();
-    const vrmHipsPosition = model instanceof VRM
-        ? model.humanoid.normalizedRestPose.hips?.position
-        : model.scene.getObjectByName('hips')?.position.toArray();
-    if (clipSceneHips == null || vrmHipsPosition == null) {
-        throw new Error('Failed to load VRM animation: missing animation hips object or VRM hips position.');
+    let restRoot;
+    let restRootParent;
+    if (!(model instanceof VRM)) {
+        restRoot = model.scene.getObjectByName('rest_root');
+        if (restRoot == null) {
+            throw new Error(`Model rest root not found.`);
+        }
+        restRootParent = restRoot?.parent;
+        restRoot.parent = null;
+    }
+    let positionScale = 1;
+    let clipSceneHips;
+    if (clipScene != null) {
+        clipSceneHips = clipScene.getObjectByName(hipsClipBoneName);
+        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.');
+        }
+        // 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;
-    const positionScale = vrmHipsHeight / motionHipsHeight;
     for (const track of clip.tracks) {
         // Convert each tracks for VRM use, and push to `tracks`
-        const [boneName, propertyName] = track.name.split('.');
-        const vrmBoneName = boneMap?.[boneName] ?? boneName;
-        const targetBone = model instanceof VRM
-            ? model.humanoid.getNormalizedBoneNode(vrmBoneName)
-            : model.scene.getObjectByName(vrmBoneName);
-        if (targetBone == null) {
+        const [clipBoneName, propertyName] = track.name.split('.');
+        const vrmBoneName = (boneMap?.[clipBoneName] ?? clipBoneName);
+        const targetNormalizedBoneName = model instanceof VRM ? model.humanoid.getNormalizedBoneNode(vrmBoneName)?.name : vrmBoneName;
+        if (targetNormalizedBoneName == null) {
+            continue;
+        }
+        const trackName = `${targetNormalizedBoneName}.${propertyName}`;
+        let targetLocalBoneTransform;
+        let targetParentWorldBoneTransform;
+        //for vrm targetLocalBoneTransform and targetParentWorldBoneTransform are the identity quaternion
+        if (model instanceof VRM) {
+            targetLocalBoneTransform = { rotation: [0, 0, 0, 1] };
+            targetParentWorldBoneTransform = { rotation: [0, 0, 0, 1] };
+        }
+        else {
+            const targetBone = model.scene.getObjectByName(`rest_${vrmBoneName}`);
+            if (targetBone != null) {
+                targetLocalBoneTransform = { rotation: targetBone.quaternion.toArray() };
+            }
+            if (targetBone?.parent != null) {
+                targetParentWorldBoneTransform = { rotation: targetBone.parent.getWorldQuaternion(new Quaternion()).toArray() };
+            }
+        }
+        if (targetLocalBoneTransform == null) {
             continue;
         }
-        const vrmNodeName = model instanceof VRM ? targetBone.name : vrmBoneName;
-        const baseBone = clipScene.getObjectByName(boneName);
-        if (vrmNodeName == null || baseBone == null) {
+        let baseBone = clipScene?.getObjectByName(clipBoneName);
+        if (clipScene != null && baseBone == null) {
             continue;
         }
         if (track instanceof QuaternionKeyframeTrack) {
             // Store rotations of rest-pose.
-            baseThisLocalRestRotation_inverse.copy(baseBone.quaternion).invert();
-            if (baseBone.parent != null) {
+            if (baseBone != null) {
+                baseThisLocalRestRotation_inverse.copy(baseBone.quaternion).invert();
+            }
+            else {
+                baseThisLocalRestRotation_inverse.identity();
+            }
+            if (baseBone?.parent != null) {
                 baseBone.parent.getWorldQuaternion(baseParentWorldRestRotation);
                 baseParentWorldRestRotation_inverse.copy(baseParentWorldRestRotation).invert();
             }
@@ -62,9 +100,9 @@ export function fixModelAnimationClip(model, clip, clipScene, removeXZMovement,
                 baseParentWorldRestRotation.identity();
                 baseParentWorldRestRotation_inverse.identity();
             }
-            targetThisLocalRestRotation.copy(targetBone.quaternion);
-            if (targetBone.parent != null) {
-                targetBone.parent.getWorldQuaternion(targetParentWorldRestRotation);
+            targetThisLocalRestRotation.fromArray(targetLocalBoneTransform.rotation ?? [0, 0, 0, 1]);
+            if (targetParentWorldBoneTransform != null) {
+                targetParentWorldRestRotation.fromArray(targetParentWorldBoneTransform.rotation ?? [0, 0, 0, 1]);
                 targetParentWorldRestRotation_inverse.copy(targetParentWorldRestRotation).invert();
             }
             else {
@@ -90,16 +128,18 @@ export function fixModelAnimationClip(model, clip, clipScene, removeXZMovement,
                 }
                 targetThisLocalCurrentRotation.toArray(track.values, i);
             }
-            track.name = `${vrmNodeName}.${propertyName}`;
+            track.name = trackName;
         }
         else if (track instanceof VectorKeyframeTrack) {
-            track.name = `${vrmNodeName}.${propertyName}`;
+            if (vrmBoneName != 'hips' && vrmBoneName != 'root') {
+                continue;
+            }
             if (propertyName != 'position') {
                 continue;
             }
             for (let i = 0; i < track.values.length; i += 3) {
                 position.fromArray(track.values, i);
-                if (clipSceneHips.parent != null) {
+                if (clipSceneHips?.parent != null) {
                     if (vrmBoneName === 'hips') {
                         position.applyMatrix4(clipSceneHips.parent.matrixWorld);
                     }
@@ -108,6 +148,9 @@ export function fixModelAnimationClip(model, clip, clipScene, removeXZMovement,
                     }
                 }
                 position.multiplyScalar(positionScale);
+                if (!(model instanceof VRM) && vrmBoneName === 'hips') {
+                    position.applyQuaternion(nonVrmRotationOffset);
+                }
                 if (model instanceof VRM) {
                     if (model.meta.metaVersion === '0') {
                         position.negate();
@@ -120,15 +163,53 @@ export function fixModelAnimationClip(model, clip, clipScene, removeXZMovement,
                 }
                 position.toArray(track.values, i);
             }
+            track.name = trackName;
         }
     }
+    if (restRoot != null && restRootParent != null) {
+        restRoot.parent = restRootParent;
+    }
 }
 export * from './gltf.js';
 export * from './fbx.js';
 export * from './vrma.js';
 export * from './utils.js';
-async function uncachedLoadModelAnimation(model, type, url, removeXZMovement, trimStartTime, trimEndTime, boneMap, scaleTime) {
+export function flattenCharacterAnimationOptions(options) {
+    return [
+        options.url,
+        options.type,
+        options.removeXZMovement,
+        options.trimTime?.start,
+        options.trimTime?.end,
+        options.boneMap,
+        options.scaleTime,
+        options.mask,
+    ];
+}
+export async function loadCharacterAnimation(model, url, type, removeXZMovement = false, trimStartTime, trimEndTime, boneMap, scaleTime, mask) {
+    if (typeof url === 'object') {
+        url = await loadDefaultCharacterAnimationUrl(url.default);
+        type = 'gltf';
+    }
     let clips;
+    if (type == null) {
+        const lowerCaseUrl = url.toLocaleLowerCase();
+        if (lowerCaseUrl.endsWith('.glb') || lowerCaseUrl.endsWith('.gltf')) {
+            type = 'gltf';
+        }
+        if (lowerCaseUrl.endsWith('.fbx')) {
+            type = 'fbx';
+        }
+        if (lowerCaseUrl.endsWith('.bvh')) {
+            type = 'bvh';
+        }
+        if (lowerCaseUrl.endsWith('.vrma')) {
+            type = 'vrma';
+        }
+        if (type == null) {
+            throw new Error(`Unable to infer animation type from url "${url}. Please specify the type of the animation manually."`);
+        }
+    }
     switch (type) {
         case 'gltf':
             clips = await loadVrmModelGltfAnimations(model, url, removeXZMovement, boneMap);
@@ -136,6 +217,9 @@ async function uncachedLoadModelAnimation(model, type, url, removeXZMovement, tr
         case 'fbx':
             clips = await loadVrmModelFbxAnimations(model, url, removeXZMovement, boneMap);
             break;
+        case 'bvh':
+            clips = await loadVrmModelBvhAnimations(model, url, removeXZMovement, boneMap ?? bvhBoneMap);
+            break;
         case 'mixamo':
             clips = await loadVrmModelFbxAnimations(model, url, removeXZMovement, boneMap ?? mixamoBoneMap);
             break;
@@ -158,38 +242,5 @@ async function uncachedLoadModelAnimation(model, type, url, removeXZMovement, tr
     }
     return clip;
 }
-export function loadCharacterModelAnimation(model, options) {
-    return cached(uncachedLoadModelAnimation, [
-        model,
-        options.type,
-        options.url,
-        options.removeXZMovement ?? false,
-        options.trimTime?.start,
-        options.trimTime?.end,
-        options.boneMap,
-        options.scaleTime,
-    ]);
-}
-const extraOptions = {
-    walk: { scaleTime: 0.5 },
-    run: { scaleTime: 0.8 },
-    jumpForward: { scaleTime: 0.9 },
-};
-const simpleCharacterAnimationUrls = {
-    walk: () => import('../assets/walk.js'),
-    run: () => import('../assets/run.js'),
-    idle: () => import('../assets/idle.js'),
-    jumpUp: () => import('../assets/jump-up.js'),
-    jumpLoop: () => import('../assets/jump-loop.js'),
-    jumpDown: () => import('../assets/jump-down.js'),
-    jumpForward: () => import('../assets/jump-forward.js'),
-};
-export const simpleCharacterAnimationNames = Object.keys(simpleCharacterAnimationUrls);
-export async function getSimpleCharacterModelAnimationOptions(animationName) {
-    return {
-        type: 'gltf',
-        ...extraOptions[animationName],
-        url: (await simpleCharacterAnimationUrls[animationName]()).url,
-    };
-}
 export const mixamoBoneMap = _mixamoBoneMap;
+export const bvhBoneMap = _bvhBoneMap;

package/dist/animation/mask.d.ts

@@ -0,0 +1,3 @@
+import type { CharacterAnimationMask } from './index.js';
+import type { AnimationClip } from 'three';
+export declare function applyMask(clip: AnimationClip, mask: CharacterAnimationMask): void;

package/dist/animation/mask.js

@@ -0,0 +1,3 @@
+export function applyMask(clip, mask) {
+    clip.tracks = clip.tracks.filter((track) => mask(track.name.split('.')[0]));
+}

package/dist/camera.d.ts

@@ -1,5 +1,5 @@
 import { Object3D, Vector3, Vector3Tuple, Ray } from 'three';
-import { SimpleCharacter } from './simple-character.js';
+import { InputSystem } from './input/index.js';
 export declare const FirstPersonCharacterCameraBehavior: SimpleCharacterCameraBehaviorOptions;
 export type SimpleCharacterCameraBehaviorOptions = {
     /**
@@ -55,16 +55,12 @@ export type SimpleCharacterCameraBehaviorOptions = {
         maxDistance?: number;
     } | boolean;
 } | boolean;
-export declare class SimpleCharacterCameraBehavior {
-    getCamera: () => Object3D;
-    character: SimpleCharacter;
-    private readonly raycast?;
+export declare class CharacterCameraBehavior {
     rotationPitch: number;
     rotationYaw: number;
     zoomDistance: number;
     private collisionFreeZoomDistance;
     private firstUpdate;
-    constructor(getCamera: () => Object3D, character: SimpleCharacter, raycast?: ((ray: Ray, far: number) => number | undefined) | undefined);
     private setRotationFromDelta;
     private setDistanceFromDelta;
     private computeCharacterBaseOffset;
@@ -74,5 +70,5 @@ export declare class SimpleCharacterCameraBehavior {
     /**
      * @param delta in seconds
      */
-    update(deltaTime: number, options?: SimpleCharacterCameraBehaviorOptions): void;
+    update(camera: Object3D, target: Object3D, inputSystem: InputSystem, deltaTime: number, raycast?: (ray: Ray, far: number) => number | undefined, options?: SimpleCharacterCameraBehaviorOptions): void;
 }

package/dist/camera.js

@@ -11,25 +11,17 @@ const sphericalOffset = new Vector3();
 const characterWorldPosition = new Vector3();
 const euler = new Euler();
 const rayHelper = new Ray();
-export class SimpleCharacterCameraBehavior {
-    getCamera;
-    character;
-    raycast;
+export class CharacterCameraBehavior {
     rotationPitch = (-20 * Math.PI) / 180;
     rotationYaw = 0;
     zoomDistance = 4; // Changed from zoom to distance for clearer semantics
     //internal state
     collisionFreeZoomDistance = this.zoomDistance;
     firstUpdate = true;
-    constructor(getCamera, character, raycast) {
-        this.getCamera = getCamera;
-        this.character = character;
-        this.raycast = raycast;
-    }
-    setRotationFromDelta(delta, rotationOptions) {
+    setRotationFromDelta(camera, delta, rotationOptions) {
         if (delta.lengthSq() < 0.0001) {
             // use current camera rotation if very close to target
-            euler.setFromQuaternion(this.getCamera().quaternion, 'YXZ');
+            euler.setFromQuaternion(camera.quaternion, 'YXZ');
             this.rotationPitch = euler.x;
             this.rotationYaw = euler.y;
             return;
@@ -63,7 +55,7 @@ export class SimpleCharacterCameraBehavior {
     /**
      * @param delta in seconds
      */
-    update(deltaTime, options = true) {
+    update(camera, target, inputSystem, deltaTime, raycast, options = true) {
         if (options === false) {
             this.firstUpdate = true;
             return;
@@ -74,33 +66,33 @@ export class SimpleCharacterCameraBehavior {
         }
         //compute character->camera delta through offset
         this.computeCharacterBaseOffset(chracterBaseOffsetHelper, options.characterBaseOffset);
-        this.character.getWorldPosition(characterWorldPosition);
+        target.getWorldPosition(characterWorldPosition);
         characterWorldPosition.add(chracterBaseOffsetHelper);
-        this.getCamera().getWorldPosition(deltaHelper);
+        camera.getWorldPosition(deltaHelper);
         deltaHelper.sub(characterWorldPosition);
         // apply rotation input 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 = this.character.inputSystem.get(DeltaYawField);
-            const deltaPitch = this.character.inputSystem.get(DeltaPitchField);
+            const deltaYaw = inputSystem.get(DeltaYawField);
+            const deltaPitch = inputSystem.get(DeltaPitchField);
             this.rotationYaw = this.clampYaw(this.rotationYaw + deltaYaw * rotationSpeed * deltaTime, rotationOptions);
             this.rotationPitch = this.clampPitch(this.rotationPitch + deltaPitch * rotationSpeed * deltaTime, rotationOptions);
         }
         else {
-            this.setRotationFromDelta(deltaHelper, typeof rotationOptions === 'boolean' ? {} : rotationOptions);
+            this.setRotationFromDelta(camera, deltaHelper, typeof rotationOptions === 'boolean' ? {} : rotationOptions);
         }
         // apply yaw and pitch to camera rotation
-        this.getCamera().rotation.set(this.rotationPitch, this.rotationYaw, 0, 'YXZ');
-        rayHelper.direction.set(0, 0, 1).applyEuler(this.getCamera().rotation);
+        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
         let zoomOptions = options.zoom ?? true;
         if (!this.firstUpdate && zoomOptions !== false) {
             zoomOptions = zoomOptions === true ? {} : zoomOptions;
             const zoomSpeed = zoomOptions.speed ?? 1000.0;
-            const deltaZoom = this.character.inputSystem.get(DeltaZoomField);
+            const deltaZoom = inputSystem.get(DeltaZoomField);
             const zoomFactor = 1 + deltaZoom * zoomSpeed * deltaTime;
             if (deltaZoom >= 0) {
                 this.zoomDistance *= zoomFactor;
@@ -119,19 +111,19 @@ export class SimpleCharacterCameraBehavior {
             if (collisionOptions === true) {
                 collisionOptions = {};
             }
-            let distance = this.raycast?.(rayHelper, this.zoomDistance);
+            let distance = raycast?.(rayHelper, this.zoomDistance);
             if (distance != null) {
                 this.collisionFreeZoomDistance = distance - (collisionOptions?.offset ?? 0.2);
             }
         }
         // Calculate camera position using spherical coordinates from euler
         sphericalOffset.set(0, 0, this.collisionFreeZoomDistance);
-        sphericalOffset.applyEuler(this.getCamera().rotation);
+        sphericalOffset.applyEuler(camera.rotation);
         // Get target position with offset (reuse helper vector)
-        this.character.getWorldPosition(characterWorldPosition);
+        target.getWorldPosition(characterWorldPosition);
         this.computeCharacterBaseOffset(chracterBaseOffsetHelper, options.characterBaseOffset);
         characterWorldPosition.add(chracterBaseOffsetHelper);
         // Set camera position relative to target
-        this.getCamera().position.copy(characterWorldPosition).add(sphericalOffset);
+        camera.position.copy(characterWorldPosition).add(sphericalOffset);
     }
 }

package/dist/index.d.ts

@@ -1,8 +1,9 @@
-export { extractProxy, getIsMobileMediaQuery, isMobile } from './utils.js';
+export * from './utils.js';
 export * from './input/index.js';
+export * from './utils.js';
 export * from './camera.js';
 export * from './physics/index.js';
 export * from './animation/index.js';
 export * from './material.js';
-export * from './simple-character.js';
+export * from './simple-character/index.js';
 export * from './model/index.js';

package/dist/index.js

@@ -1,10 +1,11 @@
-export { extractProxy, getIsMobileMediaQuery, isMobile } from './utils.js';
+export * from './utils.js';
 export * from './input/index.js';
+export * from './utils.js';
 export * from './camera.js';
 export * from './physics/index.js';
 export * from './animation/index.js';
 export * from './material.js';
-export * from './simple-character.js';
+export * from './simple-character/index.js';
 export * from './model/index.js';
 (function injectMobileClassStyle() {
     if (typeof document === 'undefined') {

package/dist/input/index.d.ts

@@ -1,8 +1,7 @@
-export declare class InputSystem {
-    private readonly inputs;
-    constructor(domElement: HTMLElement, inputs: ReadonlyArray<Input | {
-        new (element: HTMLElement, options?: {}): Input;
-    }>, options?: {});
+export declare class InputSystem<T extends {} = {}> {
+    options: T;
+    readonly inputs: Array<Input>;
+    constructor(options?: T);
     add(input: Input): void;
     remove(input: Input): void;
     dispose(): void;
@@ -21,8 +20,8 @@ export declare const RunField: InputField<boolean>;
 export declare const DeltaZoomField: InputField<number>;
 export declare const DeltaYawField: InputField<number>;
 export declare const DeltaPitchField: InputField<number>;
-export interface Input {
-    get<T>(field: InputField<T>): T | undefined;
+export interface Input<O = {}> {
+    get<T>(field: InputField<T>, options: O): T | undefined;
     dispose?(): void;
 }
 export * from './pointer-lock.js';

package/dist/input/index.js

@@ -1,7 +1,8 @@
 export class InputSystem {
-    inputs;
-    constructor(domElement, inputs, options) {
-        this.inputs = inputs.map((input) => (typeof input === 'function' ? new input(domElement, options) : input));
+    options;
+    inputs = [];
+    constructor(options = {}) {
+        this.options = options;
     }
     add(input) {
         this.inputs.push(input);
@@ -20,7 +21,7 @@ export class InputSystem {
     get(field) {
         let current;
         for (const input of this.inputs) {
-            const result = input.get(field);
+            const result = input.get(field, this.options);
             if (result == null) {
                 continue;
             }

package/dist/input/keyboard.d.ts

@@ -7,11 +7,10 @@ export type LocomotionKeyboardInputOptions = {
     keyboardRunKeys?: Array<string>;
     keyboardJumpKeys?: Array<string>;
 };
-export declare class LocomotionKeyboardInput implements Input {
-    private readonly options;
+export declare class LocomotionKeyboardInput implements Input<LocomotionKeyboardInputOptions> {
     private readonly abortController;
     private readonly keyState;
-    constructor(domElement: HTMLElement, options?: LocomotionKeyboardInputOptions);
-    get<T>(field: InputField<T>): T | undefined;
+    constructor(domElement: HTMLElement);
+    get<T>(field: InputField<T>, options: LocomotionKeyboardInputOptions): T | undefined;
     dispose(): void;
 }

package/dist/input/keyboard.js

@@ -6,11 +6,9 @@ const DefaultMoveRightKeys = ['KeyD'];
 const DefaultRunKeys = ['ShiftRight', 'ShiftLeft'];
 const DefaultJumpKeys = ['Space'];
 export class LocomotionKeyboardInput {
-    options;
     abortController = new AbortController();
     keyState = new Map();
-    constructor(domElement, options = {}) {
-        this.options = options;
+    constructor(domElement) {
         domElement.tabIndex = 0;
         domElement.addEventListener('keydown', (event) => {
             let state = this.keyState.get(event.code);
@@ -41,9 +39,9 @@ export class LocomotionKeyboardInput {
             signal: this.abortController.signal,
         });
     }
-    get(field) {
+    get(field, options) {
         if (field === LastTimeJumpPressedField) {
-            const jumpKeys = this.options.keyboardJumpKeys ?? DefaultJumpKeys;
+            const jumpKeys = options.keyboardJumpKeys ?? DefaultJumpKeys;
             const pressed = jumpKeys
                 .map((key) => this.keyState.get(key)?.pressTime ?? null)
                 .filter((t) => t != null);
@@ -52,19 +50,19 @@ export class LocomotionKeyboardInput {
         let keys;
         switch (field) {
             case MoveForwardField:
-                keys = this.options.keyboardMoveForwardKeys ?? DefaultMoveForwardKeys;
+                keys = options.keyboardMoveForwardKeys ?? DefaultMoveForwardKeys;
                 break;
             case MoveBackwardField:
-                keys = this.options.keyboardMoveBackwardKeys ?? DefaultMoveBackwardKeys;
+                keys = options.keyboardMoveBackwardKeys ?? DefaultMoveBackwardKeys;
                 break;
             case MoveLeftField:
-                keys = this.options.keyboardMoveLeftKeys ?? DefaultMoveLeftKeys;
+                keys = options.keyboardMoveLeftKeys ?? DefaultMoveLeftKeys;
                 break;
             case MoveRightField:
-                keys = this.options.keyboardMoveRightKeys ?? DefaultMoveRightKeys;
+                keys = options.keyboardMoveRightKeys ?? DefaultMoveRightKeys;
                 break;
             case RunField:
-                keys = this.options.keyboardRunKeys ?? DefaultRunKeys;
+                keys = options.keyboardRunKeys ?? DefaultRunKeys;
                 break;
         }
         if (keys == null) {