骨骼动画的实现

http://www.cppblog.com/lovedday/archive/2009/12/09/24729.html

http://www.cppblog.com/lovedday/archive/2008/06/11/52868.html

重点:
http://www.cppblog.com/lovedday/archive/2007/07/22/28595.html
http://www.cppblog.com/lovedday/archive/2008/04/22/47819.html 变换

具体是个什么样子原理尚不清楚，暂时放在这里，日后再详细写入

找了好久也没有找到合适的渲染代码，几处资料讲解的不够详细，以至于貌似冲突的样子。猜测下。

D3DMESHCONTAINER     A,B,C.....

D3DXFRAME    a1,a2,a3,a4,b1,b2.b3,........

虽然D3DXFRAME （框架骨骼）   中包含一个指向D3DMESHCONTAINER（容器）的指针，但貌似其并不是最顶层。A--->B---->C--->......, 也就是说容器作为一层，一个X文件可能形成几个容器结构，然后彼此通过指针串联起来。而每块骨骼都对应着某个容器，因此每个骨骼有一个指向容器的指针。而骨骼本身的层次则通过兄弟骨骼和子骨骼指针指向下去。当然里面也是一样子的。由此就可以解释了一个网格容器（MESH）当中，可能通过D3DXSKININFO 存储了多个骨骼的信息，一个X文件中可能有多个网格容器就是了。模型容器数据在某个数据对象当中，当然了数据对象有各种类型，通过类型可以判断是否为网格容器。

typedef struct _D3DXFRAME{                  //骨骼（框架）结构体

LPSTR Name;                         //骨骼名

D3DXMATRIX TransformationMatrix;    //相对于父骨骼坐标系的变换矩阵

LPD3DXMESHCONTAINER pMeshContainer; //网格容器

struct _D3DXFRAME* pFrameSibling;   //兄弟骨骼

struct _D3DXFRAME* pFrameFirstChild;//子骨骼

}D3DXFRAME,LPD3DXFRAME;

typedef struct _D3DMESHCONTAINER{           //网格容器结构体

LPSTR Name;                         //网格容器名

D3DXMESHDATA MeshData;              //网格数据

LPD3DMATERIAL pMaterials;          //网格材质

LPD3DXEFFECTINSTANCE pEffects;      //特效

DWORD NumMatrials;                  //材质数

DWORD* pAdjacency;                  //邻接三角形信息

LPD3DXSKININFO pSkininfo;           //蒙皮信息

struct _D3DMESHCONTAINER* pNextMeshContainer;      //下一个网格容器指针

}D3DMESHCONTAINER, *LPD3DMESHCONTAINER;

struct D3DXFRAME_DERIVED:public D3DXFRAME{ //骨骼（框架）扩展结构体

D3DXMATRIXA16 CombinedTransformationMatrix;        //动作变换矩阵

};

struct D3DMESHCONTAINER_DERIVED:public D3DMESHCONTAINER{   //网格容器扩展结构体

LPDIRECT3DTEXTURE9* ppTextures;     //纹理数组，如果没有纹理数组则为NULL

LPD3DXMESH pOrigMesh;               //原网格

LPD3DXATTRIBUTERANGE pAttributeTable;              //属性表

DWORD NumAttributeGroups;           //属性组个数

DWORD NumInfl;

LPD3DXBUFFER pBoneCombinationBuf;   //骨骼缓冲区

D3DXMATRIX** ppBoneMatrixPtrs;      //骨骼矩阵

D3DXMATRIX* pBoneOffsetMatrices;    //骨骼权重矩阵

DWORD NumPaletteEntries;

};

//在内存中创建一个Frame（纯虚函数，需要给出具体的实现细节）

virtual HRESULT ID3DXAllocateHierarchy::CreateFrame(

LPCSTR Name,                        //框架名

LPD3DXFRAME* ppNewFrame             //返回创建的Frame对象

)

//创建一个网格容器（纯虚函数，需要给出具体的实现细节）

virtual HRESULT ID3DXAllocateHierarchy::CreateMeshContainer(

LPCSTR Name,                        //网格容器名

const D3DXMESHDATA* pMeshData,      //网格数据

const D3DXMATERIAL* pMaterials,     //网格材质

const D3DXEFFECTINSTANCE* pEffectInstances,   //效果

DWORD NumMaterials,                 //材质数目

const DWORD* pAjacency,             //邻接三角形信息

LPD3DXSKININFO pSkinInfo,           //蒙皮信息

LPD3DXMESHCONTAINER* ppNewMeshContainer   //返回创建的网格对象

);

//释放一个帧（纯虚函数，需要给出具体的实现细节）

virtual HRESULT ID3DXAllocateHierarchy::DestroyFrame(

LPD3DXFRAME pFrameToFree

);

//释放网格容器（纯虚函数，需要给出具体的实现细节）

virtual HRESULT ID3DXAllocateHierarchy::DestroyMeshContainer(

LPD3DMESHCONTAINER pMeshContainerToFree

);

//ID3DXAllocateHierarchy接口的扩展类

class CAllocateHierarchy: public ID3DXAllocateHierarchy

{

public:

    STDMETHOD(CreateFrame)(THIS_ LPCTSTR Name, LPD3DXFRAME *ppNewFrame);

    STDMETHOD(CreateMeshContainer)(THIS_ 

        LPCSTR Name, 

        CONST D3DXMESHDATA *pMeshData,

        CONST D3DXMATERIAL *pMaterials, 

        CONST D3DXEFFECTINSTANCE *pEffectInstances, 

        DWORD NumMaterials, 

        CONST DWORD *pAdjacency, 

        LPD3DXSKININFO pSkinInfo, 

        LPD3DXMESHCONTAINER *ppNewMeshContainer);

    STDMETHOD(DestroyFrame)(THIS_ LPD3DXFRAME pFrameToFree);

    STDMETHOD(DestroyMeshContainer)(THIS_ LPD3DXMESHCONTAINER pMeshContainerBase);

public:

    CAllocateHierarchy(CSkinMesh *pSkinMesh) :m_pSkinMesh(pSkinMesh) {}

CSkinMesh* m_pSkinMesh;

};

/*----------------------该类的实现细节（内含4个纯虚函数的实现细节）-------------------------*/

//骨骼名称命名

HRESULT AllocateName( LPCTSTR Name, LPTSTR *pNewName )

{

    UINT cbLength;

    if (Name != NULL)

    {

        cbLength = lstrlen(Name) + 1;

        *pNewName = new TCHAR[cbLength];

        if (*pNewName == NULL)

           return E_OUTOFMEMORY;

        memcpy(*pNewName, Name, cbLength*sizeof(TCHAR));

    }

    else

    {

        *pNewName = NULL;

    }

    return S_OK;

}

//创建并初始化一个帧并命名

HRESULT CAllocateHierarchy::CreateFrame(LPCTSTR Name, LPD3DXFRAME *ppNewFrame)

{

    HRESULT hr = S_OK;

    D3DXFRAME_DERIVED *pFrame;

    *ppNewFrame = NULL;

    pFrame = new D3DXFRAME_DERIVED;

    if (pFrame == NULL)

    {

        hr = E_OUTOFMEMORY;//内存分配不足

        goto e_Exit;

    }

    hr = AllocateName(Name, &pFrame->Name);

    if (FAILED(hr))

        goto e_Exit;

    //初始化帧的数据

    D3DXMatrixIdentity(&pFrame->TransformationMatrix);

    D3DXMatrixIdentity(&pFrame->CombinedTransformationMatrix);

    pFrame->pMeshContainer = NULL;

    pFrame->pFrameSibling = NULL;

    pFrame->pFrameFirstChild = NULL;

    *ppNewFrame = pFrame;//返回初始化帧

    pFrame = NULL;

e_Exit:

    delete pFrame;

    return hr;

}

//创建网格容器

HRESULT CAllocateHierarchy::CreateMeshContainer(

LPCSTR Name,                                            //网格容器名称

        CONST D3DXMESHDATA *pMeshData,                          //传入的网格数据

        CONST D3DXMATERIAL *pMaterials,                         //传入的材质数据

        CONST D3DXEFFECTINSTANCE *pEffectInstances,             //

        DWORD NumMaterials,                                     //传入的材质数量

        CONST DWORD *pAdjacency,                                //传入的邻接三角形面信息

        LPD3DXSKININFO pSkinInfo,                               //传入的蒙皮信息

        LPD3DXMESHCONTAINER *ppNewMeshContainer)                //获得的网格容器指针

{

    HRESULT hr;

    D3DXMESHCONTAINER_DERIVED *pMeshContainer = NULL;

    UINT NumFaces;

    UINT iMaterial;

    UINT iBone, cBones;

    LPDIRECT3DDEVICE9 pd3dDevice = NULL;

    LPD3DXMESH pMesh = NULL;

    *ppNewMeshContainer = NULL;

    if (pMeshData->Type != D3DXMESHTYPE_MESH) //如果不是网格数据类型

    {

        hr = E_FAIL;

        goto e_Exit;

    }

    pMesh = pMeshData->pMesh;

    if (pMesh->GetFVF() == 0) //取得定点的可变格式，返回0表示不能转换为可变格式

    {

        hr = E_FAIL;

        goto e_Exit;

    }

    pMeshContainer = new D3DXMESHCONTAINER_DERIVED; //申请内存

    if (pMeshContainer == NULL)

    {

        hr = E_OUTOFMEMORY;

        goto e_Exit;

    }

    memset(pMeshContainer, 0, sizeof(D3DXMESHCONTAINER_DERIVED)); //内存置0

    hr = AllocateName(Name, &pMeshContainer->Name); //网格容器命名

    if (FAILED(hr))

        goto e_Exit;        

    pMesh->GetDevice(&pd3dDevice);   //获得容器设备

    NumFaces = pMesh->GetNumFaces();   //获得网格的三角形面数

    //如果没有法向量,则添加它们

    if (!(pMesh->GetFVF() & D3DFVF_NORMAL))

    {

        pMeshContainer->MeshData.Type = D3DXMESHTYPE_MESH;

  

        //先复制

        hr = pMesh->CloneMeshFVF( pMesh->GetOptions(), 

    pMesh->GetFVF() | D3DFVF_NORMAL, 

    pd3dDevice, &pMeshContainer->MeshData.pMesh );

        if (FAILED(hr))

           goto e_Exit;

        pMesh = pMeshContainer->MeshData.pMesh;

  

        //生成法向量

   D3DXComputeNormals( pMesh, NULL );

    }

    else 

    {

        pMeshContainer->MeshData.pMesh = pMesh;

        pMeshContainer->MeshData.Type = D3DXMESHTYPE_MESH;

  

        pMesh->AddRef();

    }

    pMeshContainer->NumMaterials = max(1, NumMaterials);

    pMeshContainer->pMaterials = new D3DXMATERIAL[pMeshContainer->NumMaterials];

    pMeshContainer->ppTextures = new LPDIRECT3DTEXTURE9[pMeshContainer->NumMaterials];

    pMeshContainer->pAdjacency = new DWORD[NumFaces*3];

    if ((pMeshContainer->pAdjacency == NULL) || (pMeshContainer->pMaterials == NULL))

    {

        hr = E_OUTOFMEMORY;

        goto e_Exit;

    }

    memcpy(pMeshContainer->pAdjacency, pAdjacency, sizeof(DWORD) * NumFaces*3);

    memset(pMeshContainer->ppTextures, 0, sizeof(LPDIRECT3DTEXTURE9) * pMeshContainer->NumMaterials);

    //如果有材质数据,生成纹理对象，并放入扩展后的网格容器中

    if (NumMaterials > 0)            

    {

        memcpy(pMeshContainer->pMaterials, pMaterials, sizeof(D3DXMATERIAL) * NumMaterials);

  

        for (iMaterial = 0; iMaterial < NumMaterials; iMaterial++)

        {

           if (pMeshContainer->pMaterials[iMaterial].pTextureFilename != NULL)

           {

                TCHAR* strTexturePath=pMeshContainer->pMaterials[iMaterial].pTextureFilename;

                if( FAILED( D3DXCreateTextureFromFile( pd3dDevice, strTexturePath, 

      &pMeshContainer->ppTextures[iMaterial] ) ) )

                    pMeshContainer->ppTextures[iMaterial] = NULL;

                pMeshContainer->pMaterials[iMaterial].pTextureFilename = NULL;

           }

        }

    }

    else //没有材质,则添加一个默认值

    {

        pMeshContainer->pMaterials[0].pTextureFilename = NULL;

        memset(&pMeshContainer->pMaterials[0].MatD3D, 0, sizeof(D3DMATERIAL9));

        pMeshContainer->pMaterials[0].MatD3D.Diffuse.r = 0.5f;

        pMeshContainer->pMaterials[0].MatD3D.Diffuse.g = 0.5f;

        pMeshContainer->pMaterials[0].MatD3D.Diffuse.b = 0.5f;

        pMeshContainer->pMaterials[0].MatD3D.Specular = pMeshContainer->pMaterials[0].MatD3D.Diffuse;

    }

    //存在蒙皮信息

    if (pSkinInfo != NULL)

    {

        pMeshContainer->pSkinInfo = pSkinInfo;

        pSkinInfo->AddRef();

  

        pMeshContainer->pOrigMesh = pMesh; //备份指针

        pMesh->AddRef();

        cBones = pSkinInfo->GetNumBones();

        pMeshContainer->pBoneOffsetMatrices = new D3DXMATRIX[cBones];

        if (pMeshContainer->pBoneOffsetMatrices == NULL)

        {

           hr = E_OUTOFMEMORY;

           goto e_Exit;

        }

  

   //取得骨骼的权重矩阵

        for (iBone = 0; iBone < cBones; iBone++)

        {

           pMeshContainer->pBoneOffsetMatrices[iBone] = *

(pMeshContainer->pSkinInfo->GetBoneOffsetMatrix(iBone));

        }

  

        //生成蒙皮网格

        hr = m_pSkinMesh->GenerateSkinnedMesh(pMeshContainer);

        if (FAILED(hr))

           goto e_Exit;

    }

    *ppNewMeshContainer = pMeshContainer;

    pMeshContainer = NULL;

e_Exit:

    SafeRelease(pd3dDevice);

    //释放网格容器

    if (pMeshContainer != NULL)

    {

        DestroyMeshContainer(pMeshContainer);

    }

    return hr;

}

//释放帧

HRESULT CAllocateHierarchy::DestroyFrame(LPD3DXFRAME pFrameToFree) 

{

    SafeDeleteArray( pFrameToFree->Name );

    SafeDelete( pFrameToFree );

    return S_OK; 

}

//释放网格容器

HRESULT CAllocateHierarchy::DestroyMeshContainer(LPD3DXMESHCONTAINER pMeshContainerBase)

{

    UINT iMaterial;

    D3DXMESHCONTAINER_DERIVED *pMeshContainer = (D3DXMESHCONTAINER_DERIVED*)pMeshContainerBase;

    SafeDeleteArray( pMeshContainer->Name );

    SafeDeleteArray( pMeshContainer->pAdjacency );

    SafeDeleteArray( pMeshContainer->pMaterials );

    SafeDeleteArray( pMeshContainer->pBoneOffsetMatrices );

    //释放所有纹理对象

    if (pMeshContainer->ppTextures != NULL)

    {

        for (iMaterial = 0; iMaterial < pMeshContainer->NumMaterials; iMaterial++)

        {

           SafeRelease( pMeshContainer->ppTextures[iMaterial] );

        }

    }

    SafeDeleteArray( pMeshContainer->ppTextures );

    SafeDeleteArray( pMeshContainer->ppBoneMatrixPtrs );

    SafeRelease( pMeshContainer->pBoneCombinationBuf );

    SafeRelease( pMeshContainer->MeshData.pMesh );

    SafeRelease( pMeshContainer->pSkinInfo );

    SafeRelease( pMeshContainer->pOrigMesh );

    SafeDelete( pMeshContainer );

    return S_OK;

}

//装入骨骼动画

HRESULT WINAPI D3DXLoadMeshHierarchyFromX(

LPCTSTR Filename,                    //骨骼动画的.x文件名

DWORD MeshOptions,                   //D3DXMESH_MANAGED等选项

LPDIRECT3DDEVICE pDevice,            //关联的3D设备

LPD3DXALLOCATEHIERARCHY pAlloc,      //Frame层次对象生成接口

LPD3DXLOADUSERDATA pUserDataLoader, //一般为NULL

LPD3DXFRAME* ppFrameHierarchy,       //返回已具有层次结构的根Frame指针

LPD3DXANIMATIONCONTROLLER* ppAnimController //返回相应的动画控制器

);

//生成蒙皮网格

HRESULT ID3DXSkinInfo::ConvertToIndexedBlendedMesh(

LPD3DXMESH pMesh,                    //传入的原网格

DWORD Options,                       //当前并未使用 

DWORD paletteSize,                   //骨骼矩阵调用

const DWORD* pAdjacencyIn,           //传入的临界三角形信息

LPDWORD pAdjacencyOut,               //一般为NULL

DWORD* pFaceRemap,                   //一般为NULL

LPD3DXBUFFER* ppVertexRemap,         //一般为NULL

DWORD* pMaxVertexInfl,               //一个顶点可以受到骨骼影响的最大骨骼数

DWORD* pNumBoneCombinations,         //骨骼组合属性表中的骨骼数

LPD3DXBUFFER* ppBoneCombinationTable,   //骨骼组合属性表

LPD3DMESH* ppMesh

);

//ppBoneCombinationTable（骨骼组合属性表）的元素定义

typedef struct _D3DXBONECOMBINATION{

DWORD AttribId;                      //子集的属性id

DWORD FaceStart;                     //起始三角形面

DWORD FaceCount;                     //子集的三角形面个数

DWORD VertexStart;                   //起始顶点

DWORD VertexCount;                   //顶点计数

DWORD* BoneId;                       //该子集的各个骨骼

}D3DXBONECOMBINATION, *LPD3DXBONECOMBINATION;

//释放骨骼框架

HRESULT D3DXALLOCATEHIERARCHY::D3DXFrameDestroy(

LPD3DXFRAME pFrameRoot,              //根帧指针

LPD3DXALLOCATEHIERARCHY pAlloc       //创建帧层次结构的接口

);

//调整当前动画的时间点

HRESULT D3DXANIMATIONCONTROLLER::AdvanceTime(

DOUBLE TimeDelta,                    //动画进行的时间

LPD3DXANIMATIONCALLBACKHANDLER pCallbackHandler //回调处理，可设置为NULL

);