cleanup headers a bit

src/pxl8_atlas.h

@@ -10,17 +10,25 @@ typedef struct pxl8_atlas_entry {
     i32 x, y, w, h;
 } pxl8_atlas_entry;
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 pxl8_atlas* pxl8_atlas_create(u32 width, u32 height, pxl8_color_mode color_mode);
 void pxl8_atlas_destroy(pxl8_atlas* atlas);
 
-u32 pxl8_atlas_add_texture(pxl8_atlas* atlas, const u8* pixels, u32 w, u32 h,
-                           pxl8_color_mode color_mode);
-bool pxl8_atlas_expand(pxl8_atlas* atlas, pxl8_color_mode color_mode);
-
 const pxl8_atlas_entry* pxl8_atlas_get_entry(const pxl8_atlas* atlas, u32 id);
 u32 pxl8_atlas_get_entry_count(const pxl8_atlas* atlas);
 u32 pxl8_atlas_get_height(const pxl8_atlas* atlas);
 const u8* pxl8_atlas_get_pixels(const pxl8_atlas* atlas);
 u32 pxl8_atlas_get_width(const pxl8_atlas* atlas);
 bool pxl8_atlas_is_dirty(const pxl8_atlas* atlas);
+
 void pxl8_atlas_mark_clean(pxl8_atlas* atlas);
+
+u32 pxl8_atlas_add_texture(pxl8_atlas* atlas, const u8* pixels, u32 w, u32 h, pxl8_color_mode color_mode);
+bool pxl8_atlas_expand(pxl8_atlas* atlas, pxl8_color_mode color_mode);
+
+#ifdef __cplusplus
+}
+#endif

src/pxl8_bsp.h

@@ -4,31 +4,10 @@
 #include "pxl8_math.h"
 #include "pxl8_types.h"
 
-typedef struct pxl8_bsp_vertex {
-    pxl8_vec3 position;
-} pxl8_bsp_vertex;
-
 typedef struct pxl8_bsp_edge {
     u16 vertex[2];
 } pxl8_bsp_edge;
 
-typedef struct pxl8_bsp_plane {
-    f32 dist;
-    pxl8_vec3 normal;
-    i32 type;
-} pxl8_bsp_plane;
-
-typedef struct pxl8_bsp_texinfo {
-    u32 miptex;
-    char name[16];
-
-    f32 u_offset;
-    pxl8_vec3 u_axis;
-
-    f32 v_offset;
-    pxl8_vec3 v_axis;
-} pxl8_bsp_texinfo;
-
 typedef struct pxl8_bsp_face {
     u32 first_edge;
     u32 lightmap_offset;
@@ -43,17 +22,6 @@ typedef struct pxl8_bsp_face {
     pxl8_vec3 aabb_max;
 } pxl8_bsp_face;
 
-typedef struct pxl8_bsp_node {
-    i32 children[2];
-
-    u16 first_face;
-    i16 maxs[3];
-    i16 mins[3];
-    u16 num_faces;
-
-    u32 plane_id;
-} pxl8_bsp_node;
-
 typedef struct pxl8_bsp_leaf {
     u8 ambient_level[4];
     i32 contents;
@@ -77,6 +45,38 @@ typedef struct pxl8_bsp_model {
     i32 visleafs;
 } pxl8_bsp_model;
 
+typedef struct pxl8_bsp_node {
+    i32 children[2];
+
+    u16 first_face;
+    i16 maxs[3];
+    i16 mins[3];
+    u16 num_faces;
+
+    u32 plane_id;
+} pxl8_bsp_node;
+
+typedef struct pxl8_bsp_plane {
+    f32 dist;
+    pxl8_vec3 normal;
+    i32 type;
+} pxl8_bsp_plane;
+
+typedef struct pxl8_bsp_texinfo {
+    u32 miptex;
+    char name[16];
+
+    f32 u_offset;
+    pxl8_vec3 u_axis;
+
+    f32 v_offset;
+    pxl8_vec3 v_axis;
+} pxl8_bsp_texinfo;
+
+typedef struct pxl8_bsp_vertex {
+    pxl8_vec3 position;
+} pxl8_bsp_vertex;
+
 typedef struct pxl8_bsp {
     pxl8_bsp_edge* edges;
     pxl8_bsp_face* faces;

src/pxl8_gfx.h

@@ -58,22 +58,24 @@ u8* pxl8_gfx_get_framebuffer(pxl8_gfx* gfx);
 i32 pxl8_gfx_get_height(const pxl8_gfx* gfx);
 u32 pxl8_gfx_get_palette_size(const pxl8_gfx* gfx);
 i32 pxl8_gfx_get_width(const pxl8_gfx* gfx);
+
+void pxl8_gfx_set_viewport(pxl8_gfx* gfx, pxl8_viewport vp);
+
+pxl8_result pxl8_gfx_create_texture(pxl8_gfx* gfx, const u8* pixels, u32 width, u32 height);
 pxl8_result pxl8_gfx_load_font_atlas(pxl8_gfx* gfx);
 pxl8_result pxl8_gfx_load_palette(pxl8_gfx* gfx, const char* path);
 pxl8_result pxl8_gfx_load_sprite(pxl8_gfx* gfx, const char* path);
-pxl8_result pxl8_gfx_create_texture(pxl8_gfx* gfx, const u8* pixels, u32 width, u32 height);
 void pxl8_gfx_present(pxl8_gfx* gfx);
+void pxl8_gfx_process_effects(pxl8_gfx* gfx, pxl8_effects* effects, f32 dt);
 void pxl8_gfx_project(pxl8_gfx* gfx, f32 left, f32 right, f32 top, f32 bottom);
 void pxl8_gfx_upload_atlas(pxl8_gfx* gfx);
 void pxl8_gfx_upload_framebuffer(pxl8_gfx* gfx);
 pxl8_viewport pxl8_gfx_viewport(pxl8_bounds bounds, i32 width, i32 height);
-void pxl8_gfx_set_viewport(pxl8_gfx* gfx, pxl8_viewport vp);
 
 void pxl8_gfx_color_ramp(pxl8_gfx* gfx, u8 start, u8 count, u32 from_color, u32 to_color);
 void pxl8_gfx_cycle_palette(pxl8_gfx* gfx, u8 start, u8 count, i32 step);
 void pxl8_gfx_fade_palette(pxl8_gfx* gfx, u8 start, u8 count, f32 amount, u32 target_color);
 void pxl8_gfx_interpolate_palettes(pxl8_gfx* gfx, u32* palette1, u32* palette2, u8 start, u8 count, f32 t);
-void pxl8_gfx_process_effects(pxl8_gfx* gfx, pxl8_effects* effects, f32 dt);
 void pxl8_gfx_swap_palette(pxl8_gfx* gfx, u8 start, u8 count, u32* new_colors);
 
 void pxl8_circle(pxl8_gfx* gfx, i32 cx, i32 cy, i32 radius, u32 color);
@@ -88,10 +90,6 @@ void pxl8_sprite(pxl8_gfx* gfx, u32 sprite_id, i32 x, i32 y, i32 w, i32 h);
 void pxl8_text(pxl8_gfx* gfx, const char* text, i32 x, i32 y, u32 color);
 
 void pxl8_3d_clear_zbuffer(pxl8_gfx* gfx);
-void pxl8_3d_draw_line_3d(pxl8_gfx* gfx, pxl8_vec3 p0, pxl8_vec3 p1, u32 color);
-void pxl8_3d_draw_triangle(pxl8_gfx* gfx, pxl8_triangle tri);
-void pxl8_3d_draw_triangle_raw(pxl8_gfx* gfx, pxl8_vec3 v0, pxl8_vec3 v1, pxl8_vec3 v2, u32 color);
-void pxl8_3d_draw_triangle_textured(pxl8_gfx* gfx, pxl8_vec3 v0, pxl8_vec3 v1, pxl8_vec3 v2, f32 u0, f32 v0f, f32 u1, f32 v1f, f32 u2, f32 v2f, u32 texture_id);
 const pxl8_frustum* pxl8_3d_get_frustum(pxl8_gfx* gfx);
 void pxl8_3d_set_affine_textures(pxl8_gfx* gfx, bool affine);
 void pxl8_3d_set_backface_culling(pxl8_gfx* gfx, bool culling);
@@ -99,6 +97,10 @@ void pxl8_3d_set_model(pxl8_gfx* gfx, pxl8_mat4 mat);
 void pxl8_3d_set_projection(pxl8_gfx* gfx, pxl8_mat4 mat);
 void pxl8_3d_set_view(pxl8_gfx* gfx, pxl8_mat4 mat);
 void pxl8_3d_set_wireframe(pxl8_gfx* gfx, bool wireframe);
+void pxl8_3d_draw_line_3d(pxl8_gfx* gfx, pxl8_vec3 p0, pxl8_vec3 p1, u32 color);
+void pxl8_3d_draw_triangle(pxl8_gfx* gfx, pxl8_triangle tri);
+void pxl8_3d_draw_triangle_raw(pxl8_gfx* gfx, pxl8_vec3 v0, pxl8_vec3 v1, pxl8_vec3 v2, u32 color);
+void pxl8_3d_draw_triangle_textured(pxl8_gfx* gfx, pxl8_vec3 v0, pxl8_vec3 v1, pxl8_vec3 v2, f32 u0, f32 v0f, f32 u1, f32 v1f, f32 u2, f32 v2f, u32 texture_id);
 
 #ifdef __cplusplus
 }

src/pxl8_gui.h

@@ -19,19 +19,19 @@ extern "C" {
 pxl8_gui_state* pxl8_gui_state_create(void);
 void pxl8_gui_state_destroy(pxl8_gui_state* state);
 
+void pxl8_gui_get_cursor_pos(const pxl8_gui_state* state, i32* x, i32* y);
+bool pxl8_gui_is_hovering(const pxl8_gui_state* state);
+
 void pxl8_gui_begin_frame(pxl8_gui_state* state);
 void pxl8_gui_end_frame(pxl8_gui_state* state);
 
-void pxl8_gui_cursor_move(pxl8_gui_state* state, i32 x, i32 y);
 void pxl8_gui_cursor_down(pxl8_gui_state* state);
+void pxl8_gui_cursor_move(pxl8_gui_state* state, i32 x, i32 y);
 void pxl8_gui_cursor_up(pxl8_gui_state* state);
 
 bool pxl8_gui_button(pxl8_gui_state* state, pxl8_gfx* gfx, u32 id, i32 x, i32 y, i32 w, i32 h, const char* label);
-void pxl8_gui_window(pxl8_gfx* gfx, i32 x, i32 y, i32 w, i32 h, const char* title);
 void pxl8_gui_label(pxl8_gfx* gfx, i32 x, i32 y, const char* text, u8 color);
-
+void pxl8_gui_window(pxl8_gfx* gfx, i32 x, i32 y, i32 w, i32 h, const char* title);
-bool pxl8_gui_is_hovering(const pxl8_gui_state* state);
-void pxl8_gui_get_cursor_pos(const pxl8_gui_state* state, i32* x, i32* y);
 
 #ifdef __cplusplus
 }

src/pxl8_io.h

@@ -100,14 +100,14 @@ bool pxl8_key_down(const pxl8_input_state* input, const char* key_name);
 bool pxl8_key_pressed(const pxl8_input_state* input, const char* key_name);
 bool pxl8_key_released(const pxl8_input_state* input, const char* key_name);
 
+i32 pxl8_mouse_dx(const pxl8_input_state* input);
+i32 pxl8_mouse_dy(const pxl8_input_state* input);
 bool pxl8_mouse_pressed(const pxl8_input_state* input, i32 button);
 bool pxl8_mouse_released(const pxl8_input_state* input, i32 button);
 i32 pxl8_mouse_wheel_x(const pxl8_input_state* input);
 i32 pxl8_mouse_wheel_y(const pxl8_input_state* input);
 i32 pxl8_mouse_x(const pxl8_input_state* input);
 i32 pxl8_mouse_y(const pxl8_input_state* input);
-i32 pxl8_mouse_dx(const pxl8_input_state* input);
-i32 pxl8_mouse_dy(const pxl8_input_state* input);
 
 #ifdef __cplusplus
 }

src/pxl8_script.h

@@ -15,6 +15,8 @@ pxl8_script* pxl8_script_create(void);
 void pxl8_script_destroy(pxl8_script* script);
 
 const char* pxl8_script_get_last_error(pxl8_script* script);
+bool pxl8_script_is_incomplete_input(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);
@@ -22,27 +24,24 @@ void pxl8_script_set_sys(pxl8_script* script, void* sys);
 
 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);
+bool pxl8_script_check_reload(pxl8_script* script);
 pxl8_result pxl8_script_eval(pxl8_script* script, const char* code);
 pxl8_result pxl8_script_eval_repl(pxl8_script* script, const char* code);
+pxl8_result pxl8_script_load_main(pxl8_script* script, const char* path);
 pxl8_result pxl8_script_load_module(pxl8_script* script, const char* module_name);
 pxl8_result pxl8_script_run_fennel_file(pxl8_script* script, const char* filename);
 pxl8_result pxl8_script_run_file(pxl8_script* script, const char* filename);
 
-pxl8_result pxl8_script_load_main(pxl8_script* script, const char* path);
-bool pxl8_script_check_reload(pxl8_script* script);
-
 pxl8_script_repl* pxl8_script_repl_create(void);
-void pxl8_script_repl_init(pxl8_script_repl* repl);
-void pxl8_script_repl_shutdown(pxl8_script_repl* repl);
 void pxl8_script_repl_destroy(pxl8_script_repl* repl);
 
-pxl8_script_repl_command* pxl8_script_repl_pop_command(pxl8_script_repl* repl);
+void pxl8_script_repl_clear_accumulator(pxl8_script_repl* repl);
 const char* pxl8_script_repl_command_buffer(pxl8_script_repl_command* cmd);
 void pxl8_script_repl_eval_complete(pxl8_script_repl* repl);
-void pxl8_script_repl_clear_accumulator(pxl8_script_repl* repl);
+void pxl8_script_repl_init(pxl8_script_repl* repl);
-
+pxl8_script_repl_command* pxl8_script_repl_pop_command(pxl8_script_repl* repl);
 bool pxl8_script_repl_should_quit(pxl8_script_repl* repl);
-bool pxl8_script_is_incomplete_input(pxl8_script* script);
+void pxl8_script_repl_shutdown(pxl8_script_repl* repl);
 
 #ifdef __cplusplus
 }

src/pxl8_sys.h

@@ -7,25 +7,31 @@
 
 typedef struct pxl8 pxl8;
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 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(const pxl8* sys);
 pxl8_input_state* pxl8_get_input(const pxl8* sys);
+u32 pxl8_get_palette_size(pxl8_color_mode mode);
 pxl8_resolution pxl8_get_resolution(const pxl8* sys);
+pxl8_size pxl8_get_resolution_dimensions(pxl8_resolution resolution);
+bool pxl8_is_running(const pxl8* sys);
 
-void pxl8_center_cursor(pxl8* sys);
 void pxl8_set_cursor(pxl8* sys, pxl8_cursor cursor);
 void pxl8_set_relative_mouse_mode(pxl8* sys, bool enabled);
+void pxl8_set_running(pxl8* sys, bool running);
 
-pxl8_result pxl8_init(pxl8* sys, i32 argc, char* argv[]);
+void pxl8_center_cursor(pxl8* sys);
-pxl8_result pxl8_update(pxl8* sys);
 pxl8_result pxl8_frame(pxl8* sys);
+pxl8_result pxl8_init(pxl8* sys, i32 argc, char* argv[]);
 void pxl8_quit(pxl8* sys);
+pxl8_result pxl8_update(pxl8* sys);
 
-u32 pxl8_get_palette_size(pxl8_color_mode mode);
+#ifdef __cplusplus
-pxl8_size pxl8_get_resolution_dimensions(pxl8_resolution resolution);
+}
+#endif

src/pxl8_tilemap.h

@@ -91,62 +91,32 @@ extern "C" {
 
 pxl8_tilemap* pxl8_tilemap_create(u32 width, u32 height, u32 tile_size);
 void pxl8_tilemap_destroy(pxl8_tilemap* tilemap);
-u32 pxl8_tilemap_get_height(const pxl8_tilemap* tilemap);
-pxl8_tile pxl8_tilemap_get_tile(const pxl8_tilemap* tilemap, u32 layer, u32 x, u32 y);
-u32 pxl8_tilemap_get_tile_size(const pxl8_tilemap* tilemap);
-void* pxl8_tilemap_get_tile_user_data(const pxl8_tilemap* tilemap, u16 tile_id);
-u32 pxl8_tilemap_get_width(const pxl8_tilemap* tilemap);
-pxl8_result pxl8_tilemap_load_ase(pxl8_tilemap* tilemap, const char* filepath, u32 layer);
-void pxl8_tilemap_set_tile_user_data(pxl8_tilemap* tilemap, u16 tile_id, void* user_data);
 
-bool pxl8_tilemap_check_collision(const pxl8_tilemap* tilemap, i32 x, i32 y, i32 w, i32 h);
+u32 pxl8_tilemap_get_height(const pxl8_tilemap* tilemap);
-void pxl8_tilemap_compress(pxl8_tilemap* tilemap);
 u32 pxl8_tilemap_get_memory_usage(const pxl8_tilemap* tilemap);
 pxl8_tile pxl8_tilemap_get_tile(const pxl8_tilemap* tilemap, u32 layer, u32 x, u32 y);
 u16 pxl8_tilemap_get_tile_id(const pxl8_tilemap* tilemap, u32 layer, u32 x, u32 y);
-void pxl8_tilemap_get_view(
+u32 pxl8_tilemap_get_tile_size(const pxl8_tilemap* tilemap);
-    const pxl8_tilemap* tilemap,
+void* pxl8_tilemap_get_tile_user_data(const pxl8_tilemap* tilemap, u16 tile_id);
-    const pxl8_gfx* gfx,
+void pxl8_tilemap_get_view(const pxl8_tilemap* tilemap, const pxl8_gfx* gfx, pxl8_tilemap_view* view);
-    pxl8_tilemap_view* view
+u32 pxl8_tilemap_get_width(const pxl8_tilemap* tilemap);
-);
+
+void pxl8_tilemap_set_camera(pxl8_tilemap* tilemap, i32 x, i32 y);
+pxl8_result pxl8_tilemap_set_tile(pxl8_tilemap* tilemap, u32 layer, u32 x, u32 y, u16 tile_id, u8 flags);
+pxl8_result pxl8_tilemap_set_tile_auto(pxl8_tilemap* tilemap, u32 layer, u32 x, u32 y, u16 base_tile_id, u8 flags);
+void pxl8_tilemap_set_tile_user_data(pxl8_tilemap* tilemap, u16 tile_id, void* user_data);
+pxl8_result pxl8_tilemap_set_tilesheet(pxl8_tilemap* tilemap, pxl8_tilesheet* tilesheet);
+
+pxl8_result pxl8_tilemap_load_ase(pxl8_tilemap* tilemap, const char* filepath, u32 layer);
+
+bool pxl8_tilemap_check_collision(const pxl8_tilemap* tilemap, i32 x, i32 y, i32 w, i32 h);
+void pxl8_tilemap_compress(pxl8_tilemap* tilemap);
 bool pxl8_tilemap_is_solid(const pxl8_tilemap* tilemap, u32 x, u32 y);
 void pxl8_tilemap_render(const pxl8_tilemap* tilemap, pxl8_gfx* gfx);
 void pxl8_tilemap_render_layer(const pxl8_tilemap* tilemap, pxl8_gfx* gfx, u32 layer);
-void pxl8_tilemap_render_tile(
+void pxl8_tilemap_render_tile(const pxl8_tilemap* tilemap, pxl8_gfx* gfx, u16 tile_id, i32 x, i32 y, u8 flags);
-    const pxl8_tilemap* tilemap,
-    pxl8_gfx* gfx,
-    u16 tile_id,
-    i32 x,
-    i32 y,
-    u8 flags
-);
-void pxl8_tilemap_set_camera(pxl8_tilemap* tilemap, i32 x, i32 y);
-pxl8_result pxl8_tilemap_set_tile(
-    pxl8_tilemap* tilemap,
-    u32 layer,
-    u32 x,
-    u32 y,
-    u16 tile_id,
-    u8 flags
-);
-pxl8_result pxl8_tilemap_set_tile_auto(
-    pxl8_tilemap* tilemap,
-    u32 layer,
-    u32 x,
-    u32 y,
-    u16 base_tile_id,
-    u8 flags
-);
-pxl8_result pxl8_tilemap_set_tilesheet(pxl8_tilemap* tilemap, pxl8_tilesheet* tilesheet);
 void pxl8_tilemap_update(pxl8_tilemap* tilemap, f32 delta_time);
-void pxl8_tilemap_update_autotiles(
+void pxl8_tilemap_update_autotiles(pxl8_tilemap* tilemap, u32 layer, u32 x, u32 y, u32 w, u32 h);
-    pxl8_tilemap* tilemap,
-    u32 layer,
-    u32 x,
-    u32 y,
-    u32 w,
-    u32 h
-);
 
 #ifdef __cplusplus
 }

src/pxl8_tilesheet.h

@@ -1,11 +1,11 @@
 #pragma once
 
-#include "pxl8_types.h"
 #include "pxl8_gfx.h"
+#include "pxl8_types.h"
 
+typedef struct pxl8_autotile_rule pxl8_autotile_rule;
 typedef struct pxl8_tile_animation pxl8_tile_animation;
 typedef struct pxl8_tile_properties pxl8_tile_properties;
-typedef struct pxl8_autotile_rule pxl8_autotile_rule;
 typedef struct pxl8_tilesheet pxl8_tilesheet;
 
 #ifdef __cplusplus
@@ -15,44 +15,22 @@ extern "C" {
 pxl8_tilesheet* pxl8_tilesheet_create(u32 tile_size);
 void pxl8_tilesheet_destroy(pxl8_tilesheet* tilesheet);
 
-pxl8_result pxl8_tilesheet_add_animation(
-    pxl8_tilesheet* tilesheet,
-    u16 base_tile_id,
-    const u16* frames,
-    u16 frame_count,
-    f32 frame_duration
-);
-pxl8_result pxl8_tilesheet_add_autotile_rule(
-    pxl8_tilesheet* tilesheet,
-    u16 base_tile_id,
-    u8 neighbor_mask,
-    u16 result_tile_id
-);
-u16 pxl8_tilesheet_apply_autotile(const pxl8_tilesheet* tilesheet, u16 base_tile_id, u8 neighbors);
 u16 pxl8_tilesheet_get_animated_frame(const pxl8_tilesheet* tilesheet, u16 tile_id);
-const pxl8_tile_properties* pxl8_tilesheet_get_tile_property(
+const pxl8_tile_properties* pxl8_tilesheet_get_tile_property(const pxl8_tilesheet* tilesheet, u16 tile_id);
-    const pxl8_tilesheet* tilesheet,
-    u16 tile_id
-);
 u32 pxl8_tilesheet_get_tile_size(const pxl8_tilesheet* tilesheet);
 bool pxl8_tilesheet_is_tile_valid(const pxl8_tilesheet* tilesheet, u16 tile_id);
+
+pxl8_result pxl8_tilesheet_set_tile_pixels(pxl8_tilesheet* tilesheet, u16 tile_id, const u8* pixels);
+void pxl8_tilesheet_set_tile_property(pxl8_tilesheet* tilesheet, u16 tile_id, const pxl8_tile_properties* props);
+
 pxl8_result pxl8_tilesheet_load(pxl8_tilesheet* tilesheet, const char* filepath, pxl8_gfx* gfx);
 void pxl8_tilesheet_ref(pxl8_tilesheet* tilesheet);
-void pxl8_tilesheet_render_tile(
-    const pxl8_tilesheet* tilesheet,
-    pxl8_gfx* gfx,
-    u16 tile_id,
-    i32 x,
-    i32 y,
-    u8 flags
-);
-pxl8_result pxl8_tilesheet_set_tile_pixels(pxl8_tilesheet* tilesheet, u16 tile_id, const u8* pixels);
-void pxl8_tilesheet_set_tile_property(
-    pxl8_tilesheet* tilesheet,
-    u16 tile_id,
-    const pxl8_tile_properties* props
-);
 void pxl8_tilesheet_unref(pxl8_tilesheet* tilesheet);
+
+pxl8_result pxl8_tilesheet_add_animation(pxl8_tilesheet* tilesheet, u16 base_tile_id, const u16* frames, u16 frame_count, f32 frame_duration);
+pxl8_result pxl8_tilesheet_add_autotile_rule(pxl8_tilesheet* tilesheet, u16 base_tile_id, u8 neighbor_mask, u16 result_tile_id);
+u16 pxl8_tilesheet_apply_autotile(const pxl8_tilesheet* tilesheet, u16 base_tile_id, u8 neighbors);
+void pxl8_tilesheet_render_tile(const pxl8_tilesheet* tilesheet, pxl8_gfx* gfx, u16 tile_id, i32 x, i32 y, u8 flags);
 void pxl8_tilesheet_update_animations(pxl8_tilesheet* tilesheet, f32 delta_time);
 
 #ifdef __cplusplus

src/pxl8_transition.h

@@ -38,10 +38,12 @@ void pxl8_transition_destroy(pxl8_transition* transition);
 f32 pxl8_transition_get_progress(const pxl8_transition* transition);
 bool pxl8_transition_is_active(const pxl8_transition* transition);
 bool pxl8_transition_is_complete(const pxl8_transition* transition);
-void pxl8_transition_render(const pxl8_transition* transition, pxl8_gfx* gfx);
+
-void pxl8_transition_reset(pxl8_transition* transition);
 void pxl8_transition_set_color(pxl8_transition* transition, u32 color);
 void pxl8_transition_set_reverse(pxl8_transition* transition, bool reverse);
+
+void pxl8_transition_render(const pxl8_transition* transition, pxl8_gfx* gfx);
+void pxl8_transition_reset(pxl8_transition* transition);
 void pxl8_transition_start(pxl8_transition* transition);
 void pxl8_transition_stop(pxl8_transition* transition);
 void pxl8_transition_update(pxl8_transition* transition, f32 dt);

src/pxl8_ui.h

@@ -49,13 +49,11 @@ extern "C" {
 pxl8_ui* pxl8_ui_create(pxl8_gfx* gfx);
 void pxl8_ui_destroy(pxl8_ui* ui);
 
+bool pxl8_ui_has_mouse_focus(pxl8_ui* ui);
+
 void pxl8_ui_frame_begin(pxl8_ui* ui);
 void pxl8_ui_frame_end(pxl8_ui* ui);
 
-bool pxl8_ui_button(pxl8_ui* ui, const char* label);
-bool pxl8_ui_checkbox(pxl8_ui* ui, const char* label, bool* state);
-bool pxl8_ui_has_mouse_focus(pxl8_ui* ui);
-void pxl8_ui_indent(pxl8_ui* ui, i32 amount);
 void pxl8_ui_input_keydown(pxl8_ui* ui, i32 key);
 void pxl8_ui_input_keyup(pxl8_ui* ui, i32 key);
 void pxl8_ui_input_mousedown(pxl8_ui* ui, i32 x, i32 y, i32 button);
@@ -63,6 +61,10 @@ void pxl8_ui_input_mousemove(pxl8_ui* ui, i32 x, i32 y);
 void pxl8_ui_input_mouseup(pxl8_ui* ui, i32 x, i32 y, i32 button);
 void pxl8_ui_input_scroll(pxl8_ui* ui, i32 x, i32 y);
 void pxl8_ui_input_text(pxl8_ui* ui, const char* text);
+
+bool pxl8_ui_button(pxl8_ui* ui, const char* label);
+bool pxl8_ui_checkbox(pxl8_ui* ui, const char* label, bool* state);
+void pxl8_ui_indent(pxl8_ui* ui, i32 amount);
 void pxl8_ui_label(pxl8_ui* ui, const char* text);
 void pxl8_ui_layout_row(pxl8_ui* ui, i32 item_count, const i32* widths, i32 height);
 i32 pxl8_ui_menu(pxl8_ui* ui, pxl8_menu_item* items, i32 item_count);