//////////////////////////////////////////////////////////////////////////////////////////
//
// Program wyswietlajacy szescian w rzucie perspektywicznym. Dlugosc boku szescianu
// moze byc interaktywnie zmieniana za pomoca klwiszy '+' i '-'.
//
//////////////////////////////////////////////////////////////////////////////////////////
#pragma warning(disable : 4996)

#include <GL/glut.h>
#include <string.h>
#include <stdio.h>
#include <math.h>

// Definicja stalych
#define DLUGOSC_BOKU            5.0
#define OBSERWATOR_FOV_Y        30.0
#define M_PI 3.1415926535
#define PI                    3.1415926535
#define DEG2RAD(x) ((float)(x)*M_PI/180.0)
#define X_OFFSET_OBIEKT     10
#define Y_OFFSET_OBIEKT     300

// Zmienne globalne

int szerokoscOkna = 800;
int wysokoscOkna = 600;
int	OBSERWATOR_ODLEGLOSC = 20.0;
int	OBSERWATOR_ODLEGLOSCMIN = 10.0;
int	OBSERWATOR_ODLEGLOSCMAX = 100.0;
int	OBSERWATOR_OBROT_X = 20.0;
int	OBSERWATOR_OBROT_Y = 20.0;
int	OBSERWATOR_OBROT_Z = 0.0;
int	PODZIALY_PIONOWE = 4;
int	PODZIALY_POZIOME = 4;
double R = 10.0; //dolna podstawa
double r = 20.0; //gorna podstawa
double h = 20.0; //wysokosc
int normalne = 1;
int i = 0;
double alfa = 360.0;
double bok = 4.0;
double x, z, x2, z2 = 0;
int zrodlo1 = 1, zrodlo2 = 1;
int mat1 = 1, mat2 = 1, mat3 = 1;

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

//reflektor
GLfloat swiatlo1[5][4] = {
	{0.2,1,0.2,1.0},		//swiatlo otoczenia
	{0.2,1,0.2,1.0},			//swiatlo rozpraszane
	{0.2,1,0.2,1.0},			//swiatlo zwierciadlane
	{0,0,0,1.0},		//polozenie
	{-1.0,0.0,-1.0,0.0}			//kierunek swiecenia
};


//kierunkowe
GLfloat swiatlo2[5][4] = {
	{0.5, 0.5, 0.1, 1.0},			//swiatlo otoczenia
	{0.5, 0.5, 0.1, 1.0},			//swiatlo rozpraszane
	{0.5, 0.5, 0.1, 1.0},			//swiatlo zwierciadlane
	{5.0, 5.0, 20.0, 0.0},			//polozenie
	{0.0, 0.0, -1.0, 0.0}			//kierunek swiecenia
};



float material1[5][4] = { //braz
	{0.5, 0.5, 0.5, 1.000000},	//swiatlo otoczenia
	{0.5, 0.5, 0.5, 1.000000},	//swiatlo rozpraszane
	{0.5, 0.5, 0.5, 1.000000},	//swiatlo zwierciadlane
	{6, 0.0, 0.0, 1.0},						//polysk
	{0.0, 0.0, 0.0, 1.0}						//emisja
};



float material2[5][4] = { // turkus
	{0, 0, 1, 1},	//swiatlo otoczenia
	{0, 0, 1, 1},	//swiatlo rozpraszane
	{0, 0, 0.2, 1},	//swiatlo zwierciadlane
	{10, 0.0, 0.0, 1.0},						//polysk
	{0.0, 0.0, 0.0, 1.0}						//emisja
};


float material3[5][4] = { //perla
	{0.250000, 0.207250, 0.207250, 0.922000},	//swiatlo otoczenia
	{1.000000, 0.829000, 0.829000, 0.922000},	//swiatlo rozpraszane
	{0.296648, 0.296648, 0.296648, 0.922000},	//swiatlo zwierciadlane
	{11.264, 0.0, 0.0, 0.0},					//polysk
	{0.0, 0.0, 0.0, 1.0}						//emisja
};



//////////////////////////////////////////////////////////////////////////////////////////
// Funkcja rysujaca szescian o boku "a" w trybie GL_QUAD_STRIP.
// Srodek szescianu znajduje się w punkcie (0,0,0).


void RysujTekstRastrowy(void* font, char* tekst)
{
	int i;

	for (i = 0; i < (int)strlen(tekst); i++)
		glutBitmapCharacter(font, tekst[i]);
}

void RysujNakladke(void)
{
	char buf[255];

	// 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

	glColor3f(1.0, 1.0, 1.0);

	sprintf(buf, "Pierscien:");
	glRasterPos2i(X_OFFSET_OBIEKT, Y_OFFSET_OBIEKT);
	RysujTekstRastrowy(GLUT_BITMAP_8_BY_13, buf);

	sprintf(buf, " * Zrodlo swiatla nr 1:  (%d)", -zrodlo1);
	glRasterPos2i(X_OFFSET_OBIEKT, Y_OFFSET_OBIEKT - 10);
	RysujTekstRastrowy(GLUT_BITMAP_8_BY_13, buf);

	sprintf(buf, " * Zrodlo swiatla nr 2: (%d)", -zrodlo2);
	glRasterPos2i(X_OFFSET_OBIEKT, Y_OFFSET_OBIEKT - 20);
	RysujTekstRastrowy(GLUT_BITMAP_8_BY_13, buf);


	sprintf(buf, " * Braz: (%d)", -mat1);
	glRasterPos2i(X_OFFSET_OBIEKT, Y_OFFSET_OBIEKT - 30);
	RysujTekstRastrowy(GLUT_BITMAP_8_BY_13, buf);

	sprintf(buf, " * Turksus: (%d)", -mat2);
	glRasterPos2i(X_OFFSET_OBIEKT, Y_OFFSET_OBIEKT - 40);
	RysujTekstRastrowy(GLUT_BITMAP_8_BY_13, buf);

	sprintf(buf, " * Perla: (%d)", -mat3);
	glRasterPos2i(X_OFFSET_OBIEKT, Y_OFFSET_OBIEKT - 50);
	RysujTekstRastrowy(GLUT_BITMAP_8_BY_13, buf);

	sprintf(buf, " * Ilosc podzialow pierscienia: (%d)", PODZIALY_PIONOWE);
	glRasterPos2i(X_OFFSET_OBIEKT, Y_OFFSET_OBIEKT - 60);
	RysujTekstRastrowy(GLUT_BITMAP_8_BY_13, buf);

	sprintf(buf, "Aby zmienic wlasciwosci nalezy nacisnac:");
	glRasterPos2i(X_OFFSET_OBIEKT, Y_OFFSET_OBIEKT - 80);
	RysujTekstRastrowy(GLUT_BITMAP_8_BY_13, buf);

	sprintf(buf, "-/+ - oddalanie, przyblizanie");
	glRasterPos2i(X_OFFSET_OBIEKT, Y_OFFSET_OBIEKT - 90);
	RysujTekstRastrowy(GLUT_BITMAP_8_BY_13, buf);

	sprintf(buf, "1/2/3/4/5/6 - zmiany osi");
	glRasterPos2i(X_OFFSET_OBIEKT, Y_OFFSET_OBIEKT - 100);
	RysujTekstRastrowy(GLUT_BITMAP_8_BY_13, buf);

	sprintf(buf, "9/0 - zmiana smooth/flat");
	glRasterPos2i(X_OFFSET_OBIEKT, Y_OFFSET_OBIEKT - 110);
	RysujTekstRastrowy(GLUT_BITMAP_8_BY_13, buf);

	sprintf(buf, "q/w - sterowanie zrodlem swiatla");
	glRasterPos2i(X_OFFSET_OBIEKT, Y_OFFSET_OBIEKT - 120);
	RysujTekstRastrowy(GLUT_BITMAP_8_BY_13, buf);

	sprintf(buf, "a/s/d - zalaczanie materialow");
	glRasterPos2i(X_OFFSET_OBIEKT, Y_OFFSET_OBIEKT - 130);
	RysujTekstRastrowy(GLUT_BITMAP_8_BY_13, buf);

	sprintf(buf, "z/x - zmiana podzialow");
	glRasterPos2i(X_OFFSET_OBIEKT, Y_OFFSET_OBIEKT - 140);
	RysujTekstRastrowy(GLUT_BITMAP_8_BY_13, buf);

	sprintf(buf, "n/m - zmiana trybu zapelniania");
	glRasterPos2i(X_OFFSET_OBIEKT, Y_OFFSET_OBIEKT - 150);
	RysujTekstRastrowy(GLUT_BITMAP_8_BY_13, buf);

	// Przywrocenie macierzy sprzed wywolania funkcji
	glMatrixMode(GL_PROJECTION);
	glPopMatrix();
	glMatrixMode(GL_MODELVIEW);
	glPopMatrix();
}



void RysujXYZ()
{
	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);
	glEnd();
}
//2.(Y1)Promień wewnętrzny : 10, przekrój : trójkąt równramienny o ramionach 4

void wektory(float radius, int slices, int stacks)
{
	glDisable(GL_LIGHTING);

	double r1 = 10;
	double r2 = 14;
	double angle;
	double H = 4;
	int i = 0;
	double alfa = 0;
	bok = PODZIALY_PIONOWE;

	glBegin(GL_LINES);
	glColor3f(0.8, 0.6, 0.4);
	for (angle = 0; angle < (PI * 2.0); angle += (2.0 * PI / bok))
	{
		glVertex3f(r1 * cos(angle), 0, r1 * sin(angle));					//kat prosty, pionowy
		glVertex3f(r1 * cos(angle), -1, r1 * sin(angle));

		glVertex3f(r2 * cos(angle), 0, r2 * sin(angle));					//kat zewnetrzny, pionowy
		glVertex3f(r2 * cos(angle), -1, r2 * sin(angle));


		glVertex3f(r2 * cos(angle), 0, r2 * sin(angle));								//kat zewnetrzny, prostopadly do nachylonej sciany		CZY NA PEWNO?
		glVertex3f((r2 + cos(45)) * cos(angle), sin(45), (r2 + cos(45)) * sin(angle));

		glVertex3f(r1 * cos(angle), H, r1 * sin(angle));									//kat wewnetrzny, prostopadly do nachylonej sciany		CZY NA PEWNO?
		glVertex3f((r1 + cos(45)) * cos(angle), H + sin(45), (r1 + cos(45)) * sin(angle));


		glVertex3f(r1 * cos(angle), H, r1 * sin(angle));					//kat wewnetrzny, poziomy
		glVertex3f((r1 - 1) * cos(angle), H, (r1 - 1) * sin(angle));

		glVertex3f(r1 * cos(angle), 0, r1 * sin(angle));					//kat prosty, poziomy
		glVertex3f((r1 - 1) * cos(angle), 0, (r1 - 1) * sin(angle));

	}
	glEnd();

	glEnable(GL_LIGHTING);
}

void RysujPierscien()
{
	//oświetlenie
	glEnable(GL_LIGHTING);

	if (zrodlo1 == (-1))
	{
		glEnable(GL_LIGHT1);
		glLightfv(GL_LIGHT1, GL_AMBIENT, swiatlo1[0]);
		glLightfv(GL_LIGHT1, GL_DIFFUSE, swiatlo1[1]);
		glLightfv(GL_LIGHT1, GL_SPECULAR, swiatlo1[2]);
		glLightfv(GL_LIGHT1, GL_POSITION, swiatlo1[3]);
		glLightfv(GL_LIGHT1, GL_SPOT_DIRECTION, swiatlo1[4]);
	}
	else glDisable(GL_LIGHT1);

	if (zrodlo2 == (-1))
	{
		glEnable(GL_LIGHT2);
		glLightfv(GL_LIGHT2, GL_AMBIENT, swiatlo2[0]);
		glLightfv(GL_LIGHT2, GL_DIFFUSE, swiatlo2[1]);
		glLightfv(GL_LIGHT2, GL_SPECULAR, swiatlo2[2]);
		glLightfv(GL_LIGHT2, GL_POSITION, swiatlo2[3]);
		glLightfv(GL_LIGHT2, GL_SPOT_DIRECTION, swiatlo2[4]);
		glLightf(GL_LIGHT2, GL_SPOT_CUTOFF, 30);
	}
	else glDisable(GL_LIGHT2);


	//materiały
	if (mat1 == (-1))
	{
		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]);
	}

	if (mat2 == (-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]);
	}

	if (mat3 == (-1))
	{
		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]);
	}

	// pierscien
	double R = 10;
	double r = 20;
	double h = 20;
	double angle;

	double r1 = 10;
	double r2 = 14;
	double H = 4;
	bok = PODZIALY_PIONOWE;


	glBegin(GL_TRIANGLES);

	for (angle = 0; angle < (PI * 2.1); angle += (2.0 * PI / bok))
	{
		glNormal3f(0, -1, 0);

		glVertex3f(r1 * cos(angle), 0, r1 * sin(angle));
		glVertex3f(r2 * cos(angle), 0, r2 * sin(angle));
		glVertex3f(r1 * cos(angle + 2.0 * PI / bok), 0, r1 * sin(angle + 2.0 * PI / bok));

		glVertex3f(r2 * cos(angle), 0, r2 * sin(angle));
		glVertex3f(r2 * cos(angle + 2.0 * PI / bok), 0, r2 * sin(angle + 2.0 * PI / bok));
		glVertex3f(r1 * cos(angle + 2.0 * PI / bok), 0, r1 * sin(angle + 2.0 * PI / bok));

	}

	glColor3f(1, 1, 0);

	for (angle = 0; angle < (PI * 2.1); angle += (2.0 * PI / bok))
	{
		glNormal3f(cos(45) * cos(angle), sin(45), cos(45) * sin(angle));
		glVertex3f(r2 * cos(angle), 0, r2 * sin(angle));
		glVertex3f(r1 * cos(angle), H, r1 * sin(angle));
		glVertex3f(r2 * cos(angle + 2.0 * PI / bok), 0, r2 * sin(angle + 2.0 * PI / bok));

		glVertex3f(r1 * cos(angle), H, r1 * sin(angle));
		glVertex3f(r1 * cos(angle + 2.0 * PI / bok), H, r1 * sin(angle + 2.0 * PI / bok));
		glVertex3f(r2 * cos(angle + 2.0 * PI / bok), 0, r2 * sin(angle + 2.0 * PI / bok));

	}
	glColor3f(0, 1, 1);
	for (angle = 0; angle < (PI * 2.1); angle += (2.0 * PI / bok))
	{
		glNormal3f(-cos(angle), 0, -sin(angle));
		glVertex3f(r1 * cos(angle), 0, r1 * sin(angle));
		glVertex3f(r1 * cos(angle), H, r1 * sin(angle));
		glVertex3f(r1 * cos(angle + 2.0 * PI / bok), 0, r1 * sin(angle + 2.0 * PI / bok));

		glVertex3f(r1 * cos(angle), H, r1 * sin(angle));
		glVertex3f(r1 * cos(angle + 2.0 * PI / bok), H, r1 * sin(angle + 2.0 * PI / bok));
		glVertex3f(r1 * cos(angle + 2.0 * PI / bok), 0, r1 * sin(angle + 2.0 * PI / bok));

	}
	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);

	//MODELE 3D
	//RysujXYZ();
	//RysujWalec();
	RysujPierscien();
	RysujNakladke();
	if (normalne)
		wektory(3, PODZIALY_PIONOWE, PODZIALY_POZIOME);
	//Rysujwektory(PODZIALY_PIONOWE);

	// Przelaczenie buforow ramki
	glutSwapBuffers();
}


//////////////////////////////////////////////////////////////////////////////////////////
// Funkcja obslugi klawiatury
void ObslugaKlawiatury(unsigned char klawisz, int x, int y)
{
	if (klawisz == '-')
		OBSERWATOR_ODLEGLOSC = (OBSERWATOR_ODLEGLOSC < OBSERWATOR_ODLEGLOSCMAX) ? OBSERWATOR_ODLEGLOSC + 1.0 : OBSERWATOR_ODLEGLOSC;
	else if (klawisz == '+')
		OBSERWATOR_ODLEGLOSC = (OBSERWATOR_ODLEGLOSC > OBSERWATOR_ODLEGLOSCMIN) ? OBSERWATOR_ODLEGLOSC - 1.0 : OBSERWATOR_ODLEGLOSC;
	else if (klawisz == '1')
		OBSERWATOR_OBROT_X = OBSERWATOR_OBROT_X + 1.0;
	else if (klawisz == '2')
		OBSERWATOR_OBROT_X = OBSERWATOR_OBROT_X - 1.0;
	else if (klawisz == '3')
		OBSERWATOR_OBROT_Y = OBSERWATOR_OBROT_Y - 1.0;
	else if (klawisz == '4')
		OBSERWATOR_OBROT_Y = OBSERWATOR_OBROT_Y + 1.0;
	else if (klawisz == '5')
		OBSERWATOR_OBROT_Z = OBSERWATOR_OBROT_Z - 1.0;
	else if (klawisz == '6')
		OBSERWATOR_OBROT_Z = OBSERWATOR_OBROT_Z + 1.0;
	else if (klawisz == 'm')
		PODZIALY_PIONOWE = (PODZIALY_PIONOWE < 64) ? PODZIALY_PIONOWE + 1 : PODZIALY_PIONOWE;
	else if (klawisz == 'n')
		PODZIALY_PIONOWE = (PODZIALY_PIONOWE > 4) ? PODZIALY_PIONOWE - 1 : PODZIALY_PIONOWE;
	else if (klawisz == '8')
		normalne = !normalne;
	else if (klawisz == 'n')
		glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
	else if (klawisz == 'm')
		glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
	else if (klawisz == '9')
		glShadeModel(GL_SMOOTH);
	else if (klawisz == '0')
		glShadeModel(GL_FLAT);
	else if (klawisz == 'q')
		zrodlo1 = zrodlo1 * (-1);
	else if (klawisz == 'w')
		zrodlo2 = zrodlo2 * (-1);
	else if (klawisz == 'a')
		mat1 = mat1 * (-1);
	else if (klawisz == 's')
		mat2 = mat2 * (-1);
	else if (klawisz == 'd')
		mat3 = mat3 * (-1);
	else if (klawisz == 27)
		exit(0);
}

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

	glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);

	// 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 wartosci czyszczacej zawartosc bufora glebokosci
	glClearDepth(1000.0);

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

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

	// 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;
}