SHARE
TWEET

Untitled

a guest Jan 21st, 2020 59 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  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. }
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