//laby tekstura trójkąt
/*************************************************************************************/

//  Szkielet programu do tworzenia modelu sceny 3-D z wizualizacją osi
//  układu współrzędnych dla rzutowania perspektywicznego

/*************************************************************************************/
#define _USE_MATH_DEFINES
#define _CRT_SECURE_NO_DEPRECATE
#include <windows.h>
#include <gl/gl.h>
#include <gl/glut.h>
#include <iostream>;
#include <time.h>
#include <cmath>
typedef float point3[3];
float ***colors;
float R;
static GLfloat viewer[] = { 0.0, 0.0, R };
static GLfloat theta3[] = { 0.0, 0.0, 0.0 }; // trzy kąty obrotu
// inicjalizacja położenia obserwatora
static GLfloat theta = 0.0;
static GLfloat phi = 0.0;// kąt obrotu obiektu
static GLfloat theta2 = 0.0;
static GLfloat phi2 = 0.0;
static GLfloat pix2angle;     // przelicznik pikseli na stopnie

static GLint status = 0;       // stan klawiszy myszy
							   // 0 - nie naciśnięto żadnego klawisza
							   // 1 - naciśnięty zostać lewy klawisz
static bool widok[] = { true, true, true, true, true };
static int x_pos_old = 0;	// poprzednia pozycja kursora myszy
static int y_pos_old = 0;
static int y_pos_old2 = 0;
static int x_pos_old2 = 0;

static int delta_x = 0;
static int delta_y = 0;// różnica pomiędzy pozycją bieżącą
static int delta_y2 = 0;						// i poprzednią kursora myszy
static int delta_x2 = 0;

int n;
bool en = true;
/*************************************************************************************/


/*************************************************************************************/
// Funkcja wczytuje dane obrazu zapisanego w formacie TGA w pliku o nazwie
// FileName, alokuje pamięć i zwraca wskaźnik (pBits) do bufora w którym
// umieszczone są dane.
// Ponadto udostępnia szerokość (ImWidth), wysokość (ImHeight) obrazu
// tekstury oraz dane opisujące format obrazu według specyfikacji OpenGL
// (ImComponents) i (ImFormat).
// Jest to bardzo uproszczona wersja funkcji wczytującej dane z pliku TGA.
// Działa tylko dla obrazów wykorzystujących 8, 24, or 32 bitowy kolor.
// Nie obsługuje plików w formacie TGA kodowanych z kompresją RLE.
/*************************************************************************************/

GLbyte *LoadTGAImage(const char *FileName, GLint *ImWidth, GLint *ImHeight, GLint *ImComponents, GLenum *ImFormat)
{
	/*************************************************************************************/
	// Struktura dla nagłówka pliku  TGA

#pragma pack(1)
	typedef struct
	{
		GLbyte    idlength;
		GLbyte    colormaptype;
		GLbyte    datatypecode;
		unsigned short    colormapstart;
		unsigned short    colormaplength;
		unsigned char     colormapdepth;
		unsigned short    x_orgin;
		unsigned short    y_orgin;
		unsigned short    width;
		unsigned short    height;
		GLbyte    bitsperpixel;
		GLbyte    descriptor;
	}TGAHEADER;
#pragma pack(8)

	FILE *pFile;
	TGAHEADER tgaHeader;
	unsigned long lImageSize;
	short sDepth;
	GLbyte    *pbitsperpixel = NULL;

	/*************************************************************************************/
	// Wartości domyślne zwracane w przypadku błędu

	*ImWidth = 0;
	*ImHeight = 0;
	*ImFormat = GL_BGR_EXT;
	*ImComponents = GL_RGB8;

	pFile = fopen(FileName, "rb");
	if (pFile == NULL)
		return NULL;
	/*************************************************************************************/
	// Przeczytanie nagłówka pliku

	fread(&tgaHeader, sizeof(TGAHEADER), 1, pFile);

	/*************************************************************************************/
	// Odczytanie szerokości, wysokości i głębi obrazu

	*ImWidth = tgaHeader.width;
	*ImHeight = tgaHeader.height;
	sDepth = tgaHeader.bitsperpixel / 8;

	/*************************************************************************************/
	// Sprawdzenie, czy głębia spełnia założone warunki (8, 24, lub 32 bity)

	if (tgaHeader.bitsperpixel != 8 && tgaHeader.bitsperpixel != 24 && tgaHeader.bitsperpixel != 32)
		return NULL;

	/*************************************************************************************/
	// Obliczenie rozmiaru bufora w pamięci

	lImageSize = tgaHeader.width * tgaHeader.height * sDepth;

	/*************************************************************************************/
	// Alokacja pamięci dla danych obrazu

	pbitsperpixel = (GLbyte*)malloc(lImageSize * sizeof(GLbyte));

	if (pbitsperpixel == NULL)
		return NULL;

	if (fread(pbitsperpixel, lImageSize, 1, pFile) != 1)
	{
		free(pbitsperpixel);
		return NULL;
	}

	/*************************************************************************************/
	// Ustawienie formatu OpenGL

	switch (sDepth)
	{
	case 3:
		*ImFormat = GL_BGR_EXT;
		*ImComponents = GL_RGB8;
		break;
	case 4:
		*ImFormat = GL_BGRA_EXT;
		*ImComponents = GL_RGBA8;
		break;
	case 1:
		*ImFormat = GL_LUMINANCE;
		*ImComponents = GL_LUMINANCE8;
		break;
	};

	fclose(pFile);

	return pbitsperpixel;
}
/*************************************************************************************/


void spin()
{

	theta3[0] -= 0.5;
	if (theta3[0] > 360.0) theta3[0] -= 360.0;

	theta3[1] -= 0.5;
	if (theta3[1] > 360.0) theta3[1] -= 360.0;

	theta3[2] -= 0.5;
	if (theta3[2] > 360.0) theta3[2] -= 360.0;

	glutPostRedisplay(); //odświeżenie zawartości aktualnego okna
}

void Axes(void)
{

	point3  x_min = { -5.0, 0.0, 0.0 };
	point3  x_max = { 5.0, 0.0, 0.0 };
	// pocz?tek i koniec obrazu osi x

	point3  y_min = { 0.0, -5.0, 0.0 };
	point3  y_max = { 0.0, 5.0, 0.0 };
	// pocz?tek i koniec obrazu osi y

	point3  z_min = { 0.0, 0.0, -5.0 };
	point3  z_max = { 0.0, 0.0, 5.0 };
	//  pocz?tek i koniec obrazu osi y

	glColor3f(1.0f, 0.0f, 0.0f);  // kolor rysowania osi - czerwony
	glBegin(GL_LINES); // rysowanie osi x

	glVertex3fv(x_min);
	glVertex3fv(x_max);

	glEnd();

	glColor3f(0.0f, 1.0f, 0.0f);  // kolor rysowania - zielony
	glBegin(GL_LINES);  // rysowanie osi y

	glVertex3fv(y_min);
	glVertex3fv(y_max);

	glEnd();

	glColor3f(0.0f, 0.0f, 1.0f);  // kolor rysowania - niebieski
	glBegin(GL_LINES); // rysowanie osi z

	glVertex3fv(z_min);
	glVertex3fv(z_max);

	glEnd();

}
/*************************************************************************************/

void trojkat(point3 p1, point3 p2, point3 p3) {
	glBegin(GL_TRIANGLES);
	glTexCoord2f(0.0f, 0.0f);
	glVertex3f(p1[0], p1[1], p1[2]);
	glTexCoord2f(1.0f, 0.0f);
	glVertex3f(p2[0], p2[1], p2[2]);
	glTexCoord2f(0.5f, 1.0f);
	glVertex3f(p3[0], p3[1], p3[2]);
	glEnd();

}

void pyramid() {
	point3 p1 = { 2.0, 0.0, 2.0 };
	point3 p2 = { 2.0, 0.0, -2.0 };
	point3 p3 = { -2.0, 0.0, -2.0 };
	point3 p4 = { -2.0, 0.0, 2.0 };
	point3 cz = { 0.0, 5.0, 0.0 };

	if (widok[0]) {
		glBegin(GL_POLYGON);
		glTexCoord2f(0.0f, 0.0f);
		glVertex3f(p4[0], p4[1], p4[2]);
		glTexCoord2f(0.0f, 1.0f);
		glVertex3f(p3[0], p3[1], p3[2]);
		glTexCoord2f(1.0f, 1.0f);
		glVertex3f(p2[0], p2[1], p2[2]);
		glTexCoord2f(1.0f, 0.0f);
		glVertex3f(p1[0], p1[1], p1[2]);
		glEnd();
	}
	if (widok[1])
		trojkat(p1, p2, cz);
	if (widok[2])
		trojkat(p4, p1, cz);
	if (widok[3])
		trojkat(p2, p3, cz);
	if (widok[4])
		trojkat(p3, p4, cz);
	if (en)
		glEnable(GL_CULL_FACE);
	else
		glDisable(GL_CULL_FACE);

}

void Mouse(int btn, int state, int x, int y)
{


	if (btn == GLUT_LEFT_BUTTON && state == GLUT_DOWN)
	{
		x_pos_old = x;        // przypisanie aktualnie odczytanej pozycji kursora
							  // jako pozycji poprzedniej
		y_pos_old = y;
		status = 1;          // wcięnięty został lewy klawisz myszy
	}
	else if (btn == GLUT_RIGHT_BUTTON && state == GLUT_DOWN) {
		y_pos_old2 = y;
		x_pos_old2 = x;
		status = 2;
	}
	else
		status = 0;          // nie został wcięnięty żaden klawisz
}

/*************************************************************************************/
// Funkcja "monitoruje" położenie kursora myszy i ustawia wartości odpowiednich
// zmiennych globalnych

void Motion(GLsizei x, GLsizei y)
{

	delta_x = x - x_pos_old;     // obliczenie różnicy położenia kursora myszy
	delta_y = y - y_pos_old;
	delta_y2 = y - y_pos_old2;
	delta_x2 = x - x_pos_old2;
	x_pos_old = x;          // podstawienie bieżącego położenia jako poprzednie
	y_pos_old = y;
	y_pos_old2 = y;
	x_pos_old2 = x;
	glutPostRedisplay();     // przerysowanie obrazu sceny
}

/*************************************************************************************/

// Funkcja określająca co ma być rysowane (zawsze wywoływana, gdy trzeba
// przerysować scenę)


void RenderScene(void)
{

	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	// Czyszczenie okna aktualnym kolorem czyszczącym

	glLoadIdentity();
	// Czyszczenie macierzy bie??cej



	Axes();
	// Narysowanie osi przy pomocy funkcji zdefiniowanej powyżej

	if (status == 1)                     // jeśli lewy klawisz myszy wcięnięty
	{
		theta -= delta_x*pix2angle*0.1;
		if (theta > 2 * M_PI)
			theta = 0;
		//else if (theta < 0)
		//theta = 2*M_PI;
		phi -= delta_y*pix2angle*0.1;
		if (phi > 2 * M_PI)
			phi = 0;
		else if (phi < 0)
			phi = 2 * M_PI;

		//std::cout<< theta << "  " << phi << "\n";
	}
	if (status == 2) {
		theta2 -= delta_x2*pix2angle*0.1;
		if (theta2 > 2 * M_PI)
			theta2 = 0;
		//else if (theta < 0)
		//theta = 2*M_PI;
		phi2 -= delta_y2*pix2angle*0.1;
		if (phi2 > 2 * M_PI)
			phi2 = 0;
		else if (phi2 < 0)
			phi2 = 2 * M_PI;

	}
	viewer[0] = R*cos(theta)*cos(phi);
	//viewer[1] = R*sin(phi);
	//viewer[2] = R*sin(theta)*cos(phi);

	gluLookAt(viewer[0], viewer[1], viewer[2], 0.0, 0.0, 0.0, 0.0, cos(phi), 0.0);

	GLfloat light_position[] = { viewer[0], viewer[1], viewer[2], 1.0 };
	glLightfv(GL_LIGHT0, GL_POSITION, light_position);
	// Zdefiniowanie położenia obserwatora
	glColor3f(1.0f, 1.0f, 1.0f);
	// Ustawienie koloru rysowania na biały

	//glutWireTeapot(3.0);
	// Narysowanie czajnika
	glTranslated(0.0, -2.5, 0.0);
	point3 p1 = { 2.0, 0.0, 2.0 };
	point3 p2 = { 2.0, 0.0, -2.0 };
	point3 cz = { 0.0, 5.0, 0.0 };
	//trojkat(p1, p2, cz);

	glRotatef(theta3[0], 1.0, 0.0, 0.0);

	glRotatef(theta3[1], 0.0, 1.0, 0.0);

	glRotatef(theta3[2], 0.0, 0.0, 1.0);

	pyramid();
	glFlush();
	// Przekazanie poleceń rysujących do wykonania

	glutSwapBuffers();



}
/*************************************************************************************/

// Funkcja ustalająca stan renderowania

void keys(unsigned char key, int x, int y)
{
	switch (key) {
	case '1':
		if (widok[0])
			widok[0] = false;
		else
			widok[0] = true;
		break;
	case '2':
		if (widok[1])
			widok[1] = false;
		else
			widok[1] = true;
		break;
	case '3':
		if (widok[2])
			widok[2] = false;
		else
			widok[2] = true;
		break;
	case '4':
		if (widok[3])
			widok[3] = false;
		else
			widok[3] = true;
		break;
	case '5':
		if (widok[4])
			widok[4] = false;
		else
			widok[4] = true;
		break;
	case 'a':
		if (en)
			en = false;
		else
			en = true;
	}

	RenderScene(); // przerysowanie obrazu sceny
}

void MyInit(void)
{
	// Zmienne dla obrazu tekstury

	GLbyte *pBytes;
	GLint ImWidth, ImHeight, ImComponents;
	GLenum ImFormat;

	glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
	// Kolor czyszcący (wypełnienia okna) ustawiono na czarny
	/*************************************************************************************/
	//  Definicja materiału z jakiego zrobiony jest czajnik
	//  i definicja źródła światła
	/*************************************************************************************/

	/*************************************************************************************/
	// Definicja materiału z jakiego zrobiony jest czajnik
	/*************************************************************************************/
	// Teksturowanie będzie prowadzone tyko po jednej stronie ściany

	glEnable(GL_CULL_FACE);

	/*************************************************************************************/
	//  Przeczytanie obrazu tekstury z pliku o nazwie tekstura.tga

	pBytes = LoadTGAImage("P6_t.tga", &ImWidth, &ImHeight, &ImComponents, &ImFormat);

	/*************************************************************************************/
	// Zdefiniowanie tekstury 2-D

	glTexImage2D(GL_TEXTURE_2D, 0, ImComponents, ImWidth, ImHeight, 0, ImFormat, GL_UNSIGNED_BYTE, pBytes);

	/*************************************************************************************/
	// Zwolnienie pamięci

	free(pBytes);

	/*************************************************************************************/
	// Włączenie mechanizmu teksturowania

	glEnable(GL_TEXTURE_2D);

	/*************************************************************************************/
	// Ustalenie trybu teksturowania

	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);

	/*************************************************************************************/
	// Określenie sposobu nakładania tekstur

	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	GLfloat mat_ambient[] = { 1.0, 1.0, 1.0, 0.5 };
	// współczynniki ka =[kar,kag,kab] dla światła otoczenia

	GLfloat mat_diffuse[] = { 1.0, 1.0, 1.0, 1.0 };
	// współczynniki kd =[kdr,kdg,kdb] światła rozproszonego

	GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 };
	// współczynniki ks =[ksr,ksg,ksb] dla światła odbitego

	GLfloat mat_shininess = { 35.0 };
	// współczynnik n opisujący połysk powierzchni

	/*************************************************************************************/
	// Definicja źródła światła


	// położenie źródła
	GLfloat light_position[] = { 8.0,2.0, 0.0, 1.0 };
	GLfloat light_ambient[] = { 0.1, 0.1, 0.1, 1.0 };
	// składowe intensywności świecenia źródła światła otoczenia
	// Ia = [Iar,Iag,Iab]

	GLfloat light_diffuse[] = { 1.0, 1.0, 1.0, 1.0 };
	// składowe intensywności świecenia źródła światła powodującego
	// odbicie dyfuzyjne Id = [Idr,Idg,Idb]

	GLfloat light_specular[] = { 1.0, 1.0, 1.0, 1.0 };
	// składowe intensywności świecenia źródła światła powodującego
	// odbicie kierunkowe Is = [Isr,Isg,Isb]

	GLfloat att_constant = { 1.0 };
	// składowa stała ds dla modelu zmian oświetlenia w funkcji
	// odległości od źródła

	GLfloat att_linear = { (float)0.05 };
	// składowa liniowa dl dla modelu zmian oświetlenia w funkcji
	// odległości od źródła

	GLfloat att_quadratic = { (float)0.001 };
	// składowa kwadratowa dq dla modelu zmian oświetlenia w funkcji
	// odległości od źródła

	/*************************************************************************************/
	// Ustawienie parametrów materiału i źródła światła
	/*************************************************************************************/
	// Ustawienie patrametrów materiału

	glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
	glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient);
	glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
	glMaterialf(GL_FRONT, GL_SHININESS, mat_shininess);

	/*************************************************************************************/
	// Ustawienie parametrów źródła

	glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient);
	glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);
	glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular);
	glLightfv(GL_LIGHT0, GL_POSITION, light_position);

	glLightf(GL_LIGHT0, GL_CONSTANT_ATTENUATION, att_constant);
	glLightf(GL_LIGHT0, GL_LINEAR_ATTENUATION, att_linear);
	glLightf(GL_LIGHT0, GL_QUADRATIC_ATTENUATION, att_quadratic);




	// Ustawienie opcji systemu oświetlania sceny

	glShadeModel(GL_SMOOTH); // właczenie łagodnego cieniowania
	glEnable(GL_LIGHTING);   // właczenie systemu oświetlenia sceny
	glEnable(GL_LIGHT0); // włączenie źródła o numerze 0

	glEnable(GL_DEPTH_TEST); // włączenie mechanizmu z-bufora

							 /*************************************************************************************/

}



/*************************************************************************************/

// Funkcja ma za zadanie utrzymanie stałych proporcji rysowanych
// w przypadku zmiany rozmiarów okna.
// Parametry vertical i horizontal (wysokość i szerokość okna) są
// przekazywane do funkcji za każdym razem gdy zmieni się rozmiar okna.



void ChangeSize(GLsizei horizontal, GLsizei vertical)
{
	pix2angle = 360.0 / (float)horizontal;  // przeliczenie pikseli na stopnie
	glMatrixMode(GL_PROJECTION);
	// Przełączenie macierzy bieżącej na macierz projekcji

	glLoadIdentity();
	// Czyszcznie macierzy bieżącej

	gluPerspective(95.0, horizontal / vertical, 1.0, 30.0);
	// Ustawienie parametrów dla rzutu perspektywicznego


	if (horizontal <= vertical)
		glViewport(0, (vertical - horizontal) / 2, horizontal, horizontal);

	else
		glViewport((horizontal - vertical) / 2, 0, vertical, vertical);
	// Ustawienie wielkości okna okna widoku (viewport) w zależności
	// relacji pomiędzy wysokością i szerokością okna

	glMatrixMode(GL_MODELVIEW);
	// Przełączenie macierzy bieżącej na macierz widoku modelu

	glLoadIdentity();
	// Czyszczenie macierzy bieżącej

}

/*************************************************************************************/

// Główny punkt wejścia programu. Program działa w trybie konsoli



void main(void)
{
	R = 5.0;
	n = 40;
	glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);

	glutInitWindowSize(1024, 768);

	glutCreateWindow("Rzutowanie perspektywiczne");
	glutDisplayFunc(RenderScene);
	// Określenie, że funkcja RenderScene będzie funkcją zwrotną
	// (callback function).  Będzie ona wywoływana za każdym razem
	// gdy zajdzie potrzeba przerysowania okna
	glutIdleFunc(spin);

	glutMouseFunc(Mouse);
	// Ustala funkcję zwrotną odpowiedzialną za badanie stanu myszy

	glutMotionFunc(Motion);
	// Ustala funkcję zwrotną odpowiedzialną za badanie ruchu myszy

	glutReshapeFunc(ChangeSize);
	// Dla aktualnego okna ustala funkcję zwrotną odpowiedzialną
	// za zmiany rozmiaru okna

	glutKeyboardFunc(keys);

	MyInit();
	// Funkcja MyInit() (zdefiniowana powyżej) wykonuje wszelkie
	// inicjalizacje konieczne  przed przystąpieniem do renderowania

	glEnable(GL_DEPTH_TEST);
	// Włączenie mechanizmu usuwania niewidocznych elementów sceny

	glutMainLoop();
	// Funkcja uruchamia szkielet biblioteki GLUT



}