API tools faq
paste
Advertisement
Guest User

Untitled

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