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

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

// Trochę bardziej skomplikowany program wykorzystujący funkcje biblioteki OpenGL

/*************************************************************************************/
#include "pch.h"

#include <windows.h>

#include <gl/gl.h>

#include <gl/glut.h>

#include <cstdlib>

#include <ctime>

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


// Funkcaja określająca, co ma być rysowane
// (zawsze wywoływana, gdy trzeba przerysować scenę)



typedef float point2[2];


int carpet(point2 left_down, point2 right_down, int level) {

	if (level < 1) return 1;
	float edge = right_down[0] - left_down[0];
	float small_edge = edge / 3;
	if (level == 1) {

		for (int i = 0; i < 3; i++) {

			for (int j = 0; j < 3; j++) {
				point2 new_left_down = { left_down[0] + (small_edge * i), left_down[1] + (small_edge * j) };
				point2 new_left_upper = { left_down[0] + (small_edge * i), left_down[1] + small_edge + (small_edge * j) };
				point2 new_right_upper = { left_down[0] + small_edge + (small_edge * i), left_down[1] + small_edge + (small_edge * j) };
				point2 new_right_down = { left_down[0] + small_edge + (small_edge * i), left_down[1] + (small_edge * j) };
				if ((i != 1) || (j != 1)) {
					glBegin(GL_POLYGON);
					glColor3f(static_cast <float>(rand()) / static_cast <float>(RAND_MAX), static_cast <float>(rand()) / static_cast <float>(RAND_MAX), static_cast <float>(rand()) / static_cast <float>(RAND_MAX));
					glVertex2fv(new_left_down);
					glColor3f(static_cast <float>(rand()) / static_cast <float>(RAND_MAX), static_cast <float>(rand()) / static_cast <float>(RAND_MAX), static_cast <float>(rand()) / static_cast <float>(RAND_MAX));
					glVertex2fv(new_left_upper);
					glColor3f(static_cast <float>(rand()) / static_cast <float>(RAND_MAX), static_cast <float>(rand()) / static_cast <float>(RAND_MAX), static_cast <float>(rand()) / static_cast <float>(RAND_MAX));
					glVertex2fv(new_right_upper);
					glColor3f(static_cast <float>(rand()) / static_cast <float>(RAND_MAX), static_cast <float>(rand()) / static_cast <float>(RAND_MAX), static_cast <float>(rand()) / static_cast <float>(RAND_MAX));
					glVertex2fv(new_right_down);
					glEnd();

				}
				else {
					glBegin(GL_POLYGON);
					glVertex2fv(new_left_down);
					glVertex2fv(new_left_upper);
					glVertex2fv(new_right_upper);
					glVertex2fv(new_right_down);
					glEnd();
				}
			}
		}
		return 0;
	}
	for (int i = 0; i < 3; i++) {

		for (int j = 0; j < 3; j++) {

			point2 new_left_down = { left_down[0] + (small_edge * i), left_down[1] + (small_edge * j) };
			point2 new_left_upper = { left_down[0] + (small_edge * i), left_down[1] + small_edge + (small_edge * j) };
			point2 new_right_upper = { left_down[0] + small_edge + (small_edge * i), left_down[1] + small_edge + (small_edge * j) };
			point2 new_right_down = { left_down[0] + small_edge + (small_edge * i), left_down[1] + (small_edge * j) };

			if ((i != 1) || (j != 1)) {
				carpet(new_left_down, new_right_down, level - 1);
			}
			else {
				glBegin(GL_POLYGON);
				glColor3f(static_cast <float>(rand()) / static_cast <float>(RAND_MAX), static_cast <float>(rand()) / static_cast <float>(RAND_MAX), static_cast <float>(rand()) / static_cast <float>(RAND_MAX));
				glVertex2fv(new_left_down);
				glVertex2fv(new_left_upper);
				glVertex2fv(new_left_down);
				glVertex2fv(new_right_upper);
				glVertex2fv(new_left_down);
				glVertex2fv(new_right_down);
				glEnd();
			}
		}
	}
	return 0;
}

void RenderScene(void)

{

	glClear(GL_COLOR_BUFFER_BIT);
	// Czyszczenie okna aktualnym kolorem czyszczącym



	point2 left_down = { -70, -70 };
	point2 right_down = { 70, -70 };

	int level = 5;

	carpet(left_down, right_down, level);


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

}

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

// Funkcja ustalająca stan renderowania



void MyInit(void)

{

	glClearColor(0.8f, 0.8f, 0.8f, 1.0f);

}

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

// Funkcja służąca do kontroli zachowania proporcji rysowanych obiektów
// niezależnie od rozmiarów okna graficznego



void ChangeSize(GLsizei horizontal, GLsizei vertical)

// Parametry horizontal i vertical (szerokość i wysokość okna) są
// przekazywane do funkcji za każdym razem, gdy zmieni się rozmiar okna

{

	GLfloat AspectRatio;

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



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

		vertical = 1;

	glViewport(0, 0, horizontal, vertical);
	// Ustawienie wielkościokna okna urządzenia (Viewport)
	// W tym przypadku od (0,0) do (horizontal, vertical)

	glMatrixMode(GL_PROJECTION);
	// Określenie układu współrzędnych obserwatora

	glLoadIdentity();
	// Określenie przestrzeni ograniczającej

	AspectRatio = (GLfloat)horizontal / (GLfloat)vertical;
	// Wyznaczenie współczynnika proporcji okna

	// Gdy okno na ekranie nie jest kwadratem wymagane jest
	// określenie okna obserwatora.
	// Pozwala to zachować właściwe proporcje rysowanego obiektu
	// Do określenia okna obserwatora służy funkcja glOrtho(...)



	if (horizontal <= vertical)

		glOrtho(-100.0, 100.0, -100.0 / AspectRatio, 100.0 / AspectRatio, 1.0, -1.0);

	else

		glOrtho(-100.0*AspectRatio, 100.0*AspectRatio, -100.0, 100.0, 1.0, -1.0);

	glMatrixMode(GL_MODELVIEW);
	// Określenie układu współrzędnych

	glLoadIdentity();

}

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

// Główny right_uppernkt wejścia programu. Program działa w trybie konsoli



void main(void)

{

	srand(time(NULL));

	glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA);
	// Ustawienie trybu wyświetlania
	// GLUT_SINGLE - pojedynczy bufor wyświetlania
	// GLUT_RGBA - model kolorów RGB

	glutInitWindowSize(729, 729);

	glutCreateWindow("Drugi program w OpenGL");
	// Utworzenie okna i określenie treści napisu w nagłówku okna

	glutDisplayFunc(RenderScene);
	// Określenie, że funkcja RenderScene będzie funkcją zwrotną (callback)
	// Biblioteka GLUT będzie wywoływała tą funkcję za każdym razem, gdy
	// trzeba będzie przerysować okno


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

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


	glutMainLoop();
	// Funkcja uruchamia szkielet biblioteki GLUT

}

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