www.pudn.com > Balls.rar > StaticMesh.cpp, change:2007-07-26,size:5230b

#include "StdAfx.h" 
#include "staticmesh.h" 
#include ".\staticmesh.h" 
 
#define new VNEW 
 
CStaticMesh::CStaticMesh(void) : 
m_pDevice(NULL), 
m_pMesh(NULL), 
m_enBlendType(SBT_OPAQUE) 
{ 
} 
 
CStaticMesh::~CStaticMesh(void) 
{ 
	SAFE_RELEASE(m_pMesh); 
 
	for( DWORD dw = 0; dw  m_dwNumMaterials; ++dw ) 
	{ 
		if( m_vecTexture.size() = dw ) 
			break; 
 
		if( m_vecTexture[dw] ) 
			SAFE_RELEASE(m_vecTexture[dw]); 
	} 
 
	m_vecMaterial.clear(); 
	m_vecTexture.clear(); 
} 
 
bool CStaticMesh::Init(LPDIRECT3DDEVICE9 pDevice, LPCSTR pFileName) 
{ 
	assert( pDevice!=NULL ); 
	assert( pFileName!=NULL ); 
 
	m_pDevice = pDevice; 
	strcpy(m_fileName, pFileName); 
 
	LPD3DXBUFFER pXBuffer = NULL; 
  
	if( FAILED( D3DXLoadMeshFromX(m_fileName, D3DXMESH_SYSTEMMEM, m_pDevice, NULL, 
		&pXBuffer, NULL, &m_dwNumMaterials, &m_pMesh ) ) ) 
	{ 
		return false; 
	} 
 
	m_vecMaterial.resize( m_dwNumMaterials ); 
	m_vecTexture.resize( m_dwNumMaterials ); 
 
	D3DXMATERIAL *pD3DXMaterial = 
		reinterpret_cast<D3DXMATERIAL*>( pXBuffer->GetBufferPointer() ); 
 
 
	for( DWORD dw = 0; dw  m_dwNumMaterials; ++dw ) 
	{ 
		m_vecMaterial[dw] = pD3DXMaterial[dw].MatD3D; 
 
		if( FAILED( D3DXCreateTextureFromFile(m_pDevice, pD3DXMaterial[dw].pTextureFilename,  
			&m_vecTexture[dw]) ) ) 
		{ 
			m_vecTexture[dw] = NULL; 
		} 
	} 
 
	pXBuffer->Release(); 
 
	return true; 
} 
 
void CStaticMesh::Render(const D3DXMATRIX &matWorld) 
{ 
	m_pDevice->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE ); 
	//m_pDevice->SetRenderState(D3DRS_ALPHAREF, (DWORD)0x00000001); 
	//m_pDevice->SetRenderState(D3DRS_ALPHATESTENABLE, TRUE); 
	//m_pDevice->SetRenderState(D3DRS_ALPHAFUNC, D3DCMP_GREATEREQUAL); 
 
	switch (m_enBlendType) 
	{ 
	case SBT_OPAQUE: 
		{ 
			m_pDevice->SetRenderState( D3DRS_ALPHABLENDENABLE, FALSE ); 
		} 
		break; 
	case SBT_TRANSPARENT_ALPHA: 
		{ 
			m_pDevice->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA ); 
			m_pDevice->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA ); 
		} 
		break; 
	case SBT_TRANSPARENT_COLOR: 
		{ 
			m_pDevice->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCCOLOR ); 
			m_pDevice->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCCOLOR ); 
		} 
		break; 
	case SBT_ADD_COLOR: 
		{ 
			m_pDevice->SetRenderState( D3DRS_ZWRITEENABLE, FALSE ); 
			m_pDevice->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCCOLOR ); 
			m_pDevice->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_ONE ); 
		} 
		break; 
	case SBT_ADD_ALPHA: 
		{ 
			m_pDevice->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA ); 
			m_pDevice->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_ONE ); 
		} 
		break; 
	case SBT_MODULATE: 
		{ 
			m_pDevice->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_DESTCOLOR ); 
			m_pDevice->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_ZERO ); 
		} 
		break; 
	case SBT_MODULATE2: 
		{ 
			m_pDevice->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_DESTCOLOR ); 
			m_pDevice->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_SRCCOLOR ); 
		} 
		break; 
	case SBT_TRANSPARENT_DIFFUSE: 
		{ 
			m_pDevice->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA ); 
			m_pDevice->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA ); 
 
			m_pDevice->SetTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_MODULATE ); 
			m_pDevice->SetTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_DIFFUSE ); 
			m_pDevice->SetTextureStageState( 0, D3DTSS_ALPHAARG2, D3DTA_TEXTURE ); 
		} 
		break; 
	} 
 
	m_pDevice->SetTransform(D3DTS_WORLD, &matWorld); 
 
	for( DWORD dw = 0; dw  m_dwNumMaterials; ++dw ) 
	{ 
		m_pDevice->SetMaterial( &m_vecMaterial[dw] ); 
		m_pDevice->SetTexture( 0, m_vecTexture[dw] ); 
 
		m_pMesh->DrawSubset( dw ); 
	} 
 
	m_pDevice->SetRenderState( D3DRS_ALPHABLENDENABLE, FALSE ); 
	m_pDevice->SetRenderState( D3DRS_ZWRITEENABLE, TRUE ); 
	//m_pDevice->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE); 
} 
 
HRESULT CStaticMesh::SetTextureFromFile(DWORD dwID, LPCSTR pFileName) 
{ 
	HRESULT retResult; 
 
	if(m_vecTexture.size() = dwID) 
		return E_FAIL; 
 
	SAFE_RELEASE(m_vecTexture[dwID]); 
 
	string tempName(pFileName); 
	ChangeFileNameToDDS( tempName ); 
	if( FAILED( retResult = D3DXCreateTextureFromFile(m_pDevice, tempName.c_str(),  
		&m_vecTexture[dwID]) ) ) 
	{ 
		if( FAILED( retResult = D3DXCreateTextureFromFile(m_pDevice, pFileName,  
			&m_vecTexture[dwID]) ) ) 
		{ 
			m_vecTexture[dwID] = NULL; 
			return retResult; 
		} 
	} 
 
	return S_OK; 
} 
 
void CStaticMesh::SetTexture(DWORD dwID, LPDIRECT3DTEXTURE9 pTexture) 
{ 
	if(m_vecTexture.size() = dwID) 
		return; 
 
	m_vecTexture[dwID] = pTexture; 
} 
 
HRESULT CStaticMesh::Optimize(void) 
{ 
	return E_NOTIMPL; 
} 
 
LPD3DXMESH CStaticMesh::GetSysMemMesh(void) 
{ 
	return m_pMesh; 
} 
 
HRESULT CStaticMesh::SetFVF(DWORD dwFVF) 
{ 
	LPD3DXMESH pTempMesh = NULL; 
 
	if( m_pMesh ) 
	{ 
		if( FAILED( m_pMesh->CloneMeshFVF( D3DXMESH_SYSTEMMEM, dwFVF, m_pDevice, &pTempMesh ) ) ) 
			return E_FAIL; 
	} 
 
	SAFE_RELEASE( m_pMesh ); 
 
	if( pTempMesh ) m_pMesh = pTempMesh; 
 
	// ¼ÆËã·¨Ïß 
	if( m_pMesh ) 
		D3DXComputeNormals( m_pMesh, NULL ); 
 
	return S_OK; 
} 
 
LPDIRECT3DTEXTURE9 *CStaticMesh::GetTexture(DWORD dwID) 
{ 
	if(dwID >= m_vecTexture.size()) 
		return NULL; 
 
	m_vecTexture[dwID]->AddRef(); 
	return &m_vecTexture[dwID]; 
}