一、骨骼動畫、關節動畫、關鍵幀動畫
　　在實際的遊戲中，用得較多的是這三種基本的動畫。

　　在關鍵幀動畫中，模型在每個關鍵幀中都是一個（gè）固定的姿勢，相當於一個“快（kuài）照”，通過在（zài）不同（tóng）的關鍵幀中（zhōng）進行（háng）插值平（píng）滑（huá）計算（suàn），可以得到（dào）一個（gè）較為流暢的動畫表現。關鍵（jiàn）幀動畫的一個優勢是隻需要做插值計（jì）算，相對於其他的動（dòng）畫（huà）計算量很小，但（dàn）是劣（liè）勢也比（bǐ）較明顯，基於固（gù）定的“快照”進（jìn）行插值計算，表現大大被限製（zhì），同時插值如果不夠平滑容（róng）易出現尖刺等現象。

　　關節動畫是早期出現的一種動畫，在這種動畫（huà）中，模型整體不是一個Mesh, 而是分為多個Mesh，通過父子（zǐ）的關係進行組織，這樣（yàng）父節點的Mesh就會帶動子節點的Mesh進行變換，這樣層層的變換（huàn）關係，就可以得到各個子Mesh在不同（tóng）關鍵幀（zhēn）中的位置。關節動畫相比於關鍵幀動畫，依賴於（yú）各（gè）個關鍵幀的動畫（huà）數據，可（kě）以實時的計算出各個Mesh的位置，不再受限（xiàn）於固定的位置，但（dàn）是（shì）由（yóu）於是分散的各個Mesh，這樣在不同Mesh的結合處（chù）容易出（chū）現（xiàn）裂縫。
　　骨（gǔ）骼動畫是（shì）進一步的動（dòng）畫類型，原理構成很其簡單，但是解決問題很其（qí）有優勢。將模型分（fèn）為（wéi）骨骼Bone和蒙皮Mesh兩個部分，其基本的原理（lǐ）可以闡述為：模型的骨（gǔ）骼可分為基本多（duō）層父子骨骼，在動畫關鍵（jiàn）幀數據的驅動（dòng）下，計算出各（gè）個父子骨骼的位置，基於骨骼的（de）控製通過頂點混合動態計算出（chū）蒙皮網格的頂點。在骨骼動畫中，通常包含的是骨骼層次數據，網格Mesh數據， 網格蒙皮數據Skin Info和骨骼的動畫關鍵幀數據。
一、骨骼（gé）動畫、關節動畫、關鍵幀動畫
　　在實際的遊戲中，用得多的是（shì）這（zhè）三種基本的動畫（huà）。
　　在關鍵幀動畫中，模型在每個關鍵幀中都是一個固定的姿勢，相當於一個“快照”，通過在不同的關鍵幀中進行插值平（píng）滑計算，可以得到一個較為流暢的（de）動（dòng）畫表現。關鍵幀動畫（huà）的一（yī）個優勢是隻需要做插值計算（suàn），相對於其（qí）他的動畫計算量很小，但是劣勢也比較（jiào）明顯，基於固定的“快照”進行插值計算，表現大大被限製，同時插值如（rú）果不夠平滑容易出現尖刺等現（xiàn）象（xiàng）。
　　關節動畫是早期出現的一（yī）種動畫，在這種動（dòng）畫（huà）中，模型整（zhěng）體不是一個Mesh, 而是分為多個Mesh，通過父子的關係進行組織，這樣父節點的Mesh就會帶動子（zǐ）節點的（de）Mesh進行變換，這樣層層的變換關係，就可以得到各個子Mesh在不同關鍵幀中的位置。關節動畫相比於關（guān）鍵幀動畫，依賴於各個關（guān）鍵幀的動（dòng）畫（huà）數據，可（kě）以實時的計算出各個Mesh的位置，不再受限於固定的位（wèi）置，但是由（yóu）於是（shì）分散的各個Mesh，這樣在不同Mesh的結合處容易出現裂縫。
　　骨骼動畫是進一步的（de）動畫類型，原理構成很其簡單，但是解決問題很（hěn）其有優勢。將模型分為骨（gǔ）骼Bone和蒙皮Mesh兩（liǎng）個部分，其基本的原理可以闡述為：模型的骨骼可分為基本多層父（fù）子骨骼（gé），在動畫關鍵幀數據的驅動下，計算出各個父子骨骼的位置，基於骨骼的控製通過頂點混合動態計算出蒙皮網格的頂點。在骨骼動畫中，通常包（bāo）含的是骨骼層次數據，網格Mesh數據， 網格蒙皮數據Skin Info和（hé）骨骼的動畫關鍵幀數據（jù）。

class Bone
{
   Bone* m_pFirstChild;  
   Bone* m_pSibling;
   float m_x, m_y, m_z; // pos in parents' space
   float m_wx, m_wy, m_wz; // pos in world space
  //
  public:
  Bone(float x, float y, float z): m_pSibling(NULL),m_pFirstChild(NULL),m_pFather(NULL),m_x(x), m_y(y), m_z(z){}  //
  void SetFirstChild(Bone* pChild)
  {
      m_pFirstChild = pChild;
      m_pFirstChild->m_pFather = this;
  }
  //
   void SetSibling(Bone* pSibling)
   {
      m_pSibling = pSibling;
      m_pSibling->m_pFather = m_pFather;
    }
}

這樣（yàng），當父（fù）節點骨骼發生變（biàn）換（huàn）的時候，子節（jiē）點的骨（gǔ）骼就會做相應（yīng）的變換，這樣的操作可以稱（chēng）為（wéi） UpdateBoneMatrix，這（zhè）樣的操（cāo）作可以用一個方法ComputeWorldPos來表示，這樣可以用遞歸的方式在Bone中實現：

class Bone
{
    void ComputeWorldPos(float fatherX, float fatherY, float fatherZ)
    {
         m_wx = fatherX + m_x;
         m_wy = fatherY + m_y;
         m_wz = fatherZ + m_z;
        //兄弟節點用父節點傳遞（dì）的參數
        if(m_pSibling ！=NULL)
             m_pSibling ->ComputeWorldPos(fatherX, fatherY, fatherZ)
        if(m_pFirstChild!=NULL)
             m_pFirstChild ->ComputeWorldPos(m_wx, m_wy, m_wz)
    }
}

　這樣，當父節點骨骼發生變換的（de）時（shí）候，子節點（diǎn）的（de）骨骼都會做出（chū）相應的變換，從而得到新的位置、朝向等信（xìn）息，骨骼發生變化，從（cóng）而（ér）會帶動外在的mesh發生變化，所以整（zhěng）體的模型就表現chu出運動起（qǐ）來。基於（yú）此，可以理解為什麽骨骼是骨骼動畫的核心。

2、骨骼動畫中的蒙皮

　　在說完骨（gǔ）骼後，對於整體模型在動畫中骨骼的變換，可以有一個大致的理解，當時模（mó）型隻是內在的，外在的表現是模型的蒙皮的變化，所以骨骼動畫中（zhōng）的第二（èr）部分就是蒙皮的計算。這裏的皮，就是前麵說過的Mesh。

　　首先，需要明（míng）確（què）的是Mesh所在的空間（jiān）。在建模的（de）時候，模型的Mesh是和（hé）骨（gǔ）骼一樣處於同樣的（de）空間中的，Mesh中的各個（gè）頂點是基於Mesh的原點來進行定（dìng）位的。但是模（mó）型在運動表現的時候，是根據骨骼（gé）的變換來做（zuò）相應的（de）動作的，對應的Mesh上的頂點就需要做出對應的轉（zhuǎn）換，所以Mesh的頂點需要轉換到對應的骨骼所在的坐標空間中，進行相應的位置變換（huàn），因此對應的需要添加蒙皮信息，也（yě）就是skin info，主要是當前頂點受到哪些骨骼（gé）的影響，影響的權重等，借用文章（zhāng）1的表（biǎo）述，可以用C++表示一個頂點類，代碼依據於文章1：

#define MAX_BONE_VERTEX 4
class Vertex
{
     float m_x, m_y, m_z; // local pos in mesh space
     float m_wx, m_wy, m_wz; // pos in world space
     //skin info
     int m_boneNum;
     Bone* m_bones[MAX_BONE_VERTEX];
     float m_boneWeights[MAX_BONE_VERTEX];
}

    當然，這兒隻是一個簡單的表述，具體的在引擎中會有規範（fàn）的設計。那麽我們的（de）頂點在跟隨骨骼（gé）做（zuò）運動的時候（hòu），是如何計算自（zì）己的（de）位置（zhì）的？我（wǒ）們就需要引入BoneOffsetMatrix 和 Transform Matrix的概念。
     在前麵，我們已經提到，頂點需要依（yī）附於骨骼進行（háng）位置（zhì）計算，但是建模的（de）時候，頂點的位置是基於Mesh原點進行建模的（de），通常情況（kuàng）下，Mesh的原點是和模型的骨骼的（de）根骨骼處於同一個坐標空間中，那（nà）麽 BoneOffsetMatrix就是用來將Mesh中頂點從Mesh空間轉換到骨骼所在空間中。
　　在建模的時（shí）候，對於每個骨骼，我們是可以得到其對應的Transform Matrix（用來層層（céng）計算到父節點所在空間中（zhōng）），其中根骨骼的Transform Matrix是基於世界（jiè）空間的（de）轉換，所以（yǐ）對於每一個下麵的子骨（gǔ）骼，要計算其Transform Matrix，需要進行一個矩陣的連（lián）乘操（cāo）作。*後得到（dào）的*終矩陣連乘結果矩陣就是Combined Transform Matrix，基於這個矩陣，就可以將頂點從骨骼所在的空間轉換到（dào）世界空間中。反過來（lái），這個（gè）矩陣的逆矩陣（一般隻（zhī）考慮可（kě）以取逆的操作），就是從世界空間中轉換到該骨骼的（de）空間中，由於Mesh的定（dìng）義基於Mesh原點，Mesh原（yuán）點就在世界空間中，所以這個逆矩（jǔ）陣就是（shì）要求的 Offset Matrix，也被稱為Inverse Matrix，這個逆矩陣一般實在（zài）初始位置中求得（dé），通（tōng）過取（qǔ）逆即（jí）可獲得。
　　在實際的計算中，每個骨骼可（kě）能會對應多個頂點，如果每個頂點都保存其對應的骨骼的變換矩陣，那麽大量的頂點就會報錯比較多的變換矩陣。所以我們隻需要保存當前該骨（gǔ）骼（gé）在初始位置，對（duì）應的從世界空間（jiān）到（dào）其骨骼空間的變（biàn）換矩陣，那麽其對應的每個頂（dǐng）點在每次（cì）變換操作的時候，隻需要對應的用offset Matrix來操作（zuò）即可。
      對於上麵的Transform Matrix和offset Matrix，是納入了旋轉、平移和縮放的。其實offset Matrix取決於骨骼（gé）的初始位置（zhì），此時一般隻包含了（le）平移（此（cǐ）時還沒有動畫，所以沒有旋（xuán）轉（zhuǎn）和縮放），在動畫中（zhōng），一（yī）般也以縮放為主（所以大部分的動畫的關鍵幀用四元（yuán）數表（biǎo）示）。在矩陣中都包含（hán），是處於兼容性考慮。
　　這兒就基於平移，做一個基本的蒙皮的計（jì）算過程：

class BoneOffset
{
 public:
    float m_offx, m_offy, m_offz; //暫時隻考慮平移（yí）
}class Bone
{
   public :
       BoneOffset* m_boneOffset;
      //
      void ComputeBoneOffset()
      {
           m_boneOffset.m_offx -= m_wx;
           m_boneOffset.m_offy -= m_wy;
           m_boneOffset.m_offz -= m_wz;            if(m_pSibling != NULL)
               m_pSibling->ComputeBoneOffset();
            if(m_pFirstChild !=NULL)
               m_pFirstChild->ComputeBoneOffset();
      }
}      //頂點類的計算
class Vertex
{
 public:
     void ComputeWorldPosByBone(Bone* pBone, float &outX, float& outy, float& outz)
    {
   //從mesh空間轉換到bone空間
       outx = m_x + pBone->m_boneOffset.m_offx;
       outy = m_y + pBone->m_boneOffset.m_offy;
       outz = m_z + pBone->m_boneOffset.m_offz;
 //從bone空間（jiān）轉換到世界空間
       outx += pBone->m_wx;
       outy += pBone->m_wy;
       outz += pBone->m_wz;
    }
    //GPU中（zhōng）計（jì）算頂（dǐng）點的位置
    void BlendVertex()
     ｛
       float m_wx = 0;
       float m_wy = 0;
       float m_wz = 0;
    
      for(int i=0; i < m_boneNum; i++)
       {
           float tx, ty,tz;           
           ComputeWorldPosByBone(m_bones[i], tx, ty,tz);            tx *= m_boneWeights[i];
            ty *= m_boneWeights[i];
            tz *= m_boneWeights[i];
  
            m_wx += tx;
            m_wy += ty;
            m_wz += tz;
        }
     ｝
}  

 仔（zǎi）細捋一捋上麵的代碼（mǎ），就可以理解整體的蒙皮變換的過程，當然，這兒隻用了矩陣變換中的平移變換，如果考慮加上旋轉和縮放，則回到*初的計算公式中了。至此（cǐ），對於基本的骨（gǔ）骼動畫中的骨骼變換和蒙皮變換（huàn），有了一（yī）個詳（xiáng）細的解釋（shì）。下麵說（shuō）說Unity中是如何處理（lǐ）骨骼變換的。
三、Unity3D骨骼動畫處理
 　　前麵講（jiǎng）解的對於骨骼動畫中的骨骼變換，蒙皮的計算，都是在CPU中進行的（de）。在實際的遊戲引擎中，這些都是分開處理的，較（jiào）為通用的處理是將骨骼的動畫數據驅動放在CPU中，計算出骨骼的變換矩陣，然後傳遞（dì）給GPU中進行蒙皮計算（suàn）。在DX10的時候，一般的shader給出的寄存器的（de）大小在128的大小，一個變換矩（jǔ）陣為4x4，如果去除*後一行(0,0,0,1)就（jiù）可以用3個float表示，那（nà）麽*多可以表示，嗯，42個左右，如果考慮（lǜ）進行性能優（yōu）化，不完全（quán）占用寄存器的大（dà）小，那麽一般會限製在30根骨骼的大小上。將這些骨骼的（de）變換矩陣在CPU進行計算後，就可以封（fēng）裝成skin info傳（chuán）遞到GPU中。
      在GPU的計（jì）算（suàn）中（zhōng），就會取出這些mesh上的頂點進（jìn）行對應的位置計算，基於骨骼（gé）的轉換矩陣和骨（gǔ）骼（gé）的權重，得到*新的位置，從（cóng）而進行一次頂點計算（suàn）和描繪。之所（suǒ）以將骨（gǔ）骼動畫的兩個部分分開處理，一個原因就是（shì）CPU的處理能力（lì）相對而言（yán）沒有GPU快捷，一（yī）般一個模型的骨骼數量是較小的，但（dàn）是mesh上的頂點數量較大，利用GPU的並行處理能力優勢，可以分擔CPU的計算壓力。
      在DX11還是DX12之後（記不太（tài）清楚），骨骼（gé）變換矩陣的計算結果不（bú）再（zài）存儲在（zài）寄存器（qì）中（zhōng），而是存儲在（zài）一個buffer中，這樣的buffer大小基於骨骼數量的大小在第一次計算的時候設定，之後每次骨骼動畫數據驅動得到新的變換矩陣，就依次更改對應的buffer中存儲的變換矩陣（zhèn），這樣就（jiù）不再受到寄存器（qì）的大小而限製骨骼的根數的大小。但是實際的優化中，都（dōu）會盡量優化模型的骨骼的數量，畢竟數量越多，*是影響頂點的骨骼（gé）數（shù）量越多，那（nà）麽計算量就會越大，正常的思維（wéi）是優化骨骼數（shù）量而不是去擴展buffer的大小：D
      在文章2中，對於GPU的蒙皮計算做了較大的性（xìng）能優化，主要的思維（wéi）也是這樣，在CPU中（zhōng）進行骨（gǔ）骼變換，將變換的結果傳遞到GPU中，從而進行蒙皮計算。基本的思維和前麵說的變換思維一致，其基本的優化重點也（yě）是想利（lì）用一個buffer來緩存變換矩陣，從而優化性（xìng）能。這兒我就重點分析一下shader部分（fèn）的代碼，其在cpu部分的代碼處（chù）理基本（běn）和前麵的代碼思想一致：
      如果采用CPU的計算骨骼變換，那麽（me）GPU的shader:

聲明： 本（běn）文轉自網（wǎng）絡, 不（bú）做盈利（lì）目的，如有侵權，請與我們聯係處理，謝謝。

uniform float4x4 _Matrices[24]; //設（shè）置的骨骼數量*大為24struct appdata
{
    float4 vertex:POSITION;
    float2 uv:TEXCOORD0;
   //存儲的就是骨骼的變換（huàn）矩陣，x/y為第一個骨骼的索引和權重，z/w為第二個的索引和（hé）權重
    float4 tangent:TANGENT;
}；v2f vert(appdata v)
{
    v2f o;
    //蒙皮計算位置,注（zhù）意看，其實就是矩（jǔ）陣變化加權重的表示
    float4 pos = 
    mul(_Matrices[v.tangent.x], v.vertex)* v.tangent.y +
    mul(_Matrices[v.tangent.z], v.vertex)* v.tangent.w
    //通用的mvp計算
    o.vertex = mul(UNITY_MATRIX_MVP, pos);
    o.uv  = TRANSFORM_TEX(v.uv, _MainTex);
    return o;
}//怎麽計（jì）算（suàn）index和權重,此處（chù）一（yī）個蒙皮頂點受到2根骨骼的影響
Vector4[] tangents = new Vector4[mesh.vertexCount];
for(int i=0; i < mesh.vertexCount;++i)
{
   BoneWeight boneWeight = mesh.boneWeights[i];
   tangents[i].x = boneWeight.boneIndex0;
   tangents[i].y = boneWeight.weight0;
   tangents[i].z = boneWeight.boneIndex1;
   tangents[i].w = boneWeight.weight1;
}newMesh.tangents = tangents;

其優化的策略（luè），就是用貼圖的方式來存儲這個變換矩陣，參看一下代碼吧：

inline float4 indexToUV(int index)
{
    int row = (int) (index /_MatricesTexSize.x);
    int col   = (index - row * _MatricesTexsize.x; 
    return float4(col/_MatricesTexSize.x, row/_MatricesTexSize.y, 0 , 0);
}
//算（suàn）出當前的變換矩陣
inline float4x4 getMatrix(int frameStartIndex, float boneIndex)
{
     int matStartIndex = frameStartIndex + boneIndex*3;
     float4 row0 = tex2Dlod(_MatricesTex, indexToUV(matStartIndx));
     float4 row1 = tex2Dlod(_MatricesTex, indexToUV(matStartIndx + 1));
     float4 row2 = tex2Dlod(_MatricesTex, indexToUV(matStartIndx + 2));
      float4 row3 = float4(0,0,0,0);
      float4x4 mat = float4x4(row0, row1, row2, row3);
      return mat;
}v2f vert(appdata v)
{
     v2f o;
      float time = _Time.y;
     //算出當前時間對應的index
     int framIndex = (int)(((_Time.y + v.uv2.x)*_AnimFPS)%(_AnimLength * _AnimFPS));
     int frameStartIndex = frameIndex * _MatricesTexFrameTexls;
     //去除對應的變換矩陣
     float4 mat0 = getMatrix(frameStartIndex, v.tangent.x);
     float4 mat1 = getMatrix(frameStartIndex, v.tangent.z);
   
     float4 pos =
        mul(mat0, v.vertex) * v.tangent,y + 
        mul(mat1, v.vertex) * v.tangent.w;
 
    o.vertex = mul(UNITY_MATRIX_MVP, pos);
    o.uv = TRANSFOR_TEX(v.uv, _MainTex);
    return o;
}