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

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

/*************************************************************************************/
#include "pch.h"
#include <windows.h>
#include <time.h>
#include <cstdlib>
#include <ctime>
#include <iostream>

#include <gl/gl.h>

#include <gl/glut.h>

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


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

GLfloat width = 150.f;
GLfloat disturb = 3.f;
int deepLevel = 4;

//KWADRAT
// 3 || 2 || 1
//============
// 4 ||   || 8
//============
// 5 || 6 || 7

void sierpinski(GLfloat x, GLfloat y, GLshort deep, GLfloat width)
{
    if (deep > 0)
    {
        width = width / 3; // Podzial kwadratu na 9 mniejszych
        sierpinski(x, y, deep - 1, width); // POZ 1
        sierpinski(x - width, y, deep - 1, width); // POZ 2
        sierpinski(x - 2 * width, y, deep - 1, width); // POZ 3
        sierpinski(x - 2 * width, y - width, deep - 1, width); // POZ 4
        sierpinski(x - 2 * width, y - 2 * width, deep - 1, width); // POZ 5
        sierpinski(x - width, y - 2 * width, deep - 1, width); // POZ 6
        sierpinski(x, y - 2 * width, deep - 1, width); // POZ 7
        sierpinski(x, y - width, deep - 1, width); // POZ 8

    }
    else
    {
        glBegin(GL_POLYGON);
        glColor3ub(std::rand() % 255 , std::rand() % 255 , std::rand() % 255 ); // losowy kolor (255,255,255) uByte
        glVertex2f(x + (std::rand() % (int)disturb ) / (width), y + (std::rand() % (int)disturb ) / (width));
        glColor3ub(std::rand() % 255 , std::rand() % 255 , std::rand() % 255 );  // losowy kolor
        glVertex2f(x - width + (std::rand() % (int)disturb ) / (width), y + (std::rand() % (int)disturb ) / (width));
        glColor3ub(std::rand() % 255 , std::rand() % 255 , std::rand() % 255 );  // losowy kolor
        glVertex2f(x - width + (std::rand() % (int)disturb ) / (width), y - width + (std::rand() % (int)disturb ) / (width));
        glColor3ub(std::rand() % 255 , std::rand() % 255 , std::rand() % 255 );  // losowy kolor
        glVertex2f(x + (std::rand() % (int)disturb ) / (width), y - width + (std::rand() % (int)disturb ) / (width));
        glEnd();
    }
}


void RenderScene(void)

{
    glClear(GL_COLOR_BUFFER_BIT);

    sierpinski(width / 2, width / 2, deepLevel, width);

    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

}

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