skeletalanim.cpp

用DirectX制作高级动画-[Advanced.Animation.with.DirectX]

#include "SkeletalAnim.h"

cAnimation::cAnimation()
{
  m_Name = NULL;
  m_Bone = NULL;
  m_Next = NULL;

  m_NumTranslationKeys = 0;
  m_NumScaleKeys       = 0;
  m_NumRotationKeys    = 0;
  m_NumMatrixKeys      = 0;

  m_TranslationKeys = NULL;
  m_ScaleKeys       = NULL;
  m_RotationKeys    = NULL;
  m_MatrixKeys      = NULL;
}

cAnimation::~cAnimation()
{
  delete [] m_Name; m_Name = NULL;
  delete m_Next;    m_Next = NULL;
  delete [] m_TranslationKeys;
  delete [] m_ScaleKeys;
  delete [] m_RotationKeys;
  delete [] m_MatrixKeys;
}

cAnimationSet::cAnimationSet()
{
  m_Name          = NULL;
  m_Length        = 0;
  m_Next          = NULL;
  m_NumAnimations = 0;
  m_Animations    = NULL;
}

cAnimationSet::~cAnimationSet()
{
  delete [] m_Name;    m_Name = NULL;
  delete m_Next;       m_Next = NULL;
  delete m_Animations; m_Animations = NULL;
}

cAnimationCollection::cAnimationCollection()
{
  m_NumAnimationSets = 0;
  m_AnimationSets    = NULL;
}

cAnimationCollection::~cAnimationCollection()
{
  Free();
}

BOOL cAnimationCollection::ParseObject(                     \
                   IDirectXFileData *pDataObj,                \
                   IDirectXFileData *pParentDataObj,          \
                   DWORD Depth,                               \
                   void **Data, BOOL Reference)
{
  const GUID *Type = GetObjectGUID(pDataObj);
  DWORD i;

  // Check if template is AnimationSet type
  if(*Type == TID_D3DRMAnimationSet) {

    // Create and link in a cAnimationSet object
    cAnimationSet *AnimSet = new cAnimationSet();
    AnimSet->m_Next = m_AnimationSets;
    m_AnimationSets = AnimSet;

    // Increase # of animation sets
    m_NumAnimationSets++;

    // Set animation set name
    AnimSet->m_Name = GetObjectName(pDataObj);
  }

  // Check if template is Animation type
  if(*Type == TID_D3DRMAnimation && m_AnimationSets) {

    // Add a cAnimation class to top-level cAnimationSet
    cAnimation *Anim = new cAnimation();
    Anim->m_Next = m_AnimationSets->m_Animations;
    m_AnimationSets->m_Animations = Anim;

    // Increase # of animations
    m_AnimationSets->m_NumAnimations++;
  }

  // Check if a frame reference inside animation template
  if(*Type == TID_D3DRMFrame && Reference == TRUE &&          \
                             m_AnimationSets &&               \
                             m_AnimationSets->m_Animations) {

    // Make sure parent object is an Animation template
    if(pParentDataObj && *GetObjectGUID(pParentDataObj) ==  \
                                        TID_D3DRMAnimation) {

      // Get name of frame and store it as animation
      m_AnimationSets->m_Animations->m_Name =                 \
                                  GetObjectName(pDataObj);
    }

    // Don't process child of reference frames
    return TRUE;
  }

  // Check if template is AnimationKey type
  if(*Type == TID_D3DRMAnimationKey && m_AnimationSets &&     \
                            m_AnimationSets->m_Animations) {

    // Get a pointer to top-level animation object
    cAnimation *Anim = m_AnimationSets->m_Animations;

    // Get a data pointer
    DWORD *DataPtr = (DWORD*)GetObjectData(pDataObj, NULL);

    // Get key type
    DWORD Type = *DataPtr++;

    // Get # of keys to follow
    DWORD NumKeys = *DataPtr++;

    // Branch based on key type
    switch(Type) {
      case 0: // Rotation
        delete [] Anim->m_RotationKeys;
        Anim->m_NumRotationKeys = NumKeys;
        Anim->m_RotationKeys = new                            \
                             cAnimationQuaternionKey[NumKeys];
        for(i=0;i<NumKeys;i++) {
          // Get time
          Anim->m_RotationKeys[i].m_Time = *DataPtr++;
          if(Anim->m_RotationKeys[i].m_Time >                 \
                                   m_AnimationSets->m_Length)
            m_AnimationSets->m_Length =                       \
                              Anim->m_RotationKeys[i].m_Time;

          // Skip # keys to follow (should be 4)
          DataPtr++;

          // Get rotational values
          float *fPtr = (float*)DataPtr;
          Anim->m_RotationKeys[i].m_quatKey.w = *fPtr++;
          Anim->m_RotationKeys[i].m_quatKey.x = *fPtr++;
          Anim->m_RotationKeys[i].m_quatKey.y = *fPtr++;
          Anim->m_RotationKeys[i].m_quatKey.z = *fPtr++;
          DataPtr+=4;
        }
        break;

      case 1: // Scaling
        delete [] Anim->m_ScaleKeys;
        Anim->m_NumScaleKeys = NumKeys;
        Anim->m_ScaleKeys = new cAnimationVectorKey[NumKeys];
        for(i=0;i<NumKeys;i++) {
          // Get time
          Anim->m_ScaleKeys[i].m_Time = *DataPtr++;
          if(Anim->m_ScaleKeys[i].m_Time >                    \
                                   m_AnimationSets->m_Length)
            m_AnimationSets->m_Length =                       \
                                 Anim->m_ScaleKeys[i].m_Time;

          // Skip # keys to follow (should be 3)
          DataPtr++;

          // Get scale values
          D3DXVECTOR3 *vecPtr = (D3DXVECTOR3*)DataPtr;
          Anim->m_ScaleKeys[i].m_vecKey = *vecPtr;
          DataPtr+=3;
        }
        break;

      case 2: // Translation
        delete [] Anim->m_TranslationKeys;
        Anim->m_NumTranslationKeys = NumKeys;
        Anim->m_TranslationKeys = new                         \
                                cAnimationVectorKey[NumKeys];
        for(i=0;i<NumKeys;i++) {
          // Get time
          Anim->m_TranslationKeys[i].m_Time = *DataPtr++;
          if(Anim->m_TranslationKeys[i].m_Time >              \
                                   m_AnimationSets->m_Length)
            m_AnimationSets->m_Length =                       \
                           Anim->m_TranslationKeys[i].m_Time;

          // Skip # keys to follow (should be 3)
          DataPtr++;

          // Get translation values
          D3DXVECTOR3 *vecPtr = (D3DXVECTOR3*)DataPtr;
          Anim->m_TranslationKeys[i].m_vecKey = *vecPtr;
          DataPtr+=3;
        }
        break;

      case 4: // Transformation matrix
        delete [] Anim->m_MatrixKeys;
        Anim->m_NumMatrixKeys = NumKeys;
        Anim->m_MatrixKeys = new cAnimationMatrixKey[NumKeys];
        for(i=0;i<NumKeys;i++) {
          // Get time
          Anim->m_MatrixKeys[i].m_Time = *DataPtr++;

          if(Anim->m_MatrixKeys[i].m_Time >                   \
                                  m_AnimationSets->m_Length)
            m_AnimationSets->m_Length =                       \
                               Anim->m_MatrixKeys[i].m_Time;

          // Skip # keys to follow (should be 16)
          DataPtr++;

          // Get matrix values
          D3DXMATRIX *mPtr = (D3DXMATRIX *)DataPtr;
          Anim->m_MatrixKeys[i].m_matKey = *mPtr;
          DataPtr += 16;
        }
        break;
    }
  }

  return ParseChildObjects(pDataObj, Depth, Data, Reference);
}

BOOL cAnimationCollection::Load(char *Filename)
{
  // Free a prior loaded collection
  Free();

  // Parse the file
  return Parse(Filename);
}

void cAnimationCollection::Free()
{
  m_NumAnimationSets = 0;
  delete m_AnimationSets; m_AnimationSets = NULL;
}

void cAnimationCollection::Map(D3DXFRAME_EX *RootFrame)
{
  // Go through each animation set
  cAnimationSet *AnimSet = m_AnimationSets;
  while(AnimSet != NULL) {

    // Go through each animation object
    cAnimation *Anim = AnimSet->m_Animations;
    while(Anim != NULL) {

      // Go through all frames and look for match
      Anim->m_Bone = RootFrame->Find(Anim->m_Name);

      // Go to next animation object
      Anim = Anim->m_Next;
    }

    // Go to next animation set object
    AnimSet = AnimSet->m_Next;
  }
}

void cAnimationCollection::Update(char *AnimationSetName,     \
                                  DWORD Time, BOOL Loop)
{
  cAnimationSet *AnimSet = m_AnimationSets;

  // Look for matching animation set name if used
  if(AnimationSetName) {

    // Find matching animation set name
    while(AnimSet != NULL) {

      // Break when match found
      if(!stricmp(AnimSet->m_Name, AnimationSetName))
        break;

      // Go to next animation set object
      AnimSet = AnimSet->m_Next;
    }
  }

  // Return no set found
  if(AnimSet == NULL)
    return;

  // Bounds time to animation length
  if(Time > AnimSet->m_Length)
    Time = (Loop==TRUE)?Time%(AnimSet->m_Length+1):AnimSet->m_Length;

  // Go through each animation
  cAnimation *Anim = AnimSet->m_Animations;
  while(Anim) {

    // Only process if it's attached to a bone
    if(Anim->m_Bone) {

      // Reset transformation
      D3DXMatrixIdentity(&Anim->m_Bone->TransformationMatrix);

      // Apply various matrices to transformation

      // Scaling
      if(Anim->m_NumScaleKeys && Anim->m_ScaleKeys) {

        // Loop for matching scale key
        DWORD Key1 = 0, Key2 = 0;
        for(DWORD i=0;i<Anim->m_NumScaleKeys;i++) {
          if(Time >= Anim->m_ScaleKeys[i].m_Time)
            Key1 = i;
        }

        // Get 2nd key number
        Key2 = (Key1>=(Anim->m_NumScaleKeys-1))?Key1:Key1+1;

        // Get difference in keys' times
        DWORD TimeDiff = Anim->m_ScaleKeys[Key2].m_Time-
                         Anim->m_ScaleKeys[Key1].m_Time;
        if(!TimeDiff)
          TimeDiff = 1;

        // Calculate a scalar value to use
        float Scalar = (float)(Time - Anim->m_ScaleKeys[Key1].m_Time) / (float)TimeDiff;

        // Calculate interpolated scale values
        D3DXVECTOR3 vecScale = Anim->m_ScaleKeys[Key2].m_vecKey - 
                               Anim->m_ScaleKeys[Key1].m_vecKey;
        vecScale *= Scalar;
        vecScale += Anim->m_ScaleKeys[Key1].m_vecKey;

        // Create scale matrix and combine with transformation
        D3DXMATRIX matScale;
        D3DXMatrixScaling(&matScale, vecScale.x, vecScale.y, vecScale.z);
        Anim->m_Bone->TransformationMatrix *= matScale;
      }

      // Rotation
      if(Anim->m_NumRotationKeys && Anim->m_RotationKeys) {

        // Loop for matching rotation key
        DWORD Key1 = 0, Key2 = 0;
        for(DWORD i=0;i<Anim->m_NumRotationKeys;i++) {
          if(Time >= Anim->m_RotationKeys[i].m_Time)
            Key1 = i;
        }

        // Get 2nd key number
        Key2 = (Key1>=(Anim->m_NumRotationKeys-1))?Key1:Key1+1;

        // Get difference in keys' times
        DWORD TimeDiff = Anim->m_RotationKeys[Key2].m_Time-
                         Anim->m_RotationKeys[Key1].m_Time;
        if(!TimeDiff)
          TimeDiff = 1;

        // Calculate a scalar value to use
        float Scalar = (float)(Time - Anim->m_RotationKeys[Key1].m_Time) / (float)TimeDiff;

        // slerp rotation values
        D3DXQUATERNION quatRotation;
        D3DXQuaternionSlerp(&quatRotation,
                            &Anim->m_RotationKeys[Key1].m_quatKey,
                            &Anim->m_RotationKeys[Key2].m_quatKey,
                            Scalar);

        // Create rotation matrix and combine with transformation
        D3DXMATRIX matRotation;
        D3DXMatrixRotationQuaternion(&matRotation, &quatRotation);
        Anim->m_Bone->TransformationMatrix *= matRotation;
      }

      // Translation
      if(Anim->m_NumTranslationKeys && Anim->m_TranslationKeys) {

        // Loop for matching translation key
        DWORD Key1 = 0, Key2 = 0;
        for(DWORD i=0;i<Anim->m_NumTranslationKeys;i++) {
          if(Time >= Anim->m_TranslationKeys[i].m_Time)
            Key1 = i;
        }

        // Get 2nd key number
        Key2 = (Key1>=(Anim->m_NumTranslationKeys-1))?Key1:Key1+1;

        // Get difference in keys' times
        DWORD TimeDiff = Anim->m_TranslationKeys[Key2].m_Time-
                         Anim->m_TranslationKeys[Key1].m_Time;
        if(!TimeDiff)
          TimeDiff = 1;

        // Calculate a scalar value to use
        float Scalar = (float)(Time - Anim->m_TranslationKeys[Key1].m_Time) / (float)TimeDiff;

        // Calculate interpolated vector values
        D3DXVECTOR3 vecPos = Anim->m_TranslationKeys[Key2].m_vecKey - 
                             Anim->m_TranslationKeys[Key1].m_vecKey;
        vecPos *= Scalar;
        vecPos += Anim->m_TranslationKeys[Key1].m_vecKey;

        // Create translation matrix and combine with transformation
        D3DXMATRIX matTranslation;
        D3DXMatrixTranslation(&matTranslation, vecPos.x, vecPos.y, vecPos.z);
        Anim->m_Bone->TransformationMatrix *= matTranslation;
      }

      // Matrix
      if(Anim->m_NumMatrixKeys && Anim->m_MatrixKeys) {
        // Loop for matching matrix key
        DWORD Key1 = 0, Key2 = 0;
        for(DWORD i=0;i<Anim->m_NumMatrixKeys;i++) {
          if(Time >= Anim->m_MatrixKeys[i].m_Time)
            Key1 = i;
        }

        // Get 2nd key number
        Key2 = (Key1>=(Anim->m_NumMatrixKeys-1))?Key1:Key1+1;

        // Get difference in keys' times
        DWORD TimeDiff = Anim->m_MatrixKeys[Key2].m_Time-
                         Anim->m_MatrixKeys[Key1].m_Time;
        if(!TimeDiff)
          TimeDiff = 1;

        // Calculate a scalar value to use
        float Scalar = (float)(Time - Anim->m_MatrixKeys[Key1].m_Time) / (float)TimeDiff;

        // Calculate interpolated matrix
        D3DXMATRIX matDiff = Anim->m_MatrixKeys[Key2].m_matKey - 
                             Anim->m_MatrixKeys[Key1].m_matKey;
        matDiff *= Scalar;
        matDiff += Anim->m_MatrixKeys[Key1].m_matKey;

        // Combine with transformation
        Anim->m_Bone->TransformationMatrix *= matDiff;
      }
    }

    // Go to next animation
    Anim = Anim->m_Next;
  }
}