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

typedef float point3[3];

static GLfloat viewer[] = { 0.0, 0.0, 10.0 };


static GLfloat theta = 0.0, thetaY = 0.0, przesuniecieZ = 1.0;   // kąt obrotu obiektu
static GLfloat pix2angle;     // przelicznik pikseli na stopnie

static GLint status = 0, statusM = 0, statusR = 0;                             // 0 - nie naciśnięto żadnego klawisza
                               // 1 - naciśnięty zostać lewy klawisz

static int x_pos_old = 0, yPosOld = 0, zPosOld = 0,
delta_x = 0, deltaY = 0, deltaZ = 0,
fi1Old = 0, fi2Old = 0, fi3Old = 0,
deltaFi1 = 0, deltaFi2 = 0, deltaFi3 = 0;

void RysujJajoZTrojkatow()
{

    int n = 20;
    float u, v;
    float tablica[20][20][3];

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

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

    glRotated(50, 1, 1, 1);

    glBegin(GL_TRIANGLES);

    glColor3f(1.0, 1.0, 1.0);

    for (int i = 0; i < n - 1; i++)
    {
        for (int j = 0; j < n - 1; j++)
        {
            //glColor3f(0.5, 0.5, 0.5);
            glVertex3f(tablica[i][j][0], tablica[i][j][1] - 5, tablica[i][j][2]);

            //glColor3f(0.5, 0.5, 0.5);
            glVertex3f(tablica[i][j + 1][0], tablica[i][j + 1][1] - 5, tablica[i][j + 1][2]);

            //glColor3f(0.5, 0.5, 0.5);
            glVertex3f(tablica[i + 1][j + 1][0], tablica[i + 1][j + 1][1] - 5, tablica[i + 1][j + 1][2]);



            //glColor3f(0.5, 0.5, 0.5);
            glVertex3f(tablica[i][j][0], tablica[i][j][1] - 5, tablica[i][j][2]);

            //glColor3f(0.5, 0.5, 0.5);
            glVertex3f(tablica[i + 1][j][0], tablica[i + 1][j][1] - 5, tablica[i + 1][j][2]);

            //glColor3f(0.5, 0.5, 0.5);
            glVertex3f(tablica[i + 1][j + 1][0], tablica[i + 1][j + 1][1] - 5, tablica[i + 1][j + 1][2]);

        }
    }
    glEnd();
}

void Mouse(int btn, int state, int x, int y)
{


    if (btn == GLUT_LEFT_BUTTON && state == GLUT_DOWN)
    {
        x_pos_old = x;
        yPosOld = y;// przypisanie aktualnie odczytanej pozycji kursora
                             // jako pozycji poprzedniej
        status = 1;          // wcięnięty został lewy klawisz myszy
    }
    else

        status = 0;

    if (btn == GLUT_MIDDLE_BUTTON && state == GLUT_DOWN)
    {
        zPosOld = y;

        statusM = 1;
    }
    else
    {
        statusM = 0;
    }

    if (btn == GLUT_RIGHT_BUTTON && state == GLUT_DOWN)
    {
        fi1Old = y;
        fi2Old = y;
        fi3Old = y;
        statusR = 1;
    }
    else
        statusR = 0;
}



void Motion(GLsizei x, GLsizei y)
{

    delta_x = x - x_pos_old;
    x_pos_old = x;

    deltaY = y - yPosOld;
    yPosOld = y;

    deltaZ = y - zPosOld;
    zPosOld = y;

    deltaFi1 = y - fi1Old;
    fi1Old = y;

    deltaFi2 = y - fi2Old;
    fi2Old = y;

    deltaFi3 = y - fi3Old;
    fi3Old = y;

    glutPostRedisplay();     // przerysowanie obrazu sceny
}

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

}


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

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

    if (status == 1)                     // jeśli lewy klawisz myszy wcięnięty
    {
        theta += delta_x * pix2angle; // modyfikacja kąta obrotu o kat proporcjonalny
        thetaY += deltaY * pix2angle;
    }                                  // do różnicy położeń kursora myszy

    glRotatef(theta, 0.0, 1.0, 0.0);
    glRotatef(thetaY, 1.0, 0.0, 0.0);


    glColor3f(1.0f, 1.0f, 1.0f);
    // Ustawienie koloru rysowania na biały
    if (statusM == 1)
    {
        przesuniecieZ += deltaY * pix2angle / 20.0;
    }


    //gluLookAt(viewer[0], viewer[1], viewer[2], 0.0, 0.0, 0.0, 1.0, 0.0, 0.0);

    //przesuniecieZ *= pix2angle;

    glScalef(przesuniecieZ, przesuniecieZ, przesuniecieZ);
    //glutSolidTeapot(3.0);
    // Narysowanie czajnika
    RysujJajoZTrojkatow();

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

    glutSwapBuffers();



}

void MyInit(void)
{

    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
    // Kolor czyszczący (wypełnienia okna) ustawiono na czarny
    /*************************************************************************************/

//  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 = { 20.0 };
    // współczynnik n opisujący połysk powierzchni


/*************************************************************************************/
// Definicja źródła światła


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


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

    GLfloat light_diffuse[] = { 1.0, 1.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[] = { 1.0, 1.0, 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.05 };
    // składowa liniowa dl dla modelu zmian oświetlenia w funkcji
    // odległości od źródła

    GLfloat att_quadratic = { 0.001 };
    // 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);

    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

/*************************************************************************************/
}

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

void ChangeSize(GLsizei horizontal, GLsizei vertical)
{
    pix2angle = 360.0 / (float)horizontal;

    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();
    // Czyszczenie macierzy bieżącej

}

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

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



void main(void)
{

    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);

    glutInitWindowSize(300, 300);

    glutCreateWindow("Rzutowanie perspektywiczne");

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

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

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

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



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

    MyInit();

    glEnable(GL_DEPTH_TEST);
    // Włączenie mechanizmu usuwania niewidocznych elementów sceny

    glutMainLoop();
    // Funkcja uruchamia szkielet biblioteki GLUT

}

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