@sage-rsc/talking-head-react 1.4.2 → 1.4.5

package/src/lib/talkinghead.mjs.new

@@ -31,25 +31,8 @@ import { RoomEnvironment } from 'three/addons/environments/RoomEnvironment.js';
 import Stats from 'three/addons/libs/stats.module.js';
 
 import{ DynamicBones } from './dynamicbones.mjs';
-import { AudioAnalyzer } from './audioAnalyzer.js';
 const workletUrl = new URL('./playback-worklet.js', import.meta.url);
 
-// Import lipsync modules statically to ensure they're bundled
-import * as LipsyncEn from './lipsync-en.mjs';
-import * as LipsyncDe from './lipsync-de.mjs';
-import * as LipsyncFr from './lipsync-fr.mjs';
-import * as LipsyncFi from './lipsync-fi.mjs';
-import * as LipsyncLt from './lipsync-lt.mjs';
-
-// Lipsync module map for dynamic access
-const LIPSYNC_MODULES = {
-  en: LipsyncEn,
-  de: LipsyncDe,
-  fr: LipsyncFr,
-  fi: LipsyncFi,
-  lt: LipsyncLt
-};
-
 // Temporary objects for animation loop
 const q = new THREE.Quaternion();
 const e = new THREE.Euler();
@@ -146,8 +129,8 @@ class TalkingHead {
       ttsVoice: "fi-FI-Standard-A",
       ttsRate: 1,
       ttsPitch: 0,
-      ttsVolume: 0.3,
-      mixerGainSpeech: 1.2,
+      ttsVolume: 0,
+      mixerGainSpeech: null,
       mixerGainBackground: null,
       lipsyncLang: 'fi',
       lipsyncModules: ['fi','en','lt'],
@@ -168,9 +151,9 @@ class TalkingHead {
       cameraPanEnable: false,
       cameraZoomEnable: false,
       lightAmbientColor: 0xffffff,
-      lightAmbientIntensity: 1.25,
+      lightAmbientIntensity: 2,
       lightDirectColor: 0x8888aa,
-      lightDirectIntensity: 12,
+      lightDirectIntensity: 30,
       lightDirectPhi: 1,
       lightDirectTheta: 2,
       lightSpotIntensity: 0,
@@ -180,9 +163,9 @@ class TalkingHead {
       lightSpotDispersion: 1,
       avatarMood: "neutral",
       avatarMute: false,
-      avatarIdleEyeContact: 0.6,
+      avatarIdleEyeContact: 0.2,
       avatarIdleHeadMove: 0.5,
-      avatarSpeakingEyeContact: 0.8,
+      avatarSpeakingEyeContact: 0.5,
       avatarSpeakingHeadMove: 0.5,
       avatarIgnoreCamera: false,
       listeningSilenceThresholdLevel: 40,
@@ -425,20 +408,16 @@ class TalkingHead {
 
     this.animMoods = {
       'neutral' : {
-        baseline: { eyesLookDown: 0 },
+        baseline: { eyesLookDown: 0.1 },
         speech: { deltaRate: 0, deltaPitch: 0, deltaVolume: 0 },
         anims: [
           { name: 'breathing', delay: 1500, dt: [ 1200,500,1000 ], vs: { chestInhale: [0.5,0.5,0] } },
           { name: 'pose', alt: [
-            { p: 0.5, delay: [5000,30000], vs: { pose: ['side'] },
-              'M': { delay: [5000,30000], vs: { pose: ['wide'] } }
-            },
+            { p: 0.5, delay: [5000,30000], vs: { pose: ['side'] } },
             { p: 0.3, delay: [5000,30000], vs: { pose: ['hip'] },
               'M': { delay: [5000,30000], vs: { pose: ['wide'] } }
             },
-            { delay: [5000,30000], vs: { pose: ['straight'] },
-              'M': { delay: [5000,30000], vs: { pose: ['wide'] } }
-            }
+            { delay: [5000,30000], vs: { pose: ['straight'] } }
           ]},
           { name: 'head',
             idle: { delay: [0,1000], dt: [ [200,5000] ], vs: { bodyRotateX: [[-0.04,0.10]], bodyRotateY: [[-0.3,0.3]], bodyRotateZ: [[-0.08,0.08]] } },
@@ -1237,16 +1216,6 @@ class TalkingHead {
 
     this.stop();
     this.avatar = avatar;
-    
-    // Initialize custom properties
-    this.bodyMovement = avatar.bodyMovement || 'idle';
-    this.movementIntensity = avatar.movementIntensity || 0.5;
-    this.lockedPosition = null;
-    this.originalPosition = null;
-    this.positionWasLocked = false;
-
-    // Initialize FBX animation loader
-    this.fbxAnimationLoader = null;
 
     // Dispose Dynamic Bones
     this.dynamicbones.dispose();
@@ -1420,24 +1389,6 @@ class TalkingHead {
     // Set pose, view and start animation
     if ( !this.viewName ) this.setView( this.opt.cameraView );
     this.setMood( this.avatar.avatarMood || this.moodName || this.opt.avatarMood );
-    
-    // Set initial gender-appropriate pose for male avatars to avoid feminine appearance
-    // Do this BEFORE starting the animation system to prevent initial female pose
-    if (this.avatar.body === 'M' && this.poseTemplates['wide']) {
-      // Use setPoseFromTemplate which properly handles pose transitions without loops
-      this.poseName = 'wide';
-      this.setPoseFromTemplate(this.poseTemplates['wide'], 0); // 0ms = instant, no transition
-      console.log('Set initial male-appropriate pose: wide');
-    }
-    
-    // Initialize FBX animation loader
-    this.initializeFBXAnimationLoader();
-    
-    // Apply body movement animation if set
-    if (this.bodyMovement && this.bodyMovement !== 'idle') {
-      this.applyBodyMovementAnimation();
-    }
-    
     this.start();
 
   }
@@ -1610,9 +1561,6 @@ class TalkingHead {
         }
       }
     }
-    
-    // Apply shoulder adjustment to lower shoulders
-    this.applyShoulderAdjustment();
   }
 
   /**
@@ -1631,68 +1579,6 @@ class TalkingHead {
       }
     }
   }
-  
-  /**
-   * Apply shoulder adjustment to lower shoulders to a more natural position
-   * This is called from updatePoseBase for pose-based animations
-   */
-  applyShoulderAdjustment() {
-    // Shoulder adjustment: reduce X-axis rotation by ~0.6 radians (34 degrees) to lower shoulders to a relaxed position
-    const shoulderAdjustment = -0.6; // Negative to lower shoulders (increased for more relaxed look)
-    const tempEuler = new THREE.Euler();
-    
-    // Adjust left shoulder
-    if (this.poseAvatar.props['LeftShoulder.quaternion']) {
-      const leftShoulder = this.poseAvatar.props['LeftShoulder.quaternion'];
-      tempEuler.setFromQuaternion(leftShoulder, 'XYZ');
-      tempEuler.x += shoulderAdjustment; // Reduce X rotation to lower shoulder
-      leftShoulder.setFromEuler(tempEuler, 'XYZ');
-    }
-    
-    // Adjust right shoulder
-    if (this.poseAvatar.props['RightShoulder.quaternion']) {
-      const rightShoulder = this.poseAvatar.props['RightShoulder.quaternion'];
-      tempEuler.setFromQuaternion(rightShoulder, 'XYZ');
-      tempEuler.x += shoulderAdjustment; // Reduce X rotation to lower shoulder
-      rightShoulder.setFromEuler(tempEuler, 'XYZ');
-    }
-  }
-  
-  /**
-   * Apply shoulder adjustment directly to bone objects
-   * This is called AFTER FBX animations update to ensure shoulders stay relaxed
-   * regardless of what the animation sets
-   */
-  applyShoulderAdjustmentToBones() {
-    if (!this.armature) return;
-    
-    // Shoulder adjustment: reduce X-axis rotation by ~0.6 radians (34 degrees) to lower shoulders
-    const shoulderAdjustment = -0.6; // Negative to lower shoulders
-    const tempEuler = new THREE.Euler();
-    const tempQuaternion = new THREE.Quaternion();
-    
-    // Get shoulder bones directly from armature
-    const leftShoulderBone = this.armature.getObjectByName('LeftShoulder');
-    const rightShoulderBone = this.armature.getObjectByName('RightShoulder');
-    
-    // Adjust left shoulder bone directly
-    if (leftShoulderBone && leftShoulderBone.quaternion) {
-      tempEuler.setFromQuaternion(leftShoulderBone.quaternion, 'XYZ');
-      tempEuler.x += shoulderAdjustment; // Reduce X rotation to lower shoulder
-      tempQuaternion.setFromEuler(tempEuler, 'XYZ');
-      leftShoulderBone.quaternion.copy(tempQuaternion);
-      leftShoulderBone.updateMatrixWorld(true);
-    }
-    
-    // Adjust right shoulder bone directly
-    if (rightShoulderBone && rightShoulderBone.quaternion) {
-      tempEuler.setFromQuaternion(rightShoulderBone.quaternion, 'XYZ');
-      tempEuler.x += shoulderAdjustment; // Reduce X rotation to lower shoulder
-      tempQuaternion.setFromEuler(tempEuler, 'XYZ');
-      rightShoulderBone.quaternion.copy(tempQuaternion);
-      rightShoulderBone.updateMatrixWorld(true);
-    }
-  }
 
   /**
   * Update morph target values.
@@ -2466,9 +2352,6 @@ class TalkingHead {
     dt = dt / this.animSlowdownRate;
     this.animClock += dt;
 
-    // Maintain locked position if set
-    this.maintainLockedPosition();
-
     let i,j,l,k,vol=0;
 
     // Statistics start
@@ -2787,15 +2670,6 @@ class TalkingHead {
 
     // Update Dynamic Bones
     this.dynamicbones.update(dt);
-    
-    // Update FBX animations
-    if (this.fbxAnimationLoader) {
-      this.fbxAnimationLoader.update();
-    }
-    
-    // Apply shoulder adjustment AFTER FBX animations to ensure relaxed shoulders
-    // This overrides any shoulder positions set by animations
-    this.applyShoulderAdjustmentToBones();
 
     // Custom update
     if ( this.opt.update ) {
@@ -4415,20 +4289,9 @@ class TalkingHead {
   * @param {number} [ndx=0] Index of the clip
   * @param {number} [scale=0.01] Position scale factor
   */
-  async playAnimation(url, onprogress=null, dur=10, ndx=0, scale=0.01, disablePositionLock=false) {
+  async playAnimation(url, onprogress=null, dur=10, ndx=0, scale=0.01) {
     if ( !this.armature ) return;
 
-    // Track whether position was locked for this animation
-    this.positionWasLocked = !disablePositionLock;
-
-    // Lock position IMMEDIATELY to prevent any position changes (unless disabled)
-    if (!disablePositionLock) {
-      this.lockAvatarPosition();
-      console.log('Position locked immediately before FBX animation:', url);
-    } else {
-      console.log('Position locking disabled for FBX animation:', url);
-    }
-
     let item = this.animClips.find( x => x.url === url+'-'+ndx );
     if ( item ) {
 
@@ -4446,40 +4309,27 @@ class TalkingHead {
         this.poseTarget.props[x[0]].d = 1000;
       });
 
-      // Use existing mixer or create new one if none exists
-      if (!this.mixer) {
-      this.mixer = new THREE.AnimationMixer(this.armature);
-        console.log('Created new mixer for FBX animation');
-      } else {
-        console.log('Using existing mixer for FBX animation, preserving morph targets');
+      // Create a new mixer
+      if (this.mixer) {
+        this.mixer.removeEventListener('finished', this._mixerHandler);
+        this.mixer.stopAllAction();
+        this.mixer.uncacheRoot(this.armature);
+        this.mixer = null;
+        this._mixerHandler = null;
       }
-      this.mixer.addEventListener( 'finished', this.stopAnimation.bind(this), { once: true });
+      this.mixer = new THREE.AnimationMixer(this.armature);
+      this._mixerHandler = () => {
+        this.stopAnimation();
+        this.mixer?.removeEventListener('finished', this._mixerHandler);
+      };
+      this.mixer.addEventListener('finished', this._mixerHandler);
 
-      // Play action with error handling
+      // Play action
       const repeat = Math.ceil(dur / item.clip.duration);
       const action = this.mixer.clipAction(item.clip);
       action.setLoop( THREE.LoopRepeat, repeat );
       action.clampWhenFinished = true;
-      
-      // Store the current FBX action for proper cleanup
-      this.currentFBXAction = action;
-      
-      try {
       action.fadeIn(0.5).play();
-        console.log('FBX animation started successfully:', url);
-      } catch (error) {
-        console.warn('FBX animation failed to start:', error);
-        // Stop the animation and unlock position on error
-        this.stopAnimation();
-        return;
-      }
-      
-      // Check if the animation actually has valid tracks
-      if (action.getClip().tracks.length === 0) {
-        console.warn('FBX animation has no valid tracks, stopping');
-        this.stopAnimation();
-        return;
-      }
 
     } else {
 
@@ -4491,200 +4341,10 @@ class TalkingHead {
       if ( fbx && fbx.animations && fbx.animations[ndx] ) {
         let anim = fbx.animations[ndx];
 
-        // 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 common prefixes (mixamorig, CC_Base_, etc.)
-          let normalized = fbxBoneName
-            .replace(/^mixamorig/i, '')
-            .replace(/^CC_Base_/i, '')
-            .replace(/^RPM_/i, '');
-            
-          if (availableBones.has(normalized)) {
-            return normalized;
-          }
-          
-          // Pattern-based matching for Ready Player Me / Mixamo
-          const lowerNormalized = normalized.toLowerCase();
-          
-          // Arm bones - pattern matching
-          if (lowerNormalized.includes('left') && lowerNormalized.includes('arm')) {
-            if (lowerNormalized.includes('fore') || lowerNormalized.includes('lower')) {
-              if (availableBones.has('LeftForeArm')) return 'LeftForeArm';
-              if (availableBones.has('LeftForearm')) return 'LeftForearm';
-            } else if (!lowerNormalized.includes('fore') && !lowerNormalized.includes('hand')) {
-              if (availableBones.has('LeftArm')) return 'LeftArm';
-            }
-          }
-          
-          if (lowerNormalized.includes('right') && lowerNormalized.includes('arm')) {
-            if (lowerNormalized.includes('fore') || lowerNormalized.includes('lower')) {
-              if (availableBones.has('RightForeArm')) return 'RightForeArm';
-              if (availableBones.has('RightForearm')) return 'RightForearm';
-            } else if (!lowerNormalized.includes('fore') && !lowerNormalized.includes('hand')) {
-              if (availableBones.has('RightArm')) return 'RightArm';
-            }
-          }
-          
-          // Hand bones
-          if (lowerNormalized.includes('left') && lowerNormalized.includes('hand') && 
-              !lowerNormalized.includes('index') && !lowerNormalized.includes('thumb') &&
-              !lowerNormalized.includes('middle') && !lowerNormalized.includes('ring') &&
-              !lowerNormalized.includes('pinky')) {
-            if (availableBones.has('LeftHand')) return 'LeftHand';
-          }
-          
-          if (lowerNormalized.includes('right') && lowerNormalized.includes('hand') && 
-              !lowerNormalized.includes('index') && !lowerNormalized.includes('thumb') &&
-              !lowerNormalized.includes('middle') && !lowerNormalized.includes('ring') &&
-              !lowerNormalized.includes('pinky')) {
-            if (availableBones.has('RightHand')) return 'RightHand';
-          }
-          
-          // Shoulder bones
-          if (lowerNormalized.includes('left') && (lowerNormalized.includes('shoulder') || lowerNormalized.includes('clavicle'))) {
-            if (availableBones.has('LeftShoulder')) return 'LeftShoulder';
-          }
-          
-          if (lowerNormalized.includes('right') && (lowerNormalized.includes('shoulder') || lowerNormalized.includes('clavicle'))) {
-            if (availableBones.has('RightShoulder')) return 'RightShoulder';
-          }
-          
-          // Common bone name mappings
-          const mappings = {
-            // Arm bones - exact matches
-            '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() === lowerNormalized) {
-              return boneName;
-            }
-          }
-          
-          // Try partial match (contains)
-          for (const boneName of availableBones) {
-            const boneLower = boneName.toLowerCase();
-            // Match if normalized contains key parts of bone name
-            if ((lowerNormalized.includes('left') && boneLower.includes('left')) ||
-                (lowerNormalized.includes('right') && boneLower.includes('right'))) {
-              if ((lowerNormalized.includes('arm') && boneLower.includes('arm') && !boneLower.includes('fore')) ||
-                  (lowerNormalized.includes('forearm') && boneLower.includes('forearm')) ||
-                  (lowerNormalized.includes('hand') && boneLower.includes('hand') && !boneLower.includes('index') && !boneLower.includes('thumb')) ||
-                  (lowerNormalized.includes('shoulder') && boneLower.includes('shoulder'))) {
-                return boneName;
-              }
-            }
-          }
-          
-          return null; // No mapping found
-        };
-
-        // 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);
-          }
-        });
-        
-        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);
-          console.log(`✓ Created animation with ${mappedTracks.length} mapped tracks (from ${anim.tracks.length} original tracks)`);
-          if (boneNameMap.size > 0) {
-            console.log(`✓ Mapped ${boneNameMap.size} bone(s):`, 
-              Array.from(boneNameMap.entries()).map(([from, to]) => `${from}→${to}`).join(', '));
-          }
-        }
-
         // Rename and scale Mixamo tracks, create a pose
         const props = {};
         anim.tracks.forEach( t => {
+          t.name = t.name.replaceAll('mixamorig','');
           const ids = t.name.split('.');
           if ( ids[1] === 'position' ) {
             for(let i=0; i<t.values.length; i++ ) {
@@ -4738,14 +4398,6 @@ class TalkingHead {
       this._mixerHandler = null;
     }
 
-    // Unlock position if it was locked
-    if (this.positionWasLocked) {
-      this.unlockAvatarPosition();
-      console.log('Position unlocked after FBX animation stopped');
-    } else {
-      console.log('Position was not locked, no unlock needed');
-    }
-
     // Restart gesture
     if ( this.gesture ) {
       for( let [p,v] of Object.entries(this.gesture) ) {
@@ -5096,376 +4748,6 @@ class TalkingHead {
     }
   }
 
-  /**
-   * Initialize FBX animation loader
-   */
-  async initializeFBXAnimationLoader() {
-    try {
-      // Dynamic import to avoid loading issues
-      const { FBXAnimationLoader } = await import('./fbxAnimationLoader.js');
-      this.fbxAnimationLoader = new FBXAnimationLoader(this.armature);
-      console.log('FBX Animation Loader initialized');
-    } catch (error) {
-      console.warn('FBX Animation Loader not available:', error);
-      this.fbxAnimationLoader = null;
-    }
-  }
-
-  /**
-   * Set body movement type.
-   * @param {string} movement Movement type (idle, walking, prancing, gesturing, dancing, excited).
-   */
-  setBodyMovement(movement) {
-    this.bodyMovement = movement;
-    
-    // Only set avatar property if avatar exists
-    if (this.avatar) {
-      this.avatar.bodyMovement = movement;
-    }
-    
-    console.log('Body movement set to:', movement);
-    
-    // Respect the current showFullAvatar setting instead of forcing it to true
-    // Only unlock position when returning to idle
-    if (movement === 'idle') {
-      // Unlock position when returning to idle
-      this.unlockAvatarPosition();
-    }
-    // Note: We no longer force showFullAvatar to true for body movements
-    // The avatar will use whatever showFullAvatar value was set by the user
-    
-    // Apply body movement animation
-    this.applyBodyMovementAnimation();
-  }
-
-  /**
-   * Apply body movement animation based on current movement type.
-   */
-  async applyBodyMovementAnimation() {
-    // Check if avatar is ready
-    if (!this.armature || !this.animQueue) {
-      console.log('Avatar not ready for body movement animations');
-      return;
-    }
-    
-    console.log('Avatar is running:', this.isRunning);
-    console.log('Animation queue exists:', !!this.animQueue);
-    
-    // Remove existing body movement animations
-    const beforeLength = this.animQueue.length;
-    this.animQueue = this.animQueue.filter(anim => !anim.template.name.startsWith('bodyMovement'));
-    const afterLength = this.animQueue.length;
-    console.log(`Filtered animation queue: ${beforeLength} -> ${afterLength} animations`);
-    
-    if (this.bodyMovement === 'idle') {
-      // Stop FBX animations if any
-      if (this.fbxAnimationLoader) {
-        this.fbxAnimationLoader.stopCurrentAnimation();
-      }
-      return; // No body movement for idle
-    }
-    
-    // Try to use FBX animations first
-    if (this.fbxAnimationLoader) {
-      try {
-        await this.fbxAnimationLoader.playGestureAnimation(this.bodyMovement, this.movementIntensity);
-        console.log('Applied FBX body movement animation:', this.bodyMovement);
-        return; // Successfully applied FBX animation
-      } catch (error) {
-        console.warn('FBX animation failed, falling back to code animation:', error);
-      }
-    }
-    
-    // Fallback to code-based animations
-    const movementAnim = this.createBodyMovementAnimation(this.bodyMovement);
-    console.log('Created movement animation:', movementAnim);
-    if (movementAnim) {
-      try {
-        // Use animFactory to create proper animation object
-        const animObj = this.animFactory(movementAnim, true); // true for looping
-        
-        // Validate the animation object before adding
-        if (animObj && animObj.ts && animObj.ts.length > 0) {
-          this.animQueue.push(animObj);
-          console.log('Applied code-based body movement animation:', this.bodyMovement);
-          console.log('Animation queue length:', this.animQueue.length);
-          console.log('Animation object:', animObj);
-        } else {
-          console.error('Invalid animation object created for:', this.bodyMovement);
-          console.error('Animation object:', animObj);
-        }
-      } catch (error) {
-        console.error('Error creating body movement animation:', error);
-      }
-    }
-  }
-
-  /**
-   * Lock avatar position to prevent movement during animations.
-   */
-  lockAvatarPosition() {
-    if (!this.armature) {
-      console.warn('Cannot lock position: armature not available');
-      return;
-    }
-    
-    // Store the original position if not already stored
-    if (!this.originalPosition) {
-      this.originalPosition = {
-        x: this.armature.position.x,
-        y: this.armature.position.y,
-        z: this.armature.position.z
-      };
-      console.log('Original position stored:', this.originalPosition);
-    }
-    
-    // Lock the avatar at its CURRENT position (don't move it)
-    this.lockedPosition = {
-      x: this.armature.position.x,
-      y: this.armature.position.y,
-      z: this.armature.position.z
-    };
-    
-    console.log('Avatar position locked at current position:', this.lockedPosition);
-  }
-
-  /**
-   * Unlock avatar position and restore original position.
-   */
-  unlockAvatarPosition() {
-    if (this.armature && this.originalPosition) {
-      // Restore avatar to its original position before locking
-      this.armature.position.set(
-        this.originalPosition.x,
-        this.originalPosition.y,
-        this.originalPosition.z
-      );
-      console.log('Avatar position restored to original:', this.originalPosition);
-    } else if (this.armature) {
-      // Fallback: reset to center if no original position was stored
-      this.armature.position.set(0, 0, 0);
-      console.log('Avatar position reset to center (0,0,0)');
-    }
-    this.lockedPosition = null;
-    this.originalPosition = null; // Clear original position after unlock
-    console.log('Avatar position unlocked');
-  }
-
-  /**
-   * Ensure avatar stays at locked position.
-   */
-  maintainLockedPosition() {
-    if (this.lockedPosition && this.armature) {
-      // Enforce the locked position - keep avatar exactly where it was locked
-      // This prevents FBX animations from moving the avatar
-        this.armature.position.set(
-          this.lockedPosition.x,
-        this.lockedPosition.y,
-          this.lockedPosition.z
-        );
-    }
-  }
-
-  /**
-   * Create body movement animation.
-   * @param {string} movementType Movement type.
-   * @returns {Object} Animation object.
-   */
-  createBodyMovementAnimation(movementType) {
-    const intensity = this.movementIntensity || 0.5;
-    
-    const movementAnimations = {
-      walking: {
-        name: 'bodyMovement_walking',
-        delay: [500, 2000],
-        dt: [800, 1200],
-        vs: {
-          bodyRotateY: [-0.1 * intensity, 0.1 * intensity, 0],
-          bodyRotateZ: [-0.05 * intensity, 0.05 * intensity, 0],
-          bodyRotateX: [-0.02 * intensity, 0.02 * intensity, 0]
-        }
-      },
-      prancing: {
-        name: 'bodyMovement_prancing',
-        delay: [300, 1000],
-        dt: [400, 800],
-        vs: {
-          bodyRotateY: [-0.15 * intensity, 0.15 * intensity, 0],
-          bodyRotateZ: [-0.08 * intensity, 0.08 * intensity, 0],
-          bodyRotateX: [-0.05 * intensity, 0.05 * intensity, 0]
-        }
-      },
-      gesturing: {
-        name: 'bodyMovement_gesturing',
-        delay: [400, 1500],
-        dt: [600, 1000],
-        vs: {
-          bodyRotateY: [-0.08 * intensity, 0.08 * intensity, 0],
-          bodyRotateZ: [-0.03 * intensity, 0.03 * intensity, 0]
-        }
-      },
-      dancing: {
-        name: 'bodyMovement_dancing',
-        delay: [200, 600],
-        dt: [400, 800],
-        vs: {
-          bodyRotateY: [-0.25 * intensity, 0.25 * intensity, 0],
-          bodyRotateZ: [-0.15 * intensity, 0.15 * intensity, 0],
-          bodyRotateX: [-0.1 * intensity, 0.1 * intensity, 0]
-        }
-      },
-      dancing2: {
-        name: 'bodyMovement_dancing2',
-        delay: [150, 500],
-        dt: [300, 700],
-        vs: {
-          bodyRotateY: [-0.3 * intensity, 0.3 * intensity, 0],
-          bodyRotateZ: [-0.2 * intensity, 0.2 * intensity, 0],
-          bodyRotateX: [-0.12 * intensity, 0.12 * intensity, 0]
-        }
-      },
-      dancing3: {
-        name: 'bodyMovement_dancing3',
-        delay: [100, 400],
-        dt: [200, 600],
-        vs: {
-          bodyRotateY: [-0.35 * intensity, 0.35 * intensity, 0],
-          bodyRotateZ: [-0.25 * intensity, 0.25 * intensity, 0],
-          bodyRotateX: [-0.15 * intensity, 0.15 * intensity, 0]
-        }
-      },
-      excited: {
-        name: 'bodyMovement_excited',
-        delay: [200, 600],
-        dt: [300, 700],
-        vs: {
-          bodyRotateY: [-0.12 * intensity, 0.12 * intensity, 0],
-          bodyRotateZ: [-0.06 * intensity, 0.06 * intensity, 0],
-          bodyRotateX: [-0.04 * intensity, 0.04 * intensity, 0]
-        }
-      },
-      happy: {
-        name: 'bodyMovement_happy',
-        delay: [300, 800],
-        dt: [500, 1000],
-        vs: {
-          bodyRotateY: [-0.08 * intensity, 0.08 * intensity, 0],
-          bodyRotateZ: [-0.04 * intensity, 0.04 * intensity, 0],
-          bodyRotateX: [-0.02 * intensity, 0.02 * intensity, 0]
-        }
-      },
-      surprised: {
-        name: 'bodyMovement_surprised',
-        delay: [100, 300],
-        dt: [200, 500],
-        vs: {
-          bodyRotateY: [-0.05 * intensity, 0.05 * intensity, 0],
-          bodyRotateZ: [-0.03 * intensity, 0.03 * intensity, 0],
-          bodyRotateX: [-0.01 * intensity, 0.01 * intensity, 0]
-        }
-      },
-      thinking: {
-        name: 'bodyMovement_thinking',
-        delay: [800, 2000],
-        dt: [1000, 1500],
-        vs: {
-          bodyRotateY: [-0.06 * intensity, 0.06 * intensity, 0],
-          bodyRotateZ: [-0.03 * intensity, 0.03 * intensity, 0],
-          bodyRotateX: [-0.02 * intensity, 0.02 * intensity, 0]
-        }
-      },
-      nodding: {
-        name: 'bodyMovement_nodding',
-        delay: [400, 800],
-        dt: [300, 600],
-        vs: {
-          bodyRotateX: [-0.1 * intensity, 0.1 * intensity, 0],
-          bodyRotateY: [-0.02 * intensity, 0.02 * intensity, 0]
-        }
-      },
-      shaking: {
-        name: 'bodyMovement_shaking',
-        delay: [200, 400],
-        dt: [150, 300],
-        vs: {
-          bodyRotateY: [-0.15 * intensity, 0.15 * intensity, 0],
-          bodyRotateZ: [-0.05 * intensity, 0.05 * intensity, 0]
-        }
-      },
-      celebration: {
-        name: 'bodyMovement_celebration',
-        delay: [100, 300],
-        dt: [200, 500],
-        vs: {
-          bodyRotateY: [-0.2 * intensity, 0.2 * intensity, 0],
-          bodyRotateZ: [-0.1 * intensity, 0.1 * intensity, 0],
-          bodyRotateX: [-0.08 * intensity, 0.08 * intensity, 0]
-        }
-      },
-      energetic: {
-        name: 'bodyMovement_energetic',
-        delay: [150, 400],
-        dt: [250, 500],
-        vs: {
-          bodyRotateY: [-0.18 * intensity, 0.18 * intensity, 0],
-          bodyRotateZ: [-0.12 * intensity, 0.12 * intensity, 0],
-          bodyRotateX: [-0.08 * intensity, 0.08 * intensity, 0]
-        }
-      },
-      swaying: {
-        name: 'bodyMovement_swaying',
-        delay: [600, 1200],
-        dt: [800, 1000],
-        vs: {
-          bodyRotateY: [-0.1 * intensity, 0.1 * intensity, 0],
-          bodyRotateZ: [-0.05 * intensity, 0.05 * intensity, 0]
-        }
-      },
-      bouncing: {
-        name: 'bodyMovement_bouncing',
-        delay: [300, 600],
-        dt: [400, 700],
-        vs: {
-          bodyRotateY: [-0.05 * intensity, 0.05 * intensity, 0]
-        }
-      }
-    };
-    
-    // Handle dance variations
-    if (movementType === 'dancing') {
-      const danceVariations = ['dancing', 'dancing2', 'dancing3'];
-      const randomDance = danceVariations[Math.floor(Math.random() * danceVariations.length)];
-      return movementAnimations[randomDance] || movementAnimations['dancing'];
-    }
-    
-    return movementAnimations[movementType] || null;
-  }
-
-  /**
-   * Set movement intensity.
-   * @param {number} intensity Movement intensity (0-1).
-   */
-  setMovementIntensity(intensity) {
-    this.movementIntensity = Math.max(0, Math.min(1, intensity));
-    
-    // Only set avatar property if avatar exists
-    if (this.avatar) {
-      this.avatar.movementIntensity = this.movementIntensity;
-    }
-    
-    console.log('Movement intensity set to:', this.movementIntensity);
-    
-    // Update FBX animation intensity if available
-    if (this.fbxAnimationLoader) {
-      this.fbxAnimationLoader.setIntensity(this.movementIntensity);
-    }
-    
-    // Reapply body movement animation with new intensity
-    if (this.bodyMovement && this.bodyMovement !== 'idle') {
-      this.applyBodyMovementAnimation();
-    }
-  }
-
   /**
   * Dispose the instance.
   */
@@ -5532,12 +4814,6 @@ class TalkingHead {
 
     this.clearThree( this.ikMesh );
     this.dynamicbones.dispose();
-    
-    // Clean up FBX animation loader
-    if (this.fbxAnimationLoader) {
-      this.fbxAnimationLoader.stopCurrentAnimation();
-      this.fbxAnimationLoader = null;
-    }
 
     // DOM
     this.nodeAvatar = null;