#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include <gl\gl.h>
#include <gl\glut.h>

//Wymiary okna
int screen_width=1024;
int screen_height=768;

//Mysz
int pozycjaMyszyX;
int pozycjaMyszyY;

//Kamera
double kameraX;
double kameraZ;
double kameraPredkosc;

double kameraKat;
double kameraPredkoscObrotu;

GLfloat y[4], xx[4], zz[4];     //Tablice z punktami oczek siatki prostokatnej
GLfloat x,z;                    //Zmienne x,z
GLfloat k = 0.1;                //Zmienna symulujaca ruch obiektu
GLfloat rotatex = 0.0, rotatey = 0.0, rotatez = 0.0;      //Zmienne rotacji OX OY OZ
GLfloat scx = 0.1, scz = 0.1;    //Zmienne skalowania oczek siatki prostokatnej
GLfloat vnorm[3], points[3][3];  //Tablice tworzace wektor normalny
int fill = 1, animation = 0, light = 1, normalize = 1;   //Zmienne wlaczajace odpowiednie opcje: Wypelnij, Animacje, Światlo, Obliczanie Wekt. Norm.

enum{EXIT,FILL_OFF,FILL_ON,ANIM_OFF,ANIM_ON,LIGHT_OFF,LIGHT_ON,VNORM_OFF ,VNORM_ON}; //Stale obslugi menu

/**********************************************************/
void Menu( int value)
{

switch (value)
 {
  case FILL_OFF:            //Wypelnianie
      fill = 0;break;
  case FILL_ON:
      fill = 1;break;
  case ANIM_OFF:            //Animacja
       animation = 0;
       break;
  case ANIM_ON:
       animation = 1;
       break;
  case LIGHT_OFF:           //Światlo
       light = 0;
       break;
  case LIGHT_ON:
       light = 1;
       break;
  case VNORM_OFF:           //Wektor Normalny
       normalize = 0;
       break;
  case VNORM_ON:
       normalize = 1;
       break;
  case EXIT:                 //EXIT
     exit(0);
  }
}
/**********************************************************/
void resetKamery(){

    kameraX = 0;
    kameraZ = 0;
    kameraPredkosc = 0;
    kameraKat = 0;
    kameraPredkoscObrotu = 0;

}
/**********************************************************/
void mysz (int button, int state, int x, int y)
{
switch (state)
    {
        case GLUT_UP:
            kameraPredkosc = 0;
            kameraPredkoscObrotu = 0;
        break;
        case GLUT_DOWN:
            pozycjaMyszyX = x;
            pozycjaMyszyY = y;
        break;

    }
}
/**********************************************************/
void mysz_ruch (int x, int y)
{
    kameraPredkoscObrotu = -(pozycjaMyszyX - x) * 0.00001;
    kameraPredkosc = (pozycjaMyszyY - y) * 0.001;
}
/**********************************************************/
void klawisz (GLubyte key, int x, int y)
{
   switch (key) {

   case 27:    /* Esc - koniec */
      exit(1);
      break;
   case ' ':
      glutFullScreen();        //FullScreen
      break;
   case 'q':                   //Rotacja OX
      rotatex++;
      break;
   case 'w':
      rotatex--;
      break;
   case 'a':                   //Rotacja OY
      rotatey++;
      break;
   case 's':
      rotatey--;
      break;
   case 'z':                   //Rotacja OZ
      rotatez++;
      break;
   case 'x':
      rotatez--;
      break;
   case '-':                   //Skalowanie oczek siatki
        if( scx < 4.9 || scz < 3.7 )        //Oczko siatki nie może być za duże
        {
            scx += 0.08;
            scz += 0.06;
        }
        else
        {
            scx = 4.97;
            scz = 3.75;
        }
      break;
   case '+':
        if( scx > 0.17 || scz > 0.15 )      //Oczko siatki nie może być za małe
        {
            scx -= 0.08;
            scz -= 0.06;
        }
        else
        {
            scx = 0.1;
            scz = 0.1;
        }
      break;
   }
}
/**********************************************************/
void rozmiar (int width, int height)
{
    screen_width=width;
    screen_height=height;

    glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glViewport(0,0,screen_width,screen_height);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(45.0f,(GLfloat)screen_width/(GLfloat)screen_height,1.0f,1000.0f);
    glutPostRedisplay (); // Przerysowanie sceny
}
/**********************************************************/
// Funkcja normalizująca wektor podany jako zbiór trzech współrzędnych
void ReduceToUnit(float vector[3])
{
     float length;
     // Oblicz długość wektora
     length= (float)sqrt( (vector[0]*vector[0]) + (vector[1]*vector[1]) + (vector[2]*vector[2]));
     if(length== 0.0f)
         length= 1.0f;   // Zabezpieczenie przed podziałem przez 0

     // Podziel każdą ze współrzędnych przez długość wektora
     vector[0] /= length;
     vector[1] /= length;
     vector[2] /= length;
}
/**********************************************************/
// Punkty p1, p2 i p3 zdefiniowane w odwrotnym do wskazówek zegara porządku
void calcNormal(float v[3][3], float out[3])
{
     float v1[3],v2[3]; static const int x = 0; static const int y = 1; static const int z = 2;
     // Oblicz 2 wektory na podstawie trzech punktów
     v1[x] = v[0][x] -v[1][x];
     v1[y] = v[0][y] -v[1][y];
     v1[z] = v[0][z] -v[1][z];
     v2[x] = v[1][x] -v[2][x];
     v2[y] = v[1][y] -v[2][y];
     v2[z] = v[1][z] -v[2][z];
     // Oblicz współrzędne wektora normalnego na podstawie iloczynu wektorowego
     out[x] = v1[y]*v2[z] -v1[z]*v2[y];
     out[y] = v1[z]*v2[x] -v1[x]*v2[z];
     out[z] = v1[x]*v2[y] -v1[y]*v2[x];
     // Normalizuj wektor
     ReduceToUnit(out);
}
/**********************************************************/
void createTab( float a[], float b[], float c[], float wyj[3][3] )
{
                  wyj[0][0] = a[0];
                  wyj[0][1] = b[0];
                  wyj[0][2] = c[0];
                  wyj[1][0] = a[1];
                  wyj[1][1] = b[1];
                  wyj[1][2] = c[1];
                  wyj[2][0] = a[2];
                  wyj[2][1] = b[2];
                  wyj[2][2] = c[2];
}
/**********************************************************
        Glowna metoda rysujaca
 *********************************************************/
void rysuj(void)
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Kasowanie ekranu
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();

    kameraKat+=kameraPredkoscObrotu;
    kameraX+=kameraPredkosc*sin(kameraKat);
    kameraZ-=kameraPredkosc*cos(kameraKat);
    gluLookAt (kameraX,0,kameraZ,kameraX + 100*sin(kameraKat),0,kameraZ - 100*cos(kameraKat),0,1,0); // kamera

    glEnable(GL_COLOR_MATERIAL);
    glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
    glEnable(GL_LIGHTING);

    //Ustawienie Swiatla
    GLfloat  ambientLight[4] = {1.0,0.0,0.0,1};;
    GLfloat  diffuseLight[4] = {1,1,1,1};;
    GLfloat  specular[4] = {0.1,0.1,0.1,1};;
    GLfloat  lightPos[4] = {4,20,0,1};;

    glLightfv(GL_LIGHT1,GL_AMBIENT,ambientLight);
    glLightfv(GL_LIGHT1,GL_DIFFUSE,diffuseLight);
    glLightfv(GL_LIGHT1,GL_SPECULAR,specular);
    glLightfv(GL_LIGHT1,GL_POSITION,lightPos);

    //Wlacz - Wylacz Swiatlo
    switch( light )
    {
    case 1:
         glEnable(GL_LIGHT1);
         break;
    case 0:
         glDisable(GL_LIGHT1);
         break;
    }

    //Ustawienie sceny
    glTranslatef(0.0,0.0,-20); // przesuniecie obiektu przed kamerŕ
    glRotatef(-60,1.0,0.0,0.0);

    //Rotacja sceny
    glRotatef( rotatex, 1.0, 0, 0 );
    glRotatef( rotatey, 0.0, 1.0, 0 );
    glRotatef( rotatez, 0.0, 0, 1.0 );

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

    //Wlacz: Siatke - Wypelnienie
    switch( fill )
    {
     case 0:
            glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
            break;
     case 1:
            glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
            break;
    }

    //Wyrysowanie obiektu
    glColor3f(1,1,1);
    glBegin(GL_QUADS);
    for( x = -5; x <= 5; x += scx )
    {
         for(z = -5; z <= 5; z += scz )
         {
               //Pkt. X
               xx[0] = x;
               xx[1] = x+scx;
               xx[2] = x+scx;
               xx[3] = x;

               //Pkt. Z
               zz[0] = z;
               zz[1] = z;
               zz[2] = z+scz;
               zz[3] = z+scz;

               //Pkt. Y
               y[0] = sin( ( (xx[0]*zz[0]) / 5 ) + k );
               y[1] = sin( ( (xx[1]*zz[1]) / 5 ) + k );
               y[2] = sin( ( (xx[2]*zz[2]) / 5 ) + k );
               y[3] = sin( ( (xx[3]*zz[3]) / 5 ) + k );

               //Wlacz - Wylacz obliczanie wektorow normalnych
               switch( normalize )
               {
                       case 1:
                            createTab( xx, y, zz, points );
                            calcNormal(points,vnorm);
                            glNormal3f(vnorm[0], vnorm[1], vnorm[2]);
                            break;
                       case 0:
                            glNormal3f(1, 1, 1);
                            break;
               }

               glVertex3f(xx[0],y[0],zz[0]);
               glVertex3f(xx[1],y[1],zz[1]);
               glVertex3f(xx[2],y[2],zz[2]);
               glVertex3f(xx[3],y[3],zz[3]);
         }
    }
    glEnd();
    glDisable(GL_COLOR_MATERIAL);
    /*****************************************************/

    glFlush(); // rysowanie w buforze
    glutSwapBuffers(); // Wyslanie na ekran
}

void timer(int value){
  //Wlacz - Wylacz Animacje
  switch( animation )
  {
  case 1:
       k += 0.1;
       break;
  case 0:
       k = 0.0;
       break;
  }
  glutTimerFunc(10, timer, 0);
}
/*****************************************************/
int main(int argc, char **argv)
{
    // INIT - wszystkie funkcje obs-ugi okna i przetwzrzania zdarze˝ realizuje GLUT
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
    glutInitWindowSize(screen_width,screen_height);
    glutInitWindowPosition(0,0);
    glutCreateWindow("Scena Glowna");

    glutTimerFunc(10, timer, 0); ///def. funkcji nakazującej odczekiwać msecs (tutaj 20) milisekund przed każdym wywołaniem funkcji timer.
    glutDisplayFunc(rysuj);         // def. funkcji rysujacej
    glutIdleFunc(rysuj);            // def. funkcji rysujacej w czasie wolnym procesoora (w efekcie: ciagle wykonywanej)
    glutReshapeFunc (rozmiar);      // def. obslugi zdarzenia resize (GLUT)

    glutKeyboardFunc (klawisz);
    glutMouseFunc(mysz);        // def. obsługi zdarzenia przycisku myszy (GLUT)
    glutMotionFunc(mysz_ruch); // def. obsługi zdarzenia ruchu myszy (GLUT)
    resetKamery();

    //Tworzymy podmenu - MODEL
    int Wypelniaj = glutCreateMenu (Menu);
    glutAddMenuEntry("Wypełnianie",FILL_ON);
    glutAddMenuEntry("Siatka",FILL_OFF);

    //Tworzymy podmenu - ANIMACJA
    int Animacja = glutCreateMenu (Menu);
    glutAddMenuEntry("Start",ANIM_ON);
    glutAddMenuEntry("Stop",ANIM_OFF);

    //Tworzymy podmenu - SWIATLA
    int Swiatla = glutCreateMenu (Menu);
    glutAddMenuEntry("Włącz",LIGHT_ON);
    glutAddMenuEntry("Wyłacz",LIGHT_OFF);

    //Tworzymy podmenu - OBLICZANIE WEKT. NORMALNYCH
    int Vornm = glutCreateMenu (Menu);
    glutAddMenuEntry("Włącz",VNORM_ON);
    glutAddMenuEntry("Wyłacz",VNORM_OFF);

    // menu główne
    glutCreateMenu (Menu);
    glutAddSubMenu ("Model",Wypelniaj);
    glutAddSubMenu ("Światła",Swiatla);
    glutAddSubMenu ("Animacja",Animacja);
    glutAddSubMenu ("Oblicz Wekt. Normalne",Vornm);
    glutAddMenuEntry("Wyjście",EXIT); //dodanie pozycji do menu
    glutAttachMenu(GLUT_RIGHT_BUTTON); //określenie przycisku myszki do obsługo menu

    // ustawienie renderowania
    glEnable(GL_DEPTH_TEST);

    glutMainLoop();                 // start obslugi komunikatow
    return(0);
}