Guest User

Untitled

a guest
Jan 14th, 2020
80
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1.  
  2. #include <glut.h>
  3. #include <math.h>
  4.  
  5.  
  6. // Definicja stalych
  7. #define DLUGOSC_BOKU 4.0
  8. #define OBSERWATOR_ODLEGLOSC 20.0
  9. #define OBSERWATOR_FOV_Y 30.0
  10.  
  11. float alfa;
  12.  
  13. #define PI 3.1415926535
  14. #define DEG2RAD(x) ((float)(x)*PI/180.0)
  15.  
  16. // Zmienne globalne
  17. double bok = DLUGOSC_BOKU; // dlugosc boku szescianu
  18. int szerokoscOkna = 800;
  19. int wysokoscOkna = 600;
  20.  
  21.  
  22. float podzial = 5.0;
  23. float xx = 0.0;
  24. float yy = 0.0;
  25. float zz = 0.0;
  26. float x;
  27. float y;
  28. float xxx_obrot = 30.0;
  29. float yyy_obrot = 30.0;
  30. float zzz_obrot = 0.0;
  31. float r = 3.0;
  32. double i, j;
  33.  
  34. // Prototypy funkcji
  35. void RysujSzescian(double a);
  36. void UstawParametryWidoku(int szer, int wys);
  37. void WyswietlObraz(void);
  38. void ObslugaKlawiatury(unsigned char klawisz, int x, int y);
  39.  
  40. float radian(double a)
  41. {
  42. return (a * PI) / 180;
  43. }
  44.  
  45.  
  46.  
  47. //////////////////////////////////////////////////////////////////////////////////////////
  48. // Funkcja rysujaca sferę w trybie GL_TRIANGLES.
  49. // Srodek sfery znajduje się w punkcie (0,0,0).
  50.  
  51. void RysujKolo(float R, float y, int n)
  52. {
  53.  
  54. int i;
  55. float x;
  56. float z;
  57.  
  58. glBegin(GL_TRIANGLE_FAN);
  59.  
  60. glVertex3f(0, 0, 0);
  61.  
  62. alfa = 360 / n;
  63. for (j = 0; j < 360; j += alfa)
  64. {
  65. float rad = radian(j);
  66. x = cos(rad);
  67. z = sin(rad);
  68.  
  69. glVertex3f(x * R, y, z * R);
  70. }
  71. /*for (i = 0; i <= n; i++)
  72. {
  73. float rad = radian(i * alfa);
  74. x = cos(rad);
  75. z = sin(rad);
  76.  
  77. glVertex3f(x * R, y , z * R);
  78. }*/
  79.  
  80.  
  81. x = cos(0.0);
  82. z = sin(0.0);
  83.  
  84. glVertex3f(x * R, y , z * R);
  85.  
  86. glEnd();
  87. }
  88.  
  89. void RysujSzescian()
  90. {
  91.  
  92. float angle;
  93. int i;
  94. int j;
  95. float x1, y1, z1, x2, y2, z2, x3, z3, y3;
  96. //Narysowanie linii pomocniczych
  97. glBegin(GL_LINES);
  98. // Os X
  99. glColor3f(0.3, 0.8, 0.3);
  100. glVertex3f(0.0, 0.0, 0.0);
  101. glVertex3f(10.0, 0.0, 0.0);
  102.  
  103. // Os Y
  104. glColor3f(0.8, 0.3, 0.3);
  105. glVertex3f(0.0, 0.0, 0.0);
  106. glVertex3f(0.0, 10.0, 0.0);
  107.  
  108. // Os Z
  109. glColor3f(0.1, 0.1, 0.8);
  110. glVertex3f(0.0, 0.0, 0.0);
  111. glVertex3f(0.0, 0.0, 10.0);
  112. glEnd();
  113.  
  114. //Narysowanie sfery
  115.  
  116. glColor3f(1, 1, 1);
  117. RysujKolo(r, 0, podzial);
  118. glColor3f(1, 0, 1);
  119. glBegin(GL_TRIANGLES);
  120.  
  121. alfa = 360 / podzial;
  122. for (i = 0; i < 180; i += alfa) {
  123. for (j = 0; j < 360; j += alfa) {
  124.  
  125. glVertex3f(r * cos(radian(i + alfa)) * cos(radian(j)), r * sin(radian(i + alfa)), r * cos(radian(i + alfa)) * sin(radian(j)));
  126. glVertex3f(r * cos(radian(i)) * cos(radian(j + alfa)), r * sin(radian(i)), r * cos(radian(i)) * sin(radian(j + alfa)));
  127. glVertex3f(r * cos(radian(i )) * cos(radian(j)), r * sin(radian(i)), r * cos(radian(i)) * sin(radian(j)) );
  128.  
  129. /*x1 = r * cos(j) * cos(i);
  130. y1 = r * sin(i);
  131. z1 = r * sin(j) * cos(i);
  132.  
  133. y2 = r * sin(i+alfa);
  134.  
  135. x3 = r * cos(j+alfa) * cos(i);
  136.  
  137.  
  138. glVertex3f(x1, y1, z1);
  139. glVertex3f(x1, y2, z1);
  140. glVertex3f(x3, y1, z1);*/
  141.  
  142.  
  143.  
  144. /*if (i == 0)
  145. {
  146. glColor3f(0, 0, 1);
  147. glVertex3f(0.0, 0.0, 0.0);
  148. glVertex3f(r*cos(radian(i))*cos(radian(j)), r*sin(radian(i)), r*cos(radian(i))*sin(radian(j)));
  149. glVertex3f(r*cos(radian(i))*cos(radian(j + podzial)), r*sin(radian(i)), r*cos(radian(i))*sin(radian(j + podzial)));
  150. }*/
  151. }
  152. }
  153.  
  154.  
  155.  
  156. glEnd();
  157.  
  158. }
  159.  
  160. //////////////////////////////////////////////////////////////////////////////////////////
  161. // Funkcja ustawiajaca parametry rzutu perspektywicznego i rozmiary viewportu. Powinna
  162. // być wywolywana kazdorazowo po zmianie rozmiarow okna programu.
  163. void UstawParametryWidoku(int szer, int wys)
  164. {
  165. // Zapamietanie wielkosci widoku
  166. szerokoscOkna = szer;
  167. wysokoscOkna = wys;
  168.  
  169. // Ustawienie parametrow viewportu
  170. glViewport(0, 0, szerokoscOkna, wysokoscOkna);
  171.  
  172. // Przejscie w tryb modyfikacji macierzy rzutowania
  173. glMatrixMode(GL_PROJECTION);
  174. glLoadIdentity();
  175. gluPerspective(OBSERWATOR_FOV_Y, (float)szerokoscOkna / (float)wysokoscOkna, 1.0, 1000.0);
  176. }
  177.  
  178.  
  179. //////////////////////////////////////////////////////////////////////////////////////////
  180. // Funkcja wyswietlajaca pojedyncza klatke animacji
  181. void WyswietlObraz(void)
  182. {
  183. // Wyczyszczenie bufora koloru i bufora glebokosci
  184. glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  185.  
  186. // Przejscie w tryb modyfikacji macierzy przeksztalcen geometrycznych
  187. glMatrixMode(GL_MODELVIEW);
  188.  
  189. // Zastapienie aktywnej macierzy macierza jednostkowa
  190. glLoadIdentity();
  191.  
  192. // Ustalenie polozenia obserwatora
  193. glTranslatef(xx, yy, zz); // odległość obserwatora od osi X,Y,Z
  194. glTranslatef(0, 0, -OBSERWATOR_ODLEGLOSC);
  195.  
  196. //Funkcje odpowiedzialne za obrót względem wybranej osi
  197. glRotatef(xxx_obrot, 1, 0, 0);
  198. glRotatef(yyy_obrot, 0, 1, 0);
  199. glRotatef(zzz_obrot, 0, 0, 1);
  200.  
  201. // Narysowanie szescianu
  202. RysujSzescian();
  203.  
  204. // Przelaczenie buforow ramki
  205. glutSwapBuffers();
  206. }
  207.  
  208.  
  209. //////////////////////////////////////////////////////////////////////////////////////////
  210. // Funkcja obslugi klawiatury
  211. void ObslugaKlawiatury(unsigned char klawisz, int x, int y)
  212. {
  213. double a, c;
  214. int b;
  215. if (klawisz == 27)
  216. exit(0);
  217. else if (klawisz == '+') //zbliżenie obserwatora względem osi z
  218. zz++;
  219. else if (klawisz == '-') //oddalenie obserwatora względem osi z
  220. zz--;
  221. else if (klawisz == 'x') //obrot obserwatora względem osi x
  222. xxx_obrot++;
  223. else if (klawisz == 'z') //obrot obserwatora względem osi x w drugą stronę
  224. xxx_obrot--;
  225. else if (klawisz == 's') //obrot obserwatora względem osi y
  226. yyy_obrot++;
  227. else if (klawisz == 'a') //obrot obserwatora względem osi y w drugą stronę
  228. yyy_obrot--;
  229. else if (klawisz == 'q') //obrot obserwatora względem osi z
  230. zzz_obrot++;
  231. else if (klawisz == 'w') //obrot obserwatora względem osi z w drugą stronę
  232. zzz_obrot--;
  233. else if (klawisz == 'c') {
  234. podzial++;
  235. while (1) {
  236. a = 90 / podzial;
  237. b = 90 / podzial;
  238. c = a - b;
  239. if (podzial >= 45)
  240. {
  241. podzial = 45;
  242. break;
  243. }
  244. if (c != 0) {
  245. podzial++;
  246. }
  247. else break;
  248. }
  249.  
  250. }
  251. else if (klawisz == 'v') {
  252. podzial--;
  253. while (1) {
  254. a = 90 / podzial;
  255. b = 90 / podzial;
  256. c = a - b;
  257. if (podzial <= 2)
  258. {
  259. podzial = 2;
  260. break;
  261. }
  262. if (c != 0) {
  263. podzial--;
  264. }
  265. else break;
  266. }
  267. }
  268. }
  269.  
  270.  
  271. //////////////////////////////////////////////////////////////////////////////////////////
  272. // Glowna funkcja programu
  273. int main(int argc, char** argv)
  274. {
  275. // Zainicjowanie biblioteki GLUT
  276. glutInit(&argc, argv);
  277.  
  278. // Ustawienie trybu wyswietlania
  279. glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
  280.  
  281. // Ustawienie polozenia dolenego lewego rogu okna
  282. glutInitWindowPosition(100, 100);
  283.  
  284. // Ustawienie rozmiarow okna
  285. glutInitWindowSize(szerokoscOkna, wysokoscOkna);
  286.  
  287. // Utworzenie okna
  288. glutCreateWindow("Sfera");
  289.  
  290. // Odblokowanie bufora glebokosci
  291. glEnable(GL_DEPTH_TEST);
  292.  
  293. // Ustawienie wartosci czyszczacej zawartosc bufora glebokosci
  294. glClearDepth(1000.0);
  295.  
  296. // Ustawienie koloru czyszczenia bufora ramki
  297. glClearColor(0.0f, 0.5f, 0.5f, 0.9f);
  298.  
  299. // Wlaczenie wyswietlania wielokatow w postaci obrysow (przydatne w celach diagnostycznych).
  300. glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
  301.  
  302. // Zarejestrowanie funkcji (callback) odpowiedzialnej za
  303. glutDisplayFunc(WyswietlObraz);
  304.  
  305. // Zarejestrowanie funkcji (callback) wywolywanej za kazdym razem kiedy
  306. // zmieniane sa rozmiary okna
  307. glutReshapeFunc(UstawParametryWidoku);
  308.  
  309. // Zarejestrowanie funkcji wykonywanej gdy okno nie obsluguje
  310. // zadnych zadan
  311. glutIdleFunc(WyswietlObraz);
  312.  
  313. // Zarejestrowanie funkcji obslugi klawiatury
  314. glutKeyboardFunc(ObslugaKlawiatury);
  315.  
  316. // Obsluga glownej petli programu (wywolywanie zarejestrowanych callbackow
  317. // w odpowiedzi na odbierane zdarzenia lub obsluga stanu bezczynnosci)
  318. glutMainLoop();
  319.  
  320. return 0;
  321. }
RAW Paste Data