API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Oct 17th, 2018
90
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 18.19 KB | None | 0 0
raw download clone embed print report
  1. //////////////////////////////////////////////////////////////////////////////////////////
  2. // Program demonstrujacy odwzorowanie dwuwymiarowej tekstury kraty na sfere.
  3. // Autor: Wojciech Satala
  4. //
  5. //////////////////////////////////////////////////////////////////////////////////////////
  6.  
  7. #include <math.h>
  8. #include <GL/glut.h>
  9. #include <string.h>
  10. #include <stdio.h>
  11.  
  12. // Definicja stalych
  13.  
  14. // Parametry kuli
  15. #define KULA_R 4
  16. #define KULA_LPODZ_H 30
  17. #define KULA_LPODZ_V 30
  18.  
  19. // Parametry tekstury kratownicy
  20. #define TEX_SZEROKOSC 256 // szerokosc tekstury (musi byc potega 2)
  21. #define TEX_WYSOKOSC 256 // dlugosc tekstury (musi byc potega 2)
  22. #define TEX_LKOLUMN 7 // liczba kolumn kratownicy
  23. #define TEX_LWIERSZY 7 // liczba wierszy kratownicy
  24.  
  25. #ifndef M_PI
  26. #define M_PI 3.1415926535
  27. #endif
  28.  
  29.  
  30. // Makro przeliczajace stopnie na radiany
  31. #define DEG2RAD(x) ((float)(x)*M_PI/180.0)
  32.  
  33. // Zmienne globalne
  34.  
  35. // Tablica zawierajaca teksture kraty zapisana w trybie RGBA
  36. GLubyte tekstura[TEX_WYSOKOSC][TEX_SZEROKOSC][4];
  37.  
  38. // Tablica parametrow swiatla
  39. GLfloat swiatlo[10][4] = {
  40. {0.1, 0.1, 0.1, 1.0}, // [0] otoczenie
  41. {0.5, 0.5, 0.5, 1.0}, // [1] rozproszenie
  42. {1.0, 1.0, 1.0, 1.0}, // [2] lustrzane
  43. {0.0, 0.0, 20.0, 1.0}, // [3] polozenie
  44. {0.0, 0.0, -1.0, 0.0}, // [4] kierunek swiecenia
  45. {1.0, 0.0, 0.0, 0.0}, // [5] tlumienie katowe swiatla
  46. {45.0, 0.0, 0.0, 0.0},// [6] kat odciecia swiatla
  47. {1.0, 0.0, 0.0, 0.0}, // [7] stale tlumienie
  48. {0.0, 0.0, 0.0, 0.0}, // [8] tlumienie liniowe
  49. {0.0, 0.0, 0.0, 0.0}}; // [9] tlumienie kwadratowe
  50.  
  51.  
  52. GLfloat swiatlo1[10][4] = {
  53. {0.1, 0.1, 0.1, 1.0}, // [0] otoczenie
  54. {0.0, 0.0, 0.5, 1.0}, // [1] rozproszenie
  55. {1.0, 1.0, 1.0, 1.0}, // [2] lustrzane
  56. {0.0, 5.0, 5.0, 0.0}, // [3] polozenie
  57. {0.0, -5.0, -5.0, 0.0}, // [4] kierunek swiecenia
  58. {1.0, 0.0, 0.0, 0.0}, // [5] tlumienie katowe swiatla
  59. {180.0, 0.0, 0.0, 0.0},// [6] kat odciecia swiatla
  60. {1.0, 0.0, 0.0, 0.0}, // [7] stale tlumienie
  61. {0.0, 0.0, 0.0, 0.0}, // [8] tlumienie liniowe
  62. {0.0, 0.0, 0.0, 0.0}}; // [9] tlumienie kwadratowe
  63.  
  64.  
  65. GLfloat swiatlo2[10][4] = {
  66. {0.1, 0.1, 0.1, 1.0}, // [0] otoczenie
  67. {1.0, 0.0, 0.0, 1.0}, // [1] rozproszenie
  68. {1.0, 0.0, 0.0, 1.0}, // [2] lustrzane
  69. {0.0, 5.0, 5.0, 0.0}, // [3] polozenie
  70. {0.0, -5.0, -5.0, 0.0}, // [4] kierunek swiecenia
  71. {1.0, 0.0, 0.0, 0.0}, // [5] tlumienie katowe swiatla
  72. {180.0, 0.0, 0.0, 0.0},// [6] kat odciecia swiatla
  73. {1.0, 0.0, 0.0, 0.0}, // [7] stale tlumienie
  74. {0.0, 0.0, 0.0, 0.0}, // [8] tlumienie liniowe
  75. {0.0, 0.0, 0.0, 0.0}}; // [9] tlumienie kwadratowe
  76.  
  77.  
  78. // Tablica parametrow materialu
  79. GLfloat material[6][4] = {
  80. {0.2, 0.2, 0.2, 1.0}, // [0] wspolczynnik odbicia swiatla otoczenia
  81. {0.8, 0.8, 0.8, 1.0}, // [1] wspolczynnik odbicia swiatla rozproszonego
  82. {1.0, 1.0, 1.0, 1.0}, // [2] wspolczynnik odbicia swiatla lustrzanego
  83. {20.0, 0.0, 0.0, 0.0}, // [3] polysk
  84. {0.0, 0.0, 0.0, 1.0}}; // [4] kolor swiatla emitowanego
  85.  
  86.  
  87. // Pozostale zmienne
  88. int szerokoscOkna = 800;
  89. int wysokoscOkna = 600;
  90. float kat = 0.0;
  91. int texTryb = 0;
  92. int texLKolumn = TEX_LKOLUMN;
  93. int texLWierszy = TEX_LWIERSZY;
  94.  
  95. // Naglowki funkcji
  96. void WlaczOswietlenie(void);
  97. void DefiniujMaterial(void);
  98. void UtworzWzorzecTekstury(GLubyte c1R, GLubyte c1G, GLubyte c1B, GLubyte c1A,
  99. GLubyte c2R, GLubyte c2G, GLubyte c2B, GLubyte c2A);
  100. void UtworzTeksture(GLint modMiesz, GLfloat trybTeksturowania);
  101. void RysujSfere(double R);
  102. void UstawParametryWidoku(int szer, int wys);
  103. void WyswietlObraz(void);
  104. void ObslugaKlawiatury(unsigned char klawisz, int x, int y);
  105. void RysujNakladke(void);
  106.  
  107. //////////////////////////////////////////////////////////////////////////////////////////
  108. // Funkcja wypelniajaca tablice tekstury kraty, ktorej kolory podane zostaly jako
  109. // argumenty wejsciowe.
  110. void UtworzWzorzecTekstury(GLubyte c1R, GLubyte c1G, GLubyte c1B, GLubyte c1A,
  111. GLubyte c2R, GLubyte c2G, GLubyte c2B, GLubyte c2A)
  112. {
  113. int wysokoscPola = (int)ceil((double)TEX_WYSOKOSC/(double)texLWierszy);
  114. int szerokoscPola= (int)ceil((double)TEX_SZEROKOSC/(double)texLKolumn);
  115. int t, s, x, y;
  116.  
  117. for (t = 0; t < TEX_WYSOKOSC; t+=wysokoscPola)
  118. {
  119. for (s = 0; s < TEX_SZEROKOSC; s+=szerokoscPola)
  120. {
  121.  
  122. for (y = 0; y < wysokoscPola; y++)
  123. for (x = 0; x < szerokoscPola; x++)
  124. if (((s % 2) && (t % 2))
  125. || (!(s % 2) && !(t % 2)))
  126. {
  127. tekstura[t+y][s+x][0] = c1R;
  128. tekstura[t+y][s+x][1] = c1G;
  129. tekstura[t+y][s+x][2] = c1B;
  130. tekstura[t+y][s+x][3] = c1A;
  131. }
  132. else
  133. {
  134. tekstura[t+y][s+x][0] = c2R;
  135. tekstura[t+y][s+x][1] = c2G;
  136. tekstura[t+y][s+x][2] = c2B;
  137. tekstura[t+y][s+x][3] = c2A;
  138. }
  139. }
  140. }
  141. }
  142.  
  143. //////////////////////////////////////////////////////////////////////////////////////////
  144. // Funkcja tworzaca teksture na podstawie wzorca umieszczonego w tablicy 'tekstura'.
  145. // Argument <modMiesz> oznacza, ktore skladowe koloru wykorzystywane sa w procesie
  146. // modulacji/mieszania kolorow. Argument <trybTeksturowania> okresla w jaki sposob
  147. // wyznaczany jest kolor wynikowy obiektu. Dozwolone wartosci: GL_DECAL, GL_MODULATE,
  148. // GL_BLEND.
  149. void UtworzTeksture(GLint modMiesz, GLfloat trybTeksturowania)
  150. {
  151. // Okreslenie wyrownania bytow w czasie odczytywania tekstury z pamieci
  152. // glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
  153.  
  154. // Zdefiniowanie dwuwymiarowej tekstury
  155. glTexImage2D(GL_TEXTURE_2D, 0, modMiesz, TEX_SZEROKOSC, TEX_WYSOKOSC,
  156. 0, GL_RGBA, GL_UNSIGNED_BYTE, (GLubyte *) &tekstura[0][0][0]);
  157.  
  158. // Okreslenie podstawowych parametrow tekstury
  159. // - tekstura nie bedzie powtarzana w obu kierunkach
  160. glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
  161. glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
  162.  
  163. // - przy powiekszaniu i pomniejszaniu tekstury zastosowane zostanie filtrowanie liniowe
  164. glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
  165. glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
  166.  
  167. // Okreslenie trybu teksturowania zgodnie z wartoscia argumentu <trybTeksturowania>
  168. glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, trybTeksturowania);
  169.  
  170. // Odblokowanieteksturowania
  171. glEnable(GL_TEXTURE_2D);
  172. }
  173.  
  174.  
  175. //////////////////////////////////////////////////////////////////////////////////////////
  176. // Funkcja rysujaca tekst rastrowy <tekst> za pomca fontow bitmapowych <font>.Rysowanie
  177. // tekstu wykonywane jest poczawszy od biezacej pozycji ekranu.
  178. void RysujTekstRastrowy(void *font, char *tekst)
  179. {
  180. int i;
  181.  
  182. for (i = 0; i < (int)strlen(tekst); i++)
  183. glutBitmapCharacter(font, tekst[i]);
  184. }
  185.  
  186.  
  187. //////////////////////////////////////////////////////////////////////////////////////////
  188. // Wlaczenie oswietlenia sceny
  189. void WlaczOswietlenie(void)
  190. {
  191. // Odblokowanie oswietlenia
  192. glEnable(GL_LIGHTING);
  193.  
  194. // Odblokowanie zerowego zrodla swiatla
  195. glEnable(GL_LIGHT0);
  196. // Odblokowanie zerowego zrodla swiatla
  197. glEnable(GL_LIGHT1);
  198. // Odblokowanie zerowego zrodla swiatla
  199. glEnable(GL_LIGHT2);
  200.  
  201. // Inicjowanie zrodla swiatla
  202. glLightfv(GL_LIGHT0, GL_AMBIENT, swiatlo[0]);
  203. glLightfv(GL_LIGHT0, GL_DIFFUSE, swiatlo[1]);
  204. glLightfv(GL_LIGHT0, GL_SPECULAR, swiatlo[2]);
  205. glLightfv(GL_LIGHT0, GL_SPOT_DIRECTION, swiatlo[4]);
  206. glLightf(GL_LIGHT0, GL_SPOT_EXPONENT, swiatlo[5][0]);
  207. glLightf(GL_LIGHT0, GL_SPOT_CUTOFF, swiatlo[6][0]);
  208. glLightf(GL_LIGHT0, GL_CONSTANT_ATTENUATION, swiatlo[7][0]);
  209. glLightf(GL_LIGHT0, GL_LINEAR_ATTENUATION, swiatlo[8][0]);
  210. glLightf(GL_LIGHT0, GL_QUADRATIC_ATTENUATION, swiatlo[9][0]);
  211.  
  212. // Inicjowanie zrodla swiatla
  213. glLightfv(GL_LIGHT1, GL_AMBIENT, swiatlo1[0]);
  214. glLightfv(GL_LIGHT1, GL_DIFFUSE, swiatlo1[1]);
  215. glLightfv(GL_LIGHT1, GL_SPECULAR, swiatlo1[2]);
  216. glLightfv(GL_LIGHT1, GL_SPOT_DIRECTION, swiatlo1[4]);
  217. glLightf(GL_LIGHT1, GL_SPOT_EXPONENT, swiatlo1[5][0]);
  218. glLightf(GL_LIGHT1, GL_SPOT_CUTOFF, swiatlo1[6][0]);
  219. glLightf(GL_LIGHT1, GL_CONSTANT_ATTENUATION, swiatlo1[7][0]);
  220. glLightf(GL_LIGHT1, GL_LINEAR_ATTENUATION, swiatlo1[8][0]);
  221. glLightf(GL_LIGHT1, GL_QUADRATIC_ATTENUATION, swiatlo1[9][0]);
  222.  
  223.  
  224. // Inicjowanie zrodla swiatla
  225. glLightfv(GL_LIGHT2, GL_AMBIENT, swiatlo2[0]);
  226. glLightfv(GL_LIGHT2, GL_DIFFUSE, swiatlo2[1]);
  227. glLightfv(GL_LIGHT2, GL_SPECULAR, swiatlo2[2]);
  228. glLightfv(GL_LIGHT2, GL_SPOT_DIRECTION, swiatlo2[4]);
  229. glLightf(GL_LIGHT2, GL_SPOT_EXPONENT, swiatlo2[5][0]);
  230. glLightf(GL_LIGHT2, GL_SPOT_CUTOFF, swiatlo2[6][0]);
  231. glLightf(GL_LIGHT2, GL_CONSTANT_ATTENUATION, swiatlo2[7][0]);
  232. glLightf(GL_LIGHT2, GL_LINEAR_ATTENUATION, swiatlo2[8][0]);
  233. glLightf(GL_LIGHT2, GL_QUADRATIC_ATTENUATION, swiatlo2[9][0]);
  234.  
  235.  
  236. }
  237.  
  238. //////////////////////////////////////////////////////////////////////////////////////////
  239. // Zdefiniowanie walasciwosci materialu walca na podstawie zapisanych w tablcy 'material'
  240. // parametrow (material obowiazuje tylko do scian skierowanych przodem do obserwatora)
  241. void DefiniujMaterial(void)
  242. {
  243. glMaterialfv(GL_FRONT, GL_AMBIENT, material[0]);
  244. glMaterialfv(GL_FRONT, GL_DIFFUSE, material[1]);
  245. glMaterialfv(GL_FRONT, GL_SPECULAR, material[2]);
  246. glMaterialfv(GL_FRONT, GL_SHININESS, material[3]);
  247. glMaterialfv(GL_FRONT, GL_EMISSION, material[4]);
  248. }
  249.  
  250.  
  251. //////////////////////////////////////////////////////////////////////////////////////////
  252. // Funkcja rysujaca sfere o srodku w punkcie (0, 0, 0) i promieniu <R>. Powierzchnia
  253. // sfery modelowana jest w trybie GL_TRIANGLE_STRIP z rownoczesnym wyznaczaniem
  254. // wektorow normalnych i generowaniem wspolrzednych tekstury (odwzorowanie na sfere).
  255. void RysujSfere(double R)
  256. {
  257. double dPsi, dAlfa;
  258. double psi, alfa = 0.0;
  259. static double talfa = 0.0;
  260.  
  261. // Wyznaczenie kata wyznaczajacego pojedynczy wycinek poziomy
  262. dAlfa = 360.0/(double)KULA_LPODZ_H;
  263.  
  264. // Wyznaczenie kata wyznaczajacego pojedynczy wycinek pionowy
  265. dPsi = 180.0/(double)KULA_LPODZ_V;
  266.  
  267. talfa += 1.0;
  268.  
  269. glMatrixMode(GL_TEXTURE);
  270. glPushMatrix();
  271. glRotatef(talfa, 0,0,1);
  272. glTranslatef(-0.5, -0.5, 0.0);
  273. glMatrixMode(GL_MODELVIEW);
  274.  
  275. /*
  276. for (psi = -90 + dPsi; (psi) <= 90.0; psi += dPsi)
  277. {
  278. glBegin(GL_TRIANGLE_STRIP);
  279.  
  280.  
  281. for (alfa = 0; (alfa) <= 360.0; alfa += dAlfa)
  282. {
  283. glTexCoord2f(alfa/360.0, (psi + 90.0)/180.0);
  284. glNormal3f(cos(DEG2RAD(alfa))*cos(DEG2RAD(psi)),
  285. sin(DEG2RAD(psi)),
  286. -sin(DEG2RAD(alfa))*cos(DEG2RAD(psi)));
  287. glVertex3f(R*cos(DEG2RAD(alfa))*cos(DEG2RAD(psi)),
  288. R*sin(DEG2RAD(psi)),
  289. -R*sin(DEG2RAD(alfa))*cos(DEG2RAD(psi)));
  290.  
  291. glTexCoord2f(alfa/360.0, (psi - dPsi + 90.0)/180.0);
  292. glNormal3f(cos(DEG2RAD(alfa))*cos(DEG2RAD(psi - dPsi)),
  293. sin(DEG2RAD(psi - dPsi)),
  294. -sin(DEG2RAD(alfa))*cos(DEG2RAD(psi - dPsi)));
  295. glVertex3f(R*cos(DEG2RAD(alfa))*cos(DEG2RAD(psi - dPsi)),
  296. R*sin(DEG2RAD(psi - dPsi)),
  297. -R*sin(DEG2RAD(alfa))*cos(DEG2RAD(psi -dPsi)));
  298. }
  299. glEnd();
  300. }
  301. */
  302. glBegin(GL_QUADS);
  303. glNormal3f(0,0,1);
  304. glTexCoord2f(0,0);
  305. glVertex3f(0,0,0);
  306.  
  307. glTexCoord2f(1,0);
  308. glVertex3f(5,0,0);
  309.  
  310. glTexCoord2f(1,1);
  311. glVertex3f(5,5,0);
  312.  
  313. glTexCoord2f(0,1);
  314. glVertex3f(0,5,0);
  315. glEnd();
  316.  
  317.  
  318. glMatrixMode(GL_TEXTURE);
  319. glPushMatrix();
  320. glPopMatrix();
  321. glMatrixMode(GL_MODELVIEW);
  322.  
  323. }
  324.  
  325. //////////////////////////////////////////////////////////////////////////////////////////
  326. // Funkcja ustawiajaca parametry rzutu perspektywicznego i rozmiary viewportu
  327. void UstawParametryWidoku(int szer, int wys)
  328. {
  329. // Zapamietanie wielkosci widoku
  330. szerokoscOkna = szer;
  331. wysokoscOkna = wys;
  332.  
  333. // Ustawienie parametrow viewportu
  334. glViewport(0, 0, szerokoscOkna, wysokoscOkna);
  335.  
  336. // Przejscie w tryb modyfikacji macierzy rzutowania
  337. glMatrixMode(GL_PROJECTION);
  338. glLoadIdentity();
  339. gluPerspective(40.0, (float)szerokoscOkna/(float)wysokoscOkna, 1.0, 1000.0);
  340.  
  341. // Przejscie w tryb modyfikacji macierzy przeksztalcen geometrycznych
  342. glMatrixMode(GL_MODELVIEW);
  343.  
  344. // Zmiana macierzy znajdujacej sie na wierzcholku stosu na macierz jednostkowa
  345. glLoadIdentity();
  346. }
  347.  
  348.  
  349. //////////////////////////////////////////////////////////////////////////////////////////
  350. // Funkcja generujaca pojedyncza klatke animacji
  351. void WyswietlObraz(void)
  352. {
  353. glPushMatrix();
  354.  
  355. // Wyczyszczenie bufora ramki i bufora glebokosci
  356. glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
  357.  
  358. // Okreslenie wielkosci widoku, wlaczenie rzutowania perspektywicznego
  359. // i zainicjowanie stosu macierzy modelowania
  360. UstawParametryWidoku(szerokoscOkna, wysokoscOkna);
  361.  
  362. // Zrodlo swiatla polozone statycznie w uladzie obserwatora
  363. glLightfv(GL_LIGHT1, GL_POSITION, swiatlo1[3]);
  364.  
  365. // Wyznaczenie polozenia obserwatora (przeksztalcenie uladu wspolrzednych
  366. // sceny do ukladu wspolrzednych obserwatora). Obserwator obraca sie wokol punktu 0.0
  367. // na osi OY. Promien obrotu = 20, pochylenie = 20 stopni,
  368. // predkosc obrotu = 0.25 stopnia/ramke.
  369. glTranslatef(0, 0, -20);
  370. glRotatef(kat, 0, 1, 0);
  371.  
  372. // Zdefiniowanie materialu walca
  373. DefiniujMaterial();
  374.  
  375. // Utworzenie wzorca tekstury (czarno-biala krata)
  376. UtworzWzorzecTekstury(0, 255, 255, 255, 255, 0, 255, 255);
  377.  
  378. // Utworzenie tekstury na podstawie zdefiniowanego wzorca (wlaczona modulacja
  379. // pierwotnego koloru sfery wszystkimi skladowymi koloru tekstury)
  380. UtworzTeksture(4, texTryb);
  381.  
  382. // Zrodlo swiatla polozone statycznie w ukladzie sceny
  383. glLightfv(GL_LIGHT2, GL_POSITION, swiatlo2[3]);
  384.  
  385. // zrodlo swiatla okrazajace kule
  386. glPushMatrix();
  387. glRotatef(3*kat, 1,0,0);
  388. glLightfv(GL_LIGHT0, GL_POSITION, swiatlo[3]);
  389. glPopMatrix();
  390.  
  391. // Generacja obrazu sfery
  392. RysujSfere(KULA_R);
  393.  
  394. // Narysowanie nakladki
  395. RysujNakladke();
  396.  
  397. // Przelaczenie buforow ramki
  398. glutSwapBuffers();
  399.  
  400. // Modyfikacja kata obrotu
  401. kat += 0.5;
  402. glPopMatrix();
  403. }
  404.  
  405. //////////////////////////////////////////////////////////////////////////////////////////
  406. // Funkcja rysujaca na wygenerowanym obrazie sfery nkladke z tekstem
  407. void RysujNakladke(void)
  408. {
  409. GLboolean stanOswietlenia = GL_FALSE;
  410.  
  411. // Zapamietanie stanu oswietlenia
  412. if (glIsEnabled(GL_LIGHTING))
  413. {
  414. stanOswietlenia = GL_TRUE;
  415. glDisable(GL_LIGHTING);
  416. }
  417.  
  418. // Zmiana typu rzutu z perspektywicznego na ortogonalny
  419. glMatrixMode(GL_PROJECTION);
  420. glPushMatrix();
  421. glLoadIdentity();
  422. glOrtho(0.0, szerokoscOkna, 0.0, wysokoscOkna,-100.0, 100.0);
  423.  
  424. // Modelowanie sceny 2D (zawartosci nakladki)
  425. glMatrixMode(GL_MODELVIEW);
  426. glPushMatrix();
  427. glLoadIdentity();
  428.  
  429. // Zablokowanie oswietlenia (mialoby ono wplyw na kolor tekstu)
  430. glDisable(GL_LIGHTING);
  431.  
  432.  
  433. // Tu jest zawartosc nakladki
  434.  
  435.  
  436. // Przywrocenie macierzy sprzed wywolania funkcji
  437. glMatrixMode(GL_PROJECTION);
  438. glPopMatrix();
  439. glMatrixMode(GL_MODELVIEW);
  440. glPopMatrix();
  441.  
  442. // Odblokowanie oswietlenia
  443. if(stanOswietlenia)
  444. glEnable(GL_LIGHTING);
  445. }
  446.  
  447. //////////////////////////////////////////////////////////////////////////////////////////
  448. // Funkcja obslugi klawiatury
  449. void ObslugaKlawiatury(unsigned char klawisz, int x, int y)
  450. {
  451. switch(klawisz)
  452. {
  453. case 'd':
  454. texTryb = GL_DECAL;
  455. break;
  456.  
  457. case 'm':
  458. texTryb = GL_MODULATE;
  459. break;
  460.  
  461. case 'b':
  462. texTryb = GL_BLEND;
  463. break;
  464.  
  465. case 'l':
  466. if (glIsEnabled(GL_LIGHTING))
  467. glDisable(GL_LIGHTING);
  468. else
  469. glEnable(GL_LIGHTING);
  470. break;
  471.  
  472. case 'w':
  473. texLWierszy++;
  474. break;
  475.  
  476. case 'W':
  477. texLWierszy = (texLWierszy == 0) ? 0 : texLWierszy - 1;
  478. break;
  479.  
  480. case 'k':
  481. texLKolumn++;
  482. break;
  483.  
  484. case 'K':
  485. texLKolumn = (texLKolumn == 0) ? 0 : texLKolumn - 1;
  486. break;
  487.  
  488.  
  489. }
  490.  
  491. if (klawisz == 27)
  492. exit(0);
  493. }
  494.  
  495.  
  496. //////////////////////////////////////////////////////////////////////////////////////////
  497. // Glowna funkcja programu
  498. int main(int argc, char **argv)
  499. {
  500. // Zainicjowanie biblioteki GLUT
  501. glutInit(&argc, argv);
  502.  
  503. // Ustawienie trybu wyswietlania
  504. glutInitDisplayMode (GLUT_DOUBLE|GLUT_RGBA|GLUT_DEPTH);
  505.  
  506. // Ustawienie polozenia dolenego lewego rogu okna
  507. glutInitWindowPosition(100, 100);
  508.  
  509. // Ustawienie rozmiarow okna
  510. glutInitWindowSize(szerokoscOkna, wysokoscOkna);
  511.  
  512. // Utworzenie okna
  513. glutCreateWindow("Teksturowana kula");
  514.  
  515. // Odblokowanie bufora glebokosci
  516. glEnable(GL_DEPTH_TEST);
  517.  
  518. // Ustawienie funkcji wykonywanej na danych w buforze glebokosci
  519. glDepthFunc(GL_LEQUAL);
  520.  
  521. // Ustawienie wartosci czyszczacej zawartosc bufora glebokosci
  522. glClearDepth(1000.0);
  523.  
  524. // Odblokowanie wykonywania operacji na skladowych "alfa"
  525. glEnable(GL_BLEND);
  526.  
  527. // Wybor funkcji mieszajacej kolory
  528. glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  529.  
  530. // Ustawienie koloru czyszczenia bufora ramki
  531. glClearColor (0.0, 0.3, 0.0, 0.0);
  532.  
  533. // Zarejestrowanie funkcji (callback) wyswietlajacej
  534. glutDisplayFunc(WyswietlObraz);
  535.  
  536. // Zarejestrowanie funkcji (callback) wywolywanej za kazdym razem kiedy
  537. // zmieniane sa rozmiary okna
  538. glutReshapeFunc(UstawParametryWidoku);
  539.  
  540. // Zarejestrowanie funkcji wykonywanej gdy okno nie obsluguje
  541. // zadnych zadan
  542. glutIdleFunc(WyswietlObraz);
  543.  
  544. // Zarejestrowanie funkcji obslugi klawiatury
  545. glutKeyboardFunc(ObslugaKlawiatury);
  546.  
  547.  
  548. // Ustawienie oswietlenia sceny (polozenie zrodla swiatla wyznaczane jest w ukladzie
  549. // wspolrzednych obserwatora)
  550. WlaczOswietlenie();
  551.  
  552. // glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
  553. // Obsluga glownej petli programu (wywolywanie zarejestrowanych callbackow
  554. // w odpowiedzi na odbierane zdarzenia lub obsluga stanu bezczynnosci)
  555. glutMainLoop();
  556.  
  557. return 0;
  558. }
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!