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

//  Szkielet programu do tworzenia modelu sceny 3-D z wizualizacją osi
//  układu współrzednych

/*************************************************************************************/
#include "pch.h"
#include <windows.h>
#include <gl/gl.h>
#include <gl/glut.h>
#include <math.h>
#include <iostream>
using namespace std;
typedef float point3[3];
const int n=20;
point3 tab[n][n];
int model = 1;  // 1- punkty, 2- siatka, 3 - wypełnione trójkąty
static GLfloat theta[] = { 0.0, 0.0, 0.0 }; // trzy kąty obrotu
/*************************************************************************************/

// Funkcja rysująca osie układu współrzędnych
float Xfunction(float u, float v) {
	return((-90 * pow(u, 5) + 225 * pow(u, 4) - 270 * pow(u, 3) + 180 * pow(u, 2) - 45 * u)*cos(3.1415 * v));
}

float Yfunction(float u, float v) {
	return(160 * pow(u, 4) - 320 * pow(u, 3) + 160 * pow(u, 2));
}
float Zfunction(float u, float v) {
	return((-90 * pow(u, 5) + 225 * pow(u, 4) - 270 * pow(u, 3) + 180 * pow(u, 2) - 45 * u)*sin(3.1415 * v));
}
void fillTable()
{
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < n; j++) {
			float u=float(i)/float(n);
			float v=float(j)/float(n);
			tab[i][j][0] = Xfunction(u, v);
			tab[i][j][1] = Yfunction(u, v);
			tab[i][j][2] = Zfunction(u, v);
		}
	}
}
void drawEgg() {
glRotatef(theta[0], 1.0, 0.0, 0.0);
glRotatef(theta[1], 0.0, 1.0, 0.0);
glRotatef(theta[2], 0.0, 0.0, 1.0);
glTranslated(0, -4,0); // obniżenie pozyji jajka tak aby było bliżej środka
glRotated(60.0, 1.0, 1.0, 1.0); // obrócenie jajka tak aby lepiej było widać jego poziomy
fillTable();
for (int i=0; i < n; i++) {
	for (int j = 0; j < n; j++) {
		glBegin(GL_POINTS);
		glVertex3f(tab[i][j][0], tab[i][j][1], tab[i][j][2]);
		glEnd();
	}
}
}

void drawEgg2() {
	glRotatef(theta[0], 1.0, 0.0, 0.0);

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

	glRotatef(theta[2], 0.0, 0.0, 1.0);
	glTranslated(0, -4, 0); // obniżenie pozyji jajka tak aby było bliżej środka
	fillTable();
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < n; j++) {
			glBegin(GL_LINES);
			glVertex3f(tab[i][j][0], tab[i][j][1], tab[i][j][2]);
			if(j<n-1 && i <n-1)
			glVertex3f(tab[i][j][1], tab[i][j][2], tab[i][j][2]);
			glEnd();
		}
	}
}
// 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
	if (model == 1) {
		drawEgg();
		// Narysowanie osi przy pomocy funkcji zdefiniowanej wyżej
	}
	glFlush();
	// Przekazanie poleceń rysujących do wykonania
	if (model == 2)
	{
		drawEgg2();
	}
	if (model == 3)
	{

	}
	glutSwapBuffers();
	//

}

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

// Funkcja ustalająca stan renderowania

void spinEgg()
{

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

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

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

	glutPostRedisplay(); //odświeżenie zawartości aktualnego okna
}
void keys(unsigned char key, int x, int y)
{
	if (key == 'p') model = 1;
	if (key == 'w') model = 2;
	if (key == 's') model = 3;

	RenderScene(); // przerysowanie obrazu sceny
}

void MyInit(void)
{

	glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
	// Kolor czyszcą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)
{

	GLfloat AspectRatio;
	// Deklaracja zmiennej AspectRatio  określającej proporcję
	// wymiarów okna

	if (vertical == 0)  // Zabezpieczenie przed dzieleniem przez 0

		vertical = 1;

	glViewport(0, 0, horizontal, vertical);
	// Ustawienie wielkościokna okna widoku (viewport)
	// W tym przypadku od (0,0) do (horizontal, vertical)

	glMatrixMode(GL_PROJECTION);
	// Przełączenie macierzy bieżącej na macierz projekcji

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

	AspectRatio = (GLfloat)horizontal / (GLfloat)vertical;
	// Wyznaczenie współczynnika  proporcji okna
	// Gdy okno nie jest kwadratem wymagane jest określenie tak zwanej
	// przestrzeni ograniczającej pozwalającej zachować właściwe
	// proporcje rysowanego obiektu.
	// Do okreslenia przestrzeni ograniczjącej służy funkcja
	// glOrtho(...)

	if (horizontal <= vertical)

		glOrtho(-7.5, 7.5, -7.5 / AspectRatio, 7.5 / AspectRatio, 10.0, -10.0);

	else

		glOrtho(-7.5*AspectRatio, 7.5*AspectRatio, -7.5, 7.5, 10.0, -10.0);

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

	glLoadIdentity();
	// Czyszcenie 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("Układ współrzędnych 3-D");

	glutDisplayFunc(RenderScene);
	// Określenie, że funkcja RenderScene będzie funkcją zwrotną
	// (callback function).  Bedzie ona wywoływana za każdym razem
	// gdy zajdzie potrzba przeryswania okna

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

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

	glEnable(GL_DEPTH_TEST);
	// Włączenie mechanizmu usuwania powierzchni niewidocznych
	glutKeyboardFunc(keys);

	glutIdleFunc(spinEgg);


	glutMainLoop();
	// Funkcja uruchamia szkielet biblioteki GLUT

}

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