#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <windows.h>
#include <mmsystem.h>
#include <d3dx9.h>
#include <d3d9.h>

#pragma comment (lib, "winmm.lib")
#pragma comment (lib, "d3dx9.lib")
#pragma comment (lib, "d3d9.lib")

#define D3DFVF_CUSTOMVERTEX (D3DFVF_XYZ|D3DFVF_DIFFUSE)

#define HEIGHT 600
#define WIDTH 400


// GLOB
LPDIRECT3D9             gPD3D       = NULL;
LPDIRECT3DDEVICE9       gPd3dDevice = NULL;
LPDIRECT3DVERTEXBUFFER9 gVertexBuff = NULL;
HANDLE			gInst = NULL;
HWND                    ghWnd = NULL;
PCHAR			szWindowClass = "MystWex";

//STRUCT
struct CUSTOMVERTEX
{
    FLOAT x, y, z;
    DWORD color;        
};

// FUNC
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
HRESULT InitWindow(HINSTANCE, int);
HRESULT InitDevice();
HRESULT InitVertex();
void SetMatrice();
void CleanupDevice();
void Render();

int WINAPI WinMain(HINSTANCE thisH, HINSTANCE prevH, LPSTR cmd, int modeAff)
{	
	MSG message = {0};

	if(FAILED(InitWindow(thisH, modeAff))) return 0;

	if(FAILED(InitDevice())) {
		CleanupDevice();
		return 0;
	}

	ShowWindow(ghWnd, SW_SHOWDEFAULT);
	UpdateWindow(ghWnd);

	while(message.message!=WM_QUIT) {
		if(PeekMessage(&message, NULL, 0U, 0U, PM_REMOVE)) {
			TranslateMessage(&message);
			DispatchMessage(&message);
		} else {
			Render();
		}
	}

	return message.wParam;
}

LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	switch (message)
	{
		case WM_PAINT:
			Render();
			ValidateRect(hWnd, NULL);
			break;

		case WM_DESTROY:
			CleanupDevice();
			PostQuitMessage(0);
			return 0;
	}
    
	return DefWindowProc(hWnd, message, wParam, lParam);
}

HRESULT InitWindow(HINSTANCE hinst, int mode) 
{
	WNDCLASSEX wex;
	wex.cbSize		   = sizeof(WNDCLASSEX);
	wex.style          = CS_HREDRAW | CS_VREDRAW;
	wex.lpfnWndProc    = WndProc;
	wex.cbClsExtra     = 0;
	wex.cbWndExtra     = 0;
	wex.hInstance	   = hinst;
	wex.hIcon          = LoadIcon(hinst, (LPCTSTR)IDI_APPLICATION);
	wex.hCursor        = LoadCursor(NULL, IDC_ARROW);
	wex.hbrBackground  = (HBRUSH)(COLOR_WINDOW+1);
	wex.lpszMenuName   = NULL;
	wex.lpszClassName  = (LPCSTR)szWindowClass;
	wex.hIconSm        = LoadIcon(wex.hInstance, (LPCTSTR)IDI_APPLICATION);
	if(!RegisterClassEx(&wex)) return E_FAIL;

	RECT rc = {0, 0, HEIGHT, WIDTH};

	AdjustWindowRect(&rc, WS_OVERLAPPEDWINDOW, FALSE);
	ghWnd = CreateWindow(szWindowClass, (LPCSTR)"Mysterie D3D Test...", 
						WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, 
						rc.right - rc.left, rc.bottom - rc.top, 
						NULL, NULL, hinst, NULL);

	
	if(!ghWnd) {
		return E_FAIL;
	} else {
		gInst = hinst;
		ShowWindow(ghWnd, mode);
		return S_OK;
	}
}

HRESULT InitDevice() 
{

    // Create the D3D object, which is needed to create the D3DDevice.
	if(NULL == (gPD3D = Direct3DCreate9(D3D_SDK_VERSION))) {
		MessageBox(NULL, (LPCTSTR)"Direct3DCreate9 fail.", (LPCTSTR)"Erreur :')", MB_OK);
		return E_FAIL;
	}
	
	D3DPRESENT_PARAMETERS d3dpp; 
	ZeroMemory(&d3dpp, sizeof(d3dpp));
	d3dpp.BackBufferWidth = WIDTH;
	d3dpp.BackBufferHeight = HEIGHT;
	d3dpp.Windowed = TRUE;
	d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
	d3dpp.BackBufferFormat = D3DFMT_UNKNOWN; //D3DFMT_D24X8

	if(SUCCEEDED(gPD3D->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, ghWnd, D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp, &gPd3dDevice)))
	{
		InitVertex();
	} else { 
		MessageBox(NULL, (LPCTSTR)"CreateDevice fail.", (LPCTSTR)"Erreur :')", MB_OK);
		return E_FAIL; 
	}

	gPd3dDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
	gPd3dDevice->SetRenderState(D3DRS_LIGHTING, FALSE);

	return S_OK;
}

HRESULT InitVertex() 
{
	//int size = 100;
	CUSTOMVERTEX vertices[] = {
        { 0.57f, 0.0f, 0.0f, 0xffC00000, },
        { 0.35f, 0.0f, 0.0f, 0xffC00000, },
        { 0.0f, 1.67f, 0.0f, 0xffC00000, },

	{ -0.57f, 0.0f, 0.0f, 0xffC00000, },
        { -0.35f, 0.0f, 0.0f, 0xffC00000, },
        { 0.0f, 1.67f, 0.0f, 0xffC00000, },

	{ 0.57f, 0.0f, 0.0f, 0xffC00000, },
        { 0.35f, 0.0f, 0.0f, 0xffC00000, },
        { 0.0f, -1.67f, 0.0f, 0xffC00000, },

	{ -0.57f, 0.0f, 0.0f, 0xffC00000, },
        { -0.35f, 0.0f, 0.0f, 0xffC00000, },
        { 0.0f, -1.67f, 0.0f, 0xffC00000, },

	{ 0.01f, -0.01f, 0.0f, 0xffC00000, },
	{ 0.3f, 0.01f, 0.0f, 0xffC00000, },
	{ 0.08f, -0.1f, 0.0f, 0xffC00000, },

	{ 0.01f, -0.01f, 0.0f, 0xffC00000, },
	{ 0.01f, -1.4f, 0.0f, 0xffC00000, },
	{ 0.08f, -0.1f, 0.0f, 0xffC00000, },

	{ -0.01f, -0.01f, 0.0f, 0xffC00000, },
	{ -0.3f, 0.01f, 0.0f, 0xffC00000, },
	{ -0.08f, -0.1f, 0.0f, 0xffC00000, },

	{ -0.01f, -0.01f, 0.0f, 0xffC00000, },
	{ -0.01f, -1.4f, 0.0f, 0xffC00000, },
	{ -0.08f, -0.1f, 0.0f, 0xffC00000, },

	{ 0.0f, 1.72f, 0.0f, 0xffC00000, },
	{ 0.0f, 1.8f, 0.0f, 0xffC00000, },
	{ 0.61f, 0.0f, 0.0f, 0xffC00000, },
	{ 0.66f, 0.0f, 0.0f, 0xffC00000, },

	{ 0.0f, 1.72f, 0.0f, 0xffC00000, },
	{ 0.0f, 1.8f, 0.0f, 0xffC00000, },
	{ -0.61f, 0.0f, 0.0f, 0xffC00000, },
	{ -0.66f, 0.0f, 0.0f, 0xffC00000, },
	
	{ 0.0f, -1.72f, 0.0f, 0xffC00000, },
	{ 0.0f, -1.8f, 0.0f, 0xffC00000, },
	{ 0.61f, 0.0f, 0.0f, 0xffC00000, },
	{ 0.66f, 0.0f, 0.0f, 0xffC00000, },

	{ 0.0f, -1.72f, 0.0f, 0xffC00000, },
	{ 0.0f, -1.8f, 0.0f, 0xffC00000, },
	{ -0.61f, 0.0f, 0.0f, 0xffC00000, },
	{ -0.66f, 0.0f, 0.0f, 0xffC00000, },
	};

	if(FAILED(gPd3dDevice->CreateVertexBuffer((sizeof(vertices)/sizeof(vertices[0]))*sizeof(CUSTOMVERTEX), 0, D3DFVF_CUSTOMVERTEX, D3DPOOL_DEFAULT, &gVertexBuff, NULL ) ) )
	{
		return E_FAIL;
	}

	VOID* pVertices;
	if(FAILED(gVertexBuff->Lock( 0, sizeof(vertices), (void**)&pVertices, 0 ))) {
		return E_FAIL;
	}
	memcpy(pVertices, vertices, sizeof(vertices));
	gVertexBuff->Unlock();

	return S_OK;
}

void SetMatrice() {

	// WORLD
	D3DXMATRIXA16 matWorld;
	UINT  iTime  = timeGetTime() % 5000;
	FLOAT fAngle = iTime * (2.0f * D3DX_PI) / 5000.0f;
	D3DXMatrixRotationY(&matWorld, fAngle);
	gPd3dDevice->SetTransform( D3DTS_WORLD, &matWorld);

	// VIEW/SPEC
	D3DXVECTOR3 vEyePt( 0.0f, 2.0f,-5.0f );
	D3DXVECTOR3 vLookatPt( 0.0f, 0.0f, 0.0f );
	D3DXVECTOR3 vUpVec( 0.0f, 1.0f, 0.0f );
	D3DXMATRIXA16 matView;
	D3DXMatrixLookAtLH( &matView, &vEyePt, &vLookatPt, &vUpVec );
	gPd3dDevice->SetTransform( D3DTS_VIEW, &matView );

	// PROJECTION
	D3DXMATRIXA16 matProj;
	D3DXMatrixPerspectiveFovLH(&matProj, D3DX_PI/4, 1.0f, 1.0f, 100.0f);
	gPd3dDevice->SetTransform( D3DTS_PROJECTION, &matProj );
}

void CleanupDevice() 
{

	if(gVertexBuff) gVertexBuff->Release();
	if(gPd3dDevice) gPd3dDevice->Release();
	if(gPD3D) gPD3D->Release();
}

void Render()
{

	if(NULL == gPd3dDevice) return;
	gPd3dDevice->Clear(0, NULL, D3DCLEAR_TARGET, D3DCOLOR_COLORVALUE(0.0f,0.0f,0.0f,0.0f), 1.0f, 0);

	if(SUCCEEDED(gPd3dDevice->BeginScene()))
	{
		SetMatrice();

		gPd3dDevice->SetStreamSource(0, gVertexBuff, 0, sizeof(CUSTOMVERTEX));
		gPd3dDevice->SetFVF(D3DFVF_CUSTOMVERTEX);
		
		gPd3dDevice->DrawPrimitive(D3DPT_TRIANGLESTRIP, 0, 1);
		gPd3dDevice->DrawPrimitive(D3DPT_TRIANGLESTRIP, 3, 1);
		gPd3dDevice->DrawPrimitive(D3DPT_TRIANGLESTRIP, 6, 1);
		gPd3dDevice->DrawPrimitive(D3DPT_TRIANGLESTRIP, 9, 1);
		
		gPd3dDevice->DrawPrimitive(D3DPT_TRIANGLESTRIP, 12, 1);
		gPd3dDevice->DrawPrimitive(D3DPT_TRIANGLESTRIP, 15, 1);
		gPd3dDevice->DrawPrimitive(D3DPT_TRIANGLESTRIP, 18, 1);
		gPd3dDevice->DrawPrimitive(D3DPT_TRIANGLESTRIP, 21, 1);
		
		gPd3dDevice->DrawPrimitive(D3DPT_TRIANGLESTRIP, 24, 1);
		gPd3dDevice->DrawPrimitive(D3DPT_TRIANGLESTRIP, 25, 1);
		gPd3dDevice->DrawPrimitive(D3DPT_TRIANGLESTRIP, 28, 1);
		gPd3dDevice->DrawPrimitive(D3DPT_TRIANGLESTRIP, 29, 1);
		gPd3dDevice->DrawPrimitive(D3DPT_TRIANGLESTRIP, 32, 1);
		gPd3dDevice->DrawPrimitive(D3DPT_TRIANGLESTRIP, 33, 1);
		gPd3dDevice->DrawPrimitive(D3DPT_TRIANGLESTRIP, 36, 1);
		gPd3dDevice->DrawPrimitive(D3DPT_TRIANGLESTRIP, 37, 1);

		gPd3dDevice->EndScene();
	}

	gPd3dDevice->Present(NULL, NULL, NULL, NULL);
}