@sage-rsc/talking-head-react 1.1.6 → 1.1.8

package/src/lib/talkinghead.mjs

@@ -5323,532 +5323,6 @@ class TalkingHead {
   * @param {number} [ndx=0] Index of the clip
   * @param {number} [scale=0.01] Position scale factor
   */
-  /**
-   * Get all bone names from the avatar's armature
-   * @returns {Set<string>} Set of bone names
-   */
-  getAvailableBoneNames() {
-    const boneNames = new Set();
-    if (!this.armature) return boneNames;
-    
-    this.armature.traverse((child) => {
-      if (child.isBone || child.type === 'Bone') {
-        boneNames.add(child.name);
-      }
-    });
-    
-    return boneNames;
-  }
-
-  /**
-   * Map bone names from different naming conventions to avatar bone names
-   * @param {string} fbxBoneName - Bone name from FBX animation
-   * @param {Set<string>} availableBones - Set of available bone names in avatar
-   * @returns {string|null} Mapped bone name or null if no match found
-   */
-  mapBoneName(fbxBoneName, availableBones) {
-    // Direct match first
-    if (availableBones.has(fbxBoneName)) {
-      return fbxBoneName;
-    }
-
-    // Remove common prefixes
-    let normalized = fbxBoneName;
-    const originalNormalized = normalized;
-    
-    // Remove CC_Base prefix (Character Creator)
-    if (normalized.startsWith('CC_Base_')) {
-      normalized = normalized.replace('CC_Base_', '');
-    }
-    
-    // Remove mixamorig prefix (Mixamo)
-    normalized = normalized.replace(/^mixamorig/i, '');
-    
-    // Try direct match after prefix removal
-    if (availableBones.has(normalized)) {
-      return normalized;
-    }
-    
-    // Debug: Log first few failed mappings to help identify patterns
-    if (!this._mappingDebugLog) {
-      this._mappingDebugLog = new Set();
-    }
-    if (this._mappingDebugLog.size < 5 && !this._mappingDebugLog.has(fbxBoneName)) {
-      this._mappingDebugLog.add(fbxBoneName);
-      console.debug(`Mapping attempt: "${fbxBoneName}" -> "${normalized}" (not found in available bones)`);
-    }
-
-    // Handle numbered bones (e.g., Spine01 -> Spine1)
-    if (normalized.match(/^Spine\d+$/)) {
-      const num = normalized.match(/\d+/)?.[0];
-      if (num) {
-        const mapped = `Spine${parseInt(num)}`;
-        if (availableBones.has(mapped)) {
-          return mapped;
-        }
-        // Try Spine1 if Spine01, Spine2 if Spine02+
-        if (num === '01' && availableBones.has('Spine1')) {
-          return 'Spine1';
-        }
-        if (parseInt(num) >= 2 && availableBones.has('Spine2')) {
-          return 'Spine2';
-        }
-      }
-    }
-
-    // Handle twist bones (ignore them, they're usually not in standard skeletons)
-    if (normalized.includes('Twist')) {
-      return null;
-    }
-
-    // Mapping rules for common bone name patterns
-    const mappings = {
-      // Spine mapping
-      'Spine01': 'Spine1',
-      'Spine02': 'Spine2',
-      'Spine03': 'Spine2',
-      'Spine1': 'Spine1',
-      'Spine2': 'Spine2',
-      'Spine': 'Spine1',
-      
-      // Head and neck
-      'Head': 'Head',
-      'Neck': 'Neck',
-      'Neck1': 'Neck',
-      'Neck2': 'Neck',
-      
-      // Left arm mapping
-      'L_Upperarm': 'LeftArm',
-      'L_Forearm': 'LeftForeArm',
-      'L_Hand': 'LeftHand',
-      'L_Shoulder': 'LeftShoulder',
-      'L_Clavicle': 'LeftShoulder',
-      'L_UpperArm': 'LeftArm',
-      'L_ForeArm': 'LeftForeArm',
-      'L_Index1': 'LeftHandIndex1',
-      'L_Index2': 'LeftHandIndex2',
-      'L_Index3': 'LeftHandIndex3',
-      'L_Middle1': 'LeftHandMiddle1',
-      'L_Middle2': 'LeftHandMiddle2',
-      'L_Middle3': 'LeftHandMiddle3',
-      'L_Mid1': 'LeftHandMiddle1',
-      'L_Mid2': 'LeftHandMiddle2',
-      'L_Mid3': 'LeftHandMiddle3',
-      'L_Ring1': 'LeftHandRing1',
-      'L_Ring2': 'LeftHandRing2',
-      'L_Ring3': 'LeftHandRing3',
-      'L_Pinky1': 'LeftHandPinky1',
-      'L_Pinky2': 'LeftHandPinky2',
-      'L_Pinky3': 'LeftHandPinky3',
-      'L_Thumb1': 'LeftHandThumb1',
-      'L_Thumb2': 'LeftHandThumb2',
-      'L_Thumb3': 'LeftHandThumb3',
-      
-      // Right arm mapping
-      'R_Upperarm': 'RightArm',
-      'R_Forearm': 'RightForeArm',
-      'R_Hand': 'RightHand',
-      'R_Shoulder': 'RightShoulder',
-      'R_Clavicle': 'RightShoulder',
-      'R_UpperArm': 'RightArm',
-      'R_ForeArm': 'RightForeArm',
-      'R_Index1': 'RightHandIndex1',
-      'R_Index2': 'RightHandIndex2',
-      'R_Index3': 'RightHandIndex3',
-      'R_Middle1': 'RightHandMiddle1',
-      'R_Middle2': 'RightHandMiddle2',
-      'R_Middle3': 'RightHandMiddle3',
-      'R_Mid1': 'RightHandMiddle1',
-      'R_Mid2': 'RightHandMiddle2',
-      'R_Mid3': 'RightHandMiddle3',
-      'R_Ring1': 'RightHandRing1',
-      'R_Ring2': 'RightHandRing2',
-      'R_Ring3': 'RightHandRing3',
-      'R_Pinky1': 'RightHandPinky1',
-      'R_Pinky2': 'RightHandPinky2',
-      'R_Pinky3': 'RightHandPinky3',
-      'R_Thumb1': 'RightHandThumb1',
-      'R_Thumb2': 'RightHandThumb2',
-      'R_Thumb3': 'RightHandThumb3',
-      
-      // Leg mapping
-      'L_Thigh': 'LeftUpLeg',
-      'L_Calf': 'LeftLeg',
-      'L_Foot': 'LeftFoot',
-      'L_UpLeg': 'LeftUpLeg',
-      'L_Leg': 'LeftLeg',
-      'R_Thigh': 'RightUpLeg',
-      'R_Calf': 'RightLeg',
-      'R_Foot': 'RightFoot',
-      'R_UpLeg': 'RightUpLeg',
-      'R_Leg': 'RightLeg',
-      
-      // Root/Hips
-      'Hips': 'Hips',
-      'Root': 'Hips',
-      'Pelvis': 'Hips',
-    };
-
-    // Try mapping
-    if (mappings[normalized]) {
-      const mapped = mappings[normalized];
-      if (availableBones.has(mapped)) {
-        return mapped;
-      }
-    }
-
-    // Pattern-based matching for CC_Base and similar naming conventions
-    const lowerNormalized = normalized.toLowerCase();
-    const upperFirst = normalized.charAt(0).toUpperCase() + normalized.slice(1).toLowerCase();
-    
-    // Pattern: R_Index1/2/3 or r_index1/2/3 -> RightHandIndex1/2/3
-    const indexMatch = lowerNormalized.match(/^[rl]_index(\d+)$/);
-    if (indexMatch) {
-      const digit = indexMatch[1];
-      const side = lowerNormalized.startsWith('r') ? 'Right' : 'Left';
-      const candidate = `${side}HandIndex${digit}`;
-      if (availableBones.has(candidate)) {
-        return candidate;
-      }
-    }
-    
-    // Pattern: R_Pinky1/2/3 -> RightHandPinky1/2/3
-    const pinkyMatch = lowerNormalized.match(/^[rl]_pinky(\d+)$/);
-    if (pinkyMatch) {
-      const digit = pinkyMatch[1];
-      const side = lowerNormalized.startsWith('r') ? 'Right' : 'Left';
-      const candidate = `${side}HandPinky${digit}`;
-      if (availableBones.has(candidate)) {
-        return candidate;
-      }
-    }
-    
-    // Pattern: R_Ring1/2/3 -> RightHandRing1/2/3
-    const ringMatch = lowerNormalized.match(/^[rl]_ring(\d+)$/);
-    if (ringMatch) {
-      const digit = ringMatch[1];
-      const side = lowerNormalized.startsWith('r') ? 'Right' : 'Left';
-      const candidate = `${side}HandRing${digit}`;
-      if (availableBones.has(candidate)) {
-        return candidate;
-      }
-    }
-    
-    // Pattern: R_Middle1/2/3 or R_Mid1/2/3 -> RightHandMiddle1/2/3
-    const middleMatch = lowerNormalized.match(/^[rl]_(?:middle|mid)(\d+)$/);
-    if (middleMatch) {
-      const digit = middleMatch[1];
-      const side = lowerNormalized.startsWith('r') ? 'Right' : 'Left';
-      const candidate = `${side}HandMiddle${digit}`;
-      if (availableBones.has(candidate)) {
-        return candidate;
-      }
-    }
-    
-    // Pattern: R_Thumb1/2/3 -> RightHandThumb1/2/3
-    const thumbMatch = lowerNormalized.match(/^[rl]_thumb(\d+)$/);
-    if (thumbMatch) {
-      const digit = thumbMatch[1];
-      const side = lowerNormalized.startsWith('r') ? 'Right' : 'Left';
-      const candidate = `${side}HandThumb${digit}`;
-      if (availableBones.has(candidate)) {
-        return candidate;
-      }
-    }
-    
-    // Pattern: R_Upperarm -> RightArm (case insensitive)
-    if (lowerNormalized.match(/^[rl]_upperarm/)) {
-      const side = lowerNormalized.startsWith('r') ? 'Right' : 'Left';
-      const candidate = `${side}Arm`;
-      if (availableBones.has(candidate)) {
-        return candidate;
-      }
-    }
-    
-    // Pattern: R_UpperarmTwist01/02 -> ignore (twist bones and other extra bones)
-    if (lowerNormalized.includes('upperarmtwist') || 
-        lowerNormalized.includes('forearmtwist') ||
-        lowerNormalized.includes('ribstwist') ||
-        lowerNormalized.includes('breast') ||
-        lowerNormalized.includes('twist')) {
-      return null;
-    }
-    
-    // Pattern: R_Forearm -> RightForeArm
-    if (lowerNormalized.match(/^[rl]_forearm/)) {
-      const side = lowerNormalized.startsWith('r') ? 'Right' : 'Left';
-      const candidate = `${side}ForeArm`;
-      if (availableBones.has(candidate)) {
-        return candidate;
-      }
-    }
-    
-    // Pattern: R_Hand -> RightHand
-    if (lowerNormalized.match(/^[rl]_hand$/)) {
-      const side = lowerNormalized.startsWith('r') ? 'Right' : 'Left';
-      const candidate = `${side}Hand`;
-      if (availableBones.has(candidate)) {
-        return candidate;
-      }
-    }
-    
-    // Pattern: R_Clavicle -> RightShoulder
-    if (lowerNormalized.match(/^[rl]_clavicle/)) {
-      const side = lowerNormalized.startsWith('r') ? 'Right' : 'Left';
-      const candidate = `${side}Shoulder`;
-      if (availableBones.has(candidate)) {
-        return candidate;
-      }
-    }
-    
-    // Pattern: R_Shoulder -> RightShoulder
-    if (lowerNormalized.match(/^[rl]_shoulder/)) {
-      const side = lowerNormalized.startsWith('r') ? 'Right' : 'Left';
-      const candidate = `${side}Shoulder`;
-      if (availableBones.has(candidate)) {
-        return candidate;
-      }
-    }
-    
-    // Pattern: Spine01/02/03 -> Spine1/Spine2
-    if (lowerNormalized.match(/^spine0?(\d+)$/)) {
-      const spineNum = lowerNormalized.match(/^spine0?(\d+)$/)[1];
-      if (spineNum === '1') {
-        if (availableBones.has('Spine1')) return 'Spine1';
-      } else if (spineNum === '2' || spineNum === '3') {
-        if (availableBones.has('Spine2')) return 'Spine2';
-      }
-    }
-    
-    // Pattern: Neck1/2 -> Neck
-    if (lowerNormalized.match(/^neck\d*$/)) {
-      if (availableBones.has('Neck')) return 'Neck';
-    }
-    
-    // Pattern: Head -> Head
-    if (lowerNormalized === 'head') {
-      if (availableBones.has('Head')) return 'Head';
-    }
-    
-    // Pattern: Hips/Pelvis/Root -> Hips
-    if (lowerNormalized.match(/^(hips|pelvis|root)$/)) {
-      if (availableBones.has('Hips')) return 'Hips';
-    }
-
-    // Try case-insensitive exact match
-    for (const boneName of availableBones) {
-      if (boneName.toLowerCase() === lowerNormalized) {
-        return boneName;
-      }
-    }
-    
-    // Try partial match (contains)
-    for (const boneName of availableBones) {
-      const boneLower = boneName.toLowerCase();
-      if (boneLower.includes(lowerNormalized) || lowerNormalized.includes(boneLower)) {
-        // Prefer exact matches or very close matches
-        if (boneLower === lowerNormalized || 
-            boneLower.replace(/[^a-z0-9]/g, '') === lowerNormalized.replace(/[^a-z0-9]/g, '')) {
-          return boneName;
-        }
-      }
-    }
-
-    return null; // No mapping found
-  }
-
-  /**
-   * Filter animation tracks to only include bones that exist in the avatar
-   * Maps bone names from different naming conventions to avatar bone names
-   * @param {THREE.AnimationClip} clip - Animation clip to filter
-   * @param {Set<string>} availableBones - Set of available bone names
-   * @returns {THREE.AnimationClip} Filtered animation clip with mapped bone names
-   */
-  filterAnimationTracks(clip, availableBones) {
-    const validTracks = [];
-    const missingBones = new Set();
-    const mappedBones = new Map(); // Track mappings for logging
-    const fbxBoneNames = new Set(); // Track all unique FBX bone names
-    
-    // Debug: Log available bones (first time only)
-    if (!this._loggedAvailableBones) {
-      console.log('Available avatar bones:', Array.from(availableBones).sort().join(', '));
-      this._loggedAvailableBones = true;
-    }
-    
-    // First pass: collect all unique FBX bone names
-    clip.tracks.forEach(track => {
-      const trackNameParts = track.name.split('.');
-      const fbxBoneName = trackNameParts[0];
-      fbxBoneNames.add(fbxBoneName);
-    });
-    
-    console.log(`\n=== FBX Animation "${clip.name}" Bone Analysis ===`);
-    console.log('FBX bone names in animation:', Array.from(fbxBoneNames).sort().join(', '));
-    console.log(`Total FBX bones: ${fbxBoneNames.size}, Avatar bones: ${availableBones.size}\n`);
-    
-    clip.tracks.forEach(track => {
-      // Extract bone name from track name (e.g., "CC_Base_R_Index3.position" -> "CC_Base_R_Index3")
-      const trackNameParts = track.name.split('.');
-      const fbxBoneName = trackNameParts[0];
-      const property = trackNameParts[1]; // position, quaternion, rotation, etc.
-      
-      // Try to map the bone name
-      const mappedBoneName = this.mapBoneName(fbxBoneName, availableBones);
-      
-      if (mappedBoneName) {
-        // Create a new track with the mapped bone name
-        const newTrackName = `${mappedBoneName}.${property}`;
-        
-        // Clone the track and update its name
-        const newTrack = track.clone();
-        newTrack.name = newTrackName;
-        
-        // Fix rotations for arm/hand bones that might be inverted
-        // If hands are folding behind instead of in front, we need to adjust rotations
-        const isArmBone = mappedBoneName.includes('Arm') || mappedBoneName.includes('Hand') || mappedBoneName.includes('Shoulder');
-        const isForearmBone = mappedBoneName.includes('ForeArm');
-        
-        if (isArmBone && (property === 'quaternion' || property === 'rotation')) {
-          // For quaternion tracks, we might need to adjust the rotation
-          // Check if this is a quaternion track
-          if (property === 'quaternion' && newTrack.values && newTrack.values.length >= 4) {
-            // Quaternion format: [x, y, z, w] per keyframe
-            // For arm bones, we might need to invert Y or Z rotation
-            // Adjust quaternion values to fix hand position
-            const numKeyframes = newTrack.times.length;
-            for (let i = 0; i < numKeyframes; i++) {
-              const baseIdx = i * 4;
-              if (baseIdx + 3 < newTrack.values.length) {
-                // Get quaternion values
-                let x = newTrack.values[baseIdx];
-                let y = newTrack.values[baseIdx + 1];
-                let z = newTrack.values[baseIdx + 2];
-                let w = newTrack.values[baseIdx + 3];
-                
-                // For arms, adjust rotation to flip hands from back to front
-                // This is a common fix for FBX animations with different coordinate systems
-                if (isForearmBone || mappedBoneName.includes('Hand')) {
-                  // Rotate 180 degrees around X axis to flip hands from behind to in front
-                  // Create a 180-degree rotation around X axis
-                  const flipAngle = Math.PI;
-                  const flipX = Math.cos(flipAngle / 2); // w component
-                  const flipY = Math.sin(flipAngle / 2); // x component (axis X = 1,0,0)
-                  
-                  // Multiply quaternions: q_result = q_flip * q_original
-                  // For rotation around X axis: q_flip = (sin(θ/2), 0, 0, cos(θ/2))
-                  const qw = flipX * w - flipY * x;
-                  const qx = flipX * x + flipY * w;
-                  const qy = flipX * y - flipY * z;
-                  const qz = flipX * z + flipY * y;
-                  
-                  x = qx;
-                  y = qy;
-                  z = qz;
-                  w = qw;
-                }
-                
-                newTrack.values[baseIdx] = x;
-                newTrack.values[baseIdx + 1] = y;
-                newTrack.values[baseIdx + 2] = z;
-                newTrack.values[baseIdx + 3] = w;
-              }
-            }
-          } else if (property === 'rotation' && newTrack.values && newTrack.values.length >= 3) {
-            // Euler rotation format: [x, y, z] per keyframe
-            const numKeyframes = newTrack.times.length;
-            for (let i = 0; i < numKeyframes; i++) {
-              const baseIdx = i * 3;
-              if (baseIdx + 2 < newTrack.values.length) {
-                // For arm bones, adjust Y rotation to flip hands
-                if (isForearmBone || mappedBoneName.includes('Hand')) {
-                  // Add 180 degrees (PI radians) to Y rotation
-                  newTrack.values[baseIdx + 1] += Math.PI;
-                }
-              }
-            }
-          }
-        }
-        
-        validTracks.push(newTrack);
-        
-        // Track mappings for logging
-        if (fbxBoneName !== mappedBoneName) {
-          mappedBones.set(fbxBoneName, mappedBoneName);
-        }
-      } else {
-        missingBones.add(fbxBoneName);
-      }
-    });
-    
-    // Log results with detailed mapping information
-    console.log(`\n=== Mapping Results for "${clip.name}" ===`);
-    
-    // Show all mapped bones
-    if (mappedBones.size > 0) {
-      console.info(`✓ Successfully mapped ${mappedBones.size} bone(s):`);
-      Array.from(mappedBones.entries()).forEach(([from, to]) => {
-        console.log(`  ${from} → ${to}`);
-      });
-    }
-    
-    // Show all missing bones with suggestions
-    if (missingBones.size > 0) {
-      console.warn(`\n✗ Could not map ${missingBones.size} bone(s):`);
-      Array.from(missingBones).sort().forEach(boneName => {
-        console.log(`  - ${boneName}`);
-        // Try to suggest a potential mapping
-        const normalized = boneName.replace(/^(CC_Base_|mixamorig)/i, '').replace(/^[RL]_/, (match) => match.toLowerCase());
-        const suggestions = [];
-        for (const avatarBone of availableBones) {
-          const avatarLower = avatarBone.toLowerCase();
-          const normalizedLower = normalized.toLowerCase();
-          if (avatarLower.includes(normalizedLower) || normalizedLower.includes(avatarLower)) {
-            suggestions.push(avatarBone);
-          }
-        }
-        if (suggestions.length > 0) {
-          console.log(`    → Possible matches: ${suggestions.slice(0, 3).join(', ')}`);
-        }
-      });
-    }
-    
-    // Show bones that matched directly (no mapping needed)
-    const directMatches = new Set();
-    fbxBoneNames.forEach(fbxBone => {
-      if (availableBones.has(fbxBone) && !mappedBones.has(fbxBone)) {
-        directMatches.add(fbxBone);
-      }
-    });
-    if (directMatches.size > 0) {
-      console.info(`\n✓ Direct matches (no mapping needed): ${directMatches.size} bone(s)`);
-      Array.from(directMatches).sort().slice(0, 10).forEach(bone => {
-        console.log(`  - ${bone}`);
-      });
-      if (directMatches.size > 10) {
-        console.log(`  ... and ${directMatches.size - 10} more`);
-      }
-    }
-    
-    console.log(`\n=== Summary ===`);
-    console.log(`Total FBX tracks: ${clip.tracks.length}`);
-    console.log(`Valid tracks: ${validTracks.length}`);
-    console.log(`Mapped bones: ${mappedBones.size}`);
-    console.log(`Direct matches: ${directMatches.size}`);
-    console.log(`Missing bones: ${missingBones.size}`);
-    console.log(`========================================\n`);
-    
-    if (validTracks.length === 0) {
-      console.error(`No valid tracks found for animation "${clip.name}". All bones are missing or couldn't be mapped.`);
-    }
-    
-    // Create a new clip with only valid tracks
-    if (validTracks.length === 0) {
-      return null;
-    }
-    
-    return new THREE.AnimationClip(clip.name, clip.duration, validTracks);
-  }
 
   async playAnimation(url, onprogress=null, dur=10, ndx=0, scale=0.01, disablePositionLock=false) {
     if ( !this.armature ) return;
@@ -5997,19 +5471,146 @@ class TalkingHead {
       if ( fbx && fbx.animations && fbx.animations[ndx] ) {
         let anim = fbx.animations[ndx];
 
-        // Get available bone names from avatar skeleton
-        const availableBones = this.getAvailableBoneNames();
+        // Get available bone names from avatar skeleton for mapping
+        const availableBones = new Set();
+        if (this.armature) {
+          this.armature.traverse((child) => {
+            if (child.isBone || child.type === 'Bone') {
+              availableBones.add(child.name);
+            }
+          });
+        }
+
+        // Map bone names from FBX to avatar skeleton
+        const boneNameMap = new Map();
+        const mapBoneName = (fbxBoneName) => {
+          // Direct match
+          if (availableBones.has(fbxBoneName)) {
+            return fbxBoneName;
+          }
+          
+          // Remove mixamorig prefix if present
+          let normalized = fbxBoneName.replace(/^mixamorig/i, '');
+          if (availableBones.has(normalized)) {
+            return normalized;
+          }
+          
+          // Common bone name mappings for Ready Player Me / Mixamo
+          const mappings = {
+            // Arm bones - handle common variations
+            'LeftArm': 'LeftArm',
+            'leftArm': 'LeftArm',
+            'LEFTARM': 'LeftArm',
+            'RightArm': 'RightArm',
+            'rightArm': 'RightArm',
+            'RIGHTARM': 'RightArm',
+            'LeftForeArm': 'LeftForeArm',
+            'leftForeArm': 'LeftForeArm',
+            'leftForearm': 'LeftForeArm',
+            'LeftForearm': 'LeftForeArm',
+            'RightForeArm': 'RightForeArm',
+            'rightForeArm': 'RightForeArm',
+            'rightForearm': 'RightForeArm',
+            'RightForearm': 'RightForeArm',
+            'LeftHand': 'LeftHand',
+            'leftHand': 'LeftHand',
+            'RightHand': 'RightHand',
+            'rightHand': 'RightHand',
+            'LeftShoulder': 'LeftShoulder',
+            'leftShoulder': 'LeftShoulder',
+            'RightShoulder': 'RightShoulder',
+            'rightShoulder': 'RightShoulder',
+            // Spine
+            'Spine': 'Spine1',
+            'spine': 'Spine1',
+            'Spine1': 'Spine1',
+            'Spine2': 'Spine2',
+            // Head/Neck
+            'Head': 'Head',
+            'head': 'Head',
+            'Neck': 'Neck',
+            'neck': 'Neck',
+            // Hips
+            'Hips': 'Hips',
+            'hips': 'Hips',
+            'Root': 'Hips',
+            'root': 'Hips',
+          };
+          
+          if (mappings[normalized]) {
+            const mapped = mappings[normalized];
+            if (availableBones.has(mapped)) {
+              return mapped;
+            }
+          }
+          
+          // Try case-insensitive match
+          for (const boneName of availableBones) {
+            if (boneName.toLowerCase() === normalized.toLowerCase()) {
+              return boneName;
+            }
+          }
+          
+          return null; // No mapping found
+        };
+
+        // Debug: Log FBX bone names and avatar bone names for comparison
+        const fbxBoneNames = new Set();
+        anim.tracks.forEach(track => {
+          const trackParts = track.name.split('.');
+          fbxBoneNames.add(trackParts[0]);
+        });
         
-        // Filter animation tracks to only include bones that exist
-        const filteredAnim = this.filterAnimationTracks(anim, availableBones);
+        console.log('Ready Player Me FBX bone names:', Array.from(fbxBoneNames).sort().join(', '));
+        console.log('Avatar skeleton bone names:', Array.from(availableBones).sort().join(', '));
+
+        // Filter and map animation tracks
+        const mappedTracks = [];
+        const unmappedBones = new Set();
+        anim.tracks.forEach(track => {
+          // Remove mixamorig prefix first
+          let trackName = track.name.replaceAll('mixamorig', '');
+          const trackParts = trackName.split('.');
+          const fbxBoneName = trackParts[0];
+          const property = trackParts[1];
+          
+          // Map bone name to avatar skeleton
+          const mappedBoneName = mapBoneName(fbxBoneName);
+          
+          if (mappedBoneName && property) {
+            // Create new track with mapped bone name
+            const newTrackName = `${mappedBoneName}.${property}`;
+            const newTrack = track.clone();
+            newTrack.name = newTrackName;
+            mappedTracks.push(newTrack);
+            
+            // Store mapping for logging
+            if (fbxBoneName !== mappedBoneName) {
+              boneNameMap.set(fbxBoneName, mappedBoneName);
+            }
+          } else {
+            unmappedBones.add(fbxBoneName);
+            // Log unmapped bones (especially arm bones)
+            if (fbxBoneName.toLowerCase().includes('arm') || 
+                fbxBoneName.toLowerCase().includes('hand') || 
+                fbxBoneName.toLowerCase().includes('shoulder')) {
+              console.warn(`⚠️ Arm bone "${fbxBoneName}" could not be mapped to avatar skeleton`);
+            }
+          }
+        });
         
-        if (!filteredAnim) {
-          console.error(`Cannot play FBX animation "${url}": No compatible bones found.`);
-          return;
+        if (unmappedBones.size > 0) {
+          console.warn(`⚠️ ${unmappedBones.size} bone(s) could not be mapped:`, Array.from(unmappedBones).sort().join(', '));
+        }
+
+        // Use mapped tracks if we have any, otherwise use original
+        if (mappedTracks.length > 0) {
+          anim = new THREE.AnimationClip(anim.name, anim.duration, mappedTracks);
+          if (boneNameMap.size > 0) {
+            console.log(`Mapped ${boneNameMap.size} bone(s) for Ready Player Me animation:`, 
+              Array.from(boneNameMap.entries()).slice(0, 5).map(([from, to]) => `${from}→${to}`).join(', '));
+          }
         }
-        
-        // Use the filtered animation instead of the original
-        anim = filteredAnim;
 
         // Rename and scale Mixamo tracks, create a pose
         const props = {};