c3_phy.cpp

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

	fwrite ( &lpPhy->uvstep.x, sizeof ( float ), 1, file );
	chunk.dwChunkSize += sizeof ( float );

	fwrite ( &lpPhy->uvstep.y, sizeof ( float ), 1, file );
	chunk.dwChunkSize += sizeof ( float );

	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 Phy_Unload ( C3Phy **lpPhy )
{
	SafeDeleteEx ( ( *lpPhy )->lpName );
	SafeDeleteEx ( ( *lpPhy )->lpVB );
	SafeRelease ( ( *lpPhy )->vb );
	SafeDeleteEx ( ( *lpPhy )->lpIB );
	SafeRelease ( ( *lpPhy )->ib );
	SafeDeleteEx ( ( *lpPhy )->lpTexName );


	SafeDeleteEx ( ( *lpPhy )->Key.lpAlphas );
	SafeDeleteEx ( ( *lpPhy )->Key.lpDraws );
	SafeDeleteEx ( ( *lpPhy )->Key.lpChangeTexs );

	SafeDelete ( *lpPhy );
}
C3_CORE_DLL_API
void Phy_Prepare ( void )
{
	SetRenderState ( D3DRS_ZENABLE, true );
	SetRenderState ( D3DRS_ZWRITEENABLE, true );
	SetRenderState ( D3DRS_SHADEMODE, D3DSHADE_GOURAUD );
	SetRenderState ( D3DRS_DITHERENABLE, true );
	SetRenderState ( D3DRS_CULLMODE, D3DCULL_CW );
	SetRenderState ( D3DRS_AMBIENTMATERIALSOURCE, D3DMCS_COLOR2 );
	SetRenderState ( D3DRS_DIFFUSEMATERIALSOURCE, D3DMCS_COLOR2 );

	SetTextureStageState ( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
	SetTextureStageState ( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
	SetTextureStageState ( 0, D3DTSS_COLOROP, D3DTOP_MODULATE );

	SetTextureStageState ( 0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE );
	SetTextureStageState ( 0, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE );
	SetTextureStageState ( 0, D3DTSS_ALPHAOP, D3DTOP_MODULATE );

	SetTextureStageState ( 0, D3DTSS_MINFILTER, D3DTEXF_LINEAR );
	SetTextureStageState ( 0, D3DTSS_MAGFILTER, D3DTEXF_LINEAR );
	SetTextureStageState ( 0, D3DTSS_MIPFILTER, D3DTEXF_LINEAR );

	SetTextureStageState ( 1, D3DTSS_COLORARG1, D3DTA_TEXTURE );
	SetTextureStageState ( 1, D3DTSS_COLORARG2, D3DTA_CURRENT );
	SetTextureStageState ( 1, D3DTSS_COLOROP, D3DTOP_DISABLE );

	SetTextureStageState ( 1, D3DTSS_ALPHAARG1, D3DTA_TEXTURE );
	SetTextureStageState ( 1, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE );
	SetTextureStageState ( 1, D3DTSS_ALPHAOP, D3DTOP_DISABLE );

	SetTextureStageState ( 1, D3DTSS_MINFILTER, D3DTEXF_NONE );
	SetTextureStageState ( 1, D3DTSS_MAGFILTER, D3DTEXF_NONE );
	SetTextureStageState ( 1, D3DTSS_MIPFILTER, D3DTEXF_NONE );
}
C3_CORE_DLL_API
BOOL Phy_Calculate ( C3Phy *lpPhy )
{
	float alpha;
	if ( Key_ProcessAlpha ( &lpPhy->Key, lpPhy->lpMotion->nFrame, 
lpPhy->lpMotion->dwFrames, &alpha ) )
		lpPhy->fA = alpha;

	BOOL draw;
	if ( Key_ProcessDraw ( &lpPhy->Key, lpPhy->lpMotion->nFrame, &draw ) )
		lpPhy->bDraw = draw;

	int tex = -1;
	Key_ProcessChangeTex ( &lpPhy->Key, lpPhy->lpMotion->nFrame, &tex );

	if ( !lpPhy->bDraw )
		return true;


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

	D3DXMATRIX *bone = new D3DXMATRIX[lpPhy->lpMotion->dwBoneCount];
	for ( DWORD b = 0; b < lpPhy->lpMotion->dwBoneCount; b++ )
	{
		D3DXMATRIXA16 mm;
		Motion_GetMatrix ( lpPhy->lpMotion, b, &mm );
/*
		D3DXMatrixMultiply ( &bone[b],
							 &lpPhy->InitMatrix, 
							 &lpPhy->lpMotion->lpFrames[b * lpPhy->lpMotion->dwFrames + 
							 lpPhy->lpMotion->nFrame] );
*/
		D3DXMatrixMultiply ( &bone[b],
							 &lpPhy->InitMatrix, 
							 &mm );

		//bone[b] = lpPhy->InitMatrix;

		D3DXMatrixMultiply ( &bone[b],
							 &bone[b],
							 &lpPhy->lpMotion->matrix[b] );
	}

	// 计算皮肤
	for ( DWORD v = 0; v < lpPhy->dwNVecCount + lpPhy->dwAVecCount; v++ )
	{
		D3DXVECTOR3 mix = lpPhy->lpVB[v].pos[0];
		// 计算 MORPH
/*		BOOL zero[3] = { true, true, true };
		for ( DWORD m = 0; m < lpPhy->lpMotion->dwMorphCount; m++ )
		{
			// x
			if ( FloatCmp ( lpPhy->lpVB[v].pos[0].x, lpPhy->lpVB[v].pos[m + 1].x ) != 
0 )
			{
				mix.x += ( lpPhy->lpVB[v].pos[m + 1].x - lpPhy->lpVB[v].pos[0].x ) * 
lpPhy->lpMotion->lpMorph[lpPhy->lpMotion->dwMorphCount * 
lpPhy->lpMotion->nFrame + m];
			}
			// y
			if ( FloatCmp ( lpPhy->lpVB[v].pos[0].y, lpPhy->lpVB[v].pos[m + 1].y ) != 
0 )
			{
				mix.y += ( lpPhy->lpVB[v].pos[m + 1].y - lpPhy->lpVB[v].pos[0].y ) * 
lpPhy->lpMotion->lpMorph[lpPhy->lpMotion->dwMorphCount * 
lpPhy->lpMotion->nFrame + m];
			}
			// z
			if ( FloatCmp ( lpPhy->lpVB[v].pos[0].z, lpPhy->lpVB[v].pos[m + 1].z ) != 
0 )
			{
				mix.z += ( lpPhy->lpVB[v].pos[m + 1].z - lpPhy->lpVB[v].pos[0].z ) * 
lpPhy->lpMotion->lpMorph[lpPhy->lpMotion->dwMorphCount * 
lpPhy->lpMotion->nFrame + m];
			}
		}

*/


		// 计算骨骼
		D3DXVECTOR3 vec;

		vertex[v].x = 0;
		vertex[v].y = 0;
		vertex[v].z = 0;

		for ( int l = 0; l < 2; l++ )
		{
			DWORD index = lpPhy->lpVB[v].index[l];
			float weight = lpPhy->lpVB[v].weight[l];

			if ( lpPhy->lpVB[v].weight[l] > 0 )
			{

/*				D3DXVec3TransformCoord ( &vec,
										 &mix,
										 &lpPhy->InitMatrix );
				D3DXVec3TransformCoord ( &vec,
										 &vec,
										 &lpPhy->lpMotion->lpFrames[index * lpPhy->lpMotion->dwFrames + 
										 lpPhy->lpMotion->nFrame] );
				D3DXVec3TransformCoord ( &vec,
										 &vec,
										 &lpPhy->lpMotion->matrix[index] );*/

				D3DXVec3TransformCoord ( &vec,
										 &mix,
										 &bone[index] );

				//D3DXVec3Scale ( &vec, &vec, weight );
				D3DXVec3Add ( ( D3DXVECTOR3* )&vertex[v],
							  ( D3DXVECTOR3* )&vertex[v],
							  &vec );
				break;
			}
		}

		//接口内部只改变改变x, y
//		D3DXVec2Add ( ( D3DXVECTOR2* )&vertex[v],
//					  ( D3DXVECTOR2* )&vertex[v],
//					  &lpPhy->uvstep );
		//要改变u, v
		vertex[v].u = vertex[v].u + lpPhy->uvstep.x;
		vertex[v].v = vertex[v].v + lpPhy->uvstep.y;

		if ( tex > -1 )
		{
			float segsize = 1.0f / lpPhy->dwTexRow;
			vertex[v].u = lpPhy->lpVB[v].u + tex % lpPhy->dwTexRow * segsize;
			vertex[v].v = lpPhy->lpVB[v].v + tex / lpPhy->dwTexRow * segsize;
		}
	}
	if ( FAILED ( lpPhy->vb->Unlock () ) )
		return false;

	delete [] bone;

	return true;
}
C3_CORE_DLL_API
BOOL Phy_DrawNormal ( C3Phy *lpPhy )
{
	if ( !lpPhy->bDraw )
		return true;

	if ( lpPhy->dwNTriCount > 0 && lpPhy->fA == 1.0f )
	{
		SetRenderState ( D3DRS_ALPHABLENDENABLE, false );
		SetRenderState ( D3DRS_ALPHATESTENABLE, false );
		SetRenderState ( D3DRS_ZWRITEENABLE, true );

		// material
		D3DMATERIAL8 material;
		ZeroMemory ( &material, sizeof ( material ) );

		material.Diffuse.a = lpPhy->fA;
		material.Diffuse.r = lpPhy->fR;
		material.Diffuse.g = lpPhy->fG;
		material.Diffuse.b = lpPhy->fB;

		material.Ambient.a = lpPhy->fA;
		material.Ambient.r = lpPhy->fR;
		material.Ambient.g = lpPhy->fG;
		material.Ambient.b = lpPhy->fB;

		if ( FAILED ( g_D3DDevice->SetMaterial ( &material ) ) )
			return false;


		// texture
		if ( lpPhy->nTex == -1 )
		{
			if ( FAILED ( g_D3DDevice->SetTexture ( 0, 0 ) ) )
				return false;
		}
		else
		{
			if ( !g_lpTex[lpPhy->nTex] )
				return false;

			if ( FAILED ( g_D3DDevice->SetTexture ( 0, g_lpTex[lpPhy->nTex]->lpTex ) ) )
				return false;
		}

		D3DXMATRIXA16 matrix;
		D3DXMatrixIdentity ( &matrix );
		g_D3DDevice->SetTransform ( D3DTS_WORLD, &matrix );
		if ( FAILED ( g_D3DDevice->SetVertexShader ( PHY_OUT_VERTEX ) ) )
			return false;

		if ( FAILED ( g_D3DDevice->SetStreamSource ( 0, lpPhy->vb, sizeof ( 
PhyOutVertex ) ) ) )
			return false;
		if ( FAILED ( g_D3DDevice->SetIndices ( lpPhy->ib, 0 ) ) )
			return false;

		// draw normal
		if ( FAILED ( g_D3DDevice->DrawIndexedPrimitive ( D3DPT_TRIANGLELIST,
														  0,
														  lpPhy->dwNVecCount,
														  0,
														  lpPhy->dwNTriCount ) ) )
			return false;
	}
	return true;
}
C3_CORE_DLL_API
BOOL Phy_DrawAlpha ( C3Phy *lpPhy, BOOL bZ, int nAsb, int nAdb )
{
	if ( !lpPhy->bDraw )
		return true;

	if ( ( lpPhy->dwNTriCount > 0 && lpPhy->fA != 1.0f ) ||
		 ( lpPhy->dwATriCount > 0 ) )
	{
		SetRenderState ( D3DRS_ZWRITEENABLE, bZ );

		SetRenderState ( D3DRS_ALPHABLENDENABLE, true );
		SetRenderState ( D3DRS_SRCBLEND, nAsb );
		SetRenderState ( D3DRS_DESTBLEND, nAdb );

		SetRenderState ( D3DRS_ALPHATESTENABLE, true );
		SetRenderState ( D3DRS_ALPHAREF, 0x08 );
		SetRenderState ( D3DRS_ALPHAFUNC, D3DCMP_GREATEREQUAL );

		// material
		D3DMATERIAL8 material;
		ZeroMemory ( &material, sizeof ( material ) );

		material.Diffuse.a = lpPhy->fA;
		material.Diffuse.r = lpPhy->fR;
		material.Diffuse.g = lpPhy->fG;
		material.Diffuse.b = lpPhy->fB;

		material.Ambient.a = lpPhy->fA;
		material.Ambient.r = lpPhy->fR;
		material.Ambient.g = lpPhy->fG;
		material.Ambient.b = lpPhy->fB;

		if ( FAILED ( g_D3DDevice->SetMaterial ( &material ) ) )
			return false;

		// texture
		if ( lpPhy->nTex == -1 )
		{
			if ( FAILED ( g_D3DDevice->SetTexture ( 0, 0 ) ) )
				return false;
		}
		else
		{
			if ( !g_lpTex[lpPhy->nTex])
				return false;

			if ( FAILED ( g_D3DDevice->SetTexture ( 0, g_lpTex[lpPhy->nTex]->lpTex ) 
) )
				return false;
		}

		D3DXMATRIXA16 matrix;
		D3DXMatrixIdentity ( &matrix );
		g_D3DDevice->SetTransform ( D3DTS_WORLD, &matrix );
		if ( FAILED ( g_D3DDevice->SetVertexShader ( PHY_OUT_VERTEX ) ) )
			return false;

		if ( FAILED ( g_D3DDevice->SetStreamSource ( 0, lpPhy->vb, sizeof ( 
PhyOutVertex ) ) ) )
			return false;
		if ( FAILED ( g_D3DDevice->SetIndices ( lpPhy->ib, 0 ) ) )
			return false;
	}
	if ( lpPhy->dwNTriCount > 0 && lpPhy->fA != 1.0f )
	{
		// draw normal
		if ( FAILED ( g_D3DDevice->DrawIndexedPrimitive ( D3DPT_TRIANGLELIST,
														  0,
														  lpPhy->dwNVecCount,
														  0,
														  lpPhy->dwNTriCount ) ) )
			return false;
	}
	if ( lpPhy->dwATriCount > 0 )
	{
		// draw alpha
		if ( FAILED ( g_D3DDevice->DrawIndexedPrimitive ( D3DPT_TRIANGLELIST,
														  lpPhy->dwNVecCount,
														  lpPhy->dwAVecCount,
														  lpPhy->dwNTriCount * 3,
														  lpPhy->dwATriCount ) ) )
			return false;
	}
	return true;
}
C3_CORE_DLL_API
void Phy_NextFrame ( C3Phy *lpPhy, int nStep )
{
	lpPhy->lpMotion->nFrame = ( lpPhy->lpMotion->nFrame + nStep ) % 
lpPhy->lpMotion->dwFrames;
}

C3_CORE_DLL_API
void Phy_SetFrame ( C3Phy *lpPhy, DWORD dwFrame )
{
	if(lpPhy->lpMotion->dwFrames == 0)
		lpPhy->lpMotion->nFrame = 0;
	else
		lpPhy->lpMotion->nFrame = dwFrame % lpPhy->lpMotion->dwFrames;
}

C3_CORE_DLL_API
void Phy_Muliply ( C3Phy *lpPhy, int nBoneIndex, D3DXMATRIXA16 *matrix )
{
	int start, end;
	if ( nBoneIndex == -1 )
	{
		start = 0;
		end = lpPhy->lpMotion->dwBoneCount;
	}
	else
	{
		start = nBoneIndex;
		end = start + 1;
	}
	for ( int n = start; n < end; n++ )
	{
		D3DXMatrixMultiply ( &lpPhy->lpMotion->matrix[n],
							 &lpPhy->lpMotion->matrix[n],
							 matrix );
	}
}
C3_CORE_DLL_API
void Phy_SetColor ( C3Phy *lpPhy,
					float alpha,
					float red,
					float green,
					float blue )
{
	lpPhy->fA = alpha;
	lpPhy->fR = red;
	lpPhy->fG = green;
	lpPhy->fB = blue;
}

C3_CORE_DLL_API
void Phy_ClearMatrix ( C3Phy *lpPhy )
{
	// 清除运动矩阵
	for ( DWORD n = 0; n < lpPhy->lpMotion->dwBoneCount; n ++ )
		D3DXMatrixIdentity ( &lpPhy->lpMotion->matrix[n] );
}

C3_CORE_DLL_API
void Phy_ChangeTexture ( C3Phy *lpPhy, int nTexID, int nTexID2)
{
	lpPhy->nTex = nTexID;
	lpPhy->nTex2 = nTexID2;
}

/*C3_CORE_DLL_API
void Phy_LookAt ( C3Phy *lpPhy,
				  int nAxis,
				  D3DXMATRIX *lpRet )
{
	D3DXVECTOR3 camera = g_From - g_To;
	D3DXVECTOR3 axis;

	switch ( nAxis )
	{
	case 0: // x
		camera.x = 0;

		axis.x = 0;
		axis.y = 0;
		axis.z = -1;
		break;
	case 1: // y
		camera.y = 0;

		axis.x = -1;
		axis.y = 0;
		axis.z = 0;
		break;
	case 2: // z
		camera.z = 0;

		axis.x = 0;
		axis.y = -1;
		axis.z = 0;
		break;
	};

	D3DXVec3Normalize ( &camera, &camera );
	D3DXVec3Normalize ( &axis, &axis );

	float radian = ( float )acosf ( D3DXVec3Dot ( &axis, &camera ) );

	switch ( nAxis )
	{
	case 0: // x
		if ( camera.y < 0 )
			radian = D3DX_PI * 2 - radian;
		D3DXMatrixRotationX ( lpRet, radian );
		break;
	case 1: // y
		if ( camera.z < 0 )
			radian = D3DX_PI * 2 - radian;
		D3DXMatrixRotationY ( lpRet, radian );
		break;
	case 2: // z
		if ( camera.x < 0 )
			radian = D3DX_PI * 2 - radian;
		D3DXMatrixRotationZ ( lpRet, radian );
		break;
	};
}*/