SHARE
TWEET

gk

a guest Dec 6th, 2019 84 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. GLUquadricObj *slonce;
  18. GLUquadricObj *planeta;
  19. GLUquadricObj *ksiezyc;
  20.  
  21. float gamma = 0;
  22. int alfa = 0;
  23. float kalfa = 0;
  24. float spin = 0;
  25. float beta = 0;
  26. GLfloat odlmin = -20;
  27. GLfloat odlmax = -75;
  28. GLfloat odl = -75;
  29. GLfloat rotObsY = 40.0;
  30. GLfloat rotObsX = 40.0;
  31. GLfloat rotObsZ = 0.0;
  32. GLfloat rotPodstawy = 0.0;
  33. GLfloat rotRamienia1= 40.0;
  34. GLfloat rotRamienia2= -40.0;
  35. GLfloat rotGlowicy  = 20.0;
  36. GLfloat rozUchwytow = 0.5;
  37.  
  38. //////////////////////////////////////////////////////////////////////////////////////////
  39. // Funkcja inicjujaca elementy skladowe ramienia robota zamodelowane jako kwadryki
  40. //
  41. void InicjujRamieRobota(void)
  42. {
  43.   // Zainicjowanie scian bocznych walca bedacego podstawa ramienia
  44.   podstawaSciany = gluNewQuadric();
  45.   gluQuadricDrawStyle(podstawaSciany, GLU_LINE);
  46.  
  47.   // Zainicjowanie gornej podstawy walca
  48.   podstawaDyskG = gluNewQuadric();
  49.   gluQuadricDrawStyle(podstawaDyskG, GLU_LINE);
  50.  
  51.   // Zainicjowanie scian bocznych cylindrycznego przegubu ramienia
  52.   przegubSciany = gluNewQuadric();
  53.   gluQuadricDrawStyle(przegubSciany, GLU_LINE);
  54.  
  55.   // Zainicjowanie gornej podstawy walca
  56.   przegubDyskG = gluNewQuadric();
  57.   gluQuadricDrawStyle(przegubDyskG, GLU_LINE);
  58.  
  59.   // Zainicjowanie dolnej podstawy walca
  60.   przegubDyskD = gluNewQuadric();
  61.   gluQuadricDrawStyle(przegubDyskD, GLU_LINE);
  62.  
  63.   // Zainicjowanie scian bocznych cylindra glowicy
  64.   glowicaSciany = gluNewQuadric();
  65.   gluQuadricDrawStyle(glowicaSciany, GLU_LINE);
  66.  
  67.   // Zainicjowanie gornej podstawy walca
  68.   glowicaDyskG = gluNewQuadric();
  69.   gluQuadricDrawStyle(glowicaDyskG, GLU_LINE);
  70.  
  71.   // Zainicjowanie dolnej podstawy walca
  72.   glowicaDyskD = gluNewQuadric();
  73.   gluQuadricDrawStyle(glowicaDyskD, GLU_LINE);
  74.  
  75.   // Zainicjowanie orbity słońca
  76.   slonce = gluNewQuadric();
  77.   gluQuadricDrawStyle(slonce, GLU_LINE);
  78.  
  79.   // Zainicjowanie orbity planety
  80.   planeta = gluNewQuadric();
  81.   gluQuadricDrawStyle(planeta, GLU_LINE);
  82.  
  83.   // Zainicjowanie orbity ksiezyca
  84.   ksiezyc = gluNewQuadric();
  85.   gluQuadricDrawStyle(ksiezyc, GLU_LINE);
  86. }
  87.  
  88.  
  89. void RysujWieze(){                              //Rysowanie wieży
  90.  
  91.     glPushMatrix();
  92.     glRotatef(90, 1, 0, 0);            
  93.     gluDisk(slonce, 30, 30, 100, 4);            //Rysowanie orbity
  94.     glRotatef(270, 1, 0, 0);   
  95.     glPushMatrix();                             //Czerwony element
  96.     glTranslatef(0, 5, 0);
  97.     glScalef(4.23, 10, 4.23);
  98.     glRotatef(45, 0, 1, 0);
  99.     glColor3f(1, 0, 0);
  100.     glutSolidCube(1);
  101.     glPopMatrix();
  102.  
  103.     glPushMatrix();                             //Zielony element
  104.     glTranslatef(0, 11.5, 0);
  105.     glScalef(8, 3, 8);
  106.     glColor3f(0, 1, 0);
  107.     glutSolidCube(1);
  108.     glPopMatrix(); 
  109.  
  110.     glPushMatrix();                             //Niebieski element
  111.     glTranslatef(3, 14, 3);
  112.     glScalef(2, 2, 2);
  113.     glColor3f(0.0, 0.0, 1.0);
  114.     glutSolidCube(1);
  115.     glPopMatrix();
  116.  
  117.     glPushMatrix();                             //Niebieski element
  118.     glTranslatef(-3, 14, -3);
  119.     glScalef(2, 2, 2);
  120.     glColor3f(0.0, 0.0, 1.0);
  121.     glutSolidCube(1);
  122.     glPopMatrix();
  123.  
  124.     glPushMatrix();                             //Niebieski element
  125.     glTranslatef(-3, 14, 3);
  126.     glScalef(2, 2, 2);
  127.     glColor3f(0.0, 0.0, 1.0);
  128.     glutSolidCube(1);
  129.     glPopMatrix();
  130.  
  131.     glPushMatrix();                             //Niebieski element
  132.     glTranslatef(3, 14, -3);
  133.     glScalef(2, 2, 2);
  134.     glColor3f(0.0, 0.0, 1.0);
  135.     glutSolidCube(1);
  136.     glPopMatrix();
  137.  
  138.     glPopMatrix();                              //Usunięcie "podstawy"
  139. }
  140.  
  141. void RysujSlonce()
  142. {
  143.     glPushMatrix();
  144.     gamma -= 0.25;                      //Słońce
  145.     glRotatef(gamma, 0, 1, 0);
  146.     glTranslatef(-30, 0, 0);            //Promień orbity słońca
  147.  
  148.     glPushMatrix();
  149.     glColor3f(1.0, 1.0, 0);
  150.     glRotatef(90, 1, 0, 0);
  151.     gluDisk(planeta, 20, 20, 100, 4);   //Rysowanie orbity
  152.     glutWireSphere(5, 20, 20);          //Promień słońca
  153.     glPopMatrix();
  154.  
  155.     beta -= 0.25;                       //Planeta
  156.     glRotatef(beta, 0, 1, 0);
  157.     glTranslatef(-20, 0, 0);            //Promień orbity planety
  158.  
  159.     glPushMatrix();
  160.     glColor3f(0.7, 1, 0.6);
  161.     glRotatef(90, 1, 0, 0);
  162.     gluDisk(ksiezyc, 5, 5, 100, 4);     //Rysowanie orbity
  163.     glutWireSphere(2, 20, 20);          //Promień planety
  164.     glPopMatrix();
  165.  
  166.     alfa += 0.5;                        //Księżyc
  167.     glRotatef(alfa, 0, 1, 0);
  168.     glTranslatef(-5, 0, 0);             //Promień orbity księżyca
  169.  
  170.     glPushMatrix();
  171.     glColor3f(0.9, 1, 1);
  172.     glutWireSphere(0.5, 20, 20);        //Promień księżyca
  173.     glPopMatrix();
  174.     glPopMatrix();
  175. }
  176.  
  177. //////////////////////////////////////////////////////////////////////////////////////////
  178. // Funkcja rysujaca obraz sceny widzianej z biezacej pozycji obserwatora
  179. // Zalozenie: Funkcja glutWireSpehere moze ryswac tylko sfere o promieniu 1  
  180. void RysujRamieRobota(GLfloat obrotPodstawy, GLfloat obrotRamienia1,
  181.               GLfloat obrotRamienia2, GLfloat obrotGlowicy,
  182.               GLfloat rozstawUchwytow)
  183. {
  184.   // Pocztaek tworzenia ukladu wspolrzednych
  185.   glBegin(GL_LINES);
  186.  
  187.   // Os X
  188.   glColor3f(1.0, 0.0, 0.0);
  189.   glVertex3f(-140.0, 0.0, 0.0);
  190.   glVertex3f(140.0, 0.0, 0.0);
  191.  
  192.   // Os Y
  193.   glColor3f(0.0,1.0,0.0);
  194.   glVertex3f(0.0, -120.0, 0.0);
  195.   glVertex3f(0.0, 120.0, 0.0);
  196.  
  197.   // Os Z
  198.   glColor3f(0.0,0.0,1.0);
  199.   glVertex3f(0.0, 0.0, -120.0);
  200.   glVertex3f(0.0, 0.0, 120.0);
  201.  
  202.   // Koniec tworzenia ukladu wspolrzednych
  203.   glEnd();
  204.  
  205.   glColor3f(1.0,1.0,1.0);
  206.  
  207.     glTranslatef(50.0, 0, 0);                           //Przesunięcie na (50.0, 0, 0)
  208.   //glTranslatef(-30.0,0.0,0.0);
  209.  
  210.   // Przygotowanie stosu macierzy modelowania
  211.   glPushMatrix();
  212.  
  213.   // Rysowanie podstawy ramienia (cylinder bez dolnej podstawy)
  214.   glPushMatrix();
  215.   // - sciany boczne
  216.   glRotatef(-90.0, 1, 0, 0);
  217.   gluCylinder(podstawaSciany, 3.0, 3.0, 1.0, 20, 4);
  218.  
  219.   // - gorna podstawa
  220.   glTranslatef(0.0, 0.0, 1.0);
  221.   gluDisk(podstawaDyskG, 0.0, 3.0, 20, 4);
  222.   glPopMatrix();
  223.  
  224.  
  225.   // Rysowanie dwoch wspornikow ramienia (prostopadlosciany)
  226.   glPushMatrix();
  227.   glScalef(3.0, 4.0, 1.0);
  228.   glTranslatef(0.0, 3.0/4.0, 1.0);
  229.   glutWireCube(1);
  230.   glTranslatef(0.0, 0.0, -2.0);
  231.   glutWireCube(1);  
  232.   glPopMatrix();
  233.  
  234.   // Wyznaczenie osi obrotu ramienia w plaszczyznie pionowej
  235.   glTranslatef(0.0, 4.0, 0.0);
  236.  
  237.   // Obrot ramienia w plaszczyznie pionowej
  238.   glRotatef(obrotRamienia1, 0, 0, 1);
  239.  
  240.   // Modelowanie ramienia nr 1
  241.   glPushMatrix();
  242.   glScalef(8.0, 1.0, 1.0);
  243.   glTranslatef(3.5/8.0, 0.0, 0.0);
  244.   glutWireCube(1);
  245.   glPopMatrix();
  246.  
  247.   // Wyznaczenie osi obrotu ramienia 2 w plaszczyznie pionowej
  248.   glTranslatef(7.5, 0.0, 0.0);
  249.  
  250.   // Obrot ramienia 2 wzgledem ramienia 1
  251.   glRotatef(obrotRamienia2, 0, 0, 1);
  252.  
  253.   // Modelowanie przegubu (walca z obiema podstawami)
  254.   glPushMatrix();
  255.   // - sciany boczne
  256.   glTranslatef(0.0, 0.0, -0.5);
  257.   gluCylinder(podstawaSciany, 1.0, 1.0, 1.0, 20, 4);
  258.  
  259.   // - gorna podstawa
  260.   gluDisk(podstawaDyskG, 0.0, 1.0, 20, 4);
  261.  
  262.   // - dolna podstawa
  263.   glTranslatef(0.0, 0.0, 1.0);
  264.   gluDisk(podstawaDyskG, 0.0, 1.0, 20, 4);
  265.   glPopMatrix();
  266.  
  267.   // Modelowanie ramienia nr 2
  268.   glPushMatrix();
  269.   glScalef(4.0, 1.0, 1.0);
  270.   glTranslatef(2.0/4.0, 0.0, 0.0);
  271.   glutWireCube(1);
  272.   glPopMatrix();
  273.  
  274.   // Wyznaczenie osi obrotu glowicy
  275.   glTranslatef(4.0, 0.0, 0.0);
  276.   glRotatef(90, 0, 1, 0);
  277.   glRotatef(obrotGlowicy, 0, 0, 1);
  278.  
  279.   // Modelowanie glowicy (walca z oboma podstawami)
  280.   glPushMatrix();
  281.   // - sciany boczne
  282.   gluCylinder(podstawaSciany, 1.0, 1.0, 1.0, 20, 4);
  283.  
  284.   // - gorna podstawa
  285.   gluDisk(podstawaDyskG, 0.0, 1.0, 20, 4);
  286.  
  287.   // - dolna podstawa
  288.   glTranslatef(0.0, 0.0, 1.0);
  289.   gluDisk(podstawaDyskG, 0.0, 1.0, 20, 4);
  290.   glPopMatrix();
  291.  
  292.   // Modelowanie uchwytu (dwoch prostopadloscianow, ktore sie rozsuwaja i zsuwaja)
  293.   glTranslatef(0.0, 0.0, 1.5);
  294.   glScalef(0.5, 0.5, 2.0);
  295.   glTranslatef(-rozstawUchwytow, 0.0, 0.25);
  296.   glutWireCube(1);
  297.   glTranslatef(rozstawUchwytow*2.0, 0.0, 0.0);
  298.   glutWireCube(1);
  299.  
  300.  
  301.  
  302.   // Posprzatanie na stosie macierzy modelowania
  303.   glPopMatrix();
  304. }
  305.  
  306.  
  307. //////////////////////////////////////////////////////////////////////////////////////////
  308. // Funkcja generujaca pojedyncza klatke animacji
  309. void WyswietlObraz(void)
  310. {
  311.   // Wyczyszczenie bufora ramki i bufora glebokosci
  312.   glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
  313.  
  314.   // Powielenie macierzy na wierzcholku stosu
  315.   glPushMatrix();
  316.  
  317.   // Wyznaczenie polozenia obserwatora (przeksztalcenie uladu wspolrzednych
  318.   // sceny do ukladu wspolrzednych obserwatora).
  319.   if (odl < odlmax) odl = odlmax;               //Maks. odległość
  320.   if (odl > odlmin) odl = odlmin;               //Min. odległość
  321.   glTranslatef(0, 0, odl);
  322.   glTranslatef(0, 0, -40);
  323.   glRotatef(rotObsX, 1, 0, 0);
  324.   glRotatef(rotObsY, 0, 1, 0);
  325.   glRotatef(rotObsZ, 0, 0, 1);
  326.   RysujWieze();                                 //Wyrysowanie wieży
  327.   RysujSlonce();                                //Wyrysowanie słońca
  328.   // Generacja obrazu sceny w niewidocznym buforze ramki
  329.   RysujRamieRobota(rotPodstawy, rotRamienia1, rotRamienia2, rotGlowicy, rozUchwytow);
  330.  
  331.   // Usuniecie macierzy lezacej na  wierzcholku stosu (powrot do stanu
  332.   // sprzed wywolania funkcji)
  333.   glPopMatrix();
  334.  
  335.   // Przelaczenie buforow ramki
  336.   glutSwapBuffers();
  337.  
  338.  
  339. }
  340.  
  341. //////////////////////////////////////////////////////////////////////////////////////////
  342. // Funkcja ustawiajaca parametry rzutu perspektywicznego i rozmiary viewportu
  343. void UstawParametryWidoku(int szerokosc, int wysokosc)
  344. {
  345.   // Ustawienie parametrow viewportu
  346.   glViewport(0, 0, szerokosc, wysokosc);
  347.  
  348.   // Przejscie w tryb modyfikacji macierzy rzutowania
  349.   glMatrixMode(GL_PROJECTION);
  350.   glLoadIdentity();
  351.   gluPerspective(40.0, (float)szerokosc/(float)wysokosc, 1.0, 1000.0);
  352.  
  353.   // Przejscie w tryb modyfikacji macierzy przeksztalcen geometrycznych
  354.   glMatrixMode(GL_MODELVIEW);
  355.  
  356.   // Zmiana macierzy znajdujacej sie na wierzcholku stosu na macierz jednostkowa
  357.   glLoadIdentity();
  358. }
  359.  
  360. //////////////////////////////////////////////////////////////////////////////////////////
  361. // Funkcja klawiszy specjalnych
  362. void ObslugaKlawiszySpecjalnych(int klawisz, int x, int y)
  363. {
  364.   switch(klawisz)
  365.     {
  366.     case GLUT_KEY_UP:                           //Dodawanie kąta na osi OX
  367.       rotObsX += 1.0;
  368.       break;
  369.  
  370.     case GLUT_KEY_DOWN:                         //Odejmowanie kąta na osi OX
  371.       rotObsX -= 1.0;
  372.       break;
  373.  
  374.     case GLUT_KEY_LEFT:                         //Odejmowanie kąta na osi OY
  375.       rotObsY -= 1.0;
  376.       break;
  377.  
  378.     case GLUT_KEY_RIGHT:                        //Dodawanie kąta na osi OY
  379.       rotObsY += 1.0;
  380.       break;
  381.     case GLUT_KEY_PAGE_UP:                      //Dodawanie kąta na osi OY
  382.       rotObsZ += 1.0;
  383.       break;
  384.     case GLUT_KEY_PAGE_DOWN:                        //Dodawanie kąta na osi OY
  385.       rotObsZ -= 1.0;
  386.       break;
  387.  
  388.     }
  389. }
  390. //////////////////////////////////////////////////////////////////////////////////////////
  391. // Funkcja obslugi klawiatury
  392. void ObslugaKlawiatury(unsigned char klawisz, int x, int y)
  393. {
  394.  
  395.   switch(klawisz)
  396.     {
  397.     case '2':
  398.       rotRamienia1 = (rotRamienia1 < 90.0) ? rotRamienia1 + 1.0 : rotRamienia1;
  399.       break;
  400.  
  401.     case '@':
  402.       rotRamienia1 = (rotRamienia1 > 0.0) ? rotRamienia1 - 1.0 : rotRamienia1;
  403.       break;
  404.  
  405.     case '3':
  406.       rotRamienia2 = (rotRamienia2 < 0.0) ? rotRamienia2 + 1.0 : rotRamienia2;
  407.       break;
  408.  
  409.     case '#':
  410.       rotRamienia2 = (rotRamienia2 > -90.0) ? rotRamienia2 - 1.0 : rotRamienia2;
  411.       break;
  412.  
  413.     case '4':
  414.       rotGlowicy = (rotGlowicy < 360.0) ? rotGlowicy + 1.0 : rotGlowicy;
  415.       break;
  416.  
  417.     case '$':
  418.       rotGlowicy = (rotGlowicy > 0.0) ? rotGlowicy - 1.0 : rotGlowicy;
  419.       break;
  420.  
  421.     case '5':
  422.       rozUchwytow = (rozUchwytow < 1.5) ? rozUchwytow + 0.1 : rozUchwytow;
  423.       break;
  424.  
  425.     case '%':
  426.       rozUchwytow = (rozUchwytow > 0.5) ? rozUchwytow - 0.1 : rozUchwytow;
  427.       break;
  428.     case '+':                           //Przybliżenie
  429.         odl += 1;
  430.       break;
  431.     case '-':                           //Oddalenie
  432.         odl -= 1;
  433.       break;
  434.  
  435.   if(klawisz == 27)
  436.       exit(0);    
  437.   }
  438. }
  439.  
  440. //////////////////////////////////////////////////////////////////////////////////////////
  441. // Glowna funkcja programu
  442. int  main(int argc, char **argv)
  443. {
  444.   // Zainicjowanie biblioteki GLUT
  445.   glutInit(&argc, argv);
  446.  
  447.   // Ustawienie trybu wyswietlania
  448.   glutInitDisplayMode (GLUT_DOUBLE|GLUT_RGB|GLUT_DEPTH);
  449.  
  450.   // Ustawienie polozenia dolenego lewego rogu okna
  451.   glutInitWindowPosition(100, 100);
  452.  
  453.   // Ustawienie rozmiarow okna
  454.   glutInitWindowSize(700, 700);
  455.  
  456.   // Utworzenie okna
  457.   glutCreateWindow("Robot");
  458.  
  459.   // Odblokowanie bufora glebokosci
  460.   glEnable(GL_DEPTH_TEST);
  461.  
  462.   // Ustawienie funkcji wykonywanej na danych w buforze glebokosci
  463.   glDepthFunc(GL_LEQUAL);
  464.  
  465.   // Ustawienie wartosci czyszczacej zawartosc bufora glebokosci
  466.   glClearDepth(1000.0);
  467.  
  468.   // Ustawienie koloru czyszczenia bufora ramki
  469.   glClearColor (0.5, 0.3, 0.0, 0.0);
  470.  
  471.   // Zarejestrowanie funkcji (callback) wyswietlajacej
  472.   glutDisplayFunc(WyswietlObraz);
  473.  
  474.   // Zarejestrowanie funkcji (callback) wywolywanej za kazdym razem kiedy
  475.   // zmieniane sa rozmiary okna
  476.   glutReshapeFunc(UstawParametryWidoku);
  477.  
  478.   // Zarejestrowanie funkcji wykonywanej gdy okno nie obsluguje
  479.   // zadnych zadan
  480.   glutIdleFunc(WyswietlObraz);
  481.  
  482.   // Zarejestrowanie funkcji obslugi klawiatury
  483.   glutKeyboardFunc(ObslugaKlawiatury);
  484.  
  485.   // Zarejestrowanie funkcji obslugi klawiszy specjalnych
  486.   glutSpecialFunc(ObslugaKlawiszySpecjalnych);
  487.  
  488.  
  489.   // Zainicjowanie kwadryk tworzacych ramie robota
  490.   InicjujRamieRobota();
  491.  
  492.   // Obsluga glownej petli programu (wywolywanie zarejestrowanych callbackow
  493.   // w odpowiedzi na odbierane zdarzenia lub obsluga stanu bezczynnosci)
  494.   glutMainLoop();
  495.  
  496.   return 0;
  497. }
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