nd_bitmap.cpp

网络游戏魔域源代码 测试可以完整变异

}

//------------------------------------------------------
//       ----------- C3DMotion -----------
//------------------------------------------------------
C3DMotion::C3DMotion ()
{
	for ( int n = 0; n < MOTION_MAX; n++ )
		m_motion[n] = 0;
	
	m_dwMotionNum = 0;
}

//------------------------------------------------------
C3DMotion::~C3DMotion ()
{
	Destroy ();
}

//------------------------------------------------------
bool C3DMotion::IsValid ( void )
{
	if ( m_motion )
		return true;
	return false;
}

//------------------------------------------------------
bool C3DMotion::Create ( char *filename )
{
#ifdef _ANALYSIS_ON
	g_dw3DMotionLoadAmount++;
	DWORD dwTimeAnalysis = ::TimeGet();
#endif	

	m_dwMotionNum = 0;
	int nSize ;
	Common_BeforeUseDnp();
	FILE* fp = Common_OpenDnp ( filename, nSize );
	
	if ( fp )
	{
		ChunkHeader chunk;
		int nOffset = 16 ;

		while ( nOffset < nSize )
		{
			Common_GetChunk ( fp, &chunk );
			nOffset += sizeof(ChunkHeader) ;
			if ( chunk.byChunkID[0] == 'M' &&
				 chunk.byChunkID[1] == 'O' &&
				 chunk.byChunkID[2] == 'T' &&
				 chunk.byChunkID[3] == 'I' )
			{
				if ( !Motion_Load ( &m_motion[m_dwMotionNum], fp ) )
					break;
				m_dwMotionNum++;
			}
			else
			{
				fp = Common_MoveDnpFPtr(fp, chunk.dwChunkSize);
			}
			nOffset += chunk.dwChunkSize ;
		}
	}
	Common_AfterUseDnp();
#ifdef _ANALYSIS_ON
	DWORD dwTimePass = ::TimeGet() - dwTimeAnalysis;
	g_dw3DMotionLoadTime += dwTimePass;
	g_dw3DMotionLoadTimeFrame += dwTimePass;
	if(g_dw3DMotionLoadTimeMax < dwTimePass)
		g_dw3DMotionLoadTimeMax = dwTimePass;	
#endif
	return (m_dwMotionNum>0);
}

//------------------------------------------------------
bool C3DMotion::Destroy ( void )
{
	for ( int n = 0; n < m_dwMotionNum; n++ )
		Motion_Unload ( &m_motion[n] );

	m_dwMotionNum	=0;
	return true;
}

//------------------------------------------------------
DWORD C3DMotion::GetFrameAmount()
{
	DWORD dwMax	=0;
	for ( int n = 0; n < m_dwMotionNum; n++ )
	{
		dwMax	=__max(dwMax, m_motion[n]->dwFrames);
	}
	
	return dwMax;
}

//------------------------------------------------------
//       ----------- C3DObj -----------
//------------------------------------------------------
C3DObj::C3DObj ()
{
	for ( int n = 0; n < PHY_MAX; n++ )
		m_phy[n] = 0;
	
	m_dwPhyNum = 0;
}

//------------------------------------------------------
C3DObj::~C3DObj ()
{
	Destroy ();
}

//------------------------------------------------------
bool C3DObj::IsValid ()
{
	if ( m_phy )
		return true;
	return false;
}

//------------------------------------------------------
bool C3DObj::Create ( char *filename )
{
#ifdef _ANALYSIS_ON
	g_dw3DObjLoadAmount++;
	DWORD dwTimeAnalysis = ::TimeGet();
#endif	
	if (!filename)
		return false;
	m_dwPhyNum = 0;
	for ( int n = 0; n < PHY_MAX; n++ )
		m_phy[n] = NULL;

	int nSize ;
	Common_BeforeUseDnp();
	FILE* fp = Common_OpenDnp ( filename, nSize );
	if ( fp )
	{
		ChunkHeader chunk;
		int nOffset = 16 ;

		while ( nOffset < nSize )
		{
			Common_GetChunk ( fp, &chunk );
			nOffset += sizeof (ChunkHeader);
			if ( chunk.byChunkID[0] == 'P' &&
				 chunk.byChunkID[1] == 'H' &&
				 chunk.byChunkID[2] == 'Y' &&
				 chunk.byChunkID[3] == ' ' )
			{
				if ( !Phy_Load ( &m_phy[m_dwPhyNum], fp ) )
					break;
				m_dwPhyNum++;
			}
			else
			{
				 fp = Common_MoveDnpFPtr( fp, chunk.dwChunkSize);
			}
			nOffset += chunk.dwChunkSize ;
		}
	}
	Common_AfterUseDnp();
/*	else
	{
		int nSize ;
		HANDLE f = Common_OpenResPack ( filename, nSize );
		if ( f )
		{
			ChunkHeader chunk;
			int nOffset = 16 ;
			DWORD bytes ;

			while ( nOffset < nSize )
			{
				ReadFile ( f, &chunk, sizeof ( ChunkHeader ), &bytes, 0 ) ;
				nOffset += bytes ;
				if ( chunk.byChunkID[0] == 'P' &&
					 chunk.byChunkID[1] == 'H' &&
					 chunk.byChunkID[2] == 'Y' &&
					 chunk.byChunkID[3] == ' ' )
				{
					if ( !Phy_LoadPack ( &m_phy[m_dwPhyNum], f ) )
						break;
					m_dwPhyNum++;
				}
				else
				{
					SetFilePointer ( f, chunk.dwChunkSize, 0, FILE_CURRENT ) ;
				}
				nOffset += chunk.dwChunkSize ;
			}
		}
	}*/




#ifdef _ANALYSIS_ON
	DWORD dwTimePass = ::TimeGet() - dwTimeAnalysis;
	g_dw3DObjLoadTime += dwTimePass;
	g_dw3DObjLoadTimeFrame += dwTimePass;
	if(g_dw3DObjLoadTimeMax < dwTimePass)
		g_dw3DObjLoadTimeMax = dwTimePass;	
#endif
	if (m_dwPhyNum > 0)
		return true;
	else
		return false;
}

//------------------------------------------------------
void C3DObj::Destroy ()
{
	for ( int n = 0; n < m_dwPhyNum; n++ )
		Phy_Unload ( &m_phy[n] );
}

//------------------------------------------------------
void C3DObj::Move ( float x, float y, float z )
{
	D3DXMATRIXA16 matrix;
	D3DXMatrixIdentity ( &matrix );
	Common_Translate ( &matrix, x, y, z );
	for ( int n = 0; n < m_dwPhyNum; n++ )
	{
		for ( int b = 0; b < m_phy[n]->lpMotion->dwBoneCount; b++ )
			Phy_Muliply ( m_phy[n], b, &matrix );
	}
}

//------------------------------------------------------
void C3DObj::Rotate	( float x, float y, float z )
{
	D3DXMATRIXA16 matrix;
	D3DXMatrixIdentity ( &matrix );
	Common_Rotate ( &matrix, x, y, z );
	for ( int n = 0; n < m_dwPhyNum; n++ )
	{
		for ( int b = 0; b < m_phy[n]->lpMotion->dwBoneCount; b++ )
			Phy_Muliply ( m_phy[n], b, &matrix );
	}
}

//------------------------------------------------------
void C3DObj::Scale	( float x, float y, float z )
{
	D3DXMATRIXA16 matrix;
	D3DXMatrixIdentity ( &matrix );
	Common_Scale ( &matrix, x, y, z );
	for ( int n = 0; n < m_dwPhyNum; n++ )
	{
		for ( int b = 0; b < m_phy[n]->lpMotion->dwBoneCount; b++ )
			Phy_Muliply ( m_phy[n], b, &matrix );
	}
}

//------------------------------------------------------
void C3DObj::SetMotion ( C3DMotion* pMotion )
{
	//if (m_dwPhyNum != pMotion->m_dwMotionNum)
	if (m_dwPhyNum > pMotion->m_dwMotionNum)
		return;
	
	for ( int n = 0; n < m_dwPhyNum; n++ )
		m_phy[n]->lpMotion	=pMotion->m_motion[n];
}

//------------------------------------------------------
void C3DObj::SetARGB ( float alpha, float red, float green, float blue )
{
	for ( int n = 0; n < m_dwPhyNum; n++ )
		Phy_SetColor ( m_phy[n], alpha, red, green, blue );
}

//------------------------------------------------------
int C3DObj::GetIndexByName ( char *lpName )
{
	for ( int n = 0; n < m_dwPhyNum; n++ )
	{
		if ( stricmp ( m_phy[n]->lpName, lpName ) == 0 )
			return n;
	}
	return -1;
}

//------------------------------------------------------
void C3DObj::NextFrame ( int nStep )
{
	for ( int n = 0; n < m_dwPhyNum; n++ )
		Phy_NextFrame ( m_phy[n], nStep );
}

//------------------------------------------------------
void C3DObj::SetFrame (DWORD dwFrame)
{
	for ( int n = 0; n < m_dwPhyNum; n++ )
		Phy_SetFrame ( m_phy[n], dwFrame );
}

//------------------------------------------------------
void C3DObj::Draw ( int type, float lightx, float lighty, float lightz, float sa, float sr, float sg, float sb )
{
	if (CMyBitmap::s_nShowMode != modeMesh)
		C3DObj::Prepare();
	
	for ( int n = 0; n < m_dwPhyNum; n++ )
	{
		if ( stricmp( m_phy[n]->lpName, _V_ARMET	) == 0 ||
			stricmp ( m_phy[n]->lpName,	_V_MISC		) == 0 ||
			stricmp ( m_phy[n]->lpName, _V_L_WEAPON ) == 0 ||
			stricmp ( m_phy[n]->lpName, _V_R_WEAPON ) == 0 ||
			stricmp ( m_phy[n]->lpName, _V_L_SHIELD ) == 0 ||
			stricmp ( m_phy[n]->lpName, _V_R_SHIELD ) == 0 ||
			stricmp ( m_phy[n]->lpName, _V_L_SHOE	) == 0 ||
			stricmp ( m_phy[n]->lpName, _V_R_SHOE	) == 0 ||
			stricmp ( m_phy[n]->lpName, _V_PET	) == 0 ||
			stricmp ( m_phy[n]->lpName, _V_BACK	) == 0 ||

			stricmp ( m_phy[n]->lpName, _V_HEAD	) == 0 ||
			stricmp ( m_phy[n]->lpName, _V_L_ARM) == 0 ||
			stricmp ( m_phy[n]->lpName, _V_R_ARM) == 0 ||
			stricmp ( m_phy[n]->lpName, _V_L_LEG) == 0 ||
			stricmp ( m_phy[n]->lpName, _V_R_LEG) == 0 ||
			stricmp ( m_phy[n]->lpName, _V_MANTLE) == 0)
			
			continue;
		
		// 画实体
		Phy_Calculate ( m_phy[n] );
		Phy_DrawNormal ( m_phy[n] );
		
		/*switch ( type )
		{
		case 2:
		{
		// 画阴影
		D3DXMATRIXA16 matrix;
		D3DXMatrixIdentity ( &matrix );
		Common_Rotate ( &matrix, D3DXToRadian ( -45 ), 0, 0 );
		
		  D3DXVECTOR4	pos;
		  pos.x = lightx;
		  pos.y = lighty;
		  pos.z = lightz;
		  pos.w = 1;
		  D3DXVec3TransformCoord ( ( D3DXVECTOR3* )&pos, ( D3DXVECTOR3* )&pos, &matrix );
		  
			pos.x += m_phy[n]->lpMotion->matrix[0]._41;
			pos.z += m_phy[n]->lpMotion->matrix[0]._43;
			
			  D3DXVECTOR3 point;
			  point.x = m_phy[n]->lpMotion->matrix[0]._41;
			  point.y = m_phy[n]->lpMotion->matrix[0]._42;
			  point.z = m_phy[n]->lpMotion->matrix[0]._43;
			  
				D3DXVECTOR3 normal;
				normal.x = 0;
				normal.y = 0;
				normal.z = -1;
				D3DXVec3TransformCoord ( &normal, &normal, &matrix );
				D3DXVec3Normalize ( &normal, &normal );
				
				  int tex = m_phy[n]->nTex;
				  m_phy[n]->nTex = -1;
				  Phy_SetColor ( m_phy[n], sa, sr, sg, sb );
				  
					D3DXMatrixIdentity ( &matrix );
					Common_Shadow ( &matrix, &pos, &point, &normal );
					for ( int b = 0; b < m_phy[n]->lpMotion->dwBoneCount; b++ )
					Phy_Muliply ( m_phy[n], b, &matrix );
					Phy_Draw ( m_phy[n] );
					
					  m_phy[n]->nTex = tex;
					  }
					  break;
	};*/
		//Phy_SetColor ( m_phy[n], 1.0f, 1.0f, 1.0f, 1.0f );
		//Phy_ClearMatrix ( m_phy[n] );
	}
}
void C3DObj::DrawAlpha ( int type, float lightx, float lighty, float lightz, float sa, float sr, float sg, float sb, float height )
{
	if (CMyBitmap::s_nShowMode != modeMesh)
		C3DObj::Prepare();
	
	for ( int n = 0; n < m_dwPhyNum; n++ )
	{
		if ( stricmp( m_phy[n]->lpName,	_V_ARMET	) == 0 ||
			stricmp ( m_phy[n]->lpName,	_V_MISC		) == 0 ||
			stricmp ( m_phy[n]->lpName, _V_L_WEAPON ) == 0 ||
			stricmp ( m_phy[n]->lpName, _V_R_WEAPON ) == 0 ||
			stricmp ( m_phy[n]->lpName, _V_L_SHIELD ) == 0 ||
			stricmp ( m_phy[n]->lpName, _V_R_SHIELD ) == 0 ||
			stricmp ( m_phy[n]->lpName, _V_L_SHOE	) == 0 ||
			stricmp ( m_phy[n]->lpName, _V_R_SHOE	) == 0 ||
			stricmp ( m_phy[n]->lpName, _V_PET	) == 0 ||
			stricmp ( m_phy[n]->lpName, _V_BACK	) == 0 ||

			stricmp ( m_phy[n]->lpName, _V_HEAD	) == 0 ||
			stricmp ( m_phy[n]->lpName, _V_L_ARM) == 0 ||
			stricmp ( m_phy[n]->lpName, _V_R_ARM) == 0 ||
			stricmp ( m_phy[n]->lpName, _V_L_LEG) == 0 ||
			stricmp ( m_phy[n]->lpName, _V_R_LEG) == 0 ||
			stricmp ( m_phy[n]->lpName, _V_MANTLE) == 0)


			continue;
		
		// 画实体
		//Phy_Calculate ( m_phy[n] );
		Phy_DrawAlpha ( m_phy[n], true );
		
		switch ( type )
		{
		case 2:
			{
				// 画阴影
				D3DXMATRIXA16 matrix;
				D3DXMatrixIdentity ( &matrix );
				Common_Rotate ( &matrix, D3DXToRadian ( -37 ), 0, 0 );
				
				D3DXVECTOR4	pos;
				pos.x = lightx;
				pos.y = lighty;
				pos.z = lightz;
				pos.w = 1;
				D3DXVec3TransformCoord ( ( D3DXVECTOR3* )&pos, ( D3DXVECTOR3* )&pos, &matrix );
				
				pos.x += m_x[n];//m_phy[n]->lpMotion->matrix[0]._41;
				pos.z += m_z[n];//m_phy[n]->lpMotion->matrix[0]._43 - height;
				
				D3DXVECTOR3 point;

				
				/*point.x = m_phy[n]->lpMotion->matrix[0]._41;
				point.y = m_phy[n]->lpMotion->matrix[0]._42;
				point.z = m_phy[n]->lpMotion->matrix[0]._43 - height;*/
				
				
				point.x = m_x[n];
				point.y = m_y[n];
				point.z = m_z[n] - height;
				
				D3DXVECTOR3 normal;
				normal.x = 0;
				normal.y = 0;
				normal.z = -1;
				D3DXVec3TransformCoord ( &normal, &normal, &matrix );
				D3DXVec3Normalize ( &normal, &normal );
				
				//int tex = m_phy[n]->nTex;
				//m_phy[n]->nTex = -1;
				Phy_SetColor ( m_phy[n], sa, sr, sg, sb );
				SetTextureStageState ( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG2 );
				
				D3DXMatrixIdentity ( &matrix );
				Common_Shadow ( &matrix, &pos, &point, &normal );
				for ( int b = 0; b < m_phy[n]->lpMotion->dwBoneCount; b++ )
					Phy_Muliply ( m_phy[n], b, &matrix );
				Phy_Calculate ( m_phy[n] );
				Phy_DrawNormal ( m_phy[n] );
				Phy_DrawAlpha ( m_phy[n], true );
				
				SetTextureStageState ( 0, D3DTSS_COLOROP, D3DTOP_MODULATE );
				
				//m_phy[n]->nTex = tex;
			}
			break;
		};
		for ( n = 0; n < m_dwPhyNum; n++ )
		{
			Phy_SetColor ( m_phy[n], 1.0f, 1.0f, 1.0f, 1.0f );
//			Phy_ClearMatrix ( m_phy[n] );
		}
	}
}
//------------------------------------------------------
void C3DObj::ChangeTexture ( C3DTexture* pTexture, char *objname )
{
	if (!pTexture)
		return;
	
	if (!objname)
	{
		for (int i=0; i<m_dwPhyNum; i++)
			Phy_ChangeTexture (m_phy[i], pTexture->GetTexture()->nID );
	}
	else
	{
		int nIndex = GetIndexByName ( objname );
		if (nIndex < 0)
			nIndex = 0;
		
		Phy_ChangeTexture (m_phy[nIndex], pTexture->GetTexture()->nID );
	}
}

//------------------------------------------------------
void C3DObj::Prepare ( void )
{

	Phy_Prepare ();
	
	// mode
	CMyBitmap::s_nShowMode	=modeMesh;
}
//------------------------------------------------------
void C3DObj::ClearMatrix ( void )
{
	for (int n = 0; n < m_dwPhyNum; n++)
	{
		Phy_ClearMatrix (m_phy[n]);
	}
}

bool CMyBitmap::IsDBCSLeadByte	(const char* buf, int nOffset)
{
	if (!buf || nOffset < 0)
		return false;
	
	int nLen = strlen(buf);
	if (nOffset >= nLen)
		return false;
	
	BYTE btChar = buf[nOffset];
	if (!::IsDBCSLeadByte(btChar))
		return false;
	
	// 查看offset-1是不是dbcs的lead byte
	int idxLastDbcs = 0;
	for (int i=0; i<nOffset; i++)
	{
		if (::IsDBCSLeadByte(buf[i]))
		{
			idxLastDbcs = i;
			i++;
		}
	}
	
	if (idxLastDbcs < nOffset - 1 || nOffset == 0)
		return ::IsDBCSLeadByte(btChar) ? true : false;
	else
		return false;
}