关于影响蒙皮动画的几个矩阵的研究

dx实现了.x文件的加载，播放动画，但是都是对外只是提供了接口供大家调用，这样对于理解动画是如何播放的，在播放动画期间矩阵是如何影响动画效果的都成为了谜底，程序员，尤其是window平台的程序员，只要想学好用好任何一门语言，都必须首先成为了一个猜谜高手，想尽一切办法要把微软是怎么实现的，给猜透了，只有这样才能成为真正的专家，高手！

 

不过在学习dx动画的时候，市面上有一些书籍是讲底层实现原理的，并且用代码例子的形式重新实现了微软的功能，对于大家理解底层是大大有所帮助的，这里我感觉<<Advanced.Animation.with.DirectX>>重庆大学出版社出版，这本书简直把微软的dx动画给讲透了，读来受益匪浅！学dx的.x动画，这一本书足够！

 

但是学习dx的.x动画只是学习之用，理解概念之用，因为市面上现有的游戏动画，都没有超出这个动画理念的范畴，对于学习动画的原理确确实实很有益处，但是除此之外，确实没有大用，几乎所有的网游公司都是借用了现有的游戏引擎去开发，没有一家游戏引擎是采用.x作为动画的文件格式，所以对于.x懂了，会用了，即可，实际工作可以结合你公司所采用的游戏引擎去开发动画！

 

但是你学习dx又必须学习.x,有几个矩阵要搞清楚:（这里只谈蒙皮动画）

1、frame中的原始矩阵 组合矩阵

2、skinweights中的偏移矩阵

3、animationset中的关键帧矩阵

下面研究这几个矩阵是如何组合运用的:

结合dx高级动画这本书的例子研究:

int PASCAL WinMain(HINSTANCE hInst, HINSTANCE hPrev, LPSTR szCmdLine, int nCmdShow){  WNDCLASSEX wcex;  MSG        Msg;  HWND       hWnd;

  // Initialize the COM system  CoInitialize(NULL);

  // Create the window class here and register it  wcex.cbSize        = sizeof(wcex);  wcex.style         = CS_CLASSDC;  wcex.lpfnWndProc   = WindowProc;  wcex.cbClsExtra    = 0;  wcex.cbWndExtra    = 0;  wcex.hInstance     = hInst;  wcex.hIcon         = LoadIcon(NULL, IDI_APPLICATION);  wcex.hCursor       = LoadCursor(NULL, IDC_ARROW);  wcex.hbrBackground = NULL;  wcex.lpszMenuName  = NULL;  wcex.lpszClassName = g_szClass;  wcex.hIconSm       = LoadIcon(NULL, IDI_APPLICATION);  if(!RegisterClassEx(&wcex))    return FALSE;

  // Create the main window  hWnd = CreateWindow(g_szClass, g_szCaption,              WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX,              0, 0, 640, 480,              NULL, NULL, hInst, NULL);  if(!hWnd)    return FALSE;  ShowWindow(hWnd, SW_NORMAL);  UpdateWindow(hWnd);

  // Call init function and enter message pump  if(DoInit(hWnd) == TRUE) {

    // Start message pump, waiting for user to exit    ZeroMemory(&Msg, sizeof(MSG));    while(Msg.message != WM_QUIT) {      if(PeekMessage(&Msg, NULL, 0, 0, PM_REMOVE)) {        TranslateMessage(&Msg);        DispatchMessage(&Msg);      }

      // Render a single frame      DoFrame();    }  }

  // Call shutdown  DoShutdown();   // Unregister the window class  UnregisterClass(g_szClass, hInst);

  // Shut down the COM system  CoUninitialize();

  return 0;}

BOOL DoInit(HWND hWnd){  // Initialize Direct3D  InitD3D(&g_pD3D, &g_pD3DDevice, hWnd);

  // Load a skeletal mesh  LoadMesh(&g_Mesh, &g_Frame, g_pD3DDevice, "..//Data//tiny.x", "..//Data//"); 

  // Load an animation collection  g_Anim.Load("..//Data//tiny.x");

  // Map the animation to the frame hierarchy  g_Anim.Map(g_Frame);

  // Load the guide texture and create the sprite interface  D3DXCreateTextureFromFileEx(g_pD3DDevice, "..//Data//Guide.bmp",                               D3DX_DEFAULT, D3DX_DEFAULT, D3DX_DEFAULT, 0,                              D3DFMT_A1R5G5B5, D3DPOOL_DEFAULT, D3DX_DEFAULT,                               D3DX_DEFAULT, 0xFF000000,                              NULL, NULL, &g_GuideTexture);  D3DXCreateSprite(g_pD3DDevice, &g_Guide);

  // Clear toggles  memset(g_BlendFlags, 1, 5);

  return TRUE;}

 

void DoFrame(){  static DWORD StartTime = timeGetTime();  DWORD ThisTime = timeGetTime();

  // Clear the frames' transformation matrices  if(g_Frame)    g_Frame->Reset();

  // Blend the animations  if(g_BlendFlags[0])    g_Anim.Blend("left_arm",  (ThisTime-StartTime), TRUE);  if(g_BlendFlags[1])    g_Anim.Blend("right_arm", (ThisTime-StartTime), TRUE);  if(g_BlendFlags[2])    g_Anim.Blend("left_leg",  (ThisTime-StartTime), TRUE);  if(g_BlendFlags[3])    g_Anim.Blend("right_leg", (ThisTime-StartTime), TRUE);  if(g_BlendFlags[4])    g_Anim.Blend("body",      (ThisTime-StartTime), TRUE);

  // Rebuild the frame hierarchy transformations  if(g_Frame)    g_Frame->UpdateHierarchy();

  // Build the skinned mesh  UpdateMesh(g_Mesh);

  // Calculate a view transformation matrix  D3DXMATRIX matView;  D3DXMatrixLookAtLH(&matView,                     &D3DXVECTOR3(600.0f, 200.0f, -600.0f),                     &D3DXVECTOR3(0.0f, 0.0f, 0.0f),                     &D3DXVECTOR3(0.0f, 1.0f, 0.0f));  g_pD3DDevice->SetTransform(D3DTS_VIEW, &matView);

  // Set a world transformation  D3DXMATRIX matWorld;  D3DXMatrixIdentity(&matWorld);  g_pD3DDevice->SetTransform(D3DTS_WORLD, &matWorld);

  // Clear the device and start drawing the scene  g_pD3DDevice->Clear(NULL, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_RGBA(0,0,64,255), 1.0f, 0);  if(SUCCEEDED(g_pD3DDevice->BeginScene())) {

    // Render skinned mesh    DrawMesh(g_Mesh);

    // Draw the guide    //g_Guide->Draw(g_GuideTexture, NULL, NULL, NULL, 0.0f, &D3DXVECTOR2(0.0f, 0.0f), 0xFFFFFFFF);

 g_Guide->Draw(g_GuideTexture, NULL, &D3DXVECTOR3(0.0f, 0.0f,0.0f), &D3DXVECTOR3(0.0f, 0.0f,0.0f), 0xFFFFFFFF);

    // End the scene    g_pD3DDevice->EndScene();  }

  // Present the scene to the user  g_pD3DDevice->Present(NULL, NULL, NULL, NULL);}

 

 

void cBlendedAnimationCollection::Blend(                      /                         char *AnimationSetName,              /                         DWORD Time, BOOL Loop,               /                         float Blend){  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      D3DXMATRIX matAnimation;      D3DXMatrixIdentity(&matAnimation);

      // 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);        matAnimation *= 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);        matAnimation *= 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);        matAnimation *= 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        matAnimation *= matDiff;      }

      // Get the difference in transformations       D3DXMATRIX matDiff = matAnimation - Anim->m_Bone->matOriginal;

      // Adjust by blending amount      matDiff *= Blend;

      // Add to transformation matrix      Anim->m_Bone->TransformationMatrix += matDiff;    }

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

blend函数的作用是通过读取关键帧中的矩阵进行插值得到

 

// 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        matAnimation *= matDiff;      }

      // Get the difference in transformations       D3DXMATRIX matDiff = matAnimation - Anim->m_Bone->matOriginal;

      // Adjust by blending amount      matDiff *= Blend;//用偏移量矩阵乘以混合系数

      // Add to transformation matrix      Anim->m_Bone->TransformationMatrix += matDiff;//frame的本地矩阵加上混合矩阵

 

以上函数的执行表明动画播放到了当前时间，因为先用animationset中的关键帧矩阵去混合，这样说明动画是在原地播放的，播放动画就是改变frame的以mesh的根节点为世界坐标系的本地矩阵，这里的功能相当于 

//if (m_bPlayAnim && m_pAnimController != NULL) // m_pAnimController->AdvanceTime( fElapsedAppTime, NULL );

 

  // Function to combine matrices in frame hiearchy  void UpdateHierarchy(D3DXMATRIX *matTransformation = NULL)  {    D3DXFRAME_EX *pFramePtr;    D3DXMATRIX matIdentity;

    // Use an identity matrix if none passed    if(!matTransformation) {      D3DXMatrixIdentity(&matIdentity);      matTransformation = &matIdentity;    }

    // Combine matrices w/supplied transformation matrix    matCombined = TransformationMatrix * (*matTransformation);

    // Combine w/sibling frames    if((pFramePtr = (D3DXFRAME_EX*)pFrameSibling))      pFramePtr->UpdateHierarchy(matTransformation);

    // Combine w/child frames    if((pFramePtr = (D3DXFRAME_EX*)pFrameFirstChild))      pFramePtr->UpdateHierarchy(&matCombined);  }

更新frame的组合矩阵

/////// Update a skinned mesh/////HRESULT UpdateMesh(D3DXMESHCONTAINER_EX *pMesh){  // Error checking  if(!pMesh)    return E_FAIL;  if(!pMesh->MeshData.pMesh || !pMesh->pSkinMesh || !pMesh->pSkinInfo)    return E_FAIL;  if(!pMesh->pBoneMatrices || !pMesh->ppFrameMatrices)    return E_FAIL;

  // Copy the bone matrices over (must have been combined before call DrawMesh)  for(DWORD i=0;i<pMesh->pSkinInfo->GetNumBones();i++) {

    // Start with bone offset matrix    pMesh->pBoneMatrices[i] = (*pMesh->pSkinInfo->GetBoneOffsetMatrix(i));

    // Apply frame transformation    if(pMesh->ppFrameMatrices[i])      pMesh->pBoneMatrices[i] *= (*pMesh->ppFrameMatrices[i]);  }

  // Lock the meshes' vertex buffers  void *SrcPtr, *DestPtr;  pMesh->MeshData.pMesh->LockVertexBuffer(D3DLOCK_READONLY, (void**)&SrcPtr);  pMesh->pSkinMesh->LockVertexBuffer(0, (void**)&DestPtr);

  // Update the skinned mesh using provided transformations  pMesh->pSkinInfo->UpdateSkinnedMesh(pMesh->pBoneMatrices, NULL, SrcPtr, DestPtr);

  // Unlock the meshes vertex buffers  pMesh->pSkinMesh->UnlockVertexBuffer();  pMesh->MeshData.pMesh->UnlockVertexBuffer();

  // Return success  return S_OK;}

 

偏移矩阵乘以父矩阵的组合矩阵，代表先把骨骼放置到原点下，然后再放置到mesh模型下的相应位置

接下来就可以绘制了

 

/////// Draw mesh functions/////HRESULT DrawMesh(D3DXMESHCONTAINER_EX *pMesh){  IDirect3DDevice9 *pD3DDevice;  DWORD LastState, OldAlphaState, OldSrcBlend, OldDestBlend;

  // Error checking  if(!pMesh)    return E_FAIL;  if(!pMesh->MeshData.pMesh)    return E_FAIL;  if(!pMesh->NumMaterials || !pMesh->pMaterials)    return E_FAIL;

  // Get the device interface  pMesh->MeshData.pMesh->GetDevice(&pD3DDevice);

  // Release vertex shader if being used  pD3DDevice->SetVertexShader(NULL);  pD3DDevice->SetVertexDeclaration(NULL);

  // Save render states  pD3DDevice->GetRenderState(D3DRS_ALPHABLENDENABLE, &OldAlphaState);  pD3DDevice->GetRenderState(D3DRS_SRCBLEND, &OldSrcBlend);  pD3DDevice->GetRenderState(D3DRS_DESTBLEND, &OldDestBlend);  LastState = OldAlphaState;

  // Setup pointer for mesh to draw, either regular or skinned  ID3DXMesh *pDrawMesh = (!pMesh->pSkinMesh)?pMesh->MeshData.pMesh:pMesh->pSkinMesh;

  // Look through all subsets  for(DWORD i=0;i<pMesh->NumMaterials;i++) {

    // Set material and texture    pD3DDevice->SetMaterial(&pMesh->pMaterials[i].MatD3D);    pD3DDevice->SetTexture(0, pMesh->pTextures[i]);

    // Enable or disable alpha blending per material    if(pMesh->pMaterials[i].MatD3D.Diffuse.a != 1.0f) {      if(LastState != TRUE) {        LastState = TRUE;        pD3DDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);        pD3DDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_ONE);//SRCCOLOR);        pD3DDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_DESTCOLOR);      }    } else {      if(LastState != FALSE) {        LastState = FALSE;        pD3DDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);      }    }

    // Draw the mesh subset    pDrawMesh->DrawSubset(i);  }

  // Restore alpha blending states  if(LastState != OldAlphaState) {    pD3DDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, OldAlphaState);    pD3DDevice->SetRenderState(D3DRS_SRCBLEND, OldSrcBlend);    pD3DDevice->SetRenderState(D3DRS_DESTBLEND, OldDestBlend);  }

  // Make sure to release the device object!  pD3DDevice->Release();

  // Return success  return S_OK;}

 

 animationset中的是相对于frame中的原始矩阵的一系列插值矩阵，skinweights中的矩阵是把他偏移回原点，然后乘以父矩阵就又放置到了mesh下，跟模型相连接，这样就能完成一系列的动画效果！如果改变了animationset的话，就切换到了新的动画效果，理论上动画效果可以无限，在共用一份meshcontainer的情况下，真是爽耶！

 

skinweights中的顶点的blend权重，由dx内部执行混合！