// D3D Function prototypes

#include "includes.h"

IDirect3D8 * lpD3D = NULL;
IDirect3DDevice8 * lpD3DDevice = NULL;
IDirect3DVertexBuffer8 * lpD3DVB = NULL;
D3DDISPLAYMODE D3DDM;
D3DPRESENT_PARAMETERS D3DPP;

typedef struct{

	FLOAT x, y, z;
	D3DCOLOR diffuse;
       
} sVertex;


int initD3D(){


	// vertex information


	sVertex Verts[4] = {
		{-100.0f, 100.0f, 100.0f, D3DCOLOR_RGBA(255, 255, 255, 255)},
		{100.0f, 100.0f, 100.0f, D3DCOLOR_RGBA(255, 0, 0, 255)},
		{100.0f, -100.0f, 100.0f, D3DCOLOR_RGBA(0, 255, 0, 255)},
		{-100.0f, -100.0f, 100.0f, D3DCOLOR_RGBA(0, 0, 255, 255)},
	};

	// create the D3D object

	if((lpD3D = Direct3DCreate8(D3D_SDK_VERSION)) == NULL){
		
		fError("Failed on Direct3DCreate8(D3D_SDK_VERSION))");
		return 0;
	}


	ZeroMemory(&D3DPP, sizeof(D3DPRESENT_PARAMETERS));


	if(screenStatus == SS_FULL){		
		
		D3DDM.Width	        = SWIDTH;				// fullscreen width

		D3DDM.Height        = SHEIGHT;				// fullscreen height

		D3DDM.RefreshRate	= SRFR;					// fullscreen refresh rate

		D3DDM.Format		= SCF;					// fullscreen color format

	
		D3DPP.Windowed		= FALSE;				// not in windowed mode

		D3DPP.SwapEffect	= D3DSWAPEFFECT_FLIP;	// flip the back buffer

		D3DPP.FullScreen_RefreshRateInHz = D3DPRESENT_RATE_DEFAULT;				// default refresh rate

		D3DPP.FullScreen_PresentationInterval = D3DPRESENT_INTERVAL_DEFAULT;	// default refresh interval

		D3DPP.BackBufferFormat = D3DDM.Format;		// use color format from D3DDM

		D3DPP.BackBufferWidth  = D3DDM.Width;
		D3DPP.BackBufferHeight = D3DDM.Height;

		
	}else{

		// get current display info

		if(FAILED(lpD3D->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &D3DDM))){ 

			fError("Failed on lpD3D->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &D3DDM)");
			return 0;
		}

		D3DPP.Windowed = TRUE;						// in windowed mode

		D3DPP.SwapEffect = D3DSWAPEFFECT_DISCARD;	
		D3DPP.BackBufferFormat = D3DDM.Format;		// use color format from D3DDM

	}
		

	// create the D3D device

	if(FAILED(lpD3D->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, gHwnd, D3DCREATE_SOFTWARE_VERTEXPROCESSING, &D3DPP, &lpD3DDevice))){

		fError("Failed on lpD3D->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, gHwnd, D3DCREATE_SOFTWARE_VERTEXPROCESSING, &D3DPP, &lpD3DDevice)");
		return 0;
	}


	
	// create the Vertex Buffer

	if(FAILED(lpD3DDevice->CreateVertexBuffer(sizeof(sVertex) * 4, 0, VertexFVF, D3DPOOL_DEFAULT, &lpD3DVB))){

		fError("Failed on lpD3DDevice->CreateVertexBuffer(sizeof(sVertex) * 4, 0, VertexFVF, D3DPOOL_MANAGED, &lpD3DVB)");
		return 0;
	}

	BYTE * Ptr;

	// lock the vertex buffer

	if(SUCCEEDED(lpD3DVB->Lock(0, 0, (BYTE**)&Ptr, 0))){
		
		// copy vertex data over

		memcpy(Ptr, Verts, sizeof(Verts));
		

		// unlock the vertex buffer

		lpD3DVB->Unlock();

	}else{

		fError("Failed on lpD3DVB->Lock(0, 0, (BYTE**)&Ptr, 0)");
		return 0;
	}

	return 1;
}

int mainD3D(){
	
	lpD3DDevice->Clear(0, NULL, D3DCLEAR_TARGET, D3DCOLOR_RGBA(0, 0, 0, 255), 1.0f, 0);

	if(SUCCEEDED(lpD3DDevice->BeginScene())){

		// set the vertex stream and shader

		if(FAILED(lpD3DDevice->SetStreamSource(0, lpD3DVB, sizeof(sVertex)))){
			 
			fError("Failed on lpD3DDevice->SetStreamSource(0, lpD3DVB, sizeof(sVertex))");
			return 0;
		}

		if(FAILED(lpD3DDevice->SetVertexShader(VertexFVF))){

			fError("Failed on lpD3DDevice->SetVertexShader(VertexFVF))");
			return 0;
		}

		if(FAILED(lpD3DDevice->DrawPrimitive(D3DPT_TRIANGLEFAN, 0, 2))){

			fError("Failed on lpD3DDevice->DrawPrimitive(D3DPT_TRIANGLELIST, 0, 2)");
			return 0;
		}
		
		lpD3DDevice->EndScene();

	}

	lpD3DDevice->Present(NULL, NULL, NULL, NULL);

	return 1;
}


int releaseD3D(){

	if(lpD3DVB != NULL){

		lpD3DVB->Release();
		lpD3DVB = NULL;
	}

	if(lpD3DDevice != NULL){
		
		lpD3DDevice->Release();
		lpD3DDevice = NULL;
	}

	if(lpD3D != NULL){
		
		lpD3D->Release();
		lpD3D = NULL;
	}

	return 1;
}