API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jan 21st, 2020
88
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 9.66 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. #include <GL/glut.h>
  8. #include <math.h>
  9.  
  10. GLfloat M_PI = 3.14159265359;
  11.  
  12. // Definicja stalych
  13. #define DLUGOSC_BOKU            3.0
  14. #define OBSERWATOR_FOV_Y        30.0
  15.  
  16. #define MAX 64.0
  17. #define MIN 4.0
  18.  
  19. #define MIN_ODL -5.0
  20. #define MAX_ODL -180.0
  21.  
  22. GLfloat rotObsY = 20.0;
  23. GLfloat rotObsX = 20.0;
  24. GLfloat rotObsZ = 0.0;
  25. GLfloat obsOdl = -30.0;
  26.  
  27. GLfloat slacks = 15.0;
  28. GLfloat stacks = 15.0;
  29.  
  30. // Zmienne globalne
  31. double  bok           = DLUGOSC_BOKU; // Dlugosc boku szescianu
  32. int     szerokoscOkna = 800;
  33. int     wysokoscOkna  = 600;
  34.  
  35. GLfloat R = 5.0;
  36. GLfloat r = 25.0;
  37. GLfloat h = 25.0;
  38.  
  39. GLfloat xd1 = 20.0, xd2 = 20.0;
  40.  
  41.  
  42. float deg_rad(int x)
  43. {
  44.     return x * M_PI / 180.0;
  45. }
  46.  
  47. // Prototypy funkcji
  48. void RysujSzescian(double a);
  49. void UstawParametryWidoku(int szer, int wys);
  50. void WyswietlObraz(void);
  51. void ObslugaKlawiatury(unsigned char klawisz, int x, int y);
  52.  
  53.  
  54. //////////////////////////////////////////////////////////////////////////////////////////
  55. // Funkcja rysujaca szescian o boku "a" w trybie GL_QUAD_STRIP.
  56. // Srodek szescianu znajduje się w punkcie (0,0,0).
  57. void RysujSzescian(double a)
  58. {
  59.   // Sciany boczne
  60.   glBegin(GL_QUAD_STRIP);
  61.     glVertex3f(a/2.0, a/2.0, a/2.0);
  62.     glVertex3f(a/2.0, -a/2.0, a/2.0);
  63.     glVertex3f(a/2.0, a/2.0, -a/2.0);
  64.     glVertex3f(a/2.0, -a/2.0, -a/2.0);
  65.  
  66.     glVertex3f(-a/2.0, a/2.0, -a/2.0);
  67.     glVertex3f(-a/2.0, -a/2.0, -a/2.0);
  68.  
  69.     glVertex3f(-a/2.0, a/2.0, a/2.0);
  70.     glVertex3f(-a/2.0, -a/2.0, a/2.0);
  71.  
  72.     glVertex3f(a/2.0, a/2.0, a/2.0);
  73.     glVertex3f(a/2.0, -a/2.0, a/2.0);
  74.   glEnd();
  75.  
  76.   // Gorna sciana
  77.   glBegin(GL_QUAD_STRIP);
  78.     glVertex3f(-a/2.0, a/2.0, a/2.0);
  79.     glVertex3f(a/2.0, a/2.0, a/2.0);
  80.     glVertex3f(-a/2.0, a/2.0, -a/2.0);
  81.     glVertex3f(a/2.0, a/2.0, -a/2.0);
  82.   glEnd();
  83.  
  84.   // Dolna sciana
  85.   glBegin(GL_QUAD_STRIP);
  86.     glVertex3f(-a/2.0, -a/2.0, a/2.0);
  87.     glVertex3f(a/2.0, -a/2.0, a/2.0);
  88.     glVertex3f(-a/2.0, -a/2.0, -a/2.0);
  89.     glVertex3f(a/2.0, -a/2.0, -a/2.0);
  90.   glEnd();
  91.  
  92. }
  93.  
  94. void rysujStozek(GLfloat radiusTop, GLfloat radiusBottom, GLfloat h)
  95. {
  96.     double dAlfa = 360.0 / slacks;
  97.     double tangens = (radiusTop - radiusBottom) / h;
  98.  
  99.     double jump = h / stacks;
  100.     // PODSTAWA DOLNA
  101.     glColor3f(1, 1, 1);
  102.     glBegin(GL_TRIANGLE_FAN);
  103.     glVertex3f(0, 0, 0);
  104.     for (int i = 0; i * dAlfa <= 360.0; i++)
  105.     {
  106.         glVertex3f(radiusBottom * cos(deg_rad(i * dAlfa)), 0, radiusBottom * sin(deg_rad(i * dAlfa)));
  107.     }
  108.     glEnd();
  109.  
  110.     // PODSTAWA GORNA
  111.  
  112.     glColor3f(1.0, 0.0, 1.0);
  113.     glBegin(GL_TRIANGLE_FAN);
  114.  
  115.     glVertex3f(0, h, 0);
  116.  
  117.     for (int i = 0; i * dAlfa <= 360.0; i++)
  118.     {
  119.         glVertex3f(radiusTop * cos(deg_rad(i * dAlfa)), h, radiusTop * sin(deg_rad(i * dAlfa)));
  120.     }
  121.     glEnd();
  122.  
  123.  
  124.     // SCIANY BOCZNE
  125.     glColor3f(1.0, 1.0, 0.0);
  126.     glBegin(GL_QUADS);
  127.     for (int i = 0; i * dAlfa <= 360.0; i++)
  128.     {
  129.         for (int x = 0; x < stacks; x++)
  130.         {
  131.             float hPom = (x + 1) * jump;
  132.             float rBottom = radiusBottom + tangens * x * jump;
  133.             float rTop = radiusBottom + tangens * hPom;
  134.             glVertex3f(rBottom * cos(deg_rad(i * dAlfa)), x * jump, rBottom * sin(deg_rad(i * dAlfa)));
  135.             glVertex3f(rTop * cos(deg_rad(i * dAlfa)), hPom, rTop * sin(deg_rad(i * dAlfa)));
  136.             glVertex3f(rTop * cos(deg_rad((i + 1) * dAlfa)), hPom, rTop * sin(deg_rad((i + 1) * dAlfa)));
  137.             glVertex3f(rBottom * cos(deg_rad((i + 1) * dAlfa)), x * jump, rBottom * sin(deg_rad((i + 1) * dAlfa)));
  138.         }
  139.     }
  140.  
  141.     glEnd();
  142.  
  143. }
  144.  
  145. //////////////////////////////////////////////////////////////////////////////////////////
  146. // Funkcja ustawiajaca parametry rzutu perspektywicznego i rozmiary viewportu. Powinna
  147. // być wywolywana kazdorazowo po zmianie rozmiarow okna programu.
  148. void UstawParametryWidoku(int szer, int wys)
  149. {
  150.   // Zapamietanie wielkosci widoku
  151.   szerokoscOkna = szer;
  152.   wysokoscOkna  = wys;
  153.  
  154.   // Ustawienie parametrow viewportu
  155.   glViewport(0, 0, szerokoscOkna, wysokoscOkna);
  156.  
  157.   // Przejscie w tryb modyfikacji macierzy rzutowania
  158.   glMatrixMode(GL_PROJECTION);
  159.   glLoadIdentity();
  160.   gluPerspective(OBSERWATOR_FOV_Y, (float)szerokoscOkna/(float)wysokoscOkna, 1.0, 1000.0);
  161. }
  162.  
  163.  
  164. GLfloat OX(GLfloat r, GLfloat fi, GLfloat teta)
  165. {
  166.     return r * cos(M_PI / 2 - fi) * cos(teta);
  167. }
  168.  
  169. GLfloat OY(GLfloat r, GLfloat fi, GLfloat teta)
  170. {
  171.     return r * cos(M_PI / 2 - fi) * sin(teta);
  172. }
  173.  
  174. GLfloat OZ(GLfloat r, GLfloat fi)
  175. {
  176.     return r * sin(M_PI / 2 - fi);
  177. }
  178.  
  179.  
  180. void sfera(GLfloat radius, GLfloat slices, GLfloat stacks) {
  181.     GLfloat slcInc = 2 * M_PI / slices;
  182.     GLfloat stkInc = M_PI / stacks;
  183.  
  184.     glPushMatrix();
  185.     glRotatef(-90, 1, 0, 0);
  186.  
  187.     glColor3f(1, 1, 1);
  188.     glBegin(GL_TRIANGLE_STRIP);
  189.     int z = 0;
  190.     for (int i = 0; i < stacks; i++, z++) {
  191.         for (int j = 0; j < slices; j++) {
  192.             glVertex3f(OX(radius, i * stkInc, j * slcInc), OY(radius, i * stkInc, j * slcInc), OZ(radius, i * stkInc));
  193.             glVertex3f(OX(radius, (i + 1) * stkInc, j * slcInc), OY(radius, (i + 1) * stkInc, j * slcInc), OZ(radius, (i + 1) * stkInc));
  194.             glVertex3f(OX(radius, i * stkInc, (j + 1) * slcInc), OY(radius, i * stkInc, (j + 1) * slcInc), OZ(radius, i * stkInc));
  195.             glVertex3f(OX(radius, (i + 1) * stkInc, (j + 1) * slcInc), OY(radius, (i + 1) * stkInc, (j + 1) * slcInc), OZ(radius, (i + 1) * stkInc));
  196.         }
  197.     }
  198.     glEnd();
  199.     glPopMatrix();
  200. }
  201.  
  202. //////////////////////////////////////////////////////////////////////////////////////////
  203. // Funkcja wyswietlajaca pojedyncza klatke animacji
  204. void WyswietlObraz(void)
  205. {
  206.   // Wyczyszczenie bufora koloru i bufora glebokosci
  207.   glClear(0);
  208.  
  209.   glBegin(GL_LINES);
  210.  
  211.   // Os X
  212.   glColor3f(1.0, 0.0, 0.0);
  213.  
  214.   glVertex3f(-50.0, 0.0, 0.0);
  215.   glVertex3f(50.0, 0.0, 0.0);
  216.  
  217.   // Os Y
  218.   glColor3f(0.0, 1.0, 0.0);
  219.   glVertex3f(0.0, -50.0, 0.0);
  220.   glVertex3f(0.0, 50.0, 0.0);
  221.  
  222.   // Os Z
  223.   glColor3f(0.0, 0.0, 1.0);
  224.   glVertex3f(0.0, 0.0, -50.0);
  225.   glVertex3f(0.0, 0.0, 50.0);
  226.  
  227.   // Koniec tworzenia ukladu wspolrzednych
  228.   glEnd();
  229.  
  230.   glColor3f(1.0, 1.0, 1.0);
  231.  
  232.   // Przejscie w tryb modyfikacji macierzy przeksztalcen geometrycznych
  233.   glMatrixMode(GL_MODELVIEW);
  234.  
  235.   // Zastapienie aktywnej macierzy macierza jednostkowa
  236.   glLoadIdentity();
  237.  
  238.   // Ustalenie polozenia obserwatora
  239.   glTranslatef(0, 0, obsOdl);
  240.   glRotatef(rotObsX, 1, 0, 0);
  241.   glRotatef(rotObsY, 0, 1, 0);
  242.   glRotatef(rotObsZ, 0, 0, 1);
  243.  
  244.   // Narysowanie szescianu
  245.   //RysujSzescian(bok);
  246.   //rysujStozek(r, R, h);
  247.  sfera(3, slacks, stacks);
  248.   // Przelaczenie buforow ramki
  249.   glutSwapBuffers();
  250. }
  251.  
  252.  
  253.  
  254.  
  255. //////////////////////////////////////////////////////////////////////////////////////////
  256. // Funkcja obslugi klawiatury
  257. void ObslugaKlawiatury(unsigned char klawisz, int x, int y)
  258. {
  259.     switch (klawisz)
  260.     {
  261.         case '+':
  262.             obsOdl = obsOdl < MIN_ODL ? obsOdl + 1.0 : MIN_ODL;
  263.             break;
  264.         case '-':
  265.             obsOdl = obsOdl > MAX_ODL ? obsOdl - 1.0 : MAX_ODL;
  266.             break;
  267.  
  268.         case 27:
  269.             exit(0);
  270.     }
  271. }
  272.  
  273. void ObslugaKlawiszySpecjalnych(int klawisz, int x, int y)
  274. {
  275.     switch (klawisz)
  276.     {
  277.     case GLUT_KEY_UP:
  278.         rotObsX++;
  279.         break;
  280.  
  281.     case GLUT_KEY_DOWN:
  282.         rotObsX--;
  283.         break;
  284.  
  285.     case GLUT_KEY_LEFT:
  286.         rotObsY++;
  287.         break;
  288.  
  289.     case GLUT_KEY_RIGHT:
  290.         rotObsY--;
  291.         break;
  292.  
  293.     case GLUT_KEY_F1:
  294.         rotObsZ--;
  295.         break;
  296.  
  297.     case GLUT_KEY_F2:
  298.         rotObsZ++;
  299.         break;
  300.  
  301.     case GLUT_KEY_F3:
  302.         slacks = slacks > MIN ? slacks - 1.0 : MIN;
  303.         break;
  304.  
  305.     case GLUT_KEY_F4:
  306.         slacks = slacks < MAX ? slacks + 1.0 : MAX;
  307.         break;
  308.  
  309.     case GLUT_KEY_F5:
  310.         stacks = stacks > MIN ? stacks - 1.0 : MIN;
  311.         break;
  312.  
  313.     case GLUT_KEY_F6:
  314.         stacks = stacks < MAX ? stacks + 1.0 : MAX;
  315.         break;
  316.  
  317.     case GLUT_KEY_F7:
  318.         xd1 = xd1 > MIN ? xd1 - 1.0 : MIN;
  319.         break;
  320.  
  321.     case GLUT_KEY_F8:
  322.         xd1 = xd1 < MAX ? xd1 + 1.0 : MAX;
  323.         break;
  324.  
  325.     case GLUT_KEY_F9:
  326.         xd2 = xd2 > MIN ? xd2 - 1.0 : MIN;
  327.         break;
  328.  
  329.     case GLUT_KEY_F10:
  330.         xd2 = xd2 < MAX ? xd2 + 1.0 : MAX;
  331.         break;
  332.  
  333.     }
  334. }
  335.  
  336. //////////////////////////////////////////////////////////////////////////////////////////
  337. // Glowna funkcja programu
  338. int  main(int argc, char **argv)
  339. {
  340.   // Zainicjowanie biblioteki GLUT
  341.   glutInit(&argc, argv);
  342.  
  343.   // Ustawienie trybu wyswietlania
  344.   glutInitDisplayMode (GLUT_DOUBLE|GLUT_RGB|GLUT_DEPTH);
  345.  
  346.   // Ustawienie polozenia dolenego lewego rogu okna
  347.   glutInitWindowPosition(100, 100);
  348.  
  349.   // Ustawienie rozmiarow okna
  350.   glutInitWindowSize(szerokoscOkna, wysokoscOkna);
  351.  
  352.   // Utworzenie okna
  353.   glutCreateWindow("Szescian");
  354.  
  355.   // Odblokowanie bufora glebokosci
  356.   glEnable(GL_DEPTH_TEST);
  357.  
  358.   // Ustawienie wartosci czyszczacej zawartosc bufora glebokosci
  359.   glClearDepth(1000.0);
  360.  
  361.   // Ustawienie koloru czyszczenia bufora ramki
  362.   glClearColor (0.0f, 0.0f, 0.3f, 0.0f);
  363.  
  364.   // Wlaczenie wyswietlania wielokatow w postaci obrysow (przydatne w celach diagnostycznych).
  365.   glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
  366.  
  367.   // Zarejestrowanie funkcji (callback) odpowiedzialnej za
  368.   glutDisplayFunc(WyswietlObraz);
  369.  
  370.   // Zarejestrowanie funkcji (callback) wywolywanej za kazdym razem kiedy
  371.   // zmieniane sa rozmiary okna
  372.   glutReshapeFunc(UstawParametryWidoku);
  373.  
  374.     // Zarejestrowanie funkcji obslugi klawiatury
  375.   glutKeyboardFunc(ObslugaKlawiatury);
  376.   glutSpecialFunc(ObslugaKlawiszySpecjalnych);
  377.  
  378.   // Zarejestrowanie funkcji wykonywanej gdy okno nie obsluguje
  379.   // zadnych zadan
  380.   glutIdleFunc(WyswietlObraz);
  381.  
  382.   // Obsluga glownej petli programu (wywolywanie zarejestrowanych callbackow
  383.   // w odpowiedzi na odbierane zdarzenia lub obsluga stanu bezczynnosci)
  384.   glutMainLoop();
  385.  
  386.   return 0;
  387. }
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!