API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Nov 13th, 2019
124
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 8.54 KB | None | 0 0
raw download clone embed print report
  1. #include <windows.h>
  2. #include <gl/gl.h>
  3. #include <gl/glut.h>
  4. #include <vector>
  5. #include <array>
  6. #include <math.h>
  7. #include <iostream>
  8.  
  9. #define PI 3.14159265
  10.  
  11.  
  12. typedef float point3[3];
  13. int model = 1;  // 1- punkty, 2- siatka, 3 - wypełnione trójkąty
  14.  
  15. /*************************************************************************************/
  16.  
  17. // Funkcja rysująca osie układu współrzędnych
  18.  
  19.  
  20.  
  21. void Axes(void)
  22. {
  23.  
  24.     point3  x_min = { -5.0, 0.0, 0.0 };
  25.     point3  x_max = { 5.0, 0.0, 0.0 };
  26.     // początek i koniec obrazu osi x
  27.  
  28.     point3  y_min = { 0.0, -5.0, 0.0 };
  29.     point3  y_max = { 0.0,  5.0, 0.0 };
  30.     // początek i koniec obrazu osi y
  31.  
  32.     point3  z_min = { 0.0, 0.0, -5.0 };
  33.     point3  z_max = { 0.0, 0.0,  5.0 };
  34.     //  początek i koniec obrazu osi y
  35.     glColor3f(1.0f, 0.0f, 0.0f);  // kolor rysowania osi - czerwony
  36.     glBegin(GL_LINES); // rysowanie osi x
  37.     glVertex3fv(x_min);
  38.     glVertex3fv(x_max);
  39.     glEnd();
  40.  
  41.     glColor3f(0.0f, 1.0f, 0.0f);  // kolor rysowania - zielony
  42.     glBegin(GL_LINES);  // rysowanie osi y
  43.  
  44.     glVertex3fv(y_min);
  45.     glVertex3fv(y_max);
  46.     glEnd();
  47.  
  48.     glColor3f(0.0f, 0.0f, 1.0f);  // kolor rysowania - niebieski
  49.     glBegin(GL_LINES); // rysowanie osi z
  50.  
  51.     glVertex3fv(z_min);
  52.     glVertex3fv(z_max);
  53.     glEnd();
  54.  
  55. }
  56.  
  57. /*************************************************************************************/
  58.  
  59. // Funkcja określająca co ma być rysowane (zawsze wywoływana gdy trzeba
  60. // przerysować scenę)
  61.  
  62. void drawEgg(const int n) {
  63.  
  64.     std::vector<std::vector<std::array<float, 3>>> matrix(n, std::vector<std::array<float, 3>>(n));
  65.  
  66.  
  67.     for (int v = 0; v < n; v++)
  68.     {
  69.         for (int u = 0; u < n; u++)
  70.         {
  71.  
  72.             float uf = (float)u / (float)(n-1);
  73.             float vf = (float)v / (float)(n-1);
  74.  
  75.             matrix[u][v][0] = (-90 * pow(uf, 5) + 225 * pow(uf, 4) - 270 * pow(uf, 3) + 180 * pow(uf, 2) - 45 * uf) * cos(PI * vf);
  76.             matrix[u][v][1] = (160 * pow(uf, 4) - 320 * pow(uf, 3) + 160 * pow(uf, 2)) - 5;
  77.             matrix[u][v][2] = (-90 * pow(uf, 5) + 225 * pow(uf, 4) - 270 * pow(uf, 3) + 180 * pow(uf, 2) - 45 * uf) * sin(PI * vf);
  78.  
  79.  
  80.             //matrix[u][v] = new point3(temp);
  81.  
  82.         }
  83.     }
  84.  
  85.  
  86.     if (model == 1)
  87.     {
  88.         glBegin(GL_POINTS);
  89.  
  90.         for (int v = 0; v < n; v++)
  91.         {
  92.             for (int u = 0; u < n; u++)
  93.             {
  94.                 point3 temp = {
  95.                     matrix[u][v][0],
  96.                     matrix[u][v][1],
  97.                     matrix[u][v][2]
  98.                 };
  99.  
  100.                 //std::cout << matrix[u][v][0] << std::endl;
  101.                 //std::cout << matrix[u][v][1] << std::endl;
  102.                 //std::cout << matrix[u][v][2] << std::endl << std::endl;
  103.  
  104.                 glVertex3fv(temp);
  105.             }
  106.         }
  107.  
  108.         glEnd();
  109.     }
  110.  
  111.     if (model == 2) {
  112.  
  113.         for (int v = 0; v < n-1; v++)
  114.         {
  115.             for (int u = 0; u < n-1; u++)
  116.             {
  117.  
  118.                 point3 temp = {
  119.                     matrix[u][v][0],
  120.                     matrix[u][v][1],
  121.                     matrix[u][v][2]
  122.                 };
  123.  
  124.                 point3 temp2 = {
  125.                     matrix[u][v+1][0],
  126.                     matrix[u][v+1][1],
  127.                     matrix[u][v+1][2]
  128.                 };
  129.  
  130.                 glBegin(GL_LINES);
  131.                     glVertex3fv(temp);
  132.                     glVertex3fv(temp2);
  133.                 glEnd();
  134.  
  135.  
  136.                 point3 temp3 = {
  137.                     matrix[u+1][v][0],
  138.                     matrix[u+1][v][1],
  139.                     matrix[u+1][v][2]
  140.                 };
  141.  
  142.                 glBegin(GL_LINES);
  143.                 glVertex3fv(temp);
  144.                 glVertex3fv(temp3);
  145.                 glEnd();
  146.  
  147.             }
  148.         }
  149.  
  150.        
  151.     }
  152.  
  153.     if (model == 3) {
  154.  
  155.         for (int v = 0; v < (n - 1); v++)
  156.         {
  157.             for (int u = 0; u < (n - 1)/2; u++)
  158.             {
  159.  
  160.                 point3 temp = {
  161.                     matrix[u][v][0],
  162.                     matrix[u][v][1],
  163.                     matrix[u][v][2]
  164.                 };
  165.  
  166.                 point3 temp2 = {
  167.                     matrix[u][v + 1][0],
  168.                     matrix[u][v + 1][1],
  169.                     matrix[u][v + 1][2]
  170.                 };
  171.  
  172.                 point3 temp3 = {
  173.                     matrix[u + 1][v][0],
  174.                     matrix[u + 1][v][1],
  175.                     matrix[u + 1][v][2]
  176.                 };
  177.                
  178.                 point3 temp4 = {
  179.                     matrix[u + 1][v + 1][0],
  180.                     matrix[u + 1][v + 1][1],
  181.                     matrix[u + 1][v + 1][2]
  182.                 };
  183.  
  184.                 glColor3f(0.5f, 0.5f, 1.0f);
  185.  
  186.                 glBegin(GL_TRIANGLES);
  187.                     glVertex3fv(temp);
  188.                     glVertex3fv(temp2);
  189.                     glVertex3fv(temp3);
  190.                 glEnd();
  191.  
  192.                 glColor3f(0.5f, 1.f, 0.5f);
  193.  
  194.                 glBegin(GL_TRIANGLES);
  195.                 glVertex3fv(temp2);
  196.                 glVertex3fv(temp4);
  197.                 glVertex3fv(temp3);
  198.                 glEnd();
  199.  
  200.  
  201.  
  202.  
  203.             }
  204.         }
  205.  
  206.         for (int v = 0; v < (n - 1); v++)
  207.         {
  208.             for (int u = (n - 1) / 2; u < (n - 1); u++)
  209.             {
  210.  
  211.                 point3 temp = {
  212.                     matrix[u][v][0],
  213.                     matrix[u][v][1],
  214.                     matrix[u][v][2]
  215.                 };
  216.  
  217.                 point3 temp2 = {
  218.                     matrix[u][v + 1][0],
  219.                     matrix[u][v + 1][1],
  220.                     matrix[u][v + 1][2]
  221.                 };
  222.  
  223.                 point3 temp3 = {
  224.                     matrix[u + 1][v][0],
  225.                     matrix[u + 1][v][1],
  226.                     matrix[u + 1][v][2]
  227.                 };
  228.  
  229.                 point3 temp4 = {
  230.                     matrix[u + 1][v + 1][0],
  231.                     matrix[u + 1][v + 1][1],
  232.                     matrix[u + 1][v + 1][2]
  233.                 };
  234.  
  235.  
  236.                 glColor3f(0.5f, 1.f, 0.5f);
  237.  
  238.                 glBegin(GL_TRIANGLES);
  239.                 glVertex3fv(temp);
  240.                 glVertex3fv(temp2);
  241.                 glVertex3fv(temp4);
  242.                 glEnd();
  243.  
  244.  
  245.  
  246.  
  247.                 glColor3f(0.5f, 0.5f, 1.0f);
  248.                 glBegin(GL_TRIANGLES);
  249.                 glVertex3fv(temp3);
  250.                 glVertex3fv(temp4);
  251.                 glVertex3fv(temp);
  252.                 glEnd();
  253.  
  254.  
  255.  
  256.  
  257.             }
  258.         }
  259.  
  260.        
  261.  
  262.  
  263.        
  264.  
  265.  
  266.  
  267.     }
  268.  
  269.  
  270.  
  271.  
  272. }
  273.  
  274.  
  275.  
  276. void RenderScene(void)
  277. {
  278.  
  279.     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  280.     // Czyszczenie okna aktualnym kolorem czyszczącym
  281.  
  282.     glLoadIdentity();
  283.     // Czyszczenie macierzy bieżącej
  284.     Axes();
  285.     // Narysowanie osi przy pomocy funkcji zdefiniowanej wyżej
  286.     glColor3f(1.0f, 1.0f, 1.0f); // Ustawienie koloru rysowania na biały
  287.  
  288.  
  289.     glRotated(60.0, 1.0, 1.0, 0.3);  // Obrót o 60 stopni
  290.  
  291.  
  292.  
  293.     //glutWireTeapot(3.0); // Narysowanie obrazu czajnika do herbaty
  294.     drawEgg(50);
  295.  
  296.     glFlush();
  297.     // Przekazanie poleceń rysujących do wykonania
  298.  
  299.  
  300.     glutSwapBuffers();
  301.     //
  302. }
  303.  
  304. /*************************************************************************************/
  305.  
  306. // Funkcja ustalająca stan renderowania
  307.  
  308. void keys(unsigned char key, int x, int y)
  309. {
  310.     if (key == 'p') model = 1;
  311.     if (key == 'w') model = 2;
  312.     if (key == 's') model = 3;
  313.  
  314.     RenderScene(); // przerysowanie obrazu sceny
  315. }
  316.  
  317.  
  318. void MyInit(void)
  319. {
  320.  
  321.     glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
  322.     // Kolor czyszcący (wypełnienia okna) ustawiono na czarny
  323.  
  324. }
  325.  
  326. /*************************************************************************************/
  327.  
  328. // Funkcja ma za zadanie utrzymanie stałych proporcji rysowanych
  329. // w przypadku zmiany rozmiarów okna.
  330. // Parametry vertical i horizontal (wysokość i szerokość okna) są
  331. // przekazywane do funkcji za każdym razem gdy zmieni się rozmiar okna.
  332.  
  333.  
  334.  
  335. void ChangeSize(GLsizei horizontal, GLsizei vertical)
  336. {
  337.  
  338.     GLfloat AspectRatio;
  339.     // Deklaracja zmiennej AspectRatio  określającej proporcję
  340.     // wymiarów okna
  341.     if (vertical == 0)  // Zabezpieczenie przed dzieleniem przez 0
  342.         vertical = 1;
  343.     glViewport(0, 0, horizontal, vertical);
  344.     // Ustawienie wielkościokna okna widoku (viewport)
  345.     // W tym przypadku od (0,0) do (horizontal, vertical)  
  346.     glMatrixMode(GL_PROJECTION);
  347.     // Przełączenie macierzy bieżącej na macierz projekcji
  348.     glLoadIdentity();
  349.     // Czyszcznie macierzy bieżącej            
  350.     AspectRatio = (GLfloat)horizontal / (GLfloat)vertical;
  351.     // Wyznaczenie współczynnika  proporcji okna
  352.     // Gdy okno nie jest kwadratem wymagane jest określenie tak zwanej
  353.     // przestrzeni ograniczającej pozwalającej zachować właściwe
  354.     // proporcje rysowanego obiektu.
  355.     // Do okreslenia przestrzeni ograniczjącej służy funkcja
  356.     // glOrtho(...)            
  357.     if (horizontal <= vertical)
  358.  
  359.         glOrtho(-7.5, 7.5, -7.5 / AspectRatio, 7.5 / AspectRatio, 10.0, -10.0);
  360.     else
  361.  
  362.         glOrtho(-7.5*AspectRatio, 7.5*AspectRatio, -7.5, 7.5, 10.0, -10.0);
  363.     glMatrixMode(GL_MODELVIEW);
  364.     // Przełączenie macierzy bieżącej na macierz widoku modelu                                  
  365.  
  366.     glLoadIdentity();
  367.     // Czyszcenie macierzy bieżącej
  368. }
  369.  
  370. /*************************************************************************************/
  371.  
  372. // Główny punkt wejścia programu. Program działa w trybie konsoli
  373.  
  374.  
  375.  
  376.  
  377.  
  378. void main(void)
  379. {
  380.  
  381.     glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
  382.  
  383.     glutInitWindowSize(400, 400);
  384.  
  385.  
  386.     glutCreateWindow("Układ współrzędnych 3-D");
  387.  
  388.     glutDisplayFunc(RenderScene);
  389.     glutKeyboardFunc(keys);
  390.     // Określenie, że funkcja RenderScene będzie funkcją zwrotną
  391.     // (callback function).  Bedzie ona wywoływana za każdym razem
  392.     // gdy zajdzie potrzba przeryswania okna
  393.     glutReshapeFunc(ChangeSize);
  394.     // Dla aktualnego okna ustala funkcję zwrotną odpowiedzialną
  395.     // zazmiany rozmiaru okna      
  396.     MyInit();
  397.     // Funkcja MyInit() (zdefiniowana powyżej) wykonuje wszelkie
  398.     // inicjalizacje konieczne  przed przystąpieniem do renderowania
  399.     glEnable(GL_DEPTH_TEST);
  400.     // Włączenie mechanizmu usuwania powierzchni niewidocznych
  401.  
  402.     glutMainLoop();
  403.     // Funkcja uruchamia szkielet biblioteki GLUT
  404. }
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!