slon

#include <GL/glut.h>
#include <GL/gl.h>
#include <GL/glu.h>//////////////////////////////////////////////////////////////////////////////////////////
// Program demonstruje  skladanie transformacji przy modelowaniu zlozonych obiektow
// skladajacych sie z wielu elementow ruchomych (ramie robota).

#include <GL/glut.h>


// Wskazniki do wykorzystywanych kwadryk
GLUquadricObj *podstawaSciany;
GLUquadricObj *podstawaDyskG;
GLUquadricObj *przegubSciany;
GLUquadricObj *przegubDyskG;
GLUquadricObj *przegubDyskD;
GLUquadricObj *glowicaSciany;
GLUquadricObj *glowicaDyskG;
GLUquadricObj *glowicaDyskD;

GLfloat rotObsY     = 40.0;
GLfloat rotObsX     = 40.0;
GLfloat rotObsZ     = 0.0;
GLfloat rotPodstawy = 0.0;
GLfloat rotRamienia1= 40.0;
GLfloat rotRamienia2= -40.0;
GLfloat rotGlowicy  = 20.0;
GLfloat rozUchwytow = 0.5;

GLfloat rotacjaPlanety = 0.0;
GLfloat rotacjaKsiezyca = 0.0;
GLfloat spinPlanety = 0.0;

GLfloat odlMin = -80;
GLfloat Odl = -50;
GLfloat odlMax = -10;
GLfloat zoomSpeed = 0.5;
GLUquadricObj* orbitaPlanety;
GLUquadricObj* orbitaKsiezyca;
GLUquadricObj* cylinder;
GLUquadricObj* prostokat;
GLUquadricObj* orbita;
GLUquadricObj* orbitaKsiezyc;


float alp=0, spin=0,moon=0;
//////////////////////////////////////////////////////////////////////////////////////////
// Funkcja inicjujaca elementy skladowe ramienia robota zamodelowane jako kwadryki
//
void InicjujRamieRobota(void)
{
  // Zainicjowanie scian bocznych walca bedacego podstawa ramienia
  podstawaSciany = gluNewQuadric();
  gluQuadricDrawStyle(podstawaSciany, GLU_LINE);

  // Zainicjowanie gornej podstawy walca
  podstawaDyskG = gluNewQuadric();
  gluQuadricDrawStyle(podstawaDyskG, GLU_LINE);

  // Zainicjowanie scian bocznych cylindrycznego przegubu ramienia
  przegubSciany = gluNewQuadric();
  gluQuadricDrawStyle(przegubSciany, GLU_LINE);

  // Zainicjowanie gornej podstawy walca
  przegubDyskG = gluNewQuadric();
  gluQuadricDrawStyle(przegubDyskG, GLU_LINE);

  // Zainicjowanie dolnej podstawy walca
  przegubDyskD = gluNewQuadric();
  gluQuadricDrawStyle(przegubDyskD, GLU_LINE);

  // Zainicjowanie scian bocznych cylindra glowicy
  glowicaSciany = gluNewQuadric();
  gluQuadricDrawStyle(glowicaSciany, GLU_LINE);

  // Zainicjowanie gornej podstawy walca
  glowicaDyskG = gluNewQuadric();
  gluQuadricDrawStyle(glowicaDyskG, GLU_LINE);

  // Zainicjowanie dolnej podstawy walca
  glowicaDyskD = gluNewQuadric();
  gluQuadricDrawStyle(glowicaDyskD, GLU_LINE);

  cylinder = gluNewQuadric();
  gluQuadricDrawStyle(cylinder, GLU_FILL);

  prostokat = gluNewQuadric();
  gluQuadricDrawStyle(prostokat, GLU_FILL);

  orbita = gluNewQuadric();
  gluQuadricDrawStyle(orbita, GLU_LINE);

  orbitaKsiezyc = gluNewQuadric();
  gluQuadricDrawStyle(orbitaKsiezyc, GLU_LINE);

}

GLfloat zmienna = 0;
GLfloat spinukladu = 0.0;
GLUquadricObj* slonce;
GLUquadricObj* planeta;
GLUquadricObj* kk;
int i=0;
float obrot=0;
float poruszaj = 0;
float poruszajKsiezyc = 0;
int flag=0;
float obrotPlanety = 0;
GLfloat spinPlaneta = 0;
float obrotKsiezyca = 0;
//////////////////////////////////////////////////////////////////////////////////////////
// Funkcja rysujaca obraz sceny widzianej z biezacej pozycji obserwatora
// Zalozenie: Funkcja glutWireSpehere moze ryswac tylko sfere o promieniu 1
void RysujRamieRobota(GLfloat obrotPodstawy, GLfloat obrotRamienia1,
              GLfloat obrotRamienia2, GLfloat obrotGlowicy,
              GLfloat rozstawUchwytow)
{
  // Pocztaek tworzenia ukladu wspolrzednych
  glBegin(GL_LINES);

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

  // Os Y Green
  glColor3f(0.0,1.0,0.0);
  glVertex3f(0.0, -40.0, 0.0);
  glVertex3f(0.0, 20.0, 0.0);

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

  // Koniec tworzenia ukladu wspolrzednych
  glEnd();

  poruszaj += 0.25;
  zmienna += 1;
  poruszajKsiezyc += 0.5;
  //slonce
  glColor3f(1,1,0);
  glPushMatrix();
	glTranslatef(0,0,0);
	glRotatef(-90.0,1,0,0);

	glutWireSphere(2.5,20,20);
  glPopMatrix();

  //elipsa
  glColor3f(0, 1, 0.4);
  glPushMatrix();
  glRotatef(90,1,0,0);
  glTranslatef(0, 0, 0);
  gluDisk(orbita, 20, 20, 50, 1);
  glPopMatrix();

  //ziemia
  glColor3f(0, 0, 1);
  glPushMatrix();

	  glRotatef(poruszaj, 0, 1, 0);
	  glTranslatef(0, 0, 20);
	  glRotatef(zmienna, 1, 0, 0);
	  glutWireSphere(1, 20, 20);
  glPopMatrix();

  //orbitaksiezyca
  glColor3f(1, 0, 1);
  glPushMatrix();
  glRotatef(poruszaj, 0, 1, 0);
  glTranslatef(0,0,20);
  glRotatef(90.0, 1, 0, 0);
  gluDisk(orbitaKsiezyc,2.5,2.5,50,1);

  glPopMatrix();


  //ksiezyc
  glColor3f(0.75, 0.75, 0.75);
  glPushMatrix();


  glRotatef(-poruszaj, 0, 1, 0);
  glRotatef(poruszajKsiezyc, 0, 1, 0);
  glTranslatef(0, 0, 20);
  glRotatef(poruszajKsiezyc, 0, 1, 0);
  glTranslatef(0, 0, 2.5);

  glutWireSphere(0.25, 20, 20);
  glPopMatrix();









  /*

  glColor3f(1.0, 1.0, 1.0);




  // Przygotowanie stosu macierzy modelowania
  glPushMatrix();

  // Rysowanie podstawy ramienia (cylinder bez dolnej podstawy)
  //

											//glowa
  glTranslatef(0.0, 0.0, 0.0);
  glRotatef(0, 1, 0, 0);
  glRotatef(obrotGlowicy, 0, 1, 0);

  glPushMatrix();
  glTranslatef(0.0, 4.5, 0.0);
  glutWireSphere(0.75, 20, 20);
  glPopMatrix();



  //OBROT DZIAŁA W PIONIE
	// Wyznaczenie osi obrotu ramienia w plaszczyznie pionowej
  glTranslatef(0.0, 4.0, 0.0);

  // Obrot ramienia w plaszczyznie pionowej
  glRotatef(obrotRamienia1, 0, 0, 1);



  // - deska
  glPushMatrix();
  glRotatef(-90.0, 1, 0, 0);
  glTranslatef(0.0, 0.0, 0.3);
  glScalef(1.25, 4.0, 0.5);
  glutWireCube(1.0);
  glTranslatef(0.0, 0.0, 1.0);
  glPopMatrix();


  // Modelowanie ramienia nr 2
  glPushMatrix();
  glScalef(4.0, 1.0, 1.0);
  glTranslatef(2.0 / 4.0, 1.5, 2.0);
  glPopMatrix();


  //dzialo lewe
  glPushMatrix();
  glRotatef(90.0, 0, 1, 0);
  glTranslatef(2.0, -0.5, -1.5);
  gluCylinder(podstawaSciany, 0.5, 0.5, 6.0, 20, 4);
  glTranslatef(0.0, 0.0, 0);
  gluDisk(podstawaDyskG, 0.0, 0.5, 20, 4);
  glPopMatrix();
  //dzialo prawe
  glPushMatrix();
  glRotatef(90.0, 0, 1, 0);
  glTranslatef(-2.0, -0.5, -1.5);
  gluCylinder(podstawaSciany, 0.5, 0.5, 6.0, 20, 4);
  glTranslatef(0.0, 0.0, 0.0);
  gluDisk(podstawaDyskG, 0.0, 0.5, 20, 4);
  glPopMatrix();


  // Wyznaczenie osi obrotu glowicy

  glPopMatrix();




  //podstawa
  glPushMatrix();
  // - sciany boczne
  glRotatef(-90.0, 1, 0, 0);
  gluCylinder(podstawaSciany, 2.5, 2.5, 1.0, 20, 4);

  // - gorna podstawa
  glTranslatef(0.0, 0.0, 1.0);
  gluDisk(podstawaDyskG, 0.0, 2.5, 20, 4);

  // - dolna podstawa
  glTranslatef(0.0, 0.0, -1.0);
  gluDisk(podstawaDyskG, 0.0, 2.5, 20, 4);
  glPopMatrix();


  //walec pionowy
  glPushMatrix();
  // - sciany boczne
  glTranslatef(0.0, 1.0, 0.0);
  glRotatef(-90.0, 1, 0, 0);
  gluCylinder(podstawaSciany, 0.625, 0.625, 3.0, 20, 4);
  glPopMatrix();



  // Posprzatanie na stosie macierzy modelowania




  */






















  /*
  //push matrix i pop,. w ich "ciele" musi być jakiś tam obiekt graficzny, ale chyba MAX jeden.
  glColor3f(1, 0, 0);
  glPushMatrix();
	  glTranslatef(0, 5, 0);
	  glRotatef(45.0, 0, 1, 0); // obracasz sześcian o kąt 45st według osi Y.
	  glScalef(6,10,6);  // skalujesz - niżej opisałem.
	  glutSolidCube(1);
  glPopMatrix();

  glColor3f(0, 1, 0);//kolorek tej nadbudówki
  glPushMatrix();
	  glTranslatef(0,11.5,0); // przesuwasz o 10+1,5 nadbudówke od początku układu w góre żeby byo widać
	  glScalef(8, 3, 8); //rozciągasz sześcian sobie na takie wartości.
	  glutSolidCube(1); // i myk rysujesz sześcian 1x1x1 ale on sie przeskaluje przez glScalef
  glPopMatrix();

  glColor3f(0,0,1); // Kolorek tych takich wieżyczek
  glPushMatrix();
    glTranslatef(3,13.5,3); // przesuwasz sobie obiekt w takie koordy
	glutSolidCube(2); // tworzysz w tym miejscu sześcian 2x2x2
  glPopMatrix();
  //analogicznie
  glPushMatrix();
	  glTranslatef(-3, 13.5, 3);
	  glutSolidCube(2);
  glPopMatrix();
  glPushMatrix();
	  glTranslatef(-3, 13.5, -3);
	  glutSolidCube(2);
  glPopMatrix();

  glPushMatrix();
	  glTranslatef(3, 13.5, -3);
	  glutSolidCube(2);
  glPopMatrix();
  */
 /*
    gluCylinder(cylinder,2,2,5,10,10);

    glColor3f(0.5, 0.5, 0.5);

    gluCylinder(cylinder,4,3,1,10,10);
	glTranslatef(0, 0, 3);

    gluCylinder(cylinder,6,6,2,10,10);

	glTranslatef(0,0,2);
    gluCylinder(cylinder,2,2,3,10,10);
	 gluCylinder(cylinder,1,1,4,10,10);
	 glTranslatef(0,0,4);

    glColor3f(0.3, 0.5, 0.3);
	 for(i=0; i<5; i++){
    glPushMatrix();
    glRotatef(i*(360/5)+obrot,0,0,1);
        obrot+=flag*0.5;
    glTranslatef(0,5,0);
    glPushMatrix();
        glScalef(2,8,0.1);
        glutSolidCube(1);
    glPushMatrix();
    glPopMatrix();
  glPopMatrix();
    }

  // Posprzatanie na stosie macierzy modelowania
  glPopMatrix();
  */
}

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

  // Powielenie macierzy na wierzcholku stosu
  glPushMatrix();

  // Wyznaczenie polozenia obserwatora (przeksztalcenie uladu wspolrzednych
  // sceny do ukladu wspolrzednych obserwatora).
  glTranslatef(0, 0, Odl);
  glRotatef(rotObsX, 1, 0, 0);
  glRotatef(rotObsY,0,1,0);
  glRotatef(rotObsZ, 0, 0, 1);


  // Generacja obrazu sceny w niewidocznym buforze ramki
  RysujRamieRobota(rotPodstawy, rotRamienia1, rotRamienia2, rotGlowicy, rozUchwytow);

  // Usuniecie macierzy lezacej na  wierzcholku stosu (powrot do stanu
  // sprzed wywolania funkcji)
  glPopMatrix();

  // Przelaczenie buforow ramki
  glutSwapBuffers();


}

//////////////////////////////////////////////////////////////////////////////////////////
// Funkcja ustawiajaca parametry rzutu perspektywicznego i rozmiary viewportu
void UstawParametryWidoku(int szerokosc, int wysokosc)
{
  // Ustawienie parametrow viewportu
  glViewport(0, 0, szerokosc, wysokosc);

  // Przejscie w tryb modyfikacji macierzy rzutowania
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  gluPerspective(40.0, (float)szerokosc/(float)wysokosc, 1.0, 1000.0);

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

  // Zmiana macierzy znajdujacej sie na wierzcholku stosu na macierz jednostkowa
  glLoadIdentity();
}

//////////////////////////////////////////////////////////////////////////////////////////
// Funkcja klawiszy specjalnych
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;
    }
}
//////////////////////////////////////////////////////////////////////////////////////////
// Funkcja obslugi klawiatury
void ObslugaKlawiatury(unsigned char klawisz, int x, int y)
{

  switch(klawisz)
    {
    case '2':
      rotRamienia1 = (rotRamienia1 < 90.0) ? rotRamienia1 + 1.0 : rotRamienia1;
      break;

    case '@':
      rotRamienia1 = (rotRamienia1 > 0.0) ? rotRamienia1 - 1.0 : rotRamienia1;
      break;

    case '3':
      rotRamienia2 = (rotRamienia2 < 0.0) ? rotRamienia2 + 1.0 : rotRamienia2;
      break;

    case '#':
      rotRamienia2 = (rotRamienia2 > -90.0) ? rotRamienia2 - 1.0 : rotRamienia2;
      break;

    case '4':
      rotGlowicy = (rotGlowicy < 360.0) ? rotGlowicy + 1.0 : rotGlowicy;
      break;

    case '$':
      rotGlowicy = (rotGlowicy > 0.0) ? rotGlowicy - 1.0 : rotGlowicy;
      break;

    case '5':
      rozUchwytow = (rozUchwytow < 1.5) ? rozUchwytow + 0.1 : rozUchwytow;
      break;

    case '%':
      rozUchwytow = (rozUchwytow > 0.5) ? rozUchwytow - 0.1 : rozUchwytow;
      break;

    case 'o':
        if (Odl > odlMin)
            Odl--;
        break;

    case 'i':
        if (Odl < odlMax)
            Odl++;
        break;

    case 'y':
        rotObsZ++;
        break;

    case 'u':
        rotObsZ--;
        break;
    case 'n':
        flag = (flag > -4) ? flag - 1:flag ;
        break;

    case 'm':
        flag = (flag < 4) ? flag + 1:flag ;
        break;
	case 'x':
		//obrotPlanety = (obrotPlanety > -360) ? obrotPlanety - 10.25f : obrotPlanety;
		obrotPlanety = (int)(obrotPlanety + 1) % 360;
		//spinPlaneta = (int)(spinPlaneta + 1) % 360;

		break;
	case 'c':
		//obrotPlanety = (obrotPlanety < 360) ? obrotPlanety + 10.25f : obrotPlanety;
		obrotPlanety = (int)(obrotPlanety - 1) % 360;
		//spinPlaneta = (int)(spinPlaneta + 1) % 360;
		break;
	case 'v':
			//obrotPlanety = (obrotPlanety < 360) ? obrotPlanety + 10.25f : obrotPlanety;
			obrotKsiezyca = (int)(obrotKsiezyca - 1) % 360;
			//spinPlaneta = (int)(spinPlaneta + 1) % 360;
			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(400, 400);

  // Utworzenie okna
  glutCreateWindow("Robot");

  // Odblokowanie bufora glebokosci
  glEnable(GL_DEPTH_TEST);

  // Ustawienie funkcji wykonywanej na danych w buforze glebokosci
  glDepthFunc(GL_LEQUAL);

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

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

  // Zarejestrowanie funkcji (callback) wyswietlajacej
  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);


  // Zainicjowanie kwadryk tworzacych ramie robota
  InicjujRamieRobota();

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

  return 0;
}