//////////////////////////////////////////////////////////////////////////////////////////
//
// Program wyswietlajacy szescian w rzucie perspektywicznym. Dlugosc boku szescianu
// moze byc interaktywnie zmieniana za pomoca klwiszy '+' i '-'.
//
//////////////////////////////////////////////////////////////////////////////////////////


//ZESTAW 4, ZADANIE 4 - Indywidualne
#include <GL/glut.h>
#include <math.h>

// Definicja stalych
#define DLUGOSC_BOKU            10.0
#define OBSERWATOR_ODLEGLOSC    20.0
#define OBSERWATOR_OBROT_X      20.0
#define OBSERWATOR_OBROT_Y      20.0
#define OBSERWATOR_FOV_Y        30.0

int zmienna = 5;
int zmienna2 = 5;

// Zmienne globalne
double  bok           = DLUGOSC_BOKU; // Dlugosc boku szescianu
int     szerokoscOkna = 800;
int     wysokoscOkna  = 600;
GLfloat minOdl = -10.0;
GLfloat maxOdl = -200.0;
GLfloat obsOdl = -100.0;
GLfloat rotObsY     = 40.0;
GLfloat rotObsX     = 40.0;
GLfloat rotObsZ = 0.0;

// Prototypy funkcji
void RysujSzescian(int N);
void UstawParametryWidoku(int szer, int wys);
void WyswietlObraz(void);
void ObslugaKlawiatury(unsigned char klawisz, int x, int y);
void ObslugaKlawiszySpecjalnych(int 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 stozek(float R, float r, float y, float h, int n)
{
    float alfa;
    int i;
    float x;
    float z;

    glBegin(GL_QUAD_STRIP);

    alfa = 360.0/n;
    for(i=0;i<=n;i++)
    {
        x = cos(0.0174532925f*i*alfa);
        z = sin(0.0174532925f*i*alfa);

        glVertex3f(x*R,y+0,z*R);
        glVertex3f(x*r,y+h,z*r);
    }


    x = cos(0.0);
    z = sin(0.0);

    glVertex3f(x*R,y+0,z*R);
    glVertex3f(x*r,y+h,z*r);

    glEnd();
}

void powBocznaWalca(float R, float r, float y, float h, int n)
{
    float alfa;
    int i;
    float x;
    float z;
glColor3f(0,1,1);
    glBegin(GL_QUAD_STRIP);

    alfa = 360.0/n;
    for(i=0;i<=n;i++)
    {
        x = cos(0.0174532925f*i*alfa);
        z = sin(0.0174532925f*i*alfa);

        glVertex3f(x*R,y+0,z*R);
        glVertex3f(x*r,y+h,z*r);
    }


    x = cos(0.0);
    z = sin(0.0);

    glVertex3f(x*R,y+0,z*R);
    glVertex3f(x*r,y+h,z*r);

    glEnd();
}

void RysujKolo(float R, float y, int n)
{
    float alfa;
    int i;
    float x;
    float z;

    glBegin(GL_TRIANGLE_FAN);
glColor3f(1,0.4,1);
    glVertex3f(0,y,0);

    alfa = 360.0f/n;
    for(i=0;i<=n;i++)
    {
        x = cos(0.0174532925f*i*alfa);
        z = sin(0.0174532925f*i*alfa);

        glVertex3f(x*R,y+0,z*R);
    }


    x = cos(0.0);
    z = sin(0.0);

    glVertex3f(x*R,y+0,z*R);

    glEnd();
}

void RysujStozekZPodzialami(float R, float r, float h, int n, int m)
{
    int i;
    float dR,dr,dh, y, tmp1, tmp2;
    dh = h/m;
    for(i=0;i<m;i++)
    {
        y = dh*i;
        tmp1 = y/h;
        tmp2 = (y+dh)/h;
        dR = R + (r-R)*tmp1;
        dr = R + (r-R)*tmp2;
        stozek(dR, dr, y, dh, n);
    }
    RysujKolo(R, 0, n);
    RysujKolo(r, h, n);
}

void rysowanieWalca(float R, float r, float h, int n, int m){
int i;
    float dR,dr,dh, y, tmp1, tmp2;
    dh = h/m;
    for(i=0;i<m;i++)
    {
        y = dh*i;
        tmp1 = y/h;
        tmp2 = (y+dh)/h;
        dR = R + (r-R)*tmp1;
        dr = R + (r-R)*tmp2;
        powBocznaWalca(dR, dr, y, dh, n);
    }
    RysujKolo(R, 0, n);
    RysujKolo(r, h, n);

}

void RysujSzescian()
{

// Pocztaek tworzenia ukladu wspolrzednych
  glBegin(GL_LINES);

  // Os X
  glColor3f(1.0, 0.0, 0.0);

  glVertex3f(-25.0, 0.0, 0.0);
  glVertex3f(25.0, 0.0, 0.0);

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

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

  // Koniec tworzenia ukladu wspolrzednych
  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, obsOdl);
  glRotatef(rotObsX, 1, 0, 0);
  glRotatef(rotObsY,0,1,0);
  glRotatef(rotObsZ, 0, 0, 1);
  // Narysowanie szescianu
  RysujSzescian();
  glColor3f(1.0, 1.0, 1.0);
 //stozek(20, 5, 20, zmienna, zmienna2);
 rysowanieWalca(1,1,3,zmienna, zmienna2);
  // Przelaczenie buforow ramki
  glutSwapBuffers();
}


//////////////////////////////////////////////////////////////////////////////////////////
// Funkcja obslugi klawiatury
void ObslugaKlawiatury(unsigned char klawisz, int x, int y)
{
 switch(klawisz)
  {

case '+':
case '=':
if (obsOdl < minOdl)
obsOdl++;
break;

case '-':
case '_':
if (obsOdl > maxOdl)
obsOdl--;
break;

case 'z':
rotObsZ++;
break;

case 'x':
rotObsZ--;
break;

case '1':
zmienna = (zmienna>4) ? zmienna-1 : zmienna;
break;
case '2':
zmienna = (zmienna<64) ? zmienna+1 : zmienna;
break;
case '3':
zmienna2 = (zmienna2>4) ? zmienna2-1 : zmienna2;
break;
case '4':
zmienna2 = (zmienna2<64) ? zmienna2+1 : zmienna2;
break;
  }
}

void ObslugaKlawiszySpecjalnych(int klawisz, int x, int y)
{
  switch(klawisz)
  {
case GLUT_KEY_UP:
rotObsX--;
break;

case GLUT_KEY_DOWN:
rotObsX++;
break;

case GLUT_KEY_LEFT:
rotObsY--;
break;

case GLUT_KEY_RIGHT:
rotObsY++;
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("Walec");

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

  //DOPISANE
  glutSpecialFunc(ObslugaKlawiszySpecjalnych);

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

  return 0;
}