//=============================================================================
// PageFlipDemo.cpp by Frank Luna (C) 2005 All Rights Reserved.
//
// Demonstrates a page flipping animation technique.
//=============================================================================

#include "d3dApp.h"
#include "DirectInput.h"
#include <crtdbg.h>
#include "GfxStats.h"

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

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

private:
	GfxStats* mGfxStats;
	ID3DXSprite* mSprite;
	IDirect3DTexture9* mFrames;
	D3DXVECTOR3 mSpriteCenter;
 
	int mCurrFrame;
};


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

	PageFlipDemo app(hInstance, "Page Flip Demo", D3DDEVTYPE_HAL, D3DCREATE_HARDWARE_VERTEXPROCESSING);
	gd3dApp = &app;

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

	return gd3dApp->run();
}

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

	mGfxStats = new GfxStats();

	HR(D3DXCreateSprite(gd3dDevice, &mSprite));
	HR(D3DXCreateTextureFromFile(gd3dDevice, "fireatlas.bmp", &mFrames));
	mSpriteCenter = D3DXVECTOR3(32.0f, 32.0f, 0.0f);

	// The current frame of animation to render.
	mCurrFrame = 0;

	onResetDevice();
}

PageFlipDemo::~PageFlipDemo()
{
	delete mGfxStats;
	ReleaseCOM(mSprite);
	ReleaseCOM(mFrames);
}

bool PageFlipDemo::checkDeviceCaps()
{
	// Nothing to check.
	return true;
}

void PageFlipDemo::onLostDevice()
{
	mGfxStats->onLostDevice();
	HR(mSprite->OnLostDevice());
}

void PageFlipDemo::onResetDevice()
{
	// Call the onResetDevice of other objects.
	mGfxStats->onResetDevice();
	HR(mSprite->OnResetDevice());

	// Sets up the camera 1000 units back looking at the origin.
	D3DXMATRIX V;
	D3DXVECTOR3 pos(0.0f, 0.0f, -100.0f);
	D3DXVECTOR3 up(0.0f, 1.0f, 0.0f);
	D3DXVECTOR3 target(0.0f, 0.0f, 0.0f);
	D3DXMatrixLookAtLH(&V, &pos, &target, &up);
	HR(gd3dDevice->SetTransform(D3DTS_VIEW, &V));

	// The following code defines the volume of space the camera sees.
	D3DXMATRIX P;
	RECT R;
	GetClientRect(mhMainWnd, &R);
	float width  = (float)R.right;
	float height = (float)R.bottom;
	D3DXMatrixPerspectiveFovLH(&P, D3DX_PI*0.25f, width/height, 1.0f, 5000.0f);
	HR(gd3dDevice->SetTransform(D3DTS_PROJECTION, &P));

	// This code sets texture filters, which helps to smooth out distortions
	// when you scale a texture.  
	HR(gd3dDevice->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR));
	HR(gd3dDevice->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR));
	HR(gd3dDevice->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR));

	// This line of code disables Direct3D lighting.
	HR(gd3dDevice->SetRenderState(D3DRS_LIGHTING, false));
	
	// The following code is used to setup alpha blending.
	HR(gd3dDevice->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE));
	HR(gd3dDevice->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1));
	HR(gd3dDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA));
	HR(gd3dDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA));
}

void PageFlipDemo::updateScene(float dt)
{
	// Just Drawing 1 sprite at a time.
	mGfxStats->setTriCount(2);
	mGfxStats->setVertexCount(4);
	mGfxStats->update(dt);

	// Get snapshot of input devices.
	gDInput->poll();

	// Keep track of how much time has accumulated.
	static float timeAccum = 0.0f;
	timeAccum += dt;

	// Play animation at 30 frames per second.
	if( timeAccum >= 1.0f / 30.0f )
	{
		// After 1/30 seconds has passed, move on to the next frame.
		++mCurrFrame;
		timeAccum = 0.0f;

		// This animation has have 30 frames indexed from 0, 1, ..., 29, 
		// so start back at the beginning if we go over.
		if(mCurrFrame > 29)
			mCurrFrame = 0;
	}
}

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

	HR(gd3dDevice->BeginScene());
	HR(mSprite->Begin(D3DXSPRITE_OBJECTSPACE|D3DXSPRITE_DONOTMODIFY_RENDERSTATE));

	// Compute rectangle on texture atlas of the current frame
	// we want to use.
	int i = mCurrFrame / 6; // Row
	int j = mCurrFrame % 6; // Column
	RECT R = {j*64, i*64, (j+1)*64, (i+1)*64};

	// Turn on alpha blending.
	HR(gd3dDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, true));

	// Don't move explosion--set identity matrix.
	D3DXMATRIX M;
	D3DXMatrixIdentity(&M);
	HR(mSprite->SetTransform(&M));
	HR(mSprite->Draw(mFrames, &R, &mSpriteCenter, 0, D3DCOLOR_XRGB(255, 255, 255)));
	HR(mSprite->End());

	// Turn off alpha blending.
	HR(gd3dDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, false));

	mGfxStats->display();

	HR(gd3dDevice->EndScene());

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