}
static uint32_t _render_white_image(void) {
  static bool init = false;
  static struct Image image;
  if(!init) {
    init = true;
    uint8_t * data = alias_stack_allocation(16 * 16 * 3, 1);
    alias_memory_set(data, 16 * 16 * 3, 255, 16 * 16 * 3);
    _image_upload_2d(&image, 16, 16, 3, data, true);
  }
  return image.gl.image;

    .image[0] = image->gl.image,

    .image[0] = image ? image->gl.image : _render_white_image(),

static float _physics_speed = 1.0f;
static float _physics_time;
static float _physics_frame_time;
static void _update_physics(void) {
  const float timestep = 1.0f / 60.0f;
  static float p_time = 0.0f;
  static float s_time = 0.0f;
  float time = _physics_time;
  _physics_time = (float)((double)uv_hrtime() / 1000000000.0);
  _physics_frame_time = _physics_time - time;
  s_time += _physics_frame_time * _physics_speed;
  if(p_time >= s_time) {
    alias_transform_update2d_serial(engine_ecs(), engine_ecs_transform());
  }
  while(p_time < s_time) {
    alias_physics_update2d_serial_pre_transform(engine_ecs(), engine_ecs_physics_2d(), timestep);
    alias_transform_update2d_serial(engine_ecs(), engine_ecs_transform());
    alias_physics_update2d_serial_post_transform(engine_ecs(), engine_ecs_physics_2d(), timestep);
    p_time += timestep;
  }
}

  _update_physics();

void _image_load(struct Image *image, const char *path) {
  int width, height, channels;
  uint8_t *data = stbi_load(path, &width, &height, &channels, 0);
  if(data == NULL) {
    engine_warning("stb_load: loading %s failed.", path);
    return;
  }

  if(channels != 3 && channels != 4) {
    free(data);
    return;
  }

void _image_upload_2d(struct Image *image, int width, int height, int channels, const void * data, bool generate_mipmap) {

  while(w > 1 && h > 1) {
    levels++;
    w = w >> (w > 1);
    h = h >> (h > 1);

  if(generate_mipmap) {
    while(w > 1 && h > 1) {
      levels++;
      w = w >> (w > 1);
      h = h >> (h > 1);
    }

  glGenerateTextureMipmap(image->gl.image);

  if(generate_mipmap) {
    glGenerateTextureMipmap(image->gl.image);
  }
  // TODO use sampler for this

  stbi_image_free(data);

void _image_load(struct Image *image, const char *path) {
  int width, height, channels;
  uint8_t *data = stbi_load(path, &width, &height, &channels, 0);

  if(data == NULL) {
    engine_warning("stb_load: loading %s failed.", path);
    return;
  }
  if(channels != 3 && channels != 4) {
    engine_warning("stb_load: invalid channel value %i", channels);
    stbi_image_free(data);
    return;
  }
  engine_trace("stb_load: loaded %s", path);
  _image_upload_2d(image, width, height, channels, data, true);
  stbi_image_free(data);
}

  glViewport(x, y, width, height);

  float transform_m[16];

  alias_matrix_ortho(0, width, height, 0, -99999, 99999, engine_r_projection_matrix.uniform.data.mat);

    float origin_m[16], rotation_m[16], scale_m[16], translation_m[16];

    float origin_m[16], rotation_m[16], scale_m[16], translation_m[16], transform_m[16];

    alias_matrix_multiply(transform_m, translation_m, transform_m);

    alias_matrix_multiply(transform_m, translation_m, engine_r_view_matrix.uniform.data.mat);

  alias_matrix_identity(engine_r_model_matrix.uniform.data.mat);

  glViewport(x, y, width, height);

#define ENGINE_SPAWN_COMPONENT(...) SPAWN_COMPONENT_ __VA_ARGS__

#define ENGINE_SPAWN_COMPONENT(...) ENGINE_SPAWN_COMPONENT_ __VA_ARGS__

    (void)state;                                                                                                       \

per_platform executable ___-game_01 \
	___-engine \
	game_01/src/main.c