//////////////////////////////////////////////////////////////////////////////////////////
//
// Program wyswietlajacy szescian w rzucie perspektywicznym. Dlugosc boku szescianu
// moze byc interaktywnie zmieniana za pomoca klwiszy '+' i '-'.
//
//////////////////////////////////////////////////////////////////////////////////////////
#include "glut.h"
#include <math.h>

// Definicja stalych
#define DLUGOSC_BOKU            5.0
#define OBSERWATOR_ODLEGLOSC    20.0
#define OBSERWATOR_OBROT_X      20.0
#define OBSERWATOR_OBROT_Y      20.0
#define OBSERWATOR_FOV_Y        30.0
#define minOdl 10.0
#define maxOdl 300.0
#define M_PI 3.1415926535
#define DEG2RAD(x) ((float)(x)*M_PI/180.0)

int h = 5;
int R = 6;
int r = 8;
int n = 32;
int nMin = 4;
int nMax = 64;
double dAlfa;
int i = 0;

GLfloat rotObsY = 40.0;
GLfloat rotObsX = 40.0;
GLfloat rotObsZ = 0.0;
GLfloat odl = 100.0;

// Zmienne globalne
double  bok           = DLUGOSC_BOKU; // Dlugosc boku szescianu
int     szerokoscOkna = 800;
int     wysokoscOkna  = 600;


// Prototypy funkcji
void RysujSzescian(double a);
void UstawParametryWidoku(int szer, int wys);
void WyswietlObraz(void);
void ObslugaKlawiatury(unsigned char klawisz, int x, int y);


//////////////////////////////////////////////////////////////////////////////////////////
// Funkcja rysujaca szescian o boku "a" w trybie GL_QUAD_STRIP.
// Srodek szescianu znajduje się w punkcie (0,0,0).
void RysujSzescian(double a)
{
    // Pocztaek tworzenia ukladu wspolrzednych
    glBegin(GL_LINES);

    // Os X
    glColor3f(1.0, 0.0, 0.0);
    glVertex3f(-50.0, 0.0, 0.0);
    glVertex3f(50.0, 0.0, 0.0);

    // Os Y
    glColor3f(0.0, 1.0, 0.0);
    glVertex3f(0.0, -50.0, 0.0);
    glVertex3f(0.0, 50.0, 0.0);

    // Os Z
    glColor3f(0.0, 0.0, 1.0);
    glVertex3f(0.0, 0.0, -50.0);
    glVertex3f(0.0, 0.0, 50.0);

    // Koniec tworzenia ukladu wspolrzednych
    glEnd();
    //szescian:
    {/*// Sciany boczne
        glBegin(GL_QUAD_STRIP);
        glVertex3f(a / 2.0, a / 2.0, a / 2.0);
        glVertex3f(a / 2.0, -a / 2.0, a / 2.0);
        glVertex3f(a / 2.0, a / 2.0, -a / 2.0);
        glVertex3f(a / 2.0, -a / 2.0, -a / 2.0);

        glVertex3f(-a / 2.0, a / 2.0, -a / 2.0);
        glVertex3f(-a / 2.0, -a / 2.0, -a / 2.0);

        glVertex3f(-a / 2.0, a / 2.0, a / 2.0);
        glVertex3f(-a / 2.0, -a / 2.0, a / 2.0);

        glVertex3f(a / 2.0, a / 2.0, a / 2.0);
        glVertex3f(a / 2.0, -a / 2.0, a / 2.0);
        glEnd();

        // Gorna sciana
        glBegin(GL_QUAD_STRIP);
        glVertex3f(-a / 2.0, a / 2.0, a / 2.0);
        glVertex3f(a / 2.0, a / 2.0, a / 2.0);
        glVertex3f(-a / 2.0, a / 2.0, -a / 2.0);
        glVertex3f(a / 2.0, a / 2.0, -a / 2.0);
        glEnd();

        // Dolna sciana
        glBegin(GL_QUAD_STRIP);
        glVertex3f(-a / 2.0, -a / 2.0, a / 2.0);
        glVertex3f(a / 2.0, -a / 2.0, a / 2.0);
        glVertex3f(-a / 2.0, -a / 2.0, -a / 2.0);
        glVertex3f(a / 2.0, -a / 2.0, -a / 2.0);
        glEnd();
    */}
    //////////

    glColor3f(1.0, 0.0,0.0);
    //górna podstawa
    glBegin(GL_TRIANGLE_FAN);
    glVertex3f(0, h, 0);
    for (i = 0; i * 360 / n <= 360; i++) {
        glVertex3f(r * cos((float)(i * 360 / n) * 3.1415926535 / 180.0), h, r * sin((float)(i * 360 / n) * 3.1415926535 / 180.0));
    }
    glEnd();
    glBegin(GL_TRIANGLE_FAN);
    glVertex3f(0, 0, 0);
    for (i = 0; i * 360 / n <= 360; i++) {
        glVertex3f(R * cos((float)(i * 360 / n) * 3.1415926535 / 180.0), 0, R * sin((float)(i * 360 / n) * 3.1415926535 / 180.0));
    }
    glEnd();

    glBegin(GL_QUAD_STRIP);
    for (i = 0; i * 360.0 / n <= 360.0; i++)
    {
        glVertex3f(R * cos((float)(i * 360 / n) * 3.1415926535 / 180.0), 0, R * sin((float)(i * 360 / n) * 3.1415926535 / 180.0));
        glVertex3f(r * cos((float)((i+1) * 360 / n) * 3.1415926535 / 180.0), h, r * sin((float)((i+1) * 360 / n) * 3.1415926535 / 180.0));


    }
    glEnd();

}

//////////////////////////////////////////////////////////////////////////////////////////
// Funkcja ustawiajaca parametry rzutu perspektywicznego i rozmiary viewportu. Powinna
// być wywolywana kazdorazowo po zmianie rozmiarow okna programu.
void UstawParametryWidoku(int szer, int wys)
{
  // Zapamietanie wielkosci widoku
  szerokoscOkna = szer;
  wysokoscOkna  = wys;

  // Ustawienie parametrow viewportu
  glViewport(0, 0, szerokoscOkna, wysokoscOkna);

  // Przejscie w tryb modyfikacji macierzy rzutowania
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  gluPerspective(OBSERWATOR_FOV_Y, (float)szerokoscOkna/(float)wysokoscOkna, 1.0, 1000.0);
}


//////////////////////////////////////////////////////////////////////////////////////////
// Funkcja wyswietlajaca pojedyncza klatke animacji
void WyswietlObraz(void)
{
  // Wyczyszczenie bufora koloru i bufora glebokosci
  glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);

  // Przejscie w tryb modyfikacji macierzy przeksztalcen geometrycznych
  glMatrixMode(GL_MODELVIEW);

  // Zastapienie aktywnej macierzy macierza jednostkowa
  glLoadIdentity();

  // Ustalenie polozenia obserwatora
  glTranslatef(0, 0, -odl);
  glRotatef(rotObsX, 1, 0, 0);
  glRotatef(rotObsY, 0, 1, 0);
  glRotatef(rotObsZ, 0, 0, 1);

  // Narysowanie szescianu
  RysujSzescian(bok);

  // Przelaczenie buforow ramki
  glutSwapBuffers();
}


//////////////////////////////////////////////////////////////////////////////////////////
// Funkcja obslugi klawiatury
void ObslugaKlawiatury(unsigned char klawisz, int x, int y)
{
    if (klawisz == '+')
        bok *= 1.2;
    else if (klawisz == '-')
        bok /= 1.2;
    else if (klawisz == 27)
        exit(0);
    else if ((klawisz == 'a' || klawisz == 'A')&&(n<nMax))
        n++;
    else if ((klawisz == 'z' || klawisz == 'Z')&&(n>nMin))
        n--;
}
void ObslugaKlawiszySpecjalnych(int klawisz, int x, int y)
{
    switch (klawisz)
    {
    case GLUT_KEY_UP:
        rotObsX = rotObsX + 1.0;
        break;

    case GLUT_KEY_DOWN:
        rotObsX = rotObsX - 1.0;
        break;

    case GLUT_KEY_LEFT:
        rotObsY = rotObsY - 1.0;
        break;

    case GLUT_KEY_RIGHT:
        rotObsY = rotObsY + 1.0;
        break;
        //rotacja OZ
    case GLUT_KEY_HOME:
        rotObsZ++;
        break;
    case GLUT_KEY_END:
        rotObsZ--;
        break;
        //Przybliżanie i oddalanie
    case GLUT_KEY_PAGE_UP:
        odl = odl < maxOdl ? odl + 1.0 : odl;
        break;

    case GLUT_KEY_PAGE_DOWN:
        odl = odl > minOdl ? odl - 1.0 : odl;
        break;
    }
}


//////////////////////////////////////////////////////////////////////////////////////////
// Glowna funkcja programu
int  main(int argc, char **argv)
{
  // Zainicjowanie biblioteki GLUT
  glutInit(&argc, argv);

  // Ustawienie trybu wyswietlania
  glutInitDisplayMode (GLUT_DOUBLE|GLUT_RGB|GLUT_DEPTH);

  // Ustawienie polozenia dolenego lewego rogu okna
  glutInitWindowPosition(100, 100);

  // Ustawienie rozmiarow okna
  glutInitWindowSize(szerokoscOkna, wysokoscOkna);

  // Utworzenie okna
  glutCreateWindow("Stożek ścięty");

  // Odblokowanie bufora glebokosci
  glEnable(GL_DEPTH_TEST);

  // Ustawienie wartosci czyszczacej zawartosc bufora glebokosci
  glClearDepth(1000.0);

  // Ustawienie koloru czyszczenia bufora ramki
  glClearColor (0.3f, 0.3f, 0.3f, 0.0f);

  // Wlaczenie wyswietlania wielokatow w postaci obrysow (przydatne w celach diagnostycznych).
  glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);

  // Zarejestrowanie funkcji (callback) odpowiedzialnej za
  glutDisplayFunc(WyswietlObraz);

  // Zarejestrowanie funkcji (callback) wywolywanej za kazdym razem kiedy
  // zmieniane sa rozmiary okna
  glutReshapeFunc(UstawParametryWidoku);

  // Zarejestrowanie funkcji wykonywanej gdy okno nie obsluguje
  // zadnych zadan
  glutIdleFunc(WyswietlObraz);

  // Zarejestrowanie funkcji obslugi klawiatury
  glutKeyboardFunc(ObslugaKlawiatury);

  // Zarejestrowanie funkcji obslugi klawiszy specjalnych
  glutSpecialFunc(ObslugaKlawiszySpecjalnych);

  // Obsluga glownej petli programu (wywolywanie zarejestrowanych callbackow
  // w odpowiedzi na odbierane zdarzenia lub obsluga stanu bezczynnosci)
  glutMainLoop();

  return 0;
}