API tools faq
paste
Advertisement
Guest User

lab3 egg

a guest
Oct 23rd, 2017
88
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 21.61 KB | None | 0 0
raw download clone embed print report
  1.  
  2. PASTEBIN
  3. new paste
  4. trends API tools faq
  5.  
  6. Guest User
  7. -
  8. Public Pastes
  9.  
  10.     Untitled3 sec ago
  11.     Untitled3 sec ago
  12.     Untitled4 sec ago
  13.     Untitled9 sec ago
  14.     Untitled9 sec ago
  15.     MHA + Eldorado11 sec ago
  16.     Untitled13 sec ago
  17.     My Private Server?...14 sec ago
  18.  
  19. SHARE
  20. TWEET
  21. Gk lab3
  22. a guest Oct 23rd, 2017 0 Never
  23. NOTE: Your guest paste has been posted. If you sign up for a free account, you can edit and delete your pastes!
  24. rawdownloadcloneembedreportprint C++ 9.74 KB
  25.  
  26. #include <windows.h>
  27. #include <gl/gl.h>
  28. #include <gl/glut.h>
  29. #include <iostream>
  30. #include <math.h>
  31. #include <ctime>
  32.  
  33. static GLfloat theta[] = { 0.0, 0.0, 0.0 };
  34. int size =10;
  35. const double PI = 3.141592653589793238463;
  36. typedef float point3[3];
  37. int model = 1;
  38. float X = 1;
  39. float distance = X / size;
  40. float** posX = new float*[size+1];
  41. float** posY = new float*[size + 1];
  42. float** posZ = new float*[size + 1];
  43. int** colorR = new int*[size + 1];
  44. int** colorG = new int*[size + 1];
  45. int** colorB = new int*[size + 1];
  46.  
  47. /*************************************************************************************/
  48. // Funkcja rysująca osie układu współrzędnych
  49. void Axes(void)
  50. {
  51.     point3  x_min = { -5.0, 0.0, 0.0 };
  52.     point3  x_max = { 5.0, 0.0, 0.0 };
  53.     // początek i koniec obrazu osi x
  54.  
  55.     point3  y_min = { 0.0, -5.0, 0.0 };
  56.     point3  y_max = { 0.0, 5.0, 0.0 };
  57.     // początek i koniec obrazu osi y
  58.  
  59.     point3  z_min = { 0.0, 0.0, -5.0 };
  60.     point3  z_max = { 0.0, 0.0, 5.0 };
  61.     //  początek i koniec obrazu osi y
  62.     glColor3f(1.0f, 0.0f, 0.0f);  // kolor rysowania osi - czerwony
  63.     glBegin(GL_LINES); // rysowanie osi x
  64.     glVertex3fv(x_min);
  65.     glVertex3fv(x_max);
  66.     glEnd();
  67.  
  68.     glColor3f(0.0f, 1.0f, 0.0f);  // kolor rysowania - zielony
  69.     glBegin(GL_LINES);  // rysowanie osi y
  70.     glVertex3fv(y_min);
  71.     glVertex3fv(y_max);
  72.     glEnd();
  73.  
  74.     glColor3f(0.0f, 0.0f, 1.0f);  // kolor rysowania - niebieski
  75.     glBegin(GL_LINES); // rysowanie osi z
  76.     glVertex3fv(z_min);
  77.     glVertex3fv(z_max);
  78.     glEnd();
  79. }
  80.  
  81. float x(float u, float v)
  82. {
  83.     return (-90 * pow(u, 5) + 225 * pow(u, 4) - 270 * pow(u, 3) + 180 * pow(u, 2) - 45 * u)*cos(PI *v);
  84. }
  85.  
  86. float y(float u, float v)
  87. {
  88.     return 160 * pow(u, 4) - 320 * pow(u, 3) + 160 * pow(u, 2);
  89. }
  90.  
  91. float z(float u, float v)
  92. {
  93.     return (-90 * pow(u, 5) + 225 * pow(u, 4) - 270 * pow(u, 3) + 180 * pow(u, 2) - 45 * u)*sin(PI *v);
  94. }
  95. void Egg()
  96. {
  97.  
  98.     switch (model)
  99.     {
  100.     case 1:
  101.     {
  102.         //DRAW POINTS
  103.         glBegin(GL_POINTS);
  104.         for (int i = 0; i<size + 1; i++)
  105.         {
  106.             for (int j = 0; j<size + 1; j++)
  107.             {
  108.                 glVertex3f(posX[j][i], posY[j][i] - 4, posZ[j][i]);
  109.             }
  110.         }
  111.         glEnd();
  112.         break;
  113.     }
  114.     case 2:
  115.     {
  116.         //DRAW LINES
  117.         glBegin(GL_LINES);
  118.         for (int i = 0; i<size; i++)
  119.         {
  120.             for (int j = 0; j<size; j++)
  121.             {
  122.  
  123.                 if (j<size - 1)
  124.                 {
  125.                     glVertex3f(posX[j][i], posY[j][i] - 4, posZ[j][i]);
  126.                     glVertex3f(posX[j + 1][i], posY[j + 1][i] - 4, posZ[j + 1][i]);
  127.  
  128.  
  129.                 }
  130.                 if (i<size - 1)
  131.                 {
  132.                     glVertex3f(posX[j][i], posY[j][i] - 4, posZ[j][i]);
  133.                     glVertex3f(posX[j][i + 1], posY[j][i + 1] - 4, posZ[j][i + 1]);
  134.  
  135.                     glVertex3f(-posX[j][i], posY[j][i] - 4, posZ[j][i]);
  136.                     glVertex3f(-posX[j][i + 1], posY[j][i + 1] - 4, posZ[j][i + 1]);
  137.  
  138.                 }
  139.             }
  140.             glVertex3f(posX[size - 1][i], posY[size - 1][i] - 4, posZ[size - 1][i]);
  141.             glVertex3f(posX[0][i], posY[0][i] - 4, posZ[0][i]);
  142.  
  143.  
  144.         }
  145.         glEnd();
  146.         break;
  147.     }
  148.     case 3:
  149.     {
  150.         glBegin(GL_TRIANGLES);
  151.         for (int i = 0; i<size; i++)
  152.         {
  153.             for (int j = 0; j<size; j++)
  154.             {
  155.                     glColor3ub(colorR[j][i], colorB[j][i], colorG[j][i]);
  156.                 glVertex3f(posX[j][i], posY[j][i] - 4, posZ[j][i]);
  157.  
  158.                     glColor3ub(colorR[j][i + 1], colorB[j][i + 1], colorG[j][i + 1]);
  159.                 glVertex3f(posX[j][i + 1], posY[j][i + 1] - 4, posZ[j][i + 1]);
  160.  
  161.                     glColor3ub(colorR[j + 1][i], colorB[j + 1][i], colorG[j + 1][i]);
  162.                 glVertex3f(posX[j + 1][i], posY[j + 1][i] - 4, posZ[j + 1][i]);
  163.  
  164.  
  165.                     glColor3ub(colorR[j + 1][i], colorB[j + 1][i], colorG[j + 1][i]);
  166.                 glVertex3f(posX[j + 1][i], posY[j + 1][i] - 4, posZ[j + 1][i]);
  167.  
  168.                     glColor3ub(colorR[j + 1][i + 1], colorB[j + 1][i + 1], colorG[j + 1][i + 1]);
  169.                 glVertex3f(posX[j + 1][i + 1], posY[j + 1][i + 1] - 4, posZ[j + 1][i + 1]);
  170.  
  171.                     glColor3ub(colorR[j][i + 1], colorB[j][i + 1], colorG[j][i + 1]);
  172.                 glVertex3f(posX[j][i + 1], posY[j][i + 1] - 4, posZ[j][i + 1]);
  173.             }
  174.             //glColor3ub(colorR[size - 1][i], colorB[size - 1][i], colorG[size - 1][i]);
  175.             //glVertex3f(posX[size - 1][i], posY[size - 1][i] - 4, posZ[size - 1][i]);
  176.  
  177.             //glColor3ub(colorR[size - 1][i + 1], colorB[size - 1][i+1], colorG[size - 1][i + 1]);
  178.             //glVertex3f(posX[size - 1][i + 1], posY[size - 1][i+1] - 4, posZ[size - 1][i + 1]);
  179.  
  180.             //glColor3ub(colorR[0][i], colorB[0][i], colorG[0][i]);
  181.             //glVertex3f(posX[0][i], posY[0][i] - 4, posZ[0][i]);
  182.  
  183.             //
  184.  
  185.  
  186.             glColor3ub(colorR[i][size-1 ], colorB[i][size-1], colorG[i][size-1]);
  187.             glVertex3f(posX[i][size - 1], posY[i][size - 1] - 4, posZ[i][size - 1]);
  188.  
  189.             glColor3ub(colorR[i + 1][size - 1], colorB[i + 1][size - 1], colorG[i + 1][size - 1]);
  190.             glVertex3f(posX[i + 1][size - 1], posY[i + 1][size - 1] - 4, posZ[i + 1][size - 1]);
  191.  
  192.             glColor3ub(colorR[i+1][0], colorB[i+1][0], colorG[i+1][0]);
  193.             glVertex3f(posX[i+1][0], posY[i+1][0] - 4, posZ[i+1][0]);
  194.  
  195.         }
  196.         glEnd();
  197.         break;
  198.     }
  199.     }
  200.  
  201. }
  202.  
  203.  
  204. void spinEgg()
  205. {
  206.  
  207.     theta[0] -= 0.5;
  208.     if (theta[0] > 360.0) theta[0] -= 360.0;
  209.  
  210.     theta[1] -= 0.5;
  211.     if (theta[1] > 360.0) theta[1] -= 360.0;
  212.  
  213.     theta[2] -= 0.5;
  214.     if (theta[2] > 360.0) theta[2] -= 360.0;
  215.  
  216.     glutPostRedisplay(); //odświeżenie zawartości aktualnego okna
  217. }
  218.  
  219.  
  220. /*************************************************************************************/
  221. // Funkcja określająca co ma być rysowane (zawsze wywoływana gdy trzeba
  222. // przerysować scenę)
  223. void RenderScene(void)
  224. {
  225.     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  226.     // Czyszczenie okna aktualnym kolorem czyszczącym
  227.  
  228.     glLoadIdentity();
  229.     // Czyszczenie macierzy bieżącej
  230.     Axes();
  231.     // Narysowanie osi przy pomocy funkcji zdefiniowanej wyżej
  232.  
  233.     glRotatef(theta[0], 1.0, 0.0, 0.0);
  234.  
  235.     glRotatef(theta[1], 0.0, 1.0, 0.0);
  236.  
  237.     glRotatef(theta[2], 0.0, 0.0, 1.0);
  238.  
  239.     glColor3f(1.0f, 1.0f, 1.0f); // Ustawienie koloru rysowania na biały
  240.     Egg();
  241.     glFlush();
  242.     // Przekazanie poleceń rysujących do wykonania
  243.  
  244.     glutSwapBuffers();
  245.     //
  246. }
  247.  
  248.  
  249. void keys(unsigned char key, int x, int y)
  250. {
  251.     if (key == 'p') model = 1;
  252.     if (key == 'w') model = 2;
  253.     if (key == 's') model = 3;
  254.  
  255.     RenderScene(); // przerysowanie obrazu sceny
  256. }
  257. /*************************************************************************************/
  258. // Funkcja ustalająca stan renderowania
  259.  
  260. void MyInit(void)
  261. {
  262.     glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
  263.     // Kolor czyszcący (wypełnienia okna) ustawiono na czarny
  264. }
  265. /*************************************************************************************/
  266. // Funkcja ma za zadanie utrzymanie stałych proporcji rysowanych
  267. // w przypadku zmiany rozmiarów okna.
  268. // Parametry vertical i horizontal (wysokość i szerokość okna) są
  269. // przekazywane do funkcji za każdym razem gdy zmieni się rozmiar okna.
  270.  
  271. void ChangeSize(GLsizei horizontal, GLsizei vertical)
  272. {
  273.     GLfloat AspectRatio;
  274.     // Deklaracja zmiennej AspectRatio  określającej proporcję
  275.     // wymiarów okna
  276.     if (vertical == 0)  // Zabezpieczenie przed dzieleniem przez 0
  277.         vertical = 1;
  278.     glViewport(0, 0, horizontal, vertical);
  279.     // Ustawienie wielkościokna okna widoku (viewport)
  280.     // W tym przypadku od (0,0) do (horizontal, vertical)  
  281.     glMatrixMode(GL_PROJECTION);
  282.     // Przełączenie macierzy bieżącej na macierz projekcji
  283.     glLoadIdentity();
  284.     // Czyszcznie macierzy bieżącej            
  285.     AspectRatio = (GLfloat)horizontal / (GLfloat)vertical;
  286.     // Wyznaczenie współczynnika  proporcji okna
  287.     // Gdy okno nie jest kwadratem wymagane jest określenie tak zwanej
  288.     // przestrzeni ograniczającej pozwalającej zachować właściwe
  289.     // proporcje rysowanego obiektu.
  290.     // Do okreslenia przestrzeni ograniczjącej służy funkcja
  291.     // glOrtho(...)            
  292.     if (horizontal <= vertical)
  293.         glOrtho(-7.5, 7.5, -7.5 / AspectRatio, 7.5 / AspectRatio, 10.0, -10.0);
  294.     else
  295.         glOrtho(-7.5*AspectRatio, 7.5*AspectRatio, -7.5, 7.5, 10.0, -10.0);
  296.     glMatrixMode(GL_MODELVIEW);
  297.     // Przełączenie macierzy bieżącej na macierz widoku modelu                                  
  298.     glLoadIdentity();
  299.     // Czyszcenie macierzy bieżącej
  300. }
  301. /*************************************************************************************/
  302. // Główny punkt wejścia programu. Program działa w trybie konsoli
  303.  
  304. void main(void)
  305. {
  306.  
  307.     for (int i = 0; i < size + 1; i++)
  308.     {
  309.         colorR[i] = new int[size + 1];
  310.         colorG[i] = new int[size + 1];
  311.         colorB[i] = new int[size + 1];
  312.  
  313.     }
  314.     srand(time(NULL));
  315.     for (int i = 0; i< size + 1; i++)
  316.     {
  317.         for (int j = 0; j<size + 1; j++)
  318.         {
  319.             colorR[i][j] = rand() % 256;
  320.             colorG[i][j] = rand() % 256;
  321.             colorB[i][j] = rand() % 256;
  322.         }
  323.     }
  324.  
  325.  
  326.     for (int i = 0; i < size + 1; i++)
  327.     {
  328.         posX[i] = new float[size + 1];
  329.         posY[i] = new float[size + 1];
  330.         posZ[i] = new float[size + 1];
  331.     }
  332.  
  333.     for (int i = 0; i < size + 1; i++)
  334.     {
  335.         for (int j = 0; j < size + 1; j++)
  336.         {
  337.             posX[j][i] = x(j*distance, i*distance);
  338.             posY[j][i] = y(j*distance, i*distance);
  339.             posZ[j][i] = z(j*distance, i*distance);
  340.         }
  341.     }
  342.  
  343.     glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
  344.  
  345.     glutInitWindowSize(300, 300);
  346.  
  347.     glutCreateWindow("Układ współrzędnych 3-D");
  348.     glutIdleFunc(spinEgg);
  349.     glutDisplayFunc(RenderScene);
  350.     glutKeyboardFunc(keys);
  351.     // Określenie, że funkcja RenderScene będzie funkcją zwrotną
  352.     // (callback function).  Bedzie ona wywoływana za każdym razem
  353.     // gdy zajdzie potrzba przeryswania okna
  354.     glutReshapeFunc(ChangeSize);
  355.     // Dla aktualnego okna ustala funkcję zwrotną odpowiedzialną
  356.     // zazmiany rozmiaru okna      
  357.     MyInit();
  358.     // Funkcja MyInit() (zdefiniowana powyżej) wykonuje wszelkie
  359.     // inicjalizacje konieczne  przed przystąpieniem do renderowania
  360.     glEnable(GL_DEPTH_TEST);
  361.     // Włączenie mechanizmu usuwania powierzchni niewidocznych
  362.  
  363.     glutMainLoop();
  364.     // Funkcja uruchamia szkielet biblioteki GLUT
  365.  
  366.     for (int i = 0; i< size; i++)
  367.     {
  368.         delete[] posX[i];
  369.         delete[] posY[i];
  370.         delete[] posZ[i];
  371.         delete[] colorG[i];
  372.         delete[] colorB[i];
  373.         delete[] colorR[i];
  374.     }
  375.  
  376.     }
  377.  
  378. RAW Paste Data
  379. #include <windows.h>
  380. #include <gl/gl.h>
  381. #include <gl/glut.h>
  382. #include <iostream>
  383. #include <math.h>
  384. #include <ctime>
  385.  
  386. static GLfloat theta[] = { 0.0, 0.0, 0.0 };
  387. int size =10;
  388. const double PI = 3.141592653589793238463;
  389. typedef float point3[3];
  390. int model = 1;
  391. float X = 1;
  392. float distance = X / size;
  393. float** posX = new float*[size+1];
  394. float** posY = new float*[size + 1];
  395. float** posZ = new float*[size + 1];
  396. int** colorR = new int*[size + 1];
  397. int** colorG = new int*[size + 1];
  398. int** colorB = new int*[size + 1];
  399.  
  400. /*************************************************************************************/
  401. // Funkcja rysująca osie układu współrzędnych
  402. void Axes(void)
  403. {
  404.     point3  x_min = { -5.0, 0.0, 0.0 };
  405.     point3  x_max = { 5.0, 0.0, 0.0 };
  406.     // początek i koniec obrazu osi x
  407.  
  408.     point3  y_min = { 0.0, -5.0, 0.0 };
  409.     point3  y_max = { 0.0, 5.0, 0.0 };
  410.     // początek i koniec obrazu osi y
  411.  
  412.     point3  z_min = { 0.0, 0.0, -5.0 };
  413.     point3  z_max = { 0.0, 0.0, 5.0 };
  414.     //  początek i koniec obrazu osi y
  415.     glColor3f(1.0f, 0.0f, 0.0f);  // kolor rysowania osi - czerwony
  416.     glBegin(GL_LINES); // rysowanie osi x
  417.     glVertex3fv(x_min);
  418.     glVertex3fv(x_max);
  419.     glEnd();
  420.  
  421.     glColor3f(0.0f, 1.0f, 0.0f);  // kolor rysowania - zielony
  422.     glBegin(GL_LINES);  // rysowanie osi y
  423.     glVertex3fv(y_min);
  424.     glVertex3fv(y_max);
  425.     glEnd();
  426.  
  427.     glColor3f(0.0f, 0.0f, 1.0f);  // kolor rysowania - niebieski
  428.     glBegin(GL_LINES); // rysowanie osi z
  429.     glVertex3fv(z_min);
  430.     glVertex3fv(z_max);
  431.     glEnd();
  432. }
  433.  
  434. float x(float u, float v)
  435. {
  436.     return (-90 * pow(u, 5) + 225 * pow(u, 4) - 270 * pow(u, 3) + 180 * pow(u, 2) - 45 * u)*cos(PI *v);
  437. }
  438.  
  439. float y(float u, float v)
  440. {
  441.     return 160 * pow(u, 4) - 320 * pow(u, 3) + 160 * pow(u, 2);
  442. }
  443.  
  444. float z(float u, float v)
  445. {
  446.     return (-90 * pow(u, 5) + 225 * pow(u, 4) - 270 * pow(u, 3) + 180 * pow(u, 2) - 45 * u)*sin(PI *v);
  447. }
  448. void Egg()
  449. {
  450.  
  451.     switch (model)
  452.     {
  453.     case 1:
  454.     {
  455.         //DRAW POINTS
  456.         glBegin(GL_POINTS);
  457.         for (int i = 0; i<size + 1; i++)
  458.         {
  459.             for (int j = 0; j<size + 1; j++)
  460.             {
  461.                 glVertex3f(posX[j][i], posY[j][i] - 4, posZ[j][i]);
  462.             }
  463.         }
  464.         glEnd();
  465.         break;
  466.     }
  467.     case 2:
  468.     {
  469.         //DRAW LINES
  470.         glBegin(GL_LINES);
  471.         for (int i = 0; i<size; i++)
  472.         {
  473.             for (int j = 0; j<size; j++)
  474.             {
  475.  
  476.                 if (j<size - 1)
  477.                 {
  478.                     glVertex3f(posX[j][i], posY[j][i] - 4, posZ[j][i]);
  479.                     glVertex3f(posX[j + 1][i], posY[j + 1][i] - 4, posZ[j + 1][i]);
  480.  
  481.  
  482.                 }
  483.                 if (i<size - 1)
  484.                 {
  485.                     glVertex3f(posX[j][i], posY[j][i] - 4, posZ[j][i]);
  486.                     glVertex3f(posX[j][i + 1], posY[j][i + 1] - 4, posZ[j][i + 1]);
  487.  
  488.                     glVertex3f(-posX[j][i], posY[j][i] - 4, posZ[j][i]);
  489.                     glVertex3f(-posX[j][i + 1], posY[j][i + 1] - 4, posZ[j][i + 1]);
  490.  
  491.                 }
  492.             }
  493.             glVertex3f(posX[size - 1][i], posY[size - 1][i] - 4, posZ[size - 1][i]);
  494.             glVertex3f(posX[0][i], posY[0][i] - 4, posZ[0][i]);
  495.  
  496.  
  497.         }
  498.         glEnd();
  499.         break;
  500.     }
  501.     case 3:
  502.     {
  503.         glBegin(GL_TRIANGLES);
  504.         for (int i = 0; i<size; i++)
  505.         {
  506.             for (int j = 0; j<size; j++)
  507.             {
  508.                     glColor3ub(colorR[j][i], colorB[j][i], colorG[j][i]);
  509.                 glVertex3f(posX[j][i], posY[j][i] - 4, posZ[j][i]);
  510.  
  511.                     glColor3ub(colorR[j][i + 1], colorB[j][i + 1], colorG[j][i + 1]);
  512.                 glVertex3f(posX[j][i + 1], posY[j][i + 1] - 4, posZ[j][i + 1]);
  513.  
  514.                     glColor3ub(colorR[j + 1][i], colorB[j + 1][i], colorG[j + 1][i]);
  515.                 glVertex3f(posX[j + 1][i], posY[j + 1][i] - 4, posZ[j + 1][i]);
  516.  
  517.  
  518.                     glColor3ub(colorR[j + 1][i], colorB[j + 1][i], colorG[j + 1][i]);
  519.                 glVertex3f(posX[j + 1][i], posY[j + 1][i] - 4, posZ[j + 1][i]);
  520.  
  521.                     glColor3ub(colorR[j + 1][i + 1], colorB[j + 1][i + 1], colorG[j + 1][i + 1]);
  522.                 glVertex3f(posX[j + 1][i + 1], posY[j + 1][i + 1] - 4, posZ[j + 1][i + 1]);
  523.  
  524.                     glColor3ub(colorR[j][i + 1], colorB[j][i + 1], colorG[j][i + 1]);
  525.                 glVertex3f(posX[j][i + 1], posY[j][i + 1] - 4, posZ[j][i + 1]);
  526.             }
  527.             //glColor3ub(colorR[size - 1][i], colorB[size - 1][i], colorG[size - 1][i]);
  528.             //glVertex3f(posX[size - 1][i], posY[size - 1][i] - 4, posZ[size - 1][i]);
  529.  
  530.             //glColor3ub(colorR[size - 1][i + 1], colorB[size - 1][i+1], colorG[size - 1][i + 1]);
  531.             //glVertex3f(posX[size - 1][i + 1], posY[size - 1][i+1] - 4, posZ[size - 1][i + 1]);
  532.  
  533.             //glColor3ub(colorR[0][i], colorB[0][i], colorG[0][i]);
  534.             //glVertex3f(posX[0][i], posY[0][i] - 4, posZ[0][i]);
  535.  
  536.             //
  537.  
  538.  
  539.             glColor3ub(colorR[i][size-1 ], colorB[i][size-1], colorG[i][size-1]);
  540.             glVertex3f(posX[i][size - 1], posY[i][size - 1] - 4, posZ[i][size - 1]);
  541.  
  542.             glColor3ub(colorR[i + 1][size - 1], colorB[i + 1][size - 1], colorG[i + 1][size - 1]);
  543.             glVertex3f(posX[i + 1][size - 1], posY[i + 1][size - 1] - 4, posZ[i + 1][size - 1]);
  544.  
  545.             glColor3ub(colorR[i+1][0], colorB[i+1][0], colorG[i+1][0]);
  546.             glVertex3f(posX[i+1][0], posY[i+1][0] - 4, posZ[i+1][0]);
  547.  
  548.         }
  549.         glEnd();
  550.         break;
  551.     }
  552.     }
  553.  
  554. }
  555.  
  556.  
  557. void spinEgg()
  558. {
  559.  
  560.     theta[0] -= 0.5;
  561.     if (theta[0] > 360.0) theta[0] -= 360.0;
  562.  
  563.     theta[1] -= 0.5;
  564.     if (theta[1] > 360.0) theta[1] -= 360.0;
  565.  
  566.     theta[2] -= 0.5;
  567.     if (theta[2] > 360.0) theta[2] -= 360.0;
  568.  
  569.     glutPostRedisplay(); //odświeżenie zawartości aktualnego okna
  570. }
  571.  
  572.  
  573. /*************************************************************************************/
  574. // Funkcja określająca co ma być rysowane (zawsze wywoływana gdy trzeba
  575. // przerysować scenę)
  576. void RenderScene(void)
  577. {
  578.     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  579.     // Czyszczenie okna aktualnym kolorem czyszczącym
  580.  
  581.     glLoadIdentity();
  582.     // Czyszczenie macierzy bieżącej
  583.     Axes();
  584.     // Narysowanie osi przy pomocy funkcji zdefiniowanej wyżej
  585.  
  586.     glRotatef(theta[0], 1.0, 0.0, 0.0);
  587.  
  588.     glRotatef(theta[1], 0.0, 1.0, 0.0);
  589.  
  590.     glRotatef(theta[2], 0.0, 0.0, 1.0);
  591.  
  592.     glColor3f(1.0f, 1.0f, 1.0f); // Ustawienie koloru rysowania na biały
  593.     Egg();
  594.     glFlush();
  595.     // Przekazanie poleceń rysujących do wykonania
  596.  
  597.     glutSwapBuffers();
  598.     //
  599. }
  600.  
  601.  
  602. void keys(unsigned char key, int x, int y)
  603. {
  604.     if (key == 'p') model = 1;
  605.     if (key == 'w') model = 2;
  606.     if (key == 's') model = 3;
  607.  
  608.     RenderScene(); // przerysowanie obrazu sceny
  609. }
  610. /*************************************************************************************/
  611. // Funkcja ustalająca stan renderowania
  612.  
  613. void MyInit(void)
  614. {
  615.     glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
  616.     // Kolor czyszcący (wypełnienia okna) ustawiono na czarny
  617. }
  618. /*************************************************************************************/
  619. // Funkcja ma za zadanie utrzymanie stałych proporcji rysowanych
  620. // w przypadku zmiany rozmiarów okna.
  621. // Parametry vertical i horizontal (wysokość i szerokość okna) są
  622. // przekazywane do funkcji za każdym razem gdy zmieni się rozmiar okna.
  623.  
  624. void ChangeSize(GLsizei horizontal, GLsizei vertical)
  625. {
  626.     GLfloat AspectRatio;
  627.     // Deklaracja zmiennej AspectRatio  określającej proporcję
  628.     // wymiarów okna
  629.     if (vertical == 0)  // Zabezpieczenie przed dzieleniem przez 0
  630.         vertical = 1;
  631.     glViewport(0, 0, horizontal, vertical);
  632.     // Ustawienie wielkościokna okna widoku (viewport)
  633.     // W tym przypadku od (0,0) do (horizontal, vertical)  
  634.     glMatrixMode(GL_PROJECTION);
  635.     // Przełączenie macierzy bieżącej na macierz projekcji
  636.     glLoadIdentity();
  637.     // Czyszcznie macierzy bieżącej            
  638.     AspectRatio = (GLfloat)horizontal / (GLfloat)vertical;
  639.     // Wyznaczenie współczynnika  proporcji okna
  640.     // Gdy okno nie jest kwadratem wymagane jest określenie tak zwanej
  641.     // przestrzeni ograniczającej pozwalającej zachować właściwe
  642.     // proporcje rysowanego obiektu.
  643.     // Do okreslenia przestrzeni ograniczjącej służy funkcja
  644.     // glOrtho(...)            
  645.     if (horizontal <= vertical)
  646.         glOrtho(-7.5, 7.5, -7.5 / AspectRatio, 7.5 / AspectRatio, 10.0, -10.0);
  647.     else
  648.         glOrtho(-7.5*AspectRatio, 7.5*AspectRatio, -7.5, 7.5, 10.0, -10.0);
  649.     glMatrixMode(GL_MODELVIEW);
  650.     // Przełączenie macierzy bieżącej na macierz widoku modelu                                  
  651.     glLoadIdentity();
  652.     // Czyszcenie macierzy bieżącej
  653. }
  654. /*************************************************************************************/
  655. // Główny punkt wejścia programu. Program działa w trybie konsoli
  656.  
  657. void main(void)
  658. {
  659.  
  660.     for (int i = 0; i < size + 1; i++)
  661.     {
  662.         colorR[i] = new int[size + 1];
  663.         colorG[i] = new int[size + 1];
  664.         colorB[i] = new int[size + 1];
  665.  
  666.     }
  667.     srand(time(NULL));
  668.     for (int i = 0; i< size + 1; i++)
  669.     {
  670.         for (int j = 0; j<size + 1; j++)
  671.         {
  672.             colorR[i][j] = rand() % 256;
  673.             colorG[i][j] = rand() % 256;
  674.             colorB[i][j] = rand() % 256;
  675.         }
  676.     }
  677.  
  678.  
  679.     for (int i = 0; i < size + 1; i++)
  680.     {
  681.         posX[i] = new float[size + 1];
  682.         posY[i] = new float[size + 1];
  683.         posZ[i] = new float[size + 1];
  684.     }
  685.  
  686.     for (int i = 0; i < size + 1; i++)
  687.     {
  688.         for (int j = 0; j < size + 1; j++)
  689.         {
  690.             posX[j][i] = x(j*distance, i*distance);
  691.             posY[j][i] = y(j*distance, i*distance);
  692.             posZ[j][i] = z(j*distance, i*distance);
  693.         }
  694.     }
  695.  
  696.     glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
  697.  
  698.     glutInitWindowSize(300, 300);
  699.  
  700.     glutCreateWindow("Układ współrzędnych 3-D");
  701.     glutIdleFunc(spinEgg);
  702.     glutDisplayFunc(RenderScene);
  703.     glutKeyboardFunc(keys);
  704.     // Określenie, że funkcja RenderScene będzie funkcją zwrotną
  705.     // (callback function).  Bedzie ona wywoływana za każdym razem
  706.     // gdy zajdzie potrzba przeryswania okna
  707.     glutReshapeFunc(ChangeSize);
  708.     // Dla aktualnego okna ustala funkcję zwrotną odpowiedzialną
  709.     // zazmiany rozmiaru okna      
  710.     MyInit();
  711.     // Funkcja MyInit() (zdefiniowana powyżej) wykonuje wszelkie
  712.     // inicjalizacje konieczne  przed przystąpieniem do renderowania
  713.     glEnable(GL_DEPTH_TEST);
  714.     // Włączenie mechanizmu usuwania powierzchni niewidocznych
  715.  
  716.     glutMainLoop();
  717.     // Funkcja uruchamia szkielet biblioteki GLUT
  718.  
  719.     for (int i = 0; i< size; i++)
  720.     {
  721.         delete[] posX[i];
  722.         delete[] posY[i];
  723.         delete[] posZ[i];
  724.         delete[] colorG[i];
  725.         delete[] colorB[i];
  726.         delete[] colorR[i];
  727.     }
  728. }
  729. Pastebin PRO Autumn Special!
  730. Get 40% OFF on Pastebin PRO accounts!
  731. create new paste  /  dealsnew!  /  api  /  trends  /  syntax languages  /  faq  /  tools  /  privacy  /  cookies  /  contact  /  dmca  /  scraping  /  go
  732. Site design & logo © 2017 Pastebin; user contributions (pastes) licensed under cc by-sa 3.0 -- Dedicated Server Hosting by Steadfast
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!