SHARE
TWEET

Untitled

a guest Jan 22nd, 2020 84 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.  
  8. #include "glut.h"
  9. #include <math.h>
  10. #include <time.h>
  11. #include <stdint.h>
  12.  
  13.  
  14. #define odlMin 5
  15. #define odlMax 200
  16. #define Pi 3.14159265359
  17.  
  18. int podzialPionowy = 8;
  19. int podzialPoziomy = 8;
  20. int     szerokoscOkna = 800;
  21. int     wysokoscOkna = 600;
  22.  
  23. GLboolean tryb = GL_TRUE;
  24.  
  25. GLfloat odlObs = 50.0;
  26. GLfloat rotObsY = 40.0;
  27. GLfloat rotObsX = 40.0;
  28. GLfloat rotObsZ = 0.0;
  29.  
  30. float length;
  31.  
  32. int source1 = 1;
  33. int source2 = 1;
  34. int obecnymaterial = 0;
  35. int normalne = 1;
  36. int smooth = 1;
  37. int fill = 1;
  38.  
  39. // Tablica parametrow materialu nr 1
  40. float material1[5][4] = {
  41.     {0.192250, 0.192250, 0.192250, 1.000000},  // [0] wspolczynnik odbicia swiatla otoczenia
  42.     {0.507540, 0.507540, 0.507540, 1.000000},  // [1] wspolczynnik odbicia swiatla rozproszonego
  43.     {0.508273, 0.508273, 0.508273, 1.000000},  // [2] wspolczynnik odbicia swiatla lustrzanego
  44.     {51.2, 0.0, 0.0, 0.0}, // [3] polysk
  45.     {0.5, 0.0, 0.2, 1.0} }; // [4] kolor swiatla emitowanego
  46.  
  47.     // Tablica parametrow materialu nr 2
  48. float material2[5][4] = {
  49.   {0.250000, 0.148000, 0.064750, 1.000000},  // [0] wspolczynnik odbicia swiatla otoczenia
  50.   {0.400000, 0.236800, 0.103600, 1.000000},  // [1] wspolczynnik odbicia swiatla rozproszonego
  51.   {0.774597, 0.458561, 0.200621, 1.000000},  // [2] wspolczynnik odbicia swiatla lustrzanego
  52.   {76.8, 0.0, 0.0, 0.0},                     // [3] polysk
  53.   {0.0, 0.1, 0.3, 1.0} };                    // [4] kolor swiatla emitowanego
  54.  
  55.     // Tablica parametrow materialu nr 3
  56. float material3[5][4] = {
  57.     {0.231250, 0.231250, 0.231250, 1.000000},  // [0] wspolczynnik odbicia swiatla otoczenia
  58.     {0.277500, 0.277500, 0.277500, 1.000000},  // [1] wspolczynnik odbicia swiatla rozproszonego
  59.     {0.773911, 0.773911, 0.773911, 1.000000 },  // [2] wspolczynnik odbicia swiatla lustrzanego
  60.     {52.2, 0.0, 0.0, 0.0},                     // [3] polysk
  61.     {0.0, 0.0, 0.0, 1.0} };                    // [4] kolor swiatla emitowanego
  62.  
  63. // Tablica parametrow zrodla swiatla nr 1
  64. GLfloat swiatlo1[5][4] = {
  65.   {0.2, 0.2, 0, 1.0},      // [0] otoczenie
  66.   {0.2, 0.2, 0.0, 1.0},    // [1] rozproszenie
  67.   {0.2, 0.8, 0.0, 1.0},    // [2] lustrzane
  68.   {0, 10.0, 0, 1.0}, // [3] polozenie
  69.   {-1.0, -1.0, -1.0, 0.0}  // [4] kierunek swiecenia
  70. };
  71.  
  72. // Tablica parametrow zrodla swiatla nr 2
  73. GLfloat swiatlo2[5][4] = {
  74.   {0, 1, 1, 1.0},           // [0] otoczenie
  75.   {0, 1, 1, 1.0},           // [1] rozproszenie
  76.   {0, 28, 1, 1.0},          // [2] lustrzane
  77.   {0, 0, -10.0, 1.0}, // [3] polozenie
  78.   {-1.0, -1.0, -1.0, 0.0}   // [4] kierunek swiecenia
  79. };
  80.  
  81.  
  82. // Prototypy funkcji
  83. void RysujSzescian(double a);
  84. void UstawParametryWidoku(int szer, int wys);
  85. void WyswietlObraz(void);
  86. void ObslugaKlawiatury(unsigned char klawisz, int x, int y);
  87. void PoliczNormal(float x1, float x2, float x3, float y1, float y2, float y3, float z1, float z2, float z3, float* normal);
  88.  
  89. void RysujTekstRastrowy(void* font, char* tekst)
  90. {
  91.     int i = 0;
  92.     while (tekst[i] != '\0')
  93.     {
  94.         glutBitmapCharacter(font, tekst[i]);
  95.         i++;
  96.     }
  97. }
  98.  
  99. #define numberofoptions 11
  100.  
  101. void RysujNakladke(void)
  102. {
  103.     char tab[numberofoptions][50] =
  104.     {"1 - Przyblizenie",
  105.      "2 - Oddalenie",
  106.      "5 - Zmiana materialu walca",
  107.      "6 - Sterowanie swiatlem nr. 1",
  108.      "7 - Sterowanie swiatlem nr. 2",
  109.      "8 - Widocznosc wektorow normalnych",
  110.      "9 - Zmiana cienia (GL_SMOOTH i GL_FLAT)",
  111.      "0 - Zmiana wypelnienia (GL_FILL, GL_LINE)",
  112.      "a,z - Zmniejszanie ilosci podzialow",
  113.      "s,x - Zwiekszanie ilosci podzialow",
  114.      "(l,r,d,u arrows),. - Sterowanie kamera",
  115.     };
  116.     int i;
  117.  
  118.     // Zmiana typu rzutu z perspektywicznego na ortogonalny
  119.     glMatrixMode(GL_PROJECTION);
  120.     glPushMatrix();
  121.     glLoadIdentity();
  122.     glOrtho(0.0, szerokoscOkna, 0.0, wysokoscOkna, -100.0, 100.0);
  123.  
  124.     // Modelowanie sceny 2D (zawartosci nakladki)
  125.     glMatrixMode(GL_MODELVIEW);
  126.     glPushMatrix();
  127.     glLoadIdentity();
  128.  
  129.     // Zablokowanie oswietlenia (mialoby ono wplyw na kolor tekstu)
  130.     glDisable(GL_LIGHTING);
  131.  
  132.     // Okreslenie koloru tekstu
  133.     glColor3f(1.0, 1.0, 1.0);
  134.  
  135.     // RYSOWANIE MENU PARAMETROW ZRODLA SWIATLA
  136.  
  137.     for (i = 0; i < numberofoptions; i++)
  138.     {
  139.         glRasterPos2i(10, 10 + i * 13);
  140.         RysujTekstRastrowy(GLUT_BITMAP_8_BY_13, tab[numberofoptions - i - 1]);
  141.     }
  142.  
  143.     glMatrixMode(GL_PROJECTION);
  144.     glPopMatrix();
  145.     glMatrixMode(GL_MODELVIEW);
  146.     glPopMatrix();
  147. }
  148.  
  149. void UstawSwiatlaIMaterialy()
  150. {
  151.     glEnable(GL_LIGHTING);
  152.     // Odblokowanie zrodla swiatla nr 1
  153.     if (source1 == 1) {
  154.         glEnable(GL_LIGHT0);
  155.         glLightfv(GL_LIGHT0, GL_AMBIENT, swiatlo1[0]);
  156.         glLightfv(GL_LIGHT0, GL_DIFFUSE, swiatlo1[1]);
  157.         glLightfv(GL_LIGHT0, GL_SPECULAR, swiatlo1[2]);
  158.         glLightfv(GL_LIGHT0, GL_POSITION, swiatlo1[3]);
  159.         glLightfv(GL_LIGHT0, GL_SPOT_DIRECTION, swiatlo1[4]);
  160.  
  161.     }
  162.     else {
  163.         //wylaczenie zrodla swiatla nr 1
  164.         glDisable(GL_LIGHT0);
  165.     }
  166.     // Odblokowanie zrodla swiatla nr 2
  167.     if (source2 == 1) {
  168.         glEnable(GL_LIGHT1);
  169.         glLightfv(GL_LIGHT1, GL_AMBIENT, swiatlo2[0]);
  170.         glLightfv(GL_LIGHT1, GL_DIFFUSE, swiatlo2[1]);
  171.         glLightfv(GL_LIGHT1, GL_SPECULAR, swiatlo2[2]);
  172.         glLightfv(GL_LIGHT1, GL_POSITION, swiatlo2[3]);
  173.         glLightfv(GL_LIGHT1, GL_SPOT_DIRECTION, swiatlo2[4]);
  174.  
  175.     }
  176.     else {
  177.         //wylaczenie zrodla swiatla nr 2
  178.         glDisable(GL_LIGHT1);
  179.     }
  180.  
  181.     switch (obecnymaterial)
  182.     {
  183.     case 0:
  184.         glMaterialfv(GL_FRONT, GL_AMBIENT, material1[0]);
  185.         glMaterialfv(GL_FRONT, GL_DIFFUSE, material1[1]);
  186.         glMaterialfv(GL_FRONT, GL_SPECULAR, material1[2]);
  187.         glMaterialfv(GL_FRONT, GL_SHININESS, material1[3]);
  188.         glMaterialfv(GL_FRONT, GL_EMISSION, material1[4]);
  189.         break;
  190.     case 1:
  191.         glMaterialfv(GL_FRONT, GL_AMBIENT, material2[0]);
  192.         glMaterialfv(GL_FRONT, GL_DIFFUSE, material2[1]);
  193.         glMaterialfv(GL_FRONT, GL_SPECULAR, material2[2]);
  194.         glMaterialfv(GL_FRONT, GL_SHININESS, material2[3]);
  195.         glMaterialfv(GL_FRONT, GL_EMISSION, material2[4]);
  196.         break;
  197.     case 2:
  198.         glMaterialfv(GL_FRONT, GL_AMBIENT, material3[0]);
  199.         glMaterialfv(GL_FRONT, GL_DIFFUSE, material3[1]);
  200.         glMaterialfv(GL_FRONT, GL_SPECULAR, material3[2]);
  201.         glMaterialfv(GL_FRONT, GL_SHININESS, material3[3]);
  202.         glMaterialfv(GL_FRONT, GL_EMISSION, material3[4]);
  203.         break;
  204.     default:
  205.         break;
  206.     }
  207. }
  208.  
  209. void PoliczNormal(float x1, float x2, float x3, float y1, float y2, float y3, float z1, float z2, float z3, float* normal)
  210. {
  211.     float xa = x2 - x1;
  212.     float ya = y2 - y1;
  213.     float za = z2 - z1;
  214.  
  215.     float xb = x3 - x1;
  216.     float yb = y3 - y1;
  217.     float zb = z3 - z1;
  218.  
  219.     normal[0] = ya * zb - za * yb;
  220.     normal[1] = za * xb - xa * zb;
  221.     normal[2] = xa * yb - ya * xb;
  222.  
  223.     length = sqrtf(normal[0] * normal[0] + normal[1] * normal[1] + normal[2] * normal[2]);
  224.  
  225.     normal[0] /= length;
  226.     normal[1] /= length;
  227.     normal[2] /= length;
  228. }
  229.  
  230. void SyncSmoothIFill()
  231. {
  232.     if (smooth)
  233.         glShadeModel(GL_SMOOTH);
  234.     else
  235.         glShadeModel(GL_FLAT);
  236.  
  237.     if (fill)
  238.         glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
  239.     else
  240.         glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
  241. }
  242.  
  243. double DEG2RAD(float deg)
  244. {
  245.     return deg * Pi / 180;
  246. }
  247.  
  248.  
  249.  
  250. void Stozek(double R, double r, double h) {
  251.     int i;
  252.     double dAlfa = 360.0 / podzialPionowy;
  253.  
  254.     //podstawa dolna
  255.     glBegin(GL_TRIANGLE_FAN);
  256.     glVertex3f(0, 0, 0);
  257.     for (i = 0; i * dAlfa <= 360.0; i++) {
  258.         glVertex3f(R * cos(DEG2RAD(i * dAlfa)), 0, R * sin(DEG2RAD(i * dAlfa)));
  259.     }
  260.     glEnd();
  261.  
  262.     //podstawa gorna
  263.     glBegin(GL_TRIANGLE_FAN);
  264.     glVertex3f(0, h, 0);
  265.     for (i = 0; i * dAlfa <= 360.0; i++) {
  266.         glVertex3f(r * cos(DEG2RAD(i * dAlfa)), h, r * sin(DEG2RAD(i * dAlfa)));
  267.     }
  268.     glEnd();
  269.  
  270.     //sciana boczna
  271.     glBegin(GL_QUAD_STRIP);
  272.     for (i = 0; i * dAlfa <= 360.0; i++) {
  273.         glVertex3f(R * cos(DEG2RAD(i * dAlfa)), 0, R * sin(DEG2RAD(i * dAlfa)));
  274.         glVertex3f(r * cos(DEG2RAD(i * dAlfa)), h, r * sin(DEG2RAD(i * dAlfa)));
  275.     }
  276.     glEnd();
  277. }
  278.  
  279. void Rysuj()
  280. {
  281.     // Poczatek tworzenia ukladu wspolrzednych
  282.     glBegin(GL_LINES);
  283.  
  284.     // Os X
  285.     glColor3f(1.0, 0.0, 0.0);
  286.     glVertex3f(-80.0, 0.0, 0.0);
  287.     glVertex3f(80.0, 0.0, 0.0);
  288.  
  289.     // Os Y
  290.     glColor3f(0.0, 1.0, 0.0);
  291.     glVertex3f(0.0, -80.0, 0.0);
  292.     glVertex3f(0.0, 80.0, 0.0);
  293.  
  294.     // Os Z
  295.     glColor3f(0.0, 0.0, 1.0);
  296.     glVertex3f(0.0, 0.0, -80.0);
  297.     glVertex3f(0.0, 0.0, 80.0);
  298.  
  299.     // Koniec tworzenia ukladu wspolrzednych
  300.     glEnd();
  301.  
  302.     //Stozek(10,20,25);
  303.     Walec();
  304.  
  305. }
  306. */
  307. //////////////////////////////////////////////////////////////////////////////////////////
  308. // Funkcja generujaca pojedyncza klatke animacji
  309. void WyswietlObraz(void)
  310. {
  311.     // Wyczyszczenie bufora ramki i bufora glebokosci
  312.     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  313.     glMatrixMode(GL_MODELVIEW);
  314.  
  315.     // Powielenie macierzy na wierzcholku stosu
  316.     glPushMatrix();
  317.  
  318.     // Wyznaczenie polozenia obserwatora (przeksztalcenie uladu wspolrzednych
  319.     // sceny do ukladu wspolrzednych obserwatora).
  320.     glTranslatef(0, 0, -odlObs);
  321.     glRotatef(rotObsX, 1, 0, 0);
  322.     glRotatef(rotObsY, 0, 1, 0);
  323.     glRotatef(rotObsZ, 0, 0, 1);
  324.  
  325.     RysujNakladke();
  326.  
  327.     UstawSwiatlaIMaterialy();
  328.  
  329.     // Generacja obrazu sceny w niewidocznym buforze ramki
  330.     Walec();
  331.  
  332.     // Usuniecie macierzy lezacej na  wierzcholku stosu (powrot do stanu
  333.     // sprzed wywolania funkcji
  334.     glPopMatrix();
  335.  
  336.     // Przelaczenie buforow ramki
  337.     glutSwapBuffers();
  338. }
  339.  
  340. //////////////////////////////////////////////////////////////////////////////////////////
  341. // Funkcja ustawiajaca parametry rzutu perspektywicznego i rozmiary viewportu
  342. void UstawParametryWidoku(int szerokosc, int wysokosc)
  343. {
  344.     // Ustawienie parametrow viewportu
  345.     glViewport(0, 0, szerokosc, wysokosc);
  346.  
  347.     // Przejscie w tryb modyfikacji macierzy rzutowania
  348.     glMatrixMode(GL_PROJECTION);
  349.     glLoadIdentity();
  350.     gluPerspective(40.0, (float)szerokosc / (float)wysokosc, 1.0, 1000.0);
  351.  
  352.     // Przejscie w tryb modyfikacji macierzy przeksztalcen geometrycznych
  353.     glMatrixMode(GL_MODELVIEW);
  354.  
  355.     // Zmiana macierzy znajdujacej sie na wierzcholku stosu na macierz jednostkowa
  356.     glLoadIdentity();
  357. }
  358.  
  359. void ZmianaTrybu()
  360. {
  361.     if (tryb == GL_TRUE)
  362.     {
  363.         tryb = GL_FALSE;
  364.         glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
  365.     }
  366.     else if (tryb == GL_FALSE)
  367.     {
  368.         tryb = GL_TRUE;
  369.         glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
  370.     }
  371. }
  372.  
  373. //////////////////////////////////////////////////////////////////////////////////////////
  374. // Funkcja klawiszy specjalnych
  375. void ObslugaKlawiszySpecjalnych(int klawisz, int x, int y)
  376. {
  377.     switch (klawisz)
  378.     {
  379.     case GLUT_KEY_UP:
  380.         rotObsX = rotObsX + 1.0;
  381.         break;
  382.  
  383.     case GLUT_KEY_DOWN:
  384.         rotObsX = rotObsX - 1.0;
  385.         break;
  386.  
  387.     case GLUT_KEY_LEFT:
  388.         rotObsY = rotObsY - 1.0;
  389.         break;
  390.  
  391.     case GLUT_KEY_RIGHT:
  392.         rotObsY = rotObsY + 1.0;
  393.         break;
  394.     }
  395. }
  396. //////////////////////////////////////////////////////////////////////////////////////////
  397. // Funkcja obslugi klawiatury
  398. void ObslugaKlawiatury(unsigned char klawisz, int x, int y)
  399. {
  400.  
  401.     switch (klawisz)
  402.     {
  403.     case '1':
  404.         odlObs = (odlObs > odlMin) ? odlObs - 1 : odlObs;
  405.         break;
  406.     case '2':
  407.         odlObs = (odlObs < odlMax) ? odlObs + 1 : odlObs;
  408.         break;
  409.     case ',':
  410.         rotObsZ =  rotObsZ - 1.0;
  411.         break;
  412.     case '.':
  413.         rotObsZ = rotObsZ + 1.0;
  414.         break;
  415.     case 'z':
  416.         podzialPionowy = (podzialPionowy > 4) ? podzialPionowy - 1.0 : podzialPionowy;
  417.         break;
  418.     case 'x':
  419.         podzialPionowy = (podzialPionowy < 64) ? podzialPionowy + 1.0 : podzialPionowy;
  420.         break;
  421.     case 'a':
  422.         podzialPoziomy = (podzialPoziomy > 4) ? podzialPoziomy - 2.0 : podzialPoziomy;
  423.         break;
  424.     case 's':
  425.         podzialPoziomy = (podzialPoziomy < 64) ? podzialPoziomy + 2.0 : podzialPoziomy;
  426.         break;
  427.     case '5':
  428.         obecnymaterial++;
  429.         if (obecnymaterial > 2)
  430.             obecnymaterial = 0;
  431.         break;
  432.     case '6':
  433.         source1 = !source1;
  434.         break;
  435.     case '7':
  436.         source2 = !source2;
  437.         break;
  438.     case '8':
  439.         normalne = !normalne;
  440.         break;
  441.     case '9':
  442.         smooth = !smooth;
  443.         SyncSmoothIFill();
  444.         break;
  445.     case '0':
  446.         fill = !fill;
  447.         SyncSmoothIFill();
  448.         break;
  449.     }
  450.  
  451.     if (klawisz == 27)
  452.         exit(0);
  453. }
  454.  
  455. //////////////////////////////////////////////////////////////////////////////////////////
  456. // Glowna funkcja programu
  457. int  main(int argc, char** argv)
  458. {
  459.     // Zainicjowanie biblioteki GLUT
  460.     glutInit(&argc, argv);
  461.  
  462.     // Ustawienie trybu wyswietlania
  463.     glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
  464.  
  465.     // Ustawienie polozenia dolenego lewego rogu okna
  466.     glutInitWindowPosition(100, 100);
  467.  
  468.     // Ustawienie rozmiarow okna
  469.     glutInitWindowSize(szerokoscOkna, wysokoscOkna);
  470.  
  471.     // Utworzenie okna
  472.     glutCreateWindow("Szescian");
  473.  
  474.     // Odblokowanie bufora glebokosci
  475.     glEnable(GL_DEPTH_TEST);
  476.  
  477.     // Ustawienie funkcji wykonywanej na danych w buforze glebokosci
  478.     glDepthFunc(GL_LEQUAL);
  479.  
  480.     // Ustawienie wartosci czyszczacej zawartosc bufora glebokosci
  481.     glClearDepth(1000.0);
  482.  
  483.     // Ustawienie koloru czyszczenia bufora ramki
  484.     glClearColor(0.0, 0.0, 0.0, 0.0);
  485.  
  486.  
  487.     // Zarejestrowanie funkcji (callback) wyswietlajacej
  488.     glutDisplayFunc(WyswietlObraz);
  489.  
  490.     // Zarejestrowanie funkcji (callback) wywolywanej za kazdym razem kiedy
  491.     // zmieniane sa rozmiary okna
  492.     glutReshapeFunc(UstawParametryWidoku);
  493.  
  494.     // Zarejestrowanie funkcji wykonywanej gdy okno nie obsluguje
  495.     // zadnych zadan
  496.     glutIdleFunc(WyswietlObraz);
  497.  
  498.     // Zarejestrowanie funkcji obslugi klawiatury
  499.     glutKeyboardFunc(ObslugaKlawiatury);
  500.  
  501.     // Zarejestrowanie funkcji obslugi klawiszy specjalnych
  502.     glutSpecialFunc(ObslugaKlawiszySpecjalnych);
  503.  
  504.  
  505.  
  506.     // Obsluga glownej petli programu (wywolywanie zarejestrowanych callbackow
  507.     // w odpowiedzi na odbierane zdarzenia lub obsluga stanu bezczynnosci)
  508.     glutMainLoop();
  509.  
  510.     return 0;
  511. }
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