ohsp

platform_sdl.c (17976B)

---

 #include "platform_sdl.h"
 
 #if !defined(OHSP_NO_HOT_RELOAD)
 #include <dlfcn.h>
 #include <sys/stat.h>
 #include <stdio.h>
 #include <time.h>
 
 time_t file_get_modified_time(char *file_path)
 {
     time_t mtime = 0;
     struct stat file_status = {0};
     if (stat(file_path, &file_status) == 0)
     {
         //printf("File: %s last modified: %s\n", file_path, ctime(&file_status.st_mtime));
         mtime = file_status.st_mtime;
     }
     else
     {
         fprintf(stderr, "ERROR: Failed to stat file: %s\n", file_path);
     }
     return mtime;
 }
 
 
 void unload_game_code(struct SDLGameCode *game_code)
 {
     if (!game_code)
     {
         printf("Invalid pointer *game_code\n");
         return;
     }
 
     if (game_code->game_code_library)
     {
         dlclose(game_code->game_code_library);
         game_code->game_code_library = 0;
     }
     game_code->is_valid = false;
     game_code->game_update = 0;
     game_code->game_render = 0;
 }
 
 
 // TODO: Add backup dll in case loading fails
 struct SDLGameCode load_game_code(char *source_lib_path)
 {
     struct SDLGameCode game_code = {0};
 
     game_code.last_write_time = file_get_modified_time(source_lib_path);
     if (game_code.last_write_time)
     {
         game_code.game_code_library = dlopen(source_lib_path, RTLD_LAZY);
         if (game_code.game_code_library)
         {
             // NOTE: The C standard (as of C99) distinguishes function pointers
             // from object pointers (`void *` is an object pointer). Technically it
             // is undefined behavior to cast between these two pointer types. In
             // practice, it works on most modern platforms.
             //
             // In this case, we are protected by POSIX, which specifies that
             // function and data pointers must be the same size. We will only ever
             // be using dlsym on POSIX-compliant platforms.
             game_code.game_update = (game_update_t *) dlsym(game_code.game_code_library, "game_update");
             game_code.game_render = (game_render_t *) dlsym(game_code.game_code_library, "game_render");
             game_code.is_valid = (game_code.game_update && game_code.game_render);
         }
     }
 
     if (!game_code.is_valid)
     {
         fprintf(stderr, "ERROR: Game code is not valid: %s\n", dlerror());
     }
 
     return game_code;
 }
 #endif
 
 #include <stdbool.h>
 #include <stdio.h>
 #include <string.h>
 #include <time.h>
 
 #ifndef MAP_ANONYMOUS
 #define MAP_ANONYMOUS MAP_ANON
 #endif
 
 extern bool PAUSED;
 
 static struct SDLOffscreenBuffer global_back_buffer = {0};
 static struct SDLInputRecord input_record = {0};
 static bool TRACE = false;
 
 
 struct SDLWindowDimension sdl_get_window_dimension(SDL_Window *window)
 {
     struct SDLWindowDimension result = {0};
     SDL_GetWindowSize(window, &result.width, &result.height);
     return(result);
 }
 
 
 void sdl_resize_texture(struct SDLOffscreenBuffer *buffer, SDL_Renderer *renderer, int width, int height)
 {
     if (buffer->memory)
     {
         free(buffer->memory);
     }
 
     if (buffer->texture)
     {
         SDL_DestroyTexture(buffer->texture);
     }
 
     buffer->texture = SDL_CreateTexture(
             renderer,
             SDL_PIXELFORMAT_ARGB8888,
             SDL_TEXTUREACCESS_STREAMING,
             width, height);
 
     buffer->width = width;
     buffer->height = height;
     buffer->pitch = width * BYTES_PER_PIXEL;
 
     buffer->memory = malloc(width * height * BYTES_PER_PIXEL);
 }
 
 
 void sdl_update_window(SDL_Renderer *renderer, struct SDLOffscreenBuffer *buffer)
 {
     if (SDL_UpdateTexture(buffer->texture, 0, buffer->memory, buffer->pitch))
     {
         // TODO(amin): Handle this error
     }
 
     SDL_RenderCopy(renderer, buffer->texture, 0, 0);
     SDL_RenderPresent(renderer);
 }
 
 
 void clear_screen(struct SDLOffscreenBuffer *buffer, uint32_t pixel_value)
 {
     // NOTE(amin): Memset is faster than nested for loops, but can only set
     // pixels to single byte values
     memset(buffer->memory, pixel_value, buffer->height * buffer->width * BYTES_PER_PIXEL);
 }
 
 
 // TODO: make the deadzone circular
 float sdl_process_controller_axis_value(int16_t value, int16_t deadzone_threshold)
 {
     float result = 0.0f;
     if (value < -deadzone_threshold)
     {
         result = (float)(value + deadzone_threshold) / (32768.0f - deadzone_threshold);
     }
     else if (value > deadzone_threshold)
     {
         result = (float)(value - deadzone_threshold) / (32767.0f - deadzone_threshold);
     }
     return result;
 }
 
 
 bool sdl_handle_event(SDL_Event *event, struct GameControllerInput *controller_input)
 {
     if (!event || !controller_input)
     {
         return true;
     }
 
     bool should_quit = false;
 
     switch(event->type)
     {
         case SDL_QUIT:
         {
             printf("SDL_QUIT\n");
             should_quit = true;
         } break;
 
         case SDL_KEYDOWN:
         case SDL_KEYUP:
         {
             SDL_Keycode key_code = event->key.keysym.sym;
             bool is_down = (event->key.state == SDL_PRESSED);
             if (is_down)
             {
                 if (key_code == SDLK_p)
                 {
                     PAUSED = !PAUSED;
                 }
                 else if (key_code == SDLK_t)
                 {
                     TRACE = !TRACE;
                 }
                 else if (key_code == SDLK_r)
                 {
                     if (input_record.state == INACTIVE)
                     {
                         printf("input_record: RECORDING\n");
                         input_record.initial_state_recorded = false;
                         input_record.record_head = 0;
                         input_record.state = RECORDING;
                     }
                     else if (input_record.state == RECORDING)
                     {
                         printf("input_record: INACTIVE\n");
                         input_record.state = INACTIVE;
                     }
                     else if (input_record.state == PLAYING_BACK)
                     {
                         printf("Can't record while playing back\n");
                     }
                     else
                     {
                         printf("ERROR: input_record invalid state\n");
                     }
                 }
                 else if (key_code == SDLK_l)
                 {
                     if (input_record.state == INACTIVE)
                     {
                         printf("input_record: PLAYING_BACK\n");
                         input_record.playback_head = 0;
                         input_record.state = PLAYING_BACK;
                     }
                     else if (input_record.state == PLAYING_BACK)
                     {
                         printf("input_record: INACTIVE\n");
                         input_record.state = INACTIVE;
                     }
                     else if (input_record.state == RECORDING)
                     {
                         printf("Can't play back while recording\n");
                     }
                     else
                     {
                         printf("ERROR: input_record invalid state\n");
                     }
                 }
             }
         } break;
 
         case SDL_CONTROLLERAXISMOTION:
         {
             // down and right are positive
             float normalized_axis_value = sdl_process_controller_axis_value(event->caxis.value, DEADZONE_THRESHOLD);
 
             //printf("SDL_CONTROLLERAXISMOTION (%d, %s, %d, %f)\n",
             //        event->caxis.which,
             //        SDL_GameControllerGetStringForAxis(event->caxis.axis),
             //        event->caxis.value,
             //        normalized_axis_value);
 
             switch(event->caxis.axis)
             {
                 case SDL_CONTROLLER_AXIS_LEFTX:
                 {
                     controller_input->left_stick_x = normalized_axis_value;
                 } break;
                 case SDL_CONTROLLER_AXIS_LEFTY:
                 {
                     controller_input->left_stick_y = normalized_axis_value;
                 } break;
                 case SDL_CONTROLLER_AXIS_RIGHTX:
                 {
                     controller_input->right_stick_x = normalized_axis_value;
                 } break;
                 case SDL_CONTROLLER_AXIS_RIGHTY:
                 {
                     controller_input->right_stick_y = normalized_axis_value;
                 } break;
                 default:
                 {
                     printf("Unhandled axis input\n");
                 }
             }
         } break;
 
         case SDL_WINDOWEVENT:
         {
             switch(event->window.event)
             {
                 case SDL_WINDOWEVENT_SIZE_CHANGED:
                 {
                     SDL_Window *window = SDL_GetWindowFromID(event->window.windowID);
                     SDL_Renderer *renderer = SDL_GetRenderer(window);
                     printf("SDL_WINDOWEVENT_SIZE_CHANGED (%d, %d)\n", event->window.data1, event->window.data2);
                     sdl_resize_texture(&global_back_buffer, renderer, event->window.data1, event->window.data2);
                 } break;
 
                 case SDL_WINDOWEVENT_FOCUS_GAINED:
                 {
                     printf("SDL_WINDOWEVENT_FOCUS_GAINED\n");
                 } break;
 
                 case SDL_WINDOWEVENT_EXPOSED:
                 {
                     SDL_Window *window = SDL_GetWindowFromID(event->window.windowID);
                     SDL_Renderer *renderer = SDL_GetRenderer(window);
                     sdl_update_window(renderer, &global_back_buffer);
                 } break;
             }
         } break;
     }
     return(should_quit);
 }
 
 
 int main(int argc, char *argv[])
 {
     if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_GAMECONTROLLER))
     {
         // TODO(amin): log SDL_Init error
     }
 
     SDL_Window *window = SDL_CreateWindow(
             TITLE,
             SDL_WINDOWPOS_UNDEFINED,
             SDL_WINDOWPOS_UNDEFINED,
             SCREEN_WIDTH,
             SCREEN_HEIGHT,
             SDL_WINDOW_RESIZABLE | SDL_WINDOW_ALLOW_HIGHDPI);
 
 #ifdef FULLSCREEN
     SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN_DESKTOP);
 #endif
 
     if (window)
     {
         SDL_Renderer *renderer = SDL_CreateRenderer(window, -1, 0);
 
         if (renderer)
         {
             struct SDLWindowDimension dimension = sdl_get_window_dimension(window);
             sdl_resize_texture(&global_back_buffer, renderer, dimension.width, dimension.height);
 
             bool running = true;
 
 #ifdef USE_TEST_SEED
             srand((uint32_t)0);
 #else
             srand((uint32_t)time(NULL));
 #endif
 
             int num_joysticks = SDL_NumJoysticks();
             SDL_GameController *controller_handles[MAX_CONTROLLERS];
             for (int controller_index = 0; controller_index < num_joysticks; ++controller_index)
             {
                 if (!SDL_IsGameController(controller_index))
                 {
                     continue;
                 }
 
                 if (controller_index >= MAX_CONTROLLERS)
                 {
                     break;
                 }
 
                 controller_handles[controller_index] = SDL_GameControllerOpen(controller_index);
             }
 
             uint64_t lag = 0;
             uint64_t previous_ms = (SDL_GetPerformanceCounter() * SECOND) / SDL_GetPerformanceFrequency();
 
             struct GameState game_state = {0};
             game_init(&game_state, dimension.width, dimension.height);
 
             struct GameControllerInput controller_input = {0};
 
 #if !defined(OHSP_NO_HOT_RELOAD)
             struct SDLGameCode game_code = load_game_code(GAME_LIB_PATH);
 #endif
 
             while (running)
             {
                 uint64_t current_ms = (SDL_GetPerformanceCounter() * SECOND) / SDL_GetPerformanceFrequency();
                 uint64_t elapsed_ms = current_ms - previous_ms;
                 previous_ms = current_ms;
                 lag += elapsed_ms;
                 //printf("%" PRIu64 ", %" PRIu64 ", %f\n", elapsed_ms, lag, MS_PER_UPDATE);
 
 #if !defined(OHSP_NO_HOT_RELOAD)
                 time_t last_write_time = file_get_modified_time(GAME_LIB_PATH);
                 bool game_code_has_changed = last_write_time && (last_write_time != game_code.last_write_time);
                 if (game_code_has_changed)
                 {
                     unload_game_code(&game_code);
                     game_code = load_game_code(GAME_LIB_PATH);
                     if (!game_code.is_valid)
                     {
                         // TODO: fall back to backup?
                     }
                 }
 #endif
 
                 SDL_Event event;
                 while (SDL_PollEvent(&event))
                 {
                     running = !sdl_handle_event(&event, &controller_input);
                 }
                 SDL_PumpEvents();
 
                 switch (input_record.state)
                 {
                     case INACTIVE: {} break;
 
                     case RECORDING:
                     {
                         // TODO: sdl_input_record(&controller_input);
                         if (input_record.record_head < INPUT_RECORD_SIZE)
                         {
                             if (input_record.record_head == 0)
                             {
                                 input_record.initial_state = game_state;
                                 input_record.initial_state_recorded = true;
                             }
                             input_record.input_buffer[input_record.record_head] = controller_input;
                             ++input_record.record_head;
                         }
                         else
                         {
                             printf("Input record buffer full\n");
                             input_record.state = INACTIVE;
                         }
                     } break;
 
                     case PLAYING_BACK:
                     {
                         if (input_record.playback_head < input_record.record_head)
                         {
                             if (input_record.playback_head == 0 && input_record.initial_state_recorded)
                             {
                                 game_state = input_record.initial_state;
                             }
 
                             // TODO: sdl_input_playback(&controller_input);
                             controller_input = input_record.input_buffer[input_record.playback_head];
                             ++input_record.playback_head;
                         }
                         else
                         {
                             printf("Playback restarting\n");
                             input_record.playback_head = 0;
                         }
                     } break;
 
                     default:
                     {
                         printf("Unhandled SDLInputRecordState\n");
                     } break;
                 }
 
                 dimension = sdl_get_window_dimension(window);
 
                 struct OffscreenBuffer buffer =
                 {
                     // WARNING: these pointers are aliased until the end of the
                     // loop
                     .memory = global_back_buffer.memory,
                     .width = global_back_buffer.width,
                     .height = global_back_buffer.height,
                     .pitch = global_back_buffer.pitch,
                 };
 
                 if (PAUSED)
                 {
                     lag = 0;
                 }
                 else if (input_record.state == RECORDING || input_record.state == PLAYING_BACK)
                 {
                     // TODO: Make up your mind about what kind of time step and game loop this game needs.
 
                     // When recording or playing back, we do exactly one update
                     // per frame. This is so that recorded input played back
                     // over the initial state always results in the same
                     // sequence of states.
 #if !defined(OHSP_NO_HOT_RELOAD)
                     game_code.game_update(&game_state, controller_input, buffer.width, buffer.height);
 #else
                     game_update(&game_state, controller_input, buffer.width, buffer.height);
 #endif
                     lag -= MS_PER_UPDATE;
                 }
                 else
                 {
                     while (lag >= MS_PER_UPDATE)
                     {
 #if !defined(OHSP_NO_HOT_RELOAD)
                         game_code.game_update(&game_state, controller_input, buffer.width, buffer.height);
 #else
                         game_update(&game_state, controller_input, buffer.width, buffer.height);
 #endif
                         //printf("\t%" PRIu64 ", %f\n", lag, MS_PER_UPDATE);
                         lag -= MS_PER_UPDATE;
                     }
                 }
 
                 if (!TRACE)
                 {
                     clear_screen(&global_back_buffer, COLOR_BACKGROUND);
                 }
 #if !defined(OHSP_NO_HOT_RELOAD)
                 game_code.game_render(&buffer, lag/SECOND, &game_state);
 #else
                 game_render(&buffer, lag/SECOND, &game_state);
 #endif
                 sdl_update_window(renderer, &global_back_buffer);
                 if (elapsed_ms <= MS_PER_FRAME)
                 {
                     SDL_Delay(MS_PER_FRAME - elapsed_ms);
                 }
             }
 
             game_cleanup(&game_state);
 
             for (int controller_index = 0; controller_index < num_joysticks; ++controller_index)
             {
                 if (!SDL_IsGameController(controller_index))
                 {
                     continue;
                 }
 
                 if (controller_index >= MAX_CONTROLLERS)
                 {
                     break;
                 }
 
                 SDL_GameControllerClose(controller_handles[controller_index]);
             }
         }
         else
         {
             // TODO(amin): log SDL_Renderer error
         }
     }
     else
     {
         // TODO(amin): log SDL_Window error
     }
 
     SDL_Quit();
     return(0);
 }