SHARE
TWEET

Untitled

a guest Jan 14th, 2020 67 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
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
 
Top