LazySenpai

Untitled

Dec 9th, 2019
119
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