struct sSkinData
{
     int  NumWVertexs;                                                        // 가중치 개수
     float Weight[NUM_WVERTEX];                                       // 가중치
     cFrame* pBone[NUM_WVERTEX];                                 // 본
};

하나의 Vertex가 가지고 있는 가중치 정보다.
최대 4개의 본에 영향을 받고, 각각의 본에 대한 가중치값을 가지고 있다.

SkinData를 적용시키는 함수를 살펴보자

void cModel::ApplySkinData()
{
     m_pRoot->ApplySkinData();
}

// 스키닝 데이터 적용
void cFrame::ApplySkinData()
{
 int NumSkinData = m_vecSkinList.size();

 if(NumSkinData > 0)
  CalcWeight();

 if(m_pChild)
  m_pChild->ApplySkinData();

 if(m_pNext)
  m_pNext->ApplySkinData();

}

간단하다 이게 전부다. 루트노드로터 자식, 형제노드를 내려가면서 재귀함수를
호출하는 것이다. 다만 이 노드가 SkinData가 있는 Mesh노드일경우에만 한한다.
이렇게 되면 쓸데없는 BoneNode들도 일단 트리를 타는 단점이 있지만 옛날 코드라
일단 넣어놨다.

CalWeight()라는 함수의 내부를 보자.
지금 이 방식은 Skinning의 세가지 방법. 즉, 소프트웨어적 방식, 메트릭스 팔레트 사용,
정점셰이더 방식 중 소프트웨어적 방식을 사용했다.

 D3DXVECTOR3 vPos;
 D3DXVECTOR3 vTemp;

 for(int i = 0; i < NumSkinData; ++i)    // 해당 Mesh 노드의 Vertex개수와 같은 크기
 {

  vPos = m_pMesh->m_pDumpMesh->m_vecPos[i];
   int NumBlend = m_vecSkinList[i]->NumWVertexs;

  // 영향을 주는 Bone의 개수
  // 개수가 1개라면 가중치는 1.0f 이다.

  for(int k = 0; k < NumBlend; ++k)      
  {
       cFrame* pBone = m_vecSkinList[i]->pBone[k];   
       float  weight = m_vecSkinList[i]->Weight[k];

       if(pBone)
       {
            D3DXVec3TransformCoord(&vTemp, &vPos,  &pBone->m_OffsetTM);  --> 1
            D3DXVec3TransformCoord(&vTemp, &vTemp, &pBone->m_WorldTM); --> 2

            globalPosList[i] += (vTemp * weight);   --> 3

       }
  }
 }

Vertex를 돌면서 각각의 버텍스에 가중치 계산을 해서 결국 최종 버텍스 위치를 구해주면
되는것이다.

1) Vertex를 Bone의 에니메이션되지 않은 Offset위치로 옮겨주는(살을 뼈에 붙인다는 의미로 보면 되겠다) 개념
2) Vertex에 에니메이션 된 최종 WorldTM을 계산해준다. 즉 Bone의 최종 위치로 이동
3) 하지만 가중치만큼을 곱해줘 그 본의 가중치 만큼을 곱해줘 그만큼만 영향을 받게 해준다.
4) 이것을 가중치개수만큼 반복해 누적시켜 최종 Vertex의 위치를 구해준다.

구현 당시 꽤 어려웠던 개념이었던 것에 비해 식이 간단하다. 하지만 이해하지 못하고 쓰는 지식은
죽은 지식이므로 꼭 확실이 이해하고 쓰는게 좋다.

 // 초기 부모 노드와의 상대적인 위치를 나타내는 m_OriginTM 을 얻는다.
 D3DXMATRIX mat = m_pFrame->m_OriginTM;

 if(m_RotAnim) 
 {
  D3DXQUATERNION rot = m_RotAnim->GetSLerpValueByTime(time);

  D3DXMATRIX m;
  D3DXMatrixRotationQuaternion(&m, &rot);

  mat._11 = m._11, mat._12 = m._12, mat._13 = m._13; 
  mat._21 = m._21, mat._22 = m._22, mat._23 = m._23;
  mat._31 = m._31, mat._32 = m._32, mat._33 = m._33;
 }

 if(m_PosAnim)
 {
  D3DXVECTOR3 pos = m_PosAnim->GetLerpValueByTime(time);

  mat._41 = pos.x,
  mat._42 = pos.y,
  mat._43 = pos.z; 
 }

 // 에니메이션 된 TM 값을 m_LocalTM 에 저장
 m_pFrame->m_LocalTM = mat;
}

해당 에니메이션 트랙이 없을 경우를 위해 AnimationTM에 OriginTM을 일단 넣어준다.
Pos트랙이 있을 경우 보간하여 얻은 위치벡터를 AnimationTM의 41,42,43에 넣어준다.
Rot트랙이 있을경우도 같은 방법으로 11~33까지 넣어준다.

왜 행렬의 위의 인자에 넣어주는지는 다들 알 것이다.
다만 Pos의 경우는 Lerp보간을, Rot의 경우에는 SLerp 보간을 해주는 차이가 있을 뿐이다.

해서 우리가 최종적으로 구하는 WorldTM을 구해보면
WordTM = LocalTM(Animation된 LocalTM) * ParentTM
이 된다.

보통 루트는 단위행렬이 곧 월드 행렬이 되므로

void Animate()
{
     D3DXMATRIX m;
     D3DXMatrixIdentity(&m);

     m_pRoot->SetupWorldMatrix(&m);
}

이고 내부의 함수를 들어다 보면 재귀호출을 하는 함수인걸 알수 있다.

void cFrame::SetupWorldMatrix( const D3DXMATRIX* pParentWorldTM )
{
     D3DXMatrixMultiply( &m_WorldTM, &m_LocalTM, pParentWorldTM );

 
    if(m_pChild)
          m_pChild->SetupWorldMatrix(&m_WorldTM);

 
    if(m_pNext)
          m_pNext->SetupWorldMatrix(pParentWorldTM);
}

이렇게 된다. 루트부터 시작해서 자식노드, 형제 노드를 거쳐 모든 BoneNode들의
WorldTM이 계산되게 된다.

 enum FrameType { TYPE_NONE, TYPE_MESH, TYPE_BONE,};
 FrameType m_Type;

 // 노드 이름
 char m_Name[MAX_PATH];
 // 부모노드의 이름
 char    m_ParentName[MAX_PATH];

 // 이 노드가 본루트인지 구별해놓기 위한 bool 변수

 bool      m_IsBoneRoot;

 // 익스포터를 ASE를 수정한 것이기 때문에 실제 익스포트되어 나오는 행렬값은
 // 이미 부모 행렬을 곱한 World행렬이 익스포트되어진다.
 // 에니메이션 할 경우 오프셋 행렬이 필요하기 때문에
 // 부모 행렬의 역행렬을 구해 노드의 Offset행렬을 미리 구해놓는다.

 
 D3DXMATRIX m_OffsetTM;  // nodeTM의 역행렬
 D3DXMATRIX m_LocalTM;  // 부모TM과 상대적인 위치(에니메이션TM계산된거)
                                         // 일단 Animation행렬이라고 보면 되겠다.
 D3DXMATRIX m_WorldTM;  // 최종 변환 TM(가변) 

 cMesh* m_pMesh;    // 메시(메시노드가 아닐 경우 NULL이다.)

 cFrame* m_pParent; // 부모 프레임 포인터
 cFrame* m_pPrev;
 cFrame* m_pNext; // 형제 프레임
 cFrame* m_pChild; // 자식 프레임 

 // 마땅한 더미 노드가 없어서 손에서 나가는 마법이나 용에서 나가는 브레스를 위해
 // 비슷한 위치의 본노드를 찾아야했다.

 bool    m_bRightHand; // 이 노드가 오른손 노드인가?
 bool    m_bLeftHand;   // 이 노드가 왼손 노드인가? 
 bool    m_bHead;        // 이 노드가 머리 노드인가?

 // 스키닝 정보
 // 다른 Bone 프레임등의 정보에 접근해야 하기 때문에
 // cMesh가 아닌 cFrame에 있는 것이 편할거 같다.

 // Skinning 모델일 경우 당연히 Mesh Node에 있는 스킨데이터
 // 당연히 정점의 개수와 같은 크기가 나와야 할 것이다.

 int m_nNumSkinData;    
 sSkinData* m_vecSkinList;

public:
 cFrame(void);
 ~cFrame(void);

 HRESULT Destroy();

 // 각 스킨데이터들이 본 이름만 가지고 있기 때문에 이름으로 본을 찾으면
 // 부하가 많이 걸린다. 그래서 본 포인터를 연결시켜준다.
 // 이 프레임이 루트 프레임일 경우에 쓰는 함수이다.
 void LinkBoneToSkinData();
 
 // 스킨 데이터 적용(가중치 적용)
 void CalcWeight();
 void ApplySkinData();

 void AttachSibling(cFrame* pFrame);
 void AttachChild(cFrame* pFrame);

 cFrame* FindRoot();      // 루트 프레임 찾기
 cFrame* FindFrame(char* strFrameName); // 현재 프레임 밑으로 이름으로 프레임 찾기
 cFrame* FindLHandFrame();
 cFrame* FindRHandFrame();
 cFrame* FindHeadFrame();

 void SetupWorldMatrix(const D3DXMATRIX* pParentWorldTM);
 void Update();
 void Render();

};

자 이것이 앞서 본 schematic view에서 본 노드들을 코드화 한 것이다.
그렇다면 모델은 무엇만 가지고 있음 되는가 하면

class cModel
{
    protected:
        cFrame* m_pRootFrame; 
    ..........이하 생략 .....
};

그렇다. m_pRootFrame(루트노드)만 가지고 있으면 되는것이다.
트리구조로 노드들을 구성해놓았기 때문에 모델은 루트노드의 포인터만
가지고 있음 되는 것이다.