path: root/src/engine.c

#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

#include <GL/glew.h>
#define GLFW_INCLUDE_NONE
#include <GLFW/glfw3.h>

#include <SDL2/SDL.h>
#include <SDL2/SDL_image.h>
#include <SDL2/SDL_ttf.h>

#if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
/* include winapi */
#elif defined(__APPLE__)
/* mac includes */
#elif defined(__linux) || defined(__linux__) || defined(linux)

#include <unistd.h>

#endif

#define ENGINE_INTERNALS
#include <engine/btree.h>
#include <engine/engine.h>
#include <engine/hashmap.h>
#include <engine/list.h>

#include <engine/state.h>
// #include <states/titlescreen.h>
// #include <states/gameover.h>

#define DEFAULT_NUM_PROCS 8

#ifdef BENCHMARK
#define BENCHEXPR(timevar, expr)                                               \
  {                                                                            \
    u32 t = SDL_GetTicks();                                                    \
    expr timevar += SDL_GetTicks() - t;                                        \
  }

extern i32 drawcall_len;

#else
#define BENCHEXPR(timevar, expr) expr
#endif

static u64 FPS_CAP = 50;
Platform* GLOBAL_PLATFORM = NULL;

input_callback_t* callbacks[128];
usize callbacks_len;

i32 nproc(void) { return SDL_GetCPUCount(); }

i32 cmp_int(const void* a, const void* b) {
  const i32* x = a;
  const i32* y = b;

  return *x - *y;
}

v2_i32 get_canvas_size(SDL_Renderer* renderer) {
  v2_i32 realsize;
  SDL_GetRendererOutputSize(renderer, &(realsize.x), &(realsize.y));

  /* Set logical render size */
  return realsize;
}

Texture* load_texture(SDL_Renderer* render, const Asset_TextureSpec* ts) {
  SDL_Texture* new_texture = NULL;
  SDL_Surface* loaded_surface = NULL;
  Texture* t = NULL;

  if (ts == NULL) {
    ERROR("Invalid Asset_TextureSpec\n");
    return NULL;
  }

  loaded_surface = IMG_Load(ts->path);
  if (loaded_surface == NULL) {
    ERROR("Unable to load image \"%s\"!\n", ts->path);
    ERROR("SDL_image Error: %s\n", IMG_GetError());
    return NULL;
  }

  const i32 tw = loaded_surface->w / ts->width;

  SDL_SetColorKey(loaded_surface, SDL_TRUE,
                  SDL_MapRGB(loaded_surface->format, 0xFF, 0x00, 0xFF));

  /*Create texture from surface pixels */
  new_texture = SDL_CreateTextureFromSurface(render, loaded_surface);
  if (new_texture == NULL) {
    ERROR("Unable to create texture from \"%s\"!\n", ts->path);
    ERROR("SDL Error: %s\n", SDL_GetError());
  }

  /*Get rid of old loaded surface */
  SDL_FreeSurface(loaded_surface);

  t = (Texture*)malloc(sizeof(Texture));
  t->texture = new_texture;
  /* Assigning const value */
  *(i32*)&t->tilesize = tw;
  *(i32*)&t->width = ts->width;
  *(i32*)&t->height = ts->height;

  return t;
}

void engine_update_window(Window* w, SDL_WindowEvent* e) {
  switch (e->event) {
  case SDL_WINDOWEVENT_NONE:
  case SDL_WINDOWEVENT_SHOWN:
  case SDL_WINDOWEVENT_HIDDEN:
  case SDL_WINDOWEVENT_EXPOSED:
  case SDL_WINDOWEVENT_MOVED:
    break;
  case SDL_WINDOWEVENT_RESIZED:
    w->windowsize = get_canvas_size(w->renderer);
    LOG("Resized window to %dx%d", w->windowsize.x, w->windowsize.y);
    ui_resolve_constraints();
    if (w->game_w != NULL && w->game_h != NULL) {
      *w->game_h = w->windowsize.x;
      *w->game_w = w->windowsize.y;
    }
    break;
  case SDL_WINDOWEVENT_SIZE_CHANGED:
  case SDL_WINDOWEVENT_MINIMIZED:
  case SDL_WINDOWEVENT_MAXIMIZED:
  case SDL_WINDOWEVENT_RESTORED:
  case SDL_WINDOWEVENT_ENTER:
  case SDL_WINDOWEVENT_LEAVE:
  case SDL_WINDOWEVENT_FOCUS_GAINED:
  case SDL_WINDOWEVENT_FOCUS_LOST:
  case SDL_WINDOWEVENT_CLOSE:
  case SDL_WINDOWEVENT_TAKE_FOCUS:
  case SDL_WINDOWEVENT_HIT_TEST:
    break;
  default:
    WARN("Unhandled window event 0x%04x", (i32)e->event);
    break;
  }
  return;
}

struct sdl_ctx {SDL_Window* w; SDL_Renderer* r;} sdl_ctx;
struct glfw_ctx {GLFWwindow* w;} glfw_ctx;

struct sdl_ctx initialize_SDL(
    const char* windowtitle, v2_i32 windowsize,
    const u32 flags
    ) {
  SDL_Window* window = NULL;
  SDL_Renderer* renderer = NULL;

    INFO_("initializing sdl...");
    if (SDL_Init(SDL_INIT_VIDEO) < 0) {
      ERROR("failed to initialize sdl: %s\n", SDL_GetError());
      exit(EXIT_FAILURE);
    } else
      printf("ok\n");

    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3);
    SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
    SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);

    INFO_("creating window...");
    window = SDL_CreateWindow(
        windowtitle, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
        windowsize.x, windowsize.y,
        SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN | SDL_WINDOW_INPUT_FOCUS |
            SDL_WINDOW_MOUSE_FOCUS | flags);

    if (window == NULL) {
      ERROR("failed to create window: %s\n", SDL_GetError());
      exit(EXIT_FAILURE);
    } else
      printf("ok\n");

    INFO_("creating renderer...");
    renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
    if (renderer == NULL) {
      ERROR("failed to create renderer: %s\n", SDL_GetError());
      exit(EXIT_FAILURE);
    } else
      printf("ok\n");

    INFO_("initializing sdl_image...");
    if (IMG_Init(IMG_INIT_PNG) != IMG_INIT_PNG) {
      ERROR("failed to initialize sdl_image png support\n");
      exit(EXIT_FAILURE);
    } else
      printf("ok\n");

    INFO_("initializing sdl_ttf...");
    if (TTF_Init() == -1) {
      ERROR("failed to initialize sdl_ttf: %s\n", TTF_GetError());
      exit(EXIT_FAILURE);
    } else
      printf("ok\n");

  return (struct sdl_ctx){.w = window,.r = renderer};
}


/* GLFW And vulkan spaghetti boiler */
void glfw_err_callback(int code, const char* description) {
    ERROR("glfw [%d]: %s\n", code, description);
    // Terminate?
    exit(EXIT_FAILURE);
}

struct QueueFamilyIndices {
  int64_t graphicsFamily;
  int64_t presentFamily;
};



struct glfw_ctx initialize_GLFW(
    const char* windowtitle, v2_i32 windowsize,
    const u32 flags
    ) {
  GLFWwindow* window = NULL;

  glfwSetErrorCallback(&glfw_err_callback);

  INFO_("initializing glfw...");
  if (glfwInit() == GLFW_FALSE) {
    const char *desc;
    int code = glfwGetError(&desc);
    ERROR("failed to initialize glfw [%d]: %s\n", code, *desc);
    exit(EXIT_FAILURE);
  } else
    printf("ok\n");


  INFO_("initializing window...");
  //glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
  glfwWindowHint(GLFW_RESIZABLE, GLFW_FALSE);

  glfwWindowHint(GLFW_SAMPLES, 0); // Disable anti aliasing

  glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
  glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 6);
  glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); // To make MacOS happy; should not be needed
  glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

  window = glfwCreateWindow(windowsize.x, windowsize.y, windowtitle, NULL, NULL);
  if (window == NULL) {
    ERROR("Failed to create GLFW window!\n");
    const char *desc;
    int code = glfwGetError(&desc);
    ERROR("failed to initialize glfw window [%d]: %s\n", code, desc);
    exit(EXIT_FAILURE);
  } else
    printf("ok\n");

  glfwMakeContextCurrent(window);


  gladLoadGL(glfwGetProcAddress);

  // TODO: Replace with callback
  //glfwSetInputMode(window, GLFW_STICKY_KEYS, GL_TRUE);

  //while(!(glfwWindowShouldClose(window) && glfwGetKey(window, GLFW_KEY_ESCAPE ) != GLFW_PRESS)) {

  //  glClear( GL_COLOR_BUFFER_BIT );

  //  glfwSwapBuffers(window);

  //  glfwPollEvents();
  //}

  //glfwDestroyWindow(window);

  //glfwTerminate();

  return (struct glfw_ctx){.w = NULL};
}


/* Creates the window, initializes IO, Rendering, Fonts and engine-specific
 * resources. */
Platform* engine_init(const char* windowtitle, v2_i32 windowsize,
                      const f32 render_scale, const u32 flags,
                      const usize initial_memory, const Asset_FontSpec* fonts[],
                      const Asset_TextureSpec* textures[]) {

#ifdef BENCHMARK
  u32 init_start = SDL_GetTicks();
#endif

#if defined(__linux) || defined(__linux__) || defined(linux)
  {
    pid_t pid = getpid();
    INFO("Starting with pid %lu", pid);
  }
#endif

  Platform* p = (Platform*)malloc(sizeof(Platform));
  Window* w = (Window*)malloc(sizeof(Window));
  SDL_Window* window = NULL;
  SDL_Renderer* renderer = NULL;

  /* initialize resources */
  struct Resources* resources =
      (struct Resources*)malloc(sizeof(struct Resources));
  resources->textures_len = 0;
  resources->fonts_len = 0;
  resources->texturepaths_len = 0;
  resources->fontpaths_len = 0;
  resources->texture_paths = NULL;
  resources->font_paths = NULL;
  resources->textures = NULL;
  resources->fonts = NULL;

  /* Init subsystems */
  //{
  //  struct sdl_ctx sdl_ctx = initialize_SDL(windowtitle, windowsize, flags);
  //  window = sdl_ctx.w;
  //  renderer = sdl_ctx.r;
  //}
  /* Init glfw haha */
  {
    struct glfw_ctx ctx = initialize_GLFW(windowtitle, windowsize, flags);
  }
  exit(0);



  { /* Resource loading */

    /* Count resources */
    usize n_textures = 0;
    usize n_fonts = 0;

    if (textures != NULL)
      while (textures[n_textures] != NULL) n_textures++;
    if (fonts != NULL)
      while (fonts[n_fonts] != NULL) n_fonts++;

    INFO("Number of textures: " TERM_COLOR_YELLOW "%d" TERM_COLOR_RESET,
         n_textures);
    INFO("Number of fonts: " TERM_COLOR_YELLOW "%d" TERM_COLOR_RESET, n_fonts);

    /* Save the textures and fonts, if we should need to reload them later */
    resources->texture_paths = (Asset_TextureSpec**)textures;
    resources->font_paths = (Asset_FontSpec**)fonts;

    /* Allocate memory for textures and fonts */
    resources->textures = (Texture**)malloc(sizeof(Texture*) * n_textures);
    resources->fonts = (TTF_Font**)malloc(sizeof(TTF_Font*) * n_fonts);
    resources->textures_size = n_textures;

    for (usize i = 0; i < n_textures; i++) resources->textures[i] = NULL;
    for (usize i = 0; i < n_fonts; i++) resources->fonts[i] = NULL;

    /* Load textures */
    for (usize i = 0; i < n_textures; i++) {
      Texture* t = NULL;
      INFO_("loading texture \"" TERM_COLOR_YELLOW "%s" TERM_COLOR_RESET
            "\"...",
            textures[i]->path);

      t = load_texture(renderer, textures[i]);
      if (t == NULL) {
        puts("");
        ERROR("failed to load texture\n");
        exit(EXIT_FAILURE);
      }

      if (t->tilesize < 8) {
        puts("");
        ERROR("texture too small!\n");
        exit(EXIT_FAILURE);
      }

      if (t->texture == NULL) {
        puts("");
        ERROR("failed to load texture\n");
      } else {
        printf("ok\n");
        resources->textures[i] = t;
        resources->textures_len++;
      }
    }

    /* Load fonts */
    for (usize i = 0; i < n_fonts; i++) {
      INFO_("loading font \"" TERM_COLOR_YELLOW "%s" TERM_COLOR_RESET "\"...",
            fonts[i]->font_path);

      TTF_Font* font = TTF_OpenFont(fonts[i]->font_path, fonts[i]->ptsize);
      if (!font) {
        ERROR("failed to load font: %s\n", TTF_GetError());
      } else {
        printf("ok\n");
        resources->fonts[i] = font;
        resources->fonts_len++;
      }
    }

    if (resources->textures_len != n_textures) {
      WARN("Done. %d/%d textures loaded.", resources->textures_len, n_textures);
    } else {
      INFO("Done. All %d textures loaded.", n_textures);
    }

    if (resources->fonts_len != n_fonts) {
      WARN("Done. %d/%d fonts loaded.", resources->fonts_len, n_fonts);
    } else {
      INFO("Done. All %d fonts loaded.", n_fonts);
    }

    resources->texturepaths_len = resources->textures_len;
    resources->fontpaths_len = resources->fonts_len;
  }

  { /* Adjust window and such */
    /* Set actual windowsize, which might be forced by OS */
    SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "0");
    INFO("Adjusting window size...");
    windowsize = get_canvas_size(renderer);

    SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_BLEND);

    INFO("Windowsize: <%d,%d>", windowsize.x, windowsize.y);
  }

  w->renderer = renderer;
  w->window = window;
  w->render_scale = render_scale;
  w->windowsize = windowsize;
  w->game_w = NULL;
  w->game_h = NULL;

  p->data = (void*)resources;
  p->data_len = sizeof(struct Resources);
  p->window = w;
  p->quit = false;

  p->frame = 0;
  p->fps_target = 60;

  p->mem = memory_new(initial_memory);

  /* Getting the mouse coords now resolves the issue where a click "isn't
   * registered" when the mouse isn't moved before the user clicks */
  SDL_GetMouseState(&p->mouse_pos.x, &p->mouse_pos.y);

  p->mousedown = (v2_i32){-1, -1};
  p->mouseup = (v2_i32){-1, -1};

  p->mouse_lclick = false;
  p->mouse_rclick = false;

  p->camera_x = 0;
  p->camera_y = 0;

  p->edit_text = NULL;
  p->edit_pos = 0;

  p->bindings = NULL;
  p->bindings_sz = 0;
  p->bindings_len = 0;

  // TODO: Add global bindings

#ifdef BENCHMARK
  u32 init_stop = SDL_GetTicks();
  INFO("Initialization took %dms", init_stop - init_start);
#endif

  INFO("Available cores: %d", nproc());

  GLOBAL_PLATFORM = p;

#ifdef DAW_BUILD_HOTRELOAD

#define State(name)                                                            \
  if (!State_reload(STATE_##name, p->bindings, p->bindings_len)) {             \
    ERROR("Failed to reload shared object file for state %s", #name);          \
  };

#include <states/list_of_states.h>
#undef State

#endif

  return p;
}

i32 engine_run(Platform* p, StateType initial_state) {
  if (p == NULL) {
    ERROR("Platform is uninitialized.\n");
    INFO("initialize with `engine_init`");
    return -1;
  }

  memory* mem = p->mem;

  StateType state = initial_state;

  {
    u32 state_init_time = SDL_GetTicks();
    State_init(state, mem);
    INFO("Initializing state \"%s\" took %ldms", StateTypeStr[state],
         SDL_GetTicks() - state_init_time);
  }

  u32 time = SDL_GetTicks();

  // Update ticks
  u64 ticks = 0;

  /* Profiling values */
#ifdef BENCHMARK
  u64 profile_tick_counter = 0;
  // u64 profile_slack          = 0;
  u64 profile_rendering = 0;
  u64 profile_gameloop = 0;
  u64 profile_input = 0;
  u64 profile_input_handling = 0;
  u64 profile_num_drawcalls = 0;
  u32 profile_interval_timer = time;
  const u32 profile_interval_ms = 5000;
  const f32 profile_interval_scale = (f32)(profile_interval_ms) / 100.0f;
#endif

  const f64 frame_interval = 1000.0 / FPS_CAP;

  StateType (*update_func)(void*) = State_updateFunc(state);

  /* Main loop */
  do {
    const u32 now = SDL_GetTicks();
    const u64 dt = now - time;
    time = now;
    /* Wait frame_interval */
    if (dt < frame_interval) {
#ifndef BENCHMARK
      SDL_Delay(frame_interval - dt);

#else
      /* We want to know how much time is spend sleeping */
      // profile_slack += frame_interval - dt;
#endif
    }

#ifdef BENCHMARK
    if (time - profile_interval_timer > profile_interval_ms) {
      /* Ticks/frames since last measurement */
      u32 fps = (ticks - profile_tick_counter) / profile_interval_scale;
      u64 drawcalls = profile_num_drawcalls / profile_interval_scale / fps;

      u32 sum = +profile_rendering
                //+ profile_slack
                + profile_input + profile_input_handling + profile_gameloop;

      /* Log fps and slack percentage */
      LOG("fps:%d\t"
          "rendering:%.2f%%\t"
          //"slack:%.2f%%\t"
          "input:%.2f%% (%.2f%%)\t"
          "gameloop:%.2f%%\t"
          "unaccounted:%llu / %llu ms\t"
          "avg drawcalls:%llu",
          fps, 100.0f * (f32)profile_rendering / (f32)sum,
          // 100.0f * (f32)profile_slack          / (f32)sum,
          100.0f * (f32)profile_input / (f32)sum,
          100.0f * (f32)profile_input_handling / (f32)sum,
          100.0f * (f32)profile_gameloop / (f32)sum,
          time - profile_interval_timer - sum, sum, drawcalls);
      /* Reset values */
      profile_tick_counter = ticks;
      profile_interval_timer = time;
      // profile_slack          = 0;
      profile_rendering = 0;
      profile_gameloop = 0;
      profile_input = 0;
      profile_input_handling = 0;
      profile_num_drawcalls = 0;
    }
#endif

    /* Events */
    BENCHEXPR(profile_input, {
      if (p->mouse_lclick) {
        p->mouseup.x = -1;
        p->mouseup.y = -1;
        p->mousedown.x = -1;
        p->mousedown.y = -1;
        p->mouse_lclick = false;
      }
      if (p->mouse_rclick) {
        p->mouse_rclick = false;
      }

      /* Window events */
      SDL_Event e[8];
      i32 num_events;
      SDL_PumpEvents();
      while ((num_events = SDL_PeepEvents(e, 8, SDL_GETEVENT, SDL_FIRSTEVENT,
                                          SDL_SYSWMEVENT)) > 0) {
        for (i32 i = 0; i < num_events; i++) {
          switch (e[i].type) {
          case SDL_QUIT:
            state = STATE_quit;
            break;
          case SDL_WINDOWEVENT:
            engine_update_window(p->window, &e[i].window);
            break;
          default:
            WARN("Unhandled event 0x%04x", (i32)e[i].type);
          }
        }
      }

      /* Mouse events */
      while ((num_events = SDL_PeepEvents(e, 8, SDL_GETEVENT, SDL_MOUSEMOTION,
                                          SDL_MOUSEWHEEL)) > 0) {
        for (i32 i = 0; i < num_events; i++) {
          switch (e[i].type) {
          case SDL_MOUSEWHEEL:
            break;
          case SDL_MOUSEMOTION: {
            SDL_MouseMotionEvent m = e[i].motion;
            /* In case of a first-person game, use xrel and yrel */
            p->mouse_pos.x = m.x;
            p->mouse_pos.y = m.y;
          } break;
          case SDL_MOUSEBUTTONUP: {
            switch (e[i].button.button) {
            case SDL_BUTTON_LEFT:
              p->mouseup = p->mouse_pos;

              p->mouse_lclick = true;
            case SDL_BUTTON_RIGHT:
              break;
            default:
              break;
            }
          } break;
          case SDL_MOUSEBUTTONDOWN:
            switch (e[i].button.button) {
            case SDL_BUTTON_LEFT:
              p->mousedown = p->mouse_pos;
              break;
            case SDL_BUTTON_RIGHT:
              break;
            default:
              break;
            }
            break;
          default:
            WARN("Unhandled mouse event 0x%04x", (i32)e[i].type);
            break;
          }
        }
      }

      BENCHEXPR(profile_input_handling, {
        if (p->bindings != NULL) {
          const i_ctx* bindings = *p->bindings;
          const usize bindings_len = p->bindings_len;

          while ((num_events = SDL_PeepEvents(e, 8, SDL_GETEVENT, SDL_KEYDOWN,
                                              SDL_KEYUP)) > 0) {
            for (i32 i = 0; i < num_events; i++) {
              switch (e[i].type) {
              case SDL_KEYDOWN:
                if (e[i].key.keysym.sym == SDLK_F7) {
                  INFO("Reloading %s", StateTypeStr[state]);
                  if (!State_reload(state, p->bindings, p->bindings_len)) {
                    ERROR("Failed to reload state library!");
                  } else {
                    update_func = State_updateFunc(state);
                  }
                  break;
                }
                for (usize b = 0; b < bindings_len; b++) {
                  const action_t a =
                      i_get_action(&bindings[b], e[i].key.timestamp,
                                   e[i].key.keysym.scancode);

                  switch (a.type) {
                  case InputType_action:
                    if (a.action.callback != NULL) {
                      callbacks[callbacks_len++] = a.action.callback;
                    }
                    break;

                  case InputType_state:
                    if (!e[i].key.repeat && a.state.activate != NULL) {
                      callbacks[callbacks_len++] = a.state.activate;
                    }
                    break;

                  case InputType_range:
                    WARN("Range inputs not supported yet!");
                    break;
                  case InputType_error:
                    WARN("Unhandled scancode: %lu", e[i].key.keysym.scancode);

                  default:
                    break;
                  }
                }
                break;

              case SDL_KEYUP:
                for (usize b = 0; b < bindings_len; b++) {
                  const action_t a =
                      i_get_action(&bindings[b], e[i].key.timestamp,
                                   e[i].key.keysym.scancode);
                  if (a.type == InputType_state && a.state.deactivate != NULL &&
                      !e[i].key.repeat) {
                    callbacks[callbacks_len++] = a.state.deactivate;
                  }
                }
                break;
              default:
                WARN("Unhandled mouse event 0x%04x", (i32)e[i].type);
                break;
              }
            }
          }
        }
      });
    });

    i_flush_bindings(callbacks_len, mem->data, callbacks);
    callbacks_len = 0;

    /* update */
    StateType next_state;
    BENCHEXPR(profile_gameloop, {
      next_state = update_func((void*)(mem->data));
    });  // State_update(state, mem);});

    if (next_state != STATE_null) {
      if (next_state == STATE_quit) break;

      drawcall_reset();

      engine_window_resize_pointers_reset();
      State_free(state, mem);
      memory_clear(mem);

      engine_input_ctx_reset();

      state = next_state;
      update_func = State_updateFunc(state);
#ifdef BENCHMARK
      {
        u32 t = SDL_GetTicks();
        State_init(state, mem);
        LOG("Initializing %s took %dms", StateTypeStr[state],
            SDL_GetTicks() - t);
      }
#else
      State_init(state, mem);
#endif
    } else {
#ifdef BENCHMARK
      profile_num_drawcalls += drawcall_len;
#endif
      render_begin(p->window);
      BENCHEXPR(profile_rendering, { render_present(p->window); })
    }

    ticks++;
  } while (state != STATE_quit);

  return 0;
}

void stop(Platform* p) {
  if (p == NULL) return;

  { /* Deallocate resources */
    struct Resources* r = (struct Resources*)p->data;
    if (r != NULL) {
      /* Destroy textures */
      for (usize i = 0; i < r->textures_len; i++) {
        if (r->textures[i] != NULL) {
          SDL_DestroyTexture(r->textures[i]->texture);
          r->textures[i] = NULL;
        }
      }
      free(r->textures);

      /* Destroy Fonts */
      for (usize i = 0; i < r->fonts_len; i++) {
        if (r->fonts[i] != NULL) {
          TTF_CloseFont(r->fonts[i]);
          r->fonts[i] = NULL;
        }
      }
      free(r->fonts);
    }
  }

  { /* Deallocate window */
    Window* w = p->window;
    if (w != NULL) {
      if (w->window != NULL) {
        SDL_DestroyWindow(w->window);
        w->window = NULL;
      }
      if (w->renderer != NULL) {
        SDL_DestroyRenderer(w->renderer);
        w->renderer = NULL;
      }
    }
  }

  TTF_Quit();
  IMG_Quit();
  SDL_Quit();
}

/* Set the maximum framerate */
void engine_fps_max(u64 cap) { FPS_CAP = cap; }

/* Pushes an input context onto the input handling stack */
void engine_input_ctx_push(i_ctx* ctx) {
  if (GLOBAL_PLATFORM->bindings == NULL) {
    GLOBAL_PLATFORM->bindings = calloc(8, sizeof(i_ctx*));
    GLOBAL_PLATFORM->bindings_sz = 8;
  }

  if (GLOBAL_PLATFORM->bindings_len + 1 >= GLOBAL_PLATFORM->bindings_sz) {
    void* m =
        realloc(GLOBAL_PLATFORM->bindings, GLOBAL_PLATFORM->bindings_sz + 8);
    if (m == NULL) {
      ERROR("Failed to allocate 8 bytes (%d): %s", errno, strerror(errno));
      exit(EXIT_FAILURE);
    }
    GLOBAL_PLATFORM->bindings_sz += 8;
  }

  LOG("Bindings in ctx[%d]:", GLOBAL_PLATFORM->bindings_len);
  for (isize i = 0; i < ctx->len; i++) {
    switch (ctx->bindings[i].action.type) {
    case InputType_error:
      LOG("(error)");
      break;

    case InputType_action:
      LOG("(action) %s", ctx->bindings[i].action.action.callback_str);
      break;

    case InputType_state:
      LOG("(+state) %s", ctx->bindings[i].action.state.activate_str);
      LOG("(-state) %s", ctx->bindings[i].action.state.deactivate_str);
      break;
    case InputType_range:
      LOG("(range) --unhandled--");
      break;
    }
  }

  GLOBAL_PLATFORM->bindings[GLOBAL_PLATFORM->bindings_len++] = ctx;
}

/* Pops an input context from the input stack */
void engine_input_ctx_pop(void) {
  if (GLOBAL_PLATFORM->bindings == NULL || GLOBAL_PLATFORM->bindings_sz == 0)
    return;
  i_ctx_t_free(GLOBAL_PLATFORM->bindings[--GLOBAL_PLATFORM->bindings_len]);
}

/* Removes all input contexts from the input stack */
void engine_input_ctx_reset(void) {
  while (GLOBAL_PLATFORM->bindings_len > 0) {
    i_ctx_t_free(GLOBAL_PLATFORM->bindings[--GLOBAL_PLATFORM->bindings_len]);
  }
}

u32 get_time(void) { return SDL_GetTicks(); }
v2_i32 get_windowsize(void) { return GLOBAL_PLATFORM->window->windowsize; }
v2_i32* get_mousepos(void) { return &GLOBAL_PLATFORM->mouse_pos; }