API tools faq
paste
Advertisement
Guest User

jajko_oswietlenie

a guest
Dec 5th, 2016
68
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 14.94 KB | None | 0 0
raw download clone embed print report
  1. /*************************************************************************************/
  2.  
  3. //  Szkielet programu do tworzenia modelu sceny 3-D z wizualizacją osi
  4. //  układu współrzędnych dla rzutowania perspektywicznego
  5.  
  6. /*************************************************************************************/
  7. #define _USE_MATH_DEFINES
  8. #include <windows.h>
  9. #include <gl/gl.h>
  10. #include <gl/glut.h>
  11. #include <math.h>
  12. #include <iostream>
  13.  
  14. typedef float point3[3];
  15. typedef float point2[2];
  16. GLint N = 10;
  17.  
  18. // Funkcja rysująca osie układu współrzędnych
  19. enum Model{
  20.     PUNKTY, NET, TRIANGLES
  21. };
  22.  
  23. Model model = TRIANGLES;
  24. point3** colors;
  25.  
  26. static GLfloat viewer[] = { 0.0, 0.0, 10.0 };
  27. // inicjalizacja położenia obserwatora
  28.  
  29. /*************************************************************************************/
  30.  
  31. // Funkcja rysująca osie układu wspó?rz?dnych
  32.  
  33.  
  34.  
  35. void Axes(void)
  36. {
  37.  
  38.     point3  x_min = { -5.0, 0.0, 0.0 };
  39.     point3  x_max = { 5.0, 0.0, 0.0 };
  40.     // pocz?tek i koniec obrazu osi x
  41.  
  42.     point3  y_min = { 0.0, -5.0, 0.0 };
  43.     point3  y_max = { 0.0, 5.0, 0.0 };
  44.     // pocz?tek i koniec obrazu osi y
  45.  
  46.     point3  z_min = { 0.0, 0.0, -5.0 };
  47.     point3  z_max = { 0.0, 0.0, 5.0 };
  48.     //  pocz?tek i koniec obrazu osi y
  49.  
  50.     glColor3f(1.0f, 0.0f, 0.0f);  // kolor rysowania osi - czerwony
  51.     glBegin(GL_LINES); // rysowanie osi x
  52.  
  53.     glVertex3fv(x_min);
  54.     glVertex3fv(x_max);
  55.  
  56.     glEnd();
  57.  
  58.     glColor3f(0.0f, 1.0f, 0.0f);  // kolor rysowania - zielony
  59.     glBegin(GL_LINES);  // rysowanie osi y
  60.  
  61.     glVertex3fv(y_min);
  62.     glVertex3fv(y_max);
  63.  
  64.     glEnd();
  65.  
  66.     glColor3f(0.0f, 0.0f, 1.0f);  // kolor rysowania - niebieski
  67.     glBegin(GL_LINES); // rysowanie osi z
  68.  
  69.     glVertex3fv(z_min);
  70.     glVertex3fv(z_max);
  71.  
  72.     glEnd();
  73.  
  74. }
  75.  
  76. /*************************************************************************************/
  77.  
  78. // Funkcja określająca co ma być rysowane (zawsze wywoływana, gdy trzeba
  79. // przerysować scenę)
  80.  
  81. void calculateNormalVector(point3& normalVector, GLfloat u, GLfloat v){
  82.     GLfloat Xu, Xv, Yu, Yv, Zu, Zv;
  83.  
  84.     Xu = cos(M_PI*v)*(-450 * pow(u, 4) + 900 * pow(u, 3) - 810 * pow(u, 2) +360 * u - 45);
  85.     Xv = M_PI*(90 * pow(u, 5) - 225 * pow(u, 4) + 270 * pow(u, 3) - 180 * pow(u, 2) + 45 * u)*sin(M_PI*v);
  86.     Yu = 640 * pow(u, 3) - 960 * pow(u, 2) + 320 * u;
  87.     Yv = 0;
  88.     Zu = sin(M_PI*v)*(-450 * pow(u, 4) + 900 * pow(u, 3) - 810 * pow(u, 2) + 360 * u - 45);
  89.     Zv = -M_PI*cos(M_PI*v)*(90 * pow(u, 5) - 225 * pow(u, 4) + 270 * pow(u, 3) - 180 * pow(u, 2) + 45 * u);
  90.  
  91.     normalVector[0] = Yu*Zv - Zu*Yv;
  92.     normalVector[1] = Zu*Xv - Xu*Zv;
  93.     normalVector[2] = Xu*Yv - Yu*Xv;
  94.  
  95.     GLfloat vectorLength = sqrt(pow(normalVector[0], 2) + pow(normalVector[1], 2) + pow(normalVector[2], 2));
  96.    
  97.     if (vectorLength != 0){
  98.         normalVector[0] = normalVector[0] / vectorLength;
  99.         normalVector[1] = normalVector[1] / vectorLength;
  100.         normalVector[2] = normalVector[2] / vectorLength;
  101.     }
  102.     else
  103.     {
  104.         normalVector[0] = 0;
  105.         normalVector[1] = 1;
  106.         normalVector[2] = 0;
  107.     }
  108.    
  109.    
  110. }
  111.  
  112. void Egg(GLint n)
  113. {
  114.     /*Tworzenie siatki dziedziny parametrycznej*/
  115.     point2** param = new point2*[n];
  116.  
  117.     for (int i = 0; i < n; i++)
  118.     {
  119.         param[i] = new point2[n];
  120.  
  121.         for (int k = 0; k < n; k++)
  122.         {
  123.             GLfloat u = (float)i / (n - 1);
  124.             GLfloat v = (float)k / (n - 1);
  125.  
  126.             param[i][k][0] = u;
  127.             param[i][k][1] = v;
  128.         }
  129.     }
  130.  
  131.     point3** egg_p = new point3*[n];
  132.     point3** normVec = new point3*[n];
  133.     for (int i = 0; i < n; i++)
  134.     {
  135.         egg_p[i] = new point3[n];
  136.         normVec[i] = new point3[n];
  137.         for (int k = 0; k < n; k++)
  138.         {
  139.             calculateNormalVector(normVec[i][k], param[i][k][0], param[i][k][1]);
  140.             egg_p[i][k][0] = (float)((-90 * pow(param[i][k][0], 5) + 225 * pow(param[i][k][0], 4) - 270 * pow(param[i][k][0], 3) + 180 * pow(param[i][k][0], 2) - 45 * param[i][k][0])*cos(M_PI*param[i][k][1]));
  141.             egg_p[i][k][1] = (float)(160 * pow(param[i][k][0], 4) - 320 * pow(param[i][k][0], 3) + 160 * pow(param[i][k][0], 2));
  142.             egg_p[i][k][2] = (float)((-90 * pow(param[i][k][0], 5) + 225 * pow(param[i][k][0], 4) - 270 * pow(param[i][k][0], 3) + 180 * pow(param[i][k][0], 2) - 45 * param[i][k][0])*sin(M_PI*param[i][k][1]));
  143.         }
  144.     }
  145.  
  146.     switch (model)
  147.     {
  148.     case PUNKTY:
  149.     {
  150.  
  151.         for (int i = 0; i < n; i++)
  152.             for (int k = 0; k < n; k++)
  153.             {
  154.                 glBegin(GL_POINTS);
  155.                 glColor3f(0.0f, 1.0f, 0.0f);
  156.                 glVertex3f(egg_p[i][k][0], egg_p[i][k][1] - 5.0f, egg_p[i][k][2]);
  157.                 glEnd();
  158.             }
  159.         break;
  160.     }
  161.  
  162.     case NET:
  163.     {
  164.         for (int i = 0; i < n - 1; i++) //Przechodzimy przez wszystkie poziomy jajka od dołu do góry
  165.             for (int k = 0; k < n - 1; k++) //Przechodzimy przez wszystkie punkty na jednym poziomie (piersćieniu)
  166.             {
  167.                 glBegin(GL_LINES); // Rysujemy poziome okręgi
  168.  
  169.                 glColor3f(0.0f, 0.0f, 0.85f);
  170.                 glVertex3f(egg_p[i][k][0], egg_p[i][k][1] - 5.0f, egg_p[i][k][2]);
  171.                 glVertex3f(egg_p[i][k + 1][0], egg_p[i][k + 1][1] - 5.0f, egg_p[i][k + 1][2]);
  172.                 glEnd();
  173.  
  174.                 glBegin(GL_LINES); //Rysujemy pionowe linie między poziomymi okręgami
  175.  
  176.                 glColor3f(0.0f, 0.0f, 0.85f);
  177.                 glVertex3f(egg_p[i][k][0], egg_p[i][k][1] - 5.0f, egg_p[i][k][2]);
  178.                 glVertex3f(egg_p[i + 1][k][0], egg_p[i + 1][k][1] - 5.0f, egg_p[i + 1][k][2]);
  179.                 glEnd();
  180.  
  181.                 glBegin(GL_LINES); //Rysujemy skośne linie między poziomymi okrgami
  182.  
  183.                 glColor3f(0.0f, 0.0f, 0.85f);
  184.                 glVertex3f(egg_p[i + 1][k][0], egg_p[i + 1][k][1] - 5.0f, egg_p[i + 1][k][2]);
  185.                 glVertex3f(egg_p[i][k + 1][0], egg_p[i][k + 1][1] - 5.0f, egg_p[i][k + 1][2]);
  186.                 glEnd();
  187.  
  188.             }
  189.         break;
  190.     }
  191.  
  192.     case TRIANGLES:
  193.     {
  194.         for (int i = 0; i < n - 1; i++)//Przechodzimy przez wszystkie poziomy jajka od dołu do góry
  195.         {
  196.             for (int k = 0; k < n - 1; k++) //Przechodzimy przez wszystkie punkty na jednym poziomie (piersćieniu)
  197.             {
  198.                     glBegin(GL_TRIANGLES);
  199.  
  200.                     //glColor3f(1.0f, 1.0f, 1.0f);
  201.                     glNormal3f(normVec[i][k][0], normVec[i][k][1], normVec[i][k][2]);
  202.                     //glColor3f(colors[i][k][0], colors[i][k][1], colors[i][k][2]);
  203.                     glVertex3f(egg_p[i][k][0], egg_p[i][k][1] - 5.0f, egg_p[i][k][2]);
  204.  
  205.                     //glColor3f(1.0f, 1.0f, 1.0f);
  206.                     glNormal3f(normVec[i][k+1][0], normVec[i][k+1][1], normVec[i][k+1][2]);
  207.                     //glColor3f(colors[i][k + 1][0], colors[i][k + 1][1], colors[i][k + 1][2]);
  208.                     glVertex3f(egg_p[i][k + 1][0], egg_p[i][k + 1][1] - 5.0f, egg_p[i][k + 1][2]);
  209.  
  210.                     //glColor3f(1.0f, 1.0f, 1.0f);
  211.                     glNormal3f(normVec[i+1][k][0], normVec[i+1][k][1], normVec[i+1][k][2]);
  212.                     //glColor3f(colors[i + 1][k][0], colors[i + 1][k][1], colors[i + 1][k][2]);
  213.                     glVertex3f(egg_p[i + 1][k][0], egg_p[i + 1][k][1] - 5.0f, egg_p[i + 1][k][2]);
  214.  
  215.                     glEnd();
  216.  
  217.                     glBegin(GL_TRIANGLES);
  218.  
  219.                     //glColor3f(1.0f, 1.0f, 1.0f);
  220.                     glNormal3f(normVec[i][k+1][0], normVec[i][k+1][1], normVec[i][k+1][2]);
  221.                     //glColor3f(colors[i][k + 1][0], colors[i][k + 1][1], colors[i][k + 1][2]);
  222.                     glVertex3f(egg_p[i][k + 1][0], egg_p[i][k + 1][1] - 5.0f, egg_p[i][k + 1][2]);
  223.  
  224.                     //glColor3f(1.0f, 1.0f, 1.0f);
  225.                     glNormal3f(normVec[i+1][k+1][0], normVec[i+1][k+1][1], normVec[i+1][k+1][2]);
  226.                     //glColor3f(colors[i + 1][k + 1][0], colors[i + 1][k + 1][1], colors[i + 1][k + 1][2]);
  227.                     glVertex3f(egg_p[i + 1][k + 1][0], egg_p[i + 1][k + 1][1] - 5.0f, egg_p[i + 1][k + 1][2]);
  228.  
  229.                     //glColor3f(1.0f, 1.0f, 1.0f);
  230.                     glNormal3f(normVec[i + 1][k][0], normVec[i + 1][k][1], normVec[i + 1][k][2]);
  231.                     //glColor3f(colors[i + 1][k][0], colors[i + 1][k][1], colors[i + 1][k][2]);
  232.                     glVertex3f(egg_p[i + 1][k][0], egg_p[i + 1][k][1] - 5.0f, egg_p[i + 1][k][2]);
  233.  
  234.                     glEnd();
  235.            
  236.             }
  237.         }
  238.  
  239.         break;
  240.     }
  241.     }
  242. }
  243.  
  244.  
  245. void RenderScene(void)
  246. {
  247.  
  248.     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  249.     // Czyszczenie okna aktualnym kolorem czyszczącym
  250.  
  251.     glLoadIdentity();
  252.     // Czyszczenie macierzy bie??cej
  253.  
  254.     gluLookAt(viewer[0], viewer[1], viewer[2], 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
  255.     // Zdefiniowanie położenia obserwatora
  256.  
  257.     Axes();
  258.     // Narysowanie osi przy pomocy funkcji zdefiniowanej powyżej
  259.  
  260.  
  261.     glColor3f(1.0f, 1.0f, 1.0f);
  262.     // Ustawienie koloru rysowania na biały
  263.  
  264.     Egg(N);
  265.     //glutSolidTeapot(3.0);
  266.     // Narysowanie czajnika
  267.  
  268.     glFlush();
  269.     // Przekazanie poleceń rysujących do wykonania
  270.  
  271.     glutSwapBuffers();
  272.  
  273.  
  274.  
  275. }
  276. /*************************************************************************************/
  277.  
  278. // Funkcja ustalająca stan renderowania
  279.  
  280. void keys(unsigned char key, int x, int y)
  281. {
  282.     //if (key == 'p') model = POINTS;
  283.     //if (key == 'w') model = NET;
  284.     //if (key == 's') model = TRIANGLES;
  285.     if (key == '+')
  286.     {
  287.         N += 5;
  288.         delete[] colors;
  289.         colors = new point3*[N];
  290.  
  291.         for (int i = 0; i < N; i++)
  292.         {
  293.             colors[i] = new point3[N];
  294.  
  295.             for (int k = 0; k < N; k++)
  296.             {
  297.                 colors[i][k][0] = (float)(rand() % 1001) / 1000;
  298.                 colors[i][k][1] = (float)(rand() % 1001) / 1000;
  299.                 colors[i][k][2] = (float)(rand() % 1001) / 1000;
  300.             }
  301.         }
  302.     }
  303.  
  304.     if (key == '-' && N >= 10)
  305.     {
  306.         N = N - 5;
  307.         delete[] colors;
  308.         colors = new point3*[N];
  309.  
  310.         for (int i = 0; i < N; i++)
  311.         {
  312.             colors[i] = new point3[N];
  313.  
  314.             for (int k = 0; k < N; k++)
  315.             {
  316.                 colors[i][k][0] = (float)(rand() % 1001) / 1000;
  317.                 colors[i][k][1] = (float)(rand() % 1001) / 1000;
  318.                 colors[i][k][2] = (float)(rand() % 1001) / 1000;
  319.             }
  320.         }
  321.     }
  322.     RenderScene(); // przerysowanie obrazu sceny
  323. }
  324.  
  325. void MyInit(void)
  326. {
  327.  
  328.     glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
  329.     // Kolor czyszczący (wypełnienia okna) ustawiono na czarny
  330.     /*************************************************************************************/
  331.  
  332.     //  Definicja materiału z jakiego zrobiony jest czajnik
  333.     //  i definicja źródła światła
  334.  
  335.     /*************************************************************************************/
  336.  
  337.  
  338.     /*************************************************************************************/
  339.     // Definicja materiału z jakiego zrobiony jest czajnik
  340.  
  341.     GLfloat mat_ambient[] = { 1.0, 1.0, 1.0, 1.0 };
  342.     // współczynniki ka =[kar,kag,kab] dla światła otoczenia
  343.  
  344.     GLfloat mat_diffuse[] = { 1.0, 1.0, 1.0, 1.0 };
  345.     // współczynniki kd =[kdr,kdg,kdb] światła rozproszonego
  346.  
  347.     GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 };
  348.     // współczynniki ks =[ksr,ksg,ksb] dla światła odbitego              
  349.  
  350.     GLfloat mat_shininess = { 20.0 };
  351.     // współczynnik n opisujący połysk powierzchni
  352.  
  353.     /*************************************************************************************/
  354.     // Definicja źródła światła
  355.  
  356.     GLfloat light_position[] = { 0.0, 0.0, 10.0, 1.0 };
  357.     // położenie źródła
  358.  
  359.  
  360.     GLfloat light_ambient[] = { 0.1, 0.1, 0.1, 1.0 };
  361.     // składowe intensywności świecenia źródła światła otoczenia
  362.     // Ia = [Iar,Iag,Iab]
  363.  
  364.     GLfloat light_diffuse[] = { 1.0, 1.0, 1.0, 1.0 };
  365.     // składowe intensywności świecenia źródła światła powodującego
  366.     // odbicie dyfuzyjne Id = [Idr,Idg,Idb]
  367.  
  368.     GLfloat light_specular[] = { 1.0, 1.0, 1.0, 1.0 };
  369.     // składowe intensywności świecenia źródła światła powodującego
  370.     // odbicie kierunkowe Is = [Isr,Isg,Isb]
  371.  
  372.     GLfloat att_constant = { 1.0 };
  373.     // składowa stała ds dla modelu zmian oświetlenia w funkcji
  374.     // odległości od źródła
  375.  
  376.     GLfloat att_linear = { (GLfloat)0.05 };
  377.     // składowa liniowa dl dla modelu zmian oświetlenia w funkcji
  378.     // odległości od źródła
  379.  
  380.     GLfloat att_quadratic = { (GLfloat)0.001 };
  381.     // składowa kwadratowa dq dla modelu zmian oświetlenia w funkcji
  382.     // odległości od źródła
  383.  
  384.     /*************************************************************************************/
  385.     // Ustawienie parametrów materiału i źródła światła
  386.  
  387.     /*************************************************************************************/
  388.     // Ustawienie patrametrów materiału
  389.  
  390.  
  391.     glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
  392.     glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient);
  393.     glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
  394.     glMaterialf(GL_FRONT, GL_SHININESS, mat_shininess);
  395.  
  396.     /*************************************************************************************/
  397.     // Ustawienie parametrów źródła
  398.  
  399.     glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient);
  400.     glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);
  401.     glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular);
  402.     glLightfv(GL_LIGHT0, GL_POSITION, light_position);
  403.  
  404.     glLightf(GL_LIGHT0, GL_CONSTANT_ATTENUATION, att_constant);
  405.     glLightf(GL_LIGHT0, GL_LINEAR_ATTENUATION, att_linear);
  406.     glLightf(GL_LIGHT0, GL_QUADRATIC_ATTENUATION, att_quadratic);
  407.  
  408.  
  409.     /*************************************************************************************/
  410.     // Ustawienie opcji systemu oświetlania sceny
  411.  
  412.     glShadeModel(GL_SMOOTH); // właczenie łagodnego cieniowania
  413.     glEnable(GL_LIGHTING);   // właczenie systemu oświetlenia sceny
  414.     glEnable(GL_LIGHT0);     // włączenie źródła o numerze 0
  415.     glEnable(GL_DEPTH_TEST); // włączenie mechanizmu z-bufora
  416.  
  417.     /*************************************************************************************/
  418.  
  419. }
  420.  
  421. /*************************************************************************************/
  422.  
  423. // Funkcja ma za zadanie utrzymanie stałych proporcji rysowanych
  424. // w przypadku zmiany rozmiarów okna.
  425. // Parametry vertical i horizontal (wysokość i szerokość okna) są
  426. // przekazywane do funkcji za każdym razem gdy zmieni się rozmiar okna.
  427.  
  428.  
  429.  
  430. void ChangeSize(GLsizei horizontal, GLsizei vertical)
  431. {
  432.  
  433.     glMatrixMode(GL_PROJECTION);
  434.     // Przełączenie macierzy bieżącej na macierz projekcji
  435.  
  436.     glLoadIdentity();
  437.     // Czyszcznie macierzy bieżącej
  438.  
  439.     gluPerspective(70, 1.0, 1.0, 30.0);
  440.     // Ustawienie parametrów dla rzutu perspektywicznego
  441.  
  442.  
  443.     if (horizontal <= vertical)
  444.         glViewport(0, (vertical - horizontal) / 2, horizontal, horizontal);
  445.  
  446.     else
  447.         glViewport((horizontal - vertical) / 2, 0, vertical, vertical);
  448.     // Ustawienie wielkości okna okna widoku (viewport) w zależności
  449.     // relacji pomiędzy wysokością i szerokością okna
  450.  
  451.     glMatrixMode(GL_MODELVIEW);
  452.     // Przełączenie macierzy bieżącej na macierz widoku modelu  
  453.  
  454.     glLoadIdentity();
  455.     // Czyszczenie macierzy bieżącej
  456.  
  457. }
  458.  
  459. /*************************************************************************************/
  460.  
  461. // Główny punkt wejścia programu. Program działa w trybie konsoli
  462.  
  463.  
  464.  
  465. void main(void)
  466. {
  467.  
  468.     glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
  469.  
  470.     glutInitWindowSize(300, 300);
  471.  
  472.     glutCreateWindow("Rzutowanie perspektywiczne");
  473.  
  474.     glutDisplayFunc(RenderScene);
  475.     // Określenie, że funkcja RenderScene będzie funkcją zwrotną
  476.     // (callback function).  Będzie ona wywoływana za każdym razem
  477.     // gdy zajdzie potrzeba przerysowania okna
  478.  
  479.     glutKeyboardFunc(keys);
  480.  
  481.     glutReshapeFunc(ChangeSize);
  482.     // Dla aktualnego okna ustala funkcję zwrotną odpowiedzialną
  483.     // za zmiany rozmiaru okna                      
  484.  
  485.  
  486.  
  487.     MyInit();
  488.     // Funkcja MyInit() (zdefiniowana powyżej) wykonuje wszelkie
  489.     // inicjalizacje konieczne  przed przystąpieniem do renderowania
  490.  
  491.     glEnable(GL_DEPTH_TEST);
  492.     // Włączenie mechanizmu usuwania niewidocznych elementów sceny
  493.  
  494.     glutMainLoop();
  495.     // Funkcja uruchamia szkielet biblioteki GLUT
  496.  
  497. }
  498.  
  499. /*************************************************************************************/
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!