game_mesh.cpp

自己写的一个D3D游戏Dome。实现了基本的游戏功能

#include "..\Include\Game_Mesh.h"
#include "..\Include\Game_Resource.h"

Game_Mesh::Game_Mesh(wstring name){
	LPD3DXBUFFER mtrlBuffer;
	LPD3DXBUFFER adjacencyBuffer = NULL;

	//wstring path = wstring(L"resource\\") + name;
	// Load the mesh from the specified file
	D3DXLoadMeshFromX(name.c_str(), D3DXMESH_MANAGED, 
		g_sGlobal.g_pDevice, &adjacencyBuffer, 
		&mtrlBuffer, NULL, &m_dwPlaneNumMaterials, 
		&m_pMesh );

	m_pMesh->OptimizeInplace(D3DXMESHOPT_COMPACT | D3DXMESHOPT_ATTRSORT | D3DXMESHOPT_VERTEXCACHE,
							(DWORD*)adjacencyBuffer->GetBufferPointer(), NULL, NULL, NULL);

	D3DXMATERIAL* d3dxMaterials = (D3DXMATERIAL*)mtrlBuffer->GetBufferPointer();
	m_pMeshMaterials = new D3DMATERIAL9[m_dwPlaneNumMaterials];
	m_pMeshTextures  = new LPDIRECT3DTEXTURE9[m_dwPlaneNumMaterials];

	for( DWORD i=0; i<m_dwPlaneNumMaterials; i++ ){
		// Copy the material
		m_pMeshMaterials[i] = d3dxMaterials[i].MatD3D;

		// Set the ambient color for the material (D3DX does not do this)
		D3DCOLORVALUE color;
		color.a = 1;
		color.r = 1;
		color.g = 1;
		color.b = 1;
		m_pMeshMaterials[i].Ambient = m_pMeshMaterials[i].Diffuse = color;

		m_pMeshTextures[i] = NULL;
		if( d3dxMaterials[i].pTextureFilename != NULL && 
			lstrlenA(d3dxMaterials[i].pTextureFilename)>0){
			WCHAR strTextureTemp[MAX_PATH];
			MultiByteToWideChar( CP_ACP, 0, d3dxMaterials[i].pTextureFilename, -1, strTextureTemp, MAX_PATH );
			m_pMeshTextures[i] = Game_Resource::Instance()->GetTexture(wstring(strTextureTemp));
		}
	}

	mtrlBuffer->Release();
	adjacencyBuffer->Release();

	DWORD fvf = m_pMesh->GetFVF();
	if (!(fvf & D3DFVF_NORMAL)){
		fvf |= D3DFVF_NORMAL;

		LPD3DXMESH newMesh;

		m_pMesh->CloneMeshFVF( m_pMesh->GetOptions(), fvf, g_sGlobal.g_pDevice, &newMesh);
		D3DXComputeNormals( newMesh, 0 );
		SAFE_RELEASE( m_pMesh );
		m_pMesh = newMesh;
	}
}

void Game_Mesh::Destroy(){
	SAFE_DELETE_ARRAY(m_pMeshMaterials);
	SAFE_DELETE_ARRAY(m_pMeshTextures);
	SAFE_RELEASE(m_pMesh);
}

Game_Mesh::~Game_Mesh(){
	Destroy();
}

void Game_Mesh::InitMesh(D3DXVECTOR3 vPos,float pith,float angle,float scale){
	D3DXMatrixIdentity(&m_matWorld);
	m_BoundingBox=false;
	m_bThings=false;
	m_fScale=pith;
	m_vPos=vPos;
	m_angle=angle;
	m_scale=scale;
}

void Game_Mesh::FrameMove(){
	D3DXMATRIX matScaling,matTranslation,matRotate,matFscale;
	D3DXMatrixScaling(&matScaling,m_scale,m_scale,m_scale);
	D3DXMatrixRotationY(&matRotate,m_angle);
	D3DXMatrixRotationX(&matFscale,m_fScale);
	D3DXMatrixTranslation(&matTranslation,m_vPos.x,m_vPos.y,m_vPos.z);
	m_matWorld=matScaling*matTranslation*matRotate*matFscale;
	g_sGlobal.g_pDevice->SetTransform( D3DTS_WORLD, &m_matWorld );
}

void Game_Mesh::Render(float timeStep){
	for (int i=0;i<m_dwPlaneNumMaterials;i++){
		g_sGlobal.g_pDevice->SetMaterial(&m_pMeshMaterials[i]);
		if (m_pMeshTextures)
			g_sGlobal.g_pDevice->SetTexture(0, m_pMeshTextures[i]);
		m_pMesh->DrawSubset(i);
	}
}

VOID Game_Mesh::GetBoundingBox(D3DXVECTOR3 *vMin,D3DXVECTOR3 *vMax){
	*vMin=m_vMin;
	*vMax=m_vMax;
}

VOID Game_Mesh::RenderAABB(D3DXVECTOR3 *pVmin,D3DXVECTOR3 *pVmax){
	/*	
	0------MAX
	/      /|
	/	   / |
	3-----2  5
	|	  | /
	|  	  |/
	min------6

	*/
	struct VERTEX_BOUNDINGBOX{
		float x,y,z;
		DWORD color;
	};
	VERTEX_BOUNDINGBOX VB[]={  
		{pVmin->x,pVmax->y,pVmax->z,0xffff0000},	//上表面
		{pVmax->x,pVmax->y,pVmax->z,0xffff0000},
		{pVmax->x,pVmax->y,pVmin->z,0xffff0000},
		{pVmin->x,pVmax->y,pVmin->z,0xffff0000},


		{pVmin->x,pVmin->y,pVmax->z,0xffff0000},	//下边四条线
		{pVmax->x,pVmin->y,pVmax->z,0xffff0000},
		{pVmax->x,pVmin->y,pVmin->z,0xffff0000},
		{pVmin->x,pVmin->y,pVmin->z,0xffff0000},
	};
	WORD IB[]={
		0,1,1,2,2,3,3,0,
			4,5,5,6,6,7,7,4,
			0,4,1,5,2,6,3,7
	};

	//单位矩阵
	D3DXMATRIX matIdentity;
	D3DXMatrixIdentity(&matIdentity);
	g_sGlobal.g_pDevice->SetTransform(D3DTS_WORLD, &matIdentity);
	g_sGlobal.g_pDevice->SetTexture(0,NULL);  
	g_sGlobal.g_pDevice->SetFVF(D3DFVF_CUSTOM_BOUNDINGBOX);
	g_sGlobal.g_pDevice->DrawIndexedPrimitiveUP(D3DPT_LINELIST,0,24,12,IB,D3DFMT_INDEX16,
		VB,sizeof(VERTEX_BOUNDINGBOX));
}

void Game_Mesh::box(){
	D3DXMATRIX matScaling,matTranslation,matRotate,matFscale;
	D3DXMatrixScaling(&matScaling,m_scale,m_scale,m_scale);
	D3DXMatrixRotationY(&matRotate,m_angle);
	D3DXMatrixRotationX(&matFscale,m_fScale);
	D3DXMatrixTranslation(&matTranslation,m_vPos.x,m_vPos.y,m_vPos.z);
	m_matWorld=matScaling*matTranslation*matRotate*matFscale;
	g_sGlobal.g_pDevice->SetTransform( D3DTS_WORLD, &m_matWorld );
	D3DXVECTOR3 *pV; 
	D3DXVECTOR3 vTransformed;
	//D3DXMATRIX matTemp=m_matWorld;
	m_pMesh->LockVertexBuffer(0,(void**)&pV); 

	DWORD nVertex=m_pMesh->GetNumVertices();
	DWORD nStride=m_pMesh->GetNumBytesPerVertex();
	DWORD i;
	m_vMin.x=pV->x*m_matWorld._11+pV->y*m_matWorld._21+pV->z*m_matWorld._31+m_matWorld._41;
	m_vMin.y=pV->x*m_matWorld._12+pV->y*m_matWorld._22+pV->z*m_matWorld._32+m_matWorld._42;
	m_vMin.z=pV->x*m_matWorld._13+pV->y*m_matWorld._23+pV->z*m_matWorld._33+m_matWorld._43;

	m_vMax.x=pV->x*m_matWorld._11+pV->y*m_matWorld._21+pV->z*m_matWorld._31+m_matWorld._41;
	m_vMax.y=pV->x*m_matWorld._12+pV->y*m_matWorld._22+pV->z*m_matWorld._32+m_matWorld._42;
	m_vMax.z=pV->x*m_matWorld._13+pV->y*m_matWorld._23+pV->z*m_matWorld._33+m_matWorld._43;

	for(i=0;i<nVertex;i++){
		vTransformed.x=pV->x*m_matWorld._11+pV->y*m_matWorld._21+pV->z*m_matWorld._31+m_matWorld._41;
		vTransformed.y=pV->x*m_matWorld._12+pV->y*m_matWorld._22+pV->z*m_matWorld._32+m_matWorld._42;
		vTransformed.z=pV->x*m_matWorld._13+pV->y*m_matWorld._23+pV->z*m_matWorld._33+m_matWorld._43;

		if		 (vTransformed.x<m_vMin.x)	m_vMin.x=vTransformed.x;
		else if  (vTransformed.x>m_vMax.x)	m_vMax.x=vTransformed.x;

		if		(vTransformed.y<m_vMin.y)	m_vMin.y=vTransformed.y;
		else if	(vTransformed.y>m_vMax.y)	m_vMax.y=vTransformed.y;

		if		(vTransformed.z<m_vMin.z)	m_vMin.z=vTransformed.z;
		else if	(vTransformed.z>m_vMax.z)	m_vMax.z=vTransformed.z;
		pV=(D3DXVECTOR3*)((BYTE*)pV+nStride);
	}

	m_pMesh->UnlockVertexBuffer(); 
}