// 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 r = 2.0;
float 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 kruznicu
LPDIRECT3DVERTEXBUFFER9 pl_buffer = NULL; //vertex buffer za plast

#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 kruznica(float r, int n, DWORD boja);
void plast(float r, 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"D3DXStozacOs",   // 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(0, 0, 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_LINELIST, 0, 1);


	float n = sqrt(pow(r,2)+pow(3*r,2));
	float a = r/n;
	float b = (4*r)/n;

	float d = sqrt(b*b);

	float alpha = asin(b/d);
	float beta = asin(a);

	D3DXMATRIX t1,t2,rx1,rx2, ry1, ry2, z;
	D3DXMatrixTranslation(&t1, -r, 0, 0 );
	D3DXMatrixRotationX(&rx1, -alpha);
	D3DXMatrixRotationY(&ry1, beta );
	D3DXMatrixRotationZ(&z, D3DXToRadian(kut));
	D3DXMatrixRotationX(&rx2, alpha);
	D3DXMatrixRotationY(&ry2,  -beta );
	D3DXMatrixTranslation(&t2, r, 0, 0 );

	kruznica(r,50,0xFFFF00);
	d3ddev->SetTransform(D3DTS_WORLD, &(t2*rx2*ry2*z*ry1*rx1*t1));
	d3ddev->SetStreamSource(0, el_buffer, 0, sizeof(CUSTOMVERTEX));
	d3ddev->DrawPrimitive(D3DPT_LINESTRIP, 0, 50);

	plast(r,32,0xFFFF00);
	d3ddev->SetStreamSource(0, pl_buffer, 0, sizeof(CUSTOMVERTEX));
	d3ddev->DrawPrimitive(D3DPT_LINELIST, 0, 32);

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

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

	kut++;
	if( kut == 360.0 )
		kut = 0.0;
}

// 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, 3*XMIN+3*r, 0.0, boja},
		{XMAX, 3*XMAX+3*r, 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 kruznica(float r, 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 = r*cos(t);
		vertices[i].Y = 0.0;
		vertices[i].Z = r*sin(t);
		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
}

void plast(float r, int n, DWORD boja ){
		CUSTOMVERTEX *vertices = new CUSTOMVERTEX[2*n];

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

	for( int i = 0; i < n; i++ ){
		
		vertices[2*i].X = 0.0;
		vertices[2*i].Y = 3*r;
		vertices[2*i].Z = 0.0;
		vertices[2*i].COLOR = boja;

		vertices[2*i+1].X = r*cos(t);
		vertices[2*i+1].Y = 0.0;
		vertices[2*i+1].Z = r*sin(t);
		vertices[2*i+1].COLOR = boja;
		t += korak;
	}

	d3ddev->CreateVertexBuffer(2*n*sizeof(CUSTOMVERTEX),
		0,
		CUSTOMFVF,
		D3DPOOL_MANAGED,
		&pl_buffer,
		NULL);

	VOID* pVoid;

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