API tools faq
paste
Advertisement
Ladies_Man

#CG LAB1 (solar system) COMPLETE

Ladies_Man
Mar 4th, 2015
289
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 12.25 KB | None | 0 0
raw download clone embed print report
  1. //управление: стрелочки
  2.  
  3. // glfw_30.cpp : Defines the entry point for the console application.
  4. //  http://www.glfw.org/docs/latest/quick.html
  5.  
  6. #include "stdafx.h"
  7. #include <time.h>
  8. #define _USE_MATH_DEFINES // for C++
  9. #include <cmath>
  10.  
  11. #define SCREEN_WIDTH 1500
  12. #define SCREEN_HEIGHT 1000
  13.  
  14. #define CENTER_X SCREEN_WIDTH/2
  15. #define CENTER_Y SCREEN_HEIGHT/2
  16. //------------IDS--------------
  17. #define SUN_ID 0
  18. #define MERCURY_ID 1
  19. #define VENUS_ID 2
  20. #define EARTH_ID 3
  21. #define MARS_ID 4
  22. #define JUPITER_ID 5
  23. #define SATURN_ID 6
  24. #define UrAnus_ID 7
  25. #define PLANEPTUNE_ID 8
  26. #define PLUTO_ID 9
  27. //----------SIZES--------------
  28. #define SUN_SIZE 70
  29. #define MERCURY_SIZE 8
  30. #define VENUS_SIZE 11
  31. #define EARTH_SIZE 11
  32. #define LUNA_SIZE 3
  33. #define MARS_SIZE 8
  34. #define JUPITER_SIZE 58
  35. #define JUPITER_MOON_SIZE_MIN 2
  36. #define JUPITER_MOON_SIZE_MAX 4
  37. #define SATURN_SIZE 37
  38. #define SATURN_MOON_SIZE_MIN 2
  39. #define SATURN_MOON_SIZE_MAX 4
  40. #define UrAnus_SIZE 25
  41. #define PLANEPTUNE_SIZE 23
  42. #define PLUTO_SIZE 3
  43. //----------DISTS--------------
  44. #define SUN_DIST 0
  45. #define MERCURY_DIST 170
  46. #define VENUS_DIST 210
  47. #define EARTH_DIST 245
  48. #define LUNA_DIST (EARTH_SIZE + 8)  //relatively to earth
  49. #define MARS_DIST 290
  50. #define AST_BELT_START 340
  51. #define AST_BELT_STOP 355
  52. #define JUPITER_DIST 460
  53. #define JUPITER_MOON_DIST (JUPITER_SIZE + 8)    //relatively to saturn
  54. #define SATURN_DIST 600
  55. #define SATURN_MOON_DIST (SATURN_SIZE + 10) //relatively to saturn
  56. #define UrAnus_DIST 685
  57. #define PLANEPTUNE_DIST 750
  58. #define PLUTO_DIST 795
  59. //---------OFFSETS------------
  60. #define SUN_OFFSET 0
  61. #define MERCURY_OFFSET 0
  62. #define VENUS_OFFSET 0
  63. #define EARTH_OFFSET 0
  64. #define MARS_OFFSET 0
  65. #define JUPITER_OFFSET 0
  66. #define SATURN_OFFSET 0
  67. #define UrAnus_OFFSET 15
  68. #define PLANEPTUNE_OFFSET -20
  69. #define PLUTO_OFFSET 40
  70. //--------VELOCITIES----------
  71. #define MERCURY_SPEED 1.5
  72. #define VENUS_SPEED 3
  73. #define EARTH_SPEED 6.3
  74. #define MARS_SPEED 9
  75. #define JUPITER_SPEED 25
  76. #define SATURN_SPEED 34
  77. #define UrAnus_SPEED 50
  78. #define PLANEPTUNE_SPEED 60
  79. #define PLUTO_SPEED 70
  80. //-----------MISC------------
  81. #define JUPITER_MOON_NUM 1
  82. #define SATURN_MOON_NUM 10
  83.  
  84. GLdouble A, B, C, D;
  85.  
  86. int flag;
  87.  
  88. static void cursor_callback(GLFWwindow* window, double x, double y)
  89. {
  90.    
  91. }
  92.  
  93. static void mouse_callback(GLFWwindow* window, int button, int action, int mods)
  94. {
  95.     if(button == GLFW_MOUSE_BUTTON_RIGHT)
  96.     {
  97.         if(action == GLFW_PRESS) glfwSetInputMode( window, GLFW_CURSOR, GLFW_CURSOR_HIDDEN);
  98.         if(action == GLFW_RELEASE) glfwSetInputMode( window, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
  99.     }
  100.  
  101.     if(button == GLFW_MOUSE_BUTTON_LEFT)
  102.     {
  103.        
  104.     }
  105. }
  106.  
  107. static void resize_callback(GLFWwindow* window, int width, int height)
  108. {
  109. //  windowWidth = width;
  110. //  windowHeight = height;
  111.  
  112.     glViewport(0, 0, width, height);
  113.     glMatrixMode(GL_PROJECTION);
  114.     glLoadIdentity();
  115.     glOrtho( 0.0, (GLdouble)width, 0.0, (GLdouble)height, -1, 1);  
  116.  
  117.     glMatrixMode(GL_MODELVIEW);
  118.     glLoadIdentity();
  119.        
  120.     A = width / 4.0;
  121.     B = 0.0;
  122.     C = D = height / 2.0;
  123.  
  124.     printf("Reshape occured\n");
  125. }
  126.  
  127. static void keyboard_callback(GLFWwindow* window, int key, int scancode, int action, int mods)
  128. {
  129.     if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS)
  130.         glfwSetWindowShouldClose(window, GL_TRUE);
  131. }
  132.  
  133. void draw_stars(int num)
  134. {
  135.     int i;
  136.  
  137.     glPointSize(1.0);
  138.     srand(time(NULL));
  139.     for (i = 0; i < num; i++) {
  140.         glBegin(GL_POINTS);
  141.             glColor3f(1, 1, 1);
  142.             glVertex2i(rand() % SCREEN_WIDTH, rand() % SCREEN_HEIGHT);
  143.         glEnd();
  144.     }
  145. }
  146.  
  147. void scroll_callback(GLFWwindow* window, double xoffset, double yoffset)
  148. {
  149.     if (yoffset > 1) {
  150.         flag++;
  151.         draw_stars(1000);
  152.     }
  153.     else {
  154.         flag--;
  155.     }
  156. }
  157.  
  158. static void error_callback(int error, const char* description)
  159. {
  160.     fputs(description, stderr);
  161. }
  162.  
  163.  
  164.  
  165. void draw_space_object(int id, int dist, int offset, int size, GLfloat angle)
  166. {
  167.     GLfloat phi = 0, theta = 0;
  168.     int i = 0, moon_size = 5, moon_dist = 5, moon_speed = 10, start_pos;
  169.    
  170.     if (id == SUN_ID) {
  171.  
  172.     }
  173.     if (id == EARTH_ID) {
  174.         glPointSize(2.0);
  175.         glBegin(GL_POLYGON);    //luna
  176.         for (theta = 0; theta < 2 * M_PI; theta += 0.1) {
  177.             glColor3f(0.8, 0.8, 0.9);
  178.             glVertex2f(CENTER_X + offset + dist*cos(angle) - LUNA_DIST*sin(angle*EARTH_SPEED) + LUNA_SIZE*cos(theta), CENTER_Y + offset + dist*sin(angle) + LUNA_DIST*cos(angle*EARTH_SPEED) + LUNA_SIZE*sin(theta));
  179.         }
  180.         glEnd();
  181.     }
  182.  
  183.     srand(time(NULL));
  184.     if (id == JUPITER_ID) {
  185.         for (i = 0; i < JUPITER_MOON_NUM; i++) {
  186.             glPointSize(1.0);
  187.             glBegin(GL_POLYGON);    //jupiter rings
  188.             for (theta = 0; theta < 2 * M_PI; theta += 0.1) {
  189.                 glColor3f(1, 1, 1);
  190.                 moon_size = rand() % JUPITER_MOON_SIZE_MAX + JUPITER_MOON_SIZE_MIN;
  191.                 moon_dist = rand() % JUPITER_MOON_NUM * 10 + JUPITER_MOON_DIST + i * 3;
  192.                 moon_speed = 10;
  193.                 glVertex2f(CENTER_X + offset + dist*cos(angle) + (JUPITER_MOON_DIST + i * 3)*cos(angle*(moon_speed + i) + i) + moon_size*cos(theta), CENTER_Y + offset + dist*sin(angle) + (JUPITER_MOON_DIST + i * 3)*sin(angle*(moon_speed + i) + i) + moon_size*sin(theta));
  194.             }
  195.             glEnd();
  196.         }
  197.     }
  198.     if (id == SATURN_ID) {
  199.         glPointSize(2.0);
  200.         glBegin(GL_POLYGON);    //saturn ring = 1.9*saturn_size
  201.         for (phi = 0; phi < 2 * M_PI; phi += 0.1) {
  202.             glColor3f(0.8, 0.5, 0.2);
  203.             glVertex2f(CENTER_X + offset + dist*cos(angle) + size*1.9*cos(phi), CENTER_Y + offset + dist*sin(angle) + size*1.9*sin(phi));
  204.         }
  205.         glEnd();
  206.  
  207.         glPointSize(2.0);
  208.         glBegin(GL_POLYGON);    //space between ring and planet is just  black ring
  209.         for (phi = 0; phi < 2 * M_PI; phi += 0.1) {
  210.             glColor3f(0, 0, 0);
  211.             glVertex2f(CENTER_X + offset + dist*cos(angle) + size*1.1*cos(phi), CENTER_Y + offset + dist*sin(angle) + size*1.1*sin(phi));
  212.         }
  213.         glEnd();
  214.         for (i = 0; i < SATURN_MOON_NUM; i++) {
  215.             glPointSize(1.0);
  216.             glBegin(GL_POLYGON);    //saturn rings
  217.             for (theta = 0; theta < 2 * M_PI; theta += 0.1) {
  218.                 glColor3f(1, 0.4, 0.2);
  219.                 moon_size = rand() % SATURN_MOON_SIZE_MAX + SATURN_MOON_SIZE_MIN;
  220.                 moon_dist = rand() % SATURN_MOON_NUM * 10 + SATURN_MOON_DIST + i * 3;
  221.                 moon_speed = 15;
  222.                 glVertex2f(CENTER_X + offset + dist*cos(angle) + (SATURN_MOON_DIST + i * 3)*cos(angle*(moon_speed + i*0.8) + i) + moon_size*cos(theta), CENTER_Y + offset + dist*sin(angle) + (SATURN_MOON_DIST + i * 3)*sin(angle*(moon_speed + i*0.8) + i) + moon_size*sin(theta));
  223.             }
  224.             glEnd();
  225.         }
  226.     }
  227.     glPointSize(2.0);
  228.     glBegin(GL_POLYGON);
  229.     for (phi = 0; phi < 2*M_PI; phi += 0.1) {
  230.         //glColor3f(1, 1, 1);
  231.         if (id == SUN_ID) glColor3f(253, 160, 0.2);
  232.         if (id == MERCURY_ID) glColor3f(0.5, 0.5, 0.5);
  233.         if (id == VENUS_ID) glColor3f(1, 0.7, 0);
  234.         if (id == EARTH_ID) glColor3f(0, 0.4, 1);
  235.         if (id == MARS_ID) glColor3f(0.5, 0, 0);
  236.         if (id == JUPITER_ID) glColor3f(1, 0.6, 0.3);
  237.         if (id == SATURN_ID) glColor3f(1, 0.5, 0.2);
  238.         if (id == UrAnus_ID) glColor3f(0, 0.7, 0.7);
  239.         if (id == PLANEPTUNE_ID) glColor3f(0, 0, 0.6);
  240.         if (id == PLUTO_ID) glColor3f(1, 0.7, 0);
  241.         glVertex2f(CENTER_X + offset + dist*cos(angle) + size*cos(phi), CENTER_Y + offset + dist*sin(angle) + size*sin(phi));
  242.     }
  243.     glEnd();
  244. }
  245.  
  246. void draw_asteroid_belt()
  247. {
  248.     GLfloat phi = 0, theta = 0;
  249.  
  250.     glPointSize(2.0);
  251.     glBegin(GL_POLYGON);
  252.     for (phi = 0; phi < 2 * M_PI; phi++) {
  253.  
  254.     }
  255.     glEnd();
  256. }
  257.  
  258. void drawPoint(int x, int y)
  259. {
  260.     glPointSize(1.0);
  261.     glBegin(GL_POINTS);
  262.         glColor3f(0.1f, 0.4f, 0.4f);
  263.         glVertex2i(x,y);
  264.     glEnd();
  265. }
  266.  
  267. typedef struct GLintPoint
  268. {
  269.     GLint   x;
  270.     GLint   y;
  271. } GLintPoint;
  272.  
  273. void serpinsky_drawing(void)
  274. {
  275.     GLintPoint T[3]= {{10,10},{210,310},{410,10}};
  276.  
  277.     int index = (int)floor((3.0 * rand()) / RAND_MAX);
  278.     // 0, 1 or 2 equally likely
  279.     // 0, 1 или 2 равновероятны
  280.     GLintPoint point = T[index];
  281.     // initial point
  282.     // начальная точка
  283.     drawPoint(point.x, point.y);
  284.     // draw initial point
  285.     // рисуем начальную точку
  286.     for(int i = 0; i < 100000; i++)
  287.         // draw 1000 dots
  288.         // рисуем 1000 точек
  289.     {
  290.         index = (int)floor((3.0 * rand()) / RAND_MAX);
  291.         point.x = (point.x + T[index].x) / 2;
  292.         point.y = (point.y + T[index].y) / 2;
  293.         drawPoint(point.x,point.y);
  294.     }
  295. }
  296.  
  297. void function_drawing(void)
  298. {
  299.     glClear(GL_COLOR_BUFFER_BIT);
  300.    
  301.     glEnable(GL_LINE_STIPPLE);
  302.     glColor3f(1.0f,0.3f,0.3f);
  303.     //glBegin(GL_LINE_STRIP);
  304.     //glBegin(GL_LINE_LOOP);
  305.     glBegin(GL_POLYGON);
  306.         for(GLdouble x = 0; x < 1.0; x += 0.05)
  307.         {
  308.             GLdouble func = exp(-x) * cos(2 * 3.14159265 * x);
  309.             glVertex2d(A * x + B, C * func + D);
  310.         }
  311.     glEnd();
  312.     glDisable(GL_LINE_STIPPLE);
  313.     //glBegin(GL_LINE_STRIP);
  314.     glBegin(GL_LINE_LOOP);
  315.         for(GLdouble x = 1.0; x < 4.0; x += 0.05)
  316.         {
  317.             GLdouble func = exp(-x) * cos(2 * 3.14159265 * x);
  318.             glVertex2d(A * x + B, C * func + D);
  319.         }
  320.     glEnd();
  321.  
  322.  
  323.     glPointSize(4.0);
  324.     glColor3b((GLbyte)20,(GLbyte)26,(GLbyte)250);
  325.     glBegin(GL_POINTS);
  326.         for(GLdouble x = 0; x < 4.0; x += 0.05)
  327.         {
  328.             GLdouble func = exp(-x) * cos(2 * 3.14159265 * x);
  329.             glVertex2d(A * x + B, C * func + D);
  330.         }
  331.     glEnd();
  332. }
  333.  
  334. void test_drawing_A(void)
  335. {
  336.     glClearColor(1.0, 1.0, 1.0, 0.0);
  337.     glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
  338.     glColor3f(1.0,0.0,0.0);
  339.  
  340.     glPointSize(10);
  341.  
  342.     glBegin(GL_POINTS);
  343.         glVertex2i(200,200);
  344.         glVertex2i(300,300);
  345.     glEnd();
  346.  
  347.     glBegin(GL_QUADS);
  348.     {
  349.         glVertex2i(200, 200);
  350.         glVertex2i(100, 200);
  351.         glVertex2i(100, 100);
  352.         glVertex2i(200, 100);
  353.     }
  354.     glEnd();
  355. }
  356.  
  357. void draw(void)
  358. {
  359.     //test_drawing();
  360.     //test_drawing_A();
  361.     //serpinsky_drawing();
  362.     //function_drawing();  
  363. }
  364.  
  365. int main(int argc, _TCHAR* argv[])
  366. {
  367.     // initialise GLFW
  368.     if(!glfwInit())
  369.     {
  370.         printf("glfwInit failed\n");
  371.         return -1;
  372.     }
  373.  
  374.     glfwSetErrorCallback(error_callback);
  375.  
  376.     GLFWwindow* window;
  377.    
  378. //  glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 1);
  379. //  glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
  380.     //glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_COMPAT_PROFILE);
  381.     window = glfwCreateWindow(SCREEN_WIDTH, SCREEN_HEIGHT, "Test app", NULL, NULL);
  382.     if (window == NULL)
  383.     {
  384.         printf("glfwOpenWindow failed.\n");
  385.         glfwTerminate();
  386.         return -2;
  387.     }
  388.  
  389.     int attrib;
  390.     attrib = glfwGetWindowAttrib(window, GLFW_CONTEXT_VERSION_MAJOR);
  391.     attrib = glfwGetWindowAttrib(window, GLFW_CONTEXT_VERSION_MINOR);
  392.     attrib = glfwGetWindowAttrib(window, GLFW_OPENGL_PROFILE);
  393.  
  394.     glfwMakeContextCurrent(window);
  395.  
  396.     glfwSetKeyCallback(window, keyboard_callback);
  397.     glfwSetFramebufferSizeCallback(window, resize_callback);
  398.     glfwSetMouseButtonCallback(window, mouse_callback);
  399.     glfwSetCursorPosCallback(window, cursor_callback);
  400.     glfwSetScrollCallback(window, scroll_callback);
  401.    
  402.     resize_callback(window, SCREEN_WIDTH, SCREEN_HEIGHT);
  403.     GLfloat phi = 0, center = 0;
  404.     int i = 1;
  405.     while (!glfwWindowShouldClose(window))
  406.     {
  407.         // ESC = exit
  408.         // ^, v = change size
  409.         // <--, --> = rotate left, right
  410.         glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  411.        
  412.         if (glfwGetKey(window, GLFW_KEY_UP) == GLFW_PRESS) {
  413.             i += 5;
  414.         }
  415.         if (glfwGetKey(window, GLFW_KEY_DOWN) == GLFW_PRESS) {
  416.             i -= 5;
  417.         }
  418.         if (glfwGetKey(window, GLFW_KEY_RIGHT) == GLFW_PRESS) {
  419.             phi += 0.3;
  420.             draw_asteroid_belt();
  421.             draw_stars(1000);
  422.         }
  423.         if (glfwGetKey(window, GLFW_KEY_LEFT) == GLFW_PRESS) {
  424.             phi -= 0.3;
  425.             draw_asteroid_belt();
  426.             draw_stars(1000);
  427.         }
  428.        
  429.         draw_space_object(SUN_ID, SUN_DIST, SUN_OFFSET, SUN_SIZE + i, phi + M_PI);
  430.         draw_space_object(MERCURY_ID, MERCURY_DIST + i, MERCURY_OFFSET, MERCURY_SIZE, phi / MERCURY_SPEED + M_PI);
  431.         draw_space_object(VENUS_ID, VENUS_DIST + i, VENUS_OFFSET, VENUS_SIZE, phi / VENUS_SPEED + M_PI);
  432.         draw_space_object(EARTH_ID, EARTH_DIST + i, EARTH_OFFSET, EARTH_SIZE, phi / EARTH_SPEED + M_PI);
  433.         draw_space_object(MARS_ID, MARS_DIST + i, MARS_OFFSET, MARS_SIZE, phi / MARS_SPEED + M_PI);
  434.        
  435.         draw_space_object(JUPITER_ID, JUPITER_DIST + i, JUPITER_OFFSET, JUPITER_SIZE, phi / JUPITER_SPEED);
  436.         draw_space_object(SATURN_ID, SATURN_DIST + i, SATURN_OFFSET, SATURN_SIZE, phi / SATURN_SPEED);
  437.         draw_space_object(UrAnus_ID, UrAnus_DIST + i, UrAnus_OFFSET, UrAnus_SIZE, phi / UrAnus_SPEED);
  438.         draw_space_object(PLANEPTUNE_ID, PLANEPTUNE_DIST + i, PLANEPTUNE_OFFSET, PLANEPTUNE_SIZE, phi / PLANEPTUNE_SPEED - M_PI / 10);
  439.         draw_space_object(PLUTO_ID, PLUTO_DIST + i, PLUTO_OFFSET, PLUTO_SIZE, phi / PLUTO_SPEED);
  440.  
  441.         glfwSwapBuffers(window);
  442.         //glfwPollEvents();
  443.         glfwWaitEvents();
  444.     }
  445.  
  446.     glfwDestroyWindow(window);
  447.  
  448.     // clean up and exit
  449.     glfwTerminate();
  450.  
  451.     return 0;
  452. }
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!