headerin3d.cpp

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

// HeaderIn3D.cpp: implementation of the HeaderIn3D class.
//
//////////////////////////////////////////////////////////////////////

#include "HeaderIn3D.h"

USING NAMESPACE CGE;
D3DXVECTOR3 vGravity(0.0f,-5.0f,0.0f);
D3DXVECTOR3 vRadiusVector(0.5f, 1.5f, 0.5f);
#define SPEED 1.5f
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
BOOL Keyboard(UINT nScanCode,WPARAM wParam,LPARAM lParam)
{
	return theApp.LockKeyboard(nScanCode,wParam,lParam);
}

HeaderIn3D::HeaderIn3D()
{
	this->m_dy3DSOctree = NULL;
	this->m_dy3DSFile = NULL;
	this->m_dyCamera = NULL;
	this->m_dyConsole = NULL;
}

HeaderIn3D::~HeaderIn3D()
{
	SAFE_DELETE(m_dy3DSOctree);
	SAFE_DELETE(m_dy3DSFile);
	SAFE_DELETE(m_dyCamera);
	SAFE_DELETE(m_dyConsole);
}

BOOL HeaderIn3D::InitializeOnFirstTime()
{
	m_dy3DSOctree = new CULLING::_3DSOCTREE;
	m_dy3DSFile = new MODEL::_3DSFILE::_3DS;
	m_dyCamera = new MATRIX::CAMERA;
	m_dyConsole = new INPUT::CONSOLE;
	return TRUE;
}



BOOL HeaderIn3D::InitializeEntironment()
{
	m_dy3DSOctree->m_fMaxNodeSize = 16;
	m_dy3DSOctree->m_nMaxTriangles = 32;
	m_dy3DSFile->Read3DSFile(DEVICE,"Park.3ds");
	m_dy3DSOctree->SetSceneDimensions(m_dy3DSFile);
	m_dy3DSOctree->m_OctreeRootNode = new CULLING::OctreeTriNode;
	LONG ModelNum,ObjectNum,TriMeshNum,TriFaceNum,UseMatNum;
	for ( ModelNum = 0; ModelNum < m_dy3DSFile->m_3DSFile.m_vModels.size(); ModelNum++)
	{
		CGE::MODEL::_3DSFILE::_3DSModel & Model = m_dy3DSFile->m_3DSFile.m_vModels[ModelNum];
		CULLING::MaterialNode Material;
		Material.m_ModelIndex = ModelNum;
		LONG NumMaterial = Model.m_vUseMaterials.size();
		LONG NumTexture = Model.m_vTextures.size();
		Material.m_vMaterials.resize(Model.m_vUseMaterials.size());
		Material.m_vTextures.resize(Model.m_vUseMaterials.size());
		memcpy((PVOID)Material.m_vMaterials.begin(),(PVOID)Model.m_vUseMaterials.begin(),
			sizeof(D3DMATERIAL8)*NumMaterial);
		memcpy((PVOID)Material.m_vTextures.begin(),(PVOID)Model.m_vTextures.begin(),
			sizeof(LPDIRECT3DTEXTURE8)*NumTexture);

		for ( ObjectNum = 0; ObjectNum < Model.m_vObjects.size(); ObjectNum++)
		{
			CGE::MODEL::_3DSFILE::_3DSObject & Object = Model.m_vObjects[ObjectNum];
			for ( TriMeshNum = 0; TriMeshNum < Object.m_vTriMeshs.size(); TriMeshNum++)
			{
				CGE::MODEL::_3DSFILE::_3DSTriMesh & TriMesh = Object.m_vTriMeshs[TriMeshNum];
				LONG NumOfUseMat = TriMesh.m_vUseMaterials.size();
				for( UseMatNum = 0; UseMatNum < TriMesh.m_vUseMaterials.size();UseMatNum++)
				{
					CGE::MODEL::_3DSFILE::_3DSUseMat & UseMat = TriMesh.m_vUseMaterials[UseMatNum];
					CULLING::Marshal MarshalIn;
					MarshalIn.m_NumOfTri = UseMat.m_vFaceIndices.size();
					MarshalIn.m_ModelIndex = ModelNum;
					MarshalIn.m_ObjectIndex = ObjectNum;
					MarshalIn.m_TriMeshIndex = TriMeshNum;
					MarshalIn.m_MatIndex = UseMat.m_usMatIdx;
					if ( TriMesh.m_vTexCoords.size() != 0 ) 
						MarshalIn.m_bHasTexture = TRUE;
					else
						MarshalIn.m_bHasTexture = FALSE;

					for( TriFaceNum = 0; TriFaceNum < UseMat.m_vFaceIndices.size(); TriFaceNum++)
					{
						CULLING::TriangleFace Face;
						Face.m_nModelIndex = ModelNum;
						Face.m_nObjIndex = ObjectNum;
						Face.m_nMarshalID = m_dy3DSOctree->m_vMarshals.size();
						Face.m_nTriMeshIndex = TriMeshNum;
						Face.m_nVertIndices[0] = TriMesh.m_vFaces[TriFaceNum].m_usIndices[0];
						Face.m_nVertIndices[1] = TriMesh.m_vFaces[TriFaceNum].m_usIndices[1];
						Face.m_nVertIndices[2] = TriMesh.m_vFaces[TriFaceNum].m_usIndices[2];
						m_dy3DSOctree->m_vTriangles.push_back(Face);
					}
					m_dy3DSOctree->m_vMarshals.push_back(MarshalIn);
				}
			}
		}
		m_dy3DSOctree->m_vMaterials.push_back(Material);
	}
	LONG MarshNum = m_dy3DSOctree->m_vMarshals.size();
	for( MarshNum = 0; MarshNum < m_dy3DSOctree->m_vMarshals.size();MarshNum++)
	{
		CULLING::Marshal & MarshalNo = m_dy3DSOctree->m_vMarshals[MarshNum];
		DEVICE->CreateVertexBuffer(MarshalNo.m_NumOfTri * sizeof(MODEL::_3DSFILE::_3DSVERTEX) * 3,0,
			0,D3DPOOL_MANAGED,&MarshalNo.m_pVB);
	}
	LONG TriangleFace = m_dy3DSOctree->m_vTriangles.size();
	m_dy3DSOctree->CreateSceneNode(m_dy3DSOctree->m_OctreeRootNode,D3DXVECTOR3(0,0,0),m_dy3DSOctree->m_fSceneDimension);

	m_dyCamera->MatrixLookAt(D3DXVECTOR3(-1,5,0),D3DXVECTOR3(-1,5,1),D3DXVECTOR3(0,1,0));

	ZeroMemory(&m_dyPointLight,sizeof(D3DLIGHT8));
	m_dyPointLight.Type = D3DLIGHT_DIRECTIONAL;
	m_dyPointLight.Diffuse.r = 1.0f;
	m_dyPointLight.Diffuse.g = 1.0f;
	m_dyPointLight.Diffuse.b = 1.0f;
	m_dyPointLight.Diffuse.a = 1.0f;
	m_dyPointLight.Ambient = m_dyPointLight.Diffuse;
	m_dyPointLight.Specular = m_dyPointLight.Ambient;
	m_dyPointLight.Position = D3DXVECTOR3(0,10,0);
    D3DXVec3Normalize( (D3DXVECTOR3*)&m_dyPointLight.Direction, &D3DXVECTOR3( 0.0f, -1.0f, 1.0f) );
    m_dyPointLight.Range    = 1000.0f;
	m_dyPointLight.Attenuation0 = 1.0f;
	m_dyPointLight.Falloff = 0; 



	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_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);

	return TRUE;
}

BOOL HeaderIn3D::SetfreeEntironment()
{
	return TRUE;
}

BOOL HeaderIn3D::AfreshEntironment()
{
	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);
	DEVICE->SetLight(0,&m_dyPointLight);
	DEVICE->LightEnable(0,TRUE);
	DEVICE->SetRenderState(D3DRS_LIGHTING,TRUE);
	DEVICE->SetRenderState( D3DRS_AMBIENT, 0xFFFFFFFF );
	DEVICE->SetRenderState( D3DRS_SPECULARMATERIALSOURCE, D3DMCS_MATERIAL);
	DEVICE->SetRenderState( D3DRS_SPECULARENABLE, TRUE );
	DEVICE->SetRenderState(D3DRS_ZENABLE,2);
	D3DXMATRIX mat;
	D3DXMatrixIdentity(&mat);
	D3DXMatrixPerspectiveFovLH(&mat,D3DX_PI/4,(FLOAT)BackBufferWidth()/BackBufferHeight(),0.001f,1000.0f);
	DEVICE->SetTransform(D3DTS_PROJECTION,&mat);

	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_dy3DSOctree->CollisionDetection(vCameraPos,vRadiusVector,vGravity,1.0f,0.0f);
	m_dyCamera->LayAt(vCameraPos);
	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.5f, 0.68f, 1.0f), 1.0f, 0 );
	if(SUCCEEDED(DEVICE->BeginScene()))
	{
		DEVICE->SetTransform(D3DTS_VIEW,&m_dyCamera->MatrixLookAtLH());
		m_dy3DSOctree->NodeInScene(DEVICE,0,0);
		DEVICE->SetTexture(0,0);
		DEVICE->EndScene();
	}
	DEVICE->Present(0,0,0,0);
	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_dy3DSOctree->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_dy3DSOctree->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_dy3DSOctree->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_dy3DSOctree->CollisionDetection(vCameraPos,vRadiusVector,vVelocity,0.0f,0.0f) )
		{
			m_dyCamera->LayAt(vCameraPos);
		}
		else
		{
			m_dyCamera->MatrixTranslateXZAxis(-SPEED);
		}
		break;
	default: break;
	}
	return TRUE; 
}

BOOL HeaderIn3D::CleanupOnLastTime()
{
	return TRUE;
}