API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jan 21st, 2020
69
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 15.69 KB | None | 0 0
raw download clone embed print report
  1. //////////////////////////////////////////////////////////////////////////////////////////
  2. //
  3. // Program wyswietlajacy szescian w rzucie perspektywicznym. Dlugosc boku szescianu
  4. // moze byc interaktywnie zmieniana za pomoca klwiszy '+' i '-'.
  5. //
  6. //////////////////////////////////////////////////////////////////////////////////////////
  7.  
  8. #include "glut.h"
  9. #include <math.h>
  10. #include <time.h>
  11. #include <stdint.h>
  12.  
  13.  
  14. #define odlMin 5
  15. #define odlMax 200
  16. #define Pi 3.14159265359
  17.  
  18. int podzialPionowy = 8;
  19. int podzialPoziomy = 5;
  20. int szerokoscOkna = 800;
  21. int wysokoscOkna = 600;
  22.  
  23. GLboolean tryb = GL_TRUE;
  24.  
  25. GLfloat odlObs = 50.0;
  26. GLfloat rotObsY = 40.0;
  27. GLfloat rotObsX = 40.0;
  28. GLfloat rotObsZ = 0.0;
  29.  
  30. float length;
  31.  
  32. int source1 = 1;
  33. int source2 = 1;
  34. int obecnymaterial = 0;
  35. int normalne = 1;
  36. int smooth = 1;
  37. int fill = 1;
  38.  
  39. // Tablica parametrow materialu nr 1
  40. float material1[5][4] = {
  41. {0.192250, 0.192250, 0.192250, 1.000000}, // [0] wspolczynnik odbicia swiatla otoczenia
  42. {0.507540, 0.507540, 0.507540, 1.000000}, // [1] wspolczynnik odbicia swiatla rozproszonego
  43. {0.508273, 0.508273, 0.508273, 1.000000}, // [2] wspolczynnik odbicia swiatla lustrzanego
  44. {51.2, 0.0, 0.0, 0.0}, // [3] polysk
  45. {0.5, 0.0, 0.2, 1.0} }; // [4] kolor swiatla emitowanego
  46.  
  47. // Tablica parametrow materialu nr 2
  48. float material2[5][4] = {
  49. {0.250000, 0.148000, 0.064750, 1.000000}, // [0] wspolczynnik odbicia swiatla otoczenia
  50. {0.400000, 0.236800, 0.103600, 1.000000}, // [1] wspolczynnik odbicia swiatla rozproszonego
  51. {0.774597, 0.458561, 0.200621, 1.000000}, // [2] wspolczynnik odbicia swiatla lustrzanego
  52. {76.8, 0.0, 0.0, 0.0}, // [3] polysk
  53. {0.0, 0.1, 0.3, 1.0} }; // [4] kolor swiatla emitowanego
  54.  
  55. // Tablica parametrow materialu nr 3
  56. float material3[5][4] = {
  57. {0.231250, 0.231250, 0.231250, 1.000000}, // [0] wspolczynnik odbicia swiatla otoczenia
  58. {0.277500, 0.277500, 0.277500, 1.000000}, // [1] wspolczynnik odbicia swiatla rozproszonego
  59. {0.773911, 0.773911, 0.773911, 1.000000 }, // [2] wspolczynnik odbicia swiatla lustrzanego
  60. {52.2, 0.0, 0.0, 0.0}, // [3] polysk
  61. {0.0, 0.0, 0.0, 1.0} }; // [4] kolor swiatla emitowanego
  62.  
  63. // Tablica parametrow zrodla swiatla nr 1
  64. GLfloat swiatlo1[5][4] = {
  65. {0.2, 0.2, 0, 1.0}, // [0] otoczenie
  66. {0.2, 0.2, 0.0, 1.0}, // [1] rozproszenie
  67. {0.2, 0.8, 0.0, 1.0}, // [2] lustrzane
  68. {0, 10.0, 0, 1.0}, // [3] polozenie
  69. {-1.0, -1.0, -1.0, 0.0} // [4] kierunek swiecenia
  70. };
  71.  
  72. // Tablica parametrow zrodla swiatla nr 2
  73. GLfloat swiatlo2[5][4] = {
  74. {0, 1, 1, 1.0}, // [0] otoczenie
  75. {0, 1, 1, 1.0}, // [1] rozproszenie
  76. {0, 28, 1, 1.0}, // [2] lustrzane
  77. {0, 0, -10.0, 1.0}, // [3] polozenie
  78. {-1.0, -1.0, -1.0, 0.0} // [4] kierunek swiecenia
  79. };
  80.  
  81.  
  82. // Prototypy funkcji
  83. void RysujSzescian(double a);
  84. void UstawParametryWidoku(int szer, int wys);
  85. void WyswietlObraz(void);
  86. void ObslugaKlawiatury(unsigned char klawisz, int x, int y);
  87. void PoliczNormal(float x1, float x2, float x3, float y1, float y2, float y3, float z1, float z2, float z3, float* normal);
  88.  
  89. void RysujTekstRastrowy(void* font, char* tekst)
  90. {
  91. int i = 0;
  92. while (tekst[i] != '\0')
  93. {
  94. glutBitmapCharacter(font, tekst[i]);
  95. i++;
  96. }
  97. }
  98.  
  99. #define numberofoptions 11
  100.  
  101. void RysujNakladke(void)
  102. {
  103. char tab[numberofoptions][50]=
  104. {"1 - Oddalenie",
  105. "2 - Przyblizenie",
  106. "5 - Zmiana materialu pierscienia",
  107. "6 - Sterowanie swiatlem nr. 1",
  108. "7 - Sterowanie swiatlem nr. 2",
  109. "8 - Widocznosc wektorow normalnych",
  110. "9 - Zmiana cienia (GL_SMOOTH i GL_FLAT)",
  111. "0 - Zmiana wypelnienia (GL_FILL, GL_LINE)",
  112. "- - Zmniejszanie ilosci podzialow",
  113. "= - Zwiekszanie ilosci podzialow",
  114. "WASDQE - Sterowanie kamera",
  115. };
  116. int i;
  117.  
  118. // Zmiana typu rzutu z perspektywicznego na ortogonalny
  119. glMatrixMode(GL_PROJECTION);
  120. glPushMatrix();
  121. glLoadIdentity();
  122. glOrtho(0.0, szerokoscOkna, 0.0, wysokoscOkna, -100.0, 100.0);
  123.  
  124. // Modelowanie sceny 2D (zawartosci nakladki)
  125. glMatrixMode(GL_MODELVIEW);
  126. glPushMatrix();
  127. glLoadIdentity();
  128.  
  129. // Zablokowanie oswietlenia (mialoby ono wplyw na kolor tekstu)
  130. glDisable(GL_LIGHTING);
  131.  
  132. // Okreslenie koloru tekstu
  133. glColor3f(1.0, 1.0, 1.0);
  134.  
  135. // RYSOWANIE MENU PARAMETROW ZRODLA SWIATLA
  136.  
  137. for (i = 0;i < numberofoptions;i++)
  138. {
  139. glRasterPos2i(10, 10 + i * 13);
  140. RysujTekstRastrowy(GLUT_BITMAP_8_BY_13, tab[numberofoptions - i - 1]);
  141. }
  142.  
  143. glMatrixMode(GL_PROJECTION);
  144. glPopMatrix();
  145. glMatrixMode(GL_MODELVIEW);
  146. glPopMatrix();
  147. }
  148.  
  149. void UstawSwiatlaIMaterialy()
  150. {
  151. glEnable(GL_LIGHTING);
  152. // Odblokowanie zrodla swiatla nr 1
  153. if (source1 == 1) {
  154. glEnable(GL_LIGHT0);
  155. glLightfv(GL_LIGHT0, GL_AMBIENT, swiatlo1[0]);
  156. glLightfv(GL_LIGHT0, GL_DIFFUSE, swiatlo1[1]);
  157. glLightfv(GL_LIGHT0, GL_SPECULAR, swiatlo1[2]);
  158. glLightfv(GL_LIGHT0, GL_POSITION, swiatlo1[3]);
  159. glLightfv(GL_LIGHT0, GL_SPOT_DIRECTION, swiatlo1[4]);
  160.  
  161. }
  162. else {
  163. //wylaczenie zrodla swiatla nr 1
  164. glDisable(GL_LIGHT0);
  165. }
  166. // Odblokowanie zrodla swiatla nr 2
  167. if (source2 == 1) {
  168. glEnable(GL_LIGHT1);
  169. glLightfv(GL_LIGHT1, GL_AMBIENT, swiatlo2[0]);
  170. glLightfv(GL_LIGHT1, GL_DIFFUSE, swiatlo2[1]);
  171. glLightfv(GL_LIGHT1, GL_SPECULAR, swiatlo2[2]);
  172. glLightfv(GL_LIGHT1, GL_POSITION, swiatlo2[3]);
  173. glLightfv(GL_LIGHT1, GL_SPOT_DIRECTION, swiatlo2[4]);
  174.  
  175. }
  176. else {
  177. //wylaczenie zrodla swiatla nr 2
  178. glDisable(GL_LIGHT1);
  179. }
  180.  
  181. switch (obecnymaterial)
  182. {
  183. case 0:
  184. glMaterialfv(GL_FRONT, GL_AMBIENT, material1[0]);
  185. glMaterialfv(GL_FRONT, GL_DIFFUSE, material1[1]);
  186. glMaterialfv(GL_FRONT, GL_SPECULAR, material1[2]);
  187. glMaterialfv(GL_FRONT, GL_SHININESS, material1[3]);
  188. glMaterialfv(GL_FRONT, GL_EMISSION, material1[4]);
  189. break;
  190. case 1:
  191. glMaterialfv(GL_FRONT, GL_AMBIENT, material2[0]);
  192. glMaterialfv(GL_FRONT, GL_DIFFUSE, material2[1]);
  193. glMaterialfv(GL_FRONT, GL_SPECULAR, material2[2]);
  194. glMaterialfv(GL_FRONT, GL_SHININESS, material2[3]);
  195. glMaterialfv(GL_FRONT, GL_EMISSION, material2[4]);
  196. break;
  197. case 2:
  198. glMaterialfv(GL_FRONT, GL_AMBIENT, material3[0]);
  199. glMaterialfv(GL_FRONT, GL_DIFFUSE, material3[1]);
  200. glMaterialfv(GL_FRONT, GL_SPECULAR, material3[2]);
  201. glMaterialfv(GL_FRONT, GL_SHININESS, material3[3]);
  202. glMaterialfv(GL_FRONT, GL_EMISSION, material3[4]);
  203. break;
  204. default:
  205. break;
  206. }
  207. }
  208.  
  209. void PoliczNormal(float x1, float x2, float x3, float y1, float y2, float y3, float z1, float z2, float z3, float* normal)
  210. {
  211. float xa = x2 - x1;
  212. float ya = y2 - y1;
  213. float za = z2 - z1;
  214.  
  215. float xb = x3 - x1;
  216. float yb = y3 - y1;
  217. float zb = z3 - z1;
  218.  
  219. normal[0] = ya * zb - za * yb;
  220. normal[1] = za * xb - xa * zb;
  221. normal[2] = xa * yb - ya * xb;
  222.  
  223. length = sqrtf(normal[0] * normal[0] + normal[1] * normal[1] + normal[2] * normal[2]);
  224.  
  225. normal[0] /= length;
  226. normal[1] /= length;
  227. normal[2] /= length;
  228. }
  229.  
  230. void SyncSmoothIFill()
  231. {
  232. if (smooth)
  233. glShadeModel(GL_SMOOTH);
  234. else
  235. glShadeModel(GL_FLAT);
  236.  
  237. if (fill)
  238. glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
  239. else
  240. glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
  241. }
  242.  
  243. double DEG2RAD(float deg)
  244. {
  245. return deg * Pi / 180;
  246. }
  247.  
  248.  
  249.  
  250. void Stozek(double R, double r, double h) {
  251. int i;
  252. double dAlfa = 360.0 / podzialPionowy;
  253.  
  254. //podstawa dolna
  255. glBegin(GL_TRIANGLE_FAN);
  256. glVertex3f(0, 0, 0);
  257. for (i = 0; i * dAlfa <= 360.0; i++) {
  258. glVertex3f(R * cos(DEG2RAD(i * dAlfa)), 0, R * sin(DEG2RAD(i * dAlfa)));
  259. }
  260. glEnd();
  261.  
  262. //podstawa gorna
  263. glBegin(GL_TRIANGLE_FAN);
  264. glVertex3f(0, h, 0);
  265. for (i = 0; i * dAlfa <= 360.0; i++) {
  266. glVertex3f(r * cos(DEG2RAD(i * dAlfa)), h, r * sin(DEG2RAD(i * dAlfa)));
  267. }
  268. glEnd();
  269.  
  270. //sciana boczna
  271. glBegin(GL_QUAD_STRIP);
  272. for (i = 0; i * dAlfa <= 360.0; i++) {
  273. glVertex3f(R * cos(DEG2RAD(i * dAlfa)), 0, R * sin(DEG2RAD(i * dAlfa)));
  274. glVertex3f(r * cos(DEG2RAD(i * dAlfa)), h, r * sin(DEG2RAD(i * dAlfa)));
  275. }
  276. glEnd();
  277. }
  278.  
  279. void Walec() {
  280. double r = 2.0;
  281. double h = 3.0;
  282. double hPodzial = h / podzialPoziomy;
  283. double dAlfa = 90.0 / podzialPionowy;
  284. int i,j;
  285. float x1, x2, x3, x4;
  286. float z1, z2, z3, z4;
  287. float y1, y2, y3, y4;
  288. float normal[3];
  289.  
  290. glColor3f(1, 0, 1);
  291. for ( j = 0; j * hPodzial < h; j++) {
  292.  
  293. glBegin(GL_QUAD_STRIP);
  294.  
  295. for ( i = 0; i * dAlfa <= 90.0; i++) {
  296.  
  297. x1=r * cos(DEG2RAD(i * dAlfa));
  298. x2=r * cos(DEG2RAD(i * dAlfa));
  299. x3=0;
  300. y1= ((j+1)*hPodzial);
  301. y2=(j*hPodzial);
  302. y3=0;
  303. z1=( r * sin(DEG2RAD(i * dAlfa)));
  304. z2=(r * sin(DEG2RAD(i * dAlfa)));
  305. z3=0;
  306. PoliczNormal(x1, x2, x3, y1, y2, y3, z1, z2, z3, normal);
  307. glNormal3f(normal[0], normal[1], normal[2]);
  308. glVertex3f(r * cos(DEG2RAD(i * dAlfa)), (j+1)*hPodzial, r * sin(DEG2RAD(i * dAlfa)));
  309. glVertex3f(r * cos(DEG2RAD(i * dAlfa)), j*hPodzial, r * sin(DEG2RAD(i * dAlfa)));
  310. if (i * dAlfa == 90) {
  311. glVertex3f(0, (j + 1) * hPodzial, 2);
  312. glVertex3f(0, j * hPodzial, 2);
  313. glVertex3f(0, (j + 1) * hPodzial, 0);
  314. glVertex3f(0, j * hPodzial, 0);
  315. glVertex3f(2, (j + 1) * hPodzial, 0);
  316. glVertex3f(2, j * hPodzial, 0);
  317. }
  318. }
  319. glEnd();
  320. }
  321.  
  322.  
  323. glBegin(GL_TRIANGLE_FAN);
  324. glVertex3f(0, 0, 0);
  325. for (i = 0; i * dAlfa <= 90.0; i++) {
  326.  
  327. x1=(r * cos(DEG2RAD(i * dAlfa)));
  328. y1=0;
  329. z1= (r * sin(DEG2RAD(i * dAlfa)));
  330. x2 =0;
  331. y2=0;
  332. z2=0;
  333. x3=0;
  334. y3=0;
  335. z3=0;
  336. PoliczNormal(x1, x2, x3, y1, y2, y3, z1, z2, z3, normal);
  337. glNormal3f(normal[0], normal[1], normal[2]);
  338.  
  339. glVertex3f(r * cos(DEG2RAD(i * dAlfa)), 0, r * sin(DEG2RAD(i * dAlfa)));
  340. }
  341. glEnd();
  342.  
  343.  
  344. glBegin(GL_TRIANGLE_FAN);
  345. glVertex3f(0, h, 0);
  346.  
  347. for (i = 0; i * dAlfa <= 90.0; i++) {
  348. x1=(r * cos(DEG2RAD(i * dAlfa)));
  349. y1=h;
  350. z1= (r * sin(DEG2RAD(i * dAlfa)));
  351. x2 =0;
  352. y2=0;
  353. z2=0;
  354. x3=0;
  355. y3=0;
  356. z3=0;
  357. PoliczNormal(x1, x2, x3, y1, y2, y3, z1, z2, z3, normal);
  358. glNormal3f(normal[0], normal[1], normal[2]);
  359. glVertex3f(r * cos(DEG2RAD(i * dAlfa)), h, r * sin(DEG2RAD(i * dAlfa)));
  360. }
  361. glEnd();
  362. }
  363. /*
  364. void Rysuj()
  365. {
  366. // Poczatek tworzenia ukladu wspolrzednych
  367. glBegin(GL_LINES);
  368.  
  369. // Os X
  370. glColor3f(1.0, 0.0, 0.0);
  371. glVertex3f(-80.0, 0.0, 0.0);
  372. glVertex3f(80.0, 0.0, 0.0);
  373.  
  374. // Os Y
  375. glColor3f(0.0, 1.0, 0.0);
  376. glVertex3f(0.0, -80.0, 0.0);
  377. glVertex3f(0.0, 80.0, 0.0);
  378.  
  379. // Os Z
  380. glColor3f(0.0, 0.0, 1.0);
  381. glVertex3f(0.0, 0.0, -80.0);
  382. glVertex3f(0.0, 0.0, 80.0);
  383.  
  384. // Koniec tworzenia ukladu wspolrzednych
  385. glEnd();
  386.  
  387. //Stozek(10,20,25);
  388. Walec();
  389.  
  390. }
  391. */
  392. //////////////////////////////////////////////////////////////////////////////////////////
  393. // Funkcja generujaca pojedyncza klatke animacji
  394. void WyswietlObraz(void)
  395. {
  396. // Wyczyszczenie bufora ramki i bufora glebokosci
  397. glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  398. glMatrixMode(GL_MODELVIEW);
  399.  
  400. // Powielenie macierzy na wierzcholku stosu
  401. glPushMatrix();
  402.  
  403. // Wyznaczenie polozenia obserwatora (przeksztalcenie uladu wspolrzednych
  404. // sceny do ukladu wspolrzednych obserwatora).
  405. glTranslatef(0, 0, -odlObs);
  406. glRotatef(rotObsX, 1, 0, 0);
  407. glRotatef(rotObsY, 0, 1, 0);
  408. glRotatef(rotObsZ, 0, 0, 1);
  409.  
  410. RysujNakladke();
  411.  
  412. UstawSwiatlaIMaterialy();
  413.  
  414. // Generacja obrazu sceny w niewidocznym buforze ramki
  415. Walec();
  416.  
  417. // Usuniecie macierzy lezacej na wierzcholku stosu (powrot do stanu
  418. // sprzed wywolania funkcji
  419. glPopMatrix();
  420.  
  421. // Przelaczenie buforow ramki
  422. glutSwapBuffers();
  423. }
  424.  
  425. //////////////////////////////////////////////////////////////////////////////////////////
  426. // Funkcja ustawiajaca parametry rzutu perspektywicznego i rozmiary viewportu
  427. void UstawParametryWidoku(int szerokosc, int wysokosc)
  428. {
  429. // Ustawienie parametrow viewportu
  430. glViewport(0, 0, szerokosc, wysokosc);
  431.  
  432. // Przejscie w tryb modyfikacji macierzy rzutowania
  433. glMatrixMode(GL_PROJECTION);
  434. glLoadIdentity();
  435. gluPerspective(40.0, (float)szerokosc / (float)wysokosc, 1.0, 1000.0);
  436.  
  437. // Przejscie w tryb modyfikacji macierzy przeksztalcen geometrycznych
  438. glMatrixMode(GL_MODELVIEW);
  439.  
  440. // Zmiana macierzy znajdujacej sie na wierzcholku stosu na macierz jednostkowa
  441. glLoadIdentity();
  442. }
  443.  
  444. void ZmianaTrybu()
  445. {
  446. if (tryb == GL_TRUE)
  447. {
  448. tryb = GL_FALSE;
  449. glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
  450. }
  451. else if (tryb == GL_FALSE)
  452. {
  453. tryb = GL_TRUE;
  454. glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
  455. }
  456. }
  457.  
  458. //////////////////////////////////////////////////////////////////////////////////////////
  459. // Funkcja klawiszy specjalnych
  460. void ObslugaKlawiszySpecjalnych(int klawisz, int x, int y)
  461. {
  462. switch (klawisz)
  463. {
  464. case GLUT_KEY_UP:
  465. rotObsX = rotObsX + 1.0;
  466. break;
  467.  
  468. case GLUT_KEY_DOWN:
  469. rotObsX = rotObsX - 1.0;
  470. break;
  471.  
  472. case GLUT_KEY_LEFT:
  473. rotObsY = rotObsY - 1.0;
  474. break;
  475.  
  476. case GLUT_KEY_RIGHT:
  477. rotObsY = rotObsY + 1.0;
  478. break;
  479. }
  480. }
  481. //////////////////////////////////////////////////////////////////////////////////////////
  482. // Funkcja obslugi klawiatury
  483. void ObslugaKlawiatury(unsigned char klawisz, int x, int y)
  484. {
  485.  
  486. switch (klawisz)
  487. {
  488. case '1':
  489. odlObs = (odlObs > odlMin) ? odlObs - 1 : odlObs;
  490. break;
  491. case '2':
  492. odlObs = (odlObs < odlMax) ? odlObs + 1 : odlObs;
  493. break;
  494. case 'Q':
  495. rotObsZ = (rotObsZ > -90.0) ? rotObsZ - 1.0 : rotObsZ;
  496. break;
  497. case 'E':
  498. rotObsZ = (rotObsZ < 90.0) ? rotObsZ + 1.0 : rotObsZ;
  499. break;
  500. case 'z':
  501. podzialPionowy = (podzialPionowy > 4) ? podzialPionowy - 1.0 : podzialPionowy;
  502. break;
  503. case 'x':
  504. podzialPionowy = (podzialPionowy < 64) ? podzialPionowy + 1.0 : podzialPionowy;
  505. break;
  506. case 'a':
  507. podzialPoziomy = (podzialPoziomy > 4) ? podzialPoziomy - 1.0 : podzialPoziomy;
  508. break;
  509. case 's':
  510. podzialPoziomy = (podzialPoziomy < 64) ? podzialPoziomy + 1.0 : podzialPoziomy;
  511. break;
  512. case '5':
  513. obecnymaterial++;
  514. if (obecnymaterial > 2)
  515. obecnymaterial = 0;
  516. break;
  517. case '6':
  518. source1 = !source1;
  519. break;
  520. case '7':
  521. source2 = !source2;
  522. break;
  523. case '8':
  524. normalne = !normalne;
  525. break;
  526. case '9':
  527. smooth = !smooth;
  528. SyncSmoothIFill();
  529. break;
  530. case '0':
  531. fill = !fill;
  532. SyncSmoothIFill();
  533. break;
  534. }
  535.  
  536. if (klawisz == 27)
  537. exit(0);
  538. }
  539.  
  540. //////////////////////////////////////////////////////////////////////////////////////////
  541. // Glowna funkcja programu
  542. int main(int argc, char** argv)
  543. {
  544. // Zainicjowanie biblioteki GLUT
  545. glutInit(&argc, argv);
  546.  
  547. // Ustawienie trybu wyswietlania
  548. glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
  549.  
  550. // Ustawienie polozenia dolenego lewego rogu okna
  551. glutInitWindowPosition(100, 100);
  552.  
  553. // Ustawienie rozmiarow okna
  554. glutInitWindowSize(400, 400);
  555.  
  556. // Utworzenie okna
  557. glutCreateWindow("Szescian");
  558.  
  559. // Odblokowanie bufora glebokosci
  560. glEnable(GL_DEPTH_TEST);
  561.  
  562. // Ustawienie funkcji wykonywanej na danych w buforze glebokosci
  563. glDepthFunc(GL_LEQUAL);
  564.  
  565. // Ustawienie wartosci czyszczacej zawartosc bufora glebokosci
  566. glClearDepth(1000.0);
  567.  
  568. // Ustawienie koloru czyszczenia bufora ramki
  569. glClearColor(0.0, 0.0, 0.0, 0.0);
  570.  
  571.  
  572. // Zarejestrowanie funkcji (callback) wyswietlajacej
  573. glutDisplayFunc(WyswietlObraz);
  574.  
  575. // Zarejestrowanie funkcji (callback) wywolywanej za kazdym razem kiedy
  576. // zmieniane sa rozmiary okna
  577. glutReshapeFunc(UstawParametryWidoku);
  578.  
  579. // Zarejestrowanie funkcji wykonywanej gdy okno nie obsluguje
  580. // zadnych zadan
  581. glutIdleFunc(WyswietlObraz);
  582.  
  583. // Zarejestrowanie funkcji obslugi klawiatury
  584. glutKeyboardFunc(ObslugaKlawiatury);
  585.  
  586. // Zarejestrowanie funkcji obslugi klawiszy specjalnych
  587. glutSpecialFunc(ObslugaKlawiszySpecjalnych);
  588.  
  589.  
  590.  
  591. // Obsluga glownej petli programu (wywolywanie zarejestrowanych callbackow
  592. // w odpowiedzi na odbierane zdarzenia lub obsluga stanu bezczynnosci)
  593. glutMainLoop();
  594.  
  595. return 0;
  596. }
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!