xskinmesh.h

VC++ DEMO, used for the beginners and the amour

#ifdef CGE_HEADER_H

#ifndef CGE_XSKINMESH_H
#define CGE_XSKINMESH_H

namespace CGE
{
	namespace MODEL
	{
		namespace XFILE
		{
			enum 
			{
				D3DNONINDEXED,
					D3DINDEXED,
					SOFTWARE,
					NONE
			};
			
			// X File formation rotate key
			struct RotateKeyXFile
			{
				DWORD			dwTime;
				DWORD			dwFloats;	
				FLOAT			w;
				FLOAT			x;
				FLOAT			y;
				FLOAT			z;
			};
			
			struct ScaleKeyXFile
			{
				DWORD	dwTime;
				DWORD	dwFloats;	
				D3DXVECTOR3	vScale;	
			};
			
			
			struct PositionKeyXFile
			{
				DWORD	dwTime;
				DWORD	dwFloats;	
				D3DXVECTOR3	vPos;	
			};
			
			struct MatrixKeyXFile
			{
				DWORD	dwTime;
				DWORD	dwFloats;	
				D3DXMATRIXA16	mat;	
			};
			
			// in memory versions
			
			struct RotateKey
			{
				DWORD			dwTime;
				D3DXQUATERNION	quatRotate;	
			};
			
			struct PositionKey
			{
				DWORD	dwTime;
				D3DXVECTOR3	vPos;	
			};
			
			struct ScaleKey
			{
				DWORD	dwTime;
				D3DXVECTOR3	vScale;	
			};
			
			struct MatrixKey
			{
				DWORD	dwTime;
				D3DXMATRIXA16	mat;	
			};
			
			struct Mesh
			{
				ID3DXMesh *m_pMesh;

				DWORD m_cMaterials;
				D3DMATERIAL8 *m_rgMaterials;
				LPDIRECT3DTEXTURE8 *m_pTextures;

				
				Mesh *m_pNext;
				
				TCHAR *m_szName;
				
				// Skin info
				LPD3DXSKINMESH m_pSkinMesh;

				DWORD m_cpattr;
				DWORD m_iAttrSplit;
				D3DXATTRIBUTERANGE *m_pAttrTable;

				DWORD			m_numBoneComb;
				D3DXMATRIXA16** m_pBoneMatrix;

				LPD3DXBUFFER	m_pBoneNamesBuf;
				LPD3DXBUFFER	m_pBoneOffsetBuf;
				D3DXMATRIXA16*  m_pBoneOffsetMat;

				DWORD*			m_rgiAdjacency;
				DWORD			m_maxFaceInfl;
				LPD3DXBUFFER	m_pBoneCombinationBuf;

				UINT			m_Method;
				DWORD			m_paletteSize;
				BOOL			m_bUseSW;

				D3DXVECTOR3     m_vMin, m_vMax;      // Bounding box
				FLOAT           m_fRadius;          // Bounding sphere

				Mesh()
					:m_pMesh(NULL),
					m_rgMaterials(NULL),
					m_pTextures(NULL),
					m_cpattr(0),
					m_iAttrSplit(0),
					m_cMaterials(0),
					m_pNext(NULL),
					m_szName(NULL),
					m_pSkinMesh(NULL),
					m_pAttrTable(NULL),
					m_pBoneMatrix(NULL),
					m_pBoneNamesBuf(NULL),
					m_pBoneOffsetBuf(NULL),
					m_pBoneOffsetMat(NULL),
					m_rgiAdjacency(NULL),
					m_numBoneComb(0),
					m_maxFaceInfl(0),
					m_pBoneCombinationBuf(NULL),
					m_Method(NONE),
					m_paletteSize(0),
					m_bUseSW(FALSE),
					m_fRadius(0)
				{
					m_vMin.x = m_vMin.y = m_vMin.z = 0;
					m_vMax.x = m_vMax.y = m_vMax.z = 0;
				}
				
				~Mesh()
				{
					SAFE_DELETE_ARRAY(m_rgMaterials);
					
					if (m_pTextures)
					{
						for (DWORD i = 0; i < m_cMaterials; ++i)
						{
							SAFE_RELEASE(m_pTextures[i]);
						}
						SAFE_DELETE_ARRAY(m_pTextures);
					}
					
					SAFE_RELEASE(m_pMesh);
					SAFE_RELEASE(m_pSkinMesh);
					SAFE_RELEASE(m_pBoneNamesBuf);
					SAFE_RELEASE(m_pBoneOffsetBuf);
					SAFE_RELEASE(m_pBoneCombinationBuf);
					
					SAFE_DELETE_ARRAY(m_pBoneMatrix);					
					SAFE_DELETE_ARRAY(m_pAttrTable);		
					SAFE_DELETE_ARRAY(m_szName);
					SAFE_DELETE_ARRAY(m_rgiAdjacency);
					SAFE_DELETE(m_pNext);
				}
			};
			
			struct Frame
			{
				TCHAR * m_pName;
				D3DXMATRIXA16 m_matRot;
				D3DXMATRIXA16 m_matTrans;
				D3DXMATRIXA16 m_matOrig;
				D3DXMATRIXA16 m_matCombined;
				
				Mesh * m_pMeshList;
				Frame *m_pSibling;
				Frame *m_pChild;
				Frame *m_pParent;
				Frame() 
				{
					m_pName = NULL;
					m_pMeshList = NULL;
					D3DXMatrixIdentity(&m_matCombined);
					D3DXMatrixIdentity(&m_matTrans);
					D3DXMatrixIdentity(&m_matRot);
					D3DXMatrixIdentity(&m_matOrig);
					m_pParent = m_pSibling = m_pChild = NULL;
				}
				
				~Frame()
				{
					SAFE_DELETE(m_pName);
					SAFE_DELETE(m_pChild);
					SAFE_DELETE(m_pSibling);
				}
				
				Frame *FindFrame(TCHAR *pName)
				{
					Frame *Frame;
					
					// Return this instance if name == NULL
					if(pName == NULL)
						return this;
					
					// Compare names and return if exact match
					if( m_pName != NULL && !_tcscmp(pName, m_pName))
						return this;
					
					// Search child lists
					if(m_pChild != NULL) {
						if((Frame = m_pChild->FindFrame(pName)) != NULL)
							return Frame;
					}
					
					// Search sibling lists
					if(m_pSibling != NULL) {
						if((Frame = m_pSibling->FindFrame(pName)) != NULL)
							return Frame;
					}
					
					return NULL;
				}
				
				
				VOID MatricesOrigin()
				{
					m_matTrans = m_matOrig;
					if(m_pChild != NULL)
						m_pChild->MatricesOrigin();
					if(m_pSibling != NULL)
						m_pSibling->MatricesOrigin();      
				}
			};

			struct Animation
			{
				TCHAR *m_pName;
				BOOL m_bLoop;
				BOOL m_bLinear;
				TCHAR *m_pFrameName;
				Frame *m_pFrame;
				
				DWORD m_dwKeyType;
				
				DWORD m_dwNumPositionKey;
				PositionKey *m_pPositionKey;
				
				DWORD m_dwNumRotateKey;
				RotateKey *m_pRotateKey;
				
				DWORD m_dwNumMatrixKey;
				MatrixKey *m_pMatrixKey;
				
				DWORD m_dwNumScaleKey;
				ScaleKey *m_pScaleKey;
				
				VOID SetAnimationCyc(FLOAT fPassTime, FLOAT fSpeed );
				
				Animation *m_pNext;

				Animation()
				{
					m_dwKeyType = 0;
					m_dwNumRotateKey = 0;
					m_dwNumMatrixKey = 0;
					m_dwNumScaleKey = 0;
					m_dwNumPositionKey = 0;
					
					m_pPositionKey = NULL;
					m_pRotateKey = NULL;
					m_pMatrixKey = NULL;
					m_pScaleKey = NULL;
					
					m_pNext = NULL;
					m_pName = NULL;
					m_pFrameName = NULL;
					m_pFrame = NULL;
					m_bLoop = TRUE;
				}
				~Animation()
				{
					SAFE_DELETE_ARRAY(m_pName);
					SAFE_DELETE_ARRAY(m_pFrameName);
					SAFE_DELETE_ARRAY(m_pRotateKey);
					SAFE_DELETE_ARRAY(m_pMatrixKey);
					SAFE_DELETE_ARRAY(m_pScaleKey);
					SAFE_DELETE_ARRAY(m_pPositionKey);
					SAFE_DELETE(m_pNext);
				}
			};
			
			//Define the sAnimationSet
			struct AnimationSet 
			{
				TCHAR		 *m_pName;	
				Animation	 *m_pAnim;
				AnimationSet *m_pNext;
				Frame		 *m_pParent;
				
				AnimationSet()
				{
					m_pName = NULL;
					m_pAnim = NULL;
					m_pNext = NULL;
					m_pParent = NULL;
				}
				
				~AnimationSet()
				{
					SAFE_DELETE_ARRAY(m_pName);
					SAFE_DELETE(m_pNext);
				}
			};
			
			typedef class XSKINMESH
			{
			public:
				XSKINMESH();
				virtual ~XSKINMESH();

				VOID	SetAnimationSet( TCHAR * szName );
				BOOL	ReadMeshHierarchy(TCHAR * strFileName,LPDIRECT3DDEVICE8 device,
										  DWORD dwMeshOptions,UINT nDrawMethod = SOFTWARE);
				VOID	SetMediaFilePath( TCHAR * strFilePath );
				VOID	AnimationMesh(FLOAT fTime, const D3DXMATRIXA16 & matCur,FLOAT fSpeed);
				VOID	DrawSkinMesh();
				VOID	GetBoundBox(D3DXVECTOR3 &vMin, D3DXVECTOR3 &vMax){vMin = m_vMin;vMax = m_vMax;}
				FLOAT	GetBoundRadius()		{	return m_fRadius;	}
				Frame * GetRootFrame() { return m_pRootFrame; }
			protected:
				AnimationSet * FindAnimationSet( const TCHAR * szName);		
				Frame * ReadFrame(IDirectXFileData *pDataObj, Frame *pParentFrame);
				BOOL	ParseXFileData(IDirectXFileData *pDataObj, Frame *pParentFrame);
				BOOL	ReadAnimationSet(IDirectXFileData *pDataObj, Frame *pParentFrame);
				BOOL	ReadAnimation(IDirectXFileData *pDataObj, AnimationSet *pParentFrame);
				BOOL	ReadSkinMesh(IDirectXFileData *pDataObj, Frame *pParentFrame);
				BOOL	MakeSkinMesh( Mesh * pMesh);
				VOID	SetMeshAnimations(Frame * pParentFrame);
				VOID	UpdateFrame( Frame * pFrame,const D3DXMATRIXA16 * matCur);
				VOID	SetMeshBones(Frame * pParentFrame);
				VOID	DrawFrame(Frame * pFrame);
				VOID	DrawOriginalMesh( Mesh * pMesh );
				VOID	LinkAllMesh(Frame * pParentFrame);
			protected:
				D3DCAPS8			m_d3dCaps;
				FLOAT				m_fRadius;
				D3DXVECTOR3			m_vMin;
				D3DXVECTOR3 	    m_vMax;
				DWORD				m_dwMeshOptions;
				UINT				m_nMethod;
				TCHAR				m_strFilePath[MAX_PATH];
				UINT				m_maxBones;
				Frame *				m_pRootFrame;
				Mesh *				m_pMeshList;
				AnimationSet *		m_pAnimationSet;
				AnimationSet *		m_pAnimationCur;
				D3DXMATRIXA16 *		m_pBoneMatrices;
				LPDIRECT3DDEVICE8	m_pD3DDevice;
				DWORD				m_dwIndexedVertexShader[4];
			}*LPXSKINMESH;
		}
	}
}
#endif
#endif