SHARE
TWEET

Untitled

LazySenpai Dec 9th, 2019 105 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. //////////////////////////////////////////////////////////////////////////////////////////
  2. // Program demonstruje  skladanie transformacji przy modelowaniu zlozonych obiektow
  3. // skladajacych sie z wielu elementow ruchomych (ramie robota).
  4.  
  5. #include <GL/glut.h>
  6.  
  7.  
  8. // Wskazniki do wykorzystywanych kwadryk
  9. GLUquadricObj *podstawaSciany;
  10. GLUquadricObj *podstawaDyskG;
  11. GLUquadricObj *przegubSciany;
  12. GLUquadricObj *przegubDyskG;
  13. GLUquadricObj *przegubDyskD;
  14. GLUquadricObj *glowicaSciany;
  15. GLUquadricObj *glowicaDyskG;
  16. GLUquadricObj *glowicaDyskD;
  17.  
  18. GLfloat rotObsY     = 40.0;
  19. GLfloat rotObsX     = 40.0;
  20. GLfloat rotObsZ     = 0.0;
  21. GLfloat rotPodstawy = 0.0;
  22. GLfloat rotRamienia1= 40.0;
  23. GLfloat rotRamienia2= -40.0;
  24. GLfloat rotGlowicy  = 20.0;
  25. GLfloat rozUchwytow = 0.5;
  26.  
  27. GLfloat rotacjaPlanety = 0.0;
  28. GLfloat rotacjaKsiezyca = 0.0;
  29. GLfloat spinPlanety = 0.0;
  30.  
  31. GLfloat odlMin = -80;
  32. GLfloat Odl = -30;
  33. GLfloat odlMax = -10;
  34. GLfloat zoomSpeed = 0.5;
  35. GLUquadricObj* orbitaPlanety;
  36. GLUquadricObj* orbitaKsiezyca;
  37. GLUquadricObj* cylinder;
  38.  
  39. float alp=0, spin=0,moon=0;
  40. //////////////////////////////////////////////////////////////////////////////////////////
  41. // Funkcja inicjujaca elementy skladowe ramienia robota zamodelowane jako kwadryki
  42. //
  43. void InicjujRamieRobota(void)
  44. {
  45.   // Zainicjowanie scian bocznych walca bedacego podstawa ramienia
  46.   podstawaSciany = gluNewQuadric();
  47.   gluQuadricDrawStyle(podstawaSciany, GLU_LINE);
  48.  
  49.   // Zainicjowanie gornej podstawy walca
  50.   podstawaDyskG = gluNewQuadric();
  51.   gluQuadricDrawStyle(podstawaDyskG, GLU_LINE);
  52.  
  53.   // Zainicjowanie scian bocznych cylindrycznego przegubu ramienia
  54.   przegubSciany = gluNewQuadric();
  55.   gluQuadricDrawStyle(przegubSciany, GLU_LINE);
  56.  
  57.   // Zainicjowanie gornej podstawy walca
  58.   przegubDyskG = gluNewQuadric();
  59.   gluQuadricDrawStyle(przegubDyskG, GLU_LINE);
  60.  
  61.   // Zainicjowanie dolnej podstawy walca
  62.   przegubDyskD = gluNewQuadric();
  63.   gluQuadricDrawStyle(przegubDyskD, GLU_LINE);
  64.  
  65.   // Zainicjowanie scian bocznych cylindra glowicy
  66.   glowicaSciany = gluNewQuadric();
  67.   gluQuadricDrawStyle(glowicaSciany, GLU_LINE);
  68.  
  69.   // Zainicjowanie gornej podstawy walca
  70.   glowicaDyskG = gluNewQuadric();
  71.   gluQuadricDrawStyle(glowicaDyskG, GLU_LINE);
  72.  
  73.   // Zainicjowanie dolnej podstawy walca
  74.   glowicaDyskD = gluNewQuadric();
  75.   gluQuadricDrawStyle(glowicaDyskD, GLU_LINE);
  76.  
  77.   cylinder = gluNewQuadric();
  78.   gluQuadricDrawStyle(cylinder, GLU_FILL);
  79. }
  80.  
  81. GLfloat zmienna = 0;
  82. GLfloat spinukladu = 0.0;
  83. GLUquadricObj* slonce;
  84. GLUquadricObj* planeta;
  85. GLUquadricObj* kk;
  86. int i=0;
  87. float obrot=0;
  88. int flag=0;
  89. //////////////////////////////////////////////////////////////////////////////////////////
  90. // Funkcja rysujaca obraz sceny widzianej z biezacej pozycji obserwatora
  91. // Zalozenie: Funkcja glutWireSpehere moze ryswac tylko sfere o promieniu 1  
  92. void RysujRamieRobota(GLfloat obrotPodstawy, GLfloat obrotRamienia1,
  93.               GLfloat obrotRamienia2, GLfloat obrotGlowicy,
  94.               GLfloat rozstawUchwytow)
  95. {
  96.   // Pocztaek tworzenia ukladu wspolrzednych
  97.   glBegin(GL_LINES);
  98.  
  99.   // Os X
  100.   glColor3f(1.0, 0.0, 0.0);
  101.   glVertex3f(-40.0, 0.0, 0.0);
  102.   glVertex3f(40.0, 0.0, 0.0);
  103.  
  104.   // Os Y
  105.   glColor3f(0.0,1.0,0.0);
  106.   glVertex3f(0.0, -20.0, 0.0);
  107.   glVertex3f(0.0, 20.0, 0.0);
  108.  
  109.   // Os Z
  110.   glColor3f(0.0,0.0,1.0);
  111.   glVertex3f(0.0, 0.0, -20.0);
  112.   glVertex3f(0.0, 0.0, 20.0);
  113.  
  114.   // Koniec tworzenia ukladu wspolrzednych
  115.   glEnd();
  116.  
  117.   glPushMatrix();
  118.  
  119.     gluCylinder(cylinder,2,2,5,10,10);
  120.     glColor3f(0.5, 0.5, 0.5);
  121.     gluCylinder(cylinder,4,3,1,10,10);
  122.     glTranslatef(0,0,5);
  123.     gluCylinder(cylinder,6,6,2,10,10);
  124.     glTranslatef(0,0,2);
  125.     gluCylinder(cylinder,2,2,3,10,10);
  126.     gluCylinder(cylinder,1,1,4,10,10);
  127.     glTranslatef(0,0,4);
  128.     glColor3f(0.5, 0.5, 0.5);
  129.     for(i=0; i<5; i++){
  130.     glPushMatrix();
  131.     glRotatef(i*(360/5)+obrot,0,0,1);
  132.         obrot+=flag*0.25;
  133.     glTranslatef(0,5,0);
  134.     glPushMatrix();
  135.         glScalef(2,8,0.1);
  136.         glutSolidCube(1);
  137.     glPushMatrix();
  138.     glPopMatrix();
  139.   glPopMatrix();
  140.     }
  141.   // Posprzatanie na stosie macierzy modelowania
  142.   glPopMatrix();
  143. }
  144.  
  145. //////////////////////////////////////////////////////////////////////////////////////////
  146. // Funkcja generujaca pojedyncza klatke animacji
  147. void WyswietlObraz(void)
  148. {
  149.   // Wyczyszczenie bufora ramki i bufora glebokosci
  150.   glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
  151.  
  152.   // Powielenie macierzy na wierzcholku stosu
  153.   glPushMatrix();
  154.  
  155.   // Wyznaczenie polozenia obserwatora (przeksztalcenie uladu wspolrzednych
  156.   // sceny do ukladu wspolrzednych obserwatora).
  157.   glTranslatef(0, 0, Odl);
  158.   glRotatef(rotObsX, 1, 0, 0);
  159.   glRotatef(rotObsY,0,1,0);
  160.   glRotatef(rotObsZ, 0, 0, 1);
  161.  
  162.  
  163.   // Generacja obrazu sceny w niewidocznym buforze ramki
  164.   RysujRamieRobota(rotPodstawy, rotRamienia1, rotRamienia2, rotGlowicy, rozUchwytow);
  165.  
  166.   // Usuniecie macierzy lezacej na  wierzcholku stosu (powrot do stanu
  167.   // sprzed wywolania funkcji)
  168.   glPopMatrix();
  169.  
  170.   // Przelaczenie buforow ramki
  171.   glutSwapBuffers();
  172.  
  173.  
  174. }
  175.  
  176. //////////////////////////////////////////////////////////////////////////////////////////
  177. // Funkcja ustawiajaca parametry rzutu perspektywicznego i rozmiary viewportu
  178. void UstawParametryWidoku(int szerokosc, int wysokosc)
  179. {
  180.   // Ustawienie parametrow viewportu
  181.   glViewport(0, 0, szerokosc, wysokosc);
  182.  
  183.   // Przejscie w tryb modyfikacji macierzy rzutowania
  184.   glMatrixMode(GL_PROJECTION);
  185.   glLoadIdentity();
  186.   gluPerspective(40.0, (float)szerokosc/(float)wysokosc, 1.0, 1000.0);
  187.  
  188.   // Przejscie w tryb modyfikacji macierzy przeksztalcen geometrycznych
  189.   glMatrixMode(GL_MODELVIEW);
  190.  
  191.   // Zmiana macierzy znajdujacej sie na wierzcholku stosu na macierz jednostkowa
  192.   glLoadIdentity();
  193. }
  194.  
  195. //////////////////////////////////////////////////////////////////////////////////////////
  196. // Funkcja klawiszy specjalnych
  197. void ObslugaKlawiszySpecjalnych(int klawisz, int x, int y)
  198. {
  199.   switch(klawisz)
  200.     {
  201.     case GLUT_KEY_UP:
  202.       rotObsX = rotObsX + 1.0;
  203.       break;
  204.  
  205.     case GLUT_KEY_DOWN:
  206.       rotObsX = rotObsX - 1.0;
  207.       break;
  208.  
  209.     case GLUT_KEY_LEFT:
  210.       rotObsY = rotObsY - 1.0;
  211.       break;
  212.  
  213.     case GLUT_KEY_RIGHT:
  214.       rotObsY = rotObsY + 1.0;
  215.       break;
  216.     }
  217. }
  218. //////////////////////////////////////////////////////////////////////////////////////////
  219. // Funkcja obslugi klawiatury
  220. void ObslugaKlawiatury(unsigned char klawisz, int x, int y)
  221. {
  222.  
  223.   switch(klawisz)
  224.     {
  225.     case '2':
  226.       rotRamienia1 = (rotRamienia1 < 90.0) ? rotRamienia1 + 1.0 : rotRamienia1;
  227.       break;
  228.  
  229.     case '@':
  230.       rotRamienia1 = (rotRamienia1 > 0.0) ? rotRamienia1 - 1.0 : rotRamienia1;
  231.       break;
  232.  
  233.     case '3':
  234.       rotRamienia2 = (rotRamienia2 < 0.0) ? rotRamienia2 + 1.0 : rotRamienia2;
  235.       break;
  236.  
  237.     case '#':
  238.       rotRamienia2 = (rotRamienia2 > -90.0) ? rotRamienia2 - 1.0 : rotRamienia2;
  239.       break;
  240.  
  241.     case '4':
  242.       rotGlowicy = (rotGlowicy < 360.0) ? rotGlowicy + 1.0 : rotGlowicy;
  243.       break;
  244.  
  245.     case '$':
  246.       rotGlowicy = (rotGlowicy > 0.0) ? rotGlowicy - 1.0 : rotGlowicy;
  247.       break;
  248.  
  249.     case '5':
  250.       rozUchwytow = (rozUchwytow < 1.5) ? rozUchwytow + 0.1 : rozUchwytow;
  251.       break;
  252.  
  253.     case '%':
  254.       rozUchwytow = (rozUchwytow > 0.5) ? rozUchwytow - 0.1 : rozUchwytow;
  255.       break;
  256.    
  257.     case 'o':
  258.         if (Odl > odlMin)
  259.             Odl--;
  260.         break;
  261.  
  262.     case 'i':
  263.         if (Odl < odlMax)
  264.             Odl++;
  265.         break;
  266.  
  267.     case 'y':
  268.         rotObsZ++;
  269.         break;
  270.  
  271.     case 'u':
  272.         rotObsZ--;
  273.         break;
  274.     case 'n':
  275.         flag = (flag > -4) ? flag - 1:flag ;
  276.         break;
  277.  
  278.     case 'm':
  279.         flag = (flag < 4) ? flag + 1:flag ;
  280.         break;
  281.   }
  282.   if(klawisz == 27)
  283.       exit(0);      
  284. }
  285.  
  286. //////////////////////////////////////////////////////////////////////////////////////////
  287. // Glowna funkcja programu
  288. int  main(int argc, char **argv)
  289. {
  290.   // Zainicjowanie biblioteki GLUT
  291.   glutInit(&argc, argv);
  292.  
  293.   // Ustawienie trybu wyswietlania
  294.   glutInitDisplayMode (GLUT_DOUBLE|GLUT_RGB|GLUT_DEPTH);
  295.  
  296.   // Ustawienie polozenia dolenego lewego rogu okna
  297.   glutInitWindowPosition(100, 100);
  298.  
  299.   // Ustawienie rozmiarow okna
  300.   glutInitWindowSize(400, 400);
  301.  
  302.   // Utworzenie okna
  303.   glutCreateWindow("Robot");
  304.  
  305.   // Odblokowanie bufora glebokosci
  306.   glEnable(GL_DEPTH_TEST);
  307.  
  308.   // Ustawienie funkcji wykonywanej na danych w buforze glebokosci
  309.   glDepthFunc(GL_LEQUAL);
  310.  
  311.   // Ustawienie wartosci czyszczacej zawartosc bufora glebokosci
  312.   glClearDepth(1000.0);
  313.  
  314.   // Ustawienie koloru czyszczenia bufora ramki
  315.   glClearColor (0.3, 0.3, 0.3, 0.0);
  316.  
  317.   // Zarejestrowanie funkcji (callback) wyswietlajacej
  318.   glutDisplayFunc(WyswietlObraz);
  319.  
  320.   // Zarejestrowanie funkcji (callback) wywolywanej za kazdym razem kiedy
  321.   // zmieniane sa rozmiary okna
  322.   glutReshapeFunc(UstawParametryWidoku);
  323.  
  324.   // Zarejestrowanie funkcji wykonywanej gdy okno nie obsluguje
  325.   // zadnych zadan
  326.   glutIdleFunc(WyswietlObraz);
  327.  
  328.   // Zarejestrowanie funkcji obslugi klawiatury
  329.   glutKeyboardFunc(ObslugaKlawiatury);
  330.  
  331.   // Zarejestrowanie funkcji obslugi klawiszy specjalnych
  332.   glutSpecialFunc(ObslugaKlawiszySpecjalnych);
  333.  
  334.  
  335.   // Zainicjowanie kwadryk tworzacych ramie robota
  336.   InicjujRamieRobota();
  337.  
  338.   // Obsluga glownej petli programu (wywolywanie zarejestrowanych callbackow
  339.   // w odpowiedzi na odbierane zdarzenia lub obsluga stanu bezczynnosci)
  340.   glutMainLoop();
  341.  
  342.   return 0;
  343. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top