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

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

/*************************************************************************************/
#include <windows.h>
#include <gl/gl.h>
#include <gl/glut.h>
#include <math.h>
/*************************************************************************************/

// Funkcaja określająca, co ma być rysowane
// (zawsze wywoływana, gdy trzeba przerysować scenę)
typedef float point2[2];

struct punkt
{
	float x;
	float y;
};
punkt nowy (float x, float y)
{
	punkt a;
	a.x = x;
	a.y = y;

	return a;
}

void RenderScene(void)
{
    punkt tab [4024];
	float bok  = 5;
	tab [0] = nowy(0,0);
	int n = 2;
	for(int i = 0; i <= n; ++i)
	{
		/*
		5,6,7
		3, ,4
		0,1,2
		*/

		//1
		for(int j = 0; j < pow(8.0f, i-1); ++j)
		{
			tab [(int)pow(8.0f, i-1) + j] = nowy(tab[j].x + (pow(3.0f,i-1)*bok), tab[j].y);
		}
		//2
		for(int j = 0; j < pow(8.0f, i-1); ++j)
		{
			tab [(2*(int)pow(8.0f, i-1)) + j] = nowy(tab[j].x + 2*(pow(3.0f,i-1)*bok), tab[j].y);
		}
		//3
		for(int j = 0; j < pow(8.0f, i-1); ++j)
		{
			tab [(3*(int)pow(8.0f, i-1)) + j] = nowy(tab[j].x, tab[j].y+(pow(3.0f,i-1)*bok));
		}
		//4
		for(int j = 0; j < pow(8.0f, i-1); ++j)
		{
			tab [(4*(int)pow(8.0f, i-1)) + j] = nowy(tab[j].x + 2*(pow(3.0f,i-1)*bok), tab[j].y+ (pow(3.0f,i-1)*bok));
		}
		//5
		for(int j = 0; j < pow(8.0f, i-1); ++j)
		{
			tab [(5*(int)pow(8.0f, i-1)) + j] = nowy(tab[j].x , tab[j].y+ 2*(pow(3.0f,i-1)*bok));
		}
		//6
		for(int j = 0; j < pow(8.0f, i-1); ++j)
		{
			tab [(6*(int)pow(8.0f, i-1)) + j] = nowy(tab[j].x + (pow(3.0f,i-1)*bok), tab[j].y+ 2*(pow(3.0f,i-1)*bok));
		}
		//7
		for(int j = 0; j < pow(8.0f, i-1); ++j)
		{
			tab [(7*(int)pow(8.0f, i-1)) + j] = nowy(tab[j].x + 2*(pow(3.0f,i-1)*bok), tab[j].y + 2*(pow(3.0f,i-1)*bok));
		}

	}

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

    glColor3f(0.0f, 1.0f, 0.0f);
    // Ustawienie aktualnego koloru rysowania na zielony
	float przesuniecie = (bok*pow(3.0f,n))/2;
	for (int i = 0; i<(int)pow(8.0f,n);++i)
	{
		glRectf(tab[i].x - przesuniecie, tab[i].y - przesuniecie, tab[i].x + bok - przesuniecie, tab[i].y + bok - przesuniecie);

	}

    glFlush();
}
/*************************************************************************************/

// Funkcja ustalająca stan renderowania


void MyInit(void)
{
   glClearColor(0.5f, 0.5f, 0.5f, 1.0f);
   // Kolor okna wnętrza okna - ustawiono na szary
}
/*************************************************************************************/

// 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 punkt wejścia programu. Program działa w trybie konsoli


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

   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
}
/*************************************************************************************/