#include <GL\glew.h>
#include<GLFW\glfw3.h>
#include<GL\glut.h>

#include<iostream>
#include <stdio.h>
#include <vector>

void Rocket();
float cx = 0, cz = 0;
float yy = 0.00f, cy = 0.00f;
int d;
float time1 = 0, time;



enum
{
	FULL_WINDOW, // aspekt obrazu - całe okno
	ASPECT_1_1, // aspekt obrazu 1:1
	EXIT // wyjście
};

// aspekt obrazu

int aspect = FULL_WINDOW;

// usunięcie definicji makr near i far

#ifdef near
#undef near
#endif
#ifdef far
#undef far
#endif

// rozmiary bryły obcinania

const GLdouble left = -2.0;
const GLdouble right = 2.0;
const GLdouble bottom = -2.0;
const GLdouble top = 2.0;
const GLdouble near = 3.0;
const GLdouble far = 7.0;

// kąty obrotu

GLfloat rotatex = 0.0;
GLfloat rotatey = 0.0;
GLfloat movex = 0.0;
GLfloat movez = 0.0;


// wskaźnik naciśnięcia lewego przycisku myszki

int button_state = GLUT_UP;
//glTranslatef(5.0, 0.0, 0.0);

// położenie kursora myszki

int button_x, button_y;

// współczynnik skalowania

GLfloat scale = 0.3;
//szybkosc poruszania sie
int speed = 100;

// współrzędne wektorów normalnych i wierzchołków

GLfloat normal_vertex[34 * 6] =
{
	0,0,0,0,0,0, //v0
	-1, 0, 0,-1, 0, 0, // v1
	-0.7071, 0, -0.7071, -0.7071, 0, -0.7071, // v2
	0.000, 0, -1,  0.000, 0, -1, // v3
	0.7071, 0,-0.7071, 0.7071, 0, -0.7071, // v4
	1, 0, 0, 1, 0, 0, // v5
	0.7071, 0, 0.7071, 0.7071, 0, 0.7071, // v6
	0, 0, 1, 0, 0, 1, // v7
	-0.7071, 0, 0.7071, -0.7071, 0, 0.7071, // v8


	0,22,0,0,22,0, //v9
	-1, 20, 0,-1, 20, 0, // v10
	-0.7071, 20, -0.7071, -0.7071, 20, -0.7071, // v11
	0.000, 20, -1,  0.000, 20, -1, // v12
	0.7071, 20,-0.7071, 0.7071, 20, -0.7071, // v13
	1, 20, 0, 1, 20, 0, // v14
	0.7071, 20, 0.7071, 0.7071, 20, 0.7071, // v15
	0, 20, 1, 0, 20, 1, // v16
	-0.7071, 20, 0.7071, -0.7071, 20, 0.7071, // v17

	-2.5, -2.5, 0,-2.5, -2.5, 0, // v18
	0,-2.5,-2.5, 0,-2.5,-2.5,  //19
	2.5, -2.5, 0, 2.5, -2.5, 0, // v20
	0,-2.5,2.5, 0,-2.5,2.5,    //21
	-1, 5, 0,-1, 5, 0,     //22
	0, 5, -1,  0, 5, -1,    //23
	1, 5, 0, 1, 5, 0,       //24
	0, 5, 1, 0, 5, 1,       //25

	-2, 8, 0,-2, 8, 0, // v26
	0,8,-2, 0,8,-2,  //27
	2, 8, 0, 2, 8, 0, // v28
	0,8,2, 0,8,2,    //29
	-1, 12, 0,-1, 12, 0,     //30
	0, 12, -1,  0, 12, -1,    //31
	1, 12, 0, 1, 12, 0,       //32
	0, 12, 1, 0, 12, 1,       //33


};
GLfloat normal_vertex1[15 * 3]
{

};

// składowe kolorów wierzchołków

GLfloat color[34 * 3] =
{
	0.5, 0.5, 0.5, // v0
	0.5, 0.5, 0.5, // v1
	0.5, 0.5, 0.5, // v2
	0.5, 0.5, 0.5, // v3
	0.5, 0.5, 0.5, // v4
	0.5, 0.5, 0.5,// v5
	0.5, 0.5, 0.5, // v6
	0.5, 0.5, 0.5, // v7
	0.5, 0.5, 0.5, // v8
	0.5, 0.5, 0.5, // v9
	0.5, 0.5, 0.5, // v10
	0.5, 0.5, 0.5, // v11
	0.5, 0.5, 0.5, // v12
	0.5, 0.5, 0.5, // v13
	0.5, 0.5, 0.5,// v14
	0.5, 0.5, 0.5, // v15
	0.5, 0.5, 0.5, // v16
	0.5, 0.5, 0.5, // v17
	0.5, 0.5, 0.5,// v14
	0.5, 0.5, 0.5, // v15
	0.5, 0.5, 0.5, // v16

	0.5, 0.5, 0.5, // v17
	0.5, 0.5, 0.5,// v14
	0.5, 0.5, 0.5, // v15
	0.5, 0.5, 0.5, // v16
	0.5, 0.5, 0.5, // v17

	0.5, 0.5, 0.5, // v17
	0.5, 0.5, 0.5,// v14
	0.5, 0.5, 0.5, // v15
	0.5, 0.5, 0.5, // v16
	0.5, 0.5, 0.5, // v17
	0.5, 0.5, 0.5, // v15
	0.5, 0.5, 0.5, // v16
	0.5, 0.5, 0.5, // v17


};


GLubyte triangles[51 * 3] =
{

	0,1,2,
	0,2,3,
	0,3,4,
	0,4,5,
	0,5,6,
	0,6,7,
	0,7,8,
	0,8,1,
	9,10,11,
	9,11,12,

	9,12,13,
	9,13,14,
	9,14,15,
	9,15,16,
	9,16,17,
	9,17,10,
	1,10,11,
	1,2,11,
	2,11,12,
	2,3,12,

	3,12,13,
	3,4,13,
	4,13,14,
	4,5,14,
	5,14,15,
	5,6,15,
	6,15,16,
	6,7,16,
	7,16,17,
	7,8,17,

	1,8,17,
	1,10,17,
	1,18,22,
	3,19,23,
	5,20,24,
	7,21,25,
	10,26,30,
	12,27,31,
	14,28,32,
	16,29,33,
};

// funkcja generująca scenę 3D
void RenderSineWave()
{
	float i;
	float x, y, z;


	glPointSize(10);
	glColor3f(1.0, 1.0, 1.0);


	for (i = 0; i < 3.61; i = i + 0.5)
	{
		z = 0;
		x = (float)i;
		y = 10.0 * sin(i *(6.284 / 360.0));
		glBegin(GL_POINTS);
		glVertex3f(x, y, z);
		glEnd();
		glFlush();
		glutPostRedisplay();
	}

}

void Display()
{
	// kolor tła - zawartość bufora koloru
	glClearColor(0.0, 0.0, 0.5, 1);

	// czyszczenie bufora koloru i bufora głębokości
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	//tworzymy mini powierzchnie
	glPushMatrix();
	glColor3f(1.0, 1.0, 1.0);
	glBegin(GL_LINES);
	for (GLfloat i = -1000; i <= 1000; i += 0.25) {
		glVertex3f(i, 0, 2.5); glVertex3f(i, 0, -2.5);
		glVertex3f(2.5, 0, i); glVertex3f(-2.5, 0, i);
	}
	glEnd();
	glPopMatrix();
	// wybór macierzy modelowania
	glMatrixMode(GL_MODELVIEW);



	// macierz modelowania = macierz jednostkowa
	glLoadIdentity();

	// przesunięcie układu współrzędnych obiektu do środka bryły odcinania
	glTranslatef(0, 0, -(near + far) / 2);

	// obroty obiektu
	glRotatef(rotatex, 1.0, 0.0, 0.0);
	glRotatef(rotatey, 0.0, 1.0, 0.0);
	//ruszanie sie
	//glTranslatef(cx, cy, cz);
	// skalowanie obiektu - klawisze "+" i "-"
	glScalef(scale, scale, scale);

	// włączenie testu bufora głębokości
	glEnable(GL_DEPTH_TEST);

	// włączenie oświetlenia
	glEnable(GL_LIGHTING);

	// włączenie światła GL_LIGHT0 z parametrami domyślnymi
	glEnable(GL_LIGHT0);

	// włączenie automatycznej normalizacji wektorów normalnych
	glEnable(GL_NORMALIZE);

	// włączenie obsługi właściwości materiałów
	glEnable(GL_COLOR_MATERIAL);

	// utworzenie danych o wektorach normalnych i współrzędnych wierzchołków
	glInterleavedArrays(GL_N3F_V3F, 0, normal_vertex);

	// włączenie tablicy z danymi o kolorach wierzchołków
	glEnableClientState(GL_COLOR_ARRAY);
	glColorPointer(3, GL_FLOAT, 0, color);

	// narysowanie tablic wierzchołków - wybór funkcji zależy
	// od dostępnoścglPushMatrix();

	Rocket();


	// skierowanie poleceń do wykonania
	glFlush();

	// zamiana buforów koloru
	glutSwapBuffers();

}
void Rocket()
{
	glPushMatrix();

	//glTranslatef(5 * sin(cx), 5 * sin(cy), sin(cz));
	glTranslatef(cx, cy, cz);
	glRotatef(movex, 0.0, 0.0, 1.0);

	if (GLUT_KEY_LEFT)
	{
		glTranslatef(0, 0.0, 0.0);
	}
	glFlush();
	if (glDrawRangeElementsEXT == NULL)
		glDrawElements(GL_TRIANGLES, 51 * 3, GL_UNSIGNED_BYTE, triangles);

	else
		glDrawRangeElementsEXT(GL_TRIANGLES, 0, 34, 51 * 3, GL_UNSIGNED_BYTE, triangles);
	if (GLUT_KEY_LEFT)
	{
		glTranslatef(0, 0.0, 0.0);
	}
	//glTranslatef(cx, cy, cz);

	glPopMatrix();
}
// zmiana wielkości okna
void update(void)

{
	d += 1;
	std::cout << d;
}
void Reshape(int width, int height)
{
	// obszar renderingu - całe okno
	glViewport(0, 0, width, height);

	// wybór macierzy rzutowania
	glMatrixMode(GL_PROJECTION);

	// macierz rzutowania = macierz jednostkowa
	glLoadIdentity();

	// parametry bryły obcinania
	if (aspect == ASPECT_1_1)
	{
		// wysokość okna większa od wysokości okna
		if (width < height && width > 0)
			glFrustum(left, right, bottom * height / width, top * height / width, near, far);
		else

			// szerokość okna większa lub równa wysokości okna
			if (width >= height && height > 0)
				glFrustum(left * width / height, right * width / height, bottom, top, near, far);

	}
	else
		glFrustum(left, right, bottom, top, near, far);

	// generowanie sceny 3D
	Display();




	//update();

}

// obsługa klawiatury

void Keyboard(unsigned char key, int x, int y)
{
	//przesuwamy scena
	if (key == 's') { cy -= 1; }
	if (key == 'd') { movex += 1; }
	//if (key == 'q') { cy += 1; }
	if (key == 'w') { cy += 1; }
	if (key == 'a') { movex -= 1; }
	//if (key == 'z') { cy -= 1; }
	// klawisz +
	if (key == '+')
		scale += 0.05;

	// klawisz -
	if (key == '-' && scale > 0.05)
		scale -= 0.05;

	if (key == ' ') {
		yy += 0.0314;
		cy = 30 * sin(yy);
		std::cout << yy << cy;

		cx = 50 * sin(yy / 2);


		movex = 180 * sin(-yy / 2);

	}
	// narysowanie sceny
	Display();
	glutPostRedisplay();
}

// obsługa klawiszy funkcyjnych i klawiszy kursora

void SpecialKeys(int key, int x, int y)
{

	switch (key)
	{
		// kursor w lewo
	case GLUT_KEY_LEFT:

		cx -= 1;
		//Rocket();
		//glRotatef(31.0, 0.0, 1.0, 0.0);
		break;

		// kursor w górę
	case GLUT_KEY_UP:

		cz += 1;
		//rotatex -= 1;
		//std::cout << "Time:" << time;
		break;

		// kursor w prawo
	case GLUT_KEY_RIGHT:

		cx += 1;
		//rotatey += 1;
		break;

		// kursor w dół
	case GLUT_KEY_DOWN:

		cz -= 1;
		//rotatex += 1;
		//glTranslatef(key, x, y);
		//glRotatef(180.0,0.0,1.0,1.0);
		break;


	}

	// odrysowanie okna
	Reshape(glutGet(GLUT_WINDOW_WIDTH), glutGet(GLUT_WINDOW_HEIGHT));
}

// obsługa przycisków myszki

void MouseButton(int button, int state, int x, int y)
{
	if (button == GLUT_LEFT_BUTTON)
	{
		// zapamiętanie stanu lewego przycisku myszki
		button_state = state;

		// zapamiętanie położenia kursora myszki
		if (state == GLUT_DOWN)
		{
			button_x = x;
			button_y = y;

		}
	}
}

// obsługa ruchu kursora myszki

void MouseMotion(int x, int y)
{

	if (button_state == GLUT_DOWN)
	{
		rotatey += 30 * (right - left) / glutGet(GLUT_WINDOW_WIDTH) *(x - button_x);
		button_x = x;
		rotatex -= 30 * (top - bottom) / glutGet(GLUT_WINDOW_HEIGHT) *(button_y - y);
		button_y = y;
		glutPostRedisplay();
	}

}

// obsługa menu podręcznego

void Menu(int value)
{
	switch (value)
	{
		// obszar renderingu - całe okno
	case FULL_WINDOW:
		aspect = FULL_WINDOW;
		Reshape(glutGet(GLUT_WINDOW_WIDTH), glutGet(GLUT_WINDOW_HEIGHT));
		break;

		// obszar renderingu - aspekt 1:1
	case ASPECT_1_1:
		aspect = ASPECT_1_1;
		Reshape(glutGet(GLUT_WINDOW_WIDTH), glutGet(GLUT_WINDOW_HEIGHT));
		break;

		// wyjście
	case EXIT:
		exit(0);
	}
}

// sprawdzenie i przygotowanie obsługi wybranych rozszerzeń

void ExtensionSetup()
{
	// pobranie numeru wersji biblioteki OpenGL
	const char * version = (char *)glGetString(GL_VERSION);

	// odczyt wersji OpenGL
	int major = 0, minor = 0;
	if (sscanf_s(version, "%d.%d", &major, &minor) != 2)
	{
#ifdef WIN32
		printf("Błędny format wersji OpenGL\n");
#else

		printf("Bledny format wersji OpenGL\n");
#endif

		exit(0);
	}

	// sprawdzenie czy jest co najmniej wersja 1.2
	if (major > 1 || minor >= 2)
	{
		// pobranie wskaźników wybranych funkcji OpenGL 1.2
		glDrawRangeElementsEXT =
			(PFNGLDRAWRANGEELEMENTSEXTPROC)wglGetProcAddress("glDrawRangeElements");
	}
	else

		// sprawdzenie czy jest obsługiwane rozszerzenie EXT_draw_range_elements
		if (glutExtensionSupported("GL_EXT_draw_range_elements"))
		{
			// pobranie wskaźników wybranych funkcji rozszerzenia EXT_draw_range_elements
			glDrawRangeElementsEXT =
				(PFNGLDRAWRANGEELEMENTSEXTPROC)wglGetProcAddress("glDrawRangeElementsEXT");
		}
		else
		{
			printf("Brak rozszerzenia EXT_draw_range_elements!\n");
			glDrawRangeElementsEXT = NULL;
		}
}

int main(int argc, char * argv[])
{

	time = GetTickCount();
	int delta = time - time1;
	time1 = time;
	std::cout << "Time:" << time;
	int yt = sin(delta * speed);
	// inicjalizacja biblioteki GLUT
	glutInit(&argc, argv);

	// inicjalizacja bufora ramki
	glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);

	// rozmiary głównego okna programu
	glutInitWindowSize(500, 500);

	// utworzenie głównego okna programu
#ifdef WIN32

	glutCreateWindow("Rakieta");
#else

	glutCreateWindow("Rakieta");
#endif

	// dołączenie funkcji generującej scenę 3D
	glutDisplayFunc(Display);

	// dołączenie funkcji wywoływanej przy zmianie rozmiaru okna
	glutReshapeFunc(Reshape);

	// dołączenie funkcji obsługi klawiatury
	glutKeyboardFunc(Keyboard);

	// dołączenie funkcji obsługi klawiszy funkcyjnych i klawiszy kursora
	glutSpecialFunc(SpecialKeys);

	// obsługa przycisków myszki
	glutMouseFunc(MouseButton);

	// obsługa ruchu kursora myszki
	glutMotionFunc(MouseMotion);


	// utworzenie menu podręcznego
	glutCreateMenu(Menu);



	// utworzenie podmenu - aspekt obrazu
	int MenuAspect = glutCreateMenu(Menu);
#ifdef WIN32

	glutAddMenuEntry("Aspekt obrazu - całe okno", FULL_WINDOW);
#else

	glutAddMenuEntry("Aspekt obrazu - cale okno", FULL_WINDOW);
#endif

	glutAddMenuEntry("Aspekt obrazu 1:1", ASPECT_1_1);

	// menu główne
	glutCreateMenu(Menu);
	glutAddSubMenu("Aspekt obrazu", MenuAspect);
#ifdef WIN32

	glutAddMenuEntry("Wyjście", EXIT);
#else

	glutAddMenuEntry("Wyjscie", EXIT);
#endif

	// określenie przycisku myszki obsługującej menu podręczne
	glutAttachMenu(GLUT_RIGHT_BUTTON);

	// sprawdzenie i przygotowanie obsługi wybranych rozszerzeń

	ExtensionSetup();


	// wprowadzenie programu do obsługi pętli komunikatów
	glutMainLoop();

	return 0;
}