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

// Definicja stalych
#define WYSOKOSC				4.0
#define PROMIEN                 5.0
#define PROMIEN2                 1.0
#define OBSERWATOR_FOV_Y        30.0
#define PODZIAL_X			    20.0
#define PODZIAL_Y				20.0
GLfloat OBSERWATOR_OBROT_Z    =  20.0;
GLfloat OBSERWATOR_OBROT_X   =   20.0;
GLfloat OBSERWATOR_OBROT_Y   =   20.0;
GLfloat OBSERWATOR_ODLEGLOSC = -40.0;
GLfloat odminimalna= -5;
GLfloat odmaxymalna = -200;
GLfloat N = 60.0;
GLfloat Nmin = 10.0;
GLfloat Nmax = 150.0;


// Makro przeliczajace stopnie na radiany
#define DEG2RAD(x)       ((float)(x)*M_PI/180.0)


// Zmienne globalne
double  promien       = PROMIEN; // Dlugosc boku szescianu
double  promien2       = PROMIEN2; // Dlugosc boku szescianu
double wysokosc		  = WYSOKOSC;
int     szerokoscOkna = 1024;
int     wysokoscOkna  = 768;
float j = 0, i = 0;
float a,x,y,z;


// Prototypy funkcji
void UstawParametryWidoku(int szer, int wys);
void WyswietlObraz(void);
void ObslugaKlawiatury(unsigned char klawisz, int x, int y);
void UstawDomyslneWartosciParametrow(void);
void RysujTekstRastrowy(void *font, char *tekst);
void UstawKolorPozycji(int m, int indeks);
void WlaczOswietlenie(void);
void DefiniujMaterial(void);
void UstawParametryOswietlenia(int indeks, char operacja);
void UstawParametryMaterialu(int indeks, char operacja);
void RysujWalec(double h, double r, int nv, int nh);
void UstawParametryWidoku(int szer, int wys);
void RysujNakladke(void);
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).

  // Skopiowanie Właściwości materiału - złoto
 /*
  memcpy(material[0], GoldAmbient, 4*sizeof(GLfloat));
  memcpy(material[1], GoldDiffuse, 4*sizeof(GLfloat));
  memcpy(material[2], GoldSpecular, 4*sizeof(GLfloat));
  memcpy(material[3], &GoldShininess, 4*sizeof(GLfloat));
  memcpy(material[4], Emission, 4*sizeof(GLfloat));
  */
  // Parametry walca


void RysujStozek(double R1, double R2, double H)
{

     float x, y, z, fi, OD, DO, OD1, DO1, R = R1;
     const long double PI = 3.1415926535897932384626433832795028841971693993751058209, EPS = PODZIAL_X, EPS2 = PODZIAL_Y;
	 OD1 = 0.0;
	 DO1 = 2.0001*PI;
	 OD = 0.0;
	 DO = 2.0001*PI;

	 glBegin(GL_LINES);



	 glBegin(GL_TRIANGLE_STRIP);
	 glColor3f(0.0,0.0,1.0);
	 for(y=0 ; (y<=H)&&(R>=R2) ; y+=H/N, R-=((R1-R2)/N))
	 {

		 for(fi = OD1; fi < DO1; fi += PI/N)
			  {
				   x = R * cos(fi);
				   z = R * sin(fi);
				   glVertex3f(x, y, z);

				   x = (R-((R1-R2)/N)) * cos(fi+ PI/N);
				   z = (R-((R1-R2)/N)) * sin(fi+ PI/N);
				   glVertex3f(x, (y+H/N), z);



	}
			  }
	  glEnd();
	 glBegin(GL_TRIANGLE_FAN);
	 glColor3f(0.0,1.0,0.0);
		  glVertex3f(0.0, 0.0, 0.0);
          for(fi = OD; fi <= DO; fi += PI/N)
          {
               x = R1 * cos(fi);
               z = R1 * sin(fi);
               glVertex3f(x, 0, z);

          }

     glEnd();

     glBegin(GL_TRIANGLE_FAN);
	 glColor3f(1.0,0.0,0.0);
		  glVertex3f(0, H, 0);
          for(fi = OD; fi < DO; fi += PI/N)
          {
               x = R2 * cos(fi);
               z = R2 * sin(fi);
               glVertex3f(x, H, z);

          }

     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, OBSERWATOR_ODLEGLOSC);
  glRotatef(OBSERWATOR_OBROT_X, 1, 0, 0);
  glRotatef(OBSERWATOR_OBROT_Y, 0, 1, 0);
  glRotatef(OBSERWATOR_OBROT_Z, 0, 0, 1);

  // Narysowanie szescianu
  RysujStozek(promien, promien2, wysokosc);

  // Przelaczenie buforow ramki
  glutSwapBuffers();
}


//////////////////////////////////////////////////////////////////////////////////////////
// Funkcja obslugi klawiatury
void ObslugaKlawiatury(unsigned char klawisz, int x, int y)
{
	if (klawisz == '+')
	{
		promien *= 1.01;
		promien2 *= 1.01;
	}
	else if (klawisz == '-')
	{
		promien /= 1.01;
		promien2 /= 1.01;
	}
	else if (klawisz == 27)
		exit(0);
	else if (klawisz == 'w')
		OBSERWATOR_OBROT_X = OBSERWATOR_OBROT_X + 1.0;
	else if (klawisz == 's')
		OBSERWATOR_OBROT_X = OBSERWATOR_OBROT_X - 1.0;
	else if (klawisz == 'd')
		OBSERWATOR_OBROT_Y = OBSERWATOR_OBROT_Y + 1.0;
	else if (klawisz == 'a')
		OBSERWATOR_OBROT_Y = OBSERWATOR_OBROT_Y - 1.0;
	else if (klawisz == 'e')
		OBSERWATOR_OBROT_Z = OBSERWATOR_OBROT_Z + 1.0;
	else if (klawisz == 'q')
		OBSERWATOR_OBROT_Z = OBSERWATOR_OBROT_Z - 1.0;
	else if (klawisz == 'r')
		OBSERWATOR_ODLEGLOSC = (OBSERWATOR_ODLEGLOSC < odminimalna) ? OBSERWATOR_ODLEGLOSC + 1.0 : OBSERWATOR_ODLEGLOSC;
	else if (klawisz == 'f')
		OBSERWATOR_ODLEGLOSC = (OBSERWATOR_ODLEGLOSC > odmaxymalna) ? OBSERWATOR_ODLEGLOSC - 1.0 : OBSERWATOR_ODLEGLOSC;
	else if (klawisz == '1')
		N+=5.0;//N = (N < Nmin) ? N + 5.0 : N;
	else if (klawisz == '2')
		N-=5.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("Stozek - GL_TRIANGLE_STRIP");

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

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

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

  return 0;
}