#pragma warning(disable : 4996)

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

// Definicja stalych
#define OBSERWATOR_FOV_Y        10.0
#define odlmin 10.0
#define odlmax 300.0

#define M_PI				3.14159
#define DEG2RAD(x)       ((float)(x)*M_PI/180.0)

// Zmienne globalne
int     szerokoscOkna = 800;
int     wysokoscOkna = 600;

GLfloat odl = 200.0;
GLfloat rotObsX = 40.0;
GLfloat rotObsY = 40.0;
GLfloat rotObsZ = 0.0;

int iloscpodzialowpoziomych = 12;
int zrodlo1 = 1;
int zrodlo2 = 1;
int obecnymaterial = 0;
int normalne = 1;
int smooth = 1;
int fill = 1;
float length;

float lPionowych = 10;         // Liczba podzialow pionowych
float lPoziomych = 10;         // Liczba podzialow poziomych
float promien = 3.0;        // Promien walca
float wysokosc = 3.0;        // Wysokosc walca
int zmienna = 5;
int zmienna2 = 5;

int a = 3;
double h = 5;
int R = 6;
int r = 8;
int n = 40;
int nMin = 4;
int nMax = 64;
double dAlfa;
int i = 0, j;
int N1 = 20;
int N2 = 10;
int rW = 15;
int rZ;
int srA;

float r_reflektor = 30;
float predkosc_reflektor = 0.1;
float nachylenie_reflektor = 0;
float kat_reflektor = 0;

float material1[5][4] = {
	{0, 0, 1, 1.0},// [0] wspolczynnik odbicia swiatla otoczenia
	{0, 0, 1, 1.0},// [1] wspolczynnik odbicia swiatla rozproszonego
	{0, 0, 1, 1.0},// [2] wspolczynnik odbicia swiatla lustrzanego
	{6,0,0,0},           // [3] polysk
	{0,0,0.0,1.0}    // [4] kolor swiatla emitowanego
};
// Tablica parametrow materialu nr 2
float material2[5][4] = {
	  {1, 1,0, 1},  // [0] wspolczynnik odbicia swiatla otoczenia
	  {1, 1,0, 1.0},  // [1] wspolczynnik odbicia swiatla rozproszonego
	  {0.1, 0.1,0, 1.0},  // [2] wspolczynnik odbicia swiatla lustrzanego
	  {10, 0.0, 0.0, 0.0},  // [3] polysk
	  {0.0, 0.0, 0.0, 1.0}   // [4] kolor swiatla emitowanego
};

//reflektor
GLfloat param_swiatla1[5][4] = {
	{1,1,1,1},   // [0] światło otoczenia
	{1,1,1,1},   // [1] światło rozproszone
	{1,1,1,1},   // [2] światło zwierciadlane
	{0,0,0,1},   // [3] położenie
	{-1,0,0}     // [4] kierunek świecenia
};

//kierunkowe
GLfloat param_swiatla2[5][4] = {
	{0,0.7,0,1},   // [0] światło otoczenia
	{0,0.7,0,1},   // [1] światło rozproszone
	{0,0.7,0,1},   // [2] światło zwierciadlane
	{10,10,10,0},   // [3] położenie
	{0,0,0,0}      // [4] kierunek świecenia
};


// Prototypy funkcji
void UstawParametryWidoku(int szer, int wys);
void WyswietlObraz(void);
void ObslugaKlawiatury(unsigned char klawisz, int x, int y);
void RysujTekstRastrowy(void* font, char* tekst);
void RysujNakladke(void);

void UstawSwiatlaIMaterialy()
{
	glEnable(GL_LIGHTING);
	// Odblokowanie zrodla swiatla nr 1


	if (zrodlo1 == 1)
	{
		glDisable(GL_LIGHTING);
		glPushMatrix();

		glRotatef(nachylenie_reflektor, 1, 0, 0);
		glBegin(GL_LINE_STRIP);
		glColor3f(0, 0, 0);
		for (int i = 0; i <= 360; i = i + 2)
		{
			glVertex3f(r_reflektor * cos(DEG2RAD(i)), 0, r_reflektor * sin(DEG2RAD(i)));
		}
		glEnd();
		glPopMatrix();

		glPushMatrix();

		glRotatef(nachylenie_reflektor, 1, 0, 0);
		glRotatef(kat_reflektor, 0, 1, 0);
		glTranslatef(r_reflektor, 0, 0);


		glColor3f(1, 1, 0);
		glutSolidSphere(0.3, 5, 5);
		glEnable(GL_LIGHTING);

		glEnable(GL_LIGHT0);

		// Inicjowanie zrodla swiatla
		glLightfv(GL_LIGHT0, GL_DIFFUSE, param_swiatla1[1]);
		glLightfv(GL_LIGHT0, GL_SPECULAR, param_swiatla1[2]);
		glLightfv(GL_LIGHT0, GL_POSITION, param_swiatla1[3]);
		glLightf(GL_LIGHT0, GL_SPOT_CUTOFF, 30);
		glLightfv(GL_LIGHT0, GL_SPOT_DIRECTION, param_swiatla1[4]);

		glPopMatrix();
	}
	else {
		glDisable(GL_LIGHT0);
	}

	if (zrodlo2 == 1)
	{
		glEnable(GL_LIGHT1);

		// Inicjowanie zrodla swiatla
		glLightfv(GL_LIGHT1, GL_DIFFUSE, param_swiatla2[1]);
		glLightfv(GL_LIGHT1, GL_SPECULAR, param_swiatla2[2]);
		glLightfv(GL_LIGHT1, GL_POSITION, param_swiatla2[3]);
		glLightfv(GL_LIGHT1, GL_SPOT_DIRECTION, param_swiatla2[4]);
	}
	else {
		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, PolishedSilverAmbient);
		glMaterialfv(GL_FRONT, GL_DIFFUSE, PolishedSilverDiffuse);
		glMaterialfv(GL_FRONT, GL_SPECULAR, PolishedSilverSpecular);
		glMaterialfv(GL_FRONT, GL_SHININESS, &PolishedSilverShininess);
		glMaterialfv(GL_FRONT, GL_EMISSION, material2[4]);
		break;
	default:
		break;
	}
}

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

void wektory(float R, float h, int n, int m)
{

	glDisable(GL_LIGHTING);

	glBegin(GL_LINES);
	glColor3f(1, 0, 0);

	float alfa;
	int i;
	float x;
	float z;
	float dR, dr, dh, y, tmp1, tmp2;
	dh = h / m;


	for (i = 0; i < m; i++)
	{
		y = dh * i;
		tmp1 = y / h;
		tmp2 = (y + dh) / h;

		alfa = 360.0 / n;
		for (j = 0; j <= n; j++)
		{
			x = cos(0.0174532925f * j * alfa);
			z = sin(0.0174532925f * j * alfa);

			glVertex3f(x * R, y, z * R);
			glVertex3f((x) * (R+1), y, (z) * (R + 1));
		}
	}


	alfa = 360.0 / n;
	glVertex3f(0, h, 0);
	glVertex3f(0, h+1, 0);
	for (i = 0; i <= n; i++)
	{
		x = cos(0.0174532925f * i * alfa);
		z = sin(0.0174532925f * i * alfa);

		glVertex3f(x * R, h, z * R);
		glVertex3f((x) * R, h + 1, (z) * R);
	}

	glVertex3f(0, 0, 0);
	glVertex3f(0, -1, 0);
	for (i = 0; i <= n; i++)
	{
		x = cos(0.0174532925f * i * alfa);
		z = sin(0.0174532925f * i * alfa);

		glVertex3f(x * R, 0, z * R);
		glVertex3f((x)*R, -1, (z)*R);
	}

	glEnd();
	glEnable(GL_LIGHTING);
}

void powBocznaWalca(float R, float y, float h, int n)
{
	float alfa;
	int i;
	float x;
	float z;
	glColor3f(0, 1, 1);
	glBegin(GL_QUAD_STRIP);

	alfa = 360.0 / n;
	for (i = 0; i <= n; i++)
	{
		x = cos(0.0174532925f * i * alfa);
		z = sin(0.0174532925f * i * alfa);
		glNormal3f(x, 0, z);
		glVertex3f(x * R, y + 0, z * R);
		glVertex3f(x * R, y + h, z * R);
	}

	glEnd();
}

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

	glBegin(GL_TRIANGLE_FAN);
	glVertex3f(0, y, 0);

	alfa = 360.0f / n;
	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 rysowanieWalca(float R, float h, int n, int m) {
	int i;
	float dR, dr, dh, y, tmp1, tmp2;
	dh = h / m;
	for (i = 0; i < m; i++)
	{
		y = dh * i;
		tmp1 = y / h;
		tmp2 = (y + dh) / h;
		powBocznaWalca(R, y, dh, n);
	}

	glNormal3f(0, -1, 0);
	RysujKolo(R, 0, n);
	glNormal3f(0, 1, 0);
	RysujKolo(R, h, n);

}

//////////////////////////////////////////////////////////////////////////////////////////
// Funkcja ustawiajaca parametry rzutu perspektywicznego i rozmiary viewportu. Powinna
// bya 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, -odl);
	glRotatef(rotObsX, 1, 0, 0);
	glRotatef(rotObsY, 0, 1, 0);
	glRotatef(rotObsZ, 0, 0, 1);


	UstawSwiatlaIMaterialy();
	//RysujUklad();
	//glColor3f(1.0, 1.0, 1.0);
	//RysujPierscien(10, 4, iloscpodzialowpoziomych);
	kat_reflektor = kat_reflektor + predkosc_reflektor;
	rysowanieWalca(promien, wysokosc, N1, N2);
	RysujNakladke();
	if (normalne)
		wektory(promien, wysokosc, N1, N2);


	// Przelaczenie buforow ramki
	glutSwapBuffers();
}

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 ZRODLA SWIATLA

	sprintf(buf, "Swiatlo: Klawisze 3, 4");
	glRasterPos2i(30, 150);
	RysujTekstRastrowy(GLUT_BITMAP_8_BY_13, buf);

	sprintf(buf, "Zobrazowanie geometryczne: Klawisz 7");
	glRasterPos2i(30, 140);
	RysujTekstRastrowy(GLUT_BITMAP_8_BY_13, buf);

	sprintf(buf, "Material: Klawisz 5");
	glRasterPos2i(30, 130);
	RysujTekstRastrowy(GLUT_BITMAP_8_BY_13, buf);

	sprintf(buf, "Podzialy poziome: 1+,!- pionowe: 2+,@-");
	glRasterPos2i(30, 120);
	RysujTekstRastrowy(GLUT_BITMAP_8_BY_13, buf);

	sprintf(buf, "Odleglosc z+ x-");
	glRasterPos2i(30, 110);
	RysujTekstRastrowy(GLUT_BITMAP_8_BY_13, buf);

	sprintf(buf, "Wygladzanie 6");
	glRasterPos2i(30, 100);
	RysujTekstRastrowy(GLUT_BITMAP_8_BY_13, buf);

	sprintf(buf, "polygon mode 7");
	glRasterPos2i(30, 90);
	RysujTekstRastrowy(GLUT_BITMAP_8_BY_13, buf);

	sprintf(buf, "wektory normalne 8");
	glRasterPos2i(30, 80);
	RysujTekstRastrowy(GLUT_BITMAP_8_BY_13, buf);

	sprintf(buf, "promien reflektora i+/j-");
	glRasterPos2i(30, 70);
	RysujTekstRastrowy(GLUT_BITMAP_8_BY_13, buf);

	sprintf(buf, "predkosc reflektora o+/k-");
	glRasterPos2i(30, 60);
	RysujTekstRastrowy(GLUT_BITMAP_8_BY_13, buf);

	sprintf(buf, "kat reflektora p+/l-");
	glRasterPos2i(30, 50);
	RysujTekstRastrowy(GLUT_BITMAP_8_BY_13, buf);

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

	// Odblokowanie oswietlenia
	glEnable(GL_LIGHTING);
}

//////////////////////////////////////////////////////////////////////////////////////////
// Funkcja obslugi klawiatury
void ObslugaKlawiatury(unsigned char klawisz, int x, int y)
{
	switch (klawisz)
	{
		//Odległość obserwatora
	case 'z':
		odl = odl > odlmin ? odl - 3.0 : odl;
		break;
	case 'x':
		odl = odl < odlmax ? odl + 3.0 : odl;
		break;
		//

		//Podziały pierścienia
	case '1':
		if (N1 < nMax) N1++;
		break;
	case '!':
		if (N1 > nMin) N1--;
		break;
	case '2':
		if (N2 < nMax) N2++;
		break;
	case '@':
		if (N2 > nMin) N2--;
		break;

		//Źródła światła
	case '3':
		zrodlo1 = !zrodlo1;
		break;
	case '4':
		zrodlo2 = !zrodlo2;
		break;

		//Zmiana materiału bryły
	case '5':
		obecnymaterial++;
		if (obecnymaterial > 2) obecnymaterial = 0;
		break;
		//

		//Cieniowanie
	case '6':
		smooth = !smooth;
		SyncSmoothIFill();
		break;

	case '7':
		fill = !fill;
		SyncSmoothIFill();
		break;
		//

	case '8':
		normalne = !normalne;
		break;

		//Poruszanie się obserwatora
	case 'q':
	case 'Q':
		rotObsZ = rotObsZ + 1.0;
		break;
	case 'e':
	case 'E':
		rotObsZ = rotObsZ - 1.0;
		break;
	case 'w':
	case 'W':
		rotObsX = rotObsX + 1.0;
		break;
	case 's':
	case 'S':
		rotObsX = rotObsX - 1.0;
		break;
	case 'a':
	case 'A':
		rotObsY = rotObsY - 1.0;
		break;
	case 'd':
	case 'D':
		rotObsY = rotObsY + 1.0;
		break;
		//


	case 'i':
		r_reflektor++;
		break;
	case 'j':
		r_reflektor--;
		break;
	case 'o':
		predkosc_reflektor = predkosc_reflektor + 0.1;
		break;
	case 'k':
		predkosc_reflektor = predkosc_reflektor - 0.1;
		break;
	case 'p':
		nachylenie_reflektor = nachylenie_reflektor + 1;
		break;
	case 'l':
		nachylenie_reflektor = nachylenie_reflektor - 1;
		break;

	case 27:
		exit(0);
		break;
	default:
		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_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;
}