//////////////////////////////////////////////////////////////////////////////////////////
//
// Program wyswietlajacy szescian w rzucie perspektywicznym. Dlugosc boku szescianu
// moze byc interaktywnie zmieniana za pomoca klwiszy '+' i '-'.
//
//////////////////////////////////////////////////////////////////////////////////////////
#include <GL/glut.h>
#include <math.h>
#define M_PI acos(-1.0)

// Definicja stalych
#define DLUGOSC_BOKU            5.0
#define OBSERWATOR_FOV_Y        30.0

// Zmienne globalne
double  bok           = DLUGOSC_BOKU; // Dlugosc boku szescianu
int     szerokoscOkna = 1280;
int     wysokoscOkna  = 720;
float R = 20;
float r = 5;
float h = 10;
float pion = 4;
float dAlfa = 360 / 4;
float podzialp = 4;
GLfloat odlmin = -23;
GLfloat odlmax = -140;
GLfloat	odl = -50;
GLfloat rotObsY = 40.0;
GLfloat rotObsX = 10.0;
GLfloat rotObsZ = 0.0;

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

double DEG2RAD(double deg) {
    return (deg * M_PI) / 180.0;
}

void RysujXYZ() {
    glBegin(GL_LINES);

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

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

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

    // Koniec tworzenia ukladu wspolrzednych
    glEnd();
}




//////////////////////////////////////////////////////////////////////////////////////////
// Funkcja rysujaca szescian o boku "a" w trybie GL_QUAD_STRIP.
// Srodek szescianu znajduje się w punkcie (0,0,0).
void RysujSzescian(double a)
{
  // 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();
}
void RysujCylinder() {
    float temp_r = R;
    float podzial_r = (R-r) / podzialp;
    float temp_h = 0;
    float podzial_h = h / podzialp;
    glBegin(GL_TRIANGLE_FAN);
    glVertex3f(0, 0, 0);
    for (int b = 0; b * dAlfa <= 360.0; b++)
    {
        glVertex3f(R * cos(DEG2RAD(b * dAlfa)), 0.0, R * sin(DEG2RAD(b * dAlfa)));
    }
    glEnd();

    for (int a = 0; a < podzialp; a++) {
        glBegin(GL_QUADS);
        float i = 0;
        glVertex3f(temp_r * cos(DEG2RAD(i * dAlfa)), temp_h, temp_r * sin(DEG2RAD(i * dAlfa)));
        glVertex3f((temp_r - podzial_r) * cos(DEG2RAD(i * dAlfa)), temp_h + podzial_h, (temp_r - podzial_r) * sin(DEG2RAD(i * dAlfa)));
        for (i = 1; i * dAlfa < 360.0; i++)
        {
            glVertex3f((temp_r - podzial_r) * cos(DEG2RAD(i * dAlfa)), temp_h + podzial_h, (temp_r - podzial_r) * sin(DEG2RAD(i * dAlfa)));
            glVertex3f(temp_r * cos(DEG2RAD(i * dAlfa)), temp_h, temp_r * sin(DEG2RAD(i * dAlfa)));

            glVertex3f(temp_r * cos(DEG2RAD(i * dAlfa)), temp_h, temp_r * sin(DEG2RAD(i * dAlfa)));
            glVertex3f((temp_r - podzial_r) * cos(DEG2RAD(i * dAlfa)), temp_h + podzial_h, (temp_r - podzial_r) * sin(DEG2RAD(i * dAlfa)));
        }
        glVertex3f((temp_r - podzial_r) * cos(DEG2RAD(360)), temp_h + podzial_h, (temp_r - podzial_r) * sin(DEG2RAD(360)));
        glVertex3f(temp_r * cos(DEG2RAD(360)), temp_h, temp_r * sin(DEG2RAD(360)));
        temp_r -= podzial_r;
        temp_h += podzial_h;
        glEnd();
        glBegin(GL_TRIANGLE_FAN);
        glVertex3f(0, h, 0);
        for (int b = 0; b * dAlfa <= 360.0; b++)
        {
            glVertex3f(r * cos(DEG2RAD(b * dAlfa)), h, r * sin(DEG2RAD(b * dAlfa)));
        }
        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
  if (odl < odlmax) odl = odlmax;
  if (odl > odlmin) odl = odlmin;
  glTranslatef(0, 0, odl);
  glRotatef(rotObsX, 1, 0, 0);
  glRotatef(rotObsY, 0, 1, 0);
  glRotatef(rotObsZ, 0, 0, 1);


  RysujXYZ(); //Rysowanie linii układu
  glColor3f(1, 0, 1);
  RysujCylinder();
  glPushMatrix();
  glTranslatef(40, 0, 0);
  glColor3f(1, 1, 1);
  // Narysowanie szescianu
  RysujSzescian(bok);
  glPopMatrix;

  // Przelaczenie buforow ramki
  glutSwapBuffers();
}

// Funkcja klawiszy specjalnych
void ObslugaKlawiszySpecjalnych(int klawisz, int x, int y)
{
    switch (klawisz)
    {
    case GLUT_KEY_UP:
        rotObsX += 1.0;
        break;

    case GLUT_KEY_DOWN:
        rotObsX -= 1.0;
        break;

    case GLUT_KEY_LEFT:
        rotObsY += 1.0;
        break;

    case GLUT_KEY_RIGHT:
        rotObsY -= 1.0;
        break;
    }
}

//////////////////////////////////////////////////////////////////////////////////////////
// Funkcja obslugi klawiatury
void ObslugaKlawiatury(unsigned char klawisz, int x, int y)
{
  switch (klawisz) {
  case '+':
      bok *= 2.0;
      break;
  case '-':
      bok /= 2.0;
      break;
  case '[':
      rotObsZ -= 1.0;
      break;
  case ']':
      rotObsZ += 1.0;
      break;
  case 'o': //oddalanie obserwatora
      odl -= 1.0;
      break;
  case 'p': //przybliżanie obserwatora
      odl += 1.0;
      break;
  case '1':
      pion++;
      if (pion > 64)pion = 64;
      dAlfa = 360 / pion;
      break;
  case '!':
      pion--;
      if (pion < 4)pion = 4;
      dAlfa = 360 / pion;
      break;
  case '2':
      podzialp++;
      if (podzialp > 64)podzialp = 64;
      break;
  case '@':
      podzialp--;
      if (podzialp < 4)podzialp = 4;
      break;
  }
  if(klawisz == 27)
      exit(0);

}


//////////////////////////////////////////////////////////////////////////////////////////
// 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("Szescian");

  // Odblokowanie bufora glebokosci
  glEnable(GL_DEPTH_TEST);

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

  // Ustawienie koloru czyszczenia bufora ramki
  glClearColor (0.0f, 0.0f, 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;
}