VS2010+DX9+Assimp使用(2)

最新推荐文章于 2021-10-31 20:09:18 发布
最新推荐文章于 2021-10-31 20:09:18 发布
阅读量767 收藏 3
点赞数
分类专栏： 游戏设计基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/szmtjs10/article/details/117307492
版权

2.VS2010+DX9情况下加载动画模型

其实在微软官方的DirectX SDK Samples中已经为我们把骨骼动画类封装好了，在一个名为SkinnedMesh的示例程序中。

如果你的SDK是安装在D盘，那么这个骨骼动画的微软官方示例程序的路径就是如下：

D:\Program Files\Microsoft DirectX SDK(June 2010)\Samples\C++\Direct3D\SkinnedMesh

微软对Samples中代码的书写方式比较密集，一般实现代码都放在一个cpp文件中，比如这里的SkinnedMesh示例程序，基本上代码都挤在了一个名为skinnedmesh.cpp的1970行代码的源文件中，在这个源文件中有一个叫CAllocateHierarchy的类，还有几个好用的全局函数，我们直接拿过来用就好了，

2.1 项目结构

在这里插入图片描述

2.1.1 骨骼动画头文件

AllocateHierarchyClass.h

#pragma once

//=============================================================================
// Desc: CAllocateHierarchy.h
// 来自微软官方DirectX SDK Samples中的骨骼动画类
//=============================================================================

#include <d3d9.h>
#include <d3dx9.h>
#include "D3DUtil.h"


//-----------------------------------------------------------------------------
// Name: struct D3DXFRAME_DERIVED
// Desc: 继承自DXDXFRAME结构的结构
//-----------------------------------------------------------------------------
struct D3DXFRAME_DERIVED: public D3DXFRAME
{
	D3DXMATRIXA16 CombinedTransformationMatrix;
};


//-----------------------------------------------------------------------------
// Name: struct D3DXMESHCONTAINER_DERIVED
// Desc: 继承自D3DXMESHCONTAINER结构的结构
//-----------------------------------------------------------------------------
struct D3DXMESHCONTAINER_DERIVED: public D3DXMESHCONTAINER
{
	LPDIRECT3DTEXTURE9*  ppTextures;            //纹理数组
	LPD3DXMESH           pOrigMesh;             //原始网格
	LPD3DXATTRIBUTERANGE pAttributeTable;
	DWORD                NumAttributeGroups;    //属性组数量,即子网格数量
	DWORD                NumInfl;               //每个顶点最多受多少骨骼的影响
	LPD3DXBUFFER         pBoneCombinationBuf;   //骨骼结合表
	D3DXMATRIX**         ppBoneMatrixPtrs;      //存放骨骼的组合变换矩阵
	D3DXMATRIX*          pBoneOffsetMatrices;   //存放骨骼的初始变换矩阵
	DWORD                NumPaletteEntries;     //骨骼数量上限
	bool                 UseSoftwareVP;         //标识是否使用软件顶点处理
};


//-----------------------------------------------------------------------------
// Name: class CAllocateHierarchy
// Desc: 来自微软官方DirectX SDK Samples中的骨骼动画类，这个类用来从.X文件加载框架层次和网格模型数据
// 核心点:      #define STDMETHOD(method) virtual HRESULT STDMETHODCALLTYPE method 
//-----------------------------------------------------------------------------
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* pEffectInstances, 
		DWORD                     NumMaterials, 
		CONST DWORD *             pAdjacency, 
		LPD3DXSKININFO pSkinInfo, 
		LPD3DXMESHCONTAINER *ppNewMeshContainer);    
	STDMETHOD(DestroyFrame)(THIS_ LPD3DXFRAME pFrameToFree);
	STDMETHOD(DestroyMeshContainer)(THIS_ LPD3DXMESHCONTAINER pMeshContainerBase);
};




//-----------------------------------------------------------------------------
// Desc: 来自微软官方DirectX SDK Samples中的骨骼动画全局函数
//-----------------------------------------------------------------------------
void DrawFrame( IDirect3DDevice9* pd3dDevice, LPD3DXFRAME pFrame );
void DrawMeshContainer( IDirect3DDevice9* pd3dDevice, LPD3DXMESHCONTAINER pMeshContainerBase, LPD3DXFRAME pFrameBase );
HRESULT SetupBoneMatrixPointers( LPD3DXFRAME pFrameBase, LPD3DXFRAME pFrameRoot );
void UpdateFrameMatrices( LPD3DXFRAME pFrameBase, LPD3DXMATRIX pParentMatrix );
2.1.2 公共辅助宏的定义文件

D3DUtil.h


//*****************************************************************************************
// Desc: D3DUtil.h头文件，用于公共辅助宏的定义
//*****************************************************************************************

#pragma once


#ifndef HR
#define HR(x)    { hr = x; if( FAILED(hr) ) { return hr; } }         //自定义一个HR宏，方便执行错误的返回
#endif

#ifndef SAFE_DELETE					
#define SAFE_DELETE(p)       { if(p) { delete (p);     (p)=NULL; } }       //自定义一个SAFE_RELEASE()宏,便于指针资源的释放
#endif    

#ifndef SAFE_RELEASE			
#define SAFE_RELEASE(p)      { if(p) { (p)->Release(); (p)=NULL; } }     //自定义一个SAFE_RELEASE()宏,便于COM资源的释放
#endif

#ifndef SAFE_DELETE_ARRAY
#define SAFE_DELETE_ARRAY(p) { if(p) { delete[] (p);   (p)=NULL; } }
#endif
2.1.3 骨骼动画类cpp文件

AllocateHierarchyClass.cpp

//=============================================================================
// Desc: AllocateHierarchyClass.cpp
// 来自微软官方DirectX SDK Samples中的骨骼动画类
//=============================================================================

#include "AllocateHierarchyClass.h"

//--------------------------------------------------------------------------------------
// Name: AllocateName()
// Desc: 为骨骼或网格名称的字符串分配内存
//--------------------------------------------------------------------------------------
HRESULT AllocateName( LPCSTR Name, LPSTR* pNewName )
{
	UINT cbLength;

	if( Name != NULL )
	{
		cbLength = ( UINT )strlen( Name ) + 1;
		*pNewName = new CHAR[cbLength];
		memcpy( *pNewName, Name, cbLength * sizeof( CHAR ) );
	}
	else
	{
		*pNewName = NULL;
	}

	return S_OK;
}

//--------------------------------------------------------------------------------------
// Name: GenerateSkinnedMesh
// Desc: 生成蒙皮网格模型。该函数判断当前网格容器是否包含有蒙皮信息，如果当前网格模型
//       中不包含蒙皮信息，则直接退出该函数。接下来确定所需要的矩阵调色板容量。最后调
//       用ID3DXSkinInfo::ConvertToIndexedBlendedMesh()函数生成索引蒙皮网格模型
//--------------------------------------------------------------------------------------
HRESULT GenerateSkinnedMesh( IDirect3DDevice9* pd3dDevice, D3DXMESHCONTAINER_DERIVED* pMeshContainer )
{
	D3DCAPS9 d3dCaps;
	pd3dDevice->GetDeviceCaps( &d3dCaps );

	if( pMeshContainer->pSkinInfo == NULL )
		return S_OK;

	SAFE_RELEASE( pMeshContainer->MeshData.pMesh );
	SAFE_RELEASE( pMeshContainer->pBoneCombinationBuf );


	if (FAILED(pMeshContainer->pSkinInfo->ConvertToBlendedMesh(
		pMeshContainer->pOrigMesh, 
		D3DXMESH_MANAGED | D3DXMESHOPT_VERTEXCACHE,
		pMeshContainer->pAdjacency,
		NULL, NULL, NULL,
		&pMeshContainer->NumInfl,
		&pMeshContainer->NumAttributeGroups,
		&pMeshContainer->pBoneCombinationBuf,
		&pMeshContainer->MeshData.pMesh)))
		return E_FAIL;
	return S_OK;
}



//--------------------------------------------------------------------------------------
// Name: CAllocateHierarchy::CreateFrame()
// Desc: 创建框架, 仅仅是分配内存和初始化,还没有对其成员赋予合适的值
//--------------------------------------------------------------------------------------
HRESULT CAllocateHierarchy::CreateFrame( LPCSTR Name, LPD3DXFRAME* ppNewFrame )
{
	HRESULT hr = S_OK;
	D3DXFRAME_DERIVED *pFrame;

	*ppNewFrame = NULL;

	// 为框架指定名称
	pFrame = new D3DXFRAME_DERIVED;  // 创建框架结构对象
	if (FAILED(AllocateName(Name, (LPSTR*)&pFrame->Name)))
	{
		delete pFrame;
		return hr;
	}

	// 初始化D3DXFRAME_DERIVED结构其它成员变量
	D3DXMatrixIdentity(&pFrame->TransformationMatrix);
	D3DXMatrixIdentity(&pFrame->CombinedTransformationMatrix);

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

	*ppNewFrame = pFrame;
	pFrame = NULL;

	return hr;
}


//--------------------------------------------------------------------------------------
// Name: CAllocateHierarchy::CreateMeshContainer()
// Desc: 创建蒙皮网格容器，以加载蒙皮信息
//--------------------------------------------------------------------------------------
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;
	UINT NumFaces;
	UINT iMaterial;
	UINT iBone, cBones;
	LPDIRECT3DDEVICE9 pd3dDevice = NULL;
	D3DXMESHCONTAINER_DERIVED *pMeshContainer = NULL;

	LPD3DXMESH pMesh = NULL;

	*ppNewMeshContainer = NULL;

	// this sample does not handle patch meshes, so fail when one is found
	if( pMeshData->Type != D3DXMESHTYPE_MESH )
	{
		hr = E_FAIL;
		goto e_Exit;
	}

	// get the pMesh interface pointer out of the mesh data structure
	pMesh = pMeshData->pMesh;

	// this sample does not FVF compatible meshes, so fail when one is found
	if( pMesh->GetFVF() == 0 )
	{
		hr = E_FAIL;
		goto e_Exit;
	}

	// allocate the overloaded structure to return as a D3DXMESHCONTAINER
	pMeshContainer = new D3DXMESHCONTAINER_DERIVED;
	memset( pMeshContainer, 0, sizeof( D3DXMESHCONTAINER_DERIVED ) );

	// make sure and copy the name.  All memory as input belongs to caller, interfaces can be addref'd though
	hr = AllocateName( Name, &pMeshContainer->Name );
	if( FAILED( hr ) )
		goto e_Exit;

	pMesh->GetDevice( &pd3dDevice );
	NumFaces = pMesh->GetNumFaces();

	// if no normals are in the mesh, add them
	if( !( pMesh->GetFVF() & D3DFVF_NORMAL ) )
	{
		pMeshContainer->MeshData.Type = D3DXMESHTYPE_MESH;

		// clone the mesh to make room for the normals
		hr = pMesh->CloneMeshFVF( pMesh->GetOptions(), pMesh->GetFVF() | D3DFVF_NORMAL,
			pd3dDevice, &pMeshContainer->MeshData.pMesh );
		if( FAILED( hr ) )
			goto e_Exit;

		// get the new pMesh pointer back out of the mesh container to use
		// NOTE: we do not release pMesh because we do not have a reference to it yet
		pMesh = pMeshContainer->MeshData.pMesh;

		// now generate the normals for the pmesh
		D3DXComputeNormals( pMesh, NULL );
	}
	else  // if no normals, just add a reference to the mesh for the mesh container
	{
		pMeshContainer->MeshData.pMesh = pMesh;
		pMeshContainer->MeshData.Type = D3DXMESHTYPE_MESH;

		pMesh->AddRef();
	}

	// allocate memory to contain the material information.  This sample uses
	//   the D3D9 materials and texture names instead of the EffectInstance style materials
	pMeshContainer->NumMaterials = max( 1, NumMaterials );
	pMeshContainer->pMaterials = new D3DXMATERIAL[pMeshContainer->NumMaterials];
	pMeshContainer->ppTextures = new LPDIRECT3DTEXTURE9[pMeshContainer->NumMaterials];
	pMeshContainer->pAdjacency = new DWORD[NumFaces*3];

	memcpy( pMeshContainer->pAdjacency, pAdjacency, sizeof( DWORD ) * NumFaces*3 );
	memset( pMeshContainer->ppTextures, 0, sizeof( LPDIRECT3DTEXTURE9 ) * pMeshContainer->NumMaterials );

	// if materials provided, copy them
	if( NumMaterials > 0 )
	{
		memcpy( pMeshContainer->pMaterials, pMaterials, sizeof( D3DXMATERIAL ) * NumMaterials );

		for( iMaterial = 0; iMaterial < NumMaterials; iMaterial++ )
		{
			if( pMeshContainer->pMaterials[iMaterial].pTextureFilename != NULL )
			{
				if( FAILED( D3DXCreateTextureFromFileA( pd3dDevice, pMeshContainer->pMaterials[iMaterial].pTextureFilename,
					&pMeshContainer->ppTextures[iMaterial] ) ) )
					pMeshContainer->ppTextures[iMaterial] = NULL;

				// don't remember a pointer into the dynamic memory, just forget the name after loading
				pMeshContainer->pMaterials[iMaterial].pTextureFilename = NULL;
			}
		}
	}
	else // if no materials provided, use a default one
	{
		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 there is skinning information, save off the required data and then setup for HW skinning
	if( pSkinInfo != NULL )
	{
		// first save off the SkinInfo and original mesh data
		pMeshContainer->pSkinInfo = pSkinInfo;
		pSkinInfo->AddRef();

		pMeshContainer->pOrigMesh = pMesh;
		pMesh->AddRef();

		// Will need an array of offset matrices to move the vertices from the figure space to the bone's space
		cBones = pSkinInfo->GetNumBones();
		pMeshContainer->pBoneOffsetMatrices = new D3DXMATRIX[cBones];

		// get each of the bone offset matrices so that we don't need to get them later
		for( iBone = 0; iBone < cBones; iBone++ )
		{
			pMeshContainer->pBoneOffsetMatrices[iBone] = *( pMeshContainer->pSkinInfo->GetBoneOffsetMatrix( iBone ) );
		}

		// GenerateSkinnedMesh will take the general skinning information and transform it to a HW friendly version
		hr = GenerateSkinnedMesh( pd3dDevice, pMeshContainer );
		if( FAILED( hr ) )
			goto e_Exit;
	}

	*ppNewMeshContainer = pMeshContainer;
	pMeshContainer = NULL;

e_Exit:
	SAFE_RELEASE( pd3dDevice );

	// call Destroy function to properly clean up the memory allocated 
	if( pMeshContainer != NULL )
	{
		DestroyMeshContainer( pMeshContainer );
	}

	return hr;
}

//--------------------------------------------------------------------------------------
// Name: CAllocateHierarchy::DestroyFrame()
// Desc: 释放骨骼框架
//--------------------------------------------------------------------------------------
HRESULT CAllocateHierarchy::DestroyFrame( LPD3DXFRAME pFrameToFree )
{
	SAFE_DELETE_ARRAY( pFrameToFree->Name );
	SAFE_DELETE( pFrameToFree );
	return S_OK;
}

//--------------------------------------------------------------------------------------
// Name: CAllocateHierarchy::DestroyMeshContainer()
// Desc: 释放网格容器
//--------------------------------------------------------------------------------------
HRESULT CAllocateHierarchy::DestroyMeshContainer( LPD3DXMESHCONTAINER pMeshContainerBase )
{
	UINT iMaterial;
	D3DXMESHCONTAINER_DERIVED* pMeshContainer = ( D3DXMESHCONTAINER_DERIVED* )pMeshContainerBase;

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

	// release all the allocated textures
	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->pBoneCombinationBuf );
	SAFE_RELEASE( pMeshContainer->MeshData.pMesh );
	SAFE_RELEASE( pMeshContainer->pSkinInfo );
	SAFE_RELEASE( pMeshContainer->pOrigMesh );
	SAFE_DELETE( pMeshContainer );
	return S_OK;
}

//--------------------------------------------------------------------------------------
// Name: SetupBoneMatrixPointers()
// Desc: 设置好各级框架的组合变换矩阵。
//--------------------------------------------------------------------------------------
HRESULT SetupBoneMatrixPointers( LPD3DXFRAME pFrameBase, LPD3DXFRAME pFrameRoot )
{
	if( pFrameBase->pMeshContainer != NULL )
	{
		D3DXFRAME_DERIVED* pFrame = NULL;
		D3DXMESHCONTAINER_DERIVED* pMeshContainer = (D3DXMESHCONTAINER_DERIVED*)pFrameBase->pMeshContainer;

		// if there is a skinmesh, then setup the bone matrices
		if (pMeshContainer->pSkinInfo != NULL)
		{
			UINT cBones = pMeshContainer->pSkinInfo->GetNumBones();
			pMeshContainer->ppBoneMatrixPtrs = new D3DXMATRIX*[cBones];
			for (UINT iBone = 0; iBone < cBones; iBone++)
			{
				pFrame = (D3DXFRAME_DERIVED*)D3DXFrameFind(pFrameRoot, pMeshContainer->pSkinInfo->GetBoneName(iBone));
				if (pFrame == NULL) return E_FAIL;

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

	if (pFrameBase->pFrameSibling != NULL)
	{
		if (FAILED(SetupBoneMatrixPointers(pFrameBase->pFrameSibling, pFrameRoot)))
			return E_FAIL;
	}

	if (pFrameBase->pFrameFirstChild != NULL)
	{
		if (FAILED(SetupBoneMatrixPointers(pFrameBase->pFrameFirstChild, pFrameRoot)))
			return E_FAIL;
	}

	return S_OK;
}

//--------------------------------------------------------------------------------------
// Name: DrawMeshContainer()
// Desc: 绘制蒙皮容器中的蒙皮网格
//--------------------------------------------------------------------------------------
void DrawMeshContainer( IDirect3DDevice9* pd3dDevice, LPD3DXMESHCONTAINER pMeshContainerBase, LPD3DXFRAME pFrameBase )
{
	D3DXMESHCONTAINER_DERIVED* pMeshContainer = ( D3DXMESHCONTAINER_DERIVED* )pMeshContainerBase;
	D3DXFRAME_DERIVED* pFrame = ( D3DXFRAME_DERIVED* )pFrameBase;
	UINT iMaterial;
	UINT NumBlend;
	UINT iAttrib;
	DWORD AttribIdPrev;
	LPD3DXBONECOMBINATION pBoneComb;

	UINT iMatrixIndex;
	D3DXMATRIXA16 matTemp;
	D3DCAPS9 d3dCaps;
	pd3dDevice->GetDeviceCaps( &d3dCaps );

	// first check for skinning
	if( pMeshContainer->pSkinInfo != NULL )
	{
		AttribIdPrev = UNUSED32;
		pBoneComb = reinterpret_cast<LPD3DXBONECOMBINATION>( pMeshContainer->pBoneCombinationBuf->GetBufferPointer() );

		// Draw using default vtx processing of the device (typically HW)
		for( iAttrib = 0; iAttrib < pMeshContainer->NumAttributeGroups; iAttrib++ )
		{
			NumBlend = 0;
			for( DWORD i = 0; i < pMeshContainer->NumInfl; ++i )
			{
				if( pBoneComb[iAttrib].BoneId[i] != UINT_MAX )
				{
					NumBlend = i;
				}
			}

			if( d3dCaps.MaxVertexBlendMatrices >= NumBlend + 1 )
			{
				// first calculate the world matrices for the current set of blend weights and get the accurate count of the number of blends
				for( DWORD i = 0; i < pMeshContainer->NumInfl; ++i )
				{
					iMatrixIndex = pBoneComb[iAttrib].BoneId[i];
					if( iMatrixIndex != UINT_MAX )
					{
						D3DXMatrixMultiply( &matTemp, &pMeshContainer->pBoneOffsetMatrices[iMatrixIndex],
							pMeshContainer->ppBoneMatrixPtrs[iMatrixIndex] );
						pd3dDevice->SetTransform( D3DTS_WORLDMATRIX( i ), &matTemp );
					}
				}

				pd3dDevice->SetRenderState( D3DRS_VERTEXBLEND, NumBlend );

				// lookup the material used for this subset of faces
				if( ( AttribIdPrev != pBoneComb[iAttrib].AttribId ) || ( AttribIdPrev == UNUSED32 ) )
				{
					pd3dDevice->SetMaterial( &pMeshContainer->pMaterials[pBoneComb[iAttrib].AttribId].MatD3D );
					pd3dDevice->SetTexture( 0, pMeshContainer->ppTextures[pBoneComb[iAttrib].AttribId] );
					AttribIdPrev = pBoneComb[iAttrib].AttribId;
				}

				// draw the subset now that the correct material and matrices are loaded
				pMeshContainer->MeshData.pMesh->DrawSubset( iAttrib );
			}
		}
		pd3dDevice->SetRenderState( D3DRS_VERTEXBLEND, 0 );
	}
	else  // standard mesh, just draw it after setting material properties
	{
		pd3dDevice->SetTransform( D3DTS_WORLD, &pFrame->CombinedTransformationMatrix );

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


//--------------------------------------------------------------------------------------
// Name: DrawFrame()
// Desc: 绘制骨骼
//--------------------------------------------------------------------------------------
void DrawFrame( IDirect3DDevice9* pd3dDevice, LPD3DXFRAME pFrame )
{
	if (pFrame == NULL) return;
	LPD3DXMESHCONTAINER pMeshContainer;
	pMeshContainer = pFrame->pMeshContainer;                    // 取得网格容器
	while( pMeshContainer != NULL )                      
	{
		DrawMeshContainer(pd3dDevice, pMeshContainer, pFrame);  // 绘制非空蒙皮网格
		pMeshContainer = pMeshContainer->pNextMeshContainer;    // 遍历所有网格容器
	}

	DrawFrame(pd3dDevice, pFrame->pFrameSibling);               // 绘制兄弟框架
	DrawFrame(pd3dDevice, pFrame->pFrameFirstChild);            // 绘制子框架
}

//--------------------------------------------------------------------------------------
// Name: UpdateFrameMatrics()
// Desc: 更新框架中的变换矩阵
//--------------------------------------------------------------------------------------
void UpdateFrameMatrices( LPD3DXFRAME pFrameBase, LPD3DXMATRIX pParentMatrix )
{
	if (pFrameBase == NULL || pParentMatrix == NULL) return;
	D3DXFRAME_DERIVED* pFrame = ( D3DXFRAME_DERIVED* )pFrameBase;

	// 将当前骨骼的相对于父骨骼的偏移矩阵作累积运算
	D3DXMatrixMultiply(&pFrame->CombinedTransformationMatrix, &pFrame->TransformationMatrix, pParentMatrix);

	UpdateFrameMatrices(pFrame->pFrameSibling, pParentMatrix);                              // 更新兄弟骨骼
	UpdateFrameMatrices(pFrame->pFrameFirstChild, &pFrame->CombinedTransformationMatrix);   // 更新子骨骼
}

2.2 骨骼动画文件

另外，本次使用的”张飞“X文件中对骨骼动画的存放，只存放了一个名为”Anim-1 “的动画，也就是说用这个X模型中就只有这一个动画。这个动画是浅墨在3DS Max中自己导出的，具体导入方式我们下次再讲（其实就是在panda插件中选项调一下）。在3.X文件，我们就可以找到这个用AnimationSet 来定义的Anim-1 的动画集出处，开头部分如下：
在这里插入图片描述

2.2.1 3dmax文件导出骨骼动画文件步骤

1.3dsmax2012打开有骨骼动画的3d文件
在这里插入图片描述
让模型只显示骨骼不显示线框:有几种解决方案，

第一种，隐藏几何体，简单粗暴（shift+G),
第二种，主工具栏里有个选择过滤器（默然是全部，即全部物体都能选择），下拉修改为骨骼，
第三种，冻结你要绑定那东西，右键冻结。

如果你是在蒙皮绑定的话，当然用第二种。调节动作的话，当然，最方便也是第二种。
在这里插入图片描述
2.添加插件
为了能把max文件导出为.x文件，需要给3dsmax添加插件，把这个文件解压，拷贝到

在这里插入图片描述
在这里插入图片描述
因为3dsmax安装的是32位的，所以对应安装插件（2012一般默认安装有该插件）

3.把max文件导出为.x文件（文件名3.x）
在这里插入图片描述

导出动画
  1. 具体设置
    在这里插入图片描述
  2. 具体设置
    在这里插入图片描述
    3.动画设置
    Key Options——帧类型，可以是Position, Scale & Rotate keys,也可以直接用__矩阵替换

Add…——可以添加第2，到多个动作组
在这里插入图片描述
4.纹理
texture converted——可以将贴图与.X文件一起输出

scaled to nearest power of 2——贴图缩放到2^幂

Format——输出类型，可以使用各种DirectX支持的纹理格式（bmp,tga,png,jpg）

Use full pathname——是否用完整路径名。（一般不使用绝对路径）
在这里插入图片描述
5.dx文件设置
DX File Type——同上

DX frame——框架结构，如果前面选择Include Animation，就不能选No frame

Top frame hierarchy——顶框架结构，所有框架在同一顶层

Sub frame hierarchy——子框架结构。父框架会影响子框架位置（MAX中的连接操作），对作IK有好处，但矩阵要经过多次变换才能传递到子框架

Left Handed Axis——左手坐标系，一般使用左手坐标系
在这里插入图片描述
6.x文件内容，并把它拷贝到相应的项目文件下
在这里插入图片描述

2.3 加载3.x文件

主代码

#pragma comment(lib,"d3d9.lib")	
#pragma comment(lib,"d3dx9.lib")	
#pragma comment(lib,"winmm.lib")	

#include "d3dUtility.h"
#include <fstream>
#include <vector>
#include "AllocateHierarchyClass.h"

//
// Globals
//

IDirect3DDevice9* Device = 0; 

const int Width  = 640;
const int Height = 480;

LPD3DXFRAME                 g_pFrameRoot      = NULL;
D3DXMATRIX*                 g_pBoneMatrices   = NULL;
CAllocateHierarchy*         g_pAllocateHier   = NULL;
LPD3DXANIMATIONCONTROLLER   g_pAnimController = NULL;
//
// Framework functions
//
bool Setup()
{

	
		//第4步：创建骨骼动画
	g_pAllocateHier = new CAllocateHierarchy();
	D3DXLoadMeshHierarchyFromX(L"3.X", D3DXMESH_MANAGED, Device, 
	                            g_pAllocateHier, NULL, &g_pFrameRoot, &g_pAnimController);
	SetupBoneMatrixPointers(g_pFrameRoot, g_pFrameRoot);

	//因为这个X文件中仅有一个默认的动作，所以以下代码可用可不用
// 	LPD3DXANIMATIONSET pAnimationSet = NULL;
// 	g_pAnimController->GetAnimationSetByName("sworddance", &pAnimationSet);
// 	g_pAnimController->SetTrackAnimationSet((UINT)1.0, pAnimationSet);


	//灯光
	D3DXVECTOR3 dir(1.0f, -1.0f, 1.0f);
	D3DXCOLOR col(1.0f, 1.0f, 1.0f, 1.0f);
	D3DLIGHT9 light = d3d::InitDirectionalLight(&dir, &col);
	
	Device->SetLight(0,&light);
	Device->LightEnable(0,true);
	Device->SetRenderState(D3DRS_NORMALIZENORMALS, true);
	Device->SetRenderState(D3DRS_SPECULARENABLE, true);
	
	//
	// Set camera.
	//

	D3DXVECTOR3 pos(0.0f, 0.0f, -15.0f);
	D3DXVECTOR3 target(0.0f, 0.0f, 0.0f);
	D3DXVECTOR3 up(0.0f, 1.0f, 0.0f);

	D3DXMATRIX V;
	D3DXMatrixLookAtLH(
		&V,
		&pos,
		&target,
		&up);

	Device->SetTransform(D3DTS_VIEW, &V);

	//
	// Set projection matrix.
	//

	D3DXMATRIX proj;
	D3DXMatrixPerspectiveFovLH(
			&proj,
			D3DX_PI * 0.5f, // 90 - degree
			(float)Width / (float)Height,
			1.0f,
			1000.0f);
	Device->SetTransform(D3DTS_PROJECTION, &proj);

	return true;
}

void Cleanup()
{

}

bool Display(float timeDelta)
{
	if( Device )
	{

	// 设置骨骼动画的矩阵
	D3DXMATRIX matFinal , matScal, matRot,matTran;
	D3DXMatrixIdentity(&matFinal);
	D3DXMatrixScaling(&matScal, 0.2f, 0.2f,0.2f);
	D3DXMatrixRotationX(&matRot,0.0*(2.0f*D3DX_PI)/360.f);
	D3DXMatrixTranslation(&matTran,0,-4.0f,0);
	matFinal = matScal *matFinal*matRot*matTran;
	Device->SetTransform(D3DTS_WORLD, &matFinal);

	// 更新骨骼动画
	g_pAnimController->AdvanceTime(timeDelta, NULL);  //设置骨骼动画的时间
	UpdateFrameMatrices(g_pFrameRoot, &matFinal);   //更新框架中的变换矩阵

		Device->Clear(0, 0, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xffffffff, 1.0f, 0);
		Device->BeginScene();

		DrawFrame(Device, g_pFrameRoot);

		Device->EndScene();
		Device->Present(0, 0, 0, 0);
	}
	return true;
}

//
// WndProc
//
LRESULT CALLBACK d3d::WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
	switch( msg )
	{
	case WM_DESTROY:
		::PostQuitMessage(0);
		break;
		
	case WM_KEYDOWN:
		if( wParam == VK_ESCAPE )
			::DestroyWindow(hwnd);
		break;
	}
	return ::DefWindowProc(hwnd, msg, wParam, lParam);
}

//
// WinMain
//
int WINAPI WinMain(HINSTANCE hinstance,
				   HINSTANCE prevInstance, 
				   PSTR cmdLine,
				   int showCmd)
{
	if(!d3d::InitD3D(hinstance,
		Width, Height, true, D3DDEVTYPE_HAL, &Device))
	{
		::MessageBox(0, L"InitD3D() - FAILED", 0, 0);
		return 0;
	}
		
	if(!Setup())
	{
		::MessageBox(0, L"Setup() - FAILED", 0, 0);
		return 0;
	}

	d3d::EnterMsgLoop( Display );

	Cleanup();

	Device->Release();

	return 0;
}

2.3 运行结果

在这里插入图片描述

在这里插入图片描述

szmtjs10
关注
专栏目录
Directx 9.0/9.0c 在vs2010 里面的环境配置
sevnape的专栏
09-26 1304
PS:因为vs2008 express实在没有VassistX插件，怒转vs
《DirectX 9.0 3D游戏开发编程基础》-第一篇-VS2010下安装配置DirectX9 runtime和SDK
cheerfullchen的专栏
03-18 3301
在编写DirectX 9 程序之前首先要安装DirectX9 runtime和Direct9 SDK 一、DirectX9 下载 可以到官网下载DirectX9 runtime和Direct9 SDK(Software Development Kit) 下载地址：http://www.microsoft.com/en-us/download/details.aspx?id=6812 这个下
VS2010+DX9+Assimp使用(3)
szmtjs10的博客
05-28 446
3.VS2010+DX9情况下加载动画控制 1.主代码添加控制动作代码 #pragma comment(lib,"d3d9.lib") #pragma comment(lib,"d3dx9.lib") #pragma comment(lib,"winmm.lib") #include "d3dUtility.h" #include <fstream> #include <vector> #include "AllocateHierarchyClass.h" // // Gl
vs2010中c#调用directx 9.0 direct3d画二维图形的方法
06-19
vs2010中c#调用directx 9.0 direct3d画二维图形的方法，文档中包括详细的配置，以及初始化等操作。需要自己下载directx 9.0的sdk并安装。 在c#工程中，我添加了两个panel，按下对应的button会画出两个对称的三角形
VS2010配置DirectX 9.0 3D常见问题
Handz_cpp的专栏
07-02 4512
最近在看《DirectX 9.0 3D游戏开发编程基础》这本书（也就是大家熟知的龙书）。然后遇到了配置上的各种问题，工具使用的是VS2010，下面将这个纠结的配置问题贴出来，希望能够帮到像我这样的新人。 注意：如果你报的错误是： 1>d3dUtility.obj : error LNK2019: 无法解析的外部符号 _Direct3DCreate9@4，该符号在函数 "bool
在Windows下使用MinGW静态编译Assimp
热门推荐
开发游戏，辉煌全中国
05-25 2万+
Assimp是目前比较全的3D格式解析库了，熟悉3D游戏开发的同行都知道，3D的格式非常混乱，各种3D格式在不同场合都有他们特定的应用，游戏引擎只能够解析少部分3D格式，更多实用的格式来自游戏公司自定义的格式。而在开源领域，Assimp算是比较全的3D格式导入库了。它对3D格式理解深入，很适合整合至3D图形引擎中，让你们的程序支持更多3D的格式。
LearnOpenGL教程 模型加载库Assimp 遇到问题
weixin_42416791的博客
10-31 1196
LearnOpenGL教程 模型加载库Assimp 遇到问题1.cmake模型加载库Assimp: cannot find IL解决方案：2.教程给的代码报错:解决方案：3.执行代码时候报错：找不到dll文件参考教程 1.cmake模型加载库Assimp: cannot find IL 刚开始和教程给的一样，cmake模型加载库Assimp时候有遇到找不到directX： 去官网下载即可： 安装direcX时候也有下面问题： 去卸载Microsoft Visual C++ 2010 Redistri
OpenGL ES 学习教程 六 使用开源库 Assimp 将 Obj 模型 转换成自己的格式
qq_43667944的博客
01-30 401
OpenGL ES 学习教程 六 使用开源库 Assimp 将 Obj 模型 转换成自己的格式
LearnOpengl_assimp模型导入库
qq_40742335的博客
08-29 360
这篇文章主要记录一下opengl加载模型并显示的过程，涉及到了assimp库的下载、cmake编译、配置，以及Vertex、Mesh、Model对象的封装，使得我们可以直接使用一条指令就可以绘制一个包含多个网格的模型。 一、assimp库的下载、编译、配置 1.github的下载速度只有20kb，所以我们将github的工程转移到国内的gitee上进行下载。 2.使用cmke编译assimp源代码时，会出现缺少dx的报错，我们需要下载安装dx，安装dx时我们需要先卸载掉c++ 2010 Redistribu
qt opengl assimp 加载骨骼动画完整代码
05-22
这里是一个简单的使用Qt、OpenGL和Assimp库加载带有骨骼动画的模型的示例代码： ```cpp #include #include #include #include #include #include #include #include <assimp/Importer.hpp> #include <assimp...
assimp库文件（lib,dll）
11-08
assimp的库文件（lib,dll）,win10,x64，可放到python相关目录下
assimp源码+vs2019编译的 32位lib+64位lib
03-23
现在市面上有一个很流行的模型加载库，叫做Assimp，全称为Open Asset Import Library。Assimp可以导入几十种不同格式的模型文件（同样也可以导出部分模型格式）。里面有32位，64位库及源码。64位lib对应的dll文件忘记放里面了，我重新上传了dll文件，链接：https://download.csdn.net/download/yxh505613923/12265460
OpenGL step by step 38 ： Skeletal Animation with Assimp
weixin_34408717的博客
11-01 199
一般骨架模型由两部分组成： Rigging(bone)：相当于骨架，可以用来控制模型的动作 Mesh(skin)：相当于表面皮肤   骨架模型一般是层级结构的，比如上面 背骨是root，他的孩子包括胳膊、腿，手指就是再下一层的结构。当父结构运动时，带动子结构也运动。而子结构运动时，父结构不一定运动。 图形引擎制作动画： 对于每个顶点添加一个槽数组，每个槽包含一个骨骼的ID和权重。此处给每个数组...
第三十八课 用 Assimp 导入骨骼动画
翻肚鱼儿的博客
07-20 1464
第三十八课 用 Assimp 导入骨骼动画 背景 这一课中将会介绍很多读者期盼已久的东西——骨骼动画，在这一课中我们将使用 Assimp 库来导入骨骼动画。 骨骼动画实际上是有两个处理过程的，第一个过程是由美术人员进行的，第二个过程则是由作为程序员的你（或者你写的引擎）来进行的。第一个过程通常是美术人员借助于建模软件对骨骼动画进行装配，借助于建模软件，美术人员在模型网格之下定义了骨架的骨骼。网格代表着对象的表面（这个对象可能是人、怪物或者其他任何东西），骨骼则用于模拟真实世界中网格的运动，它是通过将顶
如何配置DirectX开发环境
weixin_33967071的博客
11-04 499
一个DirectX程序要想正确的编译和链接，需要下面三个主要前提 安装DirectX SDK 正确配置.h文件路径和.lib文件路径 正确链接所需.lib文件 安装DirectX SDK 可以直接到微软的官方网站上下载最新的SDK，Microsoft DirectX SDK(June 2010)是微软发型的最后一个独立的DX SDK，以后则不再单独发行DX SDK，而是集成到Wi...
VS2017+DirectX9环境配置
wo16pao的博客
02-09 4428
正好学完浅墨大神的游戏编程著作，来写一下VS2017怎么配置DirectX9 首先去下一个DX9的SDK SDK下载 然后找地方安装上，不过可能安装会出问题，我的情况解决方式如下 去控制面板里面卸载掉这两个东西 然后再安装下载下来的DXSDK 接下来去VS2017里面进行配置 首先创建一个Win32的空项目 我将其改为了64位 添加一个main.cpp文件 然后右键项目->属性 V...
关于vs2017如何配置和运行龙书DX9案例
Love柒的博客
12-31 5118
关于vs2017如何配置和运行龙书DX9案例首先是运行环境 Visual Studio 2017（我用的社区版） DXSDK_Jun10（下载地址） 下面就是配置环境了-1、 下载的DXSDK_Jun10.exe双击进行安装，安装完毕后会有一个文件夹：Microsoft DirectX SDK (June 2010)（我使用的是默认安装文件夹位置在：C:\Program Files (x86) ）
OpenGL学习总结（五）
xiewenzhao123的博客
01-18 2335
OpenGL模型加载——Assimp1、Assimp模型加载库Assimp全称为Open Asset Import Library，可以导入几十种不同格式的模型文件（同样也可以导出部分模型格式）。只要Assimp加载完了模型文件，我们就可以从Assimp上获取所有我们需要的模型数据。Assimp把不同的模型文件都转换为一个统一的数据结构，所有无论我们导入何种格式的模型文件，都可以用同一个方式去访问我
【OpenCV&OpenGL&Marker-based AR】原理部分-骨骼动画
o0o
08-27 1021
文章目录说在前面骨骼动画说明原理 说在前面 opencv版本：4.0.1 opencv aruco版本：4.0.1 opengl：使用glad、glfw 模型导入：Assimp ar实现：基于标记(marker) visual studio版本：2017 原理部分：【OpenCV&amp;OpenGL&amp;AR】原理部分 骨骼动画 说明 主要还是OpenGL的知识点，参考Tutor...
mov+dx+offset+input
最新发布
10-21
mov+dx+offset+input是汇编语言中的一种指令，用于将数据从内存中读取到寄存器中。其中，DX是一个寄存器，用于存储内存地址的偏移量；OFFSET是一个运算符，用于获取变量在内存中的地址；input是一个变量名，表示需要读取的数据。通过这个指令，我们可以将用户输入的数据从内存中读取到寄存器中，以便进行后续的处理。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

szmtjs10

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值