//////////////////////////////////////////////////////////////////////////////////////////
//
// Program wyswietlajacy szescian w rzucie perspektywicznym. Dlugosc boku szescianu
// moze byc interaktywnie zmieniana za pomoca klwiszy '+' i '-'.
//
//////////////////////////////////////////////////////////////////////////////////////////

#include "glut.h"
#include <math.h>
#include <time.h>
#include <stdint.h>


#define odlMin 5
#define odlMax 200
#define Pi 3.14159265359

int podzialPionowy = 8;
int podzialPoziomy = 8;
int     szerokoscOkna = 800;
int     wysokoscOkna = 600;

GLboolean tryb = GL_TRUE;

GLfloat odlObs = 50.0;
GLfloat rotObsY = 40.0;
GLfloat rotObsX = 40.0;
GLfloat rotObsZ = 0.0;

float length;

int source1 = 1;
int source2 = 1;
int obecnymaterial = 0;
int normalne = 1;
int smooth = 1;
int fill = 1;

// Tablica parametrow materialu nr 1
float material1[5][4] = {
	{0.192250, 0.192250, 0.192250, 1.000000},  // [0] wspolczynnik odbicia swiatla otoczenia
	{0.507540, 0.507540, 0.507540, 1.000000},  // [1] wspolczynnik odbicia swiatla rozproszonego
	{0.508273, 0.508273, 0.508273, 1.000000},  // [2] wspolczynnik odbicia swiatla lustrzanego
	{51.2, 0.0, 0.0, 0.0}, // [3] polysk
	{0.5, 0.0, 0.2, 1.0} }; // [4] kolor swiatla emitowanego

	// Tablica parametrow materialu nr 2
float material2[5][4] = {
  {0.250000, 0.148000, 0.064750, 1.000000},  // [0] wspolczynnik odbicia swiatla otoczenia
  {0.400000, 0.236800, 0.103600, 1.000000},  // [1] wspolczynnik odbicia swiatla rozproszonego
  {0.774597, 0.458561, 0.200621, 1.000000},  // [2] wspolczynnik odbicia swiatla lustrzanego
  {76.8, 0.0, 0.0, 0.0},                     // [3] polysk
  {0.0, 0.1, 0.3, 1.0} };                    // [4] kolor swiatla emitowanego

	// Tablica parametrow materialu nr 3
float material3[5][4] = {
	{0.231250, 0.231250, 0.231250, 1.000000},  // [0] wspolczynnik odbicia swiatla otoczenia
	{0.277500, 0.277500, 0.277500, 1.000000},  // [1] wspolczynnik odbicia swiatla rozproszonego
	{0.773911, 0.773911, 0.773911, 1.000000 },  // [2] wspolczynnik odbicia swiatla lustrzanego
	{52.2, 0.0, 0.0, 0.0},                     // [3] polysk
	{0.0, 0.0, 0.0, 1.0} };                    // [4] kolor swiatla emitowanego

// Tablica parametrow zrodla swiatla nr 1
GLfloat swiatlo1[5][4] = {
  {0.2, 0.2, 0, 1.0},      // [0] otoczenie
  {0.2, 0.2, 0.0, 1.0},    // [1] rozproszenie
  {0.2, 0.8, 0.0, 1.0},    // [2] lustrzane
  {0, 10.0, 0, 1.0}, // [3] polozenie
  {-1.0, -1.0, -1.0, 0.0}  // [4] kierunek swiecenia
};

// Tablica parametrow zrodla swiatla nr 2
GLfloat swiatlo2[5][4] = {
  {0, 1, 1, 1.0},           // [0] otoczenie
  {0, 1, 1, 1.0},           // [1] rozproszenie
  {0, 28, 1, 1.0},          // [2] lustrzane
  {0, 0, -10.0, 1.0}, // [3] polozenie
  {-1.0, -1.0, -1.0, 0.0}   // [4] kierunek swiecenia
};


// Prototypy funkcji
void RysujSzescian(double a);
void UstawParametryWidoku(int szer, int wys);
void WyswietlObraz(void);
void ObslugaKlawiatury(unsigned char klawisz, int x, int y);
void PoliczNormal(float x1, float x2, float x3, float y1, float y2, float y3, float z1, float z2, float z3, float* normal);

void RysujTekstRastrowy(void* font, char* tekst)
{
	int i = 0;
	while (tekst[i] != '\0')
	{
		glutBitmapCharacter(font, tekst[i]);
		i++;
	}
}

#define numberofoptions 11

void RysujNakladke(void)
{
	char tab[numberofoptions][50] =
	{"1 - Przyblizenie",
	 "2 - Oddalenie",
	 "5 - Zmiana materialu walca",
	 "6 - Sterowanie swiatlem nr. 1",
	 "7 - Sterowanie swiatlem nr. 2",
	 "8 - Widocznosc wektorow normalnych",
	 "9 - Zmiana cienia (GL_SMOOTH i GL_FLAT)",
	 "0 - Zmiana wypelnienia (GL_FILL, GL_LINE)",
	 "a,z - Zmniejszanie ilosci podzialow",
	 "s,x - Zwiekszanie ilosci podzialow",
	 "(l,r,d,u arrows),. - Sterowanie kamera",
	};
	int i;

	// Zmiana typu rzutu z perspektywicznego na ortogonalny
	glMatrixMode(GL_PROJECTION);
	glPushMatrix();
	glLoadIdentity();
	glOrtho(0.0, szerokoscOkna, 0.0, wysokoscOkna, -100.0, 100.0);

	// Modelowanie sceny 2D (zawartosci nakladki)
	glMatrixMode(GL_MODELVIEW);
	glPushMatrix();
	glLoadIdentity();

	// Zablokowanie oswietlenia (mialoby ono wplyw na kolor tekstu)
	glDisable(GL_LIGHTING);

	// Okreslenie koloru tekstu
	glColor3f(1.0, 1.0, 1.0);

	// RYSOWANIE MENU PARAMETROW ZRODLA SWIATLA

	for (i = 0; i < numberofoptions; i++)
	{
		glRasterPos2i(10, 10 + i * 13);
		RysujTekstRastrowy(GLUT_BITMAP_8_BY_13, tab[numberofoptions - i - 1]);
	}

	glMatrixMode(GL_PROJECTION);
	glPopMatrix();
	glMatrixMode(GL_MODELVIEW);
	glPopMatrix();
}

void UstawSwiatlaIMaterialy()
{
	glEnable(GL_LIGHTING);
	// Odblokowanie zrodla swiatla nr 1
	if (source1 == 1) {
		glEnable(GL_LIGHT0);
		glLightfv(GL_LIGHT0, GL_AMBIENT, swiatlo1[0]);
		glLightfv(GL_LIGHT0, GL_DIFFUSE, swiatlo1[1]);
		glLightfv(GL_LIGHT0, GL_SPECULAR, swiatlo1[2]);
		glLightfv(GL_LIGHT0, GL_POSITION, swiatlo1[3]);
		glLightfv(GL_LIGHT0, GL_SPOT_DIRECTION, swiatlo1[4]);

	}
	else {
		//wylaczenie zrodla swiatla nr 1
		glDisable(GL_LIGHT0);
	}
	// Odblokowanie zrodla swiatla nr 2
	if (source2 == 1) {
		glEnable(GL_LIGHT1);
		glLightfv(GL_LIGHT1, GL_AMBIENT, swiatlo2[0]);
		glLightfv(GL_LIGHT1, GL_DIFFUSE, swiatlo2[1]);
		glLightfv(GL_LIGHT1, GL_SPECULAR, swiatlo2[2]);
		glLightfv(GL_LIGHT1, GL_POSITION, swiatlo2[3]);
		glLightfv(GL_LIGHT1, GL_SPOT_DIRECTION, swiatlo2[4]);

	}
	else {
		//wylaczenie zrodla swiatla nr 2
		glDisable(GL_LIGHT1);
	}

	switch (obecnymaterial)
	{
	case 0:
		glMaterialfv(GL_FRONT, GL_AMBIENT, material1[0]);
		glMaterialfv(GL_FRONT, GL_DIFFUSE, material1[1]);
		glMaterialfv(GL_FRONT, GL_SPECULAR, material1[2]);
		glMaterialfv(GL_FRONT, GL_SHININESS, material1[3]);
		glMaterialfv(GL_FRONT, GL_EMISSION, material1[4]);
		break;
	case 1:
		glMaterialfv(GL_FRONT, GL_AMBIENT, material2[0]);
		glMaterialfv(GL_FRONT, GL_DIFFUSE, material2[1]);
		glMaterialfv(GL_FRONT, GL_SPECULAR, material2[2]);
		glMaterialfv(GL_FRONT, GL_SHININESS, material2[3]);
		glMaterialfv(GL_FRONT, GL_EMISSION, material2[4]);
		break;
	case 2:
		glMaterialfv(GL_FRONT, GL_AMBIENT, material3[0]);
		glMaterialfv(GL_FRONT, GL_DIFFUSE, material3[1]);
		glMaterialfv(GL_FRONT, GL_SPECULAR, material3[2]);
		glMaterialfv(GL_FRONT, GL_SHININESS, material3[3]);
		glMaterialfv(GL_FRONT, GL_EMISSION, material3[4]);
		break;
	default:
		break;
	}
}

void PoliczNormal(float x1, float x2, float x3, float y1, float y2, float y3, float z1, float z2, float z3, float* normal)
{
	float xa = x2 - x1;
	float ya = y2 - y1;
	float za = z2 - z1;

	float xb = x3 - x1;
	float yb = y3 - y1;
	float zb = z3 - z1;

	normal[0] = ya * zb - za * yb;
	normal[1] = za * xb - xa * zb;
	normal[2] = xa * yb - ya * xb;

	length = sqrtf(normal[0] * normal[0] + normal[1] * normal[1] + normal[2] * normal[2]);

	normal[0] /= length;
	normal[1] /= length;
	normal[2] /= length;
}

void SyncSmoothIFill()
{
	if (smooth)
		glShadeModel(GL_SMOOTH);
	else
		glShadeModel(GL_FLAT);

	if (fill)
		glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
	else
		glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
}

double DEG2RAD(float deg)
{
	return deg * Pi / 180;
}



void Stozek(double R, double r, double h) {
	int i;
	double dAlfa = 360.0 / podzialPionowy;

	//podstawa dolna
	glBegin(GL_TRIANGLE_FAN);
	glVertex3f(0, 0, 0);
	for (i = 0; i * dAlfa <= 360.0; i++) {
		glVertex3f(R * cos(DEG2RAD(i * dAlfa)), 0, R * sin(DEG2RAD(i * dAlfa)));
	}
	glEnd();

	//podstawa gorna
	glBegin(GL_TRIANGLE_FAN);
	glVertex3f(0, h, 0);
	for (i = 0; i * dAlfa <= 360.0; i++) {
		glVertex3f(r * cos(DEG2RAD(i * dAlfa)), h, r * sin(DEG2RAD(i * dAlfa)));
	}
	glEnd();

	//sciana boczna
	glBegin(GL_QUAD_STRIP);
	for (i = 0; i * dAlfa <= 360.0; i++) {
		glVertex3f(R * cos(DEG2RAD(i * dAlfa)), 0, R * sin(DEG2RAD(i * dAlfa)));
		glVertex3f(r * cos(DEG2RAD(i * dAlfa)), h, r * sin(DEG2RAD(i * dAlfa)));
	}
	glEnd();
}

void Rysuj()
{
	// Poczatek tworzenia ukladu wspolrzednych
	glBegin(GL_LINES);

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

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

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

	// Koniec tworzenia ukladu wspolrzednych
	glEnd();

	//Stozek(10,20,25);
	Walec();

}
*/
//////////////////////////////////////////////////////////////////////////////////////////
// Funkcja generujaca pojedyncza klatke animacji
void WyswietlObraz(void)
{
	// Wyczyszczenie bufora ramki i bufora glebokosci
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glMatrixMode(GL_MODELVIEW);

	// Powielenie macierzy na wierzcholku stosu
	glPushMatrix();

	// Wyznaczenie polozenia obserwatora (przeksztalcenie uladu wspolrzednych
	// sceny do ukladu wspolrzednych obserwatora).
	glTranslatef(0, 0, -odlObs);
	glRotatef(rotObsX, 1, 0, 0);
	glRotatef(rotObsY, 0, 1, 0);
	glRotatef(rotObsZ, 0, 0, 1);

	RysujNakladke();

	UstawSwiatlaIMaterialy();

	// Generacja obrazu sceny w niewidocznym buforze ramki
	Walec();

	// Usuniecie macierzy lezacej na  wierzcholku stosu (powrot do stanu
	// sprzed wywolania funkcji
	glPopMatrix();

	// Przelaczenie buforow ramki
	glutSwapBuffers();
}

//////////////////////////////////////////////////////////////////////////////////////////
// Funkcja ustawiajaca parametry rzutu perspektywicznego i rozmiary viewportu
void UstawParametryWidoku(int szerokosc, int wysokosc)
{
	// Ustawienie parametrow viewportu
	glViewport(0, 0, szerokosc, wysokosc);

	// Przejscie w tryb modyfikacji macierzy rzutowania
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	gluPerspective(40.0, (float)szerokosc / (float)wysokosc, 1.0, 1000.0);

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

	// Zmiana macierzy znajdujacej sie na wierzcholku stosu na macierz jednostkowa
	glLoadIdentity();
}

void ZmianaTrybu()
{
	if (tryb == GL_TRUE)
	{
		tryb = GL_FALSE;
		glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
	}
	else if (tryb == GL_FALSE)
	{
		tryb = GL_TRUE;
		glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
	}
}

//////////////////////////////////////////////////////////////////////////////////////////
// Funkcja klawiszy specjalnych
void ObslugaKlawiszySpecjalnych(int klawisz, int x, int y)
{
	switch (klawisz)
	{
	case GLUT_KEY_UP:
		rotObsX = rotObsX + 1.0;
		break;

	case GLUT_KEY_DOWN:
		rotObsX = rotObsX - 1.0;
		break;

	case GLUT_KEY_LEFT:
		rotObsY = rotObsY - 1.0;
		break;

	case GLUT_KEY_RIGHT:
		rotObsY = rotObsY + 1.0;
		break;
	}
}
//////////////////////////////////////////////////////////////////////////////////////////
// Funkcja obslugi klawiatury
void ObslugaKlawiatury(unsigned char klawisz, int x, int y)
{

	switch (klawisz)
	{
	case '1':
		odlObs = (odlObs > odlMin) ? odlObs - 1 : odlObs;
		break;
	case '2':
		odlObs = (odlObs < odlMax) ? odlObs + 1 : odlObs;
		break;
	case ',':
		rotObsZ =  rotObsZ - 1.0;
		break;
	case '.':
		rotObsZ = rotObsZ + 1.0;
		break;
	case 'z':
		podzialPionowy = (podzialPionowy > 4) ? podzialPionowy - 1.0 : podzialPionowy;
		break;
	case 'x':
		podzialPionowy = (podzialPionowy < 64) ? podzialPionowy + 1.0 : podzialPionowy;
		break;
	case 'a':
		podzialPoziomy = (podzialPoziomy > 4) ? podzialPoziomy - 2.0 : podzialPoziomy;
		break;
	case 's':
		podzialPoziomy = (podzialPoziomy < 64) ? podzialPoziomy + 2.0 : podzialPoziomy;
		break;
	case '5':
		obecnymaterial++;
		if (obecnymaterial > 2)
			obecnymaterial = 0;
		break;
	case '6':
		source1 = !source1;
		break;
	case '7':
		source2 = !source2;
		break;
	case '8':
		normalne = !normalne;
		break;
	case '9':
		smooth = !smooth;
		SyncSmoothIFill();
		break;
	case '0':
		fill = !fill;
		SyncSmoothIFill();
		break;
	}

	if (klawisz == 27)
		exit(0);
}

//////////////////////////////////////////////////////////////////////////////////////////
// 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("Szescian");

	// Odblokowanie bufora glebokosci
	glEnable(GL_DEPTH_TEST);

	// Ustawienie funkcji wykonywanej na danych w buforze glebokosci
	glDepthFunc(GL_LEQUAL);

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

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


	// Zarejestrowanie funkcji (callback) wyswietlajacej
	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);

	// Zarejestrowanie funkcji obslugi klawiszy specjalnych
	glutSpecialFunc(ObslugaKlawiszySpecjalnych);



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

	return 0;
}