@pmndrs/viverse 0.1.19 → 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/index.d.ts

@@ -1,13 +1,13 @@
 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 './fbx.js';
 export * from './vrma.js';
 export * from './utils.js';
 export type ModelAnimationOptions = {
-    type: 'mixamo' | 'gltf' | 'vrma' | 'fbx';
+    type?: 'mixamo' | 'gltf' | 'vrma' | 'fbx' | 'bvh';
     url: string;
     removeXZMovement?: boolean;
     trimTime?: {
@@ -30,3 +30,4 @@ 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,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 { 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 vrmNodeName = model instanceof VRM ? targetBone.name : vrmBoneName;
-        const baseBone = clipScene.getObjectByName(boneName);
-        if (vrmNodeName == null || baseBone == null) {
+        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) {
             // 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,8 +163,12 @@ 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';
@@ -129,6 +176,24 @@ export * from './vrma.js';
 export * from './utils.js';
 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 loadVrmModelGltfAnimations(model, url, removeXZMovement, boneMap);
@@ -136,6 +201,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;
@@ -193,3 +261,4 @@ export async function getSimpleCharacterModelAnimationOptions(animationName) {
     };
 }
 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.19",
+  "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"
   },