a-game

platform_wasm.c (4991B)

---

 #include <limits.h>
 #include <stdalign.h>
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
 
 #define static_assert _Static_assert
 
 // Begin terrible libc substitutions
 // TODO: make this libc replacement not shitty
 #define assert(x) (void)0
 
 int32_t printf(const char *format, ...)
 {
     // lol
     return 0;
 }
 
 // looooooooooool
 #define exit(status) (void)0
 
 void *memset(void *s, int32_t c, size_t n)
 {
     uint8_t *p = s;
     while(n > 0)
     {
         *p = (uint8_t)c;
         p++;
         n--;
     }
     return s;
 }
 
 // TODO: assert no overlap
 void *memcpy(void *dst, const void *src, size_t n)
 {
     uint8_t *destination = (uint8_t *)dst;
     uint8_t *source = (uint8_t *)src;
 
     while (n--)
     {
         *destination = *source;
         destination++;
         source++;
     }
 
     return dst;
 }
 
 // TODO: actually implement
 void *memmove(void *dst, const void *src, size_t n)
 {
     return memcpy(dst, src, n);
 }
 
 static_assert(__has_builtin(__builtin_sqrtf), "No builtin sqrtf builtin");
 #define sqrtf(x) __builtin_sqrtf((x))
 
 float js_cosf(float);
 float js_fabsf(float);
 float js_powf(float, float);
 float js_sinf(float);
 float js_tanf(float);
 float js_cosf(float);
 
 float cosf(float x) {
     return js_cosf(x);
 }
 
 float fabsf(float x) {
     return js_fabsf(x);
 }
 
 float powf(float x, float y) {
     return js_powf(x, y);
 }
 
 float sinf(float x) {
     return js_sinf(x);
 }
 
 float tanf(float x) {
     return js_tanf(x);
 }
 // End terrible libc substitutions
 
 #include "platform_info.h"
 
 #include "game.c"
 #include "platform.h"
 #include "platform_wasm.h"
 
 // wasm-ld memory layout:
 //      a       b
 // data | stack | heap
 // a = __data_end
 // b = __heap_base
 extern u8 __heap_base;
 extern u8 __data_end;
 
 // There's no standardized, nondeprecated way to get a numeric ID of a keyboard
 // key, so I guess we have to do that ourselves.
 enum WasmKey {
     WASM_KEY_LEFT,
     WASM_KEY_RIGHT,
     WASM_KEY_UP,
     WASM_KEY_DOWN,
     WASM_KEY_S,
     WASM_KEY_F11,
 };
 
 // TODO: map this in a nicer way
 global_variable int platform_input_map[NUM_GAME_BUTTONS] = {
     [BTN_LEFT] = WASM_KEY_LEFT,
     [BTN_RIGHT] = WASM_KEY_RIGHT,
     [BTN_UP] = WASM_KEY_UP,
     [BTN_DOWN] = WASM_KEY_DOWN,
     [BTN_JUMP] = WASM_KEY_S,
     [BTN_DEBUG_FLOAT] = WASM_KEY_F11,
 };
 
 global_variable struct GameMemory game_memory = {0};
 global_variable struct GameInput game_input = {0};
 global_variable i32 g_width = PLATFORM_SCR_WIDTH;
 global_variable i32 g_height = PLATFORM_SCR_HEIGHT;
 global_variable u32 previous_time = 0;
 
 i32 str_length(const char *str)
 {
     i32 i = 0;
     while(str[i] != '\0')
     {
         i++;
     }
     return i;
 }
 
 int wasm_print(const char *format, ...)
 {
     i32 len = str_length(format);
     js_print((i32)format, len);
     return 0;
 }
 
 bool init(i32 num_wasm_memory_pages)
 {
     bool init_successful = true;
     game_memory = (struct GameMemory) {
         // NOTE(amin): each wasm memory page is 64KiB
         .buffer_size = num_wasm_memory_pages * KIBIBYTES(64),
         .platform = {
             &wasm_read_entire_file,
             &wasm_memory_free,
         },
         .buffer = &__heap_base,
     };
     if (!game_memory.buffer)
     {
         wasm_print("Game memory allocation failed\n");
         init_successful = false;
     }
     game_init(&game_memory, (v2u) {g_width, g_height});
     return init_successful;
 }
 
 void render(f64 current_time)
 {
     game_input.dt = current_time - previous_time;
     previous_time = current_time;
     game_update_and_render(&game_memory, &game_input, (v2u) {g_width, g_height});
 }
 
 void window_resize(int w, int h)
 {
     g_width = w;
     g_height = h;
 }
 
 void key_callback(enum WasmKey key, bool key_action_is_pressed)
 {
     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)
     {
         if (key_action_is_pressed)
         {
             game_input.button_states |= (1 << game_button);
         }
         else
         {
             game_input.button_states &= ~(1 << game_button);
         }
     }
 }
 
 PLATFORM_MEMORY_FREE(wasm_memory_free)
 {
     // do nothing
 }
 
 PLATFORM_READ_ENTIRE_FILE(wasm_read_entire_file)
 {
     i32 num_bytes_in_file = js_get_file_size((i32)file_path, str_length(file_path));
 
     if (out_num_bytes)
     {
         *out_num_bytes = num_bytes_in_file;
     }
 
     size_t fail_reversion_marker = mem_st_get_marker(a);
     u8 *buf = mem_st_alloc_buffer(a, u8, num_bytes_in_file + 1);
     assert(buf);
 
     bool success = js_read_entire_file((i32)file_path, str_length(file_path), buf);
     if (success)
     {
         buf[num_bytes_in_file] = '\0';
         wasm_print("Succeeded in reading file.");
     }
     else
     {
         mem_st_free_to_marker(a, fail_reversion_marker);
         buf = NULL;
         wasm_print("Failed to read file.");
     }
     return buf;
 }