//////////////////////////////////////////////////////////////////////////////////////////
//
// Program wyswietlajacy szescian w rzucie perspektywicznym. Dlugosc boku szescianu
// moze byc interaktywnie zmieniana za pomoca klwiszy '+' i '-'.
//
//////////////////////////////////////////////////////////////////////////////////////////
#include <GL\glut.h>
#include <math.h>


// Definicja stalych
#define WYSOKOSC				4.0
#define PROMIEN                 5.0
#define PROMIEN2                 1.0
#define OBSERWATOR_FOV_Y        30.0
#define PODZIAL_X			    20.0
#define PODZIAL_Y				20.0
GLfloat N = 60.0;
GLfloat OBSERWATOR_OBROT_Z = 20.0;
GLfloat OBSERWATOR_OBROT_X = 20.0;
GLfloat OBSERWATOR_OBROT_Y = 20.0;
GLfloat OBSERWATOR_ODLEGLOSC = 20.0;
GLfloat odminimalna = 5;
GLfloat odmaxymalna = 200;

// Zmienne globalne
double  promien = PROMIEN; // Dlugosc boku szescianu
double  promien2 = PROMIEN2; // Dlugosc boku szescianu
double wysokosc = WYSOKOSC;
int     szerokoscOkna = 1024;
int     wysokoscOkna = 768;
float j = 0, i = 0;
float a, x, y, z;


// Prototypy funkcji
void UstawParametryWidoku(int szer, int wys);
void WyswietlObraz(void);
void ObslugaKlawiatury(unsigned char klawisz, int x, int y);


//////////////////////////////////////////////////////////////////////////////////////////
// Funkcja rysujaca szescian o boku "a" w trybie GL_QUAD_STRIP.
// Srodek szescianu znajduje się w punkcie (0,0,0).
void RysujStozek(double R1, double R2, double H)
{

	float x, y, z, fi, OD, DO, OD1, DO1, R = R1;
	const long double PI = 3.1415926535897932384626433832795028841971693993751058209, EPS = PODZIAL_X, EPS2 = PODZIAL_Y;
	OD1 = 0.0;
	DO1 = 2.0001*PI;
	OD = 0.0;
	DO = 2.0001*PI;

	glBegin(GL_LINES);

	// Os X
	glColor3f(1.0, 0.0, 0.0);
	glVertex3f(-40.0, 0.0, 0.0);
	glVertex3f(40.0, 0.0, 0.0);

	// Os Y
	glColor3f(0.0, 1.0, 0.0);
	glVertex3f(0.0, -20.0, 0.0);
	glVertex3f(0.0, 20.0, 0.0);

	// Os Z
	glColor3f(0.0, 0.0, 1.0);
	glVertex3f(0.0, 0.0, -20.0);
	glVertex3f(0.0, 0.0, 20.0);

	// Koniec tworzenia ukladu wspolrzednych
	glEnd();

	glTranslatef(0, WYSOKOSC, 0);
	glBegin(GL_TRIANGLE_STRIP);
	for (y = 0; (y <= H) && (R >= R2); y -= H / N, R -= ((R1 - R2) / N))
	{

		for (fi = OD1; fi < DO1; fi += PI / N)
		{
			x = R * cos(fi);
			z = R * sin(fi);
			glVertex3f(x, y, z);

			x = (R - ((R1 - R2) / N)) * cos(fi - PI / N);
			z = (R - ((R1 - R2) / N)) * sin(fi - PI / N);
			glVertex3f(x, (y + H / N), z);



		}
	}
	glEnd();
	glTranslatef(0, -WYSOKOSC, 0);
	glBegin(GL_TRIANGLE_FAN);

	glVertex3f(0.0, 0.0, 0.0);
	for (fi = OD; fi <= DO; fi += PI / N)
	{
		x = R2 * cos(fi);
		z = R2 * sin(fi);
		glVertex3f(x, 0, z);

	}

	glEnd();

	glBegin(GL_TRIANGLE_FAN);

	glVertex3f(0, H, 0);
	for (fi = OD; fi < DO; fi += PI / N)
	{
		x = R1 * cos(fi);
		z = R1 * sin(fi);
		glVertex3f(x, H, z);

	}

	glEnd();
}

//////////////////////////////////////////////////////////////////////////////////////////
// Funkcja ustawiajaca parametry rzutu perspektywicznego i rozmiary viewportu. Powinna
// być wywolywana kazdorazowo po zmianie rozmiarow okna programu.
void UstawParametryWidoku(int szer, int wys)
{
	// Zapamietanie wielkosci widoku
	szerokoscOkna = szer;
	wysokoscOkna = wys;

	// Ustawienie parametrow viewportu
	glViewport(0, 0, szerokoscOkna, wysokoscOkna);

	// Przejscie w tryb modyfikacji macierzy rzutowania
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	gluPerspective(OBSERWATOR_FOV_Y, (float)szerokoscOkna / (float)wysokoscOkna, 1.0, 1000.0);
}


//////////////////////////////////////////////////////////////////////////////////////////
// Funkcja wyswietlajaca pojedyncza klatke animacji
void WyswietlObraz(void)
{
	// Wyczyszczenie bufora koloru i bufora glebokosci
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	// Przejscie w tryb modyfikacji macierzy przeksztalcen geometrycznych
	glMatrixMode(GL_MODELVIEW);

	// Zastapienie aktywnej macierzy macierza jednostkowa
	glLoadIdentity();

	// Ustalenie polozenia obserwatora
	glTranslatef(0, 0, -OBSERWATOR_ODLEGLOSC);
	glRotatef(OBSERWATOR_OBROT_X, 1, 0, 0);
	glRotatef(OBSERWATOR_OBROT_Y, 0, 1, 0);
	glRotatef(OBSERWATOR_OBROT_Z, 0, 0, 1);

	// Narysowanie szescianu
	RysujStozek(promien, promien2, wysokosc);

	// Przelaczenie buforow ramki
	glutSwapBuffers();
}


//////////////////////////////////////////////////////////////////////////////////////////
// Funkcja obslugi klawiatury
void ObslugaKlawiatury(unsigned char klawisz, int x, int y)
{
/*	if (klawisz == '+')
	{
		promien *= 1.01;
		promien2 *= 1.01;
	}
	else if (klawisz == '-')
	{
		promien /= 1.01;
		promien2 /= 1.01;
	}
	else if (klawisz == 27)
		exit(0);
	else if (klawisz == 'w')
		OBSERWATOR_OBROT_X = OBSERWATOR_OBROT_X + 1.0;
	else if (klawisz == 's')
		OBSERWATOR_OBROT_X = OBSERWATOR_OBROT_X - 1.0;
	else if (klawisz == 'd')
		OBSERWATOR_OBROT_Y = OBSERWATOR_OBROT_Y + 1.0;
	else if (klawisz == 'a')
		OBSERWATOR_OBROT_Y = OBSERWATOR_OBROT_Y - 1.0;
	else if (klawisz == 'e')
		OBSERWATOR_OBROT_Z = OBSERWATOR_OBROT_Z + 1.0;
	else if (klawisz == 'q')
		OBSERWATOR_OBROT_Z = OBSERWATOR_OBROT_Z - 1.0;
	else if (klawisz == 'g')
		OBSERWATOR_ODLEGLOSC = (OBSERWATOR_ODLEGLOSC < odminimalna) ? OBSERWATOR_ODLEGLOSC + 1.0 : OBSERWATOR_ODLEGLOSC;
	else if (klawisz == 'r')
		OBSERWATOR_ODLEGLOSC = (OBSERWATOR_ODLEGLOSC > odmaxymalna) ? OBSERWATOR_ODLEGLOSC - 1.0 : OBSERWATOR_ODLEGLOSC;
	else if (klawisz == '1')
		N += 5.0;
	else if (klawisz == '2')
		N -= 5.0;*/


	switch (klawisz) {
	case 'w':OBSERWATOR_OBROT_X = OBSERWATOR_OBROT_X + 1.0; break;
	case 's':OBSERWATOR_OBROT_X = OBSERWATOR_OBROT_X - 1.0; break;
	case 'a':OBSERWATOR_OBROT_Y = OBSERWATOR_OBROT_Y - 1.0; break;
	case 'd':OBSERWATOR_OBROT_Y = OBSERWATOR_OBROT_Y + 1.0; break;
	case 'q':OBSERWATOR_OBROT_Z = OBSERWATOR_OBROT_Z - 1.0; break;
	case 'e':OBSERWATOR_OBROT_Z = OBSERWATOR_OBROT_Z + 1.0; break;
	case 'r':OBSERWATOR_ODLEGLOSC = (OBSERWATOR_ODLEGLOSC < odmaxymalna) ? OBSERWATOR_ODLEGLOSC + 1.0 : OBSERWATOR_ODLEGLOSC; break;
	case 'f':OBSERWATOR_ODLEGLOSC = (OBSERWATOR_ODLEGLOSC > odmaxymalna) ? OBSERWATOR_ODLEGLOSC - 1.0 : OBSERWATOR_ODLEGLOSC; break;
	case '1': N += 5.0; break;
	case '2': N -= 5.0; break;
	case '3':
		{
		promien *= 1.01;promien2 *= 1.01;
		}break;
	case '4':
		{
		promien /= 1.01; promien2 /= 1.01;
		}break;

	}//koniec switcha
}


//////////////////////////////////////////////////////////////////////////////////////////
// Glowna funkcja programu
int  main(int argc, char **argv)
{
	// Zainicjowanie biblioteki GLUT
	glutInit(&argc, argv);

	// Ustawienie trybu wyswietlania
	glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);

	// Ustawienie polozenia dolenego lewego rogu okna
	glutInitWindowPosition(100, 100);

	// Ustawienie rozmiarow okna
	glutInitWindowSize(szerokoscOkna, wysokoscOkna);

	// Utworzenie okna
	glutCreateWindow("Stozek - GL_TRIANGLE_STRIP");

	// Odblokowanie bufora glebokosci
	glEnable(GL_DEPTH_TEST);

	// Ustawienie wartosci czyszczacej zawartosc bufora glebokosci
	glClearDepth(1000.0);

	// Ustawienie koloru czyszczenia bufora ramki
	glClearColor(0.0f, 0.0f, 0.3f, 0.0f);

	// Wlaczenie wyswietlania wielokatow w postaci obrysow (przydatne w celach diagnostycznych).
	glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);

	// Zarejestrowanie funkcji (callback) odpowiedzialnej za
	glutDisplayFunc(WyswietlObraz);

	// Zarejestrowanie funkcji (callback) wywolywanej za kazdym razem kiedy
	// zmieniane sa rozmiary okna
	glutReshapeFunc(UstawParametryWidoku);

	// Zarejestrowanie funkcji wykonywanej gdy okno nie obsluguje
	// zadnych zadan
	glutIdleFunc(WyswietlObraz);

	// Zarejestrowanie funkcji obslugi klawiatury
	glutKeyboardFunc(ObslugaKlawiatury);

	// Obsluga glownej petli programu (wywolywanie zarejestrowanych callbackow
	// w odpowiedzi na odbierane zdarzenia lub obsluga stanu bezczynnosci)
	glutMainLoop();

	return 0;
}