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;
const FLOAT ANGLE = 3.0f;
D3DXVECTOR3 g_vPos[40];
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
typedef struct BILLBOARD{
	union {
		float     x;
		float     dvX;
	};
	union {
		float     y;
		float     dvY;
	};
	union {
		float     z;
		float     dvZ;
	};
	union {
		float     tu;
		float     dvTU;
	};
	union {
		float     tv;
		float     dvTV;
	};
	BILLBOARD() { }
	BILLBOARD(const D3DVECTOR& v, float _tu, float _tv)
	{
		x = v.x; y = v.y; z = v.z;
		tu = _tu; tv = _tv;
	}
	enum
	{
		FVF_BILLBOARD = (D3DFVF_XYZ|D3DFVF_TEX1)
	};
}*LPBILLBOARD;

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

HeaderIn3D::HeaderIn3D()
{
	this->m_Billboard = NULL;
	this->m_dyCamera = NULL;
	this->m_dyConsole = NULL;
	this->m_dyLandScape = NULL;
	this->m_dyMicrodot = NULL;
	this->m_BillboardVB = NULL;
	this->m_BillSnow = NULL;
	this->g_pHeightMap = NULL;
	this->m_dySampFont = NULL;
	this->m_dyFPS = NULL;
	this->m_dyfSpeed = 200.0f;
}

HeaderIn3D::~HeaderIn3D()
{
	SAFE_DELETE(m_dyCamera);
	SAFE_DELETE(m_dyLandScape);
	SAFE_DELETE(m_dyMicrodot);
	SAFE_DELETE(m_dyConsole);
	SAFE_DELETE(m_dySampFont);
	SAFE_DELETE(m_dyFPS);
}

BOOL HeaderIn3D::InitializeOnFirstTime()
{
	m_dyCamera = new MATRIX::CAMERA;
	m_dyLandScape = new TERRAIN::LANDSCAPE;
	m_dyMicrodot = new PARTICLE::MICRODOT;
	m_dyConsole = new INPUT::CONSOLE;
	m_dySampFont = new 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(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_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->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_ADD,1,0),INPUT::HotKey(Keyboard,1,DIK_ADD));
	m_dyConsole->SetKeyboardHotKey(INPUT::KeyboardKey(DIK_SUBTRACT,1,0),INPUT::HotKey(Keyboard,1,DIK_SUBTRACT));
	m_dyCamera->MatrixLookAt(D3DXVECTOR3(MAP_SIZE/2+10,0,MAP_SIZE/2-10),D3DXVECTOR3(MAP_SIZE/2+10,0,MAP_SIZE/2-9),D3DXVECTOR3(0,1,0));

	ReadHeightMap();
	m_dyLandScape->SetLandTexture(TEXT("FLOOR.BMP"));
	m_dyLandScape->SetMaxDesiredTri(2000);
	m_dyLandScape->SetTextureTile(20,20);
	m_dyLandScape->SetFrameVariance(10.0f);
	m_dyLandScape->m_Camera = m_dyCamera;

	m_dyMicrodot->SetMaxEmitInUse(2000);
	m_dyMicrodot->m_ParticlesCreatedPerSec = 200;
	m_dyMicrodot->m_fMinDieAge = 5.0f;
	m_dyMicrodot->m_fMaxDieAge = 5.0f;		
	m_dyMicrodot->m_fCreationVariance = 10.0f;
	m_dyMicrodot->m_bRecreateWhenDied = 0;
	m_dyMicrodot->SetCreationClr(1.0f,1.0f,1.0f,1.0f,1.0f,1.0f);
	m_dyMicrodot->SetDieClr(1.0f,1.0f,1.0f,1.0f,1.0f,1.0f);
	m_dyMicrodot->SetAlphaValues(1.0f,1.0f,1.0f,1.0f);
	m_dyMicrodot->SetEmitter(512,400,512,512,0,512);
	m_dyMicrodot->SetSpinSpeed(D3DXToRadian(0),D3DXToRadian(360));
	m_dyMicrodot->SetEmissionDirection(D3DXVECTOR3(0,-1,0),D3DXVECTOR3(0.5f,0,0.5f));
	m_dyMicrodot->SetSizeValues(0.5f,0.5f,0.5f,0.5f);
	m_dyMicrodot->m_fMinEmitSpeed = 80.0f;
	m_dyMicrodot->m_fMaxEmitSpeed = 80.0f;
	m_dyMicrodot->m_Billboarding = 1;
	m_dyMicrodot->m_bParticlesLeaveSystem = TRUE;
	m_dyMicrodot->SetMicrodotTexture("SNOW.BMP");

	m_dySampFont->SetEnFont(DEVICE,"Arial",10,200,0,0);
	return TRUE;
}

BOOL HeaderIn3D::SetfreeEntironment()
{
	SAFE_RELEASE(m_Billboard);
	SAFE_RELEASE(m_BillboardVB);
	m_dyMicrodot->SetfreeContext();
	m_dyLandScape->SetfreeContext();
	m_dySampFont->SetfreeContext();
	return TRUE;
}

BOOL HeaderIn3D::AfreshEntironment()
{
	HRESULT hr;
	m_dyLandScape->Create(DEVICE,g_pHeightMap);
	m_dyMicrodot->Create(DEVICE);

	DEVICE->SetTransform(D3DTS_PROJECTION,&m_dyCamera->MatrixPerspectiveFovLH(D3DX_PI/4,
		(FLOAT)BackBufferWidth()/BackBufferHeight(),1.0f,2000.0f));
	DEVICE->SetRenderState( D3DRS_ZENABLE, D3DZB_TRUE);
	DEVICE->SetRenderState( D3DRS_LIGHTING,FALSE);
	DEVICE->SetRenderState(D3DRS_ALPHATESTENABLE , FALSE);
	DEVICE->SetRenderState(D3DRS_ALPHAREF, 0x01);
	DEVICE->SetRenderState(D3DRS_ALPHAFUNC, D3DCMP_GREATEREQUAL );
	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, "BILLBOARD.bmp", 
		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_Billboard);
	if( FAILED(hr)) return FALSE;
	hr = D3DXCreateTextureFromFile( DEVICE,"SNOW.BMP",&m_BillSnow);
	if( FAILED(hr)) return FALSE;
	hr = DEVICE->CreateVertexBuffer(4 * sizeof(BILLBOARD),0,0,D3DPOOL_DEFAULT,&m_BillboardVB);
	if( FAILED(hr)) return FALSE;
	LPBILLBOARD PV;
	hr = m_BillboardVB->Lock(0,0,(BYTE**)&PV,0);
	*PV = BILLBOARD(D3DXVECTOR3(-5,20,0),0,0); PV++;
	*PV = BILLBOARD(D3DXVECTOR3(5,20,0),1,0); PV++;
	*PV = BILLBOARD(D3DXVECTOR3(-5,0,0),0,1); PV++;
	*PV = BILLBOARD(D3DXVECTOR3(5,0,0),1,1); PV++;
	m_BillboardVB->Unlock();
	
	for ( LONG i = 0; i< 40; i++)
	{
		D3DXVECTOR3 vPos = D3DXVECTOR3(RAND_COORD((MAP_SIZE - 1),0), 0.0, RAND_COORD((MAP_SIZE - 1),0));
		vPos.y = m_dyLandScape->GetHeightValue((LONG)vPos.x,(LONG)vPos.z);
		g_vPos[i] = vPos;
	}	

	m_dySampFont->CreateContext(DEVICE);	
	return TRUE;
}

BOOL HeaderIn3D::CheckFrameInMove()
{
	m_dyConsole->UpdateKeyboard();
	m_dyMicrodot->UpdateSystem(0.05f);
	m_dyFPS->Limit(60);
	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_RGBA(0,64,128,255), 1.0f, 0 );
	if ( SUCCEEDED(DEVICE->BeginScene()))
	{
		D3DXMATRIX mat,matTrans;
		DEVICE->SetTransform(D3DTS_VIEW,&m_dyCamera->MatrixLookAtLH());
		m_dyLandScape->SetNewFrame(0);
		m_dyLandScape->CreateLandMesh();
		m_dyLandScape->LandInScene();
		DEVICE->SetStreamSource(0,m_BillboardVB,sizeof(BILLBOARD));
		DEVICE->SetVertexShader(BILLBOARD::FVF_BILLBOARD);
		DEVICE->SetTexture(0,m_Billboard);
		DEVICE->SetRenderState(D3DRS_ALPHATESTENABLE , TRUE);
		DEVICE->GetTransform(D3DTS_WORLD,&matTrans);
		DEVICE->GetTransform(D3DTS_VIEW, &mat);
		D3DXMatrixInverse(&mat,0,&mat);
		for ( int i = 0; i < 40; ++i)
		{
			mat._41 = (FLOAT)g_vPos[i].x;
			mat._42 = (FLOAT)g_vPos[i].y;
			mat._43 = (FLOAT)g_vPos[i].z;
			DEVICE->SetTransform(D3DTS_WORLD,&mat);
			DEVICE->DrawPrimitive(D3DPT_TRIANGLESTRIP,0,2);
		}
		DEVICE->SetRenderState( D3DRS_ALPHATESTENABLE ,FALSE);
		DEVICE->SetTransform(D3DTS_WORLD,&matTrans);
		DEVICE->SetTexture(0,0);
		m_dyMicrodot->MicrodotInScene();
		TCHAR strRate[64];
		sprintf(strRate,"Limit FPS:60.0  Current FPS:%4.1f",m_dyFPS->GetFPS());
		m_dySampFont->BeginTextOut();
		m_dySampFont->Text2DOut(strRate,5,160,D3DCOLOR_RGBA(255,64,0,255));    
		m_dySampFont->Text2DOut(m_strAdapterInfo,5,2,D3DCOLOR_RGBA(255,255,0,255));
		m_dySampFont->Text2DOut("DIK_W:AHEAD\nDIK_S:BACK\nDIK_A:SPIN\nDIK_D:SPIN\n",5,45,D3DCOLOR_RGBA(255,128,128,255));
		m_dySampFont->Text2DOut("Numeric Key +: INC SPEED\nNumeric Key  -: DEC SPEED\n",5,120,D3DCOLOR_RGBA(255,64,0,255));    
		m_dySampFont->EndTextOut();
		DEVICE->EndScene();
	}
	DEVICE->Present(0,0,0,0);
	return TRUE;
}

BOOL HeaderIn3D::LockKeyboard(UINT nScanCode, WPARAM wParam, LPARAM lParam)
{
	FLOAT fAngle = ANGLE / m_dyFPS->GetFPS();
	FLOAT fSpeed = m_dyfSpeed / m_dyFPS->GetFPS();
	CHECK_RANGE(fSpeed,0,10);
	switch(nScanCode)
	{
	case DIK_A:
		m_dyCamera->MatrixRotationAxis(0.0f,-fAngle);
		break;
	case DIK_D:
		m_dyCamera->MatrixRotationAxis(0.0f,fAngle);
		break;
	case DIK_LEFT:
		m_dyCamera->MatrixRotationAxis(0.0f,-fAngle);
		break;
	case DIK_RIGHT:
		m_dyCamera->MatrixRotationAxis(0.0f,fAngle);
		break;
	case DIK_W:
		m_dyCamera->MatrixTranslateXYZAxis(fSpeed);
		break;
	case DIK_S:
		m_dyCamera->MatrixTranslateXYZAxis(-fSpeed);
		break;
	case DIK_ADD:
		m_dyfSpeed+=20;
		CHECK_RANGE(m_dyfSpeed,200,400);
		break;
	case DIK_SUBTRACT:
		m_dyfSpeed-=20;
		CHECK_RANGE(m_dyfSpeed,200,400);
	default: break;
	}
	return TRUE;
}

BOOL HeaderIn3D::CleanupOnLastTime()
{
	SAFE_RELEASE(m_Billboard);
	SAFE_RELEASE(m_BillboardVB);
	m_dyMicrodot->SetfreeContext();
	m_dyLandScape->SetfreeContext();
	m_dySampFont->SetfreeContext();
	return TRUE;
}

BOOL HeaderIn3D::ReadHeightMap()
{
	FILE *fp;
	TCHAR fileName[30];
	g_pHeightMap = (BYTE *)malloc( MAP_SIZE * MAP_SIZE * sizeof(BYTE) + MAP_SIZE * 2 );	
	sprintf( fileName, "Height%d.raw", MAP_SIZE );
	fp = fopen(fileName, "rb");
	if ( fp == NULL )
	{
		sprintf( fileName, "Map.ved", MAP_SIZE );
		fp = fopen(fileName, "rb");
		if ( fp != NULL )
			fseek( fp, 40, SEEK_SET );	// Skip to the goods...
	}
	
	if (fp == NULL)
	{
		memset( g_pHeightMap, 0, MAP_SIZE * MAP_SIZE + MAP_SIZE * 2 );
		return FALSE;
	}
	fread(g_pHeightMap + MAP_SIZE, 1, (MAP_SIZE * MAP_SIZE), fp);
	fclose(fp);
	
	memcpy( g_pHeightMap, g_pHeightMap + MAP_SIZE * MAP_SIZE, MAP_SIZE );
	memcpy( g_pHeightMap + MAP_SIZE * MAP_SIZE + MAP_SIZE, g_pHeightMap + MAP_SIZE, MAP_SIZE );
	return TRUE;
}