Guest User

Untitled

a guest
Dec 9th, 2019
96
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 *orbitaZ;
  18. GLUquadricObj *orbitaK;
  19.  
  20.  
  21. GLfloat kat = 0;
  22. GLfloat predkosc = 0;
  23. GLfloat katrakieta = 0;
  24. GLfloat katobroturakiety = 0;
  25.  
  26. GLfloat rotObsY = 40.0;
  27. GLfloat rotObsX = 40.0;
  28. GLfloat rotPodstawy = 0.0;
  29. GLfloat rotRamienia1= 40.0;
  30. GLfloat rotRamienia2= -40.0;
  31. GLfloat rotGlowicy = 20.0;
  32. GLfloat rozUchwytow = 0.5;
  33.  
  34. //JS
  35. GLfloat odlMin = -150;
  36. GLfloat currentOdl = -80;
  37. GLfloat odlMax = -10;
  38. GLfloat zoomSpeed = 0.5;
  39. GLUquadricObj* orbitaPlanety;
  40. GLUquadricObj* orbitaKsiezyca;
  41. GLfloat rotObsZ = 0.0;
  42.  
  43. //////////////////////////////////////////////////////////////////////////////////////////
  44. // Funkcja inicjujaca elementy skladowe ramienia robota zamodelowane jako kwadryki
  45. //
  46. void InicjujRamieRobota(void)
  47. {
  48. // Zainicjowanie scian bocznych walca bedacego podstawa ramienia
  49. podstawaSciany = gluNewQuadric();
  50. gluQuadricDrawStyle(podstawaSciany, GLU_LINE);
  51.  
  52. // Zainicjowanie gornej podstawy walca
  53. podstawaDyskG = gluNewQuadric();
  54. gluQuadricDrawStyle(podstawaDyskG, GLU_LINE);
  55.  
  56. // Zainicjowanie scian bocznych cylindrycznego przegubu ramienia
  57. przegubSciany = gluNewQuadric();
  58. gluQuadricDrawStyle(przegubSciany, GLU_LINE);
  59.  
  60. // Zainicjowanie gornej podstawy walca
  61. przegubDyskG = gluNewQuadric();
  62. gluQuadricDrawStyle(przegubDyskG, GLU_LINE);
  63.  
  64. // Zainicjowanie dolnej podstawy walca
  65. przegubDyskD = gluNewQuadric();
  66. gluQuadricDrawStyle(przegubDyskD, GLU_LINE);
  67.  
  68. // Zainicjowanie scian bocznych cylindra glowicy
  69. glowicaSciany = gluNewQuadric();
  70. gluQuadricDrawStyle(glowicaSciany, GLU_LINE);
  71.  
  72. // Zainicjowanie gornej podstawy walca
  73. glowicaDyskG = gluNewQuadric();
  74. gluQuadricDrawStyle(glowicaDyskG, GLU_LINE);
  75.  
  76. // Zainicjowanie dolnej podstawy walca
  77. glowicaDyskD = gluNewQuadric();
  78. gluQuadricDrawStyle(glowicaDyskD, GLU_LINE);
  79.  
  80.  
  81. //JS
  82. orbitaPlanety = gluNewQuadric();
  83. gluQuadricDrawStyle(orbitaPlanety, GLU_LINE);
  84. orbitaKsiezyca = gluNewQuadric();
  85. gluQuadricDrawStyle(orbitaKsiezyca, GLU_LINE);
  86.  
  87. }
  88.  
  89.  
  90. //////////////////////////////////////////////////////////////////////////////////////////
  91. // Funkcja rysujaca obraz sceny widzianej z biezacej pozycji obserwatora
  92. // Zalozenie: Funkcja glutWireSpehere moze ryswac tylko sfere o promieniu 1
  93. void RysujRamieRobota(GLfloat obrotPodstawy, GLfloat obrotRamienia1,
  94. GLfloat obrotRamienia2, GLfloat obrotGlowicy,
  95. GLfloat rozstawUchwytow)
  96. {
  97. // Pocztaek tworzenia ukladu wspolrzednych
  98. glBegin(GL_LINES);
  99.  
  100. // Os X
  101. glColor3f(1.0, 0.0, 0.0);
  102. glVertex3f(-40.0, 0.0, 0.0);
  103. glVertex3f(40.0, 0.0, 0.0);
  104.  
  105. // Os Y
  106. glColor3f(0.0,1.0,0.0);
  107. glVertex3f(0.0, -20.0, 0.0);
  108. glVertex3f(0.0, 20.0, 0.0);
  109.  
  110. // Os Z
  111. glColor3f(0.0,0.0,1.0);
  112. glVertex3f(0.0, 0.0, -20.0);
  113. glVertex3f(0.0, 0.0, 20.0);
  114.  
  115.  
  116. // Koniec tworzenia ukladu wspolrzednych
  117. glEnd();
  118.  
  119. glColor3f(1.0,1.0,1.0);
  120.  
  121.  
  122. //glTranslatef(-30.0,0.0,0.0);
  123.  
  124. // Przygotowanie stosu macierzy modelowania
  125. glPushMatrix();
  126.  
  127.  
  128.  
  129. glTranslatef(50, 0, 0);//JS
  130.  
  131.  
  132.  
  133.  
  134. // Rysowanie podstawy ramienia (cylinder bez dolnej podstawy)
  135. glPushMatrix();
  136. // - sciany boczne
  137. glRotatef(-90.0, 1, 0, 0);
  138. gluCylinder(podstawaSciany, 3.0, 3.0, 1.0, 20, 4);
  139.  
  140. // - gorna podstawa
  141. glTranslatef(0.0, 0.0, 1.0);
  142. gluDisk(podstawaDyskG, 0.0, 3.0, 20, 4);
  143. glPopMatrix();
  144.  
  145.  
  146. // Rysowanie dwoch wspornikow ramienia (prostopadlosciany)
  147. glPushMatrix();
  148. glScalef(3.0, 4.0, 1.0);
  149. glTranslatef(0.0, 3.0/4.0, 1.0);
  150. glutWireCube(1);
  151. glTranslatef(0.0, 0.0, -2.0);
  152. glutWireCube(1);
  153. glPopMatrix();
  154.  
  155. // Wyznaczenie osi obrotu ramienia w plaszczyznie pionowej
  156. glTranslatef(0.0, 4.0, 0.0);
  157.  
  158. // Obrot ramienia w plaszczyznie pionowej
  159. glRotatef(obrotRamienia1, 0, 0, 1);
  160.  
  161. // Modelowanie ramienia nr 1
  162. glPushMatrix();
  163. glScalef(8.0, 1.0, 1.0);
  164. glTranslatef(3.5/8.0, 0.0, 0.0);
  165. glutWireCube(1);
  166. glPopMatrix();
  167.  
  168. // Wyznaczenie osi obrotu ramienia 2 w plaszczyznie pionowej
  169. glTranslatef(7.5, 0.0, 0.0);
  170.  
  171. // Obrot ramienia 2 wzgledem ramienia 1
  172. glRotatef(obrotRamienia2, 0, 0, 1);
  173.  
  174. // Modelowanie przegubu (walca z obiema podstawami)
  175. glPushMatrix();
  176. // - sciany boczne
  177. glTranslatef(0.0, 0.0, -0.5);
  178. gluCylinder(podstawaSciany, 1.0, 1.0, 1.0, 20, 4);
  179.  
  180. // - gorna podstawa
  181. gluDisk(podstawaDyskG, 0.0, 1.0, 20, 4);
  182.  
  183. // - dolna podstawa
  184. glTranslatef(0.0, 0.0, 1.0);
  185. gluDisk(podstawaDyskG, 0.0, 1.0, 20, 4);
  186. glPopMatrix();
  187.  
  188. // Modelowanie ramienia nr 2
  189. glPushMatrix();
  190. glScalef(4.0, 1.0, 1.0);
  191. glTranslatef(2.0/4.0, 0.0, 0.0);
  192. glutWireCube(1);
  193. glPopMatrix();
  194.  
  195. // Wyznaczenie osi obrotu glowicy
  196. glTranslatef(4.0, 0.0, 0.0);
  197. glRotatef(90, 0, 1, 0);
  198. glRotatef(obrotGlowicy, 0, 0, 1);
  199.  
  200. // Modelowanie glowicy (walca z oboma podstawami)
  201. glPushMatrix();
  202. // - sciany boczne
  203. gluCylinder(podstawaSciany, 1.0, 1.0, 1.0, 20, 4);
  204.  
  205. // - gorna podstawa
  206. gluDisk(podstawaDyskG, 0.0, 1.0, 20, 4);
  207.  
  208. // - dolna podstawa
  209. glTranslatef(0.0, 0.0, 1.0);
  210. gluDisk(podstawaDyskG, 0.0, 1.0, 20, 4);
  211. glPopMatrix();
  212.  
  213. // Modelowanie uchwytu (dwoch prostopadloscianow, ktore sie rozsuwaja i zsuwaja)
  214. glTranslatef(0.0, 0.0, 1.5);
  215. glScalef(0.5, 0.5, 2.0);
  216. glTranslatef(-rozstawUchwytow, 0.0, 0.25);
  217. glutWireCube(1);
  218. glTranslatef(rozstawUchwytow*2.0, 0.0, 0.0);
  219. glutWireCube(1);
  220.  
  221.  
  222.  
  223. // Posprzatanie na stosie macierzy modelowania
  224. glPopMatrix();
  225. }
  226.  
  227. //JS
  228. void RysujZadanie1() {
  229. glColor3f(1, 0, 0);
  230. glPushMatrix();
  231. glTranslatef(0, 5, 0);
  232. glRotatef(45, 0, 1, 0);
  233. glScalef(4.23, 10, 4.23);
  234. glutSolidCube(1);
  235. glPopMatrix();
  236.  
  237. glColor3f(0, 1, 0);
  238. glPushMatrix();
  239. glTranslatef(0, 11.5, 0);
  240. glScalef(8, 3, 8);
  241. glutSolidCube(1);
  242. glPopMatrix();
  243.  
  244. glColor3f(0, 0, 1);
  245. glPushMatrix();
  246. glScalef(2, 2, 2);
  247. glTranslatef(1.5, 7, -1.5);
  248. glutSolidCube(1);
  249. glTranslatef(-3, 0, 0);
  250. glutSolidCube(1);
  251.  
  252. glTranslatef(0, 0, 3);
  253. glutSolidCube(1);
  254.  
  255. glTranslatef(3, 0, 0);
  256. glutSolidCube(1);
  257.  
  258. glPopMatrix();
  259. }
  260.  
  261. //JS
  262. GLfloat zmienna = 0;
  263. GLfloat rotacjaPlanety = 0.0;
  264. GLfloat rotacjaKsiezyca = 0.0;
  265. GLfloat spinPlanety = 0.0;
  266.  
  267. GLUquadricObj* slonce;
  268. GLUquadricObj* planeta;
  269. GLUquadricObj* kk;
  270.  
  271. void RysujUklad(void)
  272. {
  273. slonce = gluNewQuadric();
  274. planeta = gluNewQuadric();
  275. kk = gluNewQuadric();
  276. gluQuadricDrawStyle(slonce, GLU_LINE);
  277. gluQuadricDrawStyle(planeta, GLU_LINE);
  278. gluQuadricDrawStyle(kk, GLU_LINE);
  279.  
  280. zmienna += 0.25;
  281. glPushMatrix();
  282. glRotatef(45, 1, 0, 0);//JS
  283.  
  284. glPushMatrix();
  285. glRotatef(90, 1, 0, 0);
  286. glColor3f(1, 1, 1);
  287. gluDisk(kk, 30.0, 30.0, 40, 1);
  288. glPopMatrix();
  289. glRotatef(zmienna, 0, 1, 0);
  290. glTranslatef(30, 0, 0);
  291.  
  292. glColor3f(1.0, 1.0, 0.4);
  293. glPushMatrix();
  294. glRotatef(-90.0, 1, 0, 0);
  295. gluDisk(slonce, 20.0, 20.0, 40, 1);
  296. glScalef(5.0, 5.0, 5.0);
  297. glutWireSphere(1.0, 20, 20);
  298. glPopMatrix();
  299.  
  300.  
  301. glColor3f(0.53, 0.81, 0.98);
  302. glRotatef(-rotacjaPlanety, 0, 1, 0);
  303. glTranslatef(0.0, 0.0, 20.0);
  304. glPushMatrix();
  305. glRotatef(spinPlanety, 0, 1, 0);
  306. glRotatef(-90.0, 1, 0, 0);
  307. gluDisk(planeta, 5.0, 5.0, 40, 1);
  308. glScalef(2.0, 2.0, 2.0);
  309. glutWireSphere(1.0, 20, 20);
  310. glPopMatrix();
  311.  
  312. glColor3f(0.75, 0.75, 0.75);
  313. glRotatef(rotacjaKsiezyca, 0, 1, 0);
  314. glRotatef(-90.0, 1, 0, 0);
  315. glTranslatef(5.0, 0.0, 0.0);
  316. glScalef(0.5, 0.5, 0.5);
  317. glutWireSphere(1.0, 20, 20);
  318.  
  319. glPopMatrix();
  320. }
  321.  
  322. void RysujRakiete(void){
  323. //----------------------- zaczynam rakiete
  324. //narysowanie rakiety
  325. glPushMatrix();
  326. glTranslatef(0.0,20.0,0.0); //punkt względem którego rakieta się obraca wokół osi OY
  327. glPushMatrix();
  328. glColor3f(1.0,1.0,1.0);
  329. glRotatef(predkosc*katrakieta, 0, 1, 0);
  330. glTranslatef(50.0,0.0,0.0);
  331. glRotatef(katobroturakiety, 0, 0, 1); //obrót rakiety wokół osi przechodzącej przez środek kadłuba
  332. glPushMatrix();
  333.  
  334. //Tworzenie kadłuba rakiety oraz szpicy
  335. glTranslatef(0.0, 0.0, -5.0);
  336. gluDisk(podstawaSciany, 0.0, 0.5, 20, 5);
  337. gluCylinder(podstawaSciany, 0.5, 0.5, 10.0, 20, 5);
  338. glTranslatef(0.0, 0.0, 10.0);
  339. gluCylinder(podstawaSciany, 0.5, 0.2, 2.45, 20, 5);
  340. glTranslatef(0.0, 0.0, 2.45);
  341. glutWireSphere(0.2, 15.0, 15.0);
  342. glTranslatef(0.0, 0.0, 0.2);
  343. gluCylinder(podstawaSciany, 0.1, 0.1, 1.0, 20, 5);
  344. glPopMatrix();
  345.  
  346. //narysowanie stabilizatorów
  347. glColor3f(1.0,1.0,1.0);
  348. glPushMatrix();
  349. glTranslatef(-2.5, 0, -3);
  350. glRotatef(90, 0, 1, 0);
  351. gluCylinder(podstawaSciany, 0.1, 0.1, 5.0, 20, 5);
  352. glPopMatrix();
  353.  
  354. //narysowanie wypustu
  355. glColor3f(1.0,1.0,1.0);
  356. glPushMatrix();
  357. glTranslatef(-0.3, 0.0, -5.0);
  358. glRotatef(180, 0, 1, 0);
  359. gluCylinder(podstawaSciany, 0.1, 0.2, 0.3, 20, 5);
  360. glPopMatrix();
  361.  
  362. //narysowanie wypustu 2
  363. glColor3f(1.0,1.0,1.0);
  364. glPushMatrix();
  365. glTranslatef(0.3, 0.0, -5.0);
  366. glRotatef(180, 0, 1, 0);
  367. gluCylinder(podstawaSciany, 0.1, 0.2, 0.3, 20, 5);
  368. glPopMatrix();
  369. glPopMatrix();
  370. katrakieta = katrakieta +1;
  371. glPopMatrix();
  372.  
  373. //---------------------------DOBRZE
  374.  
  375.  
  376.  
  377. glTranslatef(0, 40, 0); //koniec RAKIETY
  378. //---------------------
  379.  
  380.  
  381. }
  382.  
  383.  
  384. //////////////////////////////////////////////////////////////////////////////////////////
  385. // Funkcja generujaca pojedyncza klatke animacji
  386. void WyswietlObraz(void)
  387. {
  388. // Wyczyszczenie bufora ramki i bufora glebokosci
  389. glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
  390.  
  391. // Powielenie macierzy na wierzcholku stosu
  392. glPushMatrix();
  393.  
  394. // Wyznaczenie polozenia obserwatora (przeksztalcenie uladu wspolrzednych
  395. // sceny do ukladu wspolrzednych obserwatora).
  396. //glTranslatef(0, 0, -40);
  397. glTranslatef(0, 0, currentOdl);//JS
  398. glRotatef(rotObsX, 1, 0, 0);
  399. glRotatef(rotObsY,0,1,0);
  400. glRotatef(rotObsZ, 0, 0, 1);
  401.  
  402.  
  403. // Generacja obrazu sceny w niewidocznym buforze ramki
  404. RysujRamieRobota(rotPodstawy, rotRamienia1, rotRamienia2, rotGlowicy, rozUchwytow);
  405.  
  406. //RysujZadanie1(); //JS
  407. //RysujUklad();
  408. RysujRakiete();
  409.  
  410. // Usuniecie macierzy lezacej na wierzcholku stosu (powrot do stanu
  411. // sprzed wywolania funkcji)
  412. glPopMatrix();
  413.  
  414. // Przelaczenie buforow ramki
  415. glutSwapBuffers();
  416.  
  417.  
  418. }
  419.  
  420. //////////////////////////////////////////////////////////////////////////////////////////
  421. // Funkcja ustawiajaca parametry rzutu perspektywicznego i rozmiary viewportu
  422. void UstawParametryWidoku(int szerokosc, int wysokosc)
  423. {
  424. // Ustawienie parametrow viewportu
  425. glViewport(0, 0, szerokosc, wysokosc);
  426.  
  427. // Przejscie w tryb modyfikacji macierzy rzutowania
  428. glMatrixMode(GL_PROJECTION);
  429. glLoadIdentity();
  430. gluPerspective(40.0, (float)szerokosc/(float)wysokosc, 1.0, 1000.0);
  431.  
  432. // Przejscie w tryb modyfikacji macierzy przeksztalcen geometrycznych
  433. glMatrixMode(GL_MODELVIEW);
  434.  
  435. // Zmiana macierzy znajdujacej sie na wierzcholku stosu na macierz jednostkowa
  436. glLoadIdentity();
  437. }
  438.  
  439. //////////////////////////////////////////////////////////////////////////////////////////
  440. // Funkcja klawiszy specjalnych
  441. void ObslugaKlawiszySpecjalnych(int klawisz, int x, int y)
  442. {
  443. switch(klawisz)
  444. {
  445. case GLUT_KEY_UP:
  446. rotObsX = (int)(rotObsX + 1.0) % 360; //(rotObsX < 90.0) ? rotObsX + 1.0 : rotObsX;
  447. break;
  448.  
  449. case GLUT_KEY_DOWN:
  450. rotObsX = (int)(rotObsX - 1.0) % 360; //(rotObsX > 0.0) ? rotObsX - 1.0 : rotObsX;
  451. break;
  452.  
  453. case GLUT_KEY_LEFT:
  454. rotObsY = (int)(rotObsY - 1.0) % 360; //(rotObsY > -90.0) ? rotObsY - 1.0 : rotObsY;
  455. break;
  456.  
  457. case GLUT_KEY_RIGHT:
  458. rotObsY = (int)(rotObsY + 1.0) % 360; //(rotObsY < 90.0) ? rotObsY + 1.0 : rotObsY;
  459. break;
  460. }
  461. }
  462. //////////////////////////////////////////////////////////////////////////////////////////
  463. // Funkcja obslugi klawiatury
  464. void ObslugaKlawiatury(unsigned char klawisz, int x, int y)
  465. {
  466.  
  467. switch(klawisz)
  468. {
  469. case '2':
  470. rotRamienia1 = (rotRamienia1 < 90.0) ? rotRamienia1 + 1.0 : rotRamienia1;
  471. break;
  472.  
  473. case '@':
  474. rotRamienia1 = (rotRamienia1 > 0.0) ? rotRamienia1 - 1.0 : rotRamienia1;
  475. break;
  476.  
  477. case '3':
  478. rotRamienia2 = (rotRamienia2 < 0.0) ? rotRamienia2 + 1.0 : rotRamienia2;
  479. break;
  480.  
  481. case '#':
  482. rotRamienia2 = (rotRamienia2 > -90.0) ? rotRamienia2 - 1.0 : rotRamienia2;
  483. break;
  484.  
  485. case '4':
  486. rotGlowicy = (rotGlowicy < 360.0) ? rotGlowicy + 1.0 : rotGlowicy;
  487. break;
  488.  
  489. case '$':
  490. rotGlowicy = (rotGlowicy > 0.0) ? rotGlowicy - 1.0 : rotGlowicy;
  491. break;
  492.  
  493. case '5':
  494. rozUchwytow = (rozUchwytow < 1.5) ? rozUchwytow + 0.1 : rozUchwytow;
  495. break;
  496.  
  497. case '%':
  498. rozUchwytow = (rozUchwytow > 0.5) ? rozUchwytow - 0.1 : rozUchwytow;
  499. break;
  500.  
  501. case 'k': {
  502. if (katobroturakiety > -90) katobroturakiety = katobroturakiety - 5.0; //dodalem do obrotu
  503. break;}
  504.  
  505. case 'l':{
  506. if (katobroturakiety < 90) katobroturakiety = katobroturakiety + 5.0; //dodalem do obrotu
  507. break;}
  508.  
  509. case ',': {
  510. if (predkosc > -5) predkosc = predkosc - 0.1; //predkosc rakiety
  511. break;}
  512.  
  513. case '.':{
  514. if (predkosc < 0) predkosc = predkosc + 0.1; //predkosc rakiety
  515. break;}
  516.  
  517. case '+'://JS
  518. currentOdl += zoomSpeed;
  519. if (currentOdl > odlMax)
  520. currentOdl = odlMax;
  521. if (currentOdl < odlMin)
  522. currentOdl = odlMin;
  523. break;
  524. case '-'://JS
  525. currentOdl -= zoomSpeed;
  526. if (currentOdl > odlMax)
  527. currentOdl = odlMax;
  528. if (currentOdl < odlMin)
  529. currentOdl = odlMin;
  530. break;
  531.  
  532. case '/':
  533. rotObsZ = (int)(rotObsZ + 1.0) % 360; //(rotObsY < 90.0) ? rotObsY + 1.0 : rotObsY;
  534. break;
  535. case '*':
  536. rotObsZ = (int)(rotObsZ - 1.0) % 360; //(rotObsY < 90.0) ? rotObsY + 1.0 : rotObsY;
  537. break;
  538.  
  539. }
  540.  
  541. if(klawisz == 27)
  542. exit(0);
  543. }
  544.  
  545. //////////////////////////////////////////////////////////////////////////////////////////
  546. // Glowna funkcja programu
  547. int main(int argc, char **argv)
  548. {
  549. // Zainicjowanie biblioteki GLUT
  550. glutInit(&argc, argv);
  551.  
  552. // Ustawienie trybu wyswietlania
  553. glutInitDisplayMode (GLUT_DOUBLE|GLUT_RGB|GLUT_DEPTH);
  554.  
  555. // Ustawienie polozenia dolenego lewego rogu okna
  556. glutInitWindowPosition(100, 100);
  557.  
  558. // Ustawienie rozmiarow okna
  559. glutInitWindowSize(400, 400);
  560.  
  561. // Utworzenie okna
  562. glutCreateWindow("Robot");
  563.  
  564. // Odblokowanie bufora glebokosci
  565. glEnable(GL_DEPTH_TEST);
  566.  
  567. // Ustawienie funkcji wykonywanej na danych w buforze glebokosci
  568. glDepthFunc(GL_LEQUAL);
  569.  
  570. // Ustawienie wartosci czyszczacej zawartosc bufora glebokosci
  571. glClearDepth(1000.0);
  572.  
  573. // Ustawienie koloru czyszczenia bufora ramki
  574. glClearColor (0.3, 0.3, 0.3, 0.0);
  575.  
  576. // Zarejestrowanie funkcji (callback) wyswietlajacej
  577. glutDisplayFunc(WyswietlObraz);
  578.  
  579. // Zarejestrowanie funkcji (callback) wywolywanej za kazdym razem kiedy
  580. // zmieniane sa rozmiary okna
  581. glutReshapeFunc(UstawParametryWidoku);
  582.  
  583. // Zarejestrowanie funkcji wykonywanej gdy okno nie obsluguje
  584. // zadnych zadan
  585. glutIdleFunc(WyswietlObraz);
  586.  
  587. // Zarejestrowanie funkcji obslugi klawiatury
  588. glutKeyboardFunc(ObslugaKlawiatury);
  589.  
  590. // Zarejestrowanie funkcji obslugi klawiszy specjalnych
  591. glutSpecialFunc(ObslugaKlawiszySpecjalnych);
  592.  
  593.  
  594. // Zainicjowanie kwadryk tworzacych ramie robota
  595. InicjujRamieRobota();
  596.  
  597. // Obsluga glownej petli programu (wywolywanie zarejestrowanych callbackow
  598. // w odpowiedzi na odbierane zdarzenia lub obsluga stanu bezczynnosci)
  599. glutMainLoop();
  600.  
  601. return 0;
  602. }
RAW Paste Data