asrael/pxl8
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

refactor a bit into pxl8 sys struct

Browse source
This commit is contained in:
asrael 2025-11-18 23:50:02 -06:00
parent b2682a2d40
commit f19b06d705
10 changed files with 217 additions and 148 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/lua/pxl8.lua
View file

@ -13,7 +13,7 @@ local world = require("pxl8.world")
local transition = require("pxl8.transition")
local anim = require("pxl8.anim")
core.init(_pxl8_game, _pxl8_gfx, _pxl8_input, _pxl8_ui)
core.init(_pxl8_gfx, _pxl8_input, _pxl8_sys, _pxl8_ui)
local pxl8 = {}

6
src/lua/pxl8/core.lua
View file

@ -3,15 +3,15 @@ local C = ffi.C
local core = {}
function core.init(game_ptr, gfx_ptr, input_ptr, ui_ptr)
core.game = game_ptr
function core.init(gfx_ptr, input_ptr, sys_ptr, ui_ptr)
core.gfx = gfx_ptr
core.input = input_ptr
core.sys = sys_ptr
core.ui = ui_ptr
end
function core.get_fps()
return C.pxl8_game_get_fps(core.game)
return C.pxl8_get_fps(core.sys)
end
function core.get_width()

168
src/pxl8.c
View file

@ -14,19 +14,66 @@
#include "pxl8_hal.h"
#include "pxl8_macros.h"
#include "pxl8_script.h"
#include "pxl8_sys.h"
#include "pxl8_types.h"
#include "pxl8_ui.h"
pxl8_game_result pxl8_init(pxl8_game* game, i32 argc, char* argv[]) {
if (!game) {
return PXL8_GAME_FAILURE;
struct pxl8 {
pxl8_cart* cart;
pxl8_game* game;
const pxl8_hal* hal;
void* platform_data;
};
pxl8* pxl8_create(const pxl8_hal* hal) {
if (!hal) {
pxl8_error("HAL cannot be NULL");
return NULL;
}
if (!game->hal) {
pxl8_error("HAL must be set before calling pxl8_init");
return PXL8_GAME_FAILURE;
pxl8* sys = (pxl8*)calloc(1, sizeof(pxl8));
if (!sys) {
pxl8_error("Failed to allocate pxl8 system");
return NULL;
}
sys->hal = hal;
sys->game = (pxl8_game*)calloc(1, sizeof(pxl8_game));
if (!sys->game) {
pxl8_error("Failed to allocate game");
free(sys);
return NULL;
}
return sys;
}
void pxl8_destroy(pxl8* sys) {
if (!sys) return;
if (sys->game) {
free(sys->game);
}
if (sys->cart) {
pxl8_cart_destroy(sys->cart);
}
if (sys->hal && sys->platform_data) {
sys->hal->destroy(sys->platform_data);
}
free(sys);
}
pxl8_result pxl8_init(pxl8* sys, i32 argc, char* argv[]) {
if (!sys || !sys->game) {
return PXL8_ERROR_INVALID_ARGUMENT;
}
pxl8_game* game = sys->game;
game->color_mode = PXL8_COLOR_MODE_MEGA;
game->resolution = PXL8_RESOLUTION_640x360;
@ -45,7 +92,7 @@ pxl8_game_result pxl8_init(pxl8_game* game, i32 argc, char* argv[]) {
pack_output = argv[++i];
} else {
pxl8_error("--pack requires <folder> <output.pxc>");
return PXL8_GAME_FAILURE;
return PXL8_ERROR_INVALID_ARGUMENT;
}
} else if (!script_arg) {
script_arg = argv[i];
@ -54,39 +101,42 @@ pxl8_game_result pxl8_init(pxl8_game* game, i32 argc, char* argv[]) {
if (pack_mode) {
pxl8_result result = pxl8_cart_pack(pack_input, pack_output);
return (result == PXL8_OK) ? PXL8_GAME_SUCCESS : PXL8_GAME_FAILURE;
return result;
}
if (game->repl_mode) {
fprintf(stderr, "\033[38;2;184;187;38m[pxl8]\033[0m Starting in REPL mode with script: %s\n", game->script_path);
}
pxl8_info("Starting up");
game->gfx = pxl8_gfx_create(game->hal, game->color_mode, game->resolution, "pxl8", 1280, 720);
sys->platform_data = sys->hal->create(game->color_mode, game->resolution, "pxl8", 1280, 720);
if (!sys->platform_data) {
pxl8_error("Failed to create platform context");
return PXL8_ERROR_INITIALIZATION_FAILED;
}
game->gfx = pxl8_gfx_create(sys->hal, sys->platform_data, game->color_mode, game->resolution);
if (!game->gfx) {
pxl8_error("Failed to create graphics context");
return PXL8_GAME_FAILURE;
return PXL8_ERROR_INITIALIZATION_FAILED;
}
if (pxl8_gfx_load_font_atlas(game->gfx) != PXL8_OK) {
pxl8_error("Failed to load font atlas");
return PXL8_GAME_FAILURE;
return PXL8_ERROR_INITIALIZATION_FAILED;
}
game->ui = pxl8_ui_create(game->gfx);
if (!game->ui) {
pxl8_error("Failed to create UI");
pxl8_gfx_destroy(game->gfx);
return PXL8_GAME_FAILURE;
return PXL8_ERROR_INITIALIZATION_FAILED;
}
game->script = pxl8_script_create();
if (!game->script) {
pxl8_error("Failed to initialize scripting: %s", pxl8_script_get_last_error(game->script));
pxl8_gfx_destroy(game->gfx);
return PXL8_GAME_FAILURE;
return PXL8_ERROR_INITIALIZATION_FAILED;
}
const char* cart_path = script_arg ? script_arg : "demo";
@ -97,19 +147,19 @@ pxl8_game_result pxl8_init(pxl8_game* game, i32 argc, char* argv[]) {
if (is_cart) {
char* original_cwd = getcwd(NULL, 0);
game->cart = pxl8_cart_create();
if (!game->cart) {
sys->cart = pxl8_cart_create();
if (!sys->cart) {
pxl8_error("Failed to create cart");
return PXL8_GAME_FAILURE;
return PXL8_ERROR_INITIALIZATION_FAILED;
}
if (pxl8_cart_load(game->cart, cart_path) == PXL8_OK) {
pxl8_script_set_cart_path(game->script, pxl8_cart_get_base_path(game->cart), original_cwd);
pxl8_cart_mount(game->cart);
if (pxl8_cart_load(sys->cart, cart_path) == PXL8_OK) {
pxl8_script_set_cart_path(game->script, pxl8_cart_get_base_path(sys->cart), original_cwd);
pxl8_cart_mount(sys->cart);
strcpy(game->script_path, "main.fnl");
pxl8_info("Loaded cart: %s", pxl8_cart_get_name(game->cart));
pxl8_info("Loaded cart: %s", pxl8_cart_get_name(sys->cart));
} else {
pxl8_error("Failed to load cart: %s", cart_path);
return PXL8_GAME_FAILURE;
return PXL8_ERROR_INITIALIZATION_FAILED;
}
free(original_cwd);
} else if (script_arg) {
@ -119,8 +169,8 @@ pxl8_game_result pxl8_init(pxl8_game* game, i32 argc, char* argv[]) {
pxl8_script_set_gfx(game->script, game->gfx);
pxl8_script_set_input(game->script, &game->input);
pxl8_script_set_sys(game->script, sys);
pxl8_script_set_ui(game->script, game->ui);
pxl8_script_set_game(game->script, game);
if (game->script_path[0] != '\0') {
pxl8_result result = pxl8_script_load_main(game->script, game->script_path);
@ -131,19 +181,20 @@ pxl8_game_result pxl8_init(pxl8_game* game, i32 argc, char* argv[]) {
}
}
game->last_time = game->hal->get_ticks();
game->last_time = sys->hal->get_ticks();
game->running = true;
return PXL8_GAME_CONTINUE;
return PXL8_OK;
}
pxl8_game_result pxl8_update(pxl8_game* game) {
if (!game) {
return PXL8_GAME_FAILURE;
pxl8_result pxl8_update(pxl8* sys) {
if (!sys || !sys->game) {
return PXL8_ERROR_INVALID_ARGUMENT;
}
u64 current_time = game->hal->get_ticks();
pxl8_game* game = sys->game;
u64 current_time = sys->hal->get_ticks();
f32 dt = (f32)(current_time - game->last_time) / 1000000000.0f;
game->last_time = current_time;
@ -236,14 +287,15 @@ pxl8_game_result pxl8_update(pxl8_game* game) {
pxl8_script_call_function_f32(game->script, "update", dt);
}
return PXL8_GAME_CONTINUE;
return PXL8_OK;
}
pxl8_game_result pxl8_frame(pxl8_game* game) {
if (!game) {
return PXL8_GAME_FAILURE;
pxl8_result pxl8_frame(pxl8* sys) {
if (!sys || !sys->game) {
return PXL8_ERROR_INVALID_ARGUMENT;
}
pxl8_game* game = sys->game;
pxl8_bounds bounds = pxl8_gfx_get_bounds(game->gfx);
if (game->script_loaded) {
@ -284,11 +336,15 @@ pxl8_game_result pxl8_frame(pxl8_game* game) {
game->input.mouse_wheel_x = 0;
game->input.mouse_wheel_y = 0;
return game->running ? PXL8_GAME_CONTINUE : PXL8_GAME_SUCCESS;
game->frame_count++;
return PXL8_OK;
}
void pxl8_quit(pxl8_game* game) {
if (!game) return;
void pxl8_quit(pxl8* sys) {
if (!sys || !sys->game) return;
pxl8_game* game = sys->game;
if (game->repl_mode && game->repl) {
fprintf(stderr, "\r\033[K");
@ -299,10 +355,8 @@ void pxl8_quit(pxl8_game* game) {
pxl8_info("Shutting down");
if (game->cart) {
pxl8_cart_unload(game->cart);
free(game->cart);
game->cart = NULL;
if (sys->cart) {
pxl8_cart_unmount(sys->cart);
}
pxl8_gfx_destroy(game->gfx);
@ -310,6 +364,28 @@ void pxl8_quit(pxl8_game* game) {
if (game->ui) pxl8_ui_destroy(game->ui);
}
f32 pxl8_game_get_fps(const pxl8_game* game) {
return game ? game->fps : 0.0f;
bool pxl8_is_running(const pxl8* sys) {
return sys && sys->game && sys->game->running;
}
void pxl8_set_running(pxl8* sys, bool running) {
if (sys && sys->game) {
sys->game->running = running;
}
}
f32 pxl8_get_fps(const pxl8* sys) {
return (sys && sys->game) ? sys->game->fps : 0.0f;
}
pxl8_gfx* pxl8_get_gfx(pxl8* sys) {
return (sys && sys->game) ? sys->game->gfx : NULL;
}
pxl8_input_state* pxl8_get_input(pxl8* sys) {
return (sys && sys->game) ? &sys->game->input : NULL;
}
pxl8_resolution pxl8_get_resolution(pxl8* sys) {
return (sys && sys->game) ? sys->game->resolution : PXL8_RESOLUTION_640x360;
}

30
src/pxl8_game.h
View file

@ -1,22 +1,11 @@
#pragma once
#include "pxl8_cart.h"
#include "pxl8_gfx.h"
#include "pxl8_hal.h"
#include "pxl8_script.h"
#include "pxl8_types.h"
#include "pxl8_ui.h"
typedef enum pxl8_game_result {
PXL8_GAME_CONTINUE,
PXL8_GAME_SUCCESS,
PXL8_GAME_FAILURE
} pxl8_game_result;
typedef struct pxl8_game {
const pxl8_hal* hal;
pxl8_cart* cart;
pxl8_color_mode color_mode;
pxl8_gfx* gfx;
pxl8_resolution resolution;
@ -31,25 +20,12 @@ typedef struct pxl8_game {
i32 fps_frame_count;
f32 fps;
pxl8_input_state input;
pxl8_script_repl* repl;
bool repl_mode;
bool repl_started;
bool running;
bool script_loaded;
char script_path[256];
pxl8_input_state input;
pxl8_script_repl* repl;
} pxl8_game;
typedef struct pxl8_game_callbacks {
pxl8_game_result (*init)(pxl8_game* game, i32 argc, char* argv[]);
pxl8_game_result (*update)(pxl8_game* game);
pxl8_game_result (*frame)(pxl8_game* game);
void (*quit)(pxl8_game* game);
} pxl8_game_callbacks;
pxl8_game_result pxl8_init(pxl8_game* game, i32 argc, char* argv[]);
pxl8_game_result pxl8_update(pxl8_game* game);
pxl8_game_result pxl8_frame(pxl8_game* game);
void pxl8_quit(pxl8_game* game);
f32 pxl8_game_get_fps(const pxl8_game* game);

15
src/pxl8_gfx.c
View file

@ -135,11 +135,9 @@ u32 pxl8_gfx_get_palette_size(const pxl8_gfx* gfx) {
pxl8_gfx* pxl8_gfx_create(
const pxl8_hal* hal,
void* platform_data,
pxl8_color_mode mode,
pxl8_resolution resolution,
const char* title,
i32 window_width,
i32 window_height
pxl8_resolution resolution
) {
pxl8_gfx* gfx = (pxl8_gfx*)calloc(1, sizeof(pxl8_gfx));
if (!gfx) {
@ -148,6 +146,7 @@ pxl8_gfx* pxl8_gfx_create(
}
gfx->hal = hal;
gfx->platform_data = platform_data;
gfx->color_mode = mode;
pxl8_gfx_get_resolution_dimensions(
@ -156,9 +155,8 @@ pxl8_gfx* pxl8_gfx_create(
&gfx->framebuffer_height
);
gfx->platform_data = gfx->hal->create(mode, resolution, title, window_width, window_height);
if (!gfx->platform_data) {
pxl8_error("Failed to create platform context");
pxl8_error("Platform data cannot be NULL");
free(gfx);
return NULL;
}
@ -213,11 +211,6 @@ void pxl8_gfx_destroy(pxl8_gfx* gfx) {
pxl8_atlas_destroy(gfx->atlas);
free(gfx->sprite_cache);
if (gfx->hal && gfx->platform_data) {
gfx->hal->destroy(gfx->platform_data);
}
free(gfx->framebuffer);
free(gfx->palette);
free(gfx->zbuffer);

2
src/pxl8_gfx.h
View file

@ -49,7 +49,7 @@ typedef struct pxl8_triangle {
extern "C" {
#endif
pxl8_gfx* pxl8_gfx_create(const pxl8_hal* hal, pxl8_color_mode mode, pxl8_resolution resolution, const char* title, i32 window_width, i32 window_height);
pxl8_gfx* pxl8_gfx_create(const pxl8_hal* hal, void* platform_data, pxl8_color_mode mode, pxl8_resolution resolution);
void pxl8_gfx_destroy(pxl8_gfx* gfx);
pxl8_bounds pxl8_gfx_get_bounds(pxl8_gfx* gfx);

12
src/pxl8_script.c
View file

@ -80,12 +80,12 @@ static const char* pxl8_ffi_cdefs =
"typedef int64_t i64;\n"
"typedef float f32;\n"
"typedef double f64;\n"
"typedef struct pxl8 pxl8;\n"
"typedef struct pxl8_gfx pxl8_gfx;\n"
"typedef struct pxl8_game pxl8_game;\n"
"typedef struct { int x, y, w, h; } pxl8_bounds;\n"
"typedef struct { int x, y; } pxl8_point;\n"
"\n"
"f32 pxl8_game_get_fps(const pxl8_game* game);\n"
"f32 pxl8_get_fps(const pxl8* sys);\n"
"\n"
"i32 pxl8_gfx_get_height(pxl8_gfx* ctx);\n"
"i32 pxl8_gfx_get_width(pxl8_gfx* ctx);\n"
@ -451,11 +451,11 @@ void pxl8_script_set_ui(pxl8_script* script, pxl8_ui* ui) {
}
}
void pxl8_script_set_game(pxl8_script* script, void* game) {
void pxl8_script_set_sys(pxl8_script* script, void* sys) {
if (!script) return;
if (script->L && game) {
lua_pushlightuserdata(script->L, game);
lua_setglobal(script->L, "_pxl8_game");
if (script->L && sys) {
lua_pushlightuserdata(script->L, sys);
lua_setglobal(script->L, "_pxl8_sys");
}
}

2
src/pxl8_script.h
View file

@ -19,8 +19,8 @@ const char* pxl8_script_get_last_error(pxl8_script* script);
void pxl8_script_set_cart_path(pxl8_script* script, const char* cart_path, const char* original_cwd);
void pxl8_script_set_gfx(pxl8_script* script, pxl8_gfx* gfx);
void pxl8_script_set_input(pxl8_script* script, pxl8_input_state* input);
void pxl8_script_set_sys(pxl8_script* script, void* sys);
void pxl8_script_set_ui(pxl8_script* script, pxl8_ui* ui);
void pxl8_script_set_game(pxl8_script* script, void* game);
pxl8_result pxl8_script_call_function(pxl8_script* script, const char* name);
pxl8_result pxl8_script_call_function_f32(pxl8_script* script, const char* name, f32 arg);

104
src/pxl8_sdl3.c
View file

@ -5,8 +5,8 @@
#include <SDL3/SDL_main.h>
#include "pxl8_atlas.h"
#include "pxl8_game.h"
#include "pxl8_macros.h"
#include "pxl8_sys.h"
typedef struct pxl8_sdl3_context {
SDL_Texture* atlas_texture;
@ -236,75 +236,73 @@ SDL_AppResult SDL_AppInit(void** appstate, int argc, char* argv[]) {
return SDL_APP_FAILURE;
}
pxl8_game* game = (pxl8_game*)SDL_calloc(1, sizeof(pxl8_game));
if (!game) {
pxl8_error("Failed to allocate game instance");
pxl8* sys = pxl8_create(&pxl8_hal_sdl3);
if (!sys) {
pxl8_error("Failed to create pxl8 system");
SDL_Quit();
return SDL_APP_FAILURE;
}
game->hal = &pxl8_hal_sdl3;
pxl8_game_result result = pxl8_init(game, argc, argv);
if (result != PXL8_GAME_CONTINUE) {
SDL_free(game);
pxl8_result result = pxl8_init(sys, argc, argv);
if (result != PXL8_OK) {
pxl8_destroy(sys);
SDL_Quit();
return SDL_APP_FAILURE;
}
*appstate = game;
*appstate = sys;
return SDL_APP_CONTINUE;
}
SDL_AppResult SDL_AppIterate(void* appstate) {
pxl8_game* game = (pxl8_game*)appstate;
if (!game) {
pxl8* sys = (pxl8*)appstate;
if (!sys) {
return SDL_APP_FAILURE;
}
pxl8_game_result update_result = pxl8_update(game);
if (update_result == PXL8_GAME_FAILURE) {
return SDL_APP_FAILURE;
}
if (update_result == PXL8_GAME_SUCCESS) {
return SDL_APP_SUCCESS;
}
pxl8_game_result frame_result = pxl8_frame(game);
if (frame_result == PXL8_GAME_FAILURE) {
pxl8_result update_result = pxl8_update(sys);
if (update_result != PXL8_OK) {
return SDL_APP_FAILURE;
}
return (frame_result == PXL8_GAME_SUCCESS) ? SDL_APP_SUCCESS : SDL_APP_CONTINUE;
pxl8_result frame_result = pxl8_frame(sys);
if (frame_result != PXL8_OK) {
return SDL_APP_FAILURE;
}
return pxl8_is_running(sys) ? SDL_APP_CONTINUE : SDL_APP_SUCCESS;
}
SDL_AppResult SDL_AppEvent(void* appstate, SDL_Event* event) {
pxl8_game* game = (pxl8_game*)appstate;
pxl8* sys = (pxl8*)appstate;
if (!sys) {
return SDL_APP_CONTINUE;
}
if (!game) {
pxl8_input_state* input = pxl8_get_input(sys);
if (!input) {
return SDL_APP_CONTINUE;
}
switch (event->type) {
case SDL_EVENT_QUIT:
game->running = false;
pxl8_set_running(sys, false);
break;
case SDL_EVENT_KEY_DOWN: {
#ifdef DEBUG
if (event->key.key == SDLK_ESCAPE) {
game->running = false;
pxl8_set_running(sys, false);
}
#endif
SDL_Scancode scancode = event->key.scancode;
if (scancode < 256) {
if (!game->input.keys_down[scancode]) {
game->input.keys_pressed[scancode] = true;
if (!input->keys_down[scancode]) {
input->keys_pressed[scancode] = true;
}
game->input.keys_down[scancode] = true;
game->input.keys_released[scancode] = false;
input->keys_down[scancode] = true;
input->keys_released[scancode] = false;
}
break;
}
@ -312,9 +310,9 @@ SDL_AppResult SDL_AppEvent(void* appstate, SDL_Event* event) {
case SDL_EVENT_KEY_UP: {
SDL_Scancode scancode = event->key.scancode;
if (scancode < 256) {
game->input.keys_down[scancode] = false;
game->input.keys_pressed[scancode] = false;
game->input.keys_released[scancode] = true;
input->keys_down[scancode] = false;
input->keys_pressed[scancode] = false;
input->keys_released[scancode] = true;
}
break;
}
@ -322,11 +320,11 @@ SDL_AppResult SDL_AppEvent(void* appstate, SDL_Event* event) {
case SDL_EVENT_MOUSE_BUTTON_DOWN: {
u8 button = event->button.button - 1;
if (button < 3) {
if (!game->input.mouse_buttons_down[button]) {
game->input.mouse_buttons_pressed[button] = true;
if (!input->mouse_buttons_down[button]) {
input->mouse_buttons_pressed[button] = true;
}
game->input.mouse_buttons_down[button] = true;
game->input.mouse_buttons_released[button] = false;
input->mouse_buttons_down[button] = true;
input->mouse_buttons_released[button] = false;
}
break;
}
@ -334,15 +332,16 @@ SDL_AppResult SDL_AppEvent(void* appstate, SDL_Event* event) {
case SDL_EVENT_MOUSE_BUTTON_UP: {
u8 button = event->button.button - 1;
if (button < 3) {
game->input.mouse_buttons_down[button] = false;
game->input.mouse_buttons_pressed[button] = false;
game->input.mouse_buttons_released[button] = true;
input->mouse_buttons_down[button] = false;
input->mouse_buttons_pressed[button] = false;
input->mouse_buttons_released[button] = true;
}
break;
}
case SDL_EVENT_MOUSE_MOTION: {
if (!game->gfx) break;
pxl8_gfx* gfx = pxl8_get_gfx(sys);
if (!gfx) break;
i32 window_mouse_x = (i32)event->motion.x;
i32 window_mouse_y = (i32)event->motion.y;
@ -354,19 +353,20 @@ SDL_AppResult SDL_AppEvent(void* appstate, SDL_Event* event) {
SDL_GetWindowSize(window, &window_width, &window_height);
i32 render_width, render_height;
pxl8_gfx_get_resolution_dimensions(game->resolution, &render_width, &render_height);
pxl8_resolution resolution = pxl8_get_resolution(sys);
pxl8_gfx_get_resolution_dimensions(resolution, &render_width, &render_height);
pxl8_bounds window_bounds = {0, 0, window_width, window_height};
pxl8_viewport vp = pxl8_gfx_viewport(window_bounds, render_width, render_height);
game->input.mouse_x = (i32)((window_mouse_x - vp.offset_x) / vp.scale);
game->input.mouse_y = (i32)((window_mouse_y - vp.offset_y) / vp.scale);
input->mouse_x = (i32)((window_mouse_x - vp.offset_x) / vp.scale);
input->mouse_y = (i32)((window_mouse_y - vp.offset_y) / vp.scale);
break;
}
case SDL_EVENT_MOUSE_WHEEL: {
game->input.mouse_wheel_x = (i32)event->wheel.x;
game->input.mouse_wheel_y = (i32)event->wheel.y;
input->mouse_wheel_x = (i32)event->wheel.x;
input->mouse_wheel_y = (i32)event->wheel.y;
break;
}
}
@ -377,10 +377,10 @@ SDL_AppResult SDL_AppEvent(void* appstate, SDL_Event* event) {
void SDL_AppQuit(void* appstate, SDL_AppResult result) {
(void)result;
pxl8_game* game = (pxl8_game*)appstate;
if (game) {
pxl8_quit(game);
SDL_free(game);
pxl8* sys = (pxl8*)appstate;
if (sys) {
pxl8_quit(sys);
pxl8_destroy(sys);
}
SDL_Quit();

24
src/pxl8_sys.h Normal file
View file

@ -0,0 +1,24 @@
#pragma once
#include "pxl8_gfx.h"
#include "pxl8_hal.h"
#include "pxl8_io.h"
#include "pxl8_types.h"
typedef struct pxl8 pxl8;
pxl8* pxl8_create(const pxl8_hal* hal);
void pxl8_destroy(pxl8* sys);
bool pxl8_is_running(const pxl8* sys);
void pxl8_set_running(pxl8* sys, bool running);
f32 pxl8_get_fps(const pxl8* sys);
pxl8_gfx* pxl8_get_gfx(pxl8* sys);
pxl8_input_state* pxl8_get_input(pxl8* sys);
pxl8_resolution pxl8_get_resolution(pxl8* sys);
pxl8_result pxl8_init(pxl8* sys, i32 argc, char* argv[]);
pxl8_result pxl8_update(pxl8* sys);
pxl8_result pxl8_frame(pxl8* sys);
void pxl8_quit(pxl8* sys);