c3_phy.cpp

网络游戏魔域的服务端与客户端完整源代码 包括详细的说明文档与开发日志

#include "..\include\c3_phy.h"
#include "..\include\c3_main.h"
#include "..\include\c3_datafile.h"
#include "..\include\nvtristrip.h"

C3_CORE_DLL_API
void Motion_Clear ( C3Motion *lpMotion )
{
	lpMotion->dwBoneCount = 0;
	lpMotion->dwFrames = 0;
	lpMotion->nFrame = 0;
	//lpMotion->lpFrames = 0;

	lpMotion->dwKeyFrames = 0;
	lpMotion->lpKeyFrame = 0;

	lpMotion->matrix = 0;
	lpMotion->nFrame = 0;
	lpMotion->dwMorphCount = 0;
	lpMotion->lpMorph = 0;
}

C3_CORE_DLL_API
BOOL Motion_LoadPack ( C3Motion **lpMotion, HANDLE f )
{
	*lpMotion = new C3Motion;
	Motion_Clear ( *lpMotion );
	DWORD bytes ;

	// bone
	ReadFile ( f, &( *lpMotion )->dwBoneCount, sizeof ( DWORD ), &bytes, 0 ) ;

	// matrix
	ReadFile ( f, &( *lpMotion )->dwFrames, sizeof ( DWORD ), &bytes, 0 ) ;

	( *lpMotion )->matrix = new D3DXMATRIXA16[( *lpMotion )->dwBoneCount];
	for ( DWORD n = 0; n < ( *lpMotion )->dwBoneCount; n++ )
		D3DXMatrixIdentity ( &( *lpMotion )->matrix[n] );

/*	ReadFile (	f,
				( *lpMotion )->lpFrames,
				sizeof ( D3DXMATRIX ) * ( *lpMotion )->dwBoneCount * ( *lpMotion )->dwFrames,
				&bytes,
				0 ) ;*/

	// 是否有关键帧
	char kf[4];
	ReadFile ( f, kf, sizeof ( char ) * 4, &bytes, 0 ) ;
	if ( kf[0] == 'K' &&
		 kf[1] == 'K' &&
		 kf[2] == 'E' &&
		 kf[3] == 'Y' )
	{
		ReadFile ( f, &( *lpMotion )->dwKeyFrames, sizeof ( DWORD ), &bytes, 0 ) ;
		( *lpMotion )->lpKeyFrame = new C3KeyFrame[( *lpMotion )->dwKeyFrames];

		for ( DWORD kk = 0; kk < ( *lpMotion )->dwKeyFrames; kk++ )
		{
			ReadFile ( f,
					   &( *lpMotion )->lpKeyFrame[kk].pos,
					   sizeof ( DWORD ),
					   &bytes,
					   0 ) ;

			( *lpMotion )->lpKeyFrame[kk].matrix = new D3DXMATRIXA16[( *lpMotion )->dwBoneCount];
			ReadFile ( f,
					   ( *lpMotion )->lpKeyFrame[kk].matrix,
					   sizeof ( D3DXMATRIX ),	
					   &bytes,
					   0 ) ;
		}
	}
	else if (	kf[0] == 'X' &&
		kf[1] == 'K' &&
		kf[2] == 'E' &&
		kf[3] == 'Y' )
	{	// 减小C3大小, 去掉运动矩阵中 14, 24, 34, 44的格式
		ReadFile ( f, &( *lpMotion )->dwKeyFrames, sizeof ( DWORD ), &bytes, 0 ) ;
		( *lpMotion )->lpKeyFrame = new C3KeyFrame[( *lpMotion )->dwKeyFrames];
		
		for ( DWORD kk = 0; kk < ( *lpMotion )->dwKeyFrames; kk++ )
		{
			WORD wPos = 0;
			ReadFile ( f,
				&wPos,
				sizeof ( WORD ),	// 注意这儿也减小了节省 2 个字节. :)
				&bytes,
				0 );
			
			( *lpMotion )->lpKeyFrame[kk].pos = ( DWORD )wPos;
			
			( *lpMotion )->lpKeyFrame[kk].matrix = new D3DXMATRIXA16[( *lpMotion )->dwBoneCount];
			
			struct TIDY_MATRIX {
				float        _11, _12, _13;
				float        _21, _22, _23;
				float        _31, _32, _33;
				float        _41, _42, _43;				
			};
			
			TIDY_MATRIX mx[256];	// 骨骼数不可能超过256
			ReadFile ( f,
				&mx, 
				sizeof ( TIDY_MATRIX ) * ( *lpMotion )->dwBoneCount,
				&bytes,
				0 );
			
			for ( DWORD bb = 0; bb < ( *lpMotion )->dwBoneCount; bb++ )
			{
				( *lpMotion )->lpKeyFrame[kk].matrix[bb]._11 = mx[bb]._11;
				( *lpMotion )->lpKeyFrame[kk].matrix[bb]._12 = mx[bb]._12;
				( *lpMotion )->lpKeyFrame[kk].matrix[bb]._13 = mx[bb]._13;
				( *lpMotion )->lpKeyFrame[kk].matrix[bb]._14 = 0.0f;
				
				( *lpMotion )->lpKeyFrame[kk].matrix[bb]._21 = mx[bb]._21;
				( *lpMotion )->lpKeyFrame[kk].matrix[bb]._22 = mx[bb]._22;
				( *lpMotion )->lpKeyFrame[kk].matrix[bb]._23 = mx[bb]._23;
				( *lpMotion )->lpKeyFrame[kk].matrix[bb]._24 = 0.0f;
				
				( *lpMotion )->lpKeyFrame[kk].matrix[bb]._31 = mx[bb]._31;
				( *lpMotion )->lpKeyFrame[kk].matrix[bb]._32 = mx[bb]._32;
				( *lpMotion )->lpKeyFrame[kk].matrix[bb]._33 = mx[bb]._33;
				( *lpMotion )->lpKeyFrame[kk].matrix[bb]._34 = 0.0f;
				
				( *lpMotion )->lpKeyFrame[kk].matrix[bb]._41 = mx[bb]._41;
				( *lpMotion )->lpKeyFrame[kk].matrix[bb]._42 = mx[bb]._42;
				( *lpMotion )->lpKeyFrame[kk].matrix[bb]._43 = mx[bb]._43;
				( *lpMotion )->lpKeyFrame[kk].matrix[bb]._44 = 1.0f;
			}			
		}
	}
	else
	{
		SetFilePointer ( f, -4, 0, FILE_CURRENT ) ;
		( *lpMotion )->dwKeyFrames = ( *lpMotion )->dwFrames;
		( *lpMotion )->lpKeyFrame = new C3KeyFrame[( *lpMotion )->dwFrames];

		for ( DWORD kk = 0; kk < ( *lpMotion )->dwFrames; kk++ )
		{
			( *lpMotion )->lpKeyFrame[kk].pos = kk;
			( *lpMotion )->lpKeyFrame[kk].matrix = new D3DXMATRIXA16[( *lpMotion )->dwBoneCount];
		}
		for ( DWORD bb = 0; bb < ( *lpMotion )->dwBoneCount; bb++ )
		{
			for ( DWORD kk = 0; kk < ( *lpMotion )->dwFrames; kk++ )
			{
				ReadFile ( f,
						   ( *lpMotion )->lpKeyFrame[kk].matrix[bb],
						   sizeof ( D3DXMATRIX ),	
						   &bytes,
						   0 ) ;
			}
		}
	}


	// morph
	ReadFile ( f, &( *lpMotion )->dwMorphCount, sizeof ( DWORD ), &bytes, 0 ) ;

	( *lpMotion )->lpMorph = new float[( *lpMotion )->dwMorphCount * ( *lpMotion )->dwFrames];
	ReadFile (	f,
				( *lpMotion )->lpMorph,
				sizeof ( float ) * ( *lpMotion )->dwMorphCount * ( *lpMotion )->dwFrames,
				&bytes,
				0 ) ;
	return true ;
}

C3_CORE_DLL_API
BOOL Motion_Load ( C3Motion **lpMotion, FILE *file )
{
	*lpMotion = new C3Motion;
	Motion_Clear ( *lpMotion );
	
	// bone
	fread ( &( *lpMotion )->dwBoneCount, sizeof ( DWORD ), 1, file );
	
	// matrix
	fread ( &( *lpMotion )->dwFrames, sizeof ( DWORD ), 1, file );
	
	( *lpMotion )->matrix = new D3DXMATRIXA16[( *lpMotion )->dwBoneCount];
	for ( DWORD n = 0; n < ( *lpMotion )->dwBoneCount; n++ )
		D3DXMatrixIdentity ( &( *lpMotion )->matrix[n] );
	
	// 是否有关键帧
	char kf[4];
	fread ( kf, sizeof ( char ), 4, file );
	if ( kf[0] == 'K' &&
		kf[1] == 'K' &&
		kf[2] == 'E' &&
		kf[3] == 'Y' )
	{
		fread ( &( *lpMotion )->dwKeyFrames, sizeof ( DWORD ), 1, file );
		( *lpMotion )->lpKeyFrame = new C3KeyFrame[( *lpMotion )->dwKeyFrames];
		
		for ( DWORD kk = 0; kk < ( *lpMotion )->dwKeyFrames; kk++ )
		{
			fread ( &( *lpMotion )->lpKeyFrame[kk].pos,
				sizeof ( DWORD ),
				1,
				file );
			
			( *lpMotion )->lpKeyFrame[kk].matrix = new D3DXMATRIXA16[( *lpMotion )->dwBoneCount];
			fread ( ( *lpMotion )->lpKeyFrame[kk].matrix,
				sizeof ( D3DXMATRIX ),
				( *lpMotion )->dwBoneCount,
				file );
		}
	}
	else if (	kf[0] == 'Z' &&
		kf[1] == 'K' &&
		kf[2] == 'E' &&
		kf[3] == 'Y' )
	{	// 用运动分量购置运动矩阵, 减小数据冗余信息
		fread ( &( *lpMotion )->dwKeyFrames, sizeof ( DWORD ), 1, file );
		( *lpMotion )->lpKeyFrame = new C3KeyFrame[( *lpMotion )->dwKeyFrames];
		
		for ( DWORD kk = 0; kk < ( *lpMotion )->dwKeyFrames; kk++ )
		{
			WORD wPos = 0;
			fread ( &wPos,
				sizeof ( WORD ),	// 注意这儿也减小了节省 2 个字节. :)
				1,
				file );
			
			( *lpMotion )->lpKeyFrame[kk].pos = ( DWORD )wPos;
			
			( *lpMotion )->lpKeyFrame[kk].matrix = new D3DXMATRIXA16[( *lpMotion )->dwBoneCount];
			
			
			struct DIV_INFO {
				D3DXQUATERNION	quaternion;	// 旋转数据
				float x, y, z;				// 位移数据
			};
			
			DIV_INFO mx[256];	// 骨骼数不可能超过256
			fread ( &mx, sizeof ( DIV_INFO ), ( *lpMotion )->dwBoneCount, file );
			
			for ( DWORD bb = 0; bb < ( *lpMotion )->dwBoneCount; bb++ )
			{
				::D3DXMatrixIdentity( &( *lpMotion )->lpKeyFrame[kk].matrix[bb] );
				
				::D3DXMatrixRotationQuaternion( &( *lpMotion )->lpKeyFrame[kk].matrix[bb], &mx[bb].quaternion );
				
				( *lpMotion )->lpKeyFrame[kk].matrix[bb]._41 = mx[bb].x;
				( *lpMotion )->lpKeyFrame[kk].matrix[bb]._42 = mx[bb].y;
				( *lpMotion )->lpKeyFrame[kk].matrix[bb]._43 = mx[bb].z;
				( *lpMotion )->lpKeyFrame[kk].matrix[bb]._44 = 1.0f;
			}			
		}
	}
	else
	{
		fseek ( file, -4, SEEK_CUR );

		( *lpMotion )->dwKeyFrames = ( *lpMotion )->dwFrames;
		( *lpMotion )->lpKeyFrame = new C3KeyFrame[( *lpMotion )->dwFrames];

		for ( DWORD kk = 0; kk < ( *lpMotion )->dwFrames; kk++ )
		{
			( *lpMotion )->lpKeyFrame[kk].pos = kk;
			( *lpMotion )->lpKeyFrame[kk].matrix = new D3DXMATRIXA16[( *lpMotion )->dwBoneCount];
		}
		for ( DWORD bb = 0; bb < ( *lpMotion )->dwBoneCount; bb++ )
		{
			for ( DWORD kk = 0; kk < ( *lpMotion )->dwFrames; kk++ )
			{
				fread ( ( *lpMotion )->lpKeyFrame[kk].matrix[bb],
					sizeof ( D3DXMATRIX ),
					1,
					file );
			}
		}
	}

	
	// morph
	fread ( &( *lpMotion )->dwMorphCount, sizeof ( DWORD ), 1, file );
	
	( *lpMotion )->lpMorph = new float[( *lpMotion )->dwMorphCount * ( *lpMotion )->dwFrames];
	fread ( ( *lpMotion )->lpMorph,
			sizeof ( float ),
			( *lpMotion )->dwMorphCount * ( *lpMotion )->dwFrames,
			file );
	return true;
}

C3_CORE_DLL_API
BOOL Motion_Save ( char *lpName, C3Motion *lpMotion, BOOL bNew )
{
	FILE *file = fopen ( lpName, bNew ? "w+b" : "r+b" );
	if ( !file )
		return false;
	fseek ( file, 0, SEEK_END );

	// phy
	ChunkHeader chunk;
	chunk.byChunkID[0] = 'M';
	chunk.byChunkID[1] = 'O';
	chunk.byChunkID[2] = 'T';
	chunk.byChunkID[3] = 'I';
	chunk.dwChunkSize = 0;
	fwrite ( &chunk, sizeof ( chunk ), 1, file );

	// bone
	fwrite ( &lpMotion->dwBoneCount, sizeof ( DWORD ), 1, file );
	chunk.dwChunkSize += sizeof ( DWORD );

	// matrix
	fwrite ( &lpMotion->dwFrames, sizeof ( DWORD ), 1, file );
	chunk.dwChunkSize += sizeof ( DWORD );

	// key 标志
	char kf[4];
	kf[0] = 'K';
	kf[1] = 'K';
	kf[2] = 'E';
	kf[3] = 'Y';

	fwrite ( kf, sizeof ( char ), 4, file );
	chunk.dwChunkSize += sizeof ( char ) * 4;

	fwrite ( &lpMotion->dwKeyFrames,
			 sizeof ( DWORD ),
			 1,
			 file );
	chunk.dwChunkSize += sizeof ( DWORD );

	for ( DWORD kk = 0; kk < lpMotion->dwKeyFrames; kk++ )
	{
		fwrite ( &lpMotion->lpKeyFrame[kk].pos,
				 sizeof ( DWORD ),
				 1,
				 file );
		chunk.dwChunkSize += sizeof ( DWORD );

		fwrite ( lpMotion->lpKeyFrame[kk].matrix,
				 sizeof ( D3DXMATRIXA16 ),
				 lpMotion->dwBoneCount,
				 file );
		chunk.dwChunkSize += sizeof ( D3DXMATRIX ) * lpMotion->dwBoneCount;
	}

	// morph
	fwrite ( &lpMotion->dwMorphCount, sizeof ( DWORD ), 1, file );
	chunk.dwChunkSize += sizeof ( DWORD );

	fwrite ( lpMotion->lpMorph,
			 sizeof ( float ),
			 lpMotion->dwMorphCount * lpMotion->dwFrames,
			 file );
	chunk.dwChunkSize += sizeof ( float ) * lpMotion->dwMorphCount * lpMotion->dwFrames;

	fseek ( file, -( int )( chunk.dwChunkSize + sizeof ( chunk ) ), SEEK_CUR );
	fwrite ( &chunk, sizeof ( chunk ), 1, file );
	fseek ( file, 0, SEEK_END );

	fclose ( file );
	return true;
}

C3_CORE_DLL_API
void Motion_Unload ( C3Motion **lpMotion )
{
	for ( DWORD kk = 0; kk < ( *lpMotion )->dwKeyFrames; kk++ )
	{
		SafeDeleteEx ( ( *lpMotion )->lpKeyFrame[kk].matrix );
	}
	SafeDeleteEx ( ( *lpMotion )->lpKeyFrame );

	SafeDeleteEx ( ( *lpMotion )->matrix );
	SafeDeleteEx ( ( *lpMotion )->lpMorph );

	SafeDelete ( *lpMotion );
}

C3_CORE_DLL_API
void Motion_GetMatrix ( C3Motion *lpMotion, DWORD dwBone, D3DXMATRIXA16 
*lpMatrix )
{
	// alpha
	int sindex = -1;
	int eindex = -1;
	for ( int n = 0; n < ( int )lpMotion->dwKeyFrames; n++ )
	{
		if ( lpMotion->lpKeyFrame[n].pos <= ( DWORD )lpMotion->nFrame )
		{
			if ( sindex == -1 || n > sindex)
				sindex = n;
		}
		if ( lpMotion->lpKeyFrame[n].pos > ( DWORD )lpMotion->nFrame )
		{
			if ( eindex == -1 || n < eindex )
				eindex = n;
		}
	}
	if ( sindex == -1 && eindex > -1 )
	{
		*lpMatrix = lpMotion->lpKeyFrame[eindex].matrix[dwBone];
	}
	else
	if ( sindex > -1 && eindex == -1 )
	{
		*lpMatrix = lpMotion->lpKeyFrame[sindex].matrix[dwBone];
	}
	else
	if ( sindex > -1 && eindex > -1 )
	{
		*lpMatrix = lpMotion->lpKeyFrame[sindex].matrix[dwBone] + 
				   ( ( float )( lpMotion->nFrame - lpMotion->lpKeyFrame[sindex].pos ) / ( float )( lpMotion->lpKeyFrame[eindex].pos - lpMotion->lpKeyFrame[sindex].pos ) ) * 
				   ( lpMotion->lpKeyFrame[eindex].matrix[dwBone] - lpMotion->lpKeyFrame[sindex].matrix[dwBone] );
	}
}

C3_CORE_DLL_API
void Phy_Clear ( C3Phy *lpPhy )
{
	lpPhy->lpName = 0;

	lpPhy->dwBlendCount = 0;

	lpPhy->dwNVecCount = 0;		// 顶点数(普通顶点)
	lpPhy->dwAVecCount = 0;		// 顶点数(透明顶点)
	lpPhy->lpVB = 0;			// 顶点池(普通顶点/透明顶点)
	lpPhy->vb = 0;

	lpPhy->dwNTriCount = 0;		// 多边形数(普通多边形)
	lpPhy->dwATriCount = 0;		// 多边形数(透明多边形)
	lpPhy->lpIB = 0;			// 索引池(普通多边形/透明多边形)
	lpPhy->ib = 0;

	lpPhy->lpTexName = 0;
	lpPhy->nTex = -1;

	lpPhy->bboxMin.x = lpPhy->bboxMin.y = lpPhy->bboxMin.z = 0;
	lpPhy->bboxMax.x = lpPhy->bboxMax.y = lpPhy->bboxMax.z = 0;

	lpPhy->lpMotion = 0;

	lpPhy->fA = lpPhy->fR = lpPhy->fG = lpPhy->fB = 1.0f;
	lpPhy->bDraw = true;
	lpPhy->dwTexRow = 1;
	lpPhy->uvstep.x = 0;
	lpPhy->uvstep.y = 0;

	D3DXMatrixIdentity ( &lpPhy->InitMatrix );
}

C3_CORE_DLL_API
BOOL Phy_Load ( C3Phy **lpPhy, FILE *file, BOOL bTex )
{
	*lpPhy = new C3Phy;
	Phy_Clear ( *lpPhy );

	// 读入名称
	DWORD temp;
	fread ( &temp, sizeof ( unsigned long ), 1, file );
	( *lpPhy )->lpName = new char[temp + 1];
	fread ( ( *lpPhy )->lpName, 1, temp, file );
	( *lpPhy )->lpName[temp] = '\0';

	// blend
	fread ( &( *lpPhy )->dwBlendCount, sizeof ( DWORD ), 1, file );

	// vec count
	fread ( &( *lpPhy )->dwNVecCount, sizeof ( DWORD ), 1, file );
	fread ( &( *lpPhy )->dwAVecCount, sizeof ( DWORD ), 1, file );



	// 创建输出 vb
	if ( FAILED ( g_D3DDevice->CreateVertexBuffer ( ( ( *lpPhy )->dwNVecCount + ( *lpPhy )->dwAVecCount ) * sizeof ( PhyOutVertex ),
													D3DUSAGE_WRITEONLY,
													0,
													D3DPOOL_MANAGED,
													&( *lpPhy )->vb ) ) )
		return false;

	// 读取顶点
	( *lpPhy )->lpVB = new PhyVertex[( *lpPhy )->dwNVecCount + ( *lpPhy )->dwAVecCount];
	fread ( ( *lpPhy )->lpVB,
			sizeof ( PhyVertex ),
			( *lpPhy )->dwNVecCount + ( *lpPhy )->dwAVecCount,
			file );

	PhyOutVertex *vertex;
	if ( FAILED ( ( *lpPhy )->vb->Lock ( 0,
										 0,
										 ( BYTE** )&vertex,
										 D3DLOCK_NOSYSLOCK ) ) )
		return false;