headerin3d.cpp

VC++ DEMO, used for the beginners and the amour

// HeaderIn3D.cpp: implementation of the HeaderIn3D class.
//
//////////////////////////////////////////////////////////////////////
#include "../CGE_CORE/HEADERS.H"
#include "HeaderIn3D.h"

USING NAMESPACE CGE;
#define HELPCOORD_X 10
#define HELPCOORD_Y 60

D3DXVECTOR3 vGravity(0.0f,-9.8f,0.0f);
D3DXVECTOR3 vRadiusVector(10.0f, 40.0f, 10.0f);
#define SPEED 6.0f
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
typedef struct DIRVERTEX
{
	union {
		float     x;
		float     dvX;
	};
	union {
		float     y;
		float     dvY;
	};
	union {
		float     z;
		float     dvZ;
	};
	union {
		float	  rhw;
		float	  dvRhw;
	};
	union {
		float     tu;
		float     dvTU;
	};
	union {
		float     tv;
		float     dvTV;
	};
	DIRVERTEX() { }
	DIRVERTEX(const D3DVECTOR& v, float _rhw,float _tu, float _tv)
	{
		x = v.x; y = v.y; z = v.z;
		rhw = _rhw;
		tu = _tu; tv = _tv;
	}
	enum
	{
		FVF_DIRVERTEX = (D3DFVF_XYZRHW|D3DFVF_TEX1)
	};
}*LPDIRVERTEX;

BOOL Keyboard(UINT nScanCode,WPARAM wParam,LPARAM lParam)
{
	return theApp.LockKeyboard(nScanCode,wParam,lParam);
}

HeaderIn3D::HeaderIn3D()
{
	this->m_dyCamera = NULL;
	this->m_dyOctree = NULL;
	this->m_dyMapMesh = NULL;
	this->m_dySampFont = NULL;
	this->m_dyConsole = NULL;
	this->m_Direction = 0;
	this->m_DirVB = 0;
	this->m_dyFPS = 0;
}

HeaderIn3D::~HeaderIn3D()
{
	SAFE_DELETE(m_dyConsole);
	SAFE_DELETE(m_dyCamera);
	SAFE_DELETE(m_dyMapMesh);
	SAFE_DELETE(m_dyOctree);
	SAFE_DELETE(m_dySampFont);
	SAFE_DELETE(m_dyFPS);
}

BOOL HeaderIn3D::InitializeOnFirstTime()
{
	m_dyCamera = new CGE::MATRIX::CAMERA;
	m_dyOctree = new CGE::CULLING::XOCTREE;
	m_dyMapMesh = new CGE::MODEL::XFILE::XSKINMESH;
	m_dyConsole = new CGE::INPUT::CONSOLE;
	m_dySampFont = new CGE::FONT::EnFont;
	m_dyFPS = new TIME::FPS;
	return TRUE;
}

BOOL HeaderIn3D::InitializeEntironment()
{
	HWND hWnd = D3DPARAMETER.hDeviceWindow;
	m_dyConsole->Create();
	m_dyConsole->CreateKeyboard();
	m_dyConsole->SetKeyboardBehavior((VOID*)hWnd,DISCL_FOREGROUND | DISCL_NONEXCLUSIVE);
	m_dyConsole->SetKeyboardHotKey(INPUT::KeyboardKey(DIK_A,2,0),INPUT::HotKey(Keyboard,2,DIK_A));
	m_dyConsole->SetKeyboardHotKey(INPUT::KeyboardKey(DIK_D,2,0),INPUT::HotKey(Keyboard,2,DIK_D));
	m_dyConsole->SetKeyboardHotKey(INPUT::KeyboardKey(DIK_UP,2,0),INPUT::HotKey(Keyboard,2,DIK_UP));
	m_dyConsole->SetKeyboardHotKey(INPUT::KeyboardKey(DIK_DOWN,2,0),INPUT::HotKey(Keyboard,2,DIK_DOWN));
	m_dyConsole->SetKeyboardHotKey(INPUT::KeyboardKey(DIK_LEFT,2,0),INPUT::HotKey(Keyboard,2,DIK_LEFT));
	m_dyConsole->SetKeyboardHotKey(INPUT::KeyboardKey(DIK_RIGHT,2,0),INPUT::HotKey(Keyboard,2,DIK_RIGHT));
	m_dyConsole->SetKeyboardHotKey(INPUT::KeyboardKey(DIK_W,2,0),INPUT::HotKey(Keyboard,2,DIK_W));
	m_dyConsole->SetKeyboardHotKey(INPUT::KeyboardKey(DIK_S,2,0),INPUT::HotKey(Keyboard,2,DIK_S));
	m_dyConsole->CreateMouse();
	m_dyConsole->SetMouseBehavior(hWnd,DISCL_FOREGROUND | DISCL_NONEXCLUSIVE);
	m_dyCamera->MatrixLookAt(D3DXVECTOR3(0,100,0),D3DXVECTOR3(0,100,1),D3DXVECTOR3(0,1,0));
	m_dyOctree->SetMaxTriangle(32);
	m_dyOctree->SetMaxNodeSize(1);
	m_dyMapMesh->SetMediaFilePath(_T("DATA\\"));
	m_dyMapMesh->ReadMeshHierarchy(_T("DATA\\WORLD.x"),DEVICE,D3DXMESH_VB_SYSTEMMEM );
	MODEL::XFILE::Mesh * pMesh = m_dyMapMesh->GetRootFrame()->m_pMeshList;
	m_dyOctree->m_vMaterials.resize(pMesh->m_cMaterials);
	m_dyOctree->m_vTextures.resize(pMesh->m_cMaterials);
	m_dyOctree->m_vMarshals.resize(pMesh->m_cMaterials);
	memcpy((PVOID)m_dyOctree->m_vMaterials.begin(),(PVOID)pMesh->m_rgMaterials,
		sizeof(D3DMATERIAL8)*pMesh->m_cMaterials);
	memcpy((PVOID)m_dyOctree->m_vTextures.begin(),(PVOID)pMesh->m_pTextures,
		sizeof(LPDIRECT3DTEXTURE8)*pMesh->m_cMaterials);
	m_dyOctree->SetSceneDimensions(pMesh->m_pMesh,pMesh->m_vMin,pMesh->m_vMax);
	for (LONG i = 0; i < m_dyOctree->m_vMarshals.size(); ++i)
	{
		if ( m_dyOctree->m_vMarshals[i].m_NumOfTri )
			DEVICE->CreateVertexBuffer(m_dyOctree->m_vsOfMesh * m_dyOctree->m_vMarshals[i].m_NumOfTri * 3, 0,
			m_dyOctree->m_OddSceneMesh->GetFVF(), D3DPOOL_MANAGED, &m_dyOctree->m_vMarshals[i].m_pVB);
	}
	m_dyOctree->m_ParentNode = new CULLING::XOCTREE::Node;
	m_dyOctree->CreateSceneNode(m_dyOctree->m_ParentNode,D3DXVECTOR3(0,0,0),m_dyOctree->m_fSceneDimension);
	m_dySampFont->SetEnFont(DEVICE,"Arial",16,100,0,0);
	return TRUE;
}

BOOL HeaderIn3D::SetfreeEntironment()
{
	SAFE_RELEASE(m_Direction);
	SAFE_RELEASE(m_DirVB);
	m_dySampFont->SetfreeContext();
	return TRUE;
}

BOOL HeaderIn3D::AfreshEntironment()
{	
	HRESULT hr;
	SCENE::SetPixelFog(DEVICE,0xFFFFFFFF,D3DFOG_EXP2,0,0,0.001f);
	DEVICE->SetTransform( D3DTS_PROJECTION,&m_dyCamera->MatrixPerspectiveFovLH(D3DX_PI/4,
		(FLOAT)BackBufferWidth()/BackBufferHeight(),1.0f,20000.0f));
	DEVICE->SetRenderState( D3DRS_ZENABLE, 2);
	DEVICE->SetRenderState( D3DRS_LIGHTING,FALSE);
	DEVICE->SetRenderState( D3DRS_CULLMODE,D3DCULL_NONE);
	DEVICE->SetTextureStageState(0,D3DTSS_MAGFILTER, D3DTEXF_LINEAR);
	DEVICE->SetTextureStageState(0,D3DTSS_MINFILTER, D3DTEXF_LINEAR);
	DEVICE->SetTextureStageState(0,D3DTSS_MIPFILTER, D3DTEXF_LINEAR);
	hr = D3DXCreateTextureFromFileEx(DEVICE, "DIRECTION.JPG", 
		D3DX_DEFAULT, D3DX_DEFAULT, D3DX_DEFAULT, 0, D3DFMT_A1R5G5B5, 
		D3DPOOL_DEFAULT, D3DX_FILTER_TRIANGLE, D3DX_FILTER_TRIANGLE,
		D3DCOLOR_RGBA(0,0,0,255), NULL, NULL, &m_Direction);
	if (FAILED(hr)) return FALSE;
	hr = DEVICE->CreateVertexBuffer(4 * sizeof(DIRVERTEX),0,0,D3DPOOL_DEFAULT,&m_DirVB);
	if (FAILED(hr)) return FALSE;

	LPDIRVERTEX dir;
	hr = m_DirVB->Lock(0,0,(BYTE**)&dir,0);
	if (FAILED(hr)) return FALSE;
	dir[0] = DIRVERTEX(D3DXVECTOR3(HELPCOORD_X,HELPCOORD_Y,0.9f),1.0f,0,0);
	dir[1] = DIRVERTEX(D3DXVECTOR3(HELPCOORD_X + 128,HELPCOORD_Y,0.9f),1.0f,1,0);
	dir[2] = DIRVERTEX(D3DXVECTOR3(HELPCOORD_X,HELPCOORD_Y + 128,0.9f),1.0f,0,1);
	dir[3] = DIRVERTEX(D3DXVECTOR3(HELPCOORD_X + 128,HELPCOORD_Y + 128,0.9f),1.0f,1,1);
	hr = m_DirVB->Unlock();
	if (FAILED(hr)) return FALSE;
	m_dySampFont->CreateContext(DEVICE);

	return TRUE;
}

BOOL HeaderIn3D::CheckFrameInMove()
{
	m_dyConsole->UpdateKeyboard();
	m_dyConsole->UpdateMouse();
	m_dyCamera->MatrixRotationAxis(-INPUT::CONSOLE::m_MouseDeltaY/500.0f,0);
	m_dyCamera->MatrixRotationAxis(0,INPUT::CONSOLE::m_MouseDeltaX/500.0f);
	D3DXVECTOR3 vCameraPos;
	vCameraPos = m_dyCamera->EyeAt();	
	m_dyOctree->CollisionDetection(vCameraPos,vRadiusVector,vGravity,1.0f,0.0f);
	m_dyCamera->LayAt(vCameraPos);
	m_dyFPS->Limit(40);
	m_dyFPS->Refresh();
	return TRUE;
}

LRESULT HeaderIn3D::DefineUserMsgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
	return Behavior::DefineUserMsgProc(hWnd,msg,wParam,lParam);
}

BOOL HeaderIn3D::DrawEntironment()
{
	DEVICE->Clear( 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER,
		D3DCOLOR_COLORVALUE(0.0f, 0.0f, 0.0f, 1.0f), 1.0f, 0 );
	if(SUCCEEDED(DEVICE->BeginScene()))
	{
		DEVICE->SetTransform(D3DTS_VIEW,&m_dyCamera->MatrixLookAtLH());
		m_dyOctree->NodeInScene(DEVICE,0);
		DEVICE->SetRenderState(D3DRS_ALPHABLENDENABLE ,TRUE);
		DEVICE->SetTexture(0,m_Direction);
		DEVICE->SetRenderState(D3DRS_SRCBLEND ,D3DBLEND_SRCALPHA);
		DEVICE->SetRenderState(D3DRS_DESTBLEND ,D3DBLEND_ONE);
		DEVICE->SetStreamSource(0,m_DirVB,sizeof(DIRVERTEX));
		DEVICE->SetVertexShader(DIRVERTEX::FVF_DIRVERTEX);
		DEVICE->DrawPrimitive(D3DPT_TRIANGLESTRIP,0,2);
		DEVICE->SetRenderState(D3DRS_SRCBLEND ,D3DBLEND_ONE);
		DEVICE->SetRenderState(D3DRS_DESTBLEND ,D3DBLEND_ZERO);
		DEVICE->SetRenderState(D3DRS_ALPHABLENDENABLE ,FALSE);
		DEVICE->SetTexture(0,0);
		TCHAR strRate[64];
		sprintf(strRate,"Limit FPS:40.0    Current FPS:%4.1f",m_dyFPS->GetFPS());
		m_dySampFont->BeginTextOut();
		m_dySampFont->Text2DOut(m_strAdapterInfo,2,2,D3DCOLOR_RGBA(250,128,128,255));
		m_dySampFont->Text2DOut(strRate,2,200,D3DCOLOR_RGBA(250,128,128,255));
		m_dySampFont->EndTextOut();
		DEVICE->EndScene();
	}
	DEVICE->Present(0,0,0,0);
	return TRUE;
}

BOOL HeaderIn3D::CleanupLastTime()
{
	m_bActive = FALSE;
	m_bReady = FALSE;
	SAFE_RELEASE(m_Direction);
	SAFE_RELEASE(m_DirVB);
	m_dySampFont->SetfreeContext();
	return TRUE;
}

BOOL HeaderIn3D::LockKeyboard(UINT nScanCode, WPARAM wParam, LPARAM lParam)
{
	D3DXVECTOR3 vCameraPos;
	D3DXVECTOR3 vVelocity,vView,vXZ;
	switch(nScanCode)
	{
	case DIK_W:
		D3DXVec3Subtract(&vView,&m_dyCamera->LookAt(),&m_dyCamera->EyeAt());
		D3DXVec3Normalize(&vView,&vView);
		vVelocity = vView * SPEED;
		vVelocity.y = 0;
		vCameraPos = m_dyCamera->EyeAt();
		if ( m_dyOctree->CollisionDetection(vCameraPos,vRadiusVector,vVelocity,0.0f,0.0f) )
		{
			m_dyCamera->LayAt(vCameraPos);
		}
		else
		{
			m_dyCamera->MatrixTranslateZAxis(SPEED);
			m_dyCamera->MatrixTranslateXAxis(SPEED);
		}
		break;
	case DIK_S:
		D3DXVec3Subtract(&vView,&m_dyCamera->LookAt(),&m_dyCamera->EyeAt());
		D3DXVec3Normalize(&vView,&vView);
		vVelocity = vView * (-SPEED);
		vVelocity.y = 0;
		vCameraPos = m_dyCamera->EyeAt();
		if ( m_dyOctree->CollisionDetection(vCameraPos,vRadiusVector,vVelocity,0.0f,0.0f) )
		{
			m_dyCamera->LayAt(vCameraPos);
		}
		else
		{
			m_dyCamera->MatrixTranslateZAxis(-SPEED);
			m_dyCamera->MatrixTranslateXAxis(-SPEED);
		}
		break;
	case DIK_LEFT:
		m_dyCamera->MatrixRotationAxis(0.0f,-D3DXToRadian(2));
		break;
	case DIK_RIGHT:
		m_dyCamera->MatrixRotationAxis(0.0f,D3DXToRadian(2));
		break;
	case DIK_UP:
		m_dyCamera->MatrixRotationAxis(D3DXToRadian(2),0.0f);
		break;
	case DIK_DOWN:
		m_dyCamera->MatrixRotationAxis(-D3DXToRadian(2),0.0f);
		break;
	case DIK_A:
		D3DXVec3Subtract(&vView,&m_dyCamera->LookAt(),&m_dyCamera->EyeAt());
		D3DXVec3Cross(&vXZ,&vView,&m_dyCamera->UpAt());
		D3DXVec3Normalize(&vXZ,&vXZ);
		vVelocity = vXZ * SPEED;
		vCameraPos = m_dyCamera->EyeAt();
		if ( m_dyOctree->CollisionDetection(vCameraPos,vRadiusVector,vVelocity,0.0f,0.0f) )
		{
			m_dyCamera->LayAt(vCameraPos);
		}
		else
		{
			m_dyCamera->MatrixTranslateXZAxis(SPEED);
		}
		break;
	case DIK_D:
		D3DXVec3Subtract(&vView,&m_dyCamera->LookAt(),&m_dyCamera->EyeAt());
		D3DXVec3Cross(&vXZ,&vView,&m_dyCamera->UpAt());
		D3DXVec3Normalize(&vXZ,&vXZ);
		vVelocity = vXZ * (-SPEED);
		vCameraPos = m_dyCamera->EyeAt();
		if ( m_dyOctree->CollisionDetection(vCameraPos,vRadiusVector,vVelocity,0.0f,0.0f) )
		{
			m_dyCamera->LayAt(vCameraPos);
		}
		else
		{
			m_dyCamera->MatrixTranslateXZAxis(-SPEED);
		}
		break;
	default: break;
	}
	return TRUE; 
}