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

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

double kut = 0.0;

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

#define SCREEN_WIDTH	800
#define SCREEN_HEIGHT	600
#define XMIN	-10
#define XMAX	10
#define YMIN	-10
#define YMAX	10

// 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 pravac(DWORD boja);
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"D3DXSimetrija",   // 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

	//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
	d3ddev->SetRenderState(D3DRS_CULLMODE, FALSE );
}

// 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->BeginScene();    // zapocni 3D scenu

	// napravi 3D renderiranje na straznjem bufferu


	d3ddev->SetFVF(CUSTOMFVF);

	D3DXMATRIX matrica;
	D3DXMatrixIdentity(&matrica);
	d3ddev->SetTransform(D3DTS_WORLD, &matrica);

	pravac(0xFF0000);
	d3ddev->SetStreamSource(0, v_buffer, 0, sizeof(CUSTOMVERTEX));
	d3ddev->DrawPrimitive(D3DPT_LINESTRIP, 0, 1);

	elipsa(3.0,1.0,50, 0x000000);
	d3ddev->SetStreamSource(0, el_buffer, 0, sizeof(CUSTOMVERTEX));
	d3ddev->DrawPrimitive(D3DPT_LINESTRIP, 0, 50);

	elipsa(3.0,1.0,50, 0x0000FF);

	D3DXMATRIX m, zrcaljenje;
	float kut = atan(-2.0);

	D3DXMatrixIdentity(&zrcaljenje);
	D3DXMatrixTranslation(&m, 0.0, -4.0, 0.0);
	D3DXMatrixMultiply(&zrcaljenje, &zrcaljenje, &m);
	D3DXMatrixRotationZ(&m, -kut );
	D3DXMatrixMultiply(&zrcaljenje, &zrcaljenje, &m);
	D3DXMatrixRotationX(&m, M_PI );
	D3DXMatrixMultiply(&zrcaljenje, &zrcaljenje, &m);
	D3DXMatrixRotationZ(&m, kut );
	D3DXMatrixMultiply(&zrcaljenje, &zrcaljenje, &m);
	D3DXMatrixTranslation(&m, 0.0, 4.0, 0.0);
	D3DXMatrixMultiply(&zrcaljenje, &zrcaljenje, &m);

	d3ddev->SetTransform(D3DTS_WORLD, &zrcaljenje);
	d3ddev->SetStreamSource(0, el_buffer, 0, sizeof(CUSTOMVERTEX));
	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 pravac(DWORD boja){

	CUSTOMVERTEX vertices[] = {
		{XMIN, -2*XMIN+4, 0.0, boja},
		{XMAX, -2*XMAX+4, 0.0, boja}
	};

	d3ddev->CreateVertexBuffer(2*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
	float xrange, yrange;
	// Calculate The Aspect Ratio Of The Window

	xrange = XMAX - XMIN;
	yrange = height*xrange/width;

	D3DXMatrixOrthoOffCenterLH(&matProjection, XMIN, XMAX, -yrange/2, yrange/2, -20.0, 20.0 );

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