API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Dec 17th, 2018
71
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 17.95 KB | None | 0 0
raw download clone embed print report
  1. /*************************************************************************************/
  2.  
  3. // Szkielet programu do tworzenia modelu sceny 3-D z wizualizacją osi
  4. // układu współrzędnych dla rzutowania perspektywicznego
  5.  
  6. /*************************************************************************************/
  7.  
  8. #include <windows.h>
  9. #include <gl/gl.h>
  10. #include <gl/glut.h>
  11. #include <math.h>
  12. #include <iostream>
  13.  
  14. #define M_PI 3.14159265358979323846
  15.  
  16.  
  17. typedef float point3[3];
  18.  
  19. static GLfloat viewer[] = { 0.0, 0.0, 10.0 };
  20. static GLfloat viewer2[] = { 0.0, 0.0, 10.0 };
  21. // inicjalizacja położenia obserwatora
  22.  
  23. static GLfloat theta[] = { 0.0, 0.0, 0.0 }; // trzy kąty obrotu
  24. static GLfloat theta2[] = { 0.0, 0.0, 0.0 }; // trzy kąty obrotu
  25. static GLfloat pix2angle; // przelicznik pikseli na stopnie
  26. # define Npoint 20
  27.  
  28. int model = 3; // 1- punkty, 2- siatka, 3 - wypełnione trójkąty
  29.  
  30. static GLint status = 0; // stan klawiszy myszy
  31. // 0 - nie naciśnięto żadnego klawisza
  32. // 1 - naciśnięty zostać lewy klawisz
  33. // 2 - naciśnięty zostać prawy klawisz
  34.  
  35. static int x_pos_old = 0; // poprzednia pozycja kursora myszy
  36. static int y_pos_old = 0; // poprzednia pozycja kursora myszy
  37.  
  38. static int delta_x = 0; // różnica pomiędzy pozycją bieżącą z poprzednią kursora myszy
  39. static int delta_y = 0; // różnica pomiędzy pozycją bieżącą z poprzednią kursora myszy
  40.  
  41. static GLfloat promien = 10;
  42. static GLfloat azymut = 0.0;
  43. static GLfloat elewacja = 0.0;
  44.  
  45. // kopia, aby utworzyc kolejna os
  46. static int x_pos_old2 = 0; // poprzednia pozycja kursora myszy
  47. static int y_pos_old2 = 0; // poprzednia pozycja kursora myszy
  48.  
  49. static int delta_x2 = 0; // różnica pomiędzy pozycją bieżącą z poprzednią kursora myszy
  50. static int delta_y2 = 0; // różnica pomiędzy pozycją bieżącą z poprzednią kursora myszy
  51.  
  52. static GLfloat promien2 = 10;
  53. static GLfloat azymut2 = 0.0;
  54. static GLfloat elewacja2 = 0.0;
  55.  
  56. static GLfloat color[10][3];
  57. const int n = 60;
  58. struct Point
  59. {
  60. float x, y, z;
  61. };
  62.  
  63. /*************************************************************************************/
  64.  
  65. // Funkcja rysująca osie układu wspó?rz?dnych
  66.  
  67.  
  68.  
  69. void Axes(void)
  70. {
  71.  
  72. point3 x_min = { -5.0, 0.0, 0.0 };
  73. point3 x_max = { 5.0, 0.0, 0.0 };
  74. // pocz?tek i koniec obrazu osi x
  75.  
  76. point3 y_min = { 0.0, -5.0, 0.0 };
  77. point3 y_max = { 0.0, 5.0, 0.0 };
  78. // pocz?tek i koniec obrazu osi y
  79.  
  80. point3 z_min = { 0.0, 0.0, -5.0 };
  81. point3 z_max = { 0.0, 0.0, 5.0 };
  82. // pocz?tek i koniec obrazu osi y
  83. glColor3f(1.0f, 0.0f, 0.0f); // kolor rysowania osi - czerwony
  84. glBegin(GL_LINES); // rysowanie osi x
  85. glVertex3fv(x_min);
  86. glVertex3fv(x_max);
  87. glEnd();
  88.  
  89. glColor3f(0.0f, 1.0f, 0.0f); // kolor rysowania - zielony
  90. glBegin(GL_LINES); // rysowanie osi y
  91.  
  92. glVertex3fv(y_min);
  93. glVertex3fv(y_max);
  94. glEnd();
  95.  
  96. glColor3f(0.0f, 0.0f, 1.0f); // kolor rysowania - niebieski
  97. glBegin(GL_LINES); // rysowanie osi z
  98.  
  99. glVertex3fv(z_min);
  100. glVertex3fv(z_max);
  101. glEnd();
  102.  
  103. }
  104.  
  105. /*************************************************************************************/
  106. void Egg() {
  107. Point coords[n][n]; // koordynaty
  108. Point normal[n][n]; // Do wektora normalnego
  109. float xu, xv, zu, zv, yu, yv, length;
  110. for (int i = 0; i < n; i++)
  111. {
  112. float u = (float)i / (n - 1);
  113. for (int j = 0; j < n; j++)
  114. {
  115. float v = (float)j / (n - 1);
  116.  
  117. // Wzory na obliczenie normalnych koor dla jajka
  118. coords[i][j].x = (-90 * pow(u, 5) + 225 * pow(u, 4) - 270 * pow(u, 3) + 180 * pow(u, 2) - 45 * u)*cos(3.14*v);
  119. coords[i][j].y = 160 * pow(u, 4) - 320 * pow(u, 3) + 160 * pow(u, 2);
  120. coords[i][j].z = (-90 * pow(u, 5) + 225 * pow(u, 4) - 270 * pow(u, 3) + 180 * pow(u, 2) - 45 * u) * sin(3.14*v);
  121.  
  122. // Wzory na obliczenie wektora normalnego
  123. xu = (-450 * pow(u, 4) + 900 * pow(u, 3) - 810 * pow(u, 2) + 360 * u - 45) * cos(3.14*v);
  124. xv = 3.14 * (90 * pow(u, 5) - 225 * pow(u, 4) + 270 * pow(u, 3) - 180 * pow(u, 2) + 45 * u)* sin(3.14*v);
  125. yu = 640 * pow(u, 3) - 960 * pow(u, 2) + 320 * u;
  126. yv = 0;
  127. zu = (-450 * pow(u, 4) + 900 * pow(u, 3) - 810 * pow(u, 2) + 360 * u - 45) * sin(3.14*v);
  128. zv = -3.14 * (90 * pow(u, 5) - 225 * pow(u, 4) + 270 * pow(u, 3) - 180 * pow(u, 2) + 45 * u)*cos(3.14*v);
  129.  
  130. normal[i][j].x = yu * zv - zu * yv;
  131. normal[i][j].y = zu * xv - xu * zv;
  132. normal[i][j].z = xu * yv - yu * xv;
  133.  
  134. // Potrzebne do normalizacji
  135. length = sqrt(pow(normal[i][j].x, 2) + pow(normal[i][j].y, 2) + pow(normal[i][j].z, 2));
  136.  
  137. // Gora jajka
  138. if (i == n / 2) {
  139. normal[i][j].x = 0;
  140. normal[i][j].y = 1;
  141. normal[i][j].z = 0;
  142. }
  143. // Dol jajka
  144. else if (i == n || i == 0) {
  145. normal[i][j].x = 0;
  146. normal[i][j].y = -1;
  147. normal[i][j].z = 0;
  148. }
  149. else if (i < n / 2) {
  150. normal[i][j].x = normal[i][j].x / length;
  151. normal[i][j].y = normal[i][j].y / length;
  152. normal[i][j].z = normal[i][j].z / length;
  153. }
  154. else if (i > n / 2) {
  155. normal[i][j].x = -normal[i][j].x / length;
  156. normal[i][j].y = -normal[i][j].y / length;
  157. normal[i][j].z = -normal[i][j].z / length;
  158. }
  159. }
  160. }
  161.  
  162. if (model == 3) {
  163. glBegin(GL_TRIANGLES);
  164. for (int i = 0; i < n - 1; i++)
  165. {
  166. GLfloat k = i / n;
  167. for (int j = 0; j < n - 1; j++)
  168. {
  169. GLfloat l = j / n;
  170. glNormal3f(normal[i][j].x, normal[i][j].y, normal[i][j].z);
  171. glTexCoord2f(k, l);
  172. glVertex3f(coords[i][j].x, coords[i][j].y - 5, coords[i][j].z);
  173. glNormal3f(normal[i][j + 1].x, normal[i][j + 1].y, normal[i][j + 1].z);
  174. glTexCoord2f(k, l + 1);
  175. glVertex3f(coords[i][j + 1].x, coords[i][j + 1].y - 5, coords[i][j + 1].z);
  176. glNormal3f(normal[i + 1][j].x, normal[i + 1][j].y, normal[i + 1][j].z);
  177. glTexCoord2f(k + 1, l);
  178. glVertex3f(coords[i + 1][j].x, coords[i + 1][j].y - 5, coords[i + 1][j].z);
  179. }
  180. }
  181.  
  182. for (int i = 0; i < n - 1; i++)
  183. {
  184. for (int j = 0; j < n - 1; j++)
  185. {
  186. glNormal3f(normal[i + 1][j + 1].x, normal[i + 1][j + 1].y, normal[i + 1][j + 1].z);
  187. glVertex3f(coords[i + 1][j + 1].x, coords[i + 1][j + 1].y - 5, coords[i + 1][j + 1].z);
  188. glNormal3f(normal[i][j + 1].x, normal[i][j + 1].y, normal[i][j + 1].z);
  189. glVertex3f(coords[i][j + 1].x, coords[i][j + 1].y - 5, coords[i][j + 1].z);
  190. glNormal3f(normal[i + 1][j].x, normal[i + 1][j].y, normal[i + 1][j].z);
  191. glVertex3f(coords[i + 1][j].x, coords[i + 1][j].y - 5, coords[i + 1][j].z);
  192. }
  193. }
  194. }
  195.  
  196. glEnd();
  197. }
  198.  
  199.  
  200.  
  201. void RenderScene(void)
  202. {
  203. glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  204. // Czyszczenie okna aktualnym kolorem czyszczącym
  205.  
  206. glLoadIdentity();
  207. // Czyszczenie macierzy bie??cej
  208.  
  209. // dla lewego przycisku myszki
  210. viewer[0] = promien * cos(azymut) * cos(elewacja);
  211. viewer[1] = promien * sin(elewacja);
  212. viewer[2] = promien * sin(azymut) * cos(elewacja);
  213.  
  214. if (elewacja > 3 * M_PI / 2) {
  215. gluLookAt(viewer[0], viewer[1], viewer[2], 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
  216.  
  217. }
  218. else if (elewacja > M_PI / 2) {
  219. gluLookAt(viewer[0], viewer[1], viewer[2], 0.0, 0.0, 0.0, 0.0, -1.0, 0.0);
  220. }
  221.  
  222. else {
  223. gluLookAt(viewer[0], viewer[1], viewer[2], 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
  224.  
  225. }
  226.  
  227. if (status == 1) // jeśli lewy klawisz myszy wcięnięty
  228. {
  229. theta[0] += delta_x * pix2angle; // modyfikacja kąta obrotu o kat proporcjonalny do różnicy położeń kursora myszy
  230. theta[1] += delta_y * pix2angle; // modyfikacja kąta obrotu o kat proporcjonalny do różnicy położeń kursora myszy
  231.  
  232. azymut += delta_x * 0.1;
  233. elewacja += delta_y * 0.1;
  234.  
  235. if (elewacja > 2 * M_PI) {
  236. elewacja -= 2 * M_PI;
  237. }
  238. else if (elewacja < 0) {
  239. elewacja += 2 * M_PI;
  240. }
  241. else elewacja += delta_y * pix2angle * 0.01;
  242. }
  243. // prawy przycisk myszy
  244. else if (status == 2) {
  245. theta2[0] += delta_x2 * pix2angle; // modyfikacja kąta obrotu o kat proporcjonalny do różnicy położeń kursora myszy
  246. theta2[1] += delta_y2 * pix2angle; // modyfikacja kąta obrotu o kat proporcjonalny do różnicy położeń kursora myszy
  247.  
  248. azymut2 += delta_x2 * 0.1;
  249. elewacja2 += delta_y2 * 0.1;
  250.  
  251. if (elewacja2 > 2 * M_PI) {
  252. elewacja2 -= 2 * M_PI;
  253. }
  254. else if (elewacja2 < 0) {
  255. elewacja2 += 2 * M_PI;
  256. }
  257. else elewacja2 += delta_y2 * pix2angle * 0.01;
  258.  
  259. GLfloat x = promien2 * cos(azymut2) * cos(elewacja2);
  260. GLfloat y = promien2 * sin(elewacja2);
  261. GLfloat z = promien2 * sin(azymut2) * cos(elewacja2);
  262.  
  263. // niech zmienia sie pozycja tego oswietlenia
  264. GLfloat light_position2[] = { x, y, z, 1.0 };
  265. glLightfv(GL_LIGHT1, GL_POSITION, light_position2);
  266. }
  267.  
  268. // Zdefiniowanie położenia obserwatora
  269. Axes();
  270. // Narysowanie osi przy pomocy funkcji zdefiniowanej powyżej
  271.  
  272. Egg();
  273.  
  274. //glutSolidTeapot(3);
  275. // Narysowanie czajnika
  276. glFlush();
  277. // Przekazanie poleceń rysujących do wykonania
  278. glutSwapBuffers();
  279. }
  280. /*************************************************************************************/
  281.  
  282. // Funkcja ustalająca stan renderowania
  283. void MyInit(void){
  284. glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
  285. // Kolor czyszczący (wypełnienia okna) ustawiono na czarny
  286.  
  287. /*************************************************************************************/
  288.  
  289. // Definicja materiału z jakiego zrobiony jest czajnik
  290. // i definicja źródła światła
  291.  
  292. /*************************************************************************************/
  293.  
  294.  
  295. /*************************************************************************************/
  296. // Definicja materiału z jakiego zrobiony jest czajnik
  297.  
  298. GLfloat mat_ambient[] = { 1.0, 1.0, 1.0, 1.0 };
  299. // współczynniki ka =[kar,kag,kab] dla światła otoczenia
  300.  
  301. GLfloat mat_diffuse[] = { 1.0, 1.0, 1.0, 1.0 };
  302. // współczynniki kd =[kdr,kdg,kdb] światła rozproszonego
  303.  
  304. GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 };
  305. // współczynniki ks =[ksr,ksg,ksb] dla światła odbitego
  306.  
  307. GLfloat mat_shininess = { 150.0 };
  308. // współczynnik n opisujący połysk powierzchni
  309.  
  310.  
  311. /*************************************************************************************/
  312. // Definicja źródła światła
  313.  
  314.  
  315. GLfloat light_position[] = { 20.0, 0.0, 0.0, 1.0 };
  316. GLfloat light_position2[] = { -20.0, 0.0, 0.0, 1.0 };
  317. // położenie źródła
  318.  
  319.  
  320. GLfloat light_ambient[] = { 0.0, 0.1, 0.0, 1.0 };
  321. GLfloat light_ambient2[] = { 0.1, 0.0, 0.0, 1.0 };
  322. // składowe intensywności świecenia źródła światła otoczenia
  323. // Ia = [Iar,Iag,Iab]
  324.  
  325. GLfloat light_diffuse[] = { 0.0, 1.0, 0.0, 1.0 };
  326. GLfloat light_diffuse2[] = { 1.0, 0.0, 0.0, 1.0 };
  327. // składowe intensywności świecenia źródła światła powodującego
  328. // odbicie dyfuzyjne Id = [Idr,Idg,Idb]
  329.  
  330. GLfloat light_specular[] = { 0.0, 1.0, 0.0, 1.0 };
  331. GLfloat light_specular2[] = { 1.0, 0.0, 0.0, 1.0 };
  332. // składowe intensywności świecenia źródła światła powodującego
  333. // odbicie kierunkowe Is = [Isr,Isg,Isb]
  334.  
  335. GLfloat att_constant = { 1.0 };
  336. GLfloat att_constant2 = { 1.0 };
  337. // składowa stała ds dla modelu zmian oświetlenia w funkcji
  338. // odległości od źródła
  339.  
  340. GLfloat att_linear = { 0.05 };
  341. GLfloat att_linear2 = { 0.05 };
  342. // składowa liniowa dl dla modelu zmian oświetlenia w funkcji
  343. // odległości od źródła
  344.  
  345. GLfloat att_quadratic = { 0.001 };
  346. GLfloat att_quadratic2 = { 0.001 };
  347. // składowa kwadratowa dq dla modelu zmian oświetlenia w funkcji
  348. // odległości od źródła
  349.  
  350. /*************************************************************************************/
  351. // Ustawienie parametrów materiału i źródła światła
  352.  
  353. /*************************************************************************************/
  354. // Ustawienie patrametrów materiału
  355.  
  356.  
  357. glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
  358. glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient);
  359. glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
  360. glMaterialf(GL_FRONT, GL_SHININESS, mat_shininess);
  361.  
  362. /*************************************************************************************/
  363. // Ustawienie parametrów źródła
  364.  
  365. glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient);
  366. glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);
  367. glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular);
  368. glLightfv(GL_LIGHT0, GL_POSITION, light_position);
  369.  
  370. glLightf(GL_LIGHT0, GL_CONSTANT_ATTENUATION, att_constant);
  371. glLightf(GL_LIGHT0, GL_LINEAR_ATTENUATION, att_linear);
  372. glLightf(GL_LIGHT0, GL_QUADRATIC_ATTENUATION, att_quadratic);
  373.  
  374. glLightfv(GL_LIGHT1, GL_AMBIENT, light_ambient2);
  375. glLightfv(GL_LIGHT1, GL_DIFFUSE, light_diffuse2);
  376. glLightfv(GL_LIGHT1, GL_SPECULAR, light_specular2);
  377. glLightfv(GL_LIGHT1, GL_POSITION, light_position2);
  378.  
  379. glLightf(GL_LIGHT1, GL_CONSTANT_ATTENUATION, att_constant2);
  380. glLightf(GL_LIGHT1, GL_LINEAR_ATTENUATION, att_linear2);
  381. glLightf(GL_LIGHT1, GL_QUADRATIC_ATTENUATION, att_quadratic2);
  382.  
  383. /*************************************************************************************/
  384. // Ustawienie opcji systemu oświetlania sceny
  385.  
  386. glShadeModel(GL_SMOOTH); // właczenie łagodnego cieniowania
  387. glEnable(GL_LIGHTING); // właczenie systemu oświetlenia sceny
  388. glEnable(GL_LIGHT0); // włączenie źródła o numerze 0
  389. glEnable(GL_LIGHT1); // włączenie źródła o numerze 1
  390. glEnable(GL_DEPTH_TEST); // włączenie mechanizmu z-bufora
  391.  
  392. /*************************************************************************************/
  393. }
  394.  
  395. /*************************************************************************************/
  396.  
  397.  
  398. // Funkcja ma za zadanie utrzymanie stałych proporcji rysowanych
  399. // w przypadku zmiany rozmiarów okna.
  400. // Parametry vertical i horizontal (wysokość i szerokość okna) są
  401. // przekazywane do funkcji za każdym razem gdy zmieni się rozmiar okna.
  402.  
  403.  
  404.  
  405. void ChangeSize(GLsizei horizontal, GLsizei vertical)
  406. {
  407. pix2angle = 360.0 / (float)horizontal; // przeliczenie pikseli na stopnie
  408.  
  409. glMatrixMode(GL_PROJECTION);
  410. // Przełączenie macierzy bieżącej na macierz projekcji
  411.  
  412. glLoadIdentity();
  413. // Czyszcznie macierzy bieżącej
  414.  
  415. gluPerspective(70, 1.0, 1.0, 30.0);
  416. // Ustawienie parametrów dla rzutu perspektywicznego
  417.  
  418.  
  419. if (horizontal <= vertical)
  420. glViewport(0, (vertical - horizontal) / 2, horizontal, horizontal);
  421.  
  422. else
  423. glViewport((horizontal - vertical) / 2, 0, vertical, vertical);
  424. // Ustawienie wielkości okna okna widoku (viewport) w zależności
  425. // relacji pomiędzy wysokością i szerokością okna
  426.  
  427. glMatrixMode(GL_MODELVIEW);
  428. // Przełączenie macierzy bieżącej na macierz widoku modelu
  429.  
  430. glLoadIdentity();
  431. // Czyszczenie macierzy bieżącej
  432.  
  433. }
  434.  
  435. /*************************************************************************************/
  436.  
  437. void RandColor() {
  438.  
  439. for (int i = 0; i < 10; i++) {
  440. for (int j = 0; j < 3; j++)
  441. color[i][j] = (float)(rand() % 11) / 10;
  442. }
  443. }
  444.  
  445. /*************************************************************************************/
  446. // Funkcja "bada" stan myszy i ustawia wartości odpowiednich zmiennych globalnych
  447.  
  448. void Mouse(int btn, int state, int x, int y)
  449. {
  450.  
  451.  
  452. if (btn == GLUT_LEFT_BUTTON && state == GLUT_DOWN)
  453. {
  454. x_pos_old = x; // przypisanie aktualnie odczytanej pozycji kursora jako pozycji poprzedniej
  455. y_pos_old = y; // przypisanie aktualnie odczytanej pozycji kursora jako pozycji poprzedniej
  456. status = 1; // wcięnięty został lewy klawisz myszy
  457. }
  458. else if (btn == GLUT_RIGHT_BUTTON && state == GLUT_DOWN)
  459. {
  460. y_pos_old2 = y; // przypisanie aktualnie odczytanej pozycji kursora jako pozycji poprzedniej
  461. x_pos_old2 = x; // przypisanie aktualnie odczytanej pozycji kursora jako pozycji poprzedniej
  462. status = 2; // wciśniety został prawy klawisz myszy
  463. }
  464. else
  465. status = 0; // nie został wcięnięty żaden klawisz
  466. }
  467.  
  468. /*************************************************************************************/
  469. // Funkcja "monitoruje" położenie kursora myszy i ustawia wartości odpowiednich
  470. // zmiennych globalnych
  471.  
  472. void Motion(GLsizei x, GLsizei y)
  473. {
  474.  
  475. delta_x = x - x_pos_old; // obliczenie różnicy położenia kursora myszy
  476. delta_y = y - y_pos_old; // obliczenie różnicy położenia kursora myszy
  477.  
  478. x_pos_old = x; // podstawienie bieżącego położenia jako poprzednie
  479. y_pos_old = y; // podstawienie bieżącego położenia jako poprzednie
  480.  
  481. delta_x2 = x - x_pos_old2; // obliczenie różnicy położenia kursora myszy
  482. delta_y2 = y - y_pos_old2; // obliczenie różnicy położenia kursora myszy
  483.  
  484. x_pos_old2 = x; // podstawienie bieżącego położenia jako poprzednie
  485. y_pos_old2 = y; // podstawienie bieżącego położenia jako poprzednie
  486.  
  487. glutPostRedisplay(); // przerysowanie obrazu sceny
  488. }
  489.  
  490.  
  491. // Główny punkt wejścia programu. Program działa w trybie konsoli
  492. /*************************************************************************************/
  493.  
  494. // Główny punkt wejścia programu. Program działa w trybie konsoli
  495. int main(void)
  496. {
  497.  
  498. RandColor();
  499.  
  500. glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
  501.  
  502. glutInitWindowSize(300, 300);
  503.  
  504. glutCreateWindow("OpenGL - oświetlanie scen 3-D");
  505.  
  506. glutDisplayFunc(RenderScene);
  507. // Określenie, że funkcja RenderScene będzie funkcją zwrotną
  508. // (callback function). Będzie ona wywoływana za każdym razem
  509. // gdy zajdzie potrzeba przerysowania okna
  510.  
  511.  
  512. glutReshapeFunc(ChangeSize);
  513. // Dla aktualnego okna ustala funkcję zwrotną odpowiedzialną
  514. // za zmiany rozmiaru okna
  515.  
  516.  
  517. MyInit();
  518. // Funkcja MyInit() (zdefiniowana powyżej) wykonuje wszelkie
  519. // inicjalizacje konieczne przed przystąpieniem do renderowania
  520. glEnable(GL_DEPTH_TEST);
  521. // Włączenie mechanizmu usuwania niewidocznych elementów sceny
  522.  
  523. glutMouseFunc(Mouse);
  524. // Ustala funkcję zwrotną odpowiedzialną za badanie stanu myszy
  525.  
  526. glutMotionFunc(Motion);
  527. // Ustala funkcję zwrotną odpowiedzialną za badanie ruchu myszy
  528.  
  529. glutMainLoop();
  530. // Funkcja uruchamia szkielet biblioteki GLUT
  531.  
  532. return 0;
  533. }
  534.  
  535. /*************************************************************************************/
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!