@pmndrs/viverse 0.1.18 → 0.1.20

package/dist/animation/bvh-bone-map.json

@@ -0,0 +1,24 @@
+{
+    "Hips": "hips",
+    "Spine": "spine",
+    "Spine1": "chest",
+    "Spine2": "upperChest",
+    "Neck": "neck",
+    "Head": "head",
+    "LeftShoulder": "leftShoulder",
+    "LeftArm": "leftUpperArm",
+    "LeftForeArm": "leftLowerArm",
+    "LeftHand": "leftHand",
+    "RightShoulder": "rightShoulder",
+    "RightArm": "rightUpperArm",
+    "RightForeArm": "rightLowerArm",
+    "RightHand": "rightHand",
+    "LeftUpLeg": "leftUpperLeg",
+    "LeftLeg": "leftLowerLeg",
+    "LeftFoot": "leftFoot",
+    "LeftToe": "leftToes",
+    "RightUpLeg": "rightUpperLeg",
+    "RightLeg": "rightLowerLeg",
+    "RightFoot": "rightFoot",
+    "RightToe": "rightToes"
+}

package/dist/animation/bvh.d.ts

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

package/dist/animation/bvh.js

@@ -0,0 +1,8 @@
+import { BVHLoader } from 'three/examples/jsm/Addons.js';
+import { bvhBoneMap, fixModelAnimationClip } from './index.js';
+const loader = new BVHLoader();
+export async function loadVrmModelBvhAnimations(model, url, removeXZMovement, boneMap) {
+    const clipScene = await loader.loadAsync(url);
+    fixModelAnimationClip(model, clipScene.clip, undefined, removeXZMovement, boneMap ?? bvhBoneMap);
+    return [clipScene.clip];
+}

package/dist/animation/fbx.d.ts

@@ -0,0 +1,4 @@
+import { AnimationClip } from 'three';
+import { loadCharacterModel } 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>>;

package/dist/animation/{mixamo.js → fbx.js}

@@ -1,9 +1,8 @@
 import { FBXLoader } from 'three/examples/jsm/Addons.js';
 import { fixModelAnimationClip } from './index.js';
-import mixamoBoneMap from './mixamo-bone-map.json';
 const loader = new FBXLoader();
-export async function loadVrmModelMixamoAnimations(model, url, removeXZMovement) {
+export async function loadVrmModelFbxAnimations(model, url, removeXZMovement, boneMap) {
     const clipScene = await loader.loadAsync(url);
-    clipScene.animations.forEach((clip) => fixModelAnimationClip(model, clip, clipScene, removeXZMovement, mixamoBoneMap));
+    clipScene.animations.forEach((clip) => fixModelAnimationClip(model, clip, clipScene, removeXZMovement, boneMap));
     return clipScene.animations;
 }

package/dist/animation/gltf.d.ts

@@ -1,3 +1,3 @@
 import { AnimationClip } from 'three';
-import { loadCharacterModel } from '../model/index.js';
-export declare function loadVrmModelGltfAnimations(model: Exclude<Awaited<ReturnType<typeof loadCharacterModel>>, undefined>, url: string, removeXZMovement: boolean): Promise<Array<AnimationClip>>;
+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>>;

package/dist/animation/gltf.js

@@ -1,8 +1,8 @@
 import { GLTFLoader } from 'three/examples/jsm/Addons.js';
 import { fixModelAnimationClip } from './index.js';
 const loader = new GLTFLoader();
-export async function loadVrmModelGltfAnimations(model, url, removeXZMovement) {
+export async function loadVrmModelGltfAnimations(model, url, removeXZMovement, boneMap) {
     const { animations, scene: clipScene } = await loader.loadAsync(url);
-    animations.forEach((clip) => fixModelAnimationClip(model, clip, clipScene, removeXZMovement));
+    animations.forEach((clip) => fixModelAnimationClip(model, clip, clipScene, removeXZMovement, boneMap));
     return animations;
 }

package/dist/animation/index.d.ts

@@ -1,19 +1,20 @@
 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;
+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 './mixamo.js';
+export * from './fbx.js';
 export * from './vrma.js';
 export * from './utils.js';
 export type ModelAnimationOptions = {
-    type: 'mixamo' | 'gltf' | 'vrma';
+    type?: 'mixamo' | 'gltf' | 'vrma' | 'fbx' | 'bvh';
     url: string;
     removeXZMovement?: boolean;
     trimTime?: {
         start?: number;
         end?: number;
     };
+    boneMap?: Record<string, VRMHumanBoneName>;
     scaleTime?: number;
 };
 export declare function loadCharacterModelAnimation(model: Exclude<Awaited<ReturnType<typeof loadCharacterModel>>, undefined>, options: ModelAnimationOptions): Promise<AnimationClip>;
@@ -28,3 +29,5 @@ declare const simpleCharacterAnimationUrls: {
 };
 export declare const simpleCharacterAnimationNames: Array<keyof typeof simpleCharacterAnimationUrls>;
 export declare function getSimpleCharacterModelAnimationOptions(animationName: keyof typeof simpleCharacterAnimationUrls): Promise<ModelAnimationOptions>;
+export declare const mixamoBoneMap: Record<string, VRMHumanBoneName>;
+export declare const bvhBoneMap: Record<string, VRMHumanBoneName>;

package/dist/animation/index.js

@@ -1,104 +1,211 @@
 import { VRM } from '@pixiv/three-vrm';
 import { Euler, Quaternion, QuaternionKeyframeTrack, Vector3, VectorKeyframeTrack, } from 'three';
-import { loadVrmModelGltfAnimations as loadModelGltfAnimations } from './gltf.js';
-import { loadVrmModelMixamoAnimations as loadModelMixamoAnimations } from './mixamo.js';
+import _bvhBoneMap from './bvh-bone-map.json';
+import { loadVrmModelBvhAnimations } from './bvh.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';
-const restRotationInverse = new Quaternion();
-const parentRestWorldRotation = new Quaternion();
-const quaternion = new Quaternion();
-const vector = new Vector3();
+//helper variables for the quaternion retargeting
+const baseThisLocalRestRotation_inverse = new Quaternion();
+const baseThisLocalCurrentRotation = new Quaternion();
+const baseParentWorldRestRotation = new Quaternion();
+const baseParentWorldRestRotation_inverse = new Quaternion();
+const targetParentWorldRestRotation = new Quaternion();
+const targetParentWorldRestRotation_inverse = new Quaternion();
+const targetThisLocalRestRotation = new Quaternion();
+const targetThisLocalCurrentRotation = new Quaternion();
+//helper variables for the position retargeting
+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);
-    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.position.y;
-    const [_, vrmHipsHeight] = vrmHipsPosition;
-    const hipsPositionScale = 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 vrmNodeName = model instanceof VRM ? model.humanoid.getNormalizedBoneNode(vrmBoneName)?.name : vrmBoneName;
-        const bone = clipScene.getObjectByName(boneName);
-        if (vrmNodeName == null || bone == 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;
+        }
+        let baseBone = clipScene?.getObjectByName(clipBoneName);
+        if (clipScene != null && baseBone == null) {
             continue;
         }
         if (track instanceof QuaternionKeyframeTrack) {
-            if (bone.parent != null) {
-                bone.getWorldQuaternion(restRotationInverse).invert();
-                bone.parent.getWorldQuaternion(parentRestWorldRotation);
+            // Store rotations of rest-pose.
+            if (baseBone != null) {
+                baseThisLocalRestRotation_inverse.copy(baseBone.quaternion).invert();
             }
             else {
-                restRotationInverse.identity();
-                parentRestWorldRotation.identity();
+                baseThisLocalRestRotation_inverse.identity();
+            }
+            if (baseBone?.parent != null) {
+                baseBone.parent.getWorldQuaternion(baseParentWorldRestRotation);
+                baseParentWorldRestRotation_inverse.copy(baseParentWorldRestRotation).invert();
+            }
+            else {
+                baseParentWorldRestRotation.identity();
+                baseParentWorldRestRotation_inverse.identity();
+            }
+            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 {
+                targetParentWorldRestRotation.identity();
+                targetParentWorldRestRotation_inverse.identity();
             }
-            // Store rotations of rest-pose.
             for (let i = 0; i < track.values.length; i += 4) {
-                quaternion.fromArray(track.values, i);
-                if (model instanceof VRM) {
-                    quaternion.premultiply(parentRestWorldRotation).multiply(restRotationInverse);
-                    if (model.meta.metaVersion === '0') {
-                        quaternion.x *= -1;
-                        quaternion.z *= -1;
-                    }
+                baseThisLocalCurrentRotation.fromArray(track.values, i);
+                targetThisLocalCurrentRotation
+                    .copy(targetParentWorldRestRotation_inverse)
+                    .multiply(baseParentWorldRestRotation)
+                    .multiply(baseThisLocalCurrentRotation)
+                    .multiply(baseThisLocalRestRotation_inverse)
+                    .multiply(baseParentWorldRestRotation_inverse)
+                    .multiply(targetParentWorldRestRotation)
+                    .multiply(targetThisLocalRestRotation);
+                if (model instanceof VRM && model.meta.metaVersion === '0') {
+                    targetThisLocalCurrentRotation.x *= -1;
+                    targetThisLocalCurrentRotation.z *= -1;
                 }
-                if (vrmBoneName === 'root') {
-                    quaternion.multiply(nonVrmRotationOffset);
+                if (!(model instanceof VRM) && vrmBoneName === 'hips') {
+                    targetThisLocalCurrentRotation.premultiply(nonVrmRotationOffset);
                 }
-                if (removeXZMovement) {
-                    //TODO
-                }
-                quaternion.toArray(track.values, i);
+                targetThisLocalCurrentRotation.toArray(track.values, i);
             }
-            track.name = `${vrmNodeName}.${propertyName}`;
+            track.name = trackName;
         }
         else if (track instanceof VectorKeyframeTrack) {
-            track.name = `${vrmNodeName}.${propertyName}`;
-            if (propertyName === 'scale') {
+            if (vrmBoneName != 'hips' && vrmBoneName != 'root') {
+                continue;
+            }
+            if (propertyName != 'position') {
                 continue;
             }
             for (let i = 0; i < track.values.length; i += 3) {
-                vector.fromArray(track.values, i);
-                vector.multiplyScalar(hipsPositionScale);
+                position.fromArray(track.values, i);
+                if (clipSceneHips?.parent != null) {
+                    if (vrmBoneName === 'hips') {
+                        position.applyMatrix4(clipSceneHips.parent.matrixWorld);
+                    }
+                    else {
+                        position.multiplyScalar(clipSceneHips.parent.matrixWorld.getMaxScaleOnAxis());
+                    }
+                }
+                position.multiplyScalar(positionScale);
+                if (!(model instanceof VRM) && vrmBoneName === 'hips') {
+                    position.applyQuaternion(nonVrmRotationOffset);
+                }
                 if (model instanceof VRM) {
                     if (model.meta.metaVersion === '0') {
-                        vector.negate();
-                        vector.y *= -1;
+                        position.negate();
+                        position.y *= -1;
                     }
                 }
                 if (vrmBoneName === 'hips' && removeXZMovement) {
-                    vector.x = 0;
-                    vector.z = 0;
+                    position.x = 0;
+                    position.z = 0;
                 }
-                vector.toArray(track.values, i);
+                position.toArray(track.values, i);
             }
+            track.name = trackName;
         }
     }
+    if (restRoot != null && restRootParent != null) {
+        restRoot.parent = restRootParent;
+    }
 }
 export * from './gltf.js';
-export * from './mixamo.js';
+export * from './fbx.js';
 export * from './vrma.js';
 export * from './utils.js';
-async function uncachedLoadModelAnimation(model, type, url, removeXZMovement, trimStartTime, trimEndTime, scaleTime) {
+async function uncachedLoadModelAnimation(model, type, url, removeXZMovement, trimStartTime, trimEndTime, boneMap, scaleTime) {
     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 loadModelGltfAnimations(model, url, removeXZMovement);
+            clips = await loadVrmModelGltfAnimations(model, url, removeXZMovement, boneMap);
+            break;
+        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 loadModelMixamoAnimations(model, url, removeXZMovement);
+            clips = await loadVrmModelFbxAnimations(model, url, removeXZMovement, boneMap ?? mixamoBoneMap);
             break;
         case 'vrma':
             if (!(model instanceof VRM)) {
@@ -127,6 +234,7 @@ export function loadCharacterModelAnimation(model, options) {
         options.removeXZMovement ?? false,
         options.trimTime?.start,
         options.trimTime?.end,
+        options.boneMap,
         options.scaleTime,
     ]);
 }
@@ -152,3 +260,5 @@ export async function getSimpleCharacterModelAnimationOptions(animationName) {
         url: (await simpleCharacterAnimationUrls[animationName]()).url,
     };
 }
+export const mixamoBoneMap = _mixamoBoneMap;
+export const bvhBoneMap = _bvhBoneMap;

package/dist/model/index.js

@@ -6,12 +6,23 @@ export { VRMHumanBoneName } from '@pixiv/three-vrm';
 export * from './vrm.js';
 async function uncachedLoadCharacterModel(type, url, boneRotationOffset, castShadow = true, receiveShadow = true) {
     let result;
-    if (type == null || url == null) {
+    if (url == null) {
         //prepare loading the default model
         type = 'gltf';
         url = (await import('../assets/mannequin.js')).url;
         boneRotationOffset = new Quaternion().setFromEuler(new Euler(Math.PI, 0, Math.PI / 2, 'ZYX'));
     }
+    if (type == null) {
+        if (url.endsWith('.gltf') || url.endsWith('.glb')) {
+            type = 'gltf';
+        }
+        if (url.endsWith('.vrm')) {
+            type = 'vrm';
+        }
+        if (type == null) {
+            throw new Error(`Unable to infer model type from url "${url}. Please specify the type of the model manually."`);
+        }
+    }
     switch (type) {
         case 'vrm':
             result = await loadVrmCharacterModel(url);
@@ -30,6 +41,14 @@ async function uncachedLoadCharacterModel(type, url, boneRotationOffset, castSha
             obj.receiveShadow = true;
         }
     });
+    const rootBone = result.scene.getObjectByName('root');
+    if (rootBone == null) {
+        throw new Error(`unable to load model - missing root bone`);
+    }
+    const restPose = rootBone.clone();
+    restPose.visible = false;
+    restPose.traverse((bone) => (bone.name = `rest_${bone.name}`));
+    result.scene.add(restPose);
     return result;
 }
 function getCharacterModelDependencies(options = true) {

package/dist/simple-character.d.ts

@@ -98,6 +98,7 @@ export declare class SimpleCharacter extends Group<Object3DEventMap & {
     actions?: Record<(typeof simpleCharacterAnimationNames)[number], AnimationAction> | undefined;
     model?: Awaited<Exclude<ReturnType<typeof loadCharacterModel>, undefined>>;
     private updateTimeline?;
+    private readonly abortController;
     constructor(camera: Object3D | (() => Object3D), world: BvhPhysicsWorld, domElement: HTMLElement, options?: SimpleCharacterOptions);
     getCamera(): Object3D<Object3DEventMap>;
     private init;

package/dist/simple-character.js

@@ -182,8 +182,8 @@ async function* SimpleCharacterTimeline(character) {
                         init: () => {
                             actions.jumpForward.paused = false;
                             applyJumpForce();
+                            return () => actions.jumpForward.fadeOut(character.options.animation?.crossFadeDuration ?? DefaultCrossFadeDuration);
                         },
-                        cleanup: () => void actions.jumpForward.fadeOut(character.options.animation?.crossFadeDuration ?? DefaultCrossFadeDuration),
                         until: animationFinished(actions.jumpForward),
                     });
                     if (character.physics.isGrounded) {
@@ -197,13 +197,13 @@ async function* SimpleCharacterTimeline(character) {
                     init: () => {
                         actions.jumpUp.paused = false;
                         applyJumpForce();
+                        return () => void actions.jumpUp.fadeOut(character.options.animation?.crossFadeDuration ?? DefaultCrossFadeDuration);
                     },
-                    cleanup: () => void actions.jumpUp.fadeOut(character.options.animation?.crossFadeDuration ?? DefaultCrossFadeDuration),
                     until: animationFinished(actions.jumpUp),
                 }),
                 transitionTo: {
                     jumpDown: {
-                        when: (_, clock) => clock.actionTime > 0.3 && character.physics.isGrounded,
+                        when: (_, _clock, actionTime) => actionTime > 0.3 && character.physics.isGrounded,
                     },
                     finally: 'jumpLoop',
                 },
@@ -214,8 +214,8 @@ async function* SimpleCharacterTimeline(character) {
                         actions.jumpLoop.reset();
                         actions.jumpLoop.play();
                         actions.jumpLoop.fadeIn(character.options.animation?.crossFadeDuration ?? DefaultCrossFadeDuration);
+                        return () => actions.jumpLoop.fadeOut(character.options.animation?.crossFadeDuration ?? DefaultCrossFadeDuration);
                     },
-                    cleanup: () => actions.jumpLoop.fadeOut(character.options.animation?.crossFadeDuration ?? DefaultCrossFadeDuration),
                     until: forever(),
                 }),
                 transitionTo: {
@@ -230,8 +230,8 @@ async function* SimpleCharacterTimeline(character) {
                         actions.jumpDown.reset();
                         actions.jumpDown.play();
                         actions.jumpDown.fadeIn(character.options.animation?.crossFadeDuration ?? DefaultCrossFadeDuration);
+                        return () => actions.jumpDown.fadeOut(character.options.animation?.crossFadeDuration ?? DefaultCrossFadeDuration);
                     },
-                    cleanup: () => actions.jumpDown.fadeOut(character.options.animation?.crossFadeDuration ?? DefaultCrossFadeDuration),
                     until: timePassed(150, 'milliseconds'),
                 }),
                 transitionTo: { finally: 'moving' },
@@ -263,7 +263,7 @@ async function* SimpleCharacterTimeline(character) {
                             nextAnimation.fadeIn(character.options.animation?.crossFadeDuration ?? DefaultCrossFadeDuration);
                             currentAnimation = nextAnimation;
                         },
-                        cleanup: () => currentAnimation?.fadeOut(character.options.animation?.crossFadeDuration ?? DefaultCrossFadeDuration),
+                        init: () => () => currentAnimation?.fadeOut(character.options.animation?.crossFadeDuration ?? DefaultCrossFadeDuration),
                     });
                 },
                 transitionTo: {
@@ -285,6 +285,7 @@ export class SimpleCharacter extends Group {
     actions;
     model;
     updateTimeline;
+    abortController = new AbortController();
     constructor(camera, world, domElement, options = {}) {
         super();
         this.camera = camera;
@@ -320,7 +321,7 @@ export class SimpleCharacter extends Group {
             this.actions.jumpForward.loop = LoopOnce;
             this.actions.jumpForward.clampWhenFinished = true;
         }
-        this.updateTimeline = start(SimpleCharacterTimeline(this));
+        this.updateTimeline = start(SimpleCharacterTimeline(this), this.abortController.signal);
         this.dispatchEvent({ type: 'loaded' });
     }
     update(delta) {
@@ -333,6 +334,7 @@ export class SimpleCharacter extends Group {
         this.cameraBehavior.update(delta, this.options.cameraBehavior);
     }
     dispose() {
+        this.abortController.abort();
         this.parent?.remove(this);
         this.model?.scene.dispatchEvent({ type: 'dispose' });
         this.inputSystem.dispose();

package/package.json

@@ -21,12 +21,12 @@
   "peerDependencies": {
     "three": "*"
   },
-  "version": "0.1.18",
+  "version": "0.1.20",
   "type": "module",
   "dependencies": {
     "@pixiv/three-vrm": "^3.4.2",
     "@pixiv/three-vrm-animation": "^3.4.2",
-    "@pmndrs/timeline": "^0.1.15",
+    "@pmndrs/timeline": "^0.2.6",
     "@viverse/sdk": "1.2.10-alpha.0",
     "three-mesh-bvh": "^0.9.1"
   },

package/dist/animation/mixamo.d.ts

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