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


//ZESTAW 4, ZADANIE 4 - Indywidualne
#include "GL/glut.h"
#include <math.h>

// Definicja stalych
#define DLUGOSC_BOKU            10.0
#define OBSERWATOR_ODLEGLOSC    20.0
#define OBSERWATOR_OBROT_X      20.0
#define OBSERWATOR_OBROT_Y      20.0
#define OBSERWATOR_FOV_Y        30.0

//zmienna podziałów pionowych
int zmienna = 4;
//zmienna podziałów poziomych
int zmienna2 = 4;

// Zmienne globalne
double  bok = DLUGOSC_BOKU; // Dlugosc boku szescianu
int     szerokoscOkna = 800;
int     wysokoscOkna = 600;
int zm1 = 1;
int smooth = 1;
int a = 5;

int mat1 = 0;
int mat2 = 0;

GLfloat minOdl = -10.0;
GLfloat maxOdl = -200.0;
GLfloat obsOdl = -30.0;
GLfloat rotObsY = 40.0;
GLfloat rotObsX = 40.0;
GLfloat rotObsZ = 0.0;

int N = 5;
int M = 5;

// Tablica parametrow swiatla 1
GLfloat swiatlo1[10][4] = {
{0.0, 0.0, 0.0, 1.0},  // [0] otoczenie
	{1.0, 1.0, 1.0, 1.0},  // [1] rozproszenie
	{1.0, 1.0, 1.0, 1.0},  // [2] lustrzane
	{0.0, 0.0, 1.0, 1.0},  // [3] polozenie
	{-1.0, 0.0, 0.0, 0.0}, // [4] kierunek swiecenia
	{0.0, 0.0, 0.0, 0.0},  // [5] tlumienie katowe swiatla
	{30.0, 0.0, 0.0, 0.0},// [6] kat odciecia swiatla
	{1.0, 0.0, 0.0, 0.0},  // [7] stale tlumienie
	{0.0, 0.0, 0.0, 0.0},  // [8] tlumienie liniowe
	{0.0, 0.0, 0.0, 0.0} }; // [9] tlumienie kwadratowe

// Tablica parametrow zrodla swiatla nr 1
GLfloat swiatlo2[10][4] = {
  {0,0.7, 0, 1.0},   // [0] otoczenie
  {0, 0.7, 0, 1.0},   // [1] rozproszenie
  {0, 18, 1, 1.0},   // [2] lustrzane
  {10, 10.0, 10.0, 1.0},// [3] polozenie
  {-1.0, -1.0, -1.0, 0.0},// [4] kierunek swiecenia
{0.0, 0.0, 0.0, 0.0},  // [5] tlumienie katowe swiatla
	{180.0, 0.0, 0.0, 0.0},// [6] kat odciecia swiatla
	{1.0, 0.0, 0.0, 0.0},  // [7] stale tlumienie
	{0.0, 0.0, 0.0, 0.0},  // [8] tlumienie liniowe
	{0.0, 0.0, 0.0, 0.0} }; // [9] tlumienie kwadratowe

float material1[5][4] = {
  {0.021500, 0.174500, 0.021500, 0.550000},  // [0] wspolczynnik odbicia swiatla otoczenia
  {0.075680, 0.614240, 0.075680, 0.550000},  // [1] wspolczynnik odbicia swiatla rozproszonego
  {0.633000, 0.727811, 0.633000, 0.550000},  // [2] wspolczynnik odbicia swiatla lustrzanego
  {76.8, 0.0, 0.0, 0.0}, // [3] polysk
  {0.0, 0.0, 0.0, 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.0, 0.0, 1.0} }; // [4] kolor swiatla emitowanego
float material3[5][4] = {
{0.247250, 0.199500, 0.074500, 1.000000},  // [0] wspolczynnik odbicia swiatla otoczenia
{0.751640, 0.606480, 0.226480, 1.000000},  // [1] wspolczynnik odbicia swiatla rozproszonego
{0.628281, 0.555802, 0.366065, 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


// Prototypy funkcji
void RysujSzescian(int N);
void UstawParametryWidoku(int szer, int wys);
void WyswietlObraz(void);
void ObslugaKlawiatury(unsigned char klawisz, int x, int y);
void ObslugaKlawiszySpecjalnych(int 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).

//sciany boczne
void RysujStozekBezPodstaw(float R, float r, float y, float h, int n)
{
	float alfa;
	int i;
	float x;
	float z;

	if (smooth)
		glShadeModel(GL_SMOOTH);
	else
		glShadeModel(GL_FLAT);

	//glColor3f(1.0, 0.0, 0.0);
	glBegin(GL_TRIANGLE_STRIP);


	alfa = 90.0 / n;   //kÄ…t
	for (i = 0; i <= n; i++)
	{

		x = cos(0.0174532925f * i * alfa);
		z = sin(0.0174532925f * i * alfa);

		glVertex3f(x * R, y + 0, z * R);
		glVertex3f(x * r, y + h, z * r);

	}


	x = cos(0.0);
	z = sin(0.0);

	// glVertex3f(x * R, y + 0, z * R);
	 //glVertex3f(x * r, y + h, z * r);

	glEnd();

	//sciana boczna po plaszczyznie X
	glBegin(GL_TRIANGLE_STRIP);
	glColor3f(1.0, 0.0, 0.5);
	glVertex3f(0, y, R);
	glVertex3f(0, y, 0);
	glVertex3f(0, y + h, r);
	glVertex3f(0, y + h, 0);
	glEnd();

	//sciana boczna po plaszczyznie Z
	glBegin(GL_TRIANGLE_STRIP);
	glColor3f(1.0, 0.5, 1.0);
	glVertex3f(0, y + h, 0);
	glVertex3f(0, y, 0);
	glVertex3f(r, y + h, 0);
	glVertex3f(R, y, 0);
	glVertex3f(0, y, 0);
	glEnd();
}


void zmianaMaterialu() {
	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]);
	}
	else 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]);
	}
	else {
		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]);
	}
}

//podstawa
void RysujKolo(float R, float y, int n)
{
	float alfa;
	int i;
	float x;
	float z;

	glColor3f(0.0, 1.0, 1.0);
	glBegin(GL_TRIANGLE_FAN);

	glVertex3f(0, y, 0);

	alfa = 90.0f / n;      //kąt 90 stopni (ćwierć stożka)
	for (i = 0; i <= n; i++)
	{
		x = cos(0.0174532925f * i * alfa);
		z = sin(0.0174532925f * i * alfa);
		glVertex3f(x * R, y + 0, z * R);
	}


	x = cos(0.0);
	z = sin(0.0);

	//glVertex3f(x * R, y + 0, z * R);

	glEnd();
}

/*
void ScianaBoczna(float R, float h)
{
	glColor3f(1, 0.0, 1);   // sciana boczna
	glBegin(GL_TRIANGLE_STRIP);
	glVertex3f(0, h, 0);
	glVertex3f(R, 0, 0);
	glVertex3f(-R, 0, 0);
	glEnd();


}

*/

void RysujStozekZPodzialami(float R, float r, float h, int n, int m)
{
	int i;
	float dR, dr, dh, y, tmp1, tmp2;
	dh = h / m;   // wysokosc nowego stozka
	for (i = 0; i < m; i++)
	{

		y = dh * i;   // poczatkowa wysokosc
		tmp1 = y / h;
		tmp2 = (y + dh) / h;
		dR = R + (r - R) * tmp1;        // promien dolnej podstawy nowego stozka
		dr = R + (r - R) * tmp2;        // promien gornej podstawy nowego stozka
		/*if (i % 2 == 0)
			glColor3f(0.0, 1.0, 1.0);
		else*/
			glColor3f(0.5, 0.5, 1.0);
		RysujStozekBezPodstaw(dR, dr, y, dh, n);
	}
	RysujKolo(R, 0, n);
	RysujKolo(r, h, n);
	// ScianaBoczna(R, h);
}

void RysujStozekSciety()
{

	glBegin(GL_TRIANGLE_FAN);   // gorna podstawa
	glColor3f(0.0, 0.0, 1.0);
	glVertex3f(0, 25, 0);
	for (int i = 0; i * 360 / N <= 360; i++)
	{
		glVertex3f(10 * cos((float)(i * 360 / N) * 3.1415926535 / 180.0), 25, 10 * sin((float)(i * 360 / N) * 3.1415926535 / 180.0));
	}
	glEnd()
		;
	glBegin(GL_TRIANGLE_FAN);   //dolna podstawa
	glColor3f(0.0, 1.0, 0.0);
	glVertex3f(0, 0, 0);
	for (int i = 0; i * 360 / N <= 360; i++)
	{
		glVertex3f(20 * cos((float)(i * 360 / N) * 3.1415926535 / 180.0), 0, 20 * sin((float)(i * 360 / N) * 3.1415926535 / 180.0));
	}
	glEnd();


	glBegin(GL_TRIANGLES);
	glColor3f(1.0, 0.0, 0.0);
	for (int i = 0; i * 360.0 / N <= 360.0; i++)
	{
		glVertex3f(20 * cos((float)(i * 360 / N) * 3.1415926535 / 180.0), 0, 20 * sin((float)(i * 360 / N) * 3.1415926535 / 180.0));
		glVertex3f(10 * cos((float)(i * 360 / N) * 3.1415926535 / 180.0), 25, 10 * sin((float)(i * 360 / N) * 3.1415926535 / 180.0));
		glVertex3f(10 * cos((float)((i + 1) * 360 / N) * 3.1415926535 / 180.0), 25, 10 * sin((float)((i + 1) * 360 / N) * 3.1415926535 / 180.0));

		glVertex3f(20 * cos((float)(i * 360 / N) * 3.1415926535 / 180.0), 0, 20 * sin((float)(i * 360 / N) * 3.1415926535 / 180.0));
		glVertex3f(20 * cos((float)((i+1) * 360 / N) * 3.1415926535 / 180.0), 0, 20 * sin((float)((i+1) * 360 / N) * 3.1415926535 / 180.0));
		glVertex3f(10 * cos((float)((i + 1) * 360 / N) * 3.1415926535 / 180.0), 25, 10 * sin((float)((i + 1) * 360 / N) * 3.1415926535 / 180.0));
	}
	glEnd();
}

void Uklad_wspolrzednych()
{

	// Pocztaek tworzenia ukladu wspolrzednych
	glBegin(GL_LINES);

	// Os X
	glColor3f(1.0, 0.0, 0.0);

	glVertex3f(-25.0, 0.0, 0.0);
	glVertex3f(25.0, 0.0, 0.0);

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

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

	// Koniec tworzenia ukladu wspolrzednych
	glEnd();



	/*
	// Sciany boczne
	glBegin(GL_QUAD_STRIP);
	glVertex3f(a / 2.0, a / 2.0, a / 2.0);
	glVertex3f(a / 2.0, -a / 2.0, a / 2.0);
	glVertex3f(a / 2.0, a / 2.0, -a / 2.0);
	glVertex3f(a / 2.0, -a / 2.0, -a / 2.0);

	glVertex3f(-a / 2.0, a / 2.0, -a / 2.0);
	glVertex3f(-a / 2.0, -a / 2.0, -a / 2.0);

	glVertex3f(-a / 2.0, a / 2.0, a / 2.0);
	glVertex3f(-a / 2.0, -a / 2.0, a / 2.0);

	glVertex3f(a / 2.0, a / 2.0, a / 2.0);
	glVertex3f(a / 2.0, -a / 2.0, a / 2.0);
	glEnd();

	// Gorna sciana
	glBegin(GL_QUAD_STRIP);
	glVertex3f(-a / 2.0, a / 2.0, a / 2.0);
	glVertex3f(a / 2.0, a / 2.0, a / 2.0);
	glVertex3f(-a / 2.0, a / 2.0, -a / 2.0);
	glVertex3f(a / 2.0, a / 2.0, -a / 2.0);
	glEnd();

	// Dolna sciana
	glBegin(GL_QUAD_STRIP);
	glVertex3f(-a / 2.0, -a / 2.0, a / 2.0);
	glVertex3f(a / 2.0, -a / 2.0, a / 2.0);
	glVertex3f(-a / 2.0, -a / 2.0, -a / 2.0);
	glVertex3f(a / 2.0, -a / 2.0, -a / 2.0);
	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);
}

void SwapLineFill(int zm1)
{
	if (zm1 == 1)
		glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
	else
		glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);

}

void SwapShadeModel(int zm2)
{
	if (zm2 == 1)
		glShadeModel(GL_SMOOTH);
	else
		glShadeModel(GL_FLAT);

}
//////////////////////////////////////////////////////////////////////////////////////////
// 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, obsOdl);
	glRotatef(rotObsX, 1, 0, 0);
	glRotatef(rotObsY, 0, 1, 0);
	glRotatef(rotObsZ, 0, 0, 1);
	// Narysowanie szescianu
	Uklad_wspolrzednych();
	//RysujStozekSciety();
	glColor3f(1.0, 1.0, 1.0);
	RysujStozekZPodzialami(5, 0, 5, zmienna, zmienna2);
	SwapLineFill(zm1);
	//SwapShadeModel(zm2);
	// Przelaczenie buforow ramki
	glutSwapBuffers();
}


//////////////////////////////////////////////////////////////////////////////////////////
// Funkcja obslugi klawiatury
void ObslugaKlawiatury(unsigned char klawisz, int x, int y)
{
	switch (klawisz)
	{
		//przybliżanie
	case '+':
	case '=':
		if (obsOdl < minOdl)
			obsOdl++;
		break;
		//oddalanie
	case '-':
	case '_':
		if (obsOdl > maxOdl)
			obsOdl--;
		break;
		//rotacja wokół osi Z
	case 'z':
		rotObsZ++;
		break;

	case 'x':
		rotObsZ--;
		break;
		//zwiekszanie podziałów pionowych
	case '1':
		zmienna = (zmienna > 4) ? zmienna - 1 : zmienna;
		break;
	case '2':
		zmienna = (zmienna < 64) ? zmienna + 1 : zmienna;
		break;
	case '4':
		zmienna2 = (zmienna2 > 4) ? zmienna2 - 1 : zmienna2;
		break;
	case '5':
		zmienna2 = (zmienna2 < 64) ? zmienna2 + 1 : zmienna2;
		break;
	case '&':
		zm1 = 0;
		break;
	case '7':
		zm1 = 1;
		break;
	case '9':
		smooth = !smooth;

		break;
	}
}

void ObslugaKlawiszySpecjalnych(int klawisz, int x, int y)
{
	switch (klawisz)
	{
		//rotacja wokół osi X
	case GLUT_KEY_UP:
		rotObsX++;
		break;

	case GLUT_KEY_DOWN:
		rotObsX--;
		break;
		//rotacja wokół osi Y
	case GLUT_KEY_LEFT:
		rotObsY++;
		break;

	case GLUT_KEY_RIGHT:
		rotObsY--;
		break;
	}
}

//////////////////////////////////////////////////////////////////////////////////////////
// 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 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_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);

	//DOPISANE
	glutSpecialFunc(ObslugaKlawiszySpecjalnych);

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

	return 0;
}