@pmndrs/viverse 0.1.18 → 0.1.19

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

@@ -3,17 +3,18 @@ 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 * 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';
     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,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>;

package/dist/animation/index.js

@@ -1,21 +1,31 @@
 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 { loadVrmModelFbxAnimations } from './fbx.js';
+import { loadVrmModelGltfAnimations } from './gltf.js';
 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();
+import _mixamoBoneMap from './mixamo-bone-map.json';
+//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) {
         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();
@@ -23,82 +33,111 @@ export function fixModelAnimationClip(model, clip, clipScene, removeXZMovement,
         throw new Error('Failed to load VRM animation: missing animation hips object or VRM hips position.');
     }
     // Adjust with reference to hips height.
-    const motionHipsHeight = clipSceneHips.position.y;
+    const motionHipsHeight = clipSceneHips.getWorldPosition(position).y;
     const [_, vrmHipsHeight] = vrmHipsPosition;
-    const hipsPositionScale = vrmHipsHeight / motionHipsHeight;
+    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 vrmNodeName = model instanceof VRM ? model.humanoid.getNormalizedBoneNode(vrmBoneName)?.name : vrmBoneName;
-        const bone = clipScene.getObjectByName(boneName);
-        if (vrmNodeName == null || bone == null) {
+        const targetBone = model instanceof VRM
+            ? model.humanoid.getNormalizedBoneNode(vrmBoneName)
+            : model.scene.getObjectByName(vrmBoneName);
+        if (targetBone == null) {
+            continue;
+        }
+        const vrmNodeName = model instanceof VRM ? targetBone.name : vrmBoneName;
+        const baseBone = clipScene.getObjectByName(boneName);
+        if (vrmNodeName == 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.
+            baseThisLocalRestRotation_inverse.copy(baseBone.quaternion).invert();
+            if (baseBone.parent != null) {
+                baseBone.parent.getWorldQuaternion(baseParentWorldRestRotation);
+                baseParentWorldRestRotation_inverse.copy(baseParentWorldRestRotation).invert();
             }
             else {
-                restRotationInverse.identity();
-                parentRestWorldRotation.identity();
+                baseParentWorldRestRotation.identity();
+                baseParentWorldRestRotation_inverse.identity();
+            }
+            targetThisLocalRestRotation.copy(targetBone.quaternion);
+            if (targetBone.parent != null) {
+                targetBone.parent.getWorldQuaternion(targetParentWorldRestRotation);
+                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}`;
         }
         else if (track instanceof VectorKeyframeTrack) {
             track.name = `${vrmNodeName}.${propertyName}`;
-            if (propertyName === 'scale') {
+            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) {
                     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);
             }
         }
     }
 }
 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;
     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 'mixamo':
-            clips = await loadModelMixamoAnimations(model, url, removeXZMovement);
+            clips = await loadVrmModelFbxAnimations(model, url, removeXZMovement, boneMap ?? mixamoBoneMap);
             break;
         case 'vrma':
             if (!(model instanceof VRM)) {
@@ -127,6 +166,7 @@ export function loadCharacterModelAnimation(model, options) {
         options.removeXZMovement ?? false,
         options.trimTime?.start,
         options.trimTime?.end,
+        options.boneMap,
         options.scaleTime,
     ]);
 }
@@ -152,3 +192,4 @@ export async function getSimpleCharacterModelAnimationOptions(animationName) {
         url: (await simpleCharacterAnimationUrls[animationName]()).url,
     };
 }
+export const mixamoBoneMap = _mixamoBoneMap;

package/package.json

@@ -21,7 +21,7 @@
   "peerDependencies": {
     "three": "*"
   },
-  "version": "0.1.18",
+  "version": "0.1.19",
   "type": "module",
   "dependencies": {
     "@pixiv/three-vrm": "^3.4.2",

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>>;