API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Nov 26th, 2014
139
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 32.07 KB | None | 0 0
raw download clone embed print report
  1. /**
  2. * GRAFIKA KOMPUTEROWA I KOMUNIKACJA CZLOWIEK-KOMPUTER
  3. * Cwiczenie 5 - oświetlanie scen 3D (5.1 - oświetlone, ruchome jajko)
  4. *
  5. * Sterowanie:
  6. *   PPM + ruch - zoom
  7. *
  8. * Autor:    Michał Kaczara 181132
  9. * Data:     12/01/12
  10. **/
  11.  
  12. //Zalaczenie plikow naglowkowych
  13. #include <windows.h>
  14. #include <gl/gl.h>
  15. #include <gl/glut.h>
  16. #include <math.h>
  17. #include <time.h>
  18.  
  19. //Definicja typu point3 - punkt w przestrzeni 3D
  20. typedef float point3[3];
  21.  
  22. //Stala PI
  23. const float PI = 3.14159265;
  24. //Tablica na punkty
  25. point3 **pointsTab;
  26. //Tablica na wektory normalne
  27. point3 **pointsNorms;
  28.  
  29. static GLfloat viewer[]= {0.0, 0.0, 10.0};
  30. // inicjalizacja położenia obserwatora
  31.  
  32. static GLfloat  fi = 0.0,           // kąty obrotu, elewacja i azymut
  33.                 theta = 0.0;
  34. static GLfloat  pix2angle_x = 0.0,  // przelicznik pikseli na stopnie
  35.                 pix2angle_y = 0.0;
  36. static GLint    status = 0;         // stan klawiszy myszy
  37.                                     // 0 - nie naciśnięto żadnego klawisza
  38.                                     // 1 - naciśnięty został lewy klawisz, 2 - prawy
  39. static int  x_pos_old = 0,          // poprzednia pozycja kursora myszy
  40.             y_pos_old = 0;
  41. static int  delta_x = 0,            // różnica pomiędzy pozycją bieżącą
  42.             delta_y = 0;            // i poprzednią kursora myszy
  43.  
  44. //Parametry programu
  45. int N = 50;             //Liczba punktow na jaka dzielimy kwadrat jednostkowy
  46. float verLength = 1.0;  //Dlugosc boku kwadratu
  47. float viewerR = 10.0;   //Promien sfery obserwatora
  48.  
  49. //Tablica katow obrotu
  50. static GLfloat angle[] = {0.0, 0.0, 0.0};
  51.  
  52. //Funkcja wyliczajaca wspolrzedna X punktu (u,v) w przestrzeni 3D
  53. float calc3Dx(float u, float v) {
  54.     float x, a = v*PI;
  55.  
  56.     x = (-90*pow(u, 5) +225*pow(u, 4) -270*pow(u, 3) +180*pow(u, 2) -45*u) * cos(a);
  57.     return x;
  58. }
  59.  
  60. //Funkcja wyliczajaca wspolrzedna Y punktu (u,v) w przestrzeni 3D
  61. float calc3Dy(float u, float v) {
  62.     float y;
  63.  
  64.     y = 160*pow(u, 4) -320*pow(u, 3) +160*pow(u, 2);
  65.     return y - 5;
  66. }
  67.  
  68. //Funkcja wyliczajaca wspolrzedna Z punktu (u,v) w przestrzeni 3D
  69. float calc3Dz(float u, float v) {
  70.     float z, a = v*PI;
  71.  
  72.     z = (-90*pow(u, 5) +225*pow(u, 4) -270*pow(u, 3) +180*pow(u, 2) -45*u) * sin(a);
  73.     return z;
  74. }
  75.  
  76. //Obliczenie wspolrzednej X wektora normalnego do powierzchni w punkcie
  77. float calcNormX(float u, float v) {
  78.     float x, a = v*PI;
  79.  
  80.     float yu = 640*pow(u, 3) - 960*pow(u, 2) + 320*u;
  81.     float yv = 0;
  82.     float zu = (-450*pow(u, 4) + 900*pow(u, 3) - 810*pow(u, 2) + 360*u - 45)*sin(a);
  83.     float zv = -PI*(90*pow(u, 5) - 225*pow(u, 4) + 270*pow(u, 3) - 180*pow(u, 2) + 45*u)*cos(a);
  84.  
  85.     x = (GLfloat)(yu*zv - zu*yv);
  86.     return x;
  87. }
  88.  
  89. //Obliczenie wspolrzednej Y wektora normalnego do powierzchni w punkcie
  90. float calcNormY(float u, float v) {
  91.     float y, a = v*PI;
  92.  
  93.     float xu = (-450*pow(u, 4) + 900*pow(u, 3) - 810*pow(u, 2) + 360*u - 45)*cos(a);
  94.     float xv = PI*(90*pow(u, 5) - 225*pow(u, 4) + 270*pow(u, 3) - 180*pow(u, 2) + 45*u)*sin(a);
  95.     float zu = (-450*pow(u, 4) + 900*pow(u, 3) - 810*pow(u, 2) + 360*u - 45)*sin(a);
  96.     float zv = -PI*(90*pow(u, 5) - 225*pow(u, 4) + 270*pow(u, 3) - 180*pow(u, 2) + 45*u)*cos(a);
  97.  
  98.     y = (GLfloat)(zu*xv - xu*zv);
  99.     return y;
  100. }
  101.  
  102. //Obliczenie wspolrzednej Z wektora normalnego do powierzchni w punkcie
  103. float calcNormZ(float u, float v) {
  104.     float z, a = v*PI;
  105.  
  106.     float xu = (-450*pow(u, 4) + 900*pow(u, 3) - 810*pow(u, 2) + 360*u - 45)*cos(a);
  107.     float xv = PI*(90*pow(u, 5) - 225*pow(u, 4) + 270*pow(u, 3) - 180*pow(u, 2) + 45*u)*sin(a);
  108.     float yu = 640*pow(u, 3) - 960*pow(u, 2) + 320*u;
  109.     float yv = 0;
  110.  
  111.     z = (GLfloat)(xu*yv - yu*xv);
  112.     return z;
  113. }
  114.  
  115. //Funkcja generujaca siatke puntow, najpierw w 2D, potem w 3D
  116. void genPointsMesh(){
  117.     float stepXY = verLength/N;
  118.  
  119.     //Przypisanie punktom wspolrzednych
  120.     for (int i=0; i<N+1; i++) {
  121.         for (int j=0; j<N+1; j++) {
  122.             pointsTab[i][j][0]= j*stepXY;
  123.             pointsTab[i][j][1]= i*stepXY;
  124.         }
  125.     }
  126.  
  127.     //Przeksztalcenie wspolrzednych z dziedziny parametrycznej
  128.     //w przestrzen 3D
  129.     float u,v;
  130.     for (int i=0; i<N+1; i++) {
  131.         for (int j=0; j<N+1; j++) {
  132.             v = pointsTab[i][j][0];
  133.             u = pointsTab[i][j][1];
  134.             pointsTab[i][j][0] = calc3Dx(u, v);
  135.             pointsTab[i][j][1] = calc3Dy(u, v);
  136.             pointsTab[i][j][2] = calc3Dz(u, v);
  137.  
  138.             //Wyliczenie wspolrzednych wektorow normalnych do powierzchni jajka
  139.             float x = calcNormX(u, v);
  140.             float y = calcNormY(u, v);
  141.             float z = calcNormZ(u, v);
  142.  
  143.             //Normalizacja wektorow normalnych do powierzchni jajka
  144.             //Wektory na bokach jajka
  145.             if(i < N/2){
  146.                 pointsNorms[i][j][0] = x / (float)sqrt(pow(x, 2) + pow(y, 2) + pow(z, 2));
  147.                 pointsNorms[i][j][1] = y / (float)sqrt(pow(x, 2) + pow(y, 2) + pow(z, 2));
  148.                 pointsNorms[i][j][2] = z / (float)sqrt(pow(x, 2) + pow(y, 2) + pow(z, 2));
  149.             }
  150.             if(i > N/2){
  151.                 pointsNorms[i][j][0] = -1.0*x / (float)sqrt(pow(x, 2) + pow(y, 2) + pow(z, 2));
  152.                 pointsNorms[i][j][1] = -1.0*y / (float)sqrt(pow(x, 2) + pow(y, 2) + pow(z, 2));
  153.                 pointsNorms[i][j][2] = -1.0*z / (float)sqrt(pow(x, 2) + pow(y, 2) + pow(z, 2));
  154.             }
  155.             //Wektory na "szczycie" jajka
  156.             if(i == N/2){
  157.                 pointsNorms[i][j][0]=0;
  158.                 pointsNorms[i][j][1]=1;
  159.                 pointsNorms[i][j][2]=0;
  160.             }
  161.             //Wektory na "dnie" jajka
  162.             if (i==0 || i==N)
  163.             {
  164.                 pointsNorms[i][j][0]=0;
  165.                 pointsNorms[i][j][1]=-1;
  166.                 pointsNorms[i][j][2]=0;
  167.             }
  168.         }
  169.     }
  170. }
  171.  
  172. //Funkcja renderujaca okreslony model jajka
  173. void Egg(void){
  174.     //Wygenerowanie siatki 3D punktow
  175.     genPointsMesh();
  176.  
  177.     //Parametry rysowania
  178.     glColor3f(1.0, 1.0, 1.0);
  179.  
  180.     //Rysowanie jajka - trojkaty
  181.     for(int i=0; i < N; i++){
  182.         for(int j=0; j < N; j++){
  183.             //W jedna strone
  184.             glBegin(GL_TRIANGLES);
  185.                 glNormal3fv(pointsNorms[i][j+1]);
  186.                 glVertex3fv(pointsTab[i][j+1]);
  187.                 glNormal3fv(pointsNorms[i+1][j]);
  188.                 glVertex3fv(pointsTab[i+1][j]);
  189.                 glNormal3fv(pointsNorms[i+1][j+1]);
  190.                 glVertex3fv(pointsTab[i+1][j+1]);
  191.             glEnd();
  192.             //W druga strone
  193.             glBegin(GL_TRIANGLES);
  194.                 glNormal3fv(pointsNorms[i][j]);
  195.                 glVertex3fv(pointsTab[i][j]);
  196.                 glNormal3fv(pointsNorms[i+1][j]);
  197.                 glVertex3fv(pointsTab[i+1][j]);
  198.                 glNormal3fv(pointsNorms[i][j+1]);
  199.                 glVertex3fv(pointsTab[i][j+1]);
  200.             glEnd();
  201.         }
  202.     }
  203. }
  204.  
  205. // Funkcja rysująca osie układu współrzędnych
  206. void Axes(void)
  207. {
  208.     point3  x_min = {-2.0, 0.0, 0.0};
  209.     point3  x_max = { 2.0, 0.0, 0.0};
  210.     // początek i koniec obrazu osi x
  211.  
  212.     point3  y_min = {0.0, -2.0, 0.0};
  213.     point3  y_max = {0.0,  2.0, 0.0};
  214.     // początek i koniec obrazu osi y
  215.  
  216.     point3  z_min = {0.0, 0.0, -2.0};
  217.     point3  z_max = {0.0, 0.0,  2.0};
  218.     //  początek i koniec obrazu osi y
  219.  
  220.     glColor3f(1.0f, 0.0f, 0.0f);  // kolor rysowania osi - czerwony
  221.     glBegin(GL_LINES); // rysowanie osi x
  222.         glVertex3fv(x_min);
  223.         glVertex3fv(x_max);
  224.     glEnd();
  225.  
  226.     glColor3f(0.0f, 1.0f, 0.0f);  // kolor rysowania - zielony
  227.     glBegin(GL_LINES);  // rysowanie osi y
  228.         glVertex3fv(y_min);
  229.         glVertex3fv(y_max);                          
  230.     glEnd();
  231.  
  232.     glColor3f(0.0f, 0.0f, 1.0f);  // kolor rysowania - niebieski
  233.     glBegin(GL_LINES); // rysowanie osi z
  234.         glVertex3fv(z_min);
  235.         glVertex3fv(z_max);
  236.     glEnd();
  237. }
  238.  
  239.  
  240. // Funkcja określająca co ma być rysowane (zawsze wywoływana gdy trzeba
  241. // przerysować scenę)
  242. void RenderScene(void)
  243. {
  244.     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  245.     // Czyszczenie okna aktualnym kolorem czyszczącym
  246.     glLoadIdentity();
  247.     // Czyszczenie macierzy bieżącej
  248.  
  249.     if(status == 2) {   // jeśli prawy klawisz myszy wciśnięty
  250.         viewerR +=0.1* delta_y; // modyfikacja polozenia obserwatora(zoom)
  251.         if(viewerR <= 6.0)  // ograniczenie zblizenia
  252.             viewerR = 6.0;
  253.         if(viewerR >= 25.0) // ograniczenie oddalenia
  254.             viewerR = 25.0;
  255.     }
  256.  
  257.     //Wspolrzedne obserwatora - wzorki z ZSK
  258.     viewer[0] = viewerR * cos(theta) * cos(fi);
  259.     viewer[1] = viewerR * sin(fi);
  260.     viewer[2] = viewerR * sin(theta) * cos(fi);
  261.  
  262.     gluLookAt(viewer[0],viewer[1],viewer[2], 0.0, 0.0, 0.0, 0.0, cos(fi), 0.0);
  263.     // Zdefiniowanie położenia obserwatora
  264.  
  265.     Axes();
  266.     // Narysowanie osi przy pomocy funkcji zdefiniowanej powyżej
  267.  
  268.     //Rotacje
  269.     glRotatef(angle[0], 1.0, 0.0, 0.0);
  270.     glRotatef(angle[1], 0.0, 1.0, 0.0);
  271.     glRotatef(angle[2], 0.0, 0.0, 1.0);
  272.  
  273.     //Renderowanie jajka
  274.     Egg();
  275.  
  276.     glFlush();
  277.     // Przekazanie poleceń rysujących do wykonania
  278.  
  279.     glutSwapBuffers();
  280.  }
  281.  
  282. //Funkcja callback dla obrotu
  283. void spinEgg()
  284. {
  285.  
  286.     angle[0] -= 0.5;
  287.     if( angle[0] > 360.0 ) angle[0] -= 360.0;
  288.     angle[1] -= 0.5;
  289.     if( angle[1] > 360.0 ) angle[1] -= 360.0;
  290.     angle[2] -= 0.5;
  291.     if( angle[2] > 360.0 ) angle[2] -= 360.0;
  292.  
  293.     glutPostRedisplay(); //odświeżenie zawartości aktualnego okna
  294. }
  295.  
  296. // Funkcja ustalająca stan renderowania
  297. void MyInit(void)
  298. {
  299.     glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
  300.     // Kolor czyszcący (wypełnienia okna) ustawiono na czarny
  301.  
  302.     // Definicja materiału z jakiego zrobiony jest przedmiot
  303.     //-------------------------------------------------------
  304.     GLfloat mat_ambient[]  = {1.0, 1.0, 1.0, 1.0};        
  305.     // współczynniki ka =[kar,kag,kab] dla światła otoczenia
  306.  
  307.     GLfloat mat_diffuse[]  = {1.0, 1.0, 1.0, 1.0};
  308.     // współczynniki kd =[kdr,kdg,kdb] światła rozproszonego
  309.  
  310.     GLfloat mat_specular[] = {1.0, 1.0, 1.0, 1.0};
  311.     // współczynniki ks =[ksr,ksg,ksb] dla światła odbitego                
  312.    
  313.     GLfloat mat_shininess  = {100.0};
  314.     // współczynnik n opisujący połysk powierzchni
  315.  
  316.  
  317.     // Definicja źródła światła
  318.     //-------------------------------------------------------
  319.     GLfloat light_position[] = {5.0, 5.0, 10.0, 1.0};        
  320.     // położenie źródła
  321.  
  322.     GLfloat light_ambient[] = {0.1, 0.1, 0.1, 1.0};
  323.     // składowe intensywności świecenia źródła światła otoczenia
  324.     // Ia = [Iar,Iag,Iab]
  325.  
  326.     GLfloat light_diffuse[] = {1.0, 1.0, 0.0, 1.0};
  327.     // składowe intensywności świecenia źródła światła powodującego
  328.     // odbicie dyfuzyjne Id = [Idr,Idg,Idb]
  329.  
  330.     GLfloat light_specular[]= {1.0, 1.0, 1.0, 1.0};
  331.     // składowe intensywności świecenia źródła światła powodującego
  332.     // odbicie kierunkowe Is = [Isr,Isg,Isb]
  333.  
  334.     GLfloat att_constant  = {1.0};
  335.     // składowa stała ds dla modelu zmian oświetlenia w funkcji
  336.     // odległości od źródła
  337.  
  338.     GLfloat att_linear    = {0.05};
  339.     // składowa liniowa dl dla modelu zmian oświetlenia w funkcji
  340.     // odległości od źródła
  341.  
  342.     GLfloat att_quadratic  = {0.001};
  343.     // składowa kwadratowa dq dla modelu zmian oświetlenia w funkcji
  344.     // odległości od źródła
  345.  
  346.     // Ustawienie patrametrów materiału
  347.     //-------------------------------------------------------
  348.     glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
  349.     glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient);
  350.     glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
  351.     glMaterialf(GL_FRONT, GL_SHININESS, mat_shininess);
  352.  
  353.     // Ustawienie parametrów źródła światła
  354.     //-------------------------------------------------------
  355.     glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient);
  356.     glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);
  357.     glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular);
  358.     glLightfv(GL_LIGHT0, GL_POSITION, light_position);
  359.  
  360.     glLightf(GL_LIGHT0, GL_CONSTANT_ATTENUATION, att_constant);
  361.     glLightf(GL_LIGHT0, GL_LINEAR_ATTENUATION, att_linear);
  362.     glLightf(GL_LIGHT0, GL_QUADRATIC_ATTENUATION, att_quadratic);
  363.  
  364.     // Ustawienie opcji systemu oświetlania sceny
  365.     //-------------------------------------------------------
  366.     glShadeModel(GL_SMOOTH); // właczenie łagodnego cieniowania
  367.     glEnable(GL_LIGHTING);   // właczenie systemu oświetlenia sceny
  368.     glEnable(GL_LIGHT0);     // włączenie źródła o numerze 0
  369.     glEnable(GL_DEPTH_TEST); // włączenie mechanizmu z-bufora
  370. }
  371.  
  372.  
  373. // Funkcja ma za zadanie utrzymanie stałych proporcji rysowanych
  374. // w przypadku zmiany rozmiarów okna.
  375. // Parametry vertical i horizontal (wysokość i szerokość okna) są
  376. // przekazywane do funkcji za każdym razem gdy zmieni się rozmiar okna.
  377. void ChangeSize(GLsizei horizontal, GLsizei vertical) {
  378.     pix2angle_x = 360.0*0.1/(float)horizontal; // przeliczenie pikseli na stopnie
  379.     pix2angle_y = 360.0*0.1/(float)vertical;
  380.  
  381.     glMatrixMode(GL_PROJECTION);
  382.     // Przełączenie macierzy bieżącej na macierz projekcji
  383.  
  384.     glLoadIdentity();
  385.     // Czyszcznie macierzy bieżącej
  386.  
  387.     gluPerspective(70.0, 1.0, 1.0, 30.0);
  388.     // Ustawienie parametrów dla rzutu perspektywicznego
  389.  
  390.     if(horizontal <= vertical)
  391.         glViewport(0, (vertical-horizontal)/2, horizontal, horizontal);
  392.     else
  393.         glViewport((horizontal-vertical)/2, 0, vertical, vertical);
  394.     // Ustawienie wielkości okna okna widoku (viewport) w zależności
  395.     // relacji pomiędzy wysokością i szerokością okna
  396.  
  397.     glMatrixMode(GL_MODELVIEW);
  398.     // Przełączenie macierzy bieżącej na macierz widoku modelu  
  399.  
  400.     glLoadIdentity();
  401.     // Czyszczenie macierzy bieżącej
  402. }
  403.  
  404. // Funkcja "bada" stan myszy i ustawia wartosci odpowiednich zmiennych globalnych
  405. void Mouse(int btn, int state, int x, int y) {
  406.     if(btn == GLUT_RIGHT_BUTTON && state == GLUT_DOWN) {
  407.         y_pos_old = y;      // przypisanie aktualnie odczytanej pozycji kursora
  408.                             // jako pozycji poprzedniej
  409.         status = 2;         //wciśnięty został prawy klawisz myszy
  410.     }
  411.     else
  412.         status = 0;         // nie został wciśnięty żaden klawisz
  413. }
  414.  
  415. // Funkcja "monitoruje" polozenie kursora myszy i ustawia wartosci odpowiednich
  416. // zmiennych globalnych
  417. void Motion(GLsizei x, GLsizei y) {  
  418.     delta_x = x - x_pos_old;    // obliczenie różnicy położenia kursora myszy
  419.     x_pos_old = x;  // podstawienie bieżacego położenia jako poprzednie
  420.  
  421.     delta_y = y - y_pos_old;    // obliczenie różnicy położenia kursora myszy
  422.     y_pos_old = y;  // podstawienie bieżacego położenia jako poprzednie
  423.  
  424.     glutPostRedisplay();    // przerysowanie obrazu sceny
  425. }
  426.  
  427. // Główny punkt wejścia programu. Program działa w trybie konsoli
  428. void main(void)
  429. {          
  430.     //Ziarno losowosci
  431.     srand((unsigned) time(NULL));
  432.  
  433.     //Dynamiczna alokacja tablicy punktow
  434.     pointsTab = new point3*[N+1];
  435.     for (int i=0; i<N+1;i++){
  436.         pointsTab[i] = new point3[N+1];
  437.     }
  438.  
  439.     //Dynamiczna alokacja tablicy i wygenerowanie kolorow losowych dla punktow
  440.     pointsNorms = new point3*[N+1];
  441.     for(int i=0; i < N+1; i++){
  442.         pointsNorms[i] = new point3[N+1];
  443.     }
  444.  
  445.     glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
  446.  
  447.     glutInitWindowSize(800, 600);
  448.  
  449.     glutCreateWindow("Oswietlone, ruchome jajko");
  450.                
  451.     glutDisplayFunc(RenderScene);
  452.     // Określenie, że funkcja RenderScene będzie funkcją zwrotną
  453.     // (callback function).  Bedzie ona wywoływana za każdym razem
  454.     // gdy zajdzie potrzba przeryswania okna
  455.  
  456.     // Dla aktualnego okna ustala funkcję zwrotną odpowiedzialną
  457.     // zazmiany rozmiaru okna  
  458.     glutReshapeFunc(ChangeSize);                    
  459.  
  460.     MyInit();
  461.     // Funkcja MyInit() (zdefiniowana powyżej) wykonuje wszelkie
  462.     // inicjalizacje konieczne  przed przystąpieniem do renderowania
  463.  
  464.     // Włączenie mechanizmu usuwania powierzchni niewidocznych
  465.     glutMouseFunc(Mouse);
  466.     // Ustala funkcję zwrotną odpowiedzialną za badanie stanu myszy
  467.    
  468.     glutMotionFunc(Motion);
  469.     // Ustala funkcję zwrotną odpowiedzialną za badanie ruchu myszy
  470.  
  471.     //Rejestracja funkcji zwrotnej (obrot)
  472.     glutIdleFunc(spinEgg);
  473.  
  474.     glutMainLoop();
  475.     // Funkcja uruchamia szkielet biblioteki GLUT
  476.  
  477.     //Zwolnienie pamięci
  478.     for(int i=0; i < N+1; i++){
  479.         delete[] pointsTab[i];
  480.         delete[] pointsNorms[i];
  481.         pointsTab[i] = 0;
  482.         pointsNorms[i] = 0;
  483.     }
  484.     delete[] pointsTab;
  485.     delete[] pointsNorms;
  486.     pointsTab = 0;
  487.     pointsNorms = 0;
  488. }
  489.  
  490. ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo
  491. /**
  492. * GRAFIKA KOMPUTEROWA I KOMUNIKACJA CZLOWIEK-KOMPUTER
  493. * Cwiczenie 5 - oświetlanie scen 3D (5.2 - oświetlone jajko, dwa źródła światła)
  494. *
  495. * Sterowanie:
  496. *   LPM + ruch - swiatlo zolte
  497. *   PPM + ruch - swiatlo niebieskie
  498. *
  499. * Autor:    Michał Kaczara 181132
  500. * Data:     12/01/12
  501. **/
  502.  
  503. //Zalaczenie plikow naglowkowych
  504. #include <windows.h>
  505. #include <gl/gl.h>
  506. #include <gl/glut.h>
  507. #include <math.h>
  508. #include <time.h>
  509.  
  510. //Definicja typu point3 - punkt w przestrzeni 3D
  511. typedef float point3[3];
  512.  
  513. //Stala PI
  514. const float PI = 3.14159265;
  515. //Tablica na punkty
  516. point3 **pointsTab;
  517. //Tablica na wektory normalne
  518. point3 **pointsNorms;
  519.  
  520. static GLfloat  fi[2] = {5.76, 1.05},// kąty obrotu, elewacja i azymut
  521.                 theta[2] = {4.68, 4.68};
  522. static GLfloat  pix2angle_x = 0.0,      // przelicznik pikseli na stopnie
  523.                 pix2angle_y = 0.0;
  524. static GLint    status = 0;             // stan klawiszy myszy
  525.                                         // 0 - nie naciśnięto żadnego klawisza
  526.                                         // 1 - naciśnięty został lewy klawisz, 2 - prawy
  527. static int  x_pos_old = 0,              // poprzednia pozycja kursora myszy
  528.             y_pos_old = 0;
  529. static int  delta_x = 0,                // różnica pomiędzy pozycją bieżącą
  530.             delta_y = 0;                // i poprzednią kursora myszy
  531.  
  532. //Parametry programu
  533. int N = 50;             //Liczba punktow na jaka dzielimy kwadrat jednostkowy
  534. float verLength = 1.0;  //Dlugosc boku kwadratu
  535. float lightsR = 10.0;   //Promien sfery swiatel
  536.  
  537.  
  538. //Funkcja wyliczajaca wspolrzedna X punktu (u,v) w przestrzeni 3D
  539. float calc3Dx(float u, float v) {
  540.     float x, a = v*PI;
  541.  
  542.     x = (-90*pow(u, 5) +225*pow(u, 4) -270*pow(u, 3) +180*pow(u, 2) -45*u) * cos(a);
  543.     return x;
  544. }
  545.  
  546. //Funkcja wyliczajaca wspolrzedna Y punktu (u,v) w przestrzeni 3D
  547. float calc3Dy(float u, float v) {
  548.     float y;
  549.  
  550.     y = 160*pow(u, 4) -320*pow(u, 3) +160*pow(u, 2);
  551.     return y - 5;
  552. }
  553.  
  554. //Funkcja wyliczajaca wspolrzedna Z punktu (u,v) w przestrzeni 3D
  555. float calc3Dz(float u, float v) {
  556.     float z, a = v*PI;
  557.  
  558.     z = (-90*pow(u, 5) +225*pow(u, 4) -270*pow(u, 3) +180*pow(u, 2) -45*u) * sin(a);
  559.     return z;
  560. }
  561.  
  562. //Obliczenie wspolrzednej X wektora normalnego do powierzchni w punkcie
  563. float calcNormX(float u, float v) {
  564.     float x, a = v*PI;
  565.  
  566.     float yu = 640*pow(u, 3) - 960*pow(u, 2) + 320*u;
  567.     float yv = 0;
  568.     float zu = (-450*pow(u, 4) + 900*pow(u, 3) - 810*pow(u, 2) + 360*u - 45)*sin(a);
  569.     float zv = -PI*(90*pow(u, 5) - 225*pow(u, 4) + 270*pow(u, 3) - 180*pow(u, 2) + 45*u)*cos(a);
  570.  
  571.     x = (GLfloat)(yu*zv - zu*yv);
  572.     return x;
  573. }
  574.  
  575. //Obliczenie wspolrzednej Y wektora normalnego do powierzchni w punkcie
  576. float calcNormY(float u, float v) {
  577.     float y, a = v*PI;
  578.  
  579.     float xu = (-450*pow(u, 4) + 900*pow(u, 3) - 810*pow(u, 2) + 360*u - 45)*cos(a);
  580.     float xv = PI*(90*pow(u, 5) - 225*pow(u, 4) + 270*pow(u, 3) - 180*pow(u, 2) + 45*u)*sin(a);
  581.     float zu = (-450*pow(u, 4) + 900*pow(u, 3) - 810*pow(u, 2) + 360*u - 45)*sin(a);
  582.     float zv = -PI*(90*pow(u, 5) - 225*pow(u, 4) + 270*pow(u, 3) - 180*pow(u, 2) + 45*u)*cos(a);
  583.  
  584.     y = (GLfloat)(zu*xv - xu*zv);
  585.     return y;
  586. }
  587.  
  588. //Obliczenie wspolrzednej Z wektora normalnego do powierzchni w punkcie
  589. float calcNormZ(float u, float v) {
  590.     float z, a = v*PI;
  591.  
  592.     float xu = (-450*pow(u, 4) + 900*pow(u, 3) - 810*pow(u, 2) + 360*u - 45)*cos(a);
  593.     float xv = PI*(90*pow(u, 5) - 225*pow(u, 4) + 270*pow(u, 3) - 180*pow(u, 2) + 45*u)*sin(a);
  594.     float yu = 640*pow(u, 3) - 960*pow(u, 2) + 320*u;
  595.     float yv = 0;
  596.  
  597.     z = (GLfloat)(xu*yv - yu*xv);
  598.     return z;
  599. }
  600.  
  601. //Funkcja generujaca siatke puntow, najpierw w 2D, potem w 3D
  602. void genPointsMesh(){
  603.     float stepXY = verLength/N;
  604.  
  605.     //Przypisanie punktom wspolrzednych
  606.     for (int i=0; i<N+1; i++) {
  607.         for (int j=0; j<N+1; j++) {
  608.             pointsTab[i][j][0]= j*stepXY;
  609.             pointsTab[i][j][1]= i*stepXY;
  610.         }
  611.     }
  612.  
  613.     //Przeksztalcenie wspolrzednych z dziedziny parametrycznej
  614.     //w przestrzen 3D
  615.     float u,v;
  616.     for (int i=0; i<N+1; i++) {
  617.         for (int j=0; j<N+1; j++) {
  618.             v = pointsTab[i][j][0];
  619.             u = pointsTab[i][j][1];
  620.             pointsTab[i][j][0] = calc3Dx(u, v);
  621.             pointsTab[i][j][1] = calc3Dy(u, v);
  622.             pointsTab[i][j][2] = calc3Dz(u, v);
  623.  
  624.             //Wyliczenie wspolrzednych wektorow normalnych do powierzchni jajka
  625.             float x = calcNormX(u, v);
  626.             float y = calcNormY(u, v);
  627.             float z = calcNormZ(u, v);
  628.  
  629.             //Normalizacja wektorow normalnych do powierzchni jajka
  630.             //Wektory na bokach jajka
  631.             if(i < N/2){
  632.                 pointsNorms[i][j][0] = x / (float)sqrt(pow(x, 2) + pow(y, 2) + pow(z, 2));
  633.                 pointsNorms[i][j][1] = y / (float)sqrt(pow(x, 2) + pow(y, 2) + pow(z, 2));
  634.                 pointsNorms[i][j][2] = z / (float)sqrt(pow(x, 2) + pow(y, 2) + pow(z, 2));
  635.             }
  636.             if(i > N/2){
  637.                 pointsNorms[i][j][0] = -1.0*x / (float)sqrt(pow(x, 2) + pow(y, 2) + pow(z, 2));
  638.                 pointsNorms[i][j][1] = -1.0*y / (float)sqrt(pow(x, 2) + pow(y, 2) + pow(z, 2));
  639.                 pointsNorms[i][j][2] = -1.0*z / (float)sqrt(pow(x, 2) + pow(y, 2) + pow(z, 2));
  640.             }
  641.             //Wektory na "szczycie" jajka
  642.             if(i == N/2){
  643.                 pointsNorms[i][j][0]=0;
  644.                 pointsNorms[i][j][1]=1;
  645.                 pointsNorms[i][j][2]=0;
  646.             }
  647.             //Wektory na "dnie" jajka
  648.             if (i==0 || i==N)
  649.             {
  650.                 pointsNorms[i][j][0]=0;
  651.                 pointsNorms[i][j][1]=-1;
  652.                 pointsNorms[i][j][2]=0;
  653.             }
  654.         }
  655.     }
  656. }
  657.  
  658. //Funkcja renderujaca okreslony model jajka
  659. void Egg(void){
  660.     //Wygenerowanie siatki 3D punktow
  661.     genPointsMesh();
  662.  
  663.     //Parametry rysowania
  664.     glColor3f(1.0, 1.0, 1.0);
  665.  
  666.     //Rysowanie jajka - trojkaty
  667.     for(int i=0; i < N; i++){
  668.         for(int j=0; j < N; j++){
  669.             //W jedna strone
  670.             glBegin(GL_TRIANGLES);
  671.                 glNormal3fv(pointsNorms[i][j+1]);
  672.                 glVertex3fv(pointsTab[i][j+1]);
  673.                 glNormal3fv(pointsNorms[i+1][j]);
  674.                 glVertex3fv(pointsTab[i+1][j]);
  675.                 glNormal3fv(pointsNorms[i+1][j+1]);
  676.                 glVertex3fv(pointsTab[i+1][j+1]);
  677.             glEnd();
  678.             //W druga strone
  679.             glBegin(GL_TRIANGLES);
  680.                 glNormal3fv(pointsNorms[i][j]);
  681.                 glVertex3fv(pointsTab[i][j]);
  682.                 glNormal3fv(pointsNorms[i+1][j]);
  683.                 glVertex3fv(pointsTab[i+1][j]);
  684.                 glNormal3fv(pointsNorms[i][j+1]);
  685.                 glVertex3fv(pointsTab[i][j+1]);
  686.             glEnd();
  687.         }
  688.     }
  689. }
  690.  
  691. // Funkcja rysująca osie układu współrzędnych
  692. void Axes(void)
  693. {
  694.     point3  x_min = {-2.0, 0.0, 0.0};
  695.     point3  x_max = { 2.0, 0.0, 0.0};
  696.     // początek i koniec obrazu osi x
  697.  
  698.     point3  y_min = {0.0, -2.0, 0.0};
  699.     point3  y_max = {0.0,  2.0, 0.0};
  700.     // początek i koniec obrazu osi y
  701.  
  702.     point3  z_min = {0.0, 0.0, -2.0};
  703.     point3  z_max = {0.0, 0.0,  2.0};
  704.     //  początek i koniec obrazu osi y
  705.  
  706.     glColor3f(1.0f, 0.0f, 0.0f);  // kolor rysowania osi - czerwony
  707.     glBegin(GL_LINES); // rysowanie osi x
  708.         glVertex3fv(x_min);
  709.         glVertex3fv(x_max);
  710.     glEnd();
  711.  
  712.     glColor3f(0.0f, 1.0f, 0.0f);  // kolor rysowania - zielony
  713.     glBegin(GL_LINES);  // rysowanie osi y
  714.         glVertex3fv(y_min);
  715.         glVertex3fv(y_max);                          
  716.     glEnd();
  717.  
  718.     glColor3f(0.0f, 0.0f, 1.0f);  // kolor rysowania - niebieski
  719.     glBegin(GL_LINES); // rysowanie osi z
  720.         glVertex3fv(z_min);
  721.         glVertex3fv(z_max);
  722.     glEnd();
  723. }
  724.  
  725.  
  726. // Funkcja określająca co ma być rysowane (zawsze wywoływana gdy trzeba
  727. // przerysować scenę)
  728. void RenderScene(void)
  729. {
  730.     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  731.     // Czyszczenie okna aktualnym kolorem czyszczącym
  732.     glLoadIdentity();
  733.     // Czyszczenie macierzy bieżącej
  734.  
  735.     if(status == 1){    // jeśli lewy klawisz myszy wciśnięty   
  736.         theta[0] -= delta_x*pix2angle_x;
  737.         //Ograniczenie dla azymutu
  738.         if(theta[0] <= 0)
  739.             theta[0] += 2*PI;
  740.         if(theta[0] >= 2*PI)
  741.             theta[0] -= 2*PI;
  742.  
  743.         fi[0] -= delta_y*pix2angle_y;                                
  744.         //Ograniczenie dla elewacji
  745.         if(fi[0] <= 0)
  746.             fi[0] += 2*PI;
  747.         if(fi[0] >= 2*PI)
  748.             fi[0] -= 2*PI;
  749.     }
  750.     else if(status == 2){   // jeśli prawy klawisz myszy wciśnięty
  751.         theta[1] -= delta_x*pix2angle_x;
  752.         //Ograniczenie dla azymutu
  753.         if(theta[1] <= 0)
  754.             theta[1] += 2*PI;
  755.         if(theta[1] >= 2*PI)
  756.             theta[1] -= 2*PI;
  757.  
  758.         fi[1] -= delta_y*pix2angle_y;                                
  759.         //Ograniczenie dla elewacji
  760.         if(fi[1] <= 0)
  761.             fi[1] += 2*PI;
  762.         if(fi[1] >= 2*PI)
  763.             fi[1] -= 2*PI;
  764.     }
  765.  
  766.     gluLookAt(0.0, 0.0, -10.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
  767.     // Zdefiniowanie położenia obserwatora
  768.  
  769.     GLfloat lights_positions[4] = {0};
  770.     lights_positions[0] = lightsR * cos(theta[0]) * cos(fi[0]);
  771.     lights_positions[1] = lightsR * sin(fi[0]);
  772.     lights_positions[2] = lightsR * sin(theta[0]) * cos(fi[0]);
  773.     lights_positions[3] = 1.0;
  774.     glLightfv(GL_LIGHT0, GL_POSITION, lights_positions);
  775.     //Aktualizacja pozycji swiatla 0
  776.  
  777.     lights_positions[0] = lightsR * cos(theta[1]) * cos(fi[1]);
  778.     lights_positions[1] = lightsR * sin(fi[1]);
  779.     lights_positions[2] = lightsR * sin(theta[1]) * cos(fi[1]);
  780.     lights_positions[3] = 1.0;
  781.     glLightfv(GL_LIGHT1, GL_POSITION, lights_positions);
  782.     //Aktualizacja pozycji swiatla 1
  783.  
  784.     Axes();
  785.     // Narysowanie osi przy pomocy funkcji zdefiniowanej powyżej
  786.  
  787.     //Renderowanie jajka
  788.     Egg();
  789.  
  790.     glFlush();
  791.     // Przekazanie poleceń rysujących do wykonania
  792.  
  793.     glutSwapBuffers();
  794.  }
  795.  
  796. // Funkcja ustalająca stan renderowania
  797. void MyInit(void)
  798. {
  799.     glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
  800.     // Kolor czyszcący (wypełnienia okna) ustawiono na czarny
  801.  
  802.     // Definicja materiału z jakiego zrobiony jest przedmiot
  803.     //-------------------------------------------------------
  804.     GLfloat mat_ambient[]  = {0.3, 0.3, 0.3, 1.0};        
  805.     // współczynniki ka =[kar,kag,kab] dla światła otoczenia
  806.  
  807.     GLfloat mat_diffuse[]  = {1.0, 1.0, 1.0, 1.0};
  808.     // współczynniki kd =[kdr,kdg,kdb] światła rozproszonego
  809.  
  810.     GLfloat mat_specular[] = {1.0, 1.0, 1.0, 1.0};
  811.     // współczynniki ks =[ksr,ksg,ksb] dla światła odbitego                
  812.    
  813.     GLfloat mat_shininess  = {100.0};
  814.     // współczynnik n opisujący połysk powierzchni
  815.  
  816.  
  817.     // Definicja źródła światła
  818.     //-------------------------------------------------------
  819.     GLfloat light_position[2][4] = {{-10.0, -10.0, -10.0, 1.0}, {-10.0, -10.0, -10.0, 1.0}};        
  820.     // położenie źródła
  821.  
  822.     GLfloat light_ambient[] = {0.2, 0.2, 0.2, 1.0};
  823.     // składowe intensywności świecenia źródła światła otoczenia
  824.     // Ia = [Iar,Iag,Iab]
  825.  
  826.     GLfloat light_diffuse[2][4] = {{1.0, 0.0, 0.0, 0.0}, {0.0, 0.0, 1.0, 1.0}};
  827.     // składowe intensywności świecenia źródła światła powodującego
  828.     // odbicie dyfuzyjne Id = [Idr,Idg,Idb]
  829.  
  830.     GLfloat light_specular[2][4] = {{1.0, 1.0, 0.0, 1.0}, {0.7, 0.7, 1.0, 1.0}};
  831.     // składowe intensywności świecenia źródła światła powodującego
  832.     // odbicie kierunkowe Is = [Isr,Isg,Isb]
  833.  
  834.     GLfloat att_constant  = {1.0};
  835.     // składowa stała ds dla modelu zmian oświetlenia w funkcji
  836.     // odległości od źródła
  837.  
  838.     GLfloat att_linear    = {0.001};
  839.     // składowa liniowa dl dla modelu zmian oświetlenia w funkcji
  840.     // odległości od źródła
  841.  
  842.     GLfloat att_quadratic  = {0.001};
  843.     // składowa kwadratowa dq dla modelu zmian oświetlenia w funkcji
  844.     // odległości od źródła
  845.  
  846.     // Ustawienie patrametrów materiału
  847.     //-------------------------------------------------------
  848.     glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
  849.     glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient);
  850.     glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
  851.     glMaterialf(GL_FRONT, GL_SHININESS, mat_shininess);
  852.  
  853.     // Ustawienie parametrów źródła światła
  854.     //-------------------------------------------------------
  855.     glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient);
  856.     glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse[0]);
  857.     glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular[0]);
  858.     glLightfv(GL_LIGHT0, GL_POSITION, light_position[0]);
  859.  
  860.     glLightf(GL_LIGHT0, GL_CONSTANT_ATTENUATION, att_constant);
  861.     glLightf(GL_LIGHT0, GL_LINEAR_ATTENUATION, att_linear);
  862.     glLightf(GL_LIGHT0, GL_QUADRATIC_ATTENUATION, att_quadratic);
  863.  
  864.     glLightfv(GL_LIGHT1, GL_AMBIENT, light_ambient);
  865.     glLightfv(GL_LIGHT1, GL_DIFFUSE, light_diffuse[1]);
  866.     glLightfv(GL_LIGHT1, GL_SPECULAR, light_specular[1]);
  867.     glLightfv(GL_LIGHT1, GL_POSITION, light_position[1]);
  868.  
  869.     glLightf(GL_LIGHT1, GL_CONSTANT_ATTENUATION, att_constant);
  870.     glLightf(GL_LIGHT1, GL_LINEAR_ATTENUATION, att_linear);
  871.     glLightf(GL_LIGHT1, GL_QUADRATIC_ATTENUATION, att_quadratic);
  872.  
  873.     // Ustawienie opcji systemu oświetlania sceny
  874.     //-------------------------------------------------------
  875.     glShadeModel(GL_SMOOTH); // właczenie łagodnego cieniowania
  876.     glEnable(GL_LIGHTING);   // właczenie systemu oświetlenia sceny
  877.     glEnable(GL_LIGHT0);     // włączenie źródła o numerze 0
  878.     glEnable(GL_LIGHT1);     // włączenie źródła o numerze 1
  879.     glEnable(GL_DEPTH_TEST); // włączenie mechanizmu z-bufora
  880. }
  881.  
  882.  
  883. // Funkcja ma za zadanie utrzymanie stałych proporcji rysowanych
  884. // w przypadku zmiany rozmiarów okna.
  885. // Parametry vertical i horizontal (wysokość i szerokość okna) są
  886. // przekazywane do funkcji za każdym razem gdy zmieni się rozmiar okna.
  887. void ChangeSize(GLsizei horizontal, GLsizei vertical) {
  888.     pix2angle_x = 360.0*0.0125/(float)horizontal; // przeliczenie pikseli na stopnie
  889.     pix2angle_y = 360.0*0.0125/(float)vertical;
  890.  
  891.     glMatrixMode(GL_PROJECTION);
  892.     // Przełączenie macierzy bieżącej na macierz projekcji
  893.  
  894.     glLoadIdentity();
  895.     // Czyszcznie macierzy bieżącej
  896.  
  897.     gluPerspective(70.0, 1.0, 1.0, 30.0);
  898.     // Ustawienie parametrów dla rzutu perspektywicznego
  899.  
  900.     if(horizontal <= vertical)
  901.         glViewport(0, (vertical-horizontal)/2, horizontal, horizontal);
  902.     else
  903.         glViewport((horizontal-vertical)/2, 0, vertical, vertical);
  904.     // Ustawienie wielkości okna okna widoku (viewport) w zależności
  905.     // relacji pomiędzy wysokością i szerokością okna
  906.  
  907.     glMatrixMode(GL_MODELVIEW);
  908.     // Przełączenie macierzy bieżącej na macierz widoku modelu  
  909.  
  910.     glLoadIdentity();
  911.     // Czyszczenie macierzy bieżącej
  912. }
  913.  
  914. // Funkcja "bada" stan myszy i ustawia wartosci odpowiednich zmiennych globalnych
  915. void Mouse(int btn, int state, int x, int y) {
  916.     if(btn == GLUT_LEFT_BUTTON && state == GLUT_DOWN) {
  917.         x_pos_old = x;        // przypisanie aktualnie odczytanej pozycji kursora
  918.         y_pos_old = y;        // jako pozycji poprzedniej
  919.         status = 1;         // wciśnięty został lewy klawisz myszy
  920.     }
  921.     else if(btn == GLUT_RIGHT_BUTTON && state == GLUT_DOWN) {
  922.         x_pos_old = x;        // przypisanie aktualnie odczytanej pozycji kursora
  923.         y_pos_old = y;        // jako pozycji poprzedniej
  924.         status = 2;         //wciśnięty został prawy klawisz myszy
  925.     }
  926.     else
  927.         status = 0;         // nie został wciśnięty żaden klawisz
  928. }
  929.  
  930. // Funkcja "monitoruje" polozenie kursora myszy i ustawia wartosci odpowiednich
  931. // zmiennych globalnych
  932. void Motion(GLsizei x, GLsizei y) {  
  933.     delta_x = x - x_pos_old;    // obliczenie różnicy położenia kursora myszy
  934.     x_pos_old = x;  // podstawienie bieżacego położenia jako poprzednie
  935.  
  936.     delta_y = y - y_pos_old;    // obliczenie różnicy położenia kursora myszy
  937.     y_pos_old = y;  // podstawienie bieżacego położenia jako poprzednie
  938.  
  939.     glutPostRedisplay();    // przerysowanie obrazu sceny
  940. }
  941.  
  942. // Główny punkt wejścia programu. Program działa w trybie konsoli
  943. void main(void)
  944. {          
  945.     //Ziarno losowosci
  946.     srand((unsigned) time(NULL));
  947.  
  948.     //Dynamiczna alokacja tablicy punktow
  949.     pointsTab = new point3*[N+1];
  950.     for (int i=0; i<N+1;i++){
  951.         pointsTab[i] = new point3[N+1];
  952.     }
  953.  
  954.     //Dynamiczna alokacja tablicy wspolrzednych wektorow normalnych
  955.     pointsNorms = new point3*[N+1];
  956.     for(int i=0; i < N+1; i++){
  957.         pointsNorms[i] = new point3[N+1];
  958.     }
  959.  
  960.     glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
  961.  
  962.     glutInitWindowSize(800, 600);
  963.  
  964.     glutCreateWindow("Oswietlone jajko, dwa zrodla swiatla");
  965.                
  966.     glutDisplayFunc(RenderScene);
  967.     // Określenie, że funkcja RenderScene będzie funkcją zwrotną
  968.     // (callback function).  Bedzie ona wywoływana za każdym razem
  969.     // gdy zajdzie potrzba przeryswania okna
  970.  
  971.     // Dla aktualnego okna ustala funkcję zwrotną odpowiedzialną
  972.     // zazmiany rozmiaru okna  
  973.     glutReshapeFunc(ChangeSize);                    
  974.  
  975.     MyInit();
  976.     // Funkcja MyInit() (zdefiniowana powyżej) wykonuje wszelkie
  977.     // inicjalizacje konieczne  przed przystąpieniem do renderowania
  978.  
  979.     // Włączenie mechanizmu usuwania powierzchni niewidocznych
  980.     glutMouseFunc(Mouse);
  981.     // Ustala funkcję zwrotną odpowiedzialną za badanie stanu myszy
  982.    
  983.     glutMotionFunc(Motion);
  984.     // Ustala funkcję zwrotną odpowiedzialną za badanie ruchu myszy
  985.  
  986.     glEnable(GL_DEPTH_TEST);
  987.  
  988.     glutMainLoop();
  989.     // Funkcja uruchamia szkielet biblioteki GLUT
  990.  
  991.     //Zwolnienie pamięci
  992.     for(int i=0; i < N+1; i++){
  993.         delete[] pointsTab[i];
  994.         delete[] pointsNorms[i];
  995.         pointsTab[i] = 0;
  996.         pointsNorms[i] = 0;
  997.     }
  998.     delete[] pointsTab;
  999.     delete[] pointsNorms;
  1000.     pointsTab = 0;
  1001.     pointsNorms = 0;
  1002. }
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!