【Direct3D游戏开发】——蒙皮骨骼动画学习笔记

蒙皮骨骼动画

一、蒙皮骨骼动画原理：蒙皮骨骼动画的思想来源于自然界，大多数动物都拥有一套骨骼，骨骼是身体的框架，身体的皮毛血肉都是依附于骨骼。当骨骼开始运动的时候，依附于对应骨骼的皮毛血肉都会随骨骼一起运动。而Mesh模型是由大量的三角形组成，三角形由定点组成。当我们运动时，有必要知道那些定点依附于那块骨骼，根据骨骼的移动来移动对应的顶点。

蒙皮骨骼动画的加载：和Mesh模型的加载一样，骨骼加载时也是基于本地空间，我们需要把骨骼一块一块的从基于本地空间转换到整个Mesh模型空间。对于一套骨骼，有一个根（root）骨骼，这个根骨骼位于模型的一个定点，如坐标原点，其他骨骼都是直接或者间接与之联系。每根骨骼都有相对于其父母骨骼的相对位置（包括位移，和绕关节进行的转动），这种转换由一个矩阵完成：LocalTransformMatrix，这只是完成了骨骼的定位，要实现动画还需要对骨骼进行各种变换，如你所料，这肯定也是利用矩阵完成：CombinedTransformMatrix。当上层骨骼运动时，下层骨骼并不会主动运动，而是被牵连着运动，所以上层的运动会传递到下层骨骼，这个原理表示为：（子骨骼）CombinedTransformMatrix = （子骨骼）LocalTransformMatrix * （父母骨骼的）CombinedTransformMatrix.当然这中传递是渲染之前计算好的。

关键结构体：Direct3d中一套骨骼是以树形结构存放的，有两个关键的结构体和一个接口。

1：typedef struct _D3DXFRAME

{

LPSTR Name;

D3DXMATRIX TransformationMatrix;

LPD3DXMESHCONTAINER pMeshContainer;

struct _D3DXFRAME *pFrameSibling;

struct _D3DXFRAME *pFrameFirstChild;

} D3DXFRAME, *LPD3DXFRAME;

这个结构体代表了一块骨骼，有一个标识的Name,变换矩阵TransformationMatrix对应于之前所说的LocalTransformMatrix,还有分别指向兄弟结点和第一个孩子结点的指针，最后是包含了一个指向D3DXMESHCONTAINER结构体的指针，这是第二个关键的结构体。

2：typedef struct _D3DXMESHCONTAINER

{

LPSTR Name;

D3DXMESHDATA MeshData;

LPD3DXMATERIAL pMaterials;

LPD3DXEFFECTINSTANCE pEffects;

DWORD NumMaterials;

DWORD *pAdjacency;

LPD3DXSKININFO pSkinInfo;

struct _D3DXMESHCONTAINER *pNextMeshContainer;

} D3DXMESHCONTAINER, *LPD3DXMESHCONTAINER;

对于这个结构体还是比较了解的，所以略。

3：ID3DXAllocateHierarchy 接口，这个接口只包含四个纯虚函数，我们需要去重写他们，这些函数无需我们自己调用，在我们使用D3DXLoadMeshHierarchyFromX()接口加载SkineMesh数据是自动调用。

4：D3DXLoadMeshHierarchyFromX (


















ID3DXAllocateHierarchy 接口的指针；ppFrameHierarchy，骨骼层次，也就是一个代表骨骼的树，是一个返回值；ppAnimController，这是动画控制器，是一个返回值，利用这个动画控制器就可以对SkinMesh进行控制。



笔记到此先告一段落，由于理解只在十分基本的层面，没法就很多细节进行分析，故在此只记录十分表面的东西，以后补足。PS:笔记主要参考《Direct3D游戏开发技术详解》，MSDN

参考：Direct3D游戏开发技术详解 和 SDK simple 简单的加载了tiny.x动画，只实现了SOFTWARE处理方式和走路的动画。

#include "CLD3D.h"
#include <stdio.h>

//常量
const wchar_t wndName[50] = L"蒙皮骨骼动画演示";
const wchar_t wndTitle[100] = L"【Direct3D】——蒙皮骨骼动画演示-coderling";
const wchar_t xFileName[20] = L"tiny.x";
const unsigned int wndWidth = 800;
const unsigned int wndHeight = 600;

//为每个骨骼添加一个控制矩阵
struct D3DXFRAME_EX: public D3DXFRAME
{
D3DXMATRIXA16 combinedTransformtionMatrix;
};

//保存蒙皮骨骼动画的结构体，包含网格模型
struct D3DXMESHCONTAINER_EX: public D3DXMESHCONTAINER
{
LPDIRECT3DTEXTURE9* ppTextures; //指向纹理信息指针的指针数组

//蒙皮骨骼信息
LPD3DXMESH pOrigMesh;
LPD3DXATTRIBUTERANGE pAttributeTable; //子集分布表格？
DWORD numAttributeGroups;
DWORD numInfl;
LPD3DXBUFFER pBoneCombinatonBuf; //骨骼名字缓冲区
D3DXMATRIX** ppBoneMatrixPtrs; //最终变换矩阵
D3DXMATRIX* pBoneOffsetMatrices; //offset矩阵数组指针
DWORD numPaletteEntries;
//bool useSoftwareVP;

};

HRESULT GenerateSkinnedMesh( D3DXMESHCONTAINER_EX* );

//重写ID3DXAllocateHierarchy接口
class CAllocateHierarchy: public ID3DXAllocateHierarchy
{
public:
STDMETHOD(CreateFrame)( THIS_ LPCSTR name, LPD3DXFRAME* ppNewFrame );
STDMETHOD(CreateMeshContainer)( THIS_
LPCSTR Name,
CONST D3DXMESHDATA* pMeshData,
CONST D3DXMATERIAL* pMaterials,
CONST D3DXEFFECTINSTANCE* pEffectInstance,
DWORD numMaterials,
CONST DWORD* pAdjacency,
LPD3DXSKININFO pSkinInfo,
LPD3DXMESHCONTAINER* ppNewMeshContainer );
STDMETHOD(DestroyFrame)( THIS_ LPD3DXFRAME pFrameToFree );
STDMETHOD(DestroyMeshContainer)( THIS_ LPD3DXMESHCONTAINER pMeshContainer );

};

//创建新的帧
HRESULT CAllocateHierarchy::CreateFrame( LPCSTR name, LPD3DXFRAME* ppNewFrame )
{
HRESULT hr = S_OK;

D3DXFRAME_EX *pFrame;

*ppNewFrame = NULL;

pFrame = new D3DXFRAME_EX;
if( pFrame == NULL )
{
hr = E_OUTOFMEMORY;
return hr;
}

if( name )
{
unsigned int len = strlen( name ) + 1;
pFrame->Name = new char[len];
memcpy( pFrame->Name, name, sizeof(char)*len );
}

//初始化frame
D3DXMatrixIdentity( &pFrame->TransformationMatrix );
D3DXMatrixIdentity( &pFrame->combinedTransformtionMatrix );

pFrame->pMeshContainer = NULL;
pFrame->pFrameFirstChild = NULL;
pFrame->pFrameSibling = NULL;

*ppNewFrame = pFrame; //返回

pFrame = NULL;

return hr;
}

//创建新的meshcontainner
HRESULT CAllocateHierarchy::CreateMeshContainer(
LPCSTR name,
CONST D3DXMESHDATA* pMeshData,
CONST D3DXMATERIAL* pMaterials,
CONST D3DXEFFECTINSTANCE* pEffectInstances,
DWORD numMaterials,
CONST DWORD* pAdjacency,
LPD3DXSKININFO pSkinInfo,
LPD3DXMESHCONTAINER* ppNewMeshContainer )
{
D3DXMESHCONTAINER_EX* pMeshContainer = NULL;
unsigned int numFaces;
unsigned int iMaterial;
unsigned int iBone, cBones;
LPDIRECT3DDEVICE9 pD3DDevice = NULL;

LPD3DXMESH pMesh = NULL;

*ppNewMeshContainer = NULL;

if( pMeshData->Type != D3DXMESHTYPE_MESH )
return E_FAIL;

pMesh = pMeshData->pMesh;

if( pMesh->GetFVF() == 0 )
return E_FAIL;

pMeshContainer = new D3DXMESHCONTAINER_EX;
if( pMeshContainer == NULL )
return E_FAIL;
memset( pMeshContainer, 0, sizeof(D3DXMESHCONTAINER_EX) );

if( name )
{
unsigned int len = strlen( name ) + 1;
pMeshContainer->Name = new char[len];
memcpy( pMeshContainer->Name, name, sizeof(char)*len );
}

pMesh->GetDevice( &pD3DDevice );
numFaces = pMesh->GetNumFaces();

//添加顶点法线
if( !( pMesh->GetFVF() & D3DFVF_NORMAL ) )
{
pMeshContainer->MeshData.Type = D3DXMESHTYPE_MESH;

HRESULT hr = pMesh->CloneMeshFVF( pMesh->GetOptions(), pMesh->GetFVF() | D3DFVF_NORMAL,
pD3DDevice, &pMeshContainer->MeshData.pMesh );
if( FAILED( hr ) )
return E_FAIL;

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 ) )
return E_FAIL;

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) * pMeshContainer->NumMaterials );

for( iMaterial = 0; iMaterial < numMaterials; iMaterial++ )
{
if( pMeshContainer->pMaterials[iMaterial].pTextureFilename != NULL )
{
HRESULT hr = D3DXCreateTextureFromFileA( pD3DDevice,
pMeshContainer->pMaterials[iMaterial].pTextureFilename,
&pMeshContainer->ppTextures[iMaterial] );
if( FAILED( hr ) )
pMeshContainer->ppTextures[iMaterial] = 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 )
return E_FAIL;

//获得offsetmatrix
for( iBone = 0; iBone < cBones; iBone++ )
{
pMeshContainer->pBoneOffsetMatrices[iBone] = *( pMeshContainer->pSkinInfo->GetBoneOffsetMatrix( iBone ) );
}

HRESULT hr = GenerateSkinnedMesh( pMeshContainer );
if( FAILED( hr ) )
return E_FAIL;
}

*ppNewMeshContainer = pMeshContainer;

//SAFE_RELEASE( pD3DDevice );

//if( pMeshContainer != NULL )
//DestroyMeshContainer( pMeshContainer );

return S_OK;
}

//销毁Frame
HRESULT CAllocateHierarchy::DestroyFrame( LPD3DXFRAME pFrameToFree )
{
SAFE_DELETE_ARRAY( pFrameToFree->Name );
SAFE_DELETE( pFrameToFree );

return S_OK;
}

//销毁container
HRESULT CAllocateHierarchy::DestroyMeshContainer( LPD3DXMESHCONTAINER pMeshContainerBase )
{
unsigned int iMaterial;
D3DXMESHCONTAINER_EX* pMeshContainer = (D3DXMESHCONTAINER_EX*)pMeshContainerBase;

SAFE_DELETE_ARRAY( pMeshContainer->Name );
SAFE_DELETE_ARRAY( pMeshContainer->pAdjacency );
SAFE_DELETE_ARRAY( pMeshContainer->pMaterials );
SAFE_DELETE_ARRAY( pMeshContainer->pBoneOffsetMatrices );

if( pMeshContainer->ppTextures != NULL )
{
for( iMaterial = 0; iMaterial< pMeshContainer->NumMaterials; iMaterial++ )
{
SAFE_RELEASE( pMeshContainer->ppTextures[iMaterial] );
}
}

SAFE_DELETE_ARRAY( pMeshContainer->ppTextures );
SAFE_DELETE_ARRAY( pMeshContainer->ppBoneMatrixPtrs );
SAFE_RELEASE( pMeshContainer->pBoneCombinatonBuf );
SAFE_RELEASE( pMeshContainer->pSkinInfo );
SAFE_RELEASE( pMeshContainer->pOrigMesh );
SAFE_DELETE( pMeshContainer );

return S_OK;
}

//---------------我是分割线---------------------------------------------------------------------------------------------

//全局变量
LPDIRECT3D9 g_pD3D = NULL; //direct3d对象用于创建direct设备
LPDIRECT3DDEVICE9 g_pD3DDevice = NULL; //direct3d设备指针
LPD3DXFONT g_pText = NULL;
LPD3DXFRAME g_pFrameRoot = NULL; //骨骼的根
LPD3DXANIMATIONCONTROLLER g_pAnimController; //动画控制句柄
double g_startTime = 0.0;
wchar_t* g_pAdapter = NULL;
unsigned int g_numBoneMatricesMax = 0;
D3DXMATRIXA16* g_pBoneMatrices = NULL;

//相关函数声明
LRESULT WINAPI MsgProc( HWND, UINT, WPARAM, LPARAM );
HRESULT InitApp( HWND, HINSTANCE );
HRESULT InitGeometry(); //场景数据
VOID InitTranformMatrix(); //初始变换
HRESULT InitText(); //字体接口
VOID Render( HWND ); //渲染
VOID RenderText( HWND ); //渲染提示信息
VOID UpdateScene( HWND ); //更新场景
VOID UpdateFrameMatrices( const LPD3DXFRAME, const LPD3DXMATRIX ); //为个骨骼更新变换矩阵，每帧
VOID InitLight(); //设置光源
VOID Cleanup();
HRESULT SetupBoneMatrixPointers( LPD3DXFRAME ); //设置骨骼链中的混合数组到container中，方便访问
HRESULT SetupBoneMatrixPointersOnMesh( LPD3DXMESHCONTAINER ); //
VOID DrawFrame( LPD3DXFRAME ); //绘制骨骼
VOID DrawMeshContainer( const LPD3DXMESHCONTAINER, const LPD3DXFRAME ); //绘制单个pMeshContainer

int WINAPI WinMain( HINSTANCE hInst, HINSTANCE preInst, LPSTR lpCmdLine, int nCmdShow )
{
//设计并注册窗口类
WNDCLASSEX wcEx = { sizeof(WNDCLASSEX), CS_CLASSDC, MsgProc, 0L, 0L,
GetModuleHandle( NULL ), NULL, NULL, NULL, NULL,
wndName, NULL };
RegisterClassEx( &wcEx );

//创建窗口
HWND hWnd = CreateWindow( wndName, wndTitle, WS_OVERLAPPEDWINDOW,
100, 100, wndWidth, wndHeight, GetDesktopWindow(),
NULL, hInst, NULL );

if( SUCCEEDED( InitApp( hWnd, hInst ) ) )
{
if( SUCCEEDED( InitGeometry() ) )
{
//显示并更新窗口
ShowWindow( hWnd, SW_SHOWDEFAULT );
UpdateWindow( hWnd );

//程序消息循环
MSG msg;
SecureZeroMemory( &msg, sizeof(msg) );
while( msg.message != WM_QUIT )
{
if( PeekMessage( &msg, NULL, 0U, 0U, PM_REMOVE ) )
{
TranslateMessage( &msg );
DispatchMessage( &msg );
}
else
Render( hWnd );
}
}
}

UnregisterClass( wndName, wcEx.hInstance );
return 0;
}

LRESULT WINAPI MsgProc( HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam )
{
switch( msg )
{
case WM_KEYDOWN:
if( wParam == VK_ESCAPE )
DestroyWindow( hWnd );
break;
case WM_DESTROY:
Cleanup();
PostQuitMessage(0);
break;
default:
return DefWindowProc( hWnd, msg, wParam, lParam );
}
return S_OK;
}

HRESULT InitApp( HWND hWnd , HINSTANCE hInst )
{
//创建direct3d对象
if( FAILED( g_pD3D = Direct3DCreate9( D3D_SDK_VERSION )) )
return E_FAIL;

//填写Direct3dDevice配置参数
D3DPRESENT_PARAMETERS d3dpp;
SecureZeroMemory( &d3dpp, sizeof(d3dpp) );
d3dpp.BackBufferWidth = wndWidth;
d3dpp.BackBufferHeight = wndHeight;
d3dpp.BackBufferFormat = D3DFMT_UNKNOWN;
d3dpp.BackBufferCount = 1; //缓冲数
d3dpp.hDeviceWindow = hWnd;
d3dpp.Windowed = true;
d3dpp.EnableAutoDepthStencil = true; //开启深度缓冲
d3dpp.AutoDepthStencilFormat = D3DFMT_D24S8;
d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
d3dpp.Flags = 0;
d3dpp.FullScreen_RefreshRateInHz = D3DPRESENT_RATE_DEFAULT;
d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;

//检测硬件
D3DCAPS9 caps;
g_pD3D->GetDeviceCaps( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, &caps );
int vp = 0;
if( caps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT )
vp = D3DCREATE_HARDWARE_VERTEXPROCESSING;
else
vp = D3DCREATE_SOFTWARE_VERTEXPROCESSING;

//创建Direct3d设备
if( FAILED( g_pD3D->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL,
hWnd, vp, &d3dpp, &g_pD3DDevice ) ) )
{
return E_FAIL;
}

InitText();

g_startTime = (double)timeGetTime();

return S_OK;
}

HRESULT InitGeometry()
{
HRESULT hr;
CAllocateHierarchy alloc;

hr = D3DXLoadMeshHierarchyFromX( xFileName, D3DXMESH_MANAGED, g_pD3DDevice, &alloc, NULL, &g_pFrameRoot, &g_pAnimController );
if( FAILED( hr ) )
return E_FAIL;

//设置骨骼链中的混合矩阵到Container中，方便访问
hr = SetupBoneMatrixPointers( g_pFrameRoot );

InitLight();

InitTranformMatrix();
g_pD3DDevice->SetRenderState( D3DRS_NORMALIZENORMALS, true ); //标准化顶点法线
//g_pD3DDevice->SetRenderState( D3DRS_SPECULARENABLE, true ); //开启镜面光

//显卡信息
wchar_t adapterTemp[200] = L"显卡型号：";
D3DADAPTER_IDENTIFIER9 adapter; //获取显卡信息的结构体
g_pAdapter = new wchar_t[200];
g_pD3D->GetAdapterIdentifier( 0, 0, &adapter ); //获取显卡信息，保存在adapter中

//将char*转化为wchar_t*
int len = MultiByteToWideChar( CP_ACP, 0, adapter.Description, -1, NULL, 0 );
MultiByteToWideChar( CP_ACP, 0, adapter.Description, -1, g_pAdapter, len );
wcscat_s(adapterTemp,g_pAdapter ); //链接两个字符串
memcpy( g_pAdapter, adapterTemp, sizeof(adapterTemp) ); //从新拷贝回g_pAdapter

return S_OK;
}

VOID InitTranformMatrix()
{
D3DXMATRIX matWorld;
D3DXMatrixIdentity( &matWorld );
g_pD3DDevice->SetTransform( D3DTS_WORLD, &matWorld );

// 摄像机
D3DXVECTOR3 pos(100.0f, 100.0f, -250.0f);
D3DXVECTOR3 target(0.0f, 0.0f, 0.0f);
D3DXVECTOR3 up(0.0f, 1.0f, 0.0f);
//g_camera.ReSetting( &pos, &target, &up );

//D3DXVECTOR3 right( 1.0f, 0.0f, 0.0f);
D3DXMATRIX V;
//g_camera.GetViewMatrix( &V );
D3DXMatrixLookAtLH(
&V,
&pos,
&target,
&up);
g_pD3DDevice->SetTransform(D3DTS_VIEW, &V);

// 设置投影变换矩阵.
D3DXMATRIX proj;
D3DXMatrixPerspectiveFovLH(
&proj,
D3DX_PI * 0.5f,
(float)wndWidth/ (float)wndHeight,
1.0f,
1000.0f);
g_pD3DDevice->SetTransform(D3DTS_PROJECTION, &proj);

//视口剪切矩阵，实现视口变换
D3DVIEWPORT9 vp;
vp.X = 0;
vp.Y = 0;
vp.Width = wndWidth;
vp.Height = wndHeight;
vp.MinZ = 0;
vp.MaxZ = 1;
g_pD3DDevice->SetViewport( &vp );
}

HRESULT InitText()
{
HRESULT hr;
//创建字体
hr = D3DXCreateFont( g_pD3DDevice, 25, 0, 1000, 0, false,
DEFAULT_CHARSET, OUT_DEFAULT_PRECIS,
DEFAULT_QUALITY, 0, L"微软雅黑", &g_pText );

return hr;
}

VOID Render( HWND hWnd )
{
if( NULL == g_pD3DDevice )
return ;
//清屏
g_pD3DDevice->Clear( 0, 0, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER,
D3DCOLOR_XRGB( 28, 154, 207 ), 1.0f, 0 );

if( SUCCEEDED( g_pD3DDevice->BeginScene() ) )
{
UpdateScene( hWnd );
DrawFrame( g_pFrameRoot ); //绘制骨骼动画

RenderText( hWnd );
g_pD3DDevice->EndScene();
}

g_pD3DDevice->Present( NULL, NULL, NULL, NULL );
//::Sleep(10000);
}

//递归绘制骨骼动画
VOID DrawFrame( LPD3DXFRAME pFrame )
{
LPD3DXMESHCONTAINER pMeshContainer;

pMeshContainer = pFrame->pMeshContainer;
while( pMeshContainer != NULL )
{
DrawMeshContainer( pMeshContainer, pFrame );
pMeshContainer = pMeshContainer->pNextMeshContainer;
}

if( pFrame->pFrameSibling != NULL )
{
DrawFrame( pFrame->pFrameSibling );
}

if( pFrame->pFrameFirstChild != NULL )
{
DrawFrame( pFrame->pFrameFirstChild );
}
}

//绘制单个pMeshContainer
VOID DrawMeshContainer( const LPD3DXMESHCONTAINER pMeshContainerBase, const LPD3DXFRAME pFrameBase )
{
D3DXMESHCONTAINER_EX* pMeshContainer = (D3DXMESHCONTAINER_EX*)pMeshContainerBase;
D3DXFRAME_EX* pFrame = (D3DXFRAME_EX*)pFrameBase;
unsigned int iMaterial;
//unsigned int numBlend;
unsigned int iAttrib;
//DWORD attribIdPrev;
//LPD3DXBONECOMBINATION pBoneComb;

//unsigned int iMatrixIndex;
//unsigned int iPaletteEntry;
D3DXMATRIXA16 matTemp;

if( pMeshContainer->pSkinInfo != NULL )
{
//只采用软件处理方式
//D3DXMATRIX Identity;
DWORD cBones = pMeshContainer->pSkinInfo->GetNumBones();
DWORD iBone;
PBYTE pbVerticesSrc;
PBYTE pbVerticesDest;

//D3DXMATRIX* pBoneMatrices = new D3DXMATRIX[cBones];
for( iBone = 0; iBone < cBones; ++iBone )
{
D3DXMatrixMultiply(
&g_pBoneMatrices[iBone],
&pMeshContainer->pBoneOffsetMatrices[iBone],
pMeshContainer->ppBoneMatrixPtrs[iBone]
);
}

pMeshContainer->pOrigMesh->LockVertexBuffer( D3DLOCK_READONLY, (LPVOID*)&pbVerticesSrc );
pMeshContainer->MeshData.pMesh->LockVertexBuffer( 0, (LPVOID*)&pbVerticesDest );

pMeshContainer->pSkinInfo->UpdateSkinnedMesh( g_pBoneMatrices, NULL, pbVerticesSrc, pbVerticesDest );

//delete[] pBoneMatrices;
//pBoneMatrices = NULL;

pMeshContainer->pOrigMesh->UnlockVertexBuffer();
pMeshContainer->MeshData.pMesh->UnlockVertexBuffer();

for( iAttrib = 0; iAttrib < pMeshContainer->numAttributeGroups; iAttrib++ )
{
g_pD3DDevice->SetMaterial( &( pMeshContainer->pMaterials[pMeshContainer->pAttributeTable[iAttrib].AttribId].MatD3D ) );
g_pD3DDevice->SetTexture( 0, pMeshContainer->ppTextures[pMeshContainer->pAttributeTable[iAttrib].AttribId]);
pMeshContainer->MeshData.pMesh->DrawSubset( pMeshContainer->pAttributeTable[iAttrib].AttribId);
}
}
else
{
for( iMaterial = 0; iMaterial < pMeshContainer->NumMaterials; iMaterial++ )
{
g_pD3DDevice->SetMaterial( &pMeshContainer->pMaterials[iMaterial].MatD3D );
g_pD3DDevice->SetTexture( 0, pMeshContainer->ppTextures[iMaterial] );
pMeshContainer->MeshData.pMesh->DrawSubset( iMaterial );
}
}
}

VOID RenderText( HWND hWnd )
{
RECT clientRect;
GetClientRect( hWnd, &clientRect );

//-绘制显卡信息
g_pText->DrawText( NULL, g_pAdapter, -1, &clientRect,
DT_TOP | DT_LEFT, D3DXCOLOR( 1.0f, 0.0f, 0.0f, 1.0f ) );

//绘制FPS
wchar_t strFPS[20];
int len = swprintf_s(strFPS, 20, L"FPS：%.3f", GetFPS());
g_pText->DrawText( NULL, strFPS, len, &clientRect, DT_TOP | DT_RIGHT,
D3DXCOLOR( 0.0f, 1.0f, 0.0f, 1.0f ) );

}

VOID UpdateScene( HWND hWnd )
{
if( g_pAnimController != NULL )
{
double time = (double)timeGetTime();
time = ( time - g_startTime ) * 0.001;
g_startTime = (double)timeGetTime();
g_pAnimController->AdvanceTime( time, NULL );
}

D3DXMATRIX matWorld;
//D3DXMatrixIdentity( &matWorld );
g_pD3DDevice->GetTransform( D3DTS_WORLD, &matWorld );
UpdateFrameMatrices( g_pFrameRoot, &matWorld );
}

VOID UpdateFrameMatrices( const LPD3DXFRAME pFrameBase, const LPD3DXMATRIX pParentMatrix )
{
D3DXFRAME_EX* pFrame = (D3DXFRAME_EX*)pFrameBase;

if( pParentMatrix != NULL )
D3DXMatrixMultiply( &pFrame->combinedTransformtionMatrix, &pFrame->TransformationMatrix, pParentMatrix );
else
pFrame->combinedTransformtionMatrix = pFrame->TransformationMatrix;

if( pFrame->pFrameSibling != NULL )
{
UpdateFrameMatrices( pFrame->pFrameSibling, pParentMatrix );
}

if( pFrame->pFrameFirstChild != NULL )
{
UpdateFrameMatrices( pFrame->pFrameFirstChild, &pFrame->combinedTransformtionMatrix );
}
}

VOID InitLight()
{
//------------------------------
//-1、填写D3DLIGHT9结构体
//-2、SetLinght
//-3、LightEnable
//-----------------------------

//填写光源结构体
D3DLIGHT9 pointLight;
SecureZeroMemory( &pointLight, sizeof(pointLight) );
D3DXCOLOR white = D3DCOLOR_RGBA( 255, 255, 255, 255 );
D3DXCOLOR black = D3DCOLOR_RGBA( 0, 0, 0, 0 );
pointLight.Type = D3DLIGHT_POINT;
pointLight.Ambient = white*0.4f;
pointLight.Diffuse = white;
pointLight.Specular = white*0.6f;
pointLight.Position = D3DXVECTOR3( 200.0f, 200.0f, 0.0f ); //根据需要进行更改
pointLight.Range = 500.0f;
pointLight.Attenuation0 = 1.0f;
pointLight.Attenuation1 = 0.0f;
pointLight.Attenuation2 = 0.0f;

g_pD3DDevice->SetLight( 0, &pointLight );
g_pD3DDevice->LightEnable( 0, true );
}

VOID Cleanup()
{
SAFE_DELETE( g_pAdapter );
SAFE_RELEASE( g_pD3D );
SAFE_RELEASE( g_pD3DDevice );
SAFE_RELEASE( g_pText );
SAFE_RELEASE( g_pAnimController );

if( g_pFrameRoot != NULL )
{
CAllocateHierarchy alloc;
D3DXFrameDestroy( g_pFrameRoot, &alloc );
g_pFrameRoot = NULL;
}
}

//递归设置骨骼链的混合数组
HRESULT SetupBoneMatrixPointers( LPD3DXFRAME pFrame )
{
HRESULT hr;
if( pFrame->pMeshContainer != NULL )
{
hr = SetupBoneMatrixPointersOnMesh( pFrame->pMeshContainer );
if( FAILED( hr ) )
return hr;
}

if( pFrame->pFrameSibling != NULL )
{
hr = SetupBoneMatrixPointers( pFrame->pFrameSibling );
if( FAILED( hr ) )
return hr;
}

if( pFrame->pFrameFirstChild != NULL )
{
hr = SetupBoneMatrixPointers( pFrame->pFrameFirstChild );
if( FAILED( hr ) )
return hr;
}

return S_OK;
}

HRESULT SetupBoneMatrixPointersOnMesh( LPD3DXMESHCONTAINER pMeshContainerBase )
{
unsigned int iBone;
unsigned int cBones;
D3DXFRAME_EX* pFrame;

D3DXMESHCONTAINER_EX* pMeshContainer = ( D3DXMESHCONTAINER_EX* )pMeshContainerBase;

//如果是骨骼动画
if( pMeshContainer->pSkinInfo != NULL )
{
cBones = pMeshContainer->pSkinInfo->GetNumBones();

pMeshContainer->ppBoneMatrixPtrs = new D3DXMATRIX*[cBones];
if( pMeshContainer->ppBoneMatrixPtrs == NULL )
return E_OUTOFMEMORY;

for( iBone = 0; iBone < cBones; iBone++ )
{
//根据骨骼名字寻找对应骨骼
pFrame = (D3DXFRAME_EX*)D3DXFrameFind( g_pFrameRoot, pMeshContainer->pSkinInfo->GetBoneName( iBone ) );
if( pFrame == NULL )
return E_FAIL;

pMeshContainer->ppBoneMatrixPtrs[iBone] = &pFrame->combinedTransformtionMatrix;
}
}

//--------
/*HRESULT hr = pMeshContainer->MeshData.pMesh->GetAttributeTable( NULL, &pMeshContainer->numAttributeGroups );
if( FAILED( hr ) )
return E_FAIL;
pMeshContainer->pAttributeTable = new D3DXATTRIBUTERANGE[pMeshContainer->numAttributeGroups];
if( pMeshContainer->pAttributeTable == NULL )
return E_FAIL;
hr = pMeshContainer->MeshData.pMesh->GetAttributeTable( pMeshContainer->pAttributeTable, NULL );
if( FAILED( hr ) )
return E_FAIL;*/

return S_OK;
}

//在SkinMesh加载或者改变渲染方式时是调用
HRESULT GenerateSkinnedMesh( D3DXMESHCONTAINER_EX* pMeshContainer )
{
HRESULT hr = S_OK;

if( pMeshContainer->pSkinInfo == NULL )
return hr;
SAFE_RELEASE( pMeshContainer->MeshData.pMesh );
SAFE_RELEASE( pMeshContainer->pBoneCombinatonBuf );

hr = pMeshContainer->pOrigMesh->CloneMeshFVF( D3DXMESH_MANAGED, pMeshContainer->pOrigMesh->GetFVF(),
g_pD3DDevice, &pMeshContainer->MeshData.pMesh );
if( FAILED(hr) )
return hr;

hr = pMeshContainer->MeshData.pMesh->GetAttributeTable( NULL, &pMeshContainer->numAttributeGroups );
if( FAILED(hr) )
return hr;

delete[] pMeshContainer->pAttributeTable;
pMeshContainer->pAttributeTable = new D3DXATTRIBUTERANGE[pMeshContainer->numAttributeGroups];
if( pMeshContainer->pAttributeTable == NULL )
return E_OUTOFMEMORY;

hr = pMeshContainer->MeshData.pMesh->GetAttributeTable( pMeshContainer->pAttributeTable, NULL );
if( FAILED(hr) )
return hr;

if( g_numBoneMatricesMax < pMeshContainer->pSkinInfo->GetNumBones() )
{
g_numBoneMatricesMax = pMeshContainer->pSkinInfo->GetNumBones();

//为材质分配空间
g_pBoneMatrices = new D3DXMATRIXA16[g_numBoneMatricesMax];
if( g_pBoneMatrices == NULL )
return E_OUTOFMEMORY;
}

return hr;
}

后记：好久，好久没更新了，一个由于自己突然抽风了，变得放纵，还有就是还是被其他事情影响到了。