//*********************************************************************
//
//  PLIK ŹRÓDŁOWY:       main.cpp
//
//  OPIS:               Program służy do tworzenia oświetlonego i
//                      oteksturowanego modelu jajka 3-D
//
//  AUTOR:              Kamil Kozak, [email protected]
//
//
//  DATA                10.01.2018 (Versja 1.00).
//  MODYFIKACJI:
//
//  PLATFORMA:          System operacyjny:  Microsoft Windows 10.
//                      Kompilator:  Microsoft Visual Studi Community 2015 v14.0.
//
//  MATERIAŁY          Nie wykorzystano.
//  ŹRÓDŁOWE:
//
//  UŻYTE BIBLIOTEKI   Nie używano.
//  NIESTANDARDOWE
//
//*********************************************************************
#define _CRT_SECURE_NO_WARNINGS
#include <windows.h>
#include <gl/gl.h>
#include <gl/glut.h>
#include <math.h>
#include <ctime>
#include <stdio.h>
using namespace std;
//static GLfloat theta[] = { 0.0, 0.0, 0.0 }; // trzy kąty obrotu
typedef float point3[3];
int model = 1;  // 1- punkty, 2- siatka, 3 - wypełnione trójkąty
#define N 100
#define pi 3.1415
point3 colors[N][N]; // tablica przechowująca kolory
point3 normal[N][N];
point3 texture[N][N];
static GLfloat viewer[] = { 0.0, 0.0, 10.0 };
static GLfloat thetaX = 0.0;   // kąt obrotu obiektu
static GLfloat thetaY = 0.0;
static GLfloat theta_distance = 10.0;
static GLfloat pix2angle;     // przelicznik pikseli na stopnie
static bool lightVersion = false;
float forw = 1.0 / N;


static GLint status = 0;       // stan klawiszy myszy
                               // 0 - nie naciśnięto żadnego klawisza
                               // 1 - naciśnięty zostać lewy klawisz

static int x_pos_old = 0;       // poprzednia pozycja kursora myszy

static int delta_x = 0;        // różnica pomiędzy pozycją bieżącą
                               // i poprzednią kursora myszy
static int y_pos_old = 0;       // poprzednia pozycja kursora myszy

static int delta_y = 0;        // różnica pomiędzy pozycją bieżącą
                               // i poprzednią kursora myszy
int distance = 0;

static int delta_distance = 0;
//Funkcja rysująca jajko

/*************************************************************************************/
// Funkcja wczytuje dane obrazu zapisanego w formacie TGA w pliku o nazwie
// FileName, alokuje pamięć i zwraca wskaźnik (pBits) do bufora w którym
// umieszczone są dane.
// Ponadto udostępnia szerokość (ImWidth), wysokość (ImHeight) obrazu
// tekstury oraz dane opisujące format obrazu według specyfikacji OpenGL
// (ImComponents) i (ImFormat).
// Jest to bardzo uproszczona wersja funkcji wczytującej dane z pliku TGA.
// Działa tylko dla obrazów wykorzystujących 8, 24, or 32 bitowy kolor.
// Nie obsługuje plików w formacie TGA kodowanych z kompresją RLE.
/*************************************************************************************/


GLbyte *LoadTGAImage(const char *FileName, GLint *ImWidth, GLint *ImHeight, GLint *ImComponents, GLenum *ImFormat)
{

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

    // Struktura dla nagłówka pliku  TGA


#pragma pack(1)
    typedef struct
    {
        GLbyte    idlength;
        GLbyte    colormaptype;
        GLbyte    datatypecode;
        unsigned short    colormapstart;
        unsigned short    colormaplength;
        unsigned char     colormapdepth;
        unsigned short    x_orgin;
        unsigned short    y_orgin;
        unsigned short    width;
        unsigned short    height;
        GLbyte    bitsperpixel;
        GLbyte    descriptor;
    }TGAHEADER;
#pragma pack(8)

    FILE *pFile;
    TGAHEADER tgaHeader;
    unsigned long lImageSize;
    short sDepth;
    GLbyte    *pbitsperpixel = NULL;


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

    // Wartości domyślne zwracane w przypadku błędu

    *ImWidth = 0;
    *ImHeight = 0;
    *ImFormat = GL_BGR_EXT;
    *ImComponents = GL_RGB8;

    pFile = fopen(FileName, "rb");
    if (pFile == NULL)
        return NULL;

    /*************************************************************************************/
    // Przeczytanie nagłówka pliku


    fread(&tgaHeader, sizeof(TGAHEADER), 1, pFile);


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

    // Odczytanie szerokości, wysokości i głębi obrazu

    *ImWidth = tgaHeader.width;
    *ImHeight = tgaHeader.height;
    sDepth = tgaHeader.bitsperpixel / 8;


    /*************************************************************************************/
    // Sprawdzenie, czy głębia spełnia założone warunki (8, 24, lub 32 bity)

    if (tgaHeader.bitsperpixel != 8 && tgaHeader.bitsperpixel != 24 && tgaHeader.bitsperpixel != 32)
        return NULL;

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

    // Obliczenie rozmiaru bufora w pamięci


    lImageSize = tgaHeader.width * tgaHeader.height * sDepth;


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

    // Alokacja pamięci dla danych obrazu


    pbitsperpixel = (GLbyte*)malloc(lImageSize * sizeof(GLbyte));

    if (pbitsperpixel == NULL)
        return NULL;

    if (fread(pbitsperpixel, lImageSize, 1, pFile) != 1)
    {
        free(pbitsperpixel);
        return NULL;
    }


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

    // Ustawienie formatu OpenGL


    switch (sDepth)

    {

    case 3:

        *ImFormat = GL_BGR_EXT;

        *ImComponents = GL_RGB8;

        break;

    case 4:

        *ImFormat = GL_BGRA_EXT;

        *ImComponents = GL_RGBA8;

        break;

    case 1:

        *ImFormat = GL_LUMINANCE;

        *ImComponents = GL_LUMINANCE8;

        break;

    };



    fclose(pFile);



    return pbitsperpixel;

}

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

int Egg()
{
    point3 points[N][N];

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

            texture[u][v][0] = i;
            texture[u][v][1] = j;

            points[u][v][0] = (-90 * pow(i, 5) + 225 * pow(i, 4) - 270 * pow(i, 3) + 180 * pow(i, 2) - 45 * i)*cos(3.14*j);
            points[u][v][1] = (160 * pow(i, 4) - 320 * pow(i, 3) + 160 * pow(i, 2)) - 5.0;
            points[u][v][2] = (-90 * pow(i, 5) + 225 * pow(i, 4) - 270 * pow(i, 3) + 180 * pow(i, 2) - 45 * i)*sin(3.14*j);
        }
    }

    //Jajko jako zbiór punktów
    if (model == 1)
    {
        for (int u = 0; u < N; u++)
        {
            for (int v = 0; v < N; v++)
            {
                glBegin(GL_POINTS);
                glVertex3fv(points[u][v]);
                //glVertex3f(points[u][v][0], points[u][v][1], points[u][v][2]);
                glEnd();
            }
        }
    }
    //Jajko jako siatka linii
    if (model == 2)
    {
        for (int u = 0; u < N - 1; u++)
        {
            for (int v = 0; v < N - 1; v++)
            {
                glBegin(GL_LINES);
                glVertex3fv(points[u][v]); // Rysowanie trójkątów z linii
                glVertex3fv(points[u][v + 1]);
                glVertex3fv(points[u + 1][v]);
                glVertex3fv(points[u + 1][v + 1]);
                glVertex3fv(points[u + 1][v]);
                glVertex3fv(points[u][v + 1]);
                glEnd();
            }
        }
    }

    // Jajko jako kolorowe trójkąty
    if (model == 3)
    {
        glBegin(GL_TRIANGLES);
        for (int u = 0; u < N - 1; u++)
        {
            for (int v = 0; v < N - 1 ; v++)
            {
                /*glBegin(GL_TRIANGLES);

                glNormal3fv(normal[u][v]);
                glTexCoord2fv(texture[u][v]);
                glVertex3fv(points[u][v]);

                glNormal3fv(normal[u+1][v]);
                glTexCoord2fv(points[u + 1][v]);
                glVertex3fv((points[u + 1][v]));

                glNormal3fv(normal[u][v+1]);
                glTexCoord2fv(texture[u][v + 1]);
                glVertex3fv((points[u][v + 1]));
                glEnd();

                glBegin(GL_TRIANGLES);
                glNormal3fv(normal[u+1][v+1]);
                glTexCoord2fv(texture[u + 1][v + 1]);
                glVertex3fv((points[u + 1][v + 1]));

                glNormal3fv(normal[u+1][v]);
                glTexCoord2fv(texture[u + 1][v]);
                glVertex3fv((points[u + 1][v]));

                glNormal3fv(normal[u][v+1]);
                glTexCoord2fv(texture[u][v + 1]);
                glVertex3fv((points[u][v + 1]));
                glEnd(); */


                if (u == N - 1)
                {

                    glNormal3fv(normal[u][v]);
                    glTexCoord2fv(texture[u][v]);
                    glVertex3fv(points[u][v]);

                    glNormal3fv(normal[0][v]);
                    glTexCoord2fv(points[0][v]);
                    glVertex3fv((points[0][v]));

                    glNormal3fv(normal[u][0]);
                    glTexCoord2fv(texture[u][0]);
                    glVertex3fv((points[u][0]));

                    glNormal3fv(normal[0][0]);
                    glTexCoord2fv(texture[0][0]);
                    glVertex3fv((points[0][0]));

                    glNormal3fv(normal[u][0]);
                    glTexCoord2fv(texture[u][0]);
                    glVertex3fv((points[u][0]));

                    glNormal3fv(normal[0][v]);
                    glTexCoord2fv(texture[0][v]);
                    glVertex3fv((points[0][v]));
                }
                else if (v == N - 1)
                {

                    glNormal3fv(normal[u][v]);
                    glTexCoord2fv(texture[u][v]);
                    glVertex3fv(points[u][v]);

                    glNormal3fv(normal[u + 1][v]);
                    glTexCoord2fv(texture[u+1][v]);
                    glVertex3fv((points[u + 1][v]));

                    glNormal3fv(normal[u][v]);
                    glTexCoord2fv(texture[u][v]);
                    glVertex3fv((points[u][v]));

                    glNormal3fv(normal[u + 1][v]);
                    glTexCoord2fv(texture[u+1][v]);
                    glVertex3fv((points[u + 1][v]));

                    glNormal3fv(normal[u][v]);
                    glTexCoord2fv(texture[u][v]);
                    glVertex3fv((points[u][v]));

                    glNormal3fv(normal[u + 1][v]);
                    glTexCoord2fv(texture[u+1][v]);
                    glVertex3fv((points[u + 1][v]));
                }
                else
                {

                    glNormal3fv(normal[u][v]);
                    glTexCoord2fv(texture[u][v]);
                    glVertex3fv(points[u][v]);

                    glNormal3fv(normal[u + 1][v]);
                    glTexCoord2fv(texture[u+1][v]);
                    glVertex3fv((points[u + 1][v]));

                    glNormal3fv(normal[u][v + 1]);
                    glTexCoord2fv(texture[u][v+1]);
                    glVertex3fv((points[u][v + 1]));

                    glNormal3fv(normal[u + 1][v + 1]);
                    glTexCoord2fv(texture[u+1][v+1]);
                    glVertex3fv((points[u + 1][v + 1]));

                    glNormal3fv(normal[u][v + 1]);
                    glTexCoord2fv(texture[u][v+1]);
                    glVertex3fv((points[u][v + 1]));

                    glNormal3fv(normal[u + 1][v]);
                    glTexCoord2fv(texture[u+1][v]);
                    glVertex3fv((points[u + 1][v]));
                }

            }
        }
        glEnd();
    }
    return 0;
}

void EggVectors() {
    // Liczenie Punktow
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            float u = i * forw;
            float v = j * forw;

            //Kolory
            GLfloat* color = new GLfloat[3];
            color[0] = ((double)rand() / (RAND_MAX));
            color[1] = ((double)rand() / (RAND_MAX));
            color[2] = ((double)rand() / (RAND_MAX));

            float xU = (-450 * pow(u, 4) + 900 * pow(u, 3) - 810 * pow(u, 2) + 360 * u - 45) * cos(pi * v);
            float xV = pi * (90 * pow(u, 5) - 225 * pow(u, 4) + 270 * pow(u, 3) - 180 * pow(u, 2) + 45 * u) * sin(pi * v);
            float yU = (640 * pow(u, 3) - 960 * pow(u, 2) + 320 * u);
            float yV = 0;
            float zU = (-450 * pow(u, 4) + 900 * pow(u, 3) - 810 * pow(u, 2) + 360 * u - 45)  * sin(pi * v);
            float zV = -pi * (90 * pow(u, 5) - 225 * pow(u, 4) + 270 * pow(u, 3) - 180 * pow(u, 2) + 45 * u) * cos(pi * v);

            normal[i][j][0] = yU * zV - zU * yV;
            normal[i][j][1] = zU * xV - xU * zV;
            normal[i][j][2] = xU * yV - yU * xV;


            float vectorLenght = sqrt(normal[i][j][0] * normal[i][j][0] + normal[i][j][1] * normal[i][j][1] + normal[i][j][2] * normal[i][j][2]);


            normal[i][j][0] = normal[i][j][0] / vectorLenght;
            normal[i][j][1] = normal[i][j][1] / vectorLenght;
            normal[i][j][2] = normal[i][j][2] / vectorLenght;

            if (vectorLenght == 0) {

                if (i == 0) {
                    normal[i][j][0] = 0.0f;
                    normal[i][j][1] = -1.0f;
                    normal[i][j][2] = 0.0f;
                }
                if (i == N - 1) {
                    normal[i][j][0] = 0.0f;
                    normal[i][j][1] = 1.0f;
                    normal[i][j][2] = 0.0f;
                }

            }
        }
    }

    for (int i = N / 2; i < N; i++)
    {
        for (int j = 0; j < N; j++)
        {
            for (int k = 0; k < 3; k++)
            {
                normal[i][j][k] *= -1;
            }
        }
    }
}

/*************************************************************************************/
// Funkcja rysująca osie układu współrzędnych
void Axes(void)
{
    point3  x_min = { -5.0, 0.0, 0.0 };
    point3  x_max = { 5.0, 0.0, 0.0 };
    // początek i koniec obrazu osi x

    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 };
    //  początek i koniec obrazu osi y
    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 "bada" stan myszy i ustawia wartości 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
        status = lightVersion ? 3 : 1;
    }
    else if (btn == GLUT_RIGHT_BUTTON && state == GLUT_DOWN)
    {
        distance = y;

        status = 2;
        status = lightVersion ? 4 : 2;
    }
}

/*************************************************************************************/
// Funkcja "monitoruje" położenie kursora myszy i ustawia wartości odpowiednich
// zmiennych globalnych

void Motion(GLsizei x, GLsizei y)
{

    delta_x = x - x_pos_old;     // obliczenie różnicy położenia kursora myszy

    delta_y = y - y_pos_old;

    x_pos_old = x;            // podstawienie bieżącego położenia jako poprzednie

    y_pos_old = y;

    delta_distance = y - distance;

    distance = y;

    glutPostRedisplay();     // przerysowanie obrazu sceny
}

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


/*************************************************************************************/
// 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
    gluLookAt(viewer[0], viewer[1], viewer[2], 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
    // Zdefiniowanie położenia obserwatora
    glDisable(GL_LIGHTING);
    Axes();
    glEnable(GL_LIGHTING);
    // Narysowanie osi przy pomocy funkcji zdefiniowanej wyżej

    if (status == 1)                     // jeśli lewy klawisz myszy wcięnięty
    {
        thetaX += delta_x  *pix2angle / 40.0;    // modyfikacja kąta obrotu o kat proporcjonalny
        thetaY += delta_y * pix2angle / 40.0;
    }                                            // do różnicy położeń kursora myszy
    if (status == 2)                    // jeśli prawy klawisz myszy jest wciśnięty
    {
        theta_distance += delta_distance / 10.0;
    }

    viewer[0] = theta_distance * cos(thetaX) * cos(thetaY);
    viewer[1] = theta_distance * sin(thetaY);
    viewer[2] = theta_distance * sin(thetaX) * cos(thetaY);

    Egg();

    //Oswietlenie

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

    glutSwapBuffers();
}

/*************************************************************************************/
// Funkcja ustalająca stan renderowania

void MyInit(void)
{
    EggVectors();
    //glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
    // Kolor czyszcący (wypełnienia okna) ustawiono na czarny

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

        // Zmienne dla obrazu tekstury



        GLbyte *pBytes;
        GLint ImWidth, ImHeight, ImComponents;
        GLenum ImFormat;


        // ..................................
        //       Pozostała część funkcji MyInit()

        // ..................................

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

        // Teksturowanie będzie prowadzone tyko po jednej stronie ściany

        //glEnable(GL_CULL_FACE);


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

        //  Przeczytanie obrazu tekstury z pliku o nazwie tekstura.tga

        pBytes = LoadTGAImage("P3_t.tga", &ImWidth, &ImHeight, &ImComponents, &ImFormat);


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

        // Zdefiniowanie tekstury 2-D

        glTexImage2D(GL_TEXTURE_2D, 0, ImComponents, ImWidth, ImHeight, 0, ImFormat, GL_UNSIGNED_BYTE, pBytes);

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

        // Zwolnienie pamięci

        free(pBytes);


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

        // Włączenie mechanizmu teksturowania

        glEnable(GL_TEXTURE_2D);

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

        // Ustalenie trybu teksturowania

        glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);

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

        // Określenie sposobu nakładania tekstur

        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

        glClearColor(0.0f, 0.0f, 0.1f, 1.0f);

    /*************************************************************************************/
    //  Definicja materiału z jakiego zrobiony jest czajnik
    //  i definicja źródła światła
    /*************************************************************************************/

    /*************************************************************************************/
    // Definicja materiału z jakiego zrobiony jest czajnik

    GLfloat mat_ambient[] = { 1.0, 1.0, 1.0, 1.0 };
    // współczynniki ka =[kar,kag,kab] dla światła otoczenia

    GLfloat mat_diffuse[] = { 1.0, 1.0, 1.0, 1.0 };
    // współczynniki kd =[kdr,kdg,kdb] światła rozproszonego

    GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 };
    // współczynniki ks =[ksr,ksg,ksb] dla światła odbitego

    GLfloat mat_shininess = { 10.0 };
    // współczynnik n opisujący połysk powierzchni

    /*************************************************************************************/
    // Definicja źródła światła
    //GLfloat spot_direction[] = { -1.0, -1.0, 0.0 };

    GLfloat light_position[] = { 10.0f, 0.0f, 0.0f, 1.0f};
    // położenie źródła

    GLfloat light_ambient[] = { 0.0, 0.0, 0.1, 1.0};
    // składowe intensywności świecenia źródła światła otoczenia
    // Ia = [Iar,Iag,Iab]

    GLfloat light_diffuse[] = { 0.0, 0.0, 1.0, 1.0 };
    // składowe intensywności świecenia źródła światła powodującego
    // odbicie dyfuzyjne Id = [Idr,Idg,Idb]

    GLfloat light_specular[] = { 0.5, 0.5, 1.0, 1.0 };
    // składowe intensywności świecenia źródła światła powodującego
    // odbicie kierunkowe Is = [Isr,Isg,Isb]

    GLfloat att_constant = { 1.0 };
    // składowa stała ds dla modelu zmian oświetlenia w funkcji
    // odległości od źródła

    GLfloat att_linear = { 0.35f };
    // składowa liniowa dl dla modelu zmian oświetlenia w funkcji
    // odległości od źródła

    GLfloat att_quadratic = { 0.051f };
    // składowa kwadratowa dq dla modelu zmian oświetlenia w funkcji
    // odległości od źródła

    /*************************************************************************************/
    // Ustawienie parametrów materiału i źródła światła
    /*************************************************************************************/
    // Ustawienie patrametrów materiału

    glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
    glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient);
    glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
    glMaterialf(GL_FRONT, GL_SHININESS, mat_shininess);

    /*************************************************************************************/
    // Ustawienie parametrów źródła

    glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient);
    glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);
    glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular);
    //glLightfv(GL_LIGHT0, GL_POSITION, light_position);
    //glLightfv(GL_LIGHT0, GL_SPOT_DIRECTION, spot_direction);
    //glLightf(GL_LIGHT0, GL_CONSTANT_ATTENUATION, att_constant);
    //glLightf(GL_LIGHT0, GL_LINEAR_ATTENUATION, att_linear);
    //glLightf(GL_LIGHT0, GL_QUADRATIC_ATTENUATION, att_quadratic);

    /*************************************************************************************/
    // Ustawienie opcji systemu oświetlania sceny

    glShadeModel(GL_SMOOTH); // właczenie łagodnego cieniowania
    glEnable(GL_LIGHTING);   // właczenie systemu oświetlenia sceny
    glEnable(GL_LIGHT0);     // włączenie źródła o numerze 0
    glEnable(GL_DEPTH_TEST); // włączenie mechanizmu z-bufora

                             /*************************************************************************************/
}
/*************************************************************************************/
// 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 = 360.0 / (float)horizontal;  // przeliczenie pikseli na stopnie
    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
    gluPerspective(70, 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();
    // Czyszcenie macierzy bieżącej
}

//Funkcja reagowania na klawisze klawiatury
void keys(unsigned char key, int x, int y)
{
    if (key == 'p') model = 1;
    if (key == 'w') model = 2;
    if (key == 's') model = 3;
    if (key == 'x') {
        lightVersion = !lightVersion;
    }

    for (int u = 0; u < N; u++) // Wylosowanie kolorów do tablicy
    {
        for (int v = 0; v < N; v++)
        {
            for (int k = 0; k < 3; k++)
            {
                float color = (rand() % 100);
                color = color / 100;
                colors[u][v][k] = color;
            }
        }
    }

    RenderScene(); // przerysowanie obrazu sceny
}


void main(void)
{
    srand(time(NULL));
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);

    glutInitWindowSize(300, 300);

    glutCreateWindow("Układ współrzędnych 3-D");

    glutKeyboardFunc(keys);

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

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


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