SHARE
TWEET

Untitled

a guest Jun 19th, 2019 51 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1.  
  2.  
  3. #include <GL\glew.h>
  4. #include<GLFW\glfw3.h>
  5. #include<GL\glut.h>
  6.  
  7. #include<iostream>
  8. #include <stdio.h>
  9. #include <vector>
  10.  
  11. void Rocket();
  12. float cx = 0, cz = 0;
  13. float yy = 0.00f, cy = 0.00f;
  14. int d;
  15. float time1 = 0, time;
  16.  
  17.  
  18.  
  19. enum
  20. {
  21.     FULL_WINDOW, // aspekt obrazu - całe okno
  22.     ASPECT_1_1, // aspekt obrazu 1:1
  23.     EXIT // wyjście
  24. };
  25.  
  26. // aspekt obrazu
  27.  
  28. int aspect = FULL_WINDOW;
  29.  
  30. // usunięcie definicji makr near i far
  31.  
  32. #ifdef near
  33. #undef near
  34. #endif
  35. #ifdef far
  36. #undef far
  37. #endif
  38.  
  39. // rozmiary bryły obcinania
  40.  
  41. const GLdouble left = -2.0;
  42. const GLdouble right = 2.0;
  43. const GLdouble bottom = -2.0;
  44. const GLdouble top = 2.0;
  45. const GLdouble near = 3.0;
  46. const GLdouble far = 7.0;
  47.  
  48. // kąty obrotu
  49.  
  50. GLfloat rotatex = 0.0;
  51. GLfloat rotatey = 0.0;
  52. GLfloat movex = 0.0;
  53. GLfloat movez = 0.0;
  54.  
  55.  
  56. // wskaźnik naciśnięcia lewego przycisku myszki
  57.  
  58. int button_state = GLUT_UP;
  59. //glTranslatef(5.0, 0.0, 0.0);
  60.  
  61. // położenie kursora myszki
  62.  
  63. int button_x, button_y;
  64.  
  65. // współczynnik skalowania
  66.  
  67. GLfloat scale = 0.3;
  68. //szybkosc poruszania sie
  69. int speed = 100;
  70.  
  71. // współrzędne wektorów normalnych i wierzchołków
  72.  
  73. GLfloat normal_vertex[34 * 6] =
  74. {
  75.     0,0,0,0,0,0, //v0
  76.     -1, 0, 0,-1, 0, 0, // v1
  77.     -0.7071, 0, -0.7071, -0.7071, 0, -0.7071, // v2
  78.     0.000, 0, -1,  0.000, 0, -1, // v3
  79.     0.7071, 0,-0.7071, 0.7071, 0, -0.7071, // v4
  80.     1, 0, 0, 1, 0, 0, // v5
  81.     0.7071, 0, 0.7071, 0.7071, 0, 0.7071, // v6
  82.     0, 0, 1, 0, 0, 1, // v7
  83.     -0.7071, 0, 0.7071, -0.7071, 0, 0.7071, // v8
  84.  
  85.  
  86.     0,22,0,0,22,0, //v9
  87.     -1, 20, 0,-1, 20, 0, // v10
  88.     -0.7071, 20, -0.7071, -0.7071, 20, -0.7071, // v11
  89.     0.000, 20, -1,  0.000, 20, -1, // v12
  90.     0.7071, 20,-0.7071, 0.7071, 20, -0.7071, // v13
  91.     1, 20, 0, 1, 20, 0, // v14
  92.     0.7071, 20, 0.7071, 0.7071, 20, 0.7071, // v15
  93.     0, 20, 1, 0, 20, 1, // v16
  94.     -0.7071, 20, 0.7071, -0.7071, 20, 0.7071, // v17
  95.  
  96.     -2.5, -2.5, 0,-2.5, -2.5, 0, // v18
  97.     0,-2.5,-2.5, 0,-2.5,-2.5,  //19
  98.     2.5, -2.5, 0, 2.5, -2.5, 0, // v20
  99.     0,-2.5,2.5, 0,-2.5,2.5,    //21
  100.     -1, 5, 0,-1, 5, 0,     //22
  101.     0, 5, -1,  0, 5, -1,    //23
  102.     1, 5, 0, 1, 5, 0,       //24
  103.     0, 5, 1, 0, 5, 1,       //25
  104.  
  105.     -2, 8, 0,-2, 8, 0, // v26
  106.     0,8,-2, 0,8,-2,  //27
  107.     2, 8, 0, 2, 8, 0, // v28
  108.     0,8,2, 0,8,2,    //29
  109.     -1, 12, 0,-1, 12, 0,     //30
  110.     0, 12, -1,  0, 12, -1,    //31
  111.     1, 12, 0, 1, 12, 0,       //32
  112.     0, 12, 1, 0, 12, 1,       //33
  113.  
  114.  
  115. };
  116. GLfloat normal_vertex1[15 * 3]
  117. {
  118.  
  119. };
  120.  
  121. // składowe kolorów wierzchołków
  122.  
  123. GLfloat color[34 * 3] =
  124. {
  125.     0.5, 0.5, 0.5, // v0
  126.     0.5, 0.5, 0.5, // v1
  127.     0.5, 0.5, 0.5, // v2
  128.     0.5, 0.5, 0.5, // v3
  129.     0.5, 0.5, 0.5, // v4
  130.     0.5, 0.5, 0.5,// v5
  131.     0.5, 0.5, 0.5, // v6
  132.     0.5, 0.5, 0.5, // v7
  133.     0.5, 0.5, 0.5, // v8
  134.     0.5, 0.5, 0.5, // v9
  135.     0.5, 0.5, 0.5, // v10
  136.     0.5, 0.5, 0.5, // v11
  137.     0.5, 0.5, 0.5, // v12
  138.     0.5, 0.5, 0.5, // v13
  139.     0.5, 0.5, 0.5,// v14
  140.     0.5, 0.5, 0.5, // v15
  141.     0.5, 0.5, 0.5, // v16
  142.     0.5, 0.5, 0.5, // v17
  143.     0.5, 0.5, 0.5,// v14
  144.     0.5, 0.5, 0.5, // v15
  145.     0.5, 0.5, 0.5, // v16
  146.  
  147.     0.5, 0.5, 0.5, // v17
  148.     0.5, 0.5, 0.5,// v14
  149.     0.5, 0.5, 0.5, // v15
  150.     0.5, 0.5, 0.5, // v16
  151.     0.5, 0.5, 0.5, // v17
  152.                    
  153.     0.5, 0.5, 0.5, // v17
  154.     0.5, 0.5, 0.5,// v14
  155.     0.5, 0.5, 0.5, // v15
  156.     0.5, 0.5, 0.5, // v16
  157.     0.5, 0.5, 0.5, // v17
  158.     0.5, 0.5, 0.5, // v15
  159.     0.5, 0.5, 0.5, // v16
  160.     0.5, 0.5, 0.5, // v17
  161.  
  162.  
  163. };
  164.  
  165.  
  166. GLubyte triangles[51 * 3] =
  167. {
  168.  
  169.     0,1,2,
  170.     0,2,3,
  171.     0,3,4,
  172.     0,4,5,
  173.     0,5,6,
  174.     0,6,7,
  175.     0,7,8,
  176.     0,8,1,
  177.     9,10,11,
  178.     9,11,12,
  179.    
  180.     9,12,13,
  181.     9,13,14,
  182.     9,14,15,
  183.     9,15,16,
  184.     9,16,17,
  185.     9,17,10,
  186.     1,10,11,
  187.     1,2,11,
  188.     2,11,12,
  189.     2,3,12,
  190.    
  191.     3,12,13,
  192.     3,4,13,
  193.     4,13,14,
  194.     4,5,14,
  195.     5,14,15,
  196.     5,6,15,
  197.     6,15,16,
  198.     6,7,16,
  199.     7,16,17,
  200.     7,8,17,
  201.    
  202.     1,8,17,
  203.     1,10,17,
  204.     1,18,22,
  205.     3,19,23,
  206.     5,20,24,
  207.     7,21,25,
  208.     10,26,30,
  209.     12,27,31,
  210.     14,28,32,
  211.     16,29,33,
  212. };
  213.  
  214. // funkcja generująca scenę 3D
  215. void RenderSineWave()
  216. {
  217.     float i;
  218.     float x, y, z;
  219.  
  220.  
  221.     glPointSize(10);
  222.     glColor3f(1.0, 1.0, 1.0);
  223.  
  224.  
  225.     for (i = 0; i < 3.61; i = i + 0.5)
  226.     {
  227.         z = 0;
  228.         x = (float)i;
  229.         y = 10.0 * sin(i *(6.284 / 360.0));
  230.         glBegin(GL_POINTS);
  231.         glVertex3f(x, y, z);
  232.         glEnd();
  233.         glFlush();
  234.         glutPostRedisplay();
  235.     }
  236.  
  237. }
  238.  
  239. void Display()
  240. {
  241.     // kolor tła - zawartość bufora koloru
  242.     glClearColor(0.0, 0.0, 0.5, 1);
  243.  
  244.     // czyszczenie bufora koloru i bufora głębokości
  245.     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  246.     //tworzymy mini powierzchnie
  247.     glPushMatrix();
  248.     glColor3f(1.0, 1.0, 1.0);
  249.     glBegin(GL_LINES);
  250.     for (GLfloat i = -1000; i <= 1000; i += 0.25) {
  251.         glVertex3f(i, 0, 2.5); glVertex3f(i, 0, -2.5);
  252.         glVertex3f(2.5, 0, i); glVertex3f(-2.5, 0, i);
  253.     }
  254.     glEnd();
  255.     glPopMatrix();
  256.     // wybór macierzy modelowania
  257.     glMatrixMode(GL_MODELVIEW);
  258.  
  259.  
  260.  
  261.     // macierz modelowania = macierz jednostkowa
  262.     glLoadIdentity();
  263.  
  264.     // przesunięcie układu współrzędnych obiektu do środka bryły odcinania
  265.     glTranslatef(0, 0, -(near + far) / 2);
  266.  
  267.     // obroty obiektu
  268.     glRotatef(rotatex, 1.0, 0.0, 0.0);
  269.     glRotatef(rotatey, 0.0, 1.0, 0.0);
  270.     //ruszanie sie
  271.     //glTranslatef(cx, cy, cz);
  272.     // skalowanie obiektu - klawisze "+" i "-"
  273.     glScalef(scale, scale, scale);
  274.  
  275.     // włączenie testu bufora głębokości
  276.     glEnable(GL_DEPTH_TEST);
  277.  
  278.     // włączenie oświetlenia
  279.     glEnable(GL_LIGHTING);
  280.  
  281.     // włączenie światła GL_LIGHT0 z parametrami domyślnymi
  282.     glEnable(GL_LIGHT0);
  283.  
  284.     // włączenie automatycznej normalizacji wektorów normalnych
  285.     glEnable(GL_NORMALIZE);
  286.  
  287.     // włączenie obsługi właściwości materiałów
  288.     glEnable(GL_COLOR_MATERIAL);
  289.  
  290.     // utworzenie danych o wektorach normalnych i współrzędnych wierzchołków
  291.     glInterleavedArrays(GL_N3F_V3F, 0, normal_vertex);
  292.  
  293.     // włączenie tablicy z danymi o kolorach wierzchołków
  294.     glEnableClientState(GL_COLOR_ARRAY);
  295.     glColorPointer(3, GL_FLOAT, 0, color);
  296.  
  297.     // narysowanie tablic wierzchołków - wybór funkcji zależy
  298.     // od dostępnoścglPushMatrix();
  299.  
  300.     Rocket();
  301.  
  302.  
  303.     // skierowanie poleceń do wykonania
  304.     glFlush();
  305.  
  306.     // zamiana buforów koloru
  307.     glutSwapBuffers();
  308.  
  309. }
  310. void Rocket()
  311. {
  312.     glPushMatrix();
  313.  
  314.     //glTranslatef(5 * sin(cx), 5 * sin(cy), sin(cz));
  315.     glTranslatef(cx, cy, cz);
  316.     glRotatef(movex, 0.0, 0.0, 1.0);
  317.  
  318.     if (GLUT_KEY_LEFT)
  319.     {
  320.         glTranslatef(0, 0.0, 0.0);
  321.     }
  322.     glFlush();
  323.     if (glDrawRangeElementsEXT == NULL)
  324.         glDrawElements(GL_TRIANGLES, 51 * 3, GL_UNSIGNED_BYTE, triangles);
  325.  
  326.     else
  327.         glDrawRangeElementsEXT(GL_TRIANGLES, 0, 34, 51 * 3, GL_UNSIGNED_BYTE, triangles);
  328.     if (GLUT_KEY_LEFT)
  329.     {
  330.         glTranslatef(0, 0.0, 0.0);
  331.     }
  332.     //glTranslatef(cx, cy, cz);
  333.  
  334.     glPopMatrix();
  335. }
  336. // zmiana wielkości okna
  337. void update(void)
  338.  
  339. {
  340.     d += 1;
  341.     std::cout << d;
  342. }
  343. void Reshape(int width, int height)
  344. {
  345.     // obszar renderingu - całe okno
  346.     glViewport(0, 0, width, height);
  347.  
  348.     // wybór macierzy rzutowania
  349.     glMatrixMode(GL_PROJECTION);
  350.  
  351.     // macierz rzutowania = macierz jednostkowa
  352.     glLoadIdentity();
  353.  
  354.     // parametry bryły obcinania
  355.     if (aspect == ASPECT_1_1)
  356.     {
  357.         // wysokość okna większa od wysokości okna
  358.         if (width < height && width > 0)
  359.             glFrustum(left, right, bottom * height / width, top * height / width, near, far);
  360.         else
  361.  
  362.             // szerokość okna większa lub równa wysokości okna
  363.             if (width >= height && height > 0)
  364.                 glFrustum(left * width / height, right * width / height, bottom, top, near, far);
  365.  
  366.     }
  367.     else
  368.         glFrustum(left, right, bottom, top, near, far);
  369.  
  370.     // generowanie sceny 3D
  371.     Display();
  372.  
  373.  
  374.  
  375.  
  376.     //update();
  377.  
  378. }
  379.  
  380. // obsługa klawiatury
  381.  
  382. void Keyboard(unsigned char key, int x, int y)
  383. {
  384.     //przesuwamy scena
  385.     if (key == 's') { cy -= 1; }
  386.     if (key == 'd') { movex += 1; }
  387.     //if (key == 'q') { cy += 1; }
  388.     if (key == 'w') { cy += 1; }
  389.     if (key == 'a') { movex -= 1; }
  390.     //if (key == 'z') { cy -= 1; }
  391.     // klawisz +
  392.     if (key == '+')
  393.         scale += 0.05;
  394.  
  395.     // klawisz -
  396.     if (key == '-' && scale > 0.05)
  397.         scale -= 0.05;
  398.  
  399.     if (key == ' ') {
  400.         yy += 0.0314;
  401.         cy = 30 * sin(yy);
  402.         std::cout << yy << cy;
  403.  
  404.         cx = 50 * sin(yy / 2);
  405.  
  406.  
  407.         movex = 180 * sin(-yy / 2);
  408.  
  409.     }
  410.     // narysowanie sceny
  411.     Display();
  412.     glutPostRedisplay();
  413. }
  414.  
  415. // obsługa klawiszy funkcyjnych i klawiszy kursora
  416.  
  417. void SpecialKeys(int key, int x, int y)
  418. {
  419.  
  420.     switch (key)
  421.     {
  422.         // kursor w lewo
  423.     case GLUT_KEY_LEFT:
  424.  
  425.         cx -= 1;
  426.         //Rocket();
  427.         //glRotatef(31.0, 0.0, 1.0, 0.0);
  428.         break;
  429.  
  430.         // kursor w górę
  431.     case GLUT_KEY_UP:
  432.  
  433.         cz += 1;
  434.         //rotatex -= 1;
  435.         //std::cout << "Time:" << time;
  436.         break;
  437.  
  438.         // kursor w prawo
  439.     case GLUT_KEY_RIGHT:
  440.  
  441.         cx += 1;
  442.         //rotatey += 1;
  443.         break;
  444.  
  445.         // kursor w dół
  446.     case GLUT_KEY_DOWN:
  447.  
  448.         cz -= 1;
  449.         //rotatex += 1;
  450.         //glTranslatef(key, x, y);
  451.         //glRotatef(180.0,0.0,1.0,1.0);
  452.         break;
  453.  
  454.  
  455.     }
  456.  
  457.     // odrysowanie okna
  458.     Reshape(glutGet(GLUT_WINDOW_WIDTH), glutGet(GLUT_WINDOW_HEIGHT));
  459. }
  460.  
  461. // obsługa przycisków myszki
  462.  
  463. void MouseButton(int button, int state, int x, int y)
  464. {
  465.     if (button == GLUT_LEFT_BUTTON)
  466.     {
  467.         // zapamiętanie stanu lewego przycisku myszki
  468.         button_state = state;
  469.  
  470.         // zapamiętanie położenia kursora myszki
  471.         if (state == GLUT_DOWN)
  472.         {
  473.             button_x = x;
  474.             button_y = y;
  475.  
  476.         }
  477.     }
  478. }
  479.  
  480. // obsługa ruchu kursora myszki
  481.  
  482. void MouseMotion(int x, int y)
  483. {
  484.  
  485.     if (button_state == GLUT_DOWN)
  486.     {
  487.         rotatey += 30 * (right - left) / glutGet(GLUT_WINDOW_WIDTH) *(x - button_x);
  488.         button_x = x;
  489.         rotatex -= 30 * (top - bottom) / glutGet(GLUT_WINDOW_HEIGHT) *(button_y - y);
  490.         button_y = y;
  491.         glutPostRedisplay();
  492.     }
  493.  
  494. }
  495.  
  496. // obsługa menu podręcznego
  497.  
  498. void Menu(int value)
  499. {
  500.     switch (value)
  501.     {
  502.         // obszar renderingu - całe okno
  503.     case FULL_WINDOW:
  504.         aspect = FULL_WINDOW;
  505.         Reshape(glutGet(GLUT_WINDOW_WIDTH), glutGet(GLUT_WINDOW_HEIGHT));
  506.         break;
  507.  
  508.         // obszar renderingu - aspekt 1:1
  509.     case ASPECT_1_1:
  510.         aspect = ASPECT_1_1;
  511.         Reshape(glutGet(GLUT_WINDOW_WIDTH), glutGet(GLUT_WINDOW_HEIGHT));
  512.         break;
  513.  
  514.         // wyjście
  515.     case EXIT:
  516.         exit(0);
  517.     }
  518. }
  519.  
  520. // sprawdzenie i przygotowanie obsługi wybranych rozszerzeń
  521.  
  522. void ExtensionSetup()
  523. {
  524.     // pobranie numeru wersji biblioteki OpenGL
  525.     const char * version = (char *)glGetString(GL_VERSION);
  526.  
  527.     // odczyt wersji OpenGL
  528.     int major = 0, minor = 0;
  529.     if (sscanf_s(version, "%d.%d", &major, &minor) != 2)
  530.     {
  531. #ifdef WIN32
  532.         printf("Błędny format wersji OpenGL\n");
  533. #else
  534.  
  535.         printf("Bledny format wersji OpenGL\n");
  536. #endif
  537.  
  538.         exit(0);
  539.     }
  540.  
  541.     // sprawdzenie czy jest co najmniej wersja 1.2
  542.     if (major > 1 || minor >= 2)
  543.     {
  544.         // pobranie wskaźników wybranych funkcji OpenGL 1.2
  545.         glDrawRangeElementsEXT =
  546.             (PFNGLDRAWRANGEELEMENTSEXTPROC)wglGetProcAddress("glDrawRangeElements");
  547.     }
  548.     else
  549.  
  550.         // sprawdzenie czy jest obsługiwane rozszerzenie EXT_draw_range_elements
  551.         if (glutExtensionSupported("GL_EXT_draw_range_elements"))
  552.         {
  553.             // pobranie wskaźników wybranych funkcji rozszerzenia EXT_draw_range_elements
  554.             glDrawRangeElementsEXT =
  555.                 (PFNGLDRAWRANGEELEMENTSEXTPROC)wglGetProcAddress("glDrawRangeElementsEXT");
  556.         }
  557.         else
  558.         {
  559.             printf("Brak rozszerzenia EXT_draw_range_elements!\n");
  560.             glDrawRangeElementsEXT = NULL;
  561.         }
  562. }
  563.  
  564. int main(int argc, char * argv[])
  565. {
  566.  
  567.     time = GetTickCount();
  568.     int delta = time - time1;
  569.     time1 = time;
  570.     std::cout << "Time:" << time;
  571.     int yt = sin(delta * speed);
  572.     // inicjalizacja biblioteki GLUT
  573.     glutInit(&argc, argv);
  574.  
  575.     // inicjalizacja bufora ramki
  576.     glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
  577.  
  578.     // rozmiary głównego okna programu
  579.     glutInitWindowSize(500, 500);
  580.  
  581.     // utworzenie głównego okna programu
  582. #ifdef WIN32
  583.  
  584.     glutCreateWindow("Rakieta");
  585. #else
  586.  
  587.     glutCreateWindow("Rakieta");
  588. #endif
  589.  
  590.     // dołączenie funkcji generującej scenę 3D
  591.     glutDisplayFunc(Display);
  592.  
  593.     // dołączenie funkcji wywoływanej przy zmianie rozmiaru okna
  594.     glutReshapeFunc(Reshape);
  595.  
  596.     // dołączenie funkcji obsługi klawiatury
  597.     glutKeyboardFunc(Keyboard);
  598.  
  599.     // dołączenie funkcji obsługi klawiszy funkcyjnych i klawiszy kursora
  600.     glutSpecialFunc(SpecialKeys);
  601.  
  602.     // obsługa przycisków myszki
  603.     glutMouseFunc(MouseButton);
  604.  
  605.     // obsługa ruchu kursora myszki
  606.     glutMotionFunc(MouseMotion);
  607.  
  608.  
  609.     // utworzenie menu podręcznego
  610.     glutCreateMenu(Menu);
  611.  
  612.  
  613.  
  614.     // utworzenie podmenu - aspekt obrazu
  615.     int MenuAspect = glutCreateMenu(Menu);
  616. #ifdef WIN32
  617.  
  618.     glutAddMenuEntry("Aspekt obrazu - całe okno", FULL_WINDOW);
  619. #else
  620.  
  621.     glutAddMenuEntry("Aspekt obrazu - cale okno", FULL_WINDOW);
  622. #endif
  623.  
  624.     glutAddMenuEntry("Aspekt obrazu 1:1", ASPECT_1_1);
  625.  
  626.     // menu główne
  627.     glutCreateMenu(Menu);
  628.     glutAddSubMenu("Aspekt obrazu", MenuAspect);
  629. #ifdef WIN32
  630.  
  631.     glutAddMenuEntry("Wyjście", EXIT);
  632. #else
  633.  
  634.     glutAddMenuEntry("Wyjscie", EXIT);
  635. #endif
  636.  
  637.     // określenie przycisku myszki obsługującej menu podręczne
  638.     glutAttachMenu(GLUT_RIGHT_BUTTON);
  639.  
  640.     // sprawdzenie i przygotowanie obsługi wybranych rozszerzeń
  641.  
  642.     ExtensionSetup();
  643.  
  644.  
  645.     // wprowadzenie programu do obsługi pętli komunikatów
  646.     glutMainLoop();
  647.  
  648.     return 0;
  649. }
RAW Paste Data
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
 
Top