a-game

platform_windows.c (5994B)

---

 // NOTE(amin): On windows, even with clang and -std=c11, assert.h doesn't
 // define static_assert.
 #define static_assert _Static_assert
 
 #include <time.h>
 
 #include "platform_info.h"
 #include "am_gl.h"
 #include <GLFW/glfw3.h>
 
 // LOL, Windef.h
 #undef near
 #undef far
 
 #include "game.c"
 #include "platform.h"
 #include "platform_windows.h"
 
 internal void framebuffer_size_callback(GLFWwindow* window, int width, int height);
 internal void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods);
 
 // TODO: map this in a nicer way
 global_variable int platform_input_map[NUM_GAME_BUTTONS] = {
     [BTN_LEFT] = GLFW_KEY_LEFT,
     [BTN_RIGHT] = GLFW_KEY_RIGHT,
     [BTN_UP] = GLFW_KEY_UP,
     [BTN_DOWN] = GLFW_KEY_DOWN,
     [BTN_JUMP] = GLFW_KEY_S,
     [BTN_DEBUG_FLOAT] = GLFW_KEY_F11,
 };
 
 int main(void)
 {
     glfwSetErrorCallback(error_callback);
 
     if (!glfwInit())
     {
         fprintf(stderr, "GLFW initialization failed\n");
         return -1;
     }
 
     glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
     glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
     glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
     glfwWindowHint(GLFW_RESIZABLE, GLFW_TRUE);
 
     GLFWwindow *window = glfwCreateWindow(PLATFORM_SCR_WIDTH, PLATFORM_SCR_HEIGHT, "A Game", NULL, NULL);
     if (!window)
     {
         fprintf(stderr, "GLFW window creation failed\n");
         glfwTerminate();
         return -1;
     }
     glfwMakeContextCurrent(window);
     glfwSetKeyCallback(window, key_callback);
 
     if (!am_gl_init())
     {
         fprintf(stderr, "OpenGL function loading failed\n.");
         glfwDestroyWindow(window);
         glfwTerminate();
         return -1;
     }
 
 #ifdef USE_TEST_SEED
     srand((uint32_t)0);
 #else
     srand((uint32_t)time(NULL));
 #endif
 
     struct GameMemory game_memory = {
         .buffer_size = MEBIBYTES(64),
         .platform = {
             &windows_read_entire_file,
             &windows_memory_free,
         },
     };
     // TODO: replace with VirtualAlloc
     game_memory.buffer = malloc(game_memory.buffer_size);
     if (!game_memory.buffer)
     {
         fprintf(stderr, "Game memory allocation failed\n");
         glfwTerminate();
         return -1;
     }
 
     struct GameInput game_input = {0};
     glfwSetWindowUserPointer(window, &game_input);
     game_init(&game_memory, (v2u) {PLATFORM_SCR_WIDTH, PLATFORM_SCR_HEIGHT});
 
     // NOTE(amin): lag should always be very small, so it's fine to use a float
     // to store it. We will not run out of precision.
     uint64_t previous_wall_clock_time = glfwGetTimerValue();
     uint64_t timer_frequency = glfwGetTimerFrequency();
 
     while (!glfwWindowShouldClose(window))
     {
         uint64_t current_wall_clock_time = glfwGetTimerValue();
 
         {
             uint64_t previous_frame_duration = current_wall_clock_time - previous_wall_clock_time;
             previous_wall_clock_time = current_wall_clock_time;
             f32 dt = (float)previous_frame_duration / (float)timer_frequency;
             // TODO: Debug periodic dropped frame on linux when fullscreen
             //printf("ms per frame: %f\n", dt * 1000.0f);
             game_input.dt = dt;
         }
 
         int32_t framebuffer_width = PLATFORM_SCR_WIDTH;
         int32_t framebuffer_height = PLATFORM_SCR_HEIGHT;
         glfwGetFramebufferSize(window, &framebuffer_width, &framebuffer_height);
         assert(framebuffer_width >= 0);
         assert(framebuffer_height >= 0);
         v2u framebuffer = {framebuffer_width, framebuffer_height};
 
         game_update_and_render(&game_memory, &game_input, framebuffer);
 
         // TODO: Do something sane when vsync is disabled
         glfwSwapBuffers(window);
         glfwPollEvents();
     }
 
     game_cleanup(&game_memory);
 
     // TODO: replace with VirtualFree
     free(game_memory.buffer);
 
     glfwDestroyWindow(window);
     glfwTerminate();
     return 0;
 }
 
 internal void error_callback(int error, const char *description)
 {
     fprintf(stderr, "Error: %s\n", description);
 }
 
 internal void key_callback(GLFWwindow *window, int key, int scancode, int action, int mods)
 {
     struct GameInput *game_input = (struct GameInput *)glfwGetWindowUserPointer(window);
 
     enum GameButton game_button = NULL_GAME_BUTTON;
     // TODO: Determine the button in a nicer way
     for (enum GameButton b = 0; b < NUM_GAME_BUTTONS; b++)
     {
         if (platform_input_map[b] == key)
         {
             game_button = b;
         }
     }
     if (game_button != NULL_GAME_BUTTON)
     {
         switch (action)
         {
             case GLFW_PRESS:
                 game_input->button_states |= (1 << game_button);
                 break;
             case GLFW_RELEASE:
                 game_input->button_states &= ~(1 << game_button);
                 break;
             case GLFW_REPEAT:
                 // Do nothing
                 break;
             default:
                 exit(1);
                 break;
         }
     }
 }
 
 PLATFORM_MEMORY_FREE(windows_memory_free)
 {
     free(ptr);
 }
 
 internal PLATFORM_READ_ENTIRE_FILE(windows_read_entire_file)
 {
     assert(a);
     FILE *handle = fopen(file_path, "rb");
     u8 *buffer = NULL;
 
     if (handle)
     {
         // get file size
         fseek(handle, 0, SEEK_END);
         u32 num_bytes_in_file = ftell(handle);
         rewind(handle);
 
         if (out_num_bytes)
         {
             *out_num_bytes = num_bytes_in_file;
         }
 
         buffer = mem_st_alloc_buffer(a, u8, num_bytes_in_file + 1);
 
         u32 bytes_read = fread(buffer, sizeof(u8), num_bytes_in_file, handle);
         // IMPORTANT! fread() doesn't add the '\0'
         buffer[num_bytes_in_file] = '\0';
 
         // TODO: handle this case more loudly
         if (num_bytes_in_file != bytes_read)
         {
             buffer = NULL;
         }
 
         fclose(handle);
     }
     else
     {
         printf("Error: Couldn't open file at path: %s", file_path);
         // TODO: handle errors here in a better way
         exit(1);
     }
 
     return buffer;
 }