//=============================================================================
// AsteroidsDemo.cpp by Frank Luna (C) 2005 All Rights Reserved.
//
// Demonstrates picking with a simple asteroids type game.
//
// Controls: Use mouse to look and 'W', 'S', 'A', and 'D' keys to move.
//           Left mouse button to pick asteroids.
//=============================================================================

#include "d3dApp.h"
#include "DirectInput.h"
#include <crtdbg.h>
#include "GfxStats.h"
#include <list>
#include <vector>
#include <ctime>
#include "Terrain.h"
#include "Camera.h"
#include "PSystem.h"

// Create a simple firework particle system which goes off
// whenever the user picks an asteroid.
class FireWork : public PSystem
{
public:
	FireWork(const std::string& fxName, 
		const std::string& techName, 
		const std::string& texName, 
		const D3DXVECTOR3& accel, 
		const AABB& box,
		int maxNumParticles,
		float timePerParticle)
		: PSystem(fxName, techName, texName, accel, box, 
		maxNumParticles, timePerParticle)
	{
		for(int i = 0; i < mMaxNumParticles; ++i)
		{
			initParticle(mParticles[i]);
		}
	}

	void initParticle(Particle& out)
	{
		out.initialTime = 0.0f;
		out.initialSize  = GetRandomFloat(12.0f, 15.0f);
		out.lifeTime = 10.0f;

		// Generate Random Direction
		D3DXVECTOR3 d;
		GetRandomVec(d);

		// Compute velocity.
		float speed = GetRandomFloat(100.0f, 150.0f);
		out.initialVelocity = speed*d;

		out.initialColor = WHITE;
		out.mass = GetRandomFloat(2.0f, 4.0f);

		float r = GetRandomFloat(0.0f, 2.0f);
		out.initialPos = r*d;
	}
};
 
// In order to not duplicate firework systems, we create
// a firework "instance" structure, which stores the position of
// the instance in world space and its relative time since being
// created.  In this way, we can draw several fireworks with only 
// one actual system by drawing the system in different world space
// positions and at different times.
struct FireWorkInstance
{
	float time;
	D3DXMATRIX toWorld;
};

// A simple asteroid structure to maintain the rotation, position, 
// and velocity of an asteroid.  
struct Asteroid
{
	D3DXVECTOR3 axis;
	float theta;
	D3DXVECTOR3 pos;
	D3DXVECTOR3 vel;
};

class AsteroidsDemo : public D3DApp
{
public:
	AsteroidsDemo(HINSTANCE hInstance, std::string winCaption, D3DDEVTYPE devType, DWORD requestedVP);
	~AsteroidsDemo();

	bool checkDeviceCaps();
	void onLostDevice();
	void onResetDevice();
	void updateScene(float dt);
	void drawScene();

	void initAsteroids();
	void buildFX();
	void getWorldPickingRay(D3DXVECTOR3& originW, D3DXVECTOR3& dirW);

private:
	GfxStats* mGfxStats;

	// We only need one firework system, as we just draw the same system
	// several times per frame in different positions and at different
	// relative times to simulate multiple systems.
	PSystem* mFireWork;

	// A list of firework *instances*
	std::list<FireWorkInstance> mFireWorkInstances;

	// A list of asteroids.
	static const int NUM_ASTEROIDS = 300;
	std::list<Asteroid> mAsteroids;

	// We only need one actual mesh, as we just draw the same mesh several
	// times per frame in different positions to simulate multiple asteroids.
	ID3DXMesh* mAsteroidMesh;
	std::vector<Mtrl> mAsteroidMtrls;
	std::vector<IDirect3DTexture9*> mAsteroidTextures;
	AABB mAsteroidBox;

	// General light/texture FX
	ID3DXEffect* mFX;
	D3DXHANDLE   mhTech;
	D3DXHANDLE   mhWVP;
	D3DXHANDLE   mhWorldInvTrans;
	D3DXHANDLE   mhEyePos;
	D3DXHANDLE   mhWorld;
	D3DXHANDLE   mhTex;
	D3DXHANDLE   mhMtrl;
	D3DXHANDLE   mhLight;

	DirLight mLight;

	// Default texture if no texture present for subset.
	IDirect3DTexture9* mWhiteTex;
};


int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE prevInstance,
				   PSTR cmdLine, int showCmd)
{
	// Enable run-time memory check for debug builds.
	#if defined(DEBUG) | defined(_DEBUG)
		_CrtSetDbgFlag( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF );
	#endif

	srand(time(0));

	// Construct camera before application, since the application uses the camera.
	Camera camera;
	gCamera = &camera;

	AsteroidsDemo app(hInstance, "Asteroids Demo", D3DDEVTYPE_HAL, D3DCREATE_HARDWARE_VERTEXPROCESSING);
	gd3dApp = &app;

	DirectInput di(DISCL_NONEXCLUSIVE|DISCL_FOREGROUND, DISCL_NONEXCLUSIVE|DISCL_FOREGROUND);
	gDInput = &di;

    return gd3dApp->run();
}

AsteroidsDemo::AsteroidsDemo(HINSTANCE hInstance, std::string winCaption, D3DDEVTYPE devType, DWORD requestedVP)
: D3DApp(hInstance, winCaption, devType, requestedVP)
{
	if(!checkDeviceCaps())
	{
		MessageBox(0, "checkDeviceCaps() Failed", 0, 0);
		PostQuitMessage(0);
	}

	InitAllVertexDeclarations();

	mGfxStats = new GfxStats();
	
	// Load the asteroid mesh and compute its bounding box in local space.
	LoadXFile("asteroid.x", &mAsteroidMesh, mAsteroidMtrls, mAsteroidTextures);
	VertexPNT* v = 0;
	HR(mAsteroidMesh->LockVertexBuffer(0, (void**)&v));
	HR(D3DXComputeBoundingBox(&v->pos, mAsteroidMesh->GetNumVertices(),
		mAsteroidMesh->GetNumBytesPerVertex(), 
		&mAsteroidBox.minPt, &mAsteroidBox.maxPt));
	HR(mAsteroidMesh->UnlockVertexBuffer());

	// Initialize camera.
	gCamera->pos() = D3DXVECTOR3(0.0f, 0.0f, 0.0f);
	gCamera->setSpeed(40.0f);

	// Initialize the particle system.
	D3DXMATRIX psysWorld;
	D3DXMatrixIdentity(&psysWorld);

	AABB psysBox; 
	psysBox.maxPt = D3DXVECTOR3(INFINITY, INFINITY, INFINITY);
	psysBox.minPt = D3DXVECTOR3(-INFINITY, -INFINITY, -INFINITY);
	mFireWork = new FireWork("fireworks.fx", "FireWorksTech", "bolt.dds", 
		D3DXVECTOR3(0.0f, -9.8f, 0.0f), psysBox, 500, -1.0f);
	mFireWork->setWorldMtx(psysWorld);

	// Call update once to put all particles in the "alive" list.
	mFireWork->update(0.0f);

	// Load the default texture.
	HR(D3DXCreateTextureFromFile(gd3dDevice, "whitetex.dds", &mWhiteTex));

	// Init a light.
	mLight.dirW    = D3DXVECTOR3(0.707f, 0.0f, 0.707f);
	D3DXVec3Normalize(&mLight.dirW, &mLight.dirW);
	mLight.ambient = D3DXCOLOR(1.0f, 1.0f, 1.0f, 1.0f);
	mLight.diffuse = D3DXCOLOR(1.0f, 1.0f, 1.0f, 1.0f);
	mLight.spec    = D3DXCOLOR(1.0f, 1.0f, 1.0f, 1.0f);
	
	buildFX();
	initAsteroids();

	onResetDevice();
}

AsteroidsDemo::~AsteroidsDemo()
{
	delete mGfxStats;
	ReleaseCOM(mWhiteTex);
	ReleaseCOM(mFX);
	delete mFireWork;

	ReleaseCOM(mAsteroidMesh);
	for(UINT i = 0; i < mAsteroidTextures.size(); ++i)
		ReleaseCOM(mAsteroidTextures[i]);
	
	DestroyAllVertexDeclarations();
}

bool AsteroidsDemo::checkDeviceCaps()
{
	D3DCAPS9 caps;
	HR(gd3dDevice->GetDeviceCaps(&caps));

	// Check for vertex shader version 2.0 support.
	if( caps.VertexShaderVersion < D3DVS_VERSION(2, 0) )
		return false;

	// Check for pixel shader version 2.0 support.
	if( caps.PixelShaderVersion < D3DPS_VERSION(2, 0) )
		return false;

	return true;
}

void AsteroidsDemo::onLostDevice()
{
	mGfxStats->onLostDevice();
	HR(mFX->OnLostDevice());
	mFireWork->onLostDevice();
}

void AsteroidsDemo::onResetDevice()
{
	mGfxStats->onResetDevice();
	HR(mFX->OnResetDevice());
	mFireWork->onResetDevice();

	// The aspect ratio depends on the backbuffer dimensions, which can 
	// possibly change after a reset.  So rebuild the projection matrix.
	float w = (float)md3dPP.BackBufferWidth;
	float h = (float)md3dPP.BackBufferHeight;
	gCamera->setLens(D3DX_PI * 0.25f, w/h, 0.01f, 5000.0f);
}

void AsteroidsDemo::updateScene(float dt)
{
	mGfxStats->update(dt);

	mGfxStats->setTriCount(mAsteroidMesh->GetNumFaces()*mAsteroids.size());
	mGfxStats->setVertexCount(mAsteroidMesh->GetNumVertices()*mAsteroids.size());

	gDInput->poll();

	gCamera->update(dt, 0, 0);

	// Update the asteroids' orientation and position.
	std::list<Asteroid>::iterator asteroidIter = mAsteroids.begin();
	while( asteroidIter != mAsteroids.end() )
	{
		asteroidIter->theta += 4.0f*dt;
		asteroidIter->pos += asteroidIter->vel*dt;
		++asteroidIter;
	}


	// Update and delete dead firework systems.
	std::list<FireWorkInstance>::iterator fireworkIter = mFireWorkInstances.begin();
	while(fireworkIter != mFireWorkInstances.end())
	{
		fireworkIter->time += dt;

		// Kill system after 1 seconds.
		if(fireworkIter->time > 1.0f)
			fireworkIter = mFireWorkInstances.erase(fireworkIter);
		else
			++fireworkIter;
	}
}

void AsteroidsDemo::drawScene()
{
	// Clear the backbuffer and depth buffer.
	HR(gd3dDevice->Clear(0, 0, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xff333333, 1.0f, 0));

	HR(gd3dDevice->BeginScene());

	HR(mFX->SetValue(mhEyePos, &gCamera->pos(), sizeof(D3DXVECTOR3)));
	HR(mFX->SetTechnique(mhTech));
	UINT numPasses = 0;
	HR(mFX->Begin(&numPasses, 0));
	HR(mFX->BeginPass(0));

	// Did we pick anything?
	D3DXVECTOR3 originW(0.0f, 0.0f, 0.0f);
	D3DXVECTOR3 dirW(0.0f, 0.0f, 0.0f);
	if( gDInput->mouseButtonDown(0) )
	{
		getWorldPickingRay(originW, dirW);
	}

	std::list<Asteroid>::iterator iter = mAsteroids.begin();
	while( iter != mAsteroids.end() )
	{
		// Build world matrix based on current rotation and position settings.
		D3DXMATRIX R, T;
		D3DXMatrixRotationAxis(&R, &iter->axis, iter->theta);
		D3DXMatrixTranslation(&T, iter->pos.x, iter->pos.y, iter->pos.z);

		D3DXMATRIX toWorld = R*T;

		// Transform AABB to world space.
		AABB box;
		mAsteroidBox.xform(toWorld, box);

		// Did we pick it?
		if(D3DXBoxBoundProbe(&box.minPt, &box.maxPt, &originW, &dirW))
		{
			// Create a firework instance.
			FireWorkInstance inst;
			inst.time = 0.0f;
			inst.toWorld = toWorld;
			mFireWorkInstances.push_back(inst);
	
			// Remove asteroid from list and move onto the next node.
			iter = mAsteroids.erase(iter);
			continue;
		}

		// Only draw if AABB is visible.
		if( gCamera->isVisible( box ) )
		{
			HR(mFX->SetMatrix(mhWVP, &(toWorld*gCamera->viewProj())));
			D3DXMATRIX worldInvTrans;
			D3DXMatrixInverse(&worldInvTrans, 0, &toWorld);
			D3DXMatrixTranspose(&worldInvTrans, &worldInvTrans);
			HR(mFX->SetMatrix(mhWorldInvTrans, &worldInvTrans));
			HR(mFX->SetMatrix(mhWorld, &toWorld));

			for(UINT j = 0; j < mAsteroidMtrls.size(); ++j)
			{
				HR(mFX->SetValue(mhMtrl, &mAsteroidMtrls[j], sizeof(Mtrl)));
			
				// If there is a texture, then use.
				if(mAsteroidTextures[j] != 0)
				{
					HR(mFX->SetTexture(mhTex, mAsteroidTextures[j]));
				}

				// But if not, then set a pure white texture.  When the texture color
				// is multiplied by the color from lighting, it is like multiplying by
				// 1 and won't change the color from lighting.
				else
				{
					HR(mFX->SetTexture(mhTex, mWhiteTex));
				}
			
				HR(mFX->CommitChanges());
				HR(mAsteroidMesh->DrawSubset(j));
			}
		}
		++iter;
	}
	 
	HR(mFX->EndPass());
	HR(mFX->End());

	// Draw fireworks.
	std::list<FireWorkInstance>::iterator psysIter = mFireWorkInstances.begin();
	while(psysIter != mFireWorkInstances.end())
	{
		mFireWork->setTime(psysIter->time);
		mFireWork->setWorldMtx(psysIter->toWorld);
		mFireWork->draw();
		++psysIter;
	}

	mGfxStats->display();

	HR(gd3dDevice->EndScene());

	// Present the backbuffer.
	HR(gd3dDevice->Present(0, 0, 0, 0));
}

void AsteroidsDemo::initAsteroids()
{
	Asteroid a;
	for(int i = 0; i < NUM_ASTEROIDS; ++i)
	{
		// Generate a random rotation axis.
		GetRandomVec(a.axis);

		// No rotation to start, but we will rotate as 
		// a function of time.
		a.theta = 0.0f;

		// Random position in world space.
		a.pos.x = GetRandomFloat(-500.0f, 500.0f);
		a.pos.y = GetRandomFloat(-500.0f, 500.0f);
		a.pos.z = GetRandomFloat(-500.0f, 500.0f);

		// Random velocity in world space.
		float speed = GetRandomFloat(10.0f, 20.0f);
		D3DXVECTOR3 dir;
		GetRandomVec(dir);
		a.vel = speed*dir;

		mAsteroids.push_back(a);
	}
}

void AsteroidsDemo::buildFX()
{
	// Create the FX from a .fx file.
	ID3DXBuffer* errors = 0;
	HR(D3DXCreateEffectFromFile(gd3dDevice, "PhongDirLtTex.fx", 
		0, 0, D3DXSHADER_DEBUG, 0, &mFX, &errors));
	if( errors )
		MessageBox(0, (char*)errors->GetBufferPointer(), 0, 0);

	// Obtain handles.
	mhTech            = mFX->GetTechniqueByName("PhongDirLtTexTech");
	mhWVP             = mFX->GetParameterByName(0, "gWVP");
	mhWorldInvTrans   = mFX->GetParameterByName(0, "gWorldInvTrans");
	mhMtrl            = mFX->GetParameterByName(0, "gMtrl");
	mhLight           = mFX->GetParameterByName(0, "gLight");
	mhEyePos          = mFX->GetParameterByName(0, "gEyePosW");
	mhWorld           = mFX->GetParameterByName(0, "gWorld");
	mhTex             = mFX->GetParameterByName(0, "gTex");

	HR(mFX->SetValue(mhLight, &mLight, sizeof(DirLight)));
}

void AsteroidsDemo::getWorldPickingRay(D3DXVECTOR3& originW, D3DXVECTOR3& dirW)
{
	// Get the screen point clicked.
	POINT s;
	GetCursorPos(&s);

	// Make it relative to the client area window.
	ScreenToClient(mhMainWnd, &s);

	// By the way we've been constructing things, the entire 
	// backbuffer is the viewport.

	float w = (float)md3dPP.BackBufferWidth;
	float h = (float)md3dPP.BackBufferHeight;

	D3DXMATRIX proj = gCamera->proj();

	float x = (2.0f*s.x/w - 1.0f) / proj(0,0);
	float y = (-2.0f*s.y/h + 1.0f) / proj(1,1);

	// Build picking ray in view space.
	D3DXVECTOR3 origin(0.0f, 0.0f, 0.0f);
	D3DXVECTOR3 dir(x, y, 1.0f);

	// So if the view matrix transforms coordinates from 
	// world space to view space, then the inverse of the
	// view matrix transforms coordinates from view space
	// to world space.
	D3DXMATRIX invView;
	D3DXMatrixInverse(&invView, 0, &gCamera->view());

	// Transform picking ray to world space.
	D3DXVec3TransformCoord(&originW, &origin, &invView);
	D3DXVec3TransformNormal(&dirW, &dir, &invView);
	D3DXVec3Normalize(&dirW, &dirW);
}