API tools faq
paste
Advertisement
KsaneK

C++ OpenGL Lab3

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