@memori.ai/memori-react 8.45.2 → 8.45.4

package/src/components/Avatar/AvatarView/AvatarComponent/Shadow/DynamicShadow.tsx

@@ -1,103 +0,0 @@
-import React, { useEffect, useState } from 'react';
-import { Canvas } from '@react-three/fiber';
-import { ContactShadows, PerspectiveCamera } from '@react-three/drei';
-import { AvatarAnimator } from '../components/controllers/AvatarAnimator';
-
-const DynamicShadow = ({
-  animator,
-  avatarPosition,
-  }: {
-    animator: AvatarAnimator | null;
-  avatarPosition: any;
-}) => {
-  // Calculate shadow properties based on animation
-  const getShadowProps = () => {
-    const baseProps = {
-      width: 10,
-      height: 10,
-      blur: 2.5,
-      scale: 10,
-      far: 5,
-      resolution: 1024,
-      color: '#000000',
-    };
-
-    if (!animator) {
-      return {
-        ...baseProps,
-        opacity: 0,
-      };
-    }
-    // Adjust shadow based on animation type
-    if (animator.getCurrentAnimationName()?.startsWith('Loading')) {
-      return {
-        ...baseProps,
-        opacity: 0.85,
-        blur: 3,
-        width: 12,
-        height: 12,
-      };
-    } else if (
-      animator.getCurrentAnimationName()?.includes('Gioia') ||
-      animator.getCurrentAnimationName()?.includes('Joy')
-    ) {
-      return {
-        ...baseProps,
-        opacity: 0.9,
-        blur: 2,
-        width: 11,
-        height: 11,
-      };
-    } else if (
-      animator.getCurrentAnimationName()?.includes('Rabbia') ||
-      animator.getCurrentAnimationName()?.includes('Anger')
-    ) {
-      return {
-        ...baseProps,
-        opacity: 0.95,
-        blur: 1.8,
-        width: 12,
-        height: 12,
-      };
-    }
-
-    // Default idle state
-    return {
-      ...baseProps,
-      opacity: 0.9,
-      blur: 2.2,
-    };
-  };
-
-  const shadowProps = getShadowProps();
-
-  return (
-    <>
-      {/* Main body shadow */}
-      <ContactShadows
-        opacity={shadowProps.opacity}
-        scale={shadowProps.scale}
-        blur={shadowProps.blur}
-        far={shadowProps.far}
-        resolution={shadowProps.resolution}
-        color={shadowProps.color}
-        frames={Infinity}
-        position={[0, avatarPosition.y, 0]}
-      />
-
-      {/* Foot shadow - smaller and sharper */}
-      <ContactShadows
-         opacity={1}
-         width={5}
-         height={5}
-         blur={1}
-         far={2}
-         resolution={1024}
-         color="#000000"
-        position={[0, -0.98, 0]}
-      />
-    </>
-  );
-};
-
-export default DynamicShadow;

package/src/components/Avatar/AvatarView/AvatarComponent/avatarComponent.tsx

@@ -1,105 +0,0 @@
-import { useRef, useEffect, useCallback, memo } from 'react';
-import { AvatarAnimator } from './components/controllers/AvatarAnimator';
-import { FullbodyAvatar } from './components/FullbodyAvatar/fullbodyAvatar';
-import HalfBodyAvatar from './components/halfbodyAvatar';
-
-interface AvatarViewProps {
-  chatEmission: string | null | undefined;
-  url: string;
-  sex: 'MALE' | 'FEMALE';
-  eyeBlink: boolean;
-  halfBody: boolean;
-  loading: boolean;
-  avatarHeight: number;
-  avatarDepth: number;
-  updateCurrentViseme: (
-    currentTime: number
-  ) => { name: string; weight: number } | null;
-  setCameraZ: (cameraZ: number) => void;
-  headMovement: boolean;
-  speaking: boolean;
-  showControls: boolean;
-}
-
-// Memoized FullbodyAvatar component to prevent unnecessary re-renders
-const MemoizedFullbodyAvatar = memo(FullbodyAvatar);
-
-// Memoized HalfBodyAvatar component to prevent unnecessary re-renders
-const MemoizedHalfBodyAvatar = memo(HalfBodyAvatar);
-
-export const AvatarView = ({
-  chatEmission,
-  url,
-  sex,
-  eyeBlink,
-  halfBody,
-  loading,
-  avatarHeight = 50,
-  avatarDepth = -50,
-  updateCurrentViseme,
-  setCameraZ,
-  headMovement,
-  // speaking,
-  showControls,
-}: AvatarViewProps) => {
-  // Reference to the AvatarAnimator instance for animation control
-  const animatorRef = useRef<AvatarAnimator | null>(null);
-
-  // Memoize the setAnimatorRef callback to ensure it doesn't change on re-renders
-  const setAnimatorRef = useCallback((animator: AvatarAnimator | null) => {
-    if (animator !== animatorRef.current) {
-      animatorRef.current = animator;
-    }
-  }, []); // Empty dependency array ensures this function never changes
-
-  // React to changes in chat emission or loading state
-  // This effect doesn't re-create the animator, it just uses it
-  useEffect(() => {
-    if (!animatorRef.current) return;
-    
-    try {
-      // Prevents any extra work if loading/emission hasn't changed
-      animatorRef.current.processChatEmission(chatEmission, loading);
-    } catch (error) {
-      console.error('Error processing chat emission:', error);
-    }
-  }, [loading, chatEmission]); // Both dependencies are needed
-
-  // Memoize common props to prevent unnecessary object creation on re-renders
-  const commonAvatarProps = useCallback(() => ({
-    url,
-    onCameraZChange: setCameraZ,
-    updateCurrentViseme,
-    avatarHeight,
-    avatarDepth,
-    setAnimatorRef, // This is now stable across renders
-  }), [url, setCameraZ, updateCurrentViseme, avatarHeight, avatarDepth, setAnimatorRef]);
-
-  // Render avatar based on halfBody flag
-  return (
-    <>
-      {halfBody ? (
-        <MemoizedHalfBodyAvatar
-          {...commonAvatarProps()}
-          eyeBlink={eyeBlink}
-          headMovement={headMovement}
-        />
-      ) : (
-        <MemoizedFullbodyAvatar
-          {...commonAvatarProps()}
-          sex={sex}
-          eyeBlink={eyeBlink}
-          chatEmission={chatEmission}
-          loading={loading}
-        />
-      )}
-      {showControls && animatorRef.current && (
-        <div className="animation-controls">
-          {/* Optional animation control UI could be added here */}
-        </div>
-      )}
-    </>
-  );
-};
-
-export default memo(AvatarView); // Memoize the entire component

package/src/components/Avatar/AvatarView/AvatarComponent/components/FullbodyAvatar/fullbodyAvatar.tsx

@@ -1,338 +0,0 @@
-import { useEffect, useRef, useMemo, useCallback, useState } from 'react';
-import { AnimationAction, Vector3, Scene, SkinnedMesh, Object3D } from 'three';
-import { useGLTF, useAnimations } from '@react-three/drei';
-import { useFrame } from '@react-three/fiber';
-import { MorphTargetController } from '../controllers/MorphTargetController';
-import { AvatarPositionController } from '../controllers/AvatarPositionController';
-import { AvatarAnimator } from '../controllers/AvatarAnimator';
-import {
-  ANIMATION_URLS,
-  AVATAR_POSITION,
-  AVATAR_ROTATION,
-  MALE_EXCLUDED_ANIMATIONS,
-  SCALE_LERP_FACTOR,
-} from '../../constants';
-import DynamicShadow from '../../Shadow/DynamicShadow';
-
-// Enhanced props interface for FullbodyAvatar
-export interface FullbodyAvatarProps {
-  url: string;
-  sex: 'MALE' | 'FEMALE';
-  eyeBlink: boolean;
-  updateCurrentViseme: (
-    currentTime: number
-  ) => { name: string; weight: number } | null;
-  avatarHeight?: number;
-  avatarDepth?: number;
-  onCameraZChange?: (value: number) => void;
-  chatEmission: any;
-  loading: boolean;
-  // New prop to expose animator to parent component
-  setAnimatorRef?: (animator: AvatarAnimator | null) => void;
-}
-
-export function FullbodyAvatar({
-  url,
-  sex,
-  eyeBlink,
-  updateCurrentViseme,
-  avatarHeight = 50,
-  avatarDepth = 0,
-  onCameraZChange,
-  chatEmission,
-  loading,
-  setAnimatorRef,
-}: FullbodyAvatarProps) {
-  // Load the avatar model and its animations
-  const { scene, animations: baseAnimations } = useGLTF(url);
-
-  // Load additional animations based on sex (fallback animations)
-  const { animations: additionalAnimations } = useGLTF(ANIMATION_URLS[sex]);
-
-  // Check if avatar needs additional animations
-  const needsAdditionalAnimations = useMemo(() => {
-    let found = false;
-    scene.traverse((object: Object3D) => {
-      if (
-        object instanceof SkinnedMesh &&
-        (object.name === 'GBNL__Head' ||
-          object.name === 'Wolf3D_Avatar' ||
-          object.name === 'Wolf3D_Avatar006_1')
-      ) {
-        found = true;
-      }
-    });
-    return found;
-  }, [scene]);
-
-  // Merge base and additional animations only if needed.
-  // For male avatars, exclude problematic idle clips from the full set (base + pack).
-  const mergedAnimations = useMemo(() => {
-    const clips = needsAdditionalAnimations
-      ? [...baseAnimations, ...additionalAnimations]
-      : baseAnimations;
-
-    if (sex !== 'MALE') return clips;
-
-    return clips.filter(clip => !MALE_EXCLUDED_ANIMATIONS.has(clip.name));
-  }, [baseAnimations, additionalAnimations, needsAdditionalAnimations, sex]);
-
-  // Create animation actions from the merged animations
-  const { actions } = useAnimations(mergedAnimations, scene);
-
-  // System controllers - use refs to maintain instance across renders
-  const morphTargetControllerRef = useRef<MorphTargetController | null>(null);
-  const positionControllerRef = useRef<AvatarPositionController | null>(null);
-  const animatorRef = useRef<AvatarAnimator | null>(null);
-
-  // Reference to track initialization status
-  const isInitializedRef = useRef<boolean>(false);
-
-  // For position tracking and updates
-  const lastPositionRef = useRef<Vector3>(AVATAR_POSITION.clone());
-  const positionUpdateThrottleRef = useRef<number>(0);
-  const POSITION_UPDATE_INTERVAL = 1; // ~1000fps for more frequent updates
-
-
-  const [isRpm, setIsRpm] = useState(false);
-
-  // For eye blinking
-  const blinkStateRef = useRef({
-    isBlinking: false,
-    lastBlinkTime: 0,
-    nextBlinkTime: 0,
-    blinkStartTime: 0,
-  });
-
-  // Find head mesh and initialize morph target controller - only run when scene changes
-  useEffect(() => {
-    if (!scene) return;
-  
-    // Find head mesh
-    let headMesh: SkinnedMesh | null = null;
-    
-    scene.traverse((object: Object3D) => {
-      if (object instanceof SkinnedMesh) {
-        // Keep existing RPM check
-        if (object.name === 'Wolf3D_Avatar' || object.name === 'Wolf3D_Avatar006_1') {
-          setIsRpm(true);
-          headMesh = object;
-          return; // Stop here if RPM found
-        }
-        
-        // Dynamic detection for custom avatars
-        if (object.name === 'GBNL__Head') {
-          // Known custom avatar
-          headMesh = object;
-        } else {
-          // Dynamic detection for unknown custom avatars
-          const hasMorphTargets = object.morphTargetDictionary && 
-                                 Object.keys(object.morphTargetDictionary).length > 0;
-          
-          if (hasMorphTargets) {
-            const morphTargetNames = Object.keys(object.morphTargetDictionary || {});
-            
-            // Check if it has viseme-related morph targets (for custom avatars)
-            const hasVisemes = morphTargetNames.some(name => 
-              name.toLowerCase().includes('viseme')
-            );
-            
-            // Check for other face-related blend shapes
-            const hasFaceBlendShapes = morphTargetNames.some(name => {
-              const lower = name.toLowerCase();
-              return lower.includes('mouth') || 
-                     lower.includes('eye') || 
-                     lower.includes('jaw') ||
-                     lower.includes('smile');
-            });
-  
-            if (hasVisemes || hasFaceBlendShapes) {
-              headMesh = object;
-            }
-          }
-        }
-      }
-    });
-  
-    // Initialize morph target controller if head mesh found
-    if (headMesh) {
-      // Only create a new controller if one doesn't exist
-      if (!morphTargetControllerRef.current) {
-        morphTargetControllerRef.current = new MorphTargetController(headMesh);
-      }
-    } else {
-      console.warn('⚠️ No suitable avatar mesh found');
-    }
-  }, [scene]); // Only re-run if scene changes
-
-  // Initialize position controller once
-  useEffect(() => {
-    if (!positionControllerRef.current) {
-      positionControllerRef.current = new AvatarPositionController(
-        AVATAR_POSITION
-      );
-    }
-    
-    // Cleanup function
-    return () => {
-      // No need to dispose the position controller here
-    };
-  }, []); // Empty dependency array means this runs once
-
-  // Handle avatar height changes
-  useEffect(() => {
-    if (positionControllerRef.current) {
-      positionControllerRef.current.updateHeight(avatarHeight, false);
-    }
-  }, [avatarHeight]);
-
-  // Handle avatar depth changes
-  useEffect(() => {
-    if (positionControllerRef.current && onCameraZChange) {
-      const newCameraZ = positionControllerRef.current.updateDepth(
-        avatarDepth,
-        false
-      );
-      onCameraZChange(newCameraZ);
-    }
-  }, [avatarDepth, onCameraZChange]);
-
-  // Initialize animator only once and cleanup properly
-  useEffect(() => {
-    // Only initialize if not already initialized and dependencies are available
-    if (!scene || !actions || isInitializedRef.current) {
-      return;
-    }
-
-
-    // Create the animator only once
-    if (!animatorRef.current) {
-      animatorRef.current = new AvatarAnimator();
-    }
-
-    const animator = animatorRef.current;
-
-    const initWithPreloadedAnimations = async () => {
-      try {
-        // Prevent multiple initializations
-        if (animator.isInitialized()) {
-          return;
-        }
-
-        // Initialize animator with avatar animations first, then fallback animations
-        await animator.initialize(
-          scene as unknown as Scene,
-          actions as Record<string, AnimationAction>,
-          mergedAnimations,
-          isRpm ? 'RPM' : 'CUSTOM_GLB'
-        );
-
-        // Expose animator to parent component if callback provided
-        if (setAnimatorRef) {
-          setAnimatorRef(animator);
-        }
-
-        // Mark as initialized
-        isInitializedRef.current = true;
-
-        // Set initial time scale
-        animator.setTimeScale(0.8);
-      } catch (error) {
-        console.error('Error initializing AvatarAnimator:', error);
-      }
-    };
-
-    initWithPreloadedAnimations();
-
-    // Cleanup on unmount
-    return () => {
-      // Only clean up if we created it in this component
-      if (animatorRef.current && isInitializedRef.current) {
-
-        // Dispose mixer if needed
-        if ('mixer' in animatorRef.current && animatorRef.current['mixer']) {
-          (animatorRef.current['mixer'] as any).stopAllAction();
-        }
-
-        // Clear reference in parent component
-        if (setAnimatorRef) {
-          setAnimatorRef(null);
-        }
-
-        // Reset references
-        isInitializedRef.current = false;
-        // Don't null out animatorRef here to prevent flickering during re-renders
-      }
-    };
-  }, [scene, actions, mergedAnimations, sex, setAnimatorRef]);
-
-  // Memoize the frame callback to prevent creating a new function every render
-  const frameCallback = useCallback((state: any, delta: number) => {
-    const currentTime = state.clock.elapsedTime * 1000;
-
-    // Update animation system
-    if (animatorRef.current && isInitializedRef.current) {
-      animatorRef.current.update(delta);
-    }
-
-    // Update morph targets for facial expressions and visemes
-    if (morphTargetControllerRef.current) {
-      const currentViseme = updateCurrentViseme(currentTime / 1000);
-
-      morphTargetControllerRef.current.updateMorphTargets(
-        currentTime,
-        chatEmission,
-        loading,
-        currentViseme,
-        eyeBlink,
-        blinkStateRef.current
-      );
-    }
-
-    // Update position and scale
-    if (scene && positionControllerRef.current) {
-      // Update scale
-      const newScale =
-        positionControllerRef.current.updateScale(SCALE_LERP_FACTOR);
-      scene.scale.copy(newScale);
-
-      // High frequency position update check
-      if (
-        currentTime - positionUpdateThrottleRef.current >=
-        POSITION_UPDATE_INTERVAL
-      ) {
-        const currentPosition = positionControllerRef.current.getPosition();
-
-        // Round to 6 decimal places for high precision
-        currentPosition.setX(Number(currentPosition.x.toFixed(6)));
-        currentPosition.setY(Number(currentPosition.y.toFixed(6)));
-        currentPosition.setZ(Number(currentPosition.z.toFixed(6)));
-
-        lastPositionRef.current.copy(currentPosition);
-        positionUpdateThrottleRef.current = currentTime;
-      }
-    }
-  }, [scene, updateCurrentViseme, chatEmission, loading, eyeBlink]);
-
-  // Use the memoized callback in useFrame
-  useFrame(frameCallback);
-
-  // Get current position from controller with fallback - memoize to prevent recreation
-  const position = useMemo(() => {
-    return (
-      positionControllerRef.current?.getPosition() || AVATAR_POSITION.clone()
-    );
-  }, []);
-
-  return (
-    <>
-      <DynamicShadow animator={animatorRef.current} avatarPosition={position} />
-      <group position={position} rotation={AVATAR_ROTATION}>
-        <primitive object={scene} />
-      </group>
-    </>
-  );
-}
-
-// Avoid using React.memo here as it's exported as a named function
-// The parent component should handle memoization if needed

package/src/components/Avatar/AvatarView/AvatarComponent/components/FullbodyAvatar/types.ts

@@ -1,44 +0,0 @@
-export enum AnimationState {
-  LOADING = 'LOADING',
-  EMOTION = 'EMOTION',
-  IDLE = 'IDLE',
-}
-
-export interface AnimationConfig {
-  fadeInDuration: number;
-  fadeOutDuration: number;
-  idleCount: number;
-  timeScale: number;
-}
-
-export interface FullbodyAvatarProps {
-  url: string;
-  sex: 'MALE' | 'FEMALE';
-  setIsRpm: (value: boolean) => void;
-  onLoaded?: () => void;
-  currentBaseAction: {
-    action: string;
-    weight: number;
-  };
-  timeScale: number;
-  onCameraZChange: (value: number) => void;
-  eyeBlink?: boolean;
-  avatarDepth?: number;
-  avatarHeight?: number;
-  stopProcessing: () => void;
-  resetVisemeQueue: () => void;
-  updateCurrentViseme: (
-    currentTime: number
-  ) => { name: string; weight: number } | null;
-  smoothMorphTarget?: boolean;
-  morphTargetSmoothing?: number;
-  morphTargetInfluences: Record<string, number>;
-  setMorphTargetDictionary: (
-    morphTargetDictionary: Record<string, number>
-  ) => void;
-  setMorphTargetInfluences: (
-    morphTargetInfluences: Record<string, number>
-  ) => void;
-  emotionMorphTargets: Record<string, number>;
-  halfBody: boolean;
-}