// ukljuci headere za windows API
#include <windows.h>
#include <windowsx.h>
#define _USE_MATH_DEFINES
#include <cmath>
#include <d3d9.h>
#include <d3dx9.h>


// ukljuci Direct3D library
#pragma comment (lib, "d3d9.lib")
#pragma comment (lib, "d3dx9.lib")


// globalne deklaracije
LPDIRECT3D9 d3d;    // pointer na D3D9 sucelje
LPDIRECT3DDEVICE9 d3ddev;    // pointer na klasu uredjaja
LPDIRECT3DVERTEXBUFFER9 v_buffer = NULL; //vertex buffer za osi
LPDIRECT3DVERTEXBUFFER9 el_buffer = NULL; //vertex buffer za elipsu

#define SCREEN_WIDTH	800
#define SCREEN_HEIGHT	600

// prototipi funkcija
void initD3D(HWND hWnd);    // inicijaliziraj D3D9
void render_frame(void);    // renderiraj frame
void cleanD3D(void);    // zatvori Direct3D i otpusti resurse
void resizeD3DScene(int width, int height);

void koordinatne_osi();
void elipsa(float a, float b, int n, DWORD boja);

struct CUSTOMVERTEX {FLOAT X, Y, Z; DWORD COLOR;};

#define CUSTOMFVF (D3DFVF_XYZ | D3DFVF_DIFFUSE)

// prototip funkcija WindowProc za obradu poruka
LRESULT CALLBACK WindowProc(HWND hWnd,
	UINT message,
	WPARAM wParam,
	LPARAM lParam);

// pocetak glavnog programa
int WINAPI WinMain(HINSTANCE hInstance,
	HINSTANCE hPrevInstance,
	LPSTR lpCmdLine,
	int nCmdShow)
{
	// handle za prozor
	HWND hWnd;
	// struktura koja sadrzi opis novog prozora
	WNDCLASSEX wc;

	// resetiraj podatke u wc
	ZeroMemory(&wc, sizeof(WNDCLASSEX));

	// popuni opis prozora
	wc.cbSize = sizeof(WNDCLASSEX);
	wc.style = CS_HREDRAW | CS_VREDRAW;
	wc.lpfnWndProc = WindowProc;
	wc.hInstance = hInstance;
	wc.hCursor = LoadCursor(NULL, IDC_ARROW);
	wc.hbrBackground = (HBRUSH)COLOR_WINDOW;
	wc.lpszClassName = L"WindowClass1";

	// registriraj klasu prozora
	RegisterClassEx(&wc);

	// kreiranje prozora
	hWnd = CreateWindowEx(NULL,
		L"WindowClass1",    // naziv klase
		L"D3DElipse",   // naslov na prozoru
		WS_OVERLAPPEDWINDOW,    // stil prozora (ispred svih)
		100,    // x-pozicija
		100,    // y-pozicija
		SCREEN_WIDTH,    // duljina prozora
		SCREEN_HEIGHT,    // visina prozora
		NULL,    // nema prozora roditelja, NULL
		NULL,    // ne koristi se izbornik, NULL
		hInstance,    // handle za aplikaciju
		NULL);    // ne koristi se s vise prozora, NULL

	// prikazi prozor na ekranu
	ShowWindow(hWnd, nCmdShow);


	// kreni u glavnu petlju:

	// struktura koja sadrzi podatke o poruci
	MSG msg;

	initD3D(hWnd);
	resizeD3DScene(SCREEN_WIDTH, SCREEN_HEIGHT);

	while(TRUE)
	{
		// provjeri postoji li poruku u redu cekaja
		while(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
		{
			// prevedi poruku i posalji je na obradu WindowProc()
			TranslateMessage(&msg);
			DispatchMessage(&msg);
		}

		// ako je poruka WM_QUIT, izadji iz petlje
		if(msg.message == WM_QUIT)
			break;

		// Ovdje se izvrsava Direct3D kod
		render_frame();
	}

	cleanD3D();

	// vrati poruku o izlazu WM_QUIT windowsima
	return msg.wParam;
}

// funkcija koja je glavni upravitelj porukama u programu
LRESULT CALLBACK WindowProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	// saznaj o kakvoj se poruci radi
	switch(message)
	{
		// ako je prozor zatvoren
	case WM_DESTROY:
		{
			// zatvori aplikaciju
			PostQuitMessage(0);
			return 0;
		} break;
	case WM_SIZE:		// Resize The Direct3D Window
		{
			// LoWord=Width, HiWord=Height
			resizeD3DScene(LOWORD(lParam), HIWORD(lParam));
			return 0;			// Jump Back
		}
	}

	// upravljanje sistemskim porukama koje switch nije obradio
	return DefWindowProc (hWnd, message, wParam, lParam);
}

// funkcija inicijalizira i priprema Direct3D za koristenje
void initD3D(HWND hWnd)
{
	d3d = Direct3DCreate9(D3D_SDK_VERSION);    // kreira Direct3D sucelje

	D3DPRESENT_PARAMETERS d3dpp;    // kreira strukturu koja sadrzi podatke o grafickoj

	ZeroMemory(&d3dpp, sizeof(d3dpp));    // obrisi strukturu
	d3dpp.Windowed = TRUE;    // program je u prozoru, nije fullscreen
	d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;    // odbaci stare frameove
	d3dpp.hDeviceWindow = hWnd;    // postavi da prozor koristi Direct3D
	d3dpp.EnableAutoDepthStencil = TRUE;    // automatically run the z-buffer for us
	d3dpp.AutoDepthStencilFormat = D3DFMT_D16;    // 16-bit pixel format for the z-buffer

	//kreiraj D3D9 uredjaj orema parametrima u strukturi
	d3d->CreateDevice(D3DADAPTER_DEFAULT,
		D3DDEVTYPE_HAL,
		hWnd,
		D3DCREATE_SOFTWARE_VERTEXPROCESSING,
		&d3dpp,
		&d3ddev);


	d3ddev->SetRenderState(D3DRS_LIGHTING, FALSE);    // turn off the 3D lighting
}

// funkcija koja rendreira jedan frame (OpenGL iscrtaj!)
void render_frame(void)
{
	// obrisi prozor i stavi plavu pozadinu
	d3ddev->Clear(0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(255, 255, 0), 1.0f, 0);
	d3ddev->Clear(0, NULL, D3DCLEAR_ZBUFFER, D3DCOLOR_XRGB(0, 0, 0), 1.0f, 0);


	d3ddev->BeginScene();    // zapocni 3D scenu

	// napravi 3D renderiranje na straznjem bufferu


	d3ddev->SetFVF(CUSTOMFVF);

	D3DXMATRIX matrica;
	D3DXMatrixIdentity(&matrica);

	koordinatne_osi();
	d3ddev->SetStreamSource(0, v_buffer, 0, sizeof(CUSTOMVERTEX));
	d3ddev->SetTransform(D3DTS_WORLD, &matrica );
	d3ddev->DrawPrimitive(D3DPT_LINELIST, 0, 2);

	D3DXMATRIX rotacija;
	D3DXMATRIX translacija;

	D3DXMatrixRotationZ( &rotacija, D3DXToRadian(-30.0f));
	D3DXMatrixTranslation( &translacija, 4.0, 0.0, 0.0 );

	elipsa(6,3,50,0xFF0000);
	d3ddev->SetStreamSource(0, el_buffer, 0, sizeof(CUSTOMVERTEX));
	d3ddev->SetTransform(D3DTS_WORLD, &(rotacija*translacija));
	d3ddev->DrawPrimitive(D3DPT_LINESTRIP, 0, 50);

	elipsa(6,3,50,0x0000FF);
	d3ddev->SetStreamSource(0, el_buffer, 0, sizeof(CUSTOMVERTEX));
	d3ddev->SetTransform(D3DTS_WORLD, &(translacija*rotacija));
	d3ddev->DrawPrimitive(D3DPT_LINESTRIP, 0, 50);

	elipsa(4,1,50,0x00FF00);
	D3DXMatrixRotationZ( &rotacija, D3DXToRadian(75.0f));
	D3DXMATRIX zrcaljenjeY;
	D3DXMatrixRotationY(&zrcaljenjeY,D3DXToRadian(180.0f));
	D3DXMatrixTranslation(&translacija,3.0,0.0,0.0);
	d3ddev->SetStreamSource(0, el_buffer, 0, sizeof(CUSTOMVERTEX));
	d3ddev->SetTransform(D3DTS_WORLD, &(rotacija*translacija*zrcaljenjeY));
	d3ddev->DrawPrimitive(D3DPT_LINESTRIP, 0, 50);

	d3ddev->EndScene();    // zavrsi 3D scenu

	d3ddev->Present(NULL, NULL, NULL, NULL);    // prikazi frame

}

// funkcija brise Direct3D i COM
void cleanD3D(void)
{
	d3ddev->Release();    // zatvori i otpusti 3D uredjaj
	d3d->Release();    // zatvori i otpusti Direct3D
}

void koordinatne_osi(void){

	CUSTOMVERTEX vertices[] = {
		{-10.0, 0.0, 0.0, D3DCOLOR_XRGB(0,0,0)},
		{10.0, 0.0, 0.0, D3DCOLOR_XRGB(0,0,0)},
		{0.0, -10.0, 0.0, D3DCOLOR_XRGB(0,0,0)},
		{0.0, 10.0, 0.0, D3DCOLOR_XRGB(0,0,0)}
	};

	d3ddev->CreateVertexBuffer(4*sizeof(CUSTOMVERTEX),
		0,
		CUSTOMFVF,
		D3DPOOL_MANAGED,
		&v_buffer,
		NULL);

	VOID* pVoid;

	v_buffer->Lock(0,0,(void**)&pVoid, 0 );
	memcpy(pVoid, vertices, sizeof(vertices));
	v_buffer->Unlock();
}

void elipsa(float a, float b, int n, DWORD boja){

	CUSTOMVERTEX *vertices = new CUSTOMVERTEX[n+1];

	float korak = 2*M_PI/n;
	float t = 0.0;

	for( int i = 0; i <= n; i++ ){
		vertices[i].X = a*cos(t);
		vertices[i].Y = b*sin(t);
		vertices[i].Z = 0.0;
		vertices[i].COLOR = boja;

		t += korak;
	}

	d3ddev->CreateVertexBuffer((n+1)*sizeof(CUSTOMVERTEX),
		0,
		CUSTOMFVF,
		D3DPOOL_MANAGED,
		&el_buffer,
		NULL);

	VOID* pVoid;

	el_buffer->Lock(0,0,(void**)&pVoid, 0 );
	memcpy(pVoid, vertices, (n+1)*sizeof(CUSTOMVERTEX));
	el_buffer->Unlock();
}

void resizeD3DScene(int width, int height)
{
	D3DXMATRIX matProjection;		// Create A Projection Matrix

	// Calculate The Aspect Ratio Of The Window
	D3DXMatrixOrthoOffCenterLH(&matProjection, -10.0, 10.0, -10.0, 10.0, 0.0, 10.0 );

	d3ddev->SetTransform( D3DTS_PROJECTION, &matProjection );
	D3DXMatrixIdentity(&matProjection);	// Reset The Projection Matrix
}