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

#define _USE_MATH_DEFINES
#include <iostream>
#include <windows.h>
#include <conio.h>
#include <iostream>
#include <gl/gl.h>
#include <gl/glut.h>
#include <math.h>
#include <conio.h>
#include <ctime>
#include <cstdlib>
using namespace std;

int model = 1;
static GLfloat theta[] = { 0.0, 0.0, 0.0 }; // trzy kąty obrotu
typedef float point3[3];
const int N = 25; // ustalenie stałej N
point3 tab[N][N];


double getx(double u, double v)
{
	return ((-90 * pow(u, 5)) + (225 * pow(u, 4)) - (270 * pow(u, 3)) + (180 * pow(u, 2)) - 45 * u) * cos(M_PI * v);
}

double gety(double u, double v)
{
	return  (160 * pow(u, 4)) - (320 * pow(u, 3)) + (160 * pow(u, 2));
}

double getz(double u, double v)
{
	return ((-90 * pow(u, 5)) + (225 * pow(u, 4)) - (270 * pow(u, 3)) + (180 * pow(u, 2)) - 45 * u) * sin(M_PI * v);
}

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 egg() {

	for (int i = 0; i < N; i++)
		for (int j = 0; j < N; j++)
		{
			double u = double(i) / double(N-1);
			double v = float(j) / double(N-1);

			tab[i][j][0] = getx(u, v);
			tab[i][j][1] = gety(u, v);
			tab[i][j][2] = getz(u, v);

		}


	glTranslated(0, -5, 0);

	/*
		glBegin(GL_POINTS);
		for (int i = 0; i < N; i++)
			for (int j = 0; j < N; j++)
				glVertex3fv(tab[i][j]);

		glEnd();
	}

		glBegin(GL_LINES);
		for (int i = 0; i < N - 1; i++)
			for (int j = 0; j < N - 1; j++) {
				float a = static_cast <float> (rand()) / static_cast <float> (RAND_MAX);
				float b = static_cast <float> (rand()) / static_cast <float> (RAND_MAX);
				float c = static_cast <float> (rand()) / static_cast <float> (RAND_MAX);
				glColor3f(a, b, c);
				glVertex3fv(tab[i][j]);
				glVertex3fv(tab[i][j + 1]);
				glVertex3fv(tab[i][j]);
				glVertex3fv(tab[i + 1][j]);
			}
		glEnd();
	}
	*/
		int help = (N - 1) - 1;
		for (int i = 0; i < (N - 1); i++) {
			for (int j = 0; j < (N - 1); j++) {
				glBegin(GL_TRIANGLES);
				glColor3f(1.0f, 0.0f, 0.0f);
				glVertex3f(tab[i][j][0], tab[i][j][1], tab[i][j][2]);
				glColor3f(0.0f, 1.0f, 0.0f);
				glVertex3f(tab[i][j + 1][0], tab[i][j + 1][1], tab[i][j + 1][2]);
				glColor3f(0.0f, 0.0f, 1.0f);
				glVertex3f(tab[i + 1][j][0], tab[i + 1][j][1], tab[i + 1][j][2]);
				glEnd();

				glBegin(GL_TRIANGLES);
				glColor3f(1.0f, 0.0f, 0.0f);
				glVertex3f(tab[i][j + 1][0], tab[i][j + 1][1], tab[i][j + 1][2]);
				glColor3f(0.0f, 1.0f, 0.0f);
				glVertex3f(tab[i + 1][j + 1][0], tab[i + 1][j + 1][1], tab[i + 1][j + 1][2]);
				glColor3f(0.0f, 0.0f, 1.0f);
				glVertex3f(tab[i + 1][j][0], tab[i + 1][j][1], tab[i + 1][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
	srand(static_cast <unsigned> (time(0)));


	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);
	spinEgg();
	glRotated(30.0, 1.0, 0.0, 0.0);
	egg();


	glFlush();
	glutSwapBuffers();
	//

}

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


void MyInit(void)
{
	glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
}

/*************************************************************************************/
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(600, 600);
	glutCreateWindow("Układ współrzędnych 3-D");
	//glutIdleFunc(spinEgg);
	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

	glutMainLoop();
	// Funkcja uruchamia szkielet biblioteki GLUT

}

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