// Perspektywa.cpp : This file contains the 'main' function. Program execution begins and ends there.
//

#include "pch.h"
#include <iostream>
#include <windows.h>
#include <gl/gl.h>
#include <gl/glut.h>
#include <cmath>


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

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

/*************************************************************************************/
# define M_PI           3.14159265358979323846  /* pi */


typedef float point3[3];

static GLfloat viewer[] = { 0.0, 0.0, 10.0 };
//static GLfloat viewer[] = { 3.0, 3.0, 10.0 };


// Kąt obroty obiektu wokół osi Y
static GLfloat thetaY = 0.0;

// Kąt obrotu obiektu wokół osi X
static GLfloat thetaX = 0.0;

// Skala
static GLfloat scale = 1.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




// Stara pozycja w płaszczyźnie X
static int x_pos_old = 0;

// Stara pozycja w płaszczyźnie Y
static int y_pos_old = 0;

// Stara pozycja w płaszczyźnie Z - DLA ZOOMA
static int z_pos_old = 0;


// Zmiana pomiedzy ruszaniem imbryczka, a kamery
int model = 1;

// Odległość
float R = 10;



// Różnica poruszenia myszką prawo lewo
static int delta_x = 0;        // różnica pomiędzy pozycją bieżącą
									  // i poprzednią kursora myszy


// Różnica poruszenia myszką góra dół
static int delta_y = 0;

// Różnica poruszenia myszką góra dół - DLA ZOOMA
static int delta_z = 0;


// inicjalizacja położenia obserwatora

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


/*************************************************************************************/
// Funkcja "bada" stan myszy i ustawia wartości odpowiednich zmiennych globalnych
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)
		{
			// Przypisanie starej pozycji myszki
			z_pos_old = y;

			status = 2;
		}
		else status = 0;          // nie został wcięnięty żaden klawisz
}



void keys(unsigned char key, int x, int y)
{
	if (key == 'p') model = 1;
	if (key == 'k') model = 2;
}


/*************************************************************************************/
// 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_z = (y - z_pos_old) * 0.5;

	x_pos_old = x;            // podstawienie bieżącego położenia jako poprzednie
	y_pos_old = y;
	z_pos_old = y;

	glutPostRedisplay();     // przerysowanie obrazu sceny
}



// Funkcja rysująca osie układu wspó?rz?dnych
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();

}

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

// Funkcja określająca co ma być rysowane (zawsze wywoływana, gdy trzeba
// przerysować scenę)
void RenderScene(void)
{
	if (model == 1)
	{
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
		// Czyszczenie okna aktualnym kolorem czyszczącym
		glLoadIdentity();
		// Czyszczenie macierzy bieżącej
		gluLookAt(viewer[0], viewer[1], viewer[2], 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
		// Zdefiniowanie położenia obserwatora
		Axes();
		// Narysowanie osi przy pomocy funkcji zdefiniowanej powyżej

		if (status == 1)    // jeśli lewy przycisk myszy wcięnięty
		{
			// Modyfikacja kąta Y
			thetaY += delta_x * pix2angle;    // modyfikacja kąta obrotu o kat proporcjonalny do różnicy położeń kursora myszy

			// Modyfikacja kąta X
			thetaX += delta_y * pix2angle;
		}

		if (status == 2)
		{
			// Modyfikacja zooma
			scale += delta_z * pix2angle;
		}

		// Obrót wokół osi Y
		glRotatef(thetaY, 0.0, 1.0, 0.0);

		// Obrót wokół osi X
		glRotatef(thetaX, 1.0, 0.0, 0.0);

		// Przeskalowanie obrazu
		glScalef(scale, scale, scale);
		glColor3f(1.0f, 1.0f, 1.0f);
		// Ustawienie koloru rysowania na biały
		glutWireTeapot(3.0);
		// Narysowanie czajnika
		glFlush();
		// Przekazanie poleceń rysujących do wykonania
		glutSwapBuffers();
	}

	if (model == 2)
	{
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
		// Czyszczenie okna aktualnym kolorem czyszczącym

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

		if (status == 1)  // Jeśli lewy przycisk myszy wcięnięty
		{
			// Modyfikacja kąta Y
			thetaY += delta_x * pix2angle * 0.5;

			// Modyfikacja kąta X
			thetaX += delta_y * pix2angle * 0.5;
		}

		if (status == 2)
		{
			R += delta_y;
			if (R < 3)R = 15;
			if (R > 15) R = 3;
		}

		viewer[0] = R * cos(thetaX * (M_PI / 2)) * cos(thetaY * (M_PI / 2));
		viewer[1] = R * cos(thetaY * (M_PI / 2));
		viewer[2] = R * sin(thetaX * (M_PI / 2)) * cos(thetaY * (M_PI / 2));

		gluLookAt(viewer[0], viewer[1], viewer[2], 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
		// Zdefiniowanie położenia obserwatora

		Axes();
		// Narysowanie osi przy pomocy funkcji zdefiniowanej powyżej
		glColor3f(1.0f, 1.0f, 1.0f);
		// Ustawienie koloru rysowania na biały
		glutWireTeapot(3.0);
		// Narysowanie czajnika
		glFlush();
		// Przekazanie poleceń rysujących do wykonania
		glutSwapBuffers();
	}

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

// Funkcja ustalająca stan renderowania



void MyInit(void)
{

	glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
	// Kolor czyszczący (wypełnienia okna) ustawiono na czarny

}

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

// 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(70, 1.0, 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)
{

	glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);

	glutInitWindowSize(300, 300);

	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



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



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



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

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



	glutKeyboardFunc(keys);

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

	glutMainLoop();
	// Funkcja uruchamia szkielet biblioteki GLUT

}

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