Advertisement
Guest User

Untitled

a guest
Jun 18th, 2018
633
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 17.51 KB | None | 0 0
  1. #include <windows.h>
  2. #include <stdio.h>
  3. #include <immintrin.h>
  4. #include <math.h>
  5. #include <time.h>
  6.  
  7. // Indice video for rotation's matrix
  8. #define     BPP                 4
  9. #define     LENGTH              1920                    // x
  10. #define     WIDTH               1080                    // y
  11. #define     DEPTH               2000                    // z
  12. #define     PITCH               screen_info[_x] * BPP
  13. #define     DEG2RAD(angle)      angle * (PI/180)
  14. #define     RAPPORT             (screen_info[_x]/screen_info[_y])
  15. #define     DISTANCE            1000
  16. #define     PI                  3.14159265          // 32-bit precise
  17.  
  18. // Standard color for rendering scene (copy through ColorPic program)
  19. #define     WHITE               0x00FFFFFF
  20. #define     BLACK               0x00000000
  21. #define     RED                 0x00FF0000
  22. #define     GREEN               0x0000FF00
  23. #define     BLUE                0x000000FF
  24. #define     BLUE_SCENE          0x0000204D
  25. #define     GREY_SCENE          0x001E1E22
  26. #define     MAP_GRID_SCENE      0x00585858
  27. #define     SELECT_OBJECT_SCENE 0x00FFA700
  28.  
  29. // Indice for array
  30. #define     _x                   0
  31. #define     _y                   1
  32. #define     _z                   2
  33. #define     _color               3
  34. #define     _2x                  4
  35. #define     _2y                  5
  36. #define     _2z                  6
  37. #define     _2color              7
  38. #define     _3x                  8
  39. #define     _3y                  9
  40. #define     _3z                 10
  41. #define     _3color             11
  42. #define     _4x                 12
  43. #define     _4y                 13
  44. #define     _4z                 14
  45. #define     _4color             15
  46.  
  47. #define     _next                1
  48. #define     _previous           -1
  49.  
  50. #define     SHIFT_WHEELUP        7864324
  51. #define     SHIFT_WHEELDOWN     -7864316
  52.  
  53. int         FPS_COUNTER_DATA[2] = { 0 };    // 0: compteur_boucle & affiche_fps , 1: last_time
  54.  
  55. int         quit = 1;
  56. int         offset_pixel = 0;
  57. int         screen_info[2];
  58. int         prev_coord_mouse[2];
  59. int         last_key;
  60. float       world_position[4];
  61. int         repere;
  62. int         speed_cam = 10;
  63.  
  64. int         screen[LENGTH*WIDTH] = { 0 };
  65.  
  66. float       voxel_cube[100 * 100 * 100 * 4];
  67. float       voxel_map[1000 * 1000 * 4];
  68.  
  69. HINSTANCE   instance;
  70. HBITMAP     texture;
  71. PAINTSTRUCT paint_struct;
  72. HDC         device_context_screen;
  73. HDC         device_context_texture;
  74. WNDCLASS    windows_class;
  75. HWND        windows_handle;
  76. HWND        windows_handle_2;
  77. MSG         event;
  78. LRESULT     anwser;
  79. HICON       icon_program;
  80.  
  81. typedef union xmm
  82. {
  83.     float   v[4];
  84.     __m128  xmm;
  85. }vector128;
  86. vector128   temp128;
  87.  
  88. vector128   pixel_coord;
  89.  
  90. vector128   sincosps_angle;
  91. vector128   obj_cos;
  92. vector128   obj_sin;
  93. vector128   cam_cos;
  94. vector128   cam_sin;
  95. vector128   pi_180;
  96.  
  97. vector128   position_obj;
  98. vector128   angle_obj;
  99. vector128   repere_obj;
  100.  
  101. vector128   angle_cam;
  102. vector128   repere_cam;
  103. vector128   position_cam;
  104.  
  105. vector128   cam_x;      // vector_right
  106. vector128   cam_y;      // vector_up
  107. vector128   cam_z;      // vector_forward
  108.  
  109. typedef union ymm
  110. {
  111.     float   v[8];
  112.     __m256  ymm;
  113. }vector256;
  114. vector256   temp256;
  115.  
  116. void    put_pixel(float *_obj)
  117. {
  118.     float   obj_end[4];
  119.     float   obj[4];
  120.  
  121.     obj[_x] = _obj[_x];
  122.     obj[_y] = _obj[_y];
  123.     obj[_z] = _obj[_z];
  124.  
  125.     obj[_x] += position_obj.v[_x];
  126.     obj[_y] += position_obj.v[_y];
  127.     obj[_z] += position_obj.v[_z];
  128.  
  129.     // Object Management
  130.         // Rotate xyz
  131.         obj_end[_x] = obj[_x] * ((obj_cos.v[_y] * obj_cos.v[_z])) - obj[_y] * ((obj_cos.v[_y] * obj_sin.v[_z])) - obj[_z] * (obj_sin.v[_y]);
  132.         obj_end[_y] = obj[_x] * ((obj_cos.v[_x] * obj_sin.v[_z]) - (obj_sin.v[_x] * obj_sin.v[_y] * obj_cos.v[_z])) + obj[_y] * ((obj_sin.v[_x] * obj_sin.v[_y] * obj_sin.v[_z]) + (obj_cos.v[_x] * obj_cos.v[_z])) - obj[_z] * (obj_sin.v[_x] * obj_cos.v[_y]);
  133.         obj_end[_z] = obj[_x] * ((obj_cos.v[_x] * obj_sin.v[_y] * obj_cos.v[_z]) + (obj_sin.v[_x] * obj_sin.v[_z])) + obj[_y] * ((obj_sin.v[_x] * obj_cos.v[_z]) - (obj_cos.v[_x] * obj_sin.v[_y] * obj_sin.v[_z])) + obj[_z] * (obj_cos.v[_x] * obj_cos.v[_y]);
  134.  
  135.         obj[_x] = obj_end[_x];
  136.         obj[_y] = obj_end[_y];
  137.         obj[_z] = obj_end[_z];
  138.  
  139.         obj[_x] += repere_obj.v[_x];
  140.         obj[_y] += repere_obj.v[_y];
  141.         obj[_z] += repere_obj.v[_z];
  142.  
  143.         //obj[_x] += world_position[_x];
  144.         //obj[_y] += world_position[_y];
  145.         //obj[_z] += world_position[_z];
  146.        
  147.     // Camera Management
  148.  
  149.         obj[_x] -= repere_cam.v[_x];
  150.         obj[_y] -= repere_cam.v[_y];
  151.         obj[_z] -= repere_cam.v[_z];
  152.  
  153.         // Rotate xyz
  154.         obj_end[_x] = obj[_x] * ((cam_cos.v[_y] * cam_cos.v[_z])) - obj[_y] * ((cam_cos.v[_y] * cam_sin.v[_z])) - obj[_z] * (cam_sin.v[_y]);
  155.         obj_end[_y] = obj[_x] * ((cam_cos.v[_x] * cam_sin.v[_z]) - (cam_sin.v[_x] * cam_sin.v[_y] * cam_cos.v[_z])) + obj[_y] * ((cam_sin.v[_x] * cam_sin.v[_y] * cam_sin.v[_z]) + (cam_cos.v[_x] * cam_cos.v[_z])) - obj[_z] * (cam_sin.v[_x] * cam_cos.v[_y]);
  156.         obj_end[_z] = obj[_x] * ((cam_cos.v[_x] * cam_sin.v[_y] * cam_cos.v[_z]) + (cam_sin.v[_x] * cam_sin.v[_z])) + obj[_y] * ((cam_sin.v[_x] * cam_cos.v[_z]) - (cam_cos.v[_x] * cam_sin.v[_y] * cam_sin.v[_z])) + obj[_z] * (cam_cos.v[_x] * cam_cos.v[_y]);
  157.  
  158.     obj[_x] = obj_end[_x];
  159.     obj[_y] = obj_end[_y];
  160.     obj[_z] = obj_end[_z];
  161.  
  162.     obj[_x] -= position_cam.v[_x];
  163.     obj[_y] -= position_cam.v[_y];
  164.     obj[_z] -= position_cam.v[_z];
  165.  
  166.     obj[_z] *= -1;
  167.     obj[_x] = (obj[_x] * DISTANCE) / (obj[_z]);
  168.     obj[_y] = (obj[_y] * DISTANCE) / (obj[_z]);
  169.  
  170.     if ((obj[_x] <= (screen_info[_x] / 2) - 0 && obj[_x] >= (-screen_info[_x] / 2)) &&
  171.         (obj[_y] <= (screen_info[_y] / 2) - 0 && obj[_y] >= -(screen_info[_y] / 2)) && (obj[_z] <= 0))
  172.     {
  173.         offset_pixel = repere - (screen_info[_x] * (int)obj[_y]) + (int)obj[_x];
  174.         screen[offset_pixel] = _obj[_color];
  175.     }
  176. }
  177.  
  178. void    make_voxel_map(float *cube, float size)
  179. {
  180.     float   x, z;
  181.     float   cote_voxel_cube = size;
  182.     int     indice;
  183.     float   angle;
  184.  
  185.     x = cote_voxel_cube;
  186.     indice = angle = 0;
  187.     while (x > -cote_voxel_cube) //fill_cube_volume
  188.     {
  189.         z = cote_voxel_cube;
  190.         while (z > -cote_voxel_cube) //fill_cube_line
  191.         {
  192.             angle += 5;
  193.             cube[indice + _x] = x * 8;
  194.             cube[indice + _y] = sin(DEG2RAD(angle)) * 20;
  195.             cube[indice + _z] = z * 8;
  196.             cube[indice + _color] = BLUE;
  197.             indice += 4;
  198.             z--;
  199.         }
  200.         angle = 0;
  201.         x--;
  202.     }
  203. }
  204.  
  205. void    make_voxel_cube(float *cube, float size)
  206. {
  207.     float   x, y, z;
  208.     float   cote_voxel_cube = size;
  209.     int     indice;
  210.  
  211.     x = cote_voxel_cube;
  212.     indice = 0;
  213.     while (x > -cote_voxel_cube) //fill_cube_volume
  214.     {
  215.         y = cote_voxel_cube;
  216.         while (y > -cote_voxel_cube) //fill_cube_surface
  217.         {
  218.             z = cote_voxel_cube;
  219.             while (z > -cote_voxel_cube) //fill_cube_line
  220.             {
  221.                 cube[indice + _x] = x * 1; // distance between vertex
  222.                 cube[indice + _y] = y * 1;
  223.                 cube[indice + _z] = z * 1;
  224.                 cube[indice + _color] = BLUE;
  225.                 indice += 4;
  226.                 z--;
  227.             }
  228.             y--;
  229.         }
  230.         x--;
  231.     }
  232. }
  233.  
  234. void    put_object(float *object, int size)
  235. {
  236.     sincosps_angle.xmm = _mm_mul_ps(angle_obj.xmm, pi_180.xmm);
  237.  
  238.     obj_sin.v[_x] = sin(sincosps_angle.v[0]);
  239.     obj_sin.v[_y] = sin(sincosps_angle.v[1]);
  240.     obj_sin.v[_z] = sin(sincosps_angle.v[2]);
  241.  
  242.     obj_cos.v[_x] = cos(sincosps_angle.v[0]);
  243.     obj_cos.v[_y] = cos(sincosps_angle.v[1]);
  244.     obj_cos.v[_z] = cos(sincosps_angle.v[2]);
  245.  
  246.     sincosps_angle.xmm = _mm_mul_ps(angle_cam.xmm, pi_180.xmm);
  247.  
  248.     cam_sin.v[_x] = sin(-sincosps_angle.v[0]);
  249.     cam_sin.v[_y] = sin(-sincosps_angle.v[1]);
  250.     cam_sin.v[_z] = sin(-sincosps_angle.v[2]);
  251.  
  252.     cam_cos.v[_x] = cos(-sincosps_angle.v[0]);
  253.     cam_cos.v[_y] = cos(-sincosps_angle.v[1]);
  254.     cam_cos.v[_z] = cos(-sincosps_angle.v[2]);
  255.  
  256.     // Camera Management
  257.         // right/left
  258.         cam_x.v[_x] = speed_cam * (cam_cos.v[_y] * cam_cos.v[_z]);
  259.         cam_x.v[_y] = speed_cam * (cam_cos.v[_x] * cam_sin.v[_z]) - (cam_sin.v[_x] * cam_sin.v[_y] * cam_cos.v[_z]);
  260.         cam_x.v[_z] = speed_cam * (cam_cos.v[_x] * cam_sin.v[_y] * cam_cos.v[_z]) + (cam_sin.v[_x] * cam_sin.v[_z]);
  261.  
  262.         // up/down
  263.         cam_y.v[_x] = speed_cam * (cam_cos.v[_y] * cam_sin.v[_z]);
  264.         cam_y.v[_y] = speed_cam * (cam_sin.v[_x] * cam_sin.v[_y] * cam_sin.v[_z]) + (cam_cos.v[_x] * cam_cos.v[_z]);
  265.         cam_y.v[_z] = speed_cam * (cam_sin.v[_x] * cam_cos.v[_z]) - (cam_cos.v[_x] * cam_sin.v[_y] * cam_sin.v[_z]);
  266.  
  267.         // forward/backward
  268.         cam_z.v[_x] = speed_cam * (cam_sin.v[_y]);
  269.         cam_z.v[_y] = speed_cam * (cam_sin.v[_x] * cam_cos.v[_y]);
  270.         cam_z.v[_z] = speed_cam * (cam_cos.v[_x] * cam_cos.v[_y]);
  271.  
  272.     while (size)
  273.     {
  274.         put_pixel(object);
  275.         object += 4;
  276.         size--;
  277.     }
  278. }
  279.  
  280. void    clear_screen()
  281. {
  282.     int loop = 0;
  283.  
  284.     while (loop < screen_info[_x] * screen_info[_y])
  285.         screen[loop++] = BLACK;
  286. }
  287.  
  288. void    reset_phi()
  289. {
  290.     if (angle_obj.v[_x] >= 360)
  291.         angle_obj.v[_x] = angle_obj.v[_x] - 360;
  292.  
  293.     if (angle_obj.v[_y] >= 360)
  294.         angle_obj.v[_y] = angle_obj.v[_y] - 360;
  295.  
  296.     if (angle_obj.v[_z] >= 360)
  297.         angle_obj.v[_z] = angle_obj.v[_z] - 360;
  298.  
  299.     if (angle_obj.v[_x] <= -360)
  300.         angle_obj.v[_x] = angle_obj.v[_x] + 360;
  301.  
  302.     if (angle_obj.v[_y] <= -360)
  303.         angle_obj.v[_y] = angle_obj.v[_y] + 360;
  304.  
  305.     if (angle_obj.v[_z] <= -360)
  306.         angle_obj.v[_z] = angle_obj.v[_z] + 360;
  307. }
  308.  
  309. void    upload_screen()
  310. {
  311.     SetBitmapBits(texture, screen_info[_x] * screen_info[_y] * BPP, screen);
  312.     BitBlt(device_context_screen, 0, 0, screen_info[_x], screen_info[_y], device_context_texture, 0, 0, SRCCOPY);
  313. }
  314.  
  315. void    manage_keyboard(UINT message, WPARAM state)
  316. {
  317.     //printf("msg = %d\n", message);
  318.     //printf("state = %d\n", state);
  319.  
  320.     switch (message)
  321.     {
  322.         case WM_KEYDOWN:
  323.             switch (state)
  324.             {
  325.                 case VK_ESCAPE:
  326.                 break;
  327.  
  328.                 case 'W':       // Moving Forward
  329.                     repere_cam.v[_x] += cam_z.v[_x];
  330.                     repere_cam.v[_y] += cam_z.v[_y];
  331.                     repere_cam.v[_z] += cam_z.v[_z];
  332.                 break;
  333.  
  334.                 case 'S':       // Movin Backward
  335.                     repere_cam.v[_x] -= cam_z.v[_x];
  336.                     repere_cam.v[_y] -= cam_z.v[_y];
  337.                     repere_cam.v[_z] -= cam_z.v[_z];
  338.                 break;
  339.  
  340.                 case 'D':       // Moving Right
  341.                     repere_cam.v[_x] += cam_x.v[_x];
  342.                     repere_cam.v[_y] += cam_x.v[_y];
  343.                     repere_cam.v[_z] += cam_x.v[_z];
  344.                 break;
  345.  
  346.                 case 'A':       // Moving Left
  347.                     repere_cam.v[_x] -= cam_x.v[_x];
  348.                     repere_cam.v[_y] -= cam_x.v[_y];
  349.                     repere_cam.v[_z] -= cam_x.v[_z];
  350.                 break;
  351.  
  352.                 case 'Z':       // Rotate Left
  353.                     angle_cam.v[_y] -= 2;
  354.                 break;
  355.  
  356.                 case 'X':       // Rotate Right
  357.                     angle_cam.v[_y] += 2;
  358.                 break;
  359.  
  360.                 case 'Q':       // Moving Up
  361.                     repere_cam.v[_x] += cam_y.v[_x];
  362.                     repere_cam.v[_y] += cam_y.v[_y];
  363.                     repere_cam.v[_z] += cam_y.v[_z];
  364.                 break;
  365.  
  366.                 case 'E':       // Moving Down
  367.                     repere_cam.v[_x] -= cam_y.v[_x];
  368.                     repere_cam.v[_y] -= cam_y.v[_y];
  369.                     repere_cam.v[_z] -= cam_y.v[_z];
  370.                 break;
  371.             }
  372.         break;
  373.  
  374.         case WM_KEYUP:
  375.             switch (state)
  376.             {
  377.                 case VK_SHIFT:
  378.                     last_key = 0;
  379.                 break;
  380.             }
  381.         break;
  382.  
  383.             // ALT + `
  384.         case 260:
  385.             switch (state)
  386.             {
  387.                 case 222:
  388.                     quit = 0;
  389.                 break;
  390.             }
  391.         break;
  392.  
  393.         case MK_CONTROL:
  394.         break;
  395.  
  396.         //PostMessage(windows_handle, WM_KEYUP, VK_ESCAPE, 0);
  397.         //SendMessage(windows_handle, WM_KEYUP, 0, 0);
  398.        
  399.         case WM_CLOSE:
  400.             quit = 0;
  401.         break;
  402.     }
  403. }
  404.  
  405. void    manage_mouse(UINT message, WPARAM state, int x, int y)
  406. {
  407.     float   add_angle[2];
  408.     float   temp[4];
  409.  
  410.     reset_phi();
  411.  
  412.     x = x - (screen_info[_x] / 2);
  413.     y = y - (screen_info[_y] / 2);
  414.     y *= -1;
  415.  
  416.     switch (message)
  417.     {
  418.     case WM_MOUSEMOVE:
  419.         switch (state)
  420.         {
  421.         case MK_LBUTTON:
  422.             add_angle[_x] = (y - prev_coord_mouse[_y]) / 2;
  423.             add_angle[_y] = (x - prev_coord_mouse[_x]) / 2;
  424.  
  425.             angle_cam.v[_y] += add_angle[_y];
  426.             angle_cam.v[_x] += add_angle[_x];
  427.             break;
  428.  
  429.         case MK_RBUTTON:
  430.             break;
  431.         }
  432.         prev_coord_mouse[_x] = x;
  433.         prev_coord_mouse[_y] = y;
  434.         break;
  435.  
  436.     case WM_MOUSEWHEEL:
  437.         switch (state)
  438.         {
  439.         case SHIFT_WHEELUP:
  440.             repere_cam.v[_z] -= 0.8;
  441.             break;
  442.  
  443.         case SHIFT_WHEELDOWN:
  444.             repere_cam.v[_z] += 0.8;
  445.             break;
  446.         }
  447.         break;
  448.  
  449.     case WM_LBUTTONDOWN:
  450.         // puts("WM_LBUTTONDOWN");
  451.         break;
  452.  
  453.     case WM_LBUTTONUP:
  454.         // puts("WM_LBUTTONUP");
  455.         break;
  456.  
  457.     case WM_RBUTTONDOWN:
  458.         // puts("WM_RBUTTONDOWN");
  459.         break;
  460.  
  461.     case WM_RBUTTONUP:
  462.         //puts("WM_RBUTTONUP");
  463.         break;
  464.  
  465.     case WM_MBUTTONDOWN:
  466.         //puts("WM_MBUTTONDOWN");
  467.         break;
  468.  
  469.     case WM_MBUTTONUP:
  470.         // puts("WM_MBUTTONUP");
  471.         break;
  472.  
  473.     case WM_XBUTTONDOWN:
  474.         //puts("WM_XBUTTONDOWN");
  475.         break;
  476.  
  477.     case WM_XBUTTONUP:
  478.         //puts("WM_XBUTTONUP");
  479.         break;
  480.     }
  481. }
  482.  
  483. LRESULT CALLBACK windows_procedure(HWND windows_handle, UINT message, WPARAM w_param_msg, LPARAM l_param_msg)
  484. {
  485.     switch (message)
  486.     {
  487.     case WM_SIZE:
  488.         screen_info[_x] = LOWORD(l_param_msg);
  489.         screen_info[_y] = HIWORD(l_param_msg);
  490.         repere = (screen_info[_x] * (screen_info[_y] / 2 - 1)) + ((screen_info[_x] / 2 - 1));
  491.  
  492.         texture = CreateCompatibleBitmap(device_context_screen, screen_info[_x], screen_info[_y]);
  493.         device_context_texture = CreateCompatibleDC(device_context_screen);
  494.         SelectObject(device_context_texture, texture);
  495.         break;
  496.     }
  497.  
  498.     manage_keyboard(message, w_param_msg);                                         // msg, state
  499.     manage_mouse(message, w_param_msg, LOWORD(l_param_msg), HIWORD(l_param_msg));  // msg, state, x, y
  500.  
  501.                                                                                    // Switch first or 2nd instruction for get windowed or full screen
  502.     return  DefWindowProc(windows_handle, message, w_param_msg, l_param_msg);;
  503.     //return    1;
  504. }
  505.  
  506. void    init_video(void)
  507. {
  508.     windows_class.cbClsExtra = 0;
  509.     windows_class.cbWndExtra = 0;
  510.     windows_class.hbrBackground = 0;
  511.     windows_class.hCursor = 0;
  512.     windows_class.hIcon = icon_program;
  513.     windows_class.hInstance = instance;
  514.     windows_class.lpfnWndProc = windows_procedure;
  515.     windows_class.lpszClassName = "Classe 1";
  516.     windows_class.lpszMenuName = NULL;
  517.     windows_class.style = CS_HREDRAW | CS_VREDRAW;
  518.     RegisterClass(&windows_class);
  519.  
  520.     windows_handle = CreateWindow("Classe 1",
  521.                                   "VoxEngine",
  522.                                   WS_OVERLAPPEDWINDOW | WS_VISIBLE,
  523.                                   CW_USEDEFAULT, CW_USEDEFAULT, screen_info[_x], screen_info[_y],
  524.                                   NULL,
  525.                                   NULL,
  526.                                   instance,
  527.                                   NULL);
  528.  
  529.     device_context_screen = GetDC(windows_handle);
  530.     texture = CreateCompatibleBitmap(device_context_screen, screen_info[_x], screen_info[_y]);
  531.     device_context_texture = CreateCompatibleDC(device_context_screen);
  532.     SelectObject(device_context_texture, texture);
  533. }
  534.  
  535. int     main(HINSTANCE _instance, HINSTANCE _previous_instance, LPSTR cmd_line, int cmd_show)
  536. {
  537.     windows_handle_2 = GetDesktopWindow();
  538.     instance = _instance;
  539.  
  540.     icon_program = LoadImage(NULL, "Data/Icon.ico", IMAGE_ICON, 0, 0, LR_LOADFROMFILE);
  541.     system("color 0A");
  542.  
  543.     pi_180.v[_x] = PI / 180;
  544.     pi_180.v[_y] = PI / 180;
  545.     pi_180.v[_z] = PI / 180;
  546.     pi_180.v[3] = 0;
  547.  
  548.     screen_info[_x] = 1024;
  549.     screen_info[_y] = 800;
  550.     repere = (screen_info[_x] * (screen_info[_y] / 2 - 1)) + ((screen_info[_x] / 2 - 1));
  551.     init_video();
  552.  
  553.     make_voxel_map(voxel_map, 500);
  554.     //make_voxel_cube(voxel_cube, 49);
  555.  
  556.     while (quit)
  557.     {
  558.         PeekMessage(&event, windows_handle, 0, 0, PM_REMOVE);
  559.         windows_procedure(windows_handle, event.message, event.wParam, event.lParam);
  560.  
  561.         put_object(voxel_map, 1000 * 1000);
  562.         //put_object(voxel_cube, 1000 * 1000);
  563.  
  564.         upload_screen();
  565.  
  566.         // Show FPS:
  567.             FPS_COUNTER_DATA[0]++;
  568.             if (clock() - FPS_COUNTER_DATA[1] >= 1000)
  569.             {
  570.                 printf("FPS = %d\n", FPS_COUNTER_DATA[0]);
  571.                 FPS_COUNTER_DATA[0] = 0;
  572.                 FPS_COUNTER_DATA[1] = clock();
  573.             }
  574.  
  575.         clear_screen();
  576.     }
  577.  
  578.     return  0xdeadbeef;
  579. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement