@zephyr3d/editor 0.3.7 → 0.3.8

package/dist/modules/zephyr3d_loaders.js

@@ -359,6 +359,12 @@ const VRM_GRAVITY_ACCELERATION_SCALE = 3;
 const VRM_GRAVITY_POWER_TO_ACCELERATION = 9.8 * VRM_GRAVITY_ACCELERATION_SCALE;
 const VRM_STIFFNESS_TO_FRAME_HARDNESS = 0.05;
 const VRM_DRAGFORCE_SCALE = 0.5;
+const VRMA_LOOK_AT_EXPRESSION_NAMES = new Set([
+    'lookUp',
+    'lookDown',
+    'lookLeft',
+    'lookRight'
+]);
 /**
  * The GLTF/GLB model loader
  * @public
@@ -1137,8 +1143,47 @@ const VRM_DRAGFORCE_SCALE = 0.5;
                 model.addSkeleton(skeleton);
             }
         }
+        this._loadVRMHumanoidSkeletonMappings(gltf, model);
         this._loadVRMAHumanoidSkeleton(gltf, model);
     }
+    _loadVRMHumanoidSkeletonMappings(gltf, model) {
+        const mapping = this._getVRMC1HumanoidMapping(gltf) ?? this._getVRMC0HumanoidMapping(gltf);
+        if (!mapping) {
+            return;
+        }
+        for (const skeleton of model.skeletons){
+            const skeletonMapping = this._filterHumanoidMappingToSkeleton(mapping, skeleton);
+            if (skeletonMapping) {
+                this._setAssetSkeletonHumanoidMapping(skeleton, skeletonMapping);
+            }
+        }
+    }
+    _getVRMC1HumanoidMapping(gltf) {
+        const humanBones = gltf.extensions?.VRMC_vrm?.humanoid?.humanBones;
+        if (!humanBones || typeof humanBones !== 'object') {
+            return null;
+        }
+        return this._getVRMAHumanoidMapping(gltf, humanBones);
+    }
+    _getVRMC0HumanoidMapping(gltf) {
+        const humanBones = gltf.extensions?.VRM?.humanoid?.humanBones;
+        if (!Array.isArray(humanBones)) {
+            return null;
+        }
+        const byName = {};
+        for (const value of humanBones){
+            if (!value || typeof value !== 'object') {
+                continue;
+            }
+            const boneInfo = value;
+            if (typeof boneInfo.bone === 'string') {
+                byName[boneInfo.bone] = {
+                    node: boneInfo.node
+                };
+            }
+        }
+        return this._getVRMC0HumanoidMappingFromBones(gltf, byName);
+    }
     /** @internal */ _loadVRMAHumanoidSkeleton(gltf, model) {
         const ext = gltf.extensions?.VRMC_vrm_animation;
         const humanBones = ext?.humanoid?.humanBones;
@@ -1266,6 +1311,115 @@ const VRM_DRAGFORCE_SCALE = 0.5;
         }
         return result;
     }
+    _getVRMC0HumanoidMappingFromBones(gltf, humanBones) {
+        const body = {};
+        const leftHand = {};
+        const rightHand = {};
+        const setBody = (vrmName, rig)=>{
+            const node = this._getVRMAHumanBoneNode(gltf, humanBones, vrmName);
+            if (node) {
+                body[rig] = node;
+            }
+        };
+        const setHand = (side, vrmName, rig)=>{
+            const node = this._getVRMAHumanBoneNode(gltf, humanBones, vrmName);
+            if (node) {
+                (side === 'left' ? leftHand : rightHand)[rig] = node;
+            }
+        };
+        setBody('hips', HumanoidBodyRig.Hips);
+        setBody('spine', HumanoidBodyRig.Spine);
+        setBody('chest', HumanoidBodyRig.Chest);
+        setBody('upperChest', HumanoidBodyRig.UpperChest);
+        setBody('neck', HumanoidBodyRig.Neck);
+        setBody('head', HumanoidBodyRig.Head);
+        setBody('leftShoulder', HumanoidBodyRig.LeftShoulder);
+        setBody('leftUpperArm', HumanoidBodyRig.LeftUpperArm);
+        setBody('leftLowerArm', HumanoidBodyRig.LeftLowerArm);
+        setBody('leftHand', HumanoidBodyRig.LeftHand);
+        setBody('rightShoulder', HumanoidBodyRig.RightShoulder);
+        setBody('rightUpperArm', HumanoidBodyRig.RightUpperArm);
+        setBody('rightLowerArm', HumanoidBodyRig.RightLowerArm);
+        setBody('rightHand', HumanoidBodyRig.RightHand);
+        setBody('leftUpperLeg', HumanoidBodyRig.LeftUpperLeg);
+        setBody('leftLowerLeg', HumanoidBodyRig.LeftLowerLeg);
+        setBody('leftFoot', HumanoidBodyRig.LeftFoot);
+        setBody('leftToes', HumanoidBodyRig.LeftToes);
+        setBody('rightUpperLeg', HumanoidBodyRig.RightUpperLeg);
+        setBody('rightLowerLeg', HumanoidBodyRig.RightLowerLeg);
+        setBody('rightFoot', HumanoidBodyRig.RightFoot);
+        setBody('rightToes', HumanoidBodyRig.RightToes);
+        setHand('left', 'leftThumbProximal', HumanoidHandRig.ThumbProximal);
+        setHand('left', 'leftThumbIntermediate', HumanoidHandRig.ThumbIntermediate);
+        setHand('left', 'leftThumbDistal', HumanoidHandRig.ThumbDistal);
+        setHand('left', 'leftIndexProximal', HumanoidHandRig.IndexProximal);
+        setHand('left', 'leftIndexIntermediate', HumanoidHandRig.IndexIntermediate);
+        setHand('left', 'leftIndexDistal', HumanoidHandRig.IndexDistal);
+        setHand('left', 'leftMiddleProximal', HumanoidHandRig.MiddleProximal);
+        setHand('left', 'leftMiddleIntermediate', HumanoidHandRig.MiddleIntermediate);
+        setHand('left', 'leftMiddleDistal', HumanoidHandRig.MiddleDistal);
+        setHand('left', 'leftRingProximal', HumanoidHandRig.RingProximal);
+        setHand('left', 'leftRingIntermediate', HumanoidHandRig.RingIntermediate);
+        setHand('left', 'leftRingDistal', HumanoidHandRig.RingDistal);
+        setHand('left', 'leftLittleProximal', HumanoidHandRig.PinkyProximal);
+        setHand('left', 'leftLittleIntermediate', HumanoidHandRig.PinkyIntermediate);
+        setHand('left', 'leftLittleDistal', HumanoidHandRig.PinkyDistal);
+        setHand('right', 'rightThumbProximal', HumanoidHandRig.ThumbProximal);
+        setHand('right', 'rightThumbIntermediate', HumanoidHandRig.ThumbIntermediate);
+        setHand('right', 'rightThumbDistal', HumanoidHandRig.ThumbDistal);
+        setHand('right', 'rightIndexProximal', HumanoidHandRig.IndexProximal);
+        setHand('right', 'rightIndexIntermediate', HumanoidHandRig.IndexIntermediate);
+        setHand('right', 'rightIndexDistal', HumanoidHandRig.IndexDistal);
+        setHand('right', 'rightMiddleProximal', HumanoidHandRig.MiddleProximal);
+        setHand('right', 'rightMiddleIntermediate', HumanoidHandRig.MiddleIntermediate);
+        setHand('right', 'rightMiddleDistal', HumanoidHandRig.MiddleDistal);
+        setHand('right', 'rightRingProximal', HumanoidHandRig.RingProximal);
+        setHand('right', 'rightRingIntermediate', HumanoidHandRig.RingIntermediate);
+        setHand('right', 'rightRingDistal', HumanoidHandRig.RingDistal);
+        setHand('right', 'rightLittleProximal', HumanoidHandRig.PinkyProximal);
+        setHand('right', 'rightLittleIntermediate', HumanoidHandRig.PinkyIntermediate);
+        setHand('right', 'rightLittleDistal', HumanoidHandRig.PinkyDistal);
+        if (!body[HumanoidBodyRig.Hips]) {
+            return null;
+        }
+        const result = {
+            body: body
+        };
+        if (Object.keys(leftHand).length > 0) {
+            result.leftHand = leftHand;
+        }
+        if (Object.keys(rightHand).length > 0) {
+            result.rightHand = rightHand;
+        }
+        return result;
+    }
+    _filterHumanoidMappingToSkeleton(mapping, skeleton) {
+        const joints = new Set(skeleton.joints);
+        const filter = (source)=>{
+            if (!source) {
+                return undefined;
+            }
+            const result = {};
+            for (const key of Object.keys(source)){
+                const node = source[key];
+                if (node && joints.has(node)) {
+                    result[key] = node;
+                }
+            }
+            return Object.keys(result).length > 0 ? result : undefined;
+        };
+        const body = filter(mapping.body);
+        const leftHand = filter(mapping.leftHand);
+        const rightHand = filter(mapping.rightHand);
+        if (!body && !leftHand && !rightHand) {
+            return null;
+        }
+        return {
+            body: body ?? {},
+            leftHand,
+            rightHand
+        };
+    }
     _getVRMAHumanBoneNode(gltf, humanBones, boneName) {
         const nodeIndex = humanBones[boneName]?.node;
         return this._getNode(gltf, nodeIndex);
@@ -1287,6 +1441,52 @@ const VRM_DRAGFORCE_SCALE = 0.5;
         addMappedNodes(mapping.rightHand);
         return nodes;
     }
+    _getVRMAExpressionMapping(gltf) {
+        const mapping = new Map();
+        const ext = gltf.extensions?.VRMC_vrm_animation;
+        const expressions = ext?.expressions;
+        if (!expressions || typeof expressions !== 'object') {
+            return mapping;
+        }
+        this._addVRMAExpressionMapping(gltf, mapping, expressions.preset);
+        this._addVRMAExpressionMapping(gltf, mapping, expressions.custom);
+        return mapping;
+    }
+    _addVRMAExpressionMapping(gltf, mapping, expressionMap) {
+        if (!expressionMap || typeof expressionMap !== 'object') {
+            return;
+        }
+        for (const [name, value] of Object.entries(expressionMap)){
+            if (VRMA_LOOK_AT_EXPRESSION_NAMES.has(name) || !value || typeof value !== 'object') {
+                continue;
+            }
+            const nodeIndex = value.node;
+            if (typeof nodeIndex !== 'number' || !gltf._nodes[nodeIndex] || mapping.has(nodeIndex)) {
+                continue;
+            }
+            mapping.set(nodeIndex, name);
+        }
+    }
+    _createVRMAExpressionInterpolator(interpolator) {
+        const inputs = new Float32Array(interpolator.inputs);
+        const sourceOutputs = interpolator.outputs;
+        if (interpolator.mode === 'cubicspline') {
+            const outputs = new Float32Array(inputs.length * 3);
+            for(let i = 0; i < inputs.length; i++){
+                const sourceOffset = i * 9;
+                const targetOffset = i * 3;
+                outputs[targetOffset + 0] = sourceOutputs[sourceOffset + 0];
+                outputs[targetOffset + 1] = sourceOutputs[sourceOffset + 3];
+                outputs[targetOffset + 2] = sourceOutputs[sourceOffset + 6];
+            }
+            return new InterpolatorScalar(interpolator.mode, inputs, outputs);
+        }
+        const outputs = new Float32Array(inputs.length);
+        for(let i = 0; i < inputs.length; i++){
+            outputs[i] = sourceOutputs[i * 3];
+        }
+        return new InterpolatorScalar(interpolator.mode, inputs, outputs);
+    }
     _findCommonRoot(nodes) {
         let root = nodes[0] ?? null;
         for(let i = 1; root && i < nodes.length; i++){
@@ -1396,6 +1596,7 @@ const VRM_DRAGFORCE_SCALE = 0.5;
     }
     /** @internal */ _loadAnimation(gltf, index) {
         const animationInfo = this.getAnimationInfo(gltf, index);
+        const vrmaExpressionMapping = this._getVRMAExpressionMapping(gltf);
         const animationData = {
             name: animationInfo.name,
             tracks: [],
@@ -1413,7 +1614,13 @@ const VRM_DRAGFORCE_SCALE = 0.5;
             if (!targetNode) {
                 continue;
             }
-            const track = {
+            const expressionName = interpolatorType === 'translation' ? vrmaExpressionMapping.get(targetNodeIndex) : undefined;
+            const track = expressionName ? {
+                node: targetNode,
+                type: 'morph-target-group',
+                interpolator: this._createVRMAExpressionInterpolator(interpolator),
+                morphTargetGroupName: expressionName
+            } : {
                 node: targetNode,
                 type: interpolatorType,
                 interpolator