@pmndrs/viverse 0.1.20 → 0.2.1

package/dist/animation/default.js

@@ -0,0 +1,25 @@
+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 JumpDownAnimationUrl:
+            return (await import('../assets/jump-down.js')).url;
+        case JumpForwardAnimationUrl:
+            return (await import('../assets/jump-forward.js')).url;
+        case JumpLoopAnimationUrl:
+            return (await import('../assets/jump-loop.js')).url;
+        case JumpUpAnimationUrl:
+            return (await import('../assets/jump-up.js')).url;
+        case RunAnimationUrl:
+            return (await import('../assets/run.js')).url;
+        case WalkAnimationUrl:
+            return (await import('../assets/walk.js')).url;
+    }
+}

package/dist/animation/index.d.ts

@@ -1,14 +1,15 @@
 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 | 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 ModelAnimationOptions = {
+export * from './default.js';
+export * from './mask.js';
+export type CharacterAnimationOptions = {
+    url: string | DefaultUrl;
     type?: 'mixamo' | 'gltf' | 'vrma' | 'fbx' | 'bvh';
-    url: string;
     removeXZMovement?: boolean;
     trimTime?: {
         start?: number;
@@ -16,18 +17,10 @@ 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 | 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 { 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 { cached } from '../utils.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,12 +166,32 @@ 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';
-async function uncachedLoadModelAnimation(model, type, url, removeXZMovement, trimStartTime, trimEndTime, boneMap, scaleTime) {
+export * from './default.js';
+export * from './mask.js';
+export function flattenCharacterAnimationOptions(options) {
+    return [
+        options.url,
+        options.type,
+        options.removeXZMovement,
+        options.trimTime?.start,
+        options.trimTime?.end,
+        options.boneMap,
+        options.scaleTime,
+        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 === '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')) {
@@ -195,29 +211,51 @@ async function uncachedLoadModelAnimation(model, type, url, removeXZMovement, tr
         }
     }
     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);
     }
@@ -226,39 +264,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,6 @@
+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

@@ -0,0 +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,5 +1,4 @@
 import { Object3D, Vector3, Vector3Tuple, Ray } from 'three';
-import { SimpleCharacter } from './simple-character.js';
 export declare const FirstPersonCharacterCameraBehavior: SimpleCharacterCameraBehaviorOptions;
 export type SimpleCharacterCameraBehaviorOptions = {
     /**
@@ -55,16 +54,16 @@ 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 readonly abortController;
+    private readonly yawReader;
+    private readonly pitchReader;
+    private readonly zoomReader;
     private setRotationFromDelta;
     private setDistanceFromDelta;
     private computeCharacterBaseOffset;
@@ -74,5 +73,6 @@ export declare class SimpleCharacterCameraBehavior {
     /**
      * @param delta in seconds
      */
-    update(deltaTime: number, options?: SimpleCharacterCameraBehaviorOptions): void;
+    update(camera: Object3D, target: Object3D, deltaTime: number, raycast?: (ray: Ray, far: number) => number | undefined, options?: SimpleCharacterCameraBehaviorOptions): 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 './input/index.js';
 export const FirstPersonCharacterCameraBehavior = {
     characterBaseOffset: [0, 1.6, 0],
     zoom: { maxDistance: 0, minDistance: 0 },
@@ -11,25 +11,22 @@ const sphericalOffset = new Vector3();
 const characterWorldPosition = new Vector3();
 const euler = new Euler();
 const rayHelper = new Ray();
-export class SimpleCharacterCameraBehavior {
-    getCamera;
-    character;
-    raycast;
+const quaternionHelper = new Quaternion();
+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) {
+    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
-            euler.setFromQuaternion(this.getCamera().quaternion, 'YXZ');
+            euler.setFromQuaternion(camera.quaternion, 'YXZ');
             this.rotationPitch = euler.x;
             this.rotationYaw = euler.y;
             return;
@@ -63,7 +60,7 @@ export class SimpleCharacterCameraBehavior {
     /**
      * @param delta in seconds
      */
-    update(deltaTime, options = true) {
+    update(camera, target, deltaTime, raycast, options = true) {
         if (options === false) {
             this.firstUpdate = true;
             return;
@@ -74,33 +71,38 @@ export class SimpleCharacterCameraBehavior {
         }
         //compute character->camera delta through offset
         this.computeCharacterBaseOffset(chracterBaseOffsetHelper, options.characterBaseOffset);
-        this.character.getWorldPosition(characterWorldPosition);
+        target.getWorldQuaternion(quaternionHelper);
+        chracterBaseOffsetHelper.applyQuaternion(quaternionHelper);
+        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);
+            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);
         }
         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);
+            this.zoomReader.update();
+            const deltaZoom = this.zoomReader.get();
             const zoomFactor = 1 + deltaZoom * zoomSpeed * deltaTime;
             if (deltaZoom >= 0) {
                 this.zoomDistance *= zoomFactor;
@@ -119,19 +121,24 @@ 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);
         this.computeCharacterBaseOffset(chracterBaseOffsetHelper, options.characterBaseOffset);
+        target.getWorldQuaternion(quaternionHelper);
+        chracterBaseOffsetHelper.applyQuaternion(quaternionHelper);
+        target.getWorldPosition(characterWorldPosition);
         characterWorldPosition.add(chracterBaseOffsetHelper);
         // Set camera position relative to target
-        this.getCamera().position.copy(characterWorldPosition).add(sphericalOffset);
+        camera.position.copy(characterWorldPosition).add(sphericalOffset);
+    }
+    dispose() {
+        this.abortController.abort();
     }
 }

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/action.d.ts

@@ -0,0 +1,41 @@
+export declare class EventAction<T = void> {
+    private latestTime;
+    private readonly subscriptionListeners;
+    emit(value: T): void;
+    subscribe(callback: (value: T) => void, options?: {
+        once?: true;
+        signal?: AbortSignal;
+    }): void;
+    waitFor(signal?: AbortSignal): Promise<T>;
+    getLatestTime(): number;
+}
+export type StateActionWriter<T> = {
+    write(value: T): void;
+};
+/**
+ * StateAction keeps the latest state per writer and merges them on read.
+ * Values persist until the writer is disposed (abortSignal aborts).
+ */
+export declare class StateAction<T> {
+    private readonly mergeWriters;
+    private readonly neutral;
+    private readonly absoluteActions;
+    constructor(mergeWriters: (...values: Array<T>) => T, neutral: T);
+    createWriter(abortSignal: AbortSignal): StateActionWriter<T>;
+    get(): T;
+}
+/**
+ * DeltaAction accumulates transient values each frame and clears them on frame advance.
+ * Multiple writes per frame from any source are combined using combine().
+ */
+export declare class DeltaAction<T> {
+    private readonly combine;
+    private readonly neutral;
+    constructor(combine: (...values: Array<T>) => T, neutral: T);
+    private readonly readers;
+    write(value: T): void;
+    createReader(abortSignal: AbortSignal): {
+        update(): void;
+        get(): T;
+    };
+}