www.pudn.com > Chesssource.rar > Object.cpp

#include "stdafx.h" 
 
cObject::cObject() 
{ 
	m_pGraphics		= NULL; 
	m_pMesh			= NULL; 
} 
 
 
cObject::~cObject() 
{ 
	Free(); 
} 
 
 
BOOL cObject::Create( cGraphics *pGraphics, cMesh *pMesh ) 
{ 
	if(( m_pGraphics = pGraphics ) == NULL ) 
		return FALSE; 
	m_pMesh = pMesh; 
 
	Move( 0.0f, 0.0f, 0.0f ); 
	Rotate( 0.0f, 0.0f, 0.0f ); 
	Scale( 1.0f, 1.0f, 1.0f ); 
 
	return TRUE; 
} 
 
 
void cObject::Free() 
{ 
	m_pGraphics		= NULL; 
	m_pMesh			= NULL; 
} 
 
 
BOOL cObject::EnableBillboard( BOOL bEnable ) 
{ 
	m_pPos.EnableBillboard( bEnable ); 
	return TRUE; 
} 
 
 
BOOL cObject::AttachToObject( cObject *pObject, char *strFrameName ) 
{ 
	sFrame *pFrame; 
 
	if( pObject == NULL || pObject->m_pMesh == NULL ) 
	{ 
		m_pPos.SetCombineMatrix1( NULL ); 
		m_pPos.SetCombineMatrix2( NULL ); 
	} 
	else 
	{ 
		pFrame = pObject->m_pMesh->GetFrame( strFrameName ); 
		if(pFrame == NULL ) 
		{ 
			m_pPos.SetCombineMatrix1( NULL ); 
			m_pPos.SetCombineMatrix2( NULL ); 
		} 
		else 
		{ 
			m_pPos.SetCombineMatrix1( &pFrame->m_matCombined ); 
			m_pPos.SetCombineMatrix2( pObject->m_pPos.GetMatrix() ); 
		} 
	} 
 
	return TRUE; 
} 
 
 
void cObject::Move( float fXPos, float fYPos, float fZPos ) 
{ 
	m_pPos.Move( fXPos, fYPos, fZPos ); 
} 
 
 
void cObject::MoveRel( float fXAdd, float fYAdd, float fZAdd ) 
{ 
	m_pPos.MoveRel( fXAdd, fYAdd, fZAdd ); 
} 
 
 
void cObject::Rotate( float fXRot, float fYRot, float fZRot ) 
{ 
	m_pPos.Rotate( fXRot, fYRot, fZRot ); 
} 
 
 
void cObject::RotateRel( float fXAdd, float fYAdd, float fZAdd ) 
{ 
	m_pPos.RotateRel( fXAdd, fYAdd, fZAdd ); 
} 
 
 
void cObject::Scale( float fXSca, float fYSca, float fZSca ) 
{ 
	m_pPos.Scale( fXSca, fYSca, fZSca ); 
} 
 
 
void cObject::ScaleRel( float fXAdd, float fYAdd, float fZAdd ) 
{ 
	m_pPos.ScaleRel( fXAdd, fYAdd, fZAdd ); 
} 
 
 
D3DXMATRIX *cObject::GetMatrix() 
{ 
	return m_pPos.GetMatrix(); 
} 
 
 
BOOL cObject::SetMesh( cMesh *pMesh ) 
{ 
	m_pMesh = pMesh; 
 
	return TRUE; 
} 
 
 
cMesh *cObject::GetMesh() 
{ 
	return m_pMesh; 
} 
 
 
float cObject::GetXPos() 
{ 
  return m_pPos.GetXPos(); 
} 
 
float cObject::GetYPos() 
{ 
  return m_pPos.GetYPos(); 
} 
 
float cObject::GetZPos() 
{ 
  return m_pPos.GetZPos(); 
} 
 
float cObject::GetXRotation() 
{ 
  return m_pPos.GetXRotation(); 
} 
 
float cObject::GetYRotation() 
{ 
  return m_pPos.GetYRotation(); 
} 
 
float cObject::GetZRotation() 
{ 
  return m_pPos.GetZRotation(); 
} 
 
float cObject::GetXScale() 
{ 
  return m_pPos.GetXScale(); 
} 
 
float cObject::GetYScale() 
{ 
  return m_pPos.GetYScale(); 
} 
 
float cObject::GetZScale() 
{ 
  return m_pPos.GetZScale(); 
} 
 
 
BOOL cObject::Update() 
{ 
	m_pPos.UpdateMatrix( m_pGraphics ); 
 
	return TRUE; 
} 
 
 
BOOL cObject::Render( BOOL bTex ) 
{ 
	D3DXMATRIX matMatrix; 
 
	if( m_pGraphics == NULL || m_pMesh == NULL /*|| m_pMesh->GetParentFrame == NULL || m_pMesh->GetParentMesh() == NULL*/ ) 
		return FALSE; 
 
	Update(); 
 
	D3DXMatrixIdentity( &matMatrix ); 
	UpdateFrame( m_pMesh->GetParentFrame(), &matMatrix ); 
 
	m_pMesh->GetParentMesh()->CopyFrameToBoneMatrices(); 
 
	DrawFrame( m_pMesh->GetParentFrame(), bTex ); 
 
	return TRUE; 
} 
 
 
void cObject::UpdateFrame( sFrame *pFrame, D3DXMATRIX *matMatrix ) 
{ 
	if( pFrame == NULL ) 
		return; 
 
	D3DXMatrixMultiply( &pFrame->m_matCombined, &pFrame->m_matOriginal, matMatrix ); 
 
	UpdateFrame( pFrame->m_pChild, &pFrame->m_matCombined ); 
	UpdateFrame( pFrame->m_pSibling, matMatrix ); 
} 
 
 
void cObject::DrawFrame( sFrame *pFrame, BOOL bTex ) 
{ 
	sFrameMeshList	*pList; 
	sMesh			*pMesh; 
	D3DXMATRIX		matWorld; 
	DWORD			i; 
 
	D3DXMatrixIdentity( &matWorld ); 
	if( pFrame == NULL ) 
		return; 
 
	if(( pList = pFrame->m_pMeshList ) != NULL ) 
	{ 
		while( pList != NULL ) 
		{ 
			if(( pMesh = pList->m_pMesh ) != NULL ) 
			{ 
				if( pMesh->m_dwNumBones && pMesh->m_pSkinMesh != NULL ) 
				{ 
					void *SrcPtr, *DestPtr; 
					pMesh->m_pMesh->LockVertexBuffer( D3DLOCK_READONLY, (void**)&SrcPtr ); 
					pMesh->m_pMesh->LockVertexBuffer( 0, (void**)&DestPtr ); 
 
					pMesh->m_pSkinInfo->UpdateSkinnedMesh( pMesh->m_matMatrices, NULL, SrcPtr, DestPtr ); 
 
					pMesh->m_pSkinMesh->UnlockVertexBuffer(); 
					pMesh->m_pMesh->UnlockVertexBuffer(); 
 
					m_pGraphics->Get3DDevice()->SetTransform( D3DTS_WORLD, m_pPos.GetMatrix()); 
				} 
				else 
				{ 
					//D3DXMatrixMultiply( &matWorld, &pFrame->m_matCombined, m_pPos.GetMatrix()); 
					m_pGraphics->Get3DDevice()->SetTransform( D3DTS_WORLD, m_pPos.GetMatrix() ); 
				} 
 
				for( i=0; im_dwNumMaterials; i++ ) 
				{ 
					if( pMesh->m_pmatMaterials[i].Diffuse.a != 0.0f ) 
					{ 
						m_pGraphics->Get3DDevice()->SetMaterial( &pMesh->m_pmatMaterials[i] ); 
						if( !bTex ) 
							m_pGraphics->Get3DDevice()->SetTexture( 0, pMesh->m_pTextures[i] );	 
						else 
							m_pGraphics->Get3DDevice()->SetTexture( 0, pMesh->m_pTextures[i+1] ); 
 
						if( pMesh->m_pmatMaterials[i].Diffuse.a != 1.0f ) 
							m_pGraphics->EnableAlphaBlending( TRUE, D3DBLEND_SRCCOLOR, D3DBLEND_ONE ); 
 
						if( pMesh->m_pSkinMesh != NULL ) 
							pMesh->m_pSkinMesh->DrawSubset(i); 
						else 
							pMesh->m_pMesh->DrawSubset(i); 
 
						if( pMesh->m_pmatMaterials[i].Diffuse.a != 1.0f ) 
							m_pGraphics->EnableAlphaBlending( FALSE ); 
					} 
				} 
			} 
 
			pList = pList->m_pNext; 
		} 
	} 
 
	DrawFrame( pFrame->m_pChild, bTex ); 
	DrawFrame( pFrame->m_pSibling, bTex ); 
}