/*************************************************************************************/
//  Szkielet programu do tworzenia modelu sceny 3-D z wizualizacją osi
//  układu współrzednych
/*************************************************************************************/
#define _USE_MATH_DEFINES
#include "trojkat_sierpinskiego.h"
#include <windows.h>
#include <gl/gl.h>
#include <glut.h>
#include <cstdlib>
#include <ctime>
#include <cmath>
#define M_PI 3.14

//Definicja typu point3 - punkt w przestrzeni 3D
typedef float point3[3];

//Stala PI
const float PI = 3.14159265;
//Tablica na punkty
point3 **pointsTab;
//Tablica na kolory punktow
point3 **pointsRGB;

static GLfloat viewer[] = { 0.0, 0.0, 10.0 };
// inicjalizacja położenia obserwatora
 int S = 25;					//zmienne to zageszczania wykresu lub rozredzania


static GLfloat  fi = 0.0;       // kąty obrotu, elewacja i azymut
static GLfloat  pix2angle_x,    // przelicznik pikseli na stopnie
pix2angle_y;
static GLint    status = 0;     // stan klawiszy myszy
								// 0 - nie naciśnięto żadnego klawisza
								// 1 - naciśnięty został lewy klawisz, 2 - prawy
static int  x_pos_old = 0,        // poprzednia pozycja kursora myszy
y_pos_old = 0;
static int  delta_x = 0,        // różnica pomiędzy pozycją bieżącą
delta_y = 0;        // i poprzednią kursora myszy
static GLfloat R = 30.0;
typedef float point3[3];
typedef float point2[2];
point2 tab2D[10000];
point3 tab[7][10000];
int N = 20;
static GLfloat zoom = 0.0;
bool move = true;
static GLfloat theta = 0;
float verLength = 1.0;  //Dlugosc boku kwadratu
float viewerR = 10.0;   //Promien sfery obserwatora

						/*************************************************************************************/
						// Funkcja rysująca osie układu współrzędnych

void Axes(void) {
	// początek i koniec obrazu osi x
	point3 x_min = { -5.0, 0.0, 0.0 };
	point3 x_max = { 5.0, 0.0, 0.0 };

	// początek i koniec obrazu osi y
	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 };

	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 zwracająca wartość (y) funkcji weierstrassa w punkcie x
float weierstrass(float a, float x)
{
	float wynik = 0;
	for (int k = 1; k <= 20; k++)
	{
		wynik += sin(3.14*pow(k, a)*x) / (3.14*pow(k, a));
	}
	return wynik;
}

// funkcja generująca współrzędne 2D (wykres funkcji weierstrassa)
void generuj_tab2D(float a)
{
	float x = 0;
	float s = 1.0/S;
	float mn = 10;
	for (int i = 0; i <S-1; i++)
	{
		tab2D[i][0] = x * mn;
		tab2D[i][1] = mn * weierstrass(a, x);
		x +=s ;
	}
	tab2D[S - 1][0] = x * mn;
	tab2D[S - 1][1] = 0;
}

// funkcja obracająca wykres wokół OX (rzutowanie na 3D)
void generuj_3D()
{
	for (int j = 0; j < 7; j++)
	{
		for (int i = 0; i < S; i++)
		{
			tab[j][i][0] = tab2D[i][0];
			// generowanie współrzędnych dla kolejnych kątów obrotu
			// zaczynając od 0 skacząc co 30
			switch (j)
			{
			case 0:
				tab[j][i][1] = 0;
				tab[j][i][2] = (-1)*tab2D[i][1];
				break;
			case 1:
				tab[j][i][1] = tab2D[i][1] / 2;
				tab[j][i][2] = (-5)*tab2D[i][1] / 6;
				break;
			case 2:
				tab[j][i][1] = 5 * tab2D[i][1] / 6;
				tab[j][i][2] = (-1)*tab2D[i][1] / 2;
				break;
			case 3:
				tab[j][i][1] = tab2D[i][1];
				tab[j][i][2] = 0;
				break;
			case 4:
				tab[j][i][1] = 5 * tab2D[i][1] / 6;
				tab[j][i][2] = tab2D[i][1] / 2;
				break;
			case 5:
				tab[j][i][2] = 5 * tab2D[i][1] / 6;
				tab[j][i][1] = tab2D[i][1] / 2;
				break;
			case 6:
				tab[j][i][1] = 0;
				tab[j][i][2] = tab2D[i][1];
				break;
			}
		}
	}
}
//funckja tworzaca moedl gory

void drawMountain(float a)
{
	generuj_tab2D(a);
	generuj_3D();
	for (int j = 0; j < 7; j++)
	{
		for (int i = 0; i < S-1; i++)
		{
			// rysowanie wykresu o konkretnym koncie (kąt zależny od j)
			glBegin(GL_LINES);
			glVertex3fv(tab[j][i]);
			glVertex3fv(tab[j][i + 1]);
			glEnd();
			//jeżeli nie jest to ostatni wykres to łączymy kolejne punkty (x) sąsiedniego (o większym koncie) wykresu
			if (j < 6)
			{
				glBegin(GL_LINES);
				glVertex3fv(tab[j][i]);
				glVertex3fv(tab[j + 1][i]);
				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 (status == 1) {   // jeśli lewy klawisz myszy wciśnięty
		theta += delta_x * pix2angle_x;       // modyfikacja kąta obrotu o kąt proporcjonalny
		fi += delta_y * pix2angle_y;      // do różnicy położeń kursora myszy

		if (theta >= 360.0)
			theta = 0.0;
		if (fi >= 360.0)
			fi = 0.0;
	}
	else if (status == 2) {  // jeśli prawy klawisz myszy wciśnięty
		viewerR += 0.1* delta_y; // modyfikacja polozenia obserwatora(zoom)
		if (viewerR <= 6.0) {		// ograniczenie zblizenia
			viewerR = 6.0;
		}
		if (viewerR >= 25.0) {	// ograniczenie oddalenia
			viewerR = 25.0;
		}
	}

	if (status == 2)
	{
		R += zoom;
		if (R<7)
			R = 7;
		if (R>30)
			R = 30;
		if (zoom>0)
			S -= 3;
		else
			S += 3;
		if (S > 100)
			S = 100;
		if (S < 25)
			S = 25;
	}

	//Wspolrzedne obserwatora - wzor z ZSK
	viewer[0] = viewerR * cos(theta) * cos(fi);
	viewer[1] = viewerR * sin(fi);
	viewer[2] = viewerR * sin(theta) * cos(fi);

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

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

	// Tworzenie gory
	drawMountain(3);

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

	glutSwapBuffers();
}
/*
void RenderScene(void) {
// Czyszczenie okna aktualnym kolorem czyszczącym
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

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

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

// Rysowanie czajnika
// leTeapot();

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

// Tworzenie gory
drawMountain(3);

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

glutSwapBuffers();
}*/

/*************************************************************************************/
// Funkcja ustalająca stan renderowania
void MyInit(void) {
	// Kolor okna - czarny
	glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
}


/*************************************************************************************/
// 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_x = 360.0*0.1 / (float)horizontal; // przeliczenie pikseli na stopnie
	pix2angle_y = 360.0*0.1 / (float)vertical;

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

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

	gluPerspective(70.0, 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
}

// Funkcja "bada" stan myszy i ustawia wartosci 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
		y_pos_old = y;        // jako pozycji poprzedniej
		status = 1;         // wciśnięty został lewy klawisz myszy
	}
	else if (btn == GLUT_RIGHT_BUTTON && state == GLUT_DOWN) {
		y_pos_old = y;      // przypisanie aktualnie odczytanej pozycji kursora
				// jako pozycji poprzedniej
		status = 2;         //wciśnięty został prawy klawisz myszy
	}
	else
		status = 0;         // nie został wciśnięty żaden klawisz
}

// Funkcja "monitoruje" polozenie kursora myszy i ustawia wartosci odpowiednich
// zmiennych globalnych
void Motion(GLsizei x, GLsizei y) {
	delta_x = x - x_pos_old;    // obliczenie różnicy położenia kursora myszy
	x_pos_old = x;  // podstawienie bieżacego położenia jako poprzednie

	delta_y = y - y_pos_old;    // obliczenie różnicy położenia kursora myszy
	y_pos_old = y;  // podstawienie bieżacego położenia jako poprzednie
	if(status==2)
		S += 0.001;
	RenderScene();    // przerysowanie obrazu sceny
}


/*************************************************************************************/
// Główny punkt wejścia programu. Program działa w trybie konsoli
int main() {
	//Ziarno losowosci
	srand((unsigned)time(NULL));

	//Dynamiczna alokacja tablicy punktow
	pointsTab = new point3*[N + 1];
	for (int i = 0; i < N + 1; i++) {
		pointsTab[i] = new point3[N + 1];
	}

	glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);

	glutInitWindowSize(300, 300);

	glutCreateWindow("234938");

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

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

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

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

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

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


	// Funkcja uruchamia szkielet biblioteki GLUT
	glutMainLoop();

	return 0;
}

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