API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Dec 19th, 2018
80
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 28.30 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.  
  8. #include <windows.h>
  9. #include <gl/gl.h>
  10. #include <gl/glut.h>
  11. #include <cmath>
  12. #include <ctime>
  13. #include <iostream>
  14. #pragma warning (disable : 4996)
  15.  
  16. using namespace std;
  17.  
  18. #define M_PI  3.14159265358979323846
  19.  
  20. typedef float point3[3];
  21.  
  22. //static GLfloat theta1[] = { 0.0, 0.0, 0.0 }; // trzy kąty obrotu
  23.  
  24. struct Point
  25. {
  26.     float x;
  27.     float y;
  28.     float z;
  29.     float xu;
  30.     float xv;
  31.     float yu;
  32.     float yv;
  33.     float zu;
  34.     float zv;
  35.     float nx;
  36.     float ny;
  37.     float nz;
  38. };
  39.  
  40. static int N = 60;          //wielkosc tablicy
  41.  
  42. Point **tablica;        //dynamiczna tablica struktur punktowych
  43.  
  44. Point **kolory;         //dynamiczna tablica kolorów
  45.  
  46. GLfloat promien = 20.0;
  47.  
  48. float y = 1.0f;
  49.  
  50. bool kierunek = true;  //true - dodawanie, false - odejmowanie
  51.  
  52. GLfloat PHI = 0.0, THETA = 0.0;
  53. //GLfloat cosPhi = 0.5, sinPhi = 0.5, cosTheta = 0.5, sinTheta = 0.5;
  54.  
  55. static GLfloat viewer[] = { 0.1, 0.1, 10.0 };
  56. // inicjalizacja położenia obserwatora
  57.  
  58. static GLfloat theta[] = { 0.0, 0.0 };   // kąt obrotu obiektu
  59. static GLfloat pix2angleX;     // przelicznik pikseli na stopnie
  60. static GLfloat pix2angleY;     // przelicznik pikseli na stopnie
  61.  
  62. static GLint statusL = 0;       // stan klawiszy myszy
  63.                                 // 0 - nie naciśnięto żadnego klawisza
  64.                                 // 1 - naciśnięty został lewy klawisz
  65.  
  66. static GLint statusP = 0;       // stan klawiszy myszy
  67.                                 // 0 - nie naciśnięto żadnego klawisza
  68.                                 // 1 - naciśnięty został prawy klawisz
  69.  
  70. static int x_pos_old = 0;       // poprzednia pozycja kursora myszy
  71.  
  72. static int y_pos_old = 0;       // poprzednia pozycja kursora myszy
  73.  
  74. static int delta_x = 0;        // różnica pomiędzy pozycją bieżącą
  75.                                // i poprzednią kursora myszy
  76.  
  77. static int delta_y = 0;        // różnica pomiędzy pozycją bieżącą
  78.                                // i poprzednią kursora myszy
  79.  
  80.                                /*************************************************************************************/
  81.  
  82.                                /*************************************************************************************/
  83.                                // Funkcja "bada" stan myszy i ustawia wartości odpowiednich zmiennych globalnych
  84.  
  85. GLbyte *LoadTGAImage(const char *FileName, GLint *ImWidth, GLint *ImHeight, GLint *ImComponents, GLenum *ImFormat)
  86. {
  87.  
  88.     /*************************************************************************************/
  89.  
  90.     // Struktura dla nagłówka pliku  TGA
  91.  
  92.  
  93. #pragma pack(1)            
  94.     typedef struct
  95.     {
  96.         GLbyte    idlength;
  97.         GLbyte    colormaptype;
  98.         GLbyte    datatypecode;
  99.         unsigned short    colormapstart;
  100.         unsigned short    colormaplength;
  101.         unsigned char     colormapdepth;
  102.         unsigned short    x_orgin;
  103.         unsigned short    y_orgin;
  104.         unsigned short    width;
  105.         unsigned short    height;
  106.         GLbyte    bitsperpixel;
  107.         GLbyte    descriptor;
  108.     }TGAHEADER;
  109. #pragma pack(8)
  110.  
  111.     FILE *pFile;
  112.     TGAHEADER tgaHeader;
  113.     unsigned long lImageSize;
  114.     short sDepth;
  115.     GLbyte    *pbitsperpixel = NULL;
  116.  
  117.  
  118.     /*************************************************************************************/
  119.  
  120.     // Wartości domyślne zwracane w przypadku błędu
  121.  
  122.     *ImWidth = 0;
  123.     *ImHeight = 0;
  124.     *ImFormat = GL_BGR_EXT;
  125.     *ImComponents = GL_RGB8;
  126.  
  127.     pFile = fopen(FileName, "rb");
  128.     if (pFile == NULL)
  129.         return NULL;
  130.  
  131.     /*************************************************************************************/
  132.     // Przeczytanie nagłówka pliku
  133.  
  134.  
  135.     fread(&tgaHeader, sizeof(TGAHEADER), 1, pFile);
  136.  
  137.  
  138.     /*************************************************************************************/
  139.  
  140.     // Odczytanie szerokości, wysokości i głębi obrazu
  141.  
  142.     *ImWidth = tgaHeader.width;
  143.     *ImHeight = tgaHeader.height;
  144.     sDepth = tgaHeader.bitsperpixel / 8;
  145.  
  146.  
  147.     /*************************************************************************************/
  148.     // Sprawdzenie, czy głębia spełnia założone warunki (8, 24, lub 32 bity)
  149.  
  150.     if (tgaHeader.bitsperpixel != 8 && tgaHeader.bitsperpixel != 24 && tgaHeader.bitsperpixel != 32)
  151.         return NULL;
  152.  
  153.     /*************************************************************************************/
  154.  
  155.     // Obliczenie rozmiaru bufora w pamięci
  156.  
  157.  
  158.     lImageSize = tgaHeader.width * tgaHeader.height * sDepth;
  159.  
  160.  
  161.     /*************************************************************************************/
  162.  
  163.     // Alokacja pamięci dla danych obrazu
  164.  
  165.  
  166.     pbitsperpixel = (GLbyte*)malloc(lImageSize * sizeof(GLbyte));
  167.  
  168.     if (pbitsperpixel == NULL)
  169.         return NULL;
  170.  
  171.     if (fread(pbitsperpixel, lImageSize, 1, pFile) != 1)
  172.     {
  173.         free(pbitsperpixel);
  174.         return NULL;
  175.     }
  176.  
  177.  
  178.     /*************************************************************************************/
  179.  
  180.     // Ustawienie formatu OpenGL
  181.  
  182.  
  183.     switch (sDepth)
  184.  
  185.     {
  186.  
  187.     case 3:
  188.  
  189.         *ImFormat = GL_BGR_EXT;
  190.  
  191.         *ImComponents = GL_RGB8;
  192.  
  193.         break;
  194.  
  195.     case 4:
  196.  
  197.         *ImFormat = GL_BGRA_EXT;
  198.  
  199.         *ImComponents = GL_RGBA8;
  200.  
  201.         break;
  202.  
  203.     case 1:
  204.  
  205.         *ImFormat = GL_LUMINANCE;
  206.  
  207.         *ImComponents = GL_LUMINANCE8;
  208.  
  209.         break;
  210.  
  211.     };
  212.  
  213.  
  214.  
  215.     fclose(pFile);
  216.  
  217.  
  218.  
  219.     return pbitsperpixel;
  220.  
  221. }
  222.  
  223.  
  224. void Mouse(int btn, int state, int x, int y)
  225. {
  226.  
  227.  
  228.     if (btn == GLUT_LEFT_BUTTON && state == GLUT_DOWN)
  229.     {
  230.         x_pos_old = x;         // przypisanie aktualnie odczytanej pozycji kursora
  231.                                // jako pozycji poprzedniej
  232.         y_pos_old = y;         // przypisanie aktualnie odczytanej pozycji kursora
  233.         statusL = 1;          // wcięnięty został lewy klawisz myszy
  234.     }
  235.     else
  236.         statusL = 0;          // nie został wcięnięty żaden klawisz
  237.  
  238.     if (btn == GLUT_RIGHT_BUTTON && state == GLUT_DOWN)
  239.     {
  240.         statusP = 1;          // wcięnięty został lewy klawisz myszy
  241.         y_pos_old = y;         // przypisanie aktualnie odczytanej pozycji kursora
  242.     }
  243.     else
  244.         statusP = 0;          // nie został wcięnięty żaden klawisz
  245.  
  246. }
  247.  
  248.  
  249. /*************************************************************************************/
  250. // Funkcja "monitoruje" położenie kursora myszy i ustawia wartości odpowiednich
  251. // zmiennych globalnych
  252.  
  253. void Motion(GLsizei x, GLsizei y)
  254. {
  255.  
  256.     delta_x = x - x_pos_old;     // obliczenie różnicy położenia kursora myszy
  257.  
  258.     delta_y = y - y_pos_old;     // obliczenie różnicy położenia kursora myszy
  259.  
  260.     x_pos_old = x;            // podstawienie bieżącego położenia jako poprzednie
  261.  
  262.     y_pos_old = y;            // podstawienie bieżącego położenia jako poprzednie
  263.  
  264.     glutPostRedisplay();     // przerysowanie obrazu sceny
  265. }
  266.  
  267. /*************************************************************************************/
  268.  
  269.  
  270. // Funkcja rysująca osie układu wspó?rz?dnych
  271.  
  272. /*void spinTeapot()
  273. {
  274. theta1[0] += 0.15;
  275. theta1[1] -= 0.25;
  276. theta1[2] += 0.05;
  277. glutPostRedisplay(); //odświeżenie zawartości aktualnego okna
  278. }
  279. */
  280.  
  281. void DrawEggTriangle()
  282. {
  283.     for (int i = 0; i <= N; i++)
  284.         for (int j = 0; j <= N; j++)
  285.         {
  286.             if (i <= (N - 1))
  287.             {
  288.                 if (j <= (N - 1))
  289.                 {
  290.                     glBegin(GL_TRIANGLES);
  291.                     //glColor3f(kolory[i][j].x, kolory[i][j].y, kolory[i][j].z);
  292.                     glColor3f(1.0, 1.0, 1.0);
  293.                     glNormal3f(tablica[i][j].nx, tablica[i][j].ny, tablica[i][j].nz);
  294.                     glTexCoord2f((float)((float)i/(float)N), (float)((float)j / (float)N));
  295.                     glVertex3f(tablica[i][j].x, tablica[i][j].y - 5.0f, tablica[i][j].z);
  296.                     //glColor3f(kolory[i + 1][j + 1].x, kolory[i + 1][j + 1].y, kolory[i + 1][j + 1].z);
  297.                     glColor3f(1.0, 1.0, 1.0);
  298.                     glNormal3f(tablica[i + 1][j + 1].nx, tablica[i + 1][j + 1].ny, tablica[i + 1][j + 1].nz);
  299.                     glTexCoord2f((float)((float)i / (float)N), (float)((float)j / (float)N));
  300.                     glVertex3f(tablica[i + 1][j + 1].x, tablica[i + 1][j + 1].y - 5.0f, tablica[i + 1][j + 1].z);
  301.                     //glColor3f(kolory[i][j + 1].x, kolory[i][j + 1].y, kolory[i][j + 1].z);
  302.                     glColor3f(1.0, 1.0, 1.0);
  303.                     glNormal3f(tablica[i][j + 1].nx, tablica[i][j + 1].ny, tablica[i][j + 1].nz);
  304.                     glTexCoord2f((float)((float)i / (float)N), (float)((float)j / (float)N));
  305.                     glVertex3f(tablica[i][j + 1].x, tablica[i][j + 1].y - 5.0f, tablica[i][j + 1].z);
  306.                     glEnd();
  307.                     glBegin(GL_TRIANGLES);
  308.                     //glColor3f(kolory[i][j].x, kolory[i][j].y, kolory[i][j].z);
  309.                     glColor3f(1.0, 1.0, 1.0);
  310.                     glNormal3f(tablica[i][j].nx, tablica[i][j].ny, tablica[i][j].nz);
  311.                     glTexCoord2f((float)((float)i / (float)N), (float)((float)j / (float)N));
  312.                     glVertex3f(tablica[i][j].x, tablica[i][j].y - 5.0f, tablica[i][j].z);
  313.                     //glColor3f(kolory[i + 1][j].x, kolory[i + 1][j].y, kolory[i + 1][j].z);
  314.                     glColor3f(1.0, 1.0, 1.0);
  315.                     glNormal3f(tablica[i + 1][j].nx, tablica[i + 1][j].ny, tablica[i + 1][j].nz);
  316.                     glTexCoord2f((float)((float)i / (float)N), (float)((float)j / (float)N));
  317.                     glVertex3f(tablica[i + 1][j].x, tablica[i + 1][j].y - 5.0f, tablica[i + 1][j].z);
  318.                     //glColor3f(kolory[i + 1][j + 1].x, kolory[i + 1][j + 1].y, kolory[i + 1][j + 1].z);
  319.                     glColor3f(1.0, 1.0, 1.0);
  320.                     glNormal3f(tablica[i + 1][j + 1].nx, tablica[i + 1][j + 1].ny, tablica[i + 1][j + 1].nz);
  321.                     glTexCoord2f((float)((float)i / (float)N), (float)((float)j / (float)N));
  322.                     glVertex3f(tablica[i + 1][j + 1].x, tablica[i + 1][j + 1].y - 5.0f, tablica[i + 1][j + 1].z);
  323.                     glEnd();
  324.                 }
  325.             }
  326.             else
  327.             {
  328.                 glBegin(GL_TRIANGLES);
  329.                 //glColor3f(kolory[i][j].x, kolory[i][j].y, kolory[i][j].z);
  330.                 glColor3f(1.0, 1.0, 1.0);
  331.                 glNormal3f(tablica[i][j].nx, tablica[i][j].ny, tablica[i][j].nz);
  332.                 glTexCoord2f((float)((float)i / (float)N), (float)((float)j / (float)N));
  333.                 glVertex3f(tablica[i][j].x, tablica[i][j].y - 5.0f, tablica[i][j].z);
  334.                 //glColor3f(kolory[0][0].x, kolory[0][0].y, kolory[0][0].z);
  335.                 glColor3f(1.0, 1.0, 1.0);
  336.                 glNormal3f(tablica[0][0].nx, tablica[0][0].ny, tablica[0][0].nz);
  337.                 glTexCoord2f(0.0f, 0.0f);
  338.                 glVertex3f(tablica[0][0].x, tablica[0][0].y - 5.0f, tablica[0][0].z);
  339.                 //glColor3f(kolory[i][0].x, kolory[i][0].y, kolory[i][0].z);
  340.                 glColor3f(1.0, 1.0, 1.0);
  341.                 glNormal3f(tablica[i][0].nx, tablica[i][0].ny, tablica[i][0].nz);
  342.                 glTexCoord2f((float)((float)i / (float)N), 0.0f);
  343.                 glVertex3f(tablica[i][0].x, tablica[i][0].y - 5.0f, tablica[i][0].z);
  344.                 glEnd();
  345.  
  346.                 glBegin(GL_TRIANGLES);
  347.                 //glColor3f(kolory[i][j].x, kolory[i][j].y, kolory[i][j].z);
  348.                 glColor3f(1.0, 1.0, 1.0);
  349.                 glNormal3f(tablica[i][j].nx, tablica[i][j].ny, tablica[i][j].nz);
  350.                 glTexCoord2f((float)((float)i / (float)N), (float)((float)j / (float)N));
  351.                 glVertex3f(tablica[i][j].x, tablica[i][j].y - 5.0f, tablica[i][j].z);
  352.                 //glColor3f(kolory[0][j].x, kolory[0][j].y, kolory[0][j].z);
  353.                 glColor3f(1.0, 1.0, 1.0);
  354.                 glNormal3f(tablica[0][j].nx, tablica[0][j].ny, tablica[0][j].nz);
  355.                 glTexCoord2f(0.0f, (float)((float)j / (float)N));
  356.                 glVertex3f(tablica[0][j].x, tablica[0][j].y - 5.0f, tablica[0][j].z);
  357.                 //glColor3f(kolory[0][0].x, kolory[0][0].y, kolory[0][0].z);
  358.                 glColor3f(1.0, 1.0, 1.0);
  359.                 glNormal3f(tablica[0][0].nx, tablica[0][0].ny, tablica[0][0].nz);
  360.                 glTexCoord2f(0.0f, 0.0f);
  361.                 glVertex3f(tablica[0][0].x, tablica[0][0].y - 5.0f, tablica[0][0].z);
  362.                 glEnd();
  363.             }
  364.         }
  365. }
  366.  
  367. void GeneratingColors()
  368. {
  369.     kolory = new Point*[N + 1];
  370.     for (int i = 0; i <= N; i++)
  371.         kolory[i] = new Point[N + 1];
  372.  
  373.     for (int i = 0; i <= N; i++)
  374.         for (int j = 0; j <= N; j++)
  375.         {
  376.  
  377.             //  else {
  378.             kolory[i][j].x = (float)(rand() % 1000 / 1000.0);
  379.             kolory[i][j].y = (float)(rand() % 1000 / 1000.0);
  380.             kolory[i][j].z = (float)(rand() % 1000 / 1000.0);
  381.             //  }
  382.         }
  383.  
  384.     for (int i = 0; i <= N; i++)
  385.         for (int j = 0; j <= N; j++)
  386.         {
  387.             if (j == N - 1)
  388.             {
  389.                 kolory[i][j].x = kolory[i][0].x;
  390.                 kolory[i][j].y = kolory[i][0].y;
  391.                 kolory[i][j].z = kolory[i][0].z;
  392.             }
  393.         }
  394.  
  395.  
  396.  
  397.     /*
  398.     for (int i = 0; i <= N; i++)
  399.     {
  400.     for(int j = 0 ; j <= N; j++)
  401.     std::cout << "X = " << kolory[i][j].x << "\t";
  402.     std::cout << std::endl;
  403.     for (int j = 0; j <= N; j++)
  404.     std::cout << "Y = " << kolory[i][j].y << "\t";
  405.     std::cout << std::endl;
  406.     for (int j = 0; j <= N; j++)
  407.     std::cout << "Z = " << kolory[i][j].z << "\t";
  408.     std::cout << std::endl << std::endl;
  409.     }
  410.     std::cin.get();
  411.     std::cin.get();*/
  412.     tablica = new Point*[N + 1];
  413.     for (int i = 0; i <= N; i++)
  414.         tablica[i] = new Point[N + 1];
  415.  
  416. }
  417.  
  418. void Egg()
  419. {
  420.     for (int i = 0; i <= N; i++)
  421.         for (int j = 0; j <= N; j++)
  422.         {
  423.             float u = (float)i / (float)N;
  424.             float v = (float)j / (float)N;
  425.             tablica[i][j].x = ((-90 * pow(u, 5) + 225 * pow(u, 4) - 270 * pow(u, 3) + 180 * u*u - 45 * u)*cosf((float)M_PI*v));
  426.             tablica[i][j].y = (160 * pow(u, 4) - 320 * pow(u, 3) + 160 * u*u);
  427.             tablica[i][j].z = ((-90 * pow(u, 5) + 225 * pow(u, 4) - 270 * pow(u, 3) + 180 * u*u - 45 * u)*sinf((float)M_PI*v));
  428.             tablica[i][j].xu = (-450 * pow(u, 4) + 900 * pow(u, 3) - 810 * u*u + 360 * u - 45)*cosf((float)M_PI*v);
  429.             tablica[i][j].xv = (float)M_PI*(90 * pow(u, 5) - 225 * pow(u, 4) + 270 * pow(u, 3) - 180 * u*u + 45 * u)*sinf(M_PI*v);
  430.             tablica[i][j].yu = (640 * pow(u, 3) - 960 * u*u + 320 * u);
  431.             tablica[i][j].yv = 0.0;
  432.             tablica[i][j].zu = (-450 * pow(u, 4) + 900 * pow(u, 3) - 810 * u*u + 360 * u - 45)*sinf((float)M_PI*v);
  433.             tablica[i][j].zv = (-1 * (float)M_PI)*(90 * pow(u, 5) - 225 * pow(u, 4) + 270 * pow(u, 3) - 180 * u*u + 45 * u)*cosf((float)M_PI*v);
  434.            
  435.  
  436.  
  437.             tablica[i][j].nx = tablica[i][j].yu*tablica[i][j].zv - tablica[i][j].zu*tablica[i][j].yv;
  438.             tablica[i][j].ny = tablica[i][j].zu*tablica[i][j].xv - tablica[i][j].xu*tablica[i][j].zv;
  439.             tablica[i][j].nz = tablica[i][j].xu*tablica[i][j].yv - tablica[i][j].yu*tablica[i][j].xv;
  440.  
  441.             if (i > N / 2)
  442.             {
  443.                 tablica[i][j].nx = -1.0*tablica[i][j].nx;
  444.                 tablica[i][j].ny = -1.0*tablica[i][j].ny;
  445.                 tablica[i][j].nz = -1.0*tablica[i][j].nz;
  446.             }
  447.  
  448.  
  449.             if (i == N / 2)
  450.             {
  451.                 tablica[i][j].nx = 0.0;
  452.                 tablica[i][j].ny = 1.0;
  453.                 tablica[i][j].nz = 0.0;
  454.             }
  455.  
  456.             if (i == 0 || i == N)
  457.             {
  458.                 tablica[i][j].nx = 0.0;
  459.                 tablica[i][j].ny = -1.0;
  460.                 tablica[i][j].nz = 0.0;
  461.             }
  462.  
  463.  
  464.  
  465.  
  466.             //  cout << "Przed: " << sqrtf(tablica[i][j].nx*tablica[i][j].nx + tablica[i][j].ny*tablica[i][j].ny + tablica[i][j].nz*tablica[i][j].nz);
  467.             float pierwiastek = sqrtf(tablica[i][j].nx*tablica[i][j].nx + tablica[i][j].ny*tablica[i][j].ny + tablica[i][j].nz*tablica[i][j].nz);
  468.  
  469.             //  if ()
  470.             //  {
  471.             tablica[i][j].nx = tablica[i][j].nx / pierwiastek;
  472.             tablica[i][j].ny = tablica[i][j].ny / pierwiastek;
  473.             tablica[i][j].nz = tablica[i][j].nz / pierwiastek;
  474.             //  cout << "  po: " << sqrtf(tablica[i][j].nx*tablica[i][j].nx + tablica[i][j].ny*tablica[i][j].ny + tablica[i][j].nz*tablica[i][j].nz);
  475.             //  }
  476.  
  477.             //cout << "  po: " << sqrtf(tablica[i][j].nx*tablica[i][j].nx + tablica[i][j].ny*tablica[i][j].ny + tablica[i][j].nz*tablica[i][j].nz) << endl;
  478.         }
  479.  
  480.     /*for(int i = 0; i <= N; i++)
  481.     {
  482.     for (int j = 0; j <= N; j++)
  483.     std::cout << tablica[i][j].x << ", " << tablica[i][j].y << ", " << tablica[i][j].z << "\t";
  484.     std::cout << std::endl;
  485.     }
  486.     std::cin.get();
  487.     std::cin.get();
  488.     */
  489.  
  490.     DrawEggTriangle();
  491.  
  492.  
  493. }
  494.  
  495. void Axes(void)
  496. {
  497.  
  498.     point3  x_min = { -5.0, 0.0, 0.0 };
  499.     point3  x_max = { 5.0, 0.0, 0.0 };
  500.     // pocz?tek i koniec obrazu osi x
  501.  
  502.     point3  y_min = { 0.0, -5.0, 0.0 };
  503.     point3  y_max = { 0.0,  5.0, 0.0 };
  504.     // pocz?tek i koniec obrazu osi y
  505.  
  506.     point3  z_min = { 0.0, 0.0, -5.0 };
  507.     point3  z_max = { 0.0, 0.0,  5.0 };
  508.     //  pocz?tek i koniec obrazu osi y
  509.     glColor3f(1.0f, 0.0f, 0.0f);  // kolor rysowania osi - czerwony
  510.     glBegin(GL_LINES); // rysowanie osi x
  511.     glVertex3fv(x_min);
  512.     glVertex3fv(x_max);
  513.     glEnd();
  514.  
  515.     glColor3f(0.0f, 1.0f, 0.0f);  // kolor rysowania - zielony
  516.     glBegin(GL_LINES);  // rysowanie osi y
  517.  
  518.     glVertex3fv(y_min);
  519.     glVertex3fv(y_max);
  520.     glEnd();
  521.  
  522.     glColor3f(0.0f, 0.0f, 1.0f);  // kolor rysowania - niebieski
  523.     glBegin(GL_LINES); // rysowanie osi z
  524.  
  525.     glVertex3fv(z_min);
  526.     glVertex3fv(z_max);
  527.     glEnd();
  528.  
  529. }
  530.  
  531. /*************************************************************************************/
  532.  
  533. // Funkcja określająca co ma być rysowane (zawsze wywoływana, gdy trzeba
  534. // przerysować scenę)
  535.  
  536. void viewerPlacing()
  537. {
  538.     viewer[0] = promien*cos(THETA)*cos(PHI);
  539.     viewer[1] = promien*sin(PHI);
  540.     viewer[2] = promien*sin(THETA)*cos(PHI);
  541. }
  542.  
  543. void AnglesCounting()
  544. {
  545.     /*GLfloat temp1 = cosTheta, temp2 = sinTheta, temp3 = cosPhi, temp4 = sinPhi;
  546.     cosTheta = viewer[0] / (GLfloat)sqrt(viewer[0] * viewer[0] + viewer[1] * viewer[1]);
  547.     if (cosTheta < -1 || cosTheta > 1)
  548.     cosTheta = temp1;
  549.     sinTheta = viewer[2] / (GLfloat)sqrt(viewer[0] * viewer[0] + viewer[2] * viewer[2]);
  550.     if (sinTheta < -1 || cosTheta > 1)
  551.     sinTheta = temp1;
  552.     //cosPhi = (GLfloat)sqrt(viewer[0] * viewer[0] + viewer[2] * viewer[2]) /   (GLfloat)sqrt((GLfloat)sqrt(viewer[0] * viewer[0] + viewer[1] * viewer[1]) + viewer[1]*viewer[1]);
  553.     cosPhi = (GLfloat)sqrt(viewer[0] * viewer[0] + viewer[2] * viewer[2]) / promien;
  554.     if (cosPhi < -1 || cosTheta > 1)
  555.     cosPhi = temp1;
  556.     //  sinPhi = viewer[1] / (GLfloat)sqrt((GLfloat)sqrt(viewer[0] * viewer[0] + viewer[1] * viewer[1]) + viewer[1] * viewer[1]);
  557.     sinPhi = viewer[1] /promien;
  558.     if (sinPhi < -1 || cosTheta > 1)
  559.     sinPhi = temp1;*/
  560.  
  561.     /*
  562.     GLfloat temp1 = PHI, temp2 = THETA;
  563.     if (PHI >= 0 && PHI <= M_PI)
  564.     PHI += delta_y*pix2angleY / 40.0;
  565.     if (PHI < 0 || PHI > 2 * M_PI)
  566.     PHI = temp1;
  567.     if (THETA >= 0 && THETA <= M_PI)
  568.     THETA += delta_x*pix2angleX / 40.0;
  569.     if (THETA < 0 || THETA > 2 * M_PI)
  570.     THETA = temp2;
  571.     */
  572.  
  573.     //GLfloat temp1 = PHI, temp2 = THETA;
  574.     //if(!(viewer[0] <= 0.5 && viewer[0] >= -0.5 && viewer[2] <= 0.5 && viewer[2] >= -0.5))
  575.     //{
  576.     //PHI += delta_y*pix2angleY / 20.0;
  577.     //THETA += delta_x*pix2angleX / 20.0;
  578.     //}
  579.     //viewerPlacing();
  580.     //if (viewer[0] <= 0.5 && viewer[0] >= -0.5 && viewer[2] <= 0.5 && viewer[2] >= -0.5)
  581.     //{
  582.     //  PHI = temp1;
  583.     //  THETA = temp2;
  584.     //}
  585.  
  586.     /*if (viewer[0] == 0.0 && viewer[2] == 0.0)
  587.     if (kierunek == true)
  588.     kierunek = false;
  589.     else
  590.     kierunek = true;
  591.     if(kierunek)
  592.     {
  593.     PHI += delta_y*pix2angleY / 40.0;
  594.     THETA += delta_x*pix2angleX / 40.0;
  595.     }
  596.     else
  597.     {
  598.     PHI = PHI * (-1.0);
  599.     THETA = THETA * (-1.0);
  600.     }
  601.     */
  602.  
  603.     PHI += delta_y*pix2angleY;// / 40.0;
  604.                               //    PHI = fmod(PHI, M_PI);
  605.     THETA += delta_x*pix2angleX;// / 40.0;
  606.                                 //  THETA = fmod(THETA, M_PI);
  607.  
  608.     if (cosf(PHI) >= 0.0f)
  609.         y = 1.0f;
  610.     else
  611.         y = -1.0f;
  612.  
  613. }
  614.  
  615. void RenderScene(void)
  616. {
  617.  
  618.     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  619.     // Czyszczenie okna aktualnym kolorem czyszczącym
  620.  
  621.     glLoadIdentity();
  622.     // Czyszczenie macierzy bie??cej
  623.  
  624.  
  625.  
  626.     //gluLookAt(5.0, 2.0, 10.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0);
  627.     gluLookAt(viewer[0], viewer[1], viewer[2], 0.0, 0.0, 0.0, 0.0, y, 0.0);
  628.     // Zdefiniowanie położenia obserwatora
  629.     Axes();
  630.     // Narysowanie osi przy pomocy funkcji zdefiniowanej powyżej
  631.  
  632.  
  633.     /*
  634.     if (statusL == 1)                     // jeśli lewy klawisz myszy wcięnięty
  635.     {
  636.     theta[0] += delta_x*pix2angleX;
  637.     theta[1] += delta_y*pix2angleY;
  638.     }                                  // do różnicy położeń kursora myszy
  639.     if (statusP == 1)                     // jeśli prawy klawisz myszy wcięnięty
  640.     {
  641.     GLfloat temp = viewer[2];
  642.     if (viewer[2] >= 7.0 && viewer[2] <= 30.0)
  643.     viewer[2] += delta_y*pix2angleY;    // modyfikacja kąta obrotu o kat proporcjonalny
  644.     if (viewer[2] < 7.0 || viewer[2] > 30.0)
  645.     viewer[2] = temp;
  646.     }
  647.     */
  648.  
  649.     if (statusL == 1)                     // jeśli lewy klawisz myszy wcięnięty
  650.     {
  651.         AnglesCounting();
  652.     }                                  // do różnicy położeń kursora myszy
  653.  
  654.     if (statusP == 1)                     // jeśli prawy klawisz myszy wcięnięty
  655.     {
  656.         GLfloat temp = promien;
  657.         if (promien >= 7.0 && promien <= 30.0)
  658.             promien += delta_y*pix2angleY;    // modyfikacja kąta obrotu o kat proporcjonalny
  659.         if (promien < 7.0 || promien > 30.0)
  660.             promien = temp;
  661.     }
  662.  
  663.     viewerPlacing();
  664.  
  665.     //glRotatef(theta[0], 0.0, 1.0, 0.0);  //obrót obiektu o nowy kąt
  666.     //glRotatef(theta[1], 1.0, 0.0, 0.0);  //obrót obiektu o nowy kąt
  667.  
  668.     /*
  669.     glRotatef(theta1[0], 1.0, 0.0, 0.0);
  670.     glRotatef(theta1[1], 0.0, 1.0, 0.0);
  671.     glRotatef(theta1[2], 0.0, 0.0, 1.0);
  672.     */
  673.  
  674.     //glColor3f(1.0f, 1.0f, 1.0f);
  675.     // Ustawienie koloru rysowania na biały
  676.  
  677.     //glutWireTeapot(3.0);
  678.  
  679.  
  680.     //glColor3f(1.0f, 1.0f, 1.0f);
  681.     //glutSolidTeapot(3.0f);
  682.     Egg();
  683.     // Narysowanie czajnika
  684.     glFlush();
  685.     // Przekazanie poleceń rysujących do wykonania
  686.     glutSwapBuffers();
  687. }
  688. /*************************************************************************************/
  689.  
  690. // Funkcja ustalająca stan renderowania
  691.  
  692.  
  693.  
  694. void MyInit(void)
  695. {
  696.     /*************************************************************************************/
  697.  
  698.     // Zmienne dla obrazu tekstury
  699.  
  700.  
  701.  
  702.     GLbyte *pBytes;
  703.     GLint ImWidth, ImHeight, ImComponents;
  704.     GLenum ImFormat;
  705.  
  706.  
  707.     // ..................................      
  708.     //       Pozostała część funkcji MyInit()
  709.  
  710.     // ..................................
  711.  
  712.     /*************************************************************************************/
  713.  
  714.     // Teksturowanie będzie prowadzone tyko po jednej stronie ściany
  715.  
  716. //  glEnable(GL_CULL_FACE);
  717.  
  718.  
  719.     /*************************************************************************************/
  720.  
  721.     //  Przeczytanie obrazu tekstury z pliku o nazwie tekstura.tga
  722.  
  723.     pBytes = LoadTGAImage("tekstura.tga", &ImWidth, &ImHeight, &ImComponents, &ImFormat);
  724.  
  725.  
  726.     /*************************************************************************************/
  727.  
  728.     // Zdefiniowanie tekstury 2-D
  729.  
  730.     glTexImage2D(GL_TEXTURE_2D, 0, ImComponents, ImWidth, ImHeight, 0, ImFormat, GL_UNSIGNED_BYTE, pBytes);
  731.  
  732.     /*************************************************************************************/
  733.  
  734.     // Zwolnienie pamięci
  735.  
  736.     free(pBytes);
  737.  
  738.  
  739.     /*************************************************************************************/
  740.  
  741.     // Włączenie mechanizmu teksturowania
  742.  
  743.     glEnable(GL_TEXTURE_2D);
  744.  
  745.     /*************************************************************************************/
  746.  
  747.     // Ustalenie trybu teksturowania
  748.  
  749.     glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
  750.  
  751.     /*************************************************************************************/
  752.  
  753.     // Określenie sposobu nakładania tekstur
  754.  
  755.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  756.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  757.  
  758.    
  759.     /************************************************************************************* /
  760.     //  Definicja materiału z jakiego zrobiony jest czajnik
  761.     //  i definicja źródła światła
  762.     /*************************************************************************************/
  763.  
  764.  
  765.     /*************************************************************************************/
  766.     // Definicja materiału z jakiego zrobiony jest czajnik
  767.  
  768.     GLfloat mat_ambient[] = { 1.0, 1.0, 0.0, 1.0 };
  769.     // współczynniki ka =[kar,kag,kab] dla światła otoczenia
  770.  
  771.     GLfloat mat_diffuse[] = { 1.0, 1.0, 0.0, 1.0 };
  772.     // współczynniki kd =[kdr,kdg,kdb] światła rozproszonego
  773.  
  774.     GLfloat mat_specular[] = { 1.0, 1.0, 0.0, 1.0 };
  775.     // współczynniki ks =[ksr,ksg,ksb] dla światła odbitego                
  776.  
  777.     GLfloat mat_shininess = { 20.0 };
  778.     // współczynnik n opisujący połysk powierzchni
  779.  
  780.  
  781.     /*************************************************************************************/
  782.     // Definicja źródła światła
  783.  
  784.  
  785.     GLfloat light_position[] = { 0.0, 0.0, 10.0, 1.0 };
  786.     // położenie źródła
  787.  
  788.  
  789.     GLfloat light_ambient[] = { 0.1, 0.1, 0.1, 1.0 };
  790.     // składowe intensywności świecenia źródła światła otoczenia
  791.     // Ia = [Iar,Iag,Iab]
  792.  
  793.     GLfloat light_diffuse[] = { 1.0, 1.0, 1.0, 1.0 };
  794.     // składowe intensywności świecenia źródła światła powodującego
  795.     // odbicie dyfuzyjne Id = [Idr,Idg,Idb]
  796.  
  797.     GLfloat light_specular[] = { 1.0, 1.0, 1.0, 1.0 };
  798.     // składowe intensywności świecenia źródła światła powodującego
  799.     // odbicie kierunkowe Is = [Isr,Isg,Isb]
  800.  
  801.     GLfloat att_constant = { 1.0 };
  802.     // składowa stała ds dla modelu zmian oświetlenia w funkcji
  803.     // odległości od źródła
  804.  
  805.     GLfloat att_linear = { 0.05f };
  806.     // składowa liniowa dl dla modelu zmian oświetlenia w funkcji
  807.     // odległości od źródła
  808.  
  809.     GLfloat att_quadratic = { 0.001f };
  810.     // składowa kwadratowa dq dla modelu zmian oświetlenia w funkcji
  811.     // odległości od źródła
  812.  
  813.     /*************************************************************************************/
  814.     // Ustawienie parametrów materiału i źródła światła
  815.  
  816.     /*************************************************************************************/
  817.     // Ustawienie patrametrów materiału
  818.  
  819.  
  820.     glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
  821.     glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient);
  822.     glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
  823.     glMaterialf(GL_FRONT, GL_SHININESS, mat_shininess);
  824.  
  825.  
  826.     /*************************************************************************************/
  827.     // Ustawienie parametrów źródła
  828.  
  829.     glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient);
  830.     glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);
  831.     glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular);
  832.     glLightfv(GL_LIGHT0, GL_POSITION, light_position);
  833.  
  834.     glLightf(GL_LIGHT0, GL_CONSTANT_ATTENUATION, att_constant);
  835.     glLightf(GL_LIGHT0, GL_LINEAR_ATTENUATION, att_linear);
  836.     glLightf(GL_LIGHT0, GL_QUADRATIC_ATTENUATION, att_quadratic);
  837.  
  838.  
  839.     /*************************************************************************************/
  840.     // Ustawienie opcji systemu oświetlania sceny
  841.  
  842.     glShadeModel(GL_SMOOTH); // właczenie łagodnego cieniowania
  843.     glEnable(GL_LIGHTING);   // właczenie systemu oświetlenia sceny
  844.     glEnable(GL_LIGHT0);     // włączenie źródła o numerze 0
  845.     glEnable(GL_DEPTH_TEST); // włączenie mechanizmu z-bufora
  846.  
  847.                              /*************************************************************************************/
  848.     glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
  849.     // Kolor czyszczący (wypełnienia okna) ustawiono na czarny
  850.  
  851. }
  852.  
  853. /*************************************************************************************/
  854.  
  855.  
  856. // Funkcja ma za zadanie utrzymanie stałych proporcji rysowanych
  857. // w przypadku zmiany rozmiarów okna.
  858. // Parametry vertical i horizontal (wysokość i szerokość okna) są
  859. // przekazywane do funkcji za każdym razem gdy zmieni się rozmiar okna.
  860.  
  861.  
  862.  
  863. void ChangeSize(GLsizei horizontal, GLsizei vertical)
  864. {
  865.  
  866.     pix2angleX = 2 * M_PI / (float)horizontal;  // przeliczenie pikseli na stopnie
  867.     pix2angleY = 2 * M_PI / (float)vertical;  // przeliczenie pikseli na stopnie
  868.  
  869.     glMatrixMode(GL_PROJECTION);
  870.     // Przełączenie macierzy bieżącej na macierz projekcji
  871.  
  872.     glLoadIdentity();
  873.     // Czyszcznie macierzy bieżącej
  874.  
  875.     gluPerspective(70, 1.0, 1.0, 30.0);
  876.     // Ustawienie parametrów dla rzutu perspektywicznego
  877.  
  878.  
  879.     if (horizontal <= vertical)
  880.         glViewport(0, (vertical - horizontal) / 2, horizontal, horizontal);
  881.  
  882.     else
  883.         glViewport((horizontal - vertical) / 2, 0, vertical, vertical);
  884.     // Ustawienie wielkości okna okna widoku (viewport) w zależności
  885.     // relacji pomiędzy wysokością i szerokością okna
  886.  
  887.     glMatrixMode(GL_MODELVIEW);
  888.     // Przełączenie macierzy bieżącej na macierz widoku modelu  
  889.  
  890.     glLoadIdentity();
  891.     // Czyszczenie macierzy bieżącej
  892.  
  893. }
  894.  
  895. /*************************************************************************************/
  896.  
  897. // Główny punkt wejścia programu. Program działa w trybie konsoli
  898.  
  899.  
  900.  
  901. void main(void)
  902. {
  903.  
  904.     glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
  905.  
  906.     glutInitWindowSize(300, 300);
  907.  
  908.     glutCreateWindow("Rzutowanie perspektywiczne - 2 Zadanie");
  909.  
  910.     GeneratingColors();
  911.  
  912.     glutDisplayFunc(RenderScene);
  913.     // Określenie, że funkcja RenderScene będzie funkcją zwrotną
  914.     // (callback function).  Będzie ona wywoływana za każdym razem
  915.     // gdy zajdzie potrzeba przerysowania okna
  916.  
  917.     glutMouseFunc(Mouse);
  918.     // Ustala funkcję zwrotną odpowiedzialną za badanie stanu myszy
  919.  
  920.     glutMotionFunc(Motion);
  921.     // Ustala funkcję zwrotną odpowiedzialną za badanie ruchu myszy
  922.  
  923.     //glutIdleFunc(spinTeapot);
  924.  
  925.     glutReshapeFunc(ChangeSize);
  926.     // Dla aktualnego okna ustala funkcję zwrotną odpowiedzialną
  927.     // za zmiany rozmiaru okna                      
  928.  
  929.  
  930.     MyInit();
  931.     // Funkcja MyInit() (zdefiniowana powyżej) wykonuje wszelkie
  932.     // inicjalizacje konieczne  przed przystąpieniem do renderowania
  933.     glEnable(GL_DEPTH_TEST);
  934.     // Włączenie mechanizmu usuwania niewidocznych elementów sceny
  935.  
  936.     glutMainLoop();
  937.     // Funkcja uruchamia szkielet biblioteki GLUT
  938. }
  939.  
  940. /*************************************************************************************/
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!