// Jajko.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 <math.h>


typedef float point3[3];

# define PI_NUMBER           3.14159265358979323846

// Wyliczenie współrzędnej X
float getX(float u, float v)
{
	float result =(-90 * pow(u, 5) + 225 * pow(u, 4) - 270 * pow(u, 3) + 180 * pow(u, 2) - 45 * u) * cos(PI_NUMBER * v);
	return result;
}

// Wyliczenie współrzędnej Y
float getY(float u, float v)
{
	float result = 160 * pow(u, 4) - 320 * pow(u, 3) + 160 * pow(u, 2);
	//return result;
	return (result - 5);
}

// Wyliczenie współrzędnej Z
float getZ(float u, float v)
{
	float result = (-90 * pow(u, 5) + 225 * pow(u, 4) - 270 * pow(u, 3) + 180 * pow(u, 2) - 45 * u) * sin(PI_NUMBER * v);
	return result;
}

// Liczba na ile punktow dzielimy bok dziedziny
int N = 50;

// Tablica punktów jajka
float ***calculatedPoints;
// Użyte kolory
int ***usedColors;

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


// Obsługa klawiatury
void keys(unsigned char key, int x, int y)
{
	if (key == 'p') model = 1;
	if (key == 'w') model = 2;
	if (key == 's') model = 3;
}



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 EggPoints()
{
	calculatedPoints = new float **[N];

	// Pętla po pionie
	for (int i = 0; i < N; i++)
	{
		calculatedPoints[i] = new float *[N];
		float u = (float)i / (N - 1);

		// Pętla po pozimie
		for (int k = 0; k < N; k++)
		{
			float v = (float) k / (N - 1);

			float x = getX(u, v);
			float y = getY(u, v);
			float z = getZ(u, v);

			// Zapis danych do tablicy
			calculatedPoints[i][k] = new float[3];
			calculatedPoints[i][k][0] = x;
			calculatedPoints[i][k][1] = y;
			calculatedPoints[i][k][2] = z;
		}
	}
}

// Wyświetlenie jajka zrobionego z punktów
void EggPointsDraw()
{
	glColor3f(1.0f, 1.0f, 1.0f);

	// Wyświetlenie jajka z punktów
	for (int i = 0; i < N; i++)
	{
		for (int k = 0; k < N; k++)
		{
			glBegin(GL_POINTS);
			glVertex3f(calculatedPoints[i][k][0], calculatedPoints[i][k][1], calculatedPoints[i][k][2]);
			glEnd();
		}
	}
}


void EggLinesDraw()
{
	glColor3f(1.0f, 1.0f, 1.0f);

	for (int i = 0; i < N; i++)
	{
		int NextI = i + 1;

		for (int k = 0; k < N; k++)
		{
			int NextK = k + 1;

			// Jeśli koniec zakresu
			if (NextK == N)
			{
				NextK = 0;
			}
			if (NextI == N)
			{
				NextI = 0;
			}

			// Pierwszy punkt odcinka
			float *firstPoint = calculatedPoints[i][k];
			// Drugi punkt odcinka
			float *nextPoint = calculatedPoints[i][NextK];

			// 1 prosta
			glBegin(GL_LINES);
			glVertex3f(firstPoint[0], firstPoint[1], firstPoint[2]);
			glVertex3f(nextPoint[0], nextPoint[1], nextPoint[2]);
			glEnd();

			// 2 prosta
			nextPoint = calculatedPoints[NextI][k];
			glBegin(GL_LINES);
			glVertex3f(firstPoint[0], firstPoint[1], firstPoint[2]);
			glVertex3f(nextPoint[0], nextPoint[1], nextPoint[2]);
			glEnd();

			// 3 prosta
			nextPoint = calculatedPoints[NextI][NextK];
			glBegin(GL_LINES);
			glVertex3f(firstPoint[0], firstPoint[1], firstPoint[2]);
			glVertex3f(nextPoint[0], nextPoint[1], nextPoint[2]);
			glEnd();
		}
	}
}



void EggTrianglesDraw()
{
	usedColors = new int **[N];

	for (int i = 0; i < N; i++)
	{
		int NextI = i + 1;

		usedColors[i] = new int *[N];

		for (int k = 0; k < N; k++)
		{
			int NextK = k + 1;

			// Jeśli koniec zakresu
			if (NextK == N)
			{
				NextK = 0;
			}
			if (NextI == N)
			{
				NextI = 0;
			}

			// Losowy kolor
			int *color = new int[3];
			color[0] = rand() % 255;
			color[1] = rand() % 255;
			color[2] = rand() % 255;

			usedColors[i][k] = color;

			float *firstPoint = calculatedPoints[i][k];
			float *secondPoint = calculatedPoints[NextI][k];
			float *thirdPoint = calculatedPoints[i][NextK];
			float *fourthPoint = calculatedPoints[NextI][NextK];

			// Pierwszy z trójkątów - dolny
			glBegin(GL_TRIANGLES);
			// Rysowanie trójkątów
			glColor3ub(color[0], color[1], color[2]);
			glVertex3f(firstPoint[0], firstPoint[1], firstPoint[2]);
			glColor3ub(color[0], color[2], color[1]);
			glVertex3f(secondPoint[0], secondPoint[1], secondPoint[2]);
			glColor3ub(color[1], color[0], color[2]);
			glVertex3f(thirdPoint[0], thirdPoint[1], thirdPoint[2]);
			glEnd();


			// Drugi z trójkątów - górny
			glBegin(GL_TRIANGLES);
			// Rysowanie trójkątów
			glColor3ub(color[0], color[1], color[2]);
			glVertex3f(secondPoint[0], secondPoint[1], secondPoint[2]);
			glColor3ub(color[0], color[2], color[1]);
			glVertex3f(thirdPoint[0], thirdPoint[1], thirdPoint[2]);
			glColor3ub(color[1], color[0], color[2]);
			glVertex3f(fourthPoint[0], fourthPoint[1], fourthPoint[2]);
			glEnd();
		}
	}
}






// 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)
{
	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 wyżej

	// Wyliczenie punktów jajka
	EggPoints();

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

	// Wybór pomiędzy rysowaniem punktów/linii/trójkątów
	//EggTrianglesDraw();
	//EggLinesDraw();
	EggPointsDraw();

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

	// Włączenie obsługi klawiatury
	//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 powierzchni niewidocznych




	glutIdleFunc(spinEgg);




	glutMainLoop();
	// Funkcja uruchamia szkielet biblioteki GLUT

}

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