twn_util.h: separate internal things away, remove indirect includes in places

apps/demos/bunnymark/game.c

@@ -17,7 +17,7 @@ void handle_input(void)
 {
     State *state = ctx.udata;
 
-    if (ctx.mouse_window_position.y <= 60)
+    if (ctx.mouse_position.y <= 60)
         return;
 
     if (input_is_action_pressed("add_a_bit"))
@@ -27,10 +27,10 @@ void handle_input(void)
             if (state->bunniesCount < MAX_BUNNIES)
             {
                 state->bunnies[state->bunniesCount].position = input_get_action_position("add_a_bit");
-                state->bunnies[state->bunniesCount].speed.x = (float)(rand() % 500 - 250) / 60.0;
-                state->bunnies[state->bunniesCount].speed.y = (float)(rand() % 500 - 250) / 60.0;
+                state->bunnies[state->bunniesCount].speed.x = (float)(rand() % 500 - 250) / 60.0f;
+                state->bunnies[state->bunniesCount].speed.y = (float)(rand() % 500 - 250) / 60.0f;
                 state->bunnies[state->bunniesCount].color =
-                    (Color){rand() % 190 + 50, rand() % 160 + 80, rand() % 140 + 100, 255};
+                    (Color){(uint8_t)(rand() % 190 + 50), (uint8_t)(rand() % 160 + 80), (uint8_t)(rand() % 140 + 100), 255};
                 state->bunniesCount++;
             }
         }
@@ -43,10 +43,10 @@ void handle_input(void)
             if (state->bunniesCount < MAX_BUNNIES)
             {
                 state->bunnies[state->bunniesCount].position = input_get_action_position("add_a_lot");
-                state->bunnies[state->bunniesCount].speed.x = (float)(rand() % 500 - 250) / 60.0;
-                state->bunnies[state->bunniesCount].speed.y = (float)(rand() % 500 - 250) / 60.0;
+                state->bunnies[state->bunniesCount].speed.x = (float)(rand() % 500 - 250) / 60.0f;
+                state->bunnies[state->bunniesCount].speed.y = (float)(rand() % 500 - 250) / 60.0f;
                 state->bunnies[state->bunniesCount].color =
-                    (Color){rand() % 190 + 50, rand() % 160 + 80, rand() % 140 + 100, 255};
+                    (Color){(uint8_t)(rand() % 190 + 50), (uint8_t)(rand() % 160 + 80), (uint8_t)(rand() % 140 + 100), 255};
                 state->bunniesCount++;
             }
         }
@@ -73,32 +73,29 @@ void game_tick(void)
 
     State *state = ctx.udata;
 
-    const double delta =
-        (double)(ctx.delta_time) / 1000.0; // Receiving floating point delta value (diving by 1000 based on vibe)
-
     for (int i = 0; i < state->bunniesCount; i++)
     {
         state->bunnies[i].position.x += state->bunnies[i].speed.x;
         state->bunnies[i].position.y += state->bunnies[i].speed.y;
 
-        if (((state->bunnies[i].position.x + BUNNY_W / 2) > ctx.base_draw_w) ||
-            ((state->bunnies[i].position.x + BUNNY_W / 2) < 0))
+        if (((state->bunnies[i].position.x + (float)BUNNY_W / 2) > (float)ctx.resolution.x) ||
+            ((state->bunnies[i].position.x + (float)BUNNY_W / 2) < 0))
             state->bunnies[i].speed.x *= -1;
-        if (((state->bunnies[i].position.y + BUNNY_H / 2) > ctx.base_draw_h) ||
-            ((state->bunnies[i].position.y + BUNNY_H / 2 - 60) < 0))
+        if (((state->bunnies[i].position.y + (float)BUNNY_H / 2) > (float)ctx.resolution.y) ||
+            ((state->bunnies[i].position.y + (float)BUNNY_H / 2 - 60) < 0))
             state->bunnies[i].speed.y *= -1;
     }
 
     handle_input();
 
     // Clear window with Gray color (set the background color this way)
-    draw_rectangle((Rect){0, 0, ctx.base_draw_w, ctx.base_draw_h}, GRAY);
+    draw_rectangle((Rect){0, 0, (float)ctx.resolution.x, (float)ctx.resolution.y}, GRAY);
 
     for (int i = 0; i < state->bunniesCount; i++)
     { // Draw each bunny based on their position and color, also scale accordingly
         m_sprite(m_set(path, "wabbit_alpha.png"),
-                 m_set(rect, ((Rect){.x = (int)state->bunnies[i].position.x,
-                                     .y = (int)state->bunnies[i].position.y,
+                 m_set(rect, ((Rect){.x = state->bunnies[i].position.x,
+                                     .y = state->bunnies[i].position.y,
                                      .w = BUNNY_W * SPRITE_SCALE,
                                      .h = BUNNY_H * SPRITE_SCALE})),
                  m_opt(color, (state->bunnies[i].color)), m_opt(stretch, true), );

apps/demos/platformer/scenes/title.c

@@ -19,15 +19,13 @@ static void title_tick(State *state) {
         return;
     }
 
-
     m_sprite("/assets/title.png", ((Rect) {
-            ((float)ctx.base_draw_w / 2) - ((float)320 / 2), 64, 320, 128 }));
-    
+            ((float)ctx.resolution.x / 2) - ((float)320 / 2), 64, 320, 128 }));
     
     /* draw the tick count as an example of dynamic text */
-    size_t text_str_len = snprintf(NULL, 0, "%lu", state->ctx->tick_count) + 1;
+    size_t text_str_len = snprintf(NULL, 0, "%lu", state->ctx->frame_number) + 1;
     char *text_str = cmalloc(text_str_len);
-    snprintf(text_str, text_str_len, "%lu", state->ctx->tick_count);
+    snprintf(text_str, text_str_len, "%lu", state->ctx->frame_number);
 
     const char *font = "fonts/kenney-pixel.ttf";
     int text_h = 32;

apps/demos/scenery/scenes/ingame.c

@@ -17,8 +17,8 @@ static void ingame_tick(State *state) {
 
     if (input_is_mouse_captured()) {
         const float sensitivity = 0.6f; /* TODO: put this in a better place */
-        scn->yaw += (float)ctx.mouse_relative_position.x * sensitivity;
-        scn->pitch -= (float)ctx.mouse_relative_position.y * sensitivity;
+        scn->yaw += (float)ctx.mouse_movement.x * sensitivity;
+        scn->pitch -= (float)ctx.mouse_movement.y * sensitivity;
         scn->pitch = clampf(scn->pitch, -89.0f, 89.0f);
 
         const float yaw_rad = scn->yaw * (float)DEG2RAD;
@@ -62,8 +62,8 @@ static void ingame_tick(State *state) {
 
     for (int ly = 64; ly--;) {
         for (int lx = 64; lx--;) {
-            float x = SDL_truncf(scn->cam.pos.x + 32 - lx);
-            float y = SDL_truncf(scn->cam.pos.z + 32 - ly);
+            float x = SDL_truncf(scn->cam.pos.x + 32 - (float)lx);
+            float y = SDL_truncf(scn->cam.pos.z + 32 - (float)ly);
 
             float d0 = stb_perlin_noise3((float)x       * TERRAIN_FREQUENCY, (float)y       * TERRAIN_FREQUENCY, 0, 0, 0, 0) * 3 - 6;
             float d1 = stb_perlin_noise3((float)(x + 1) * TERRAIN_FREQUENCY, (float)y       * TERRAIN_FREQUENCY, 0, 0, 0, 0) * 3 - 6;
@@ -89,7 +89,7 @@ static void ingame_tick(State *state) {
     }
 
     draw_skybox("/assets/miramar/miramar_*.tga");
-    draw_fog(0.9, 1.0, 0.05, (Color){ 140, 147, 160, 255 });
+    draw_fog(0.9f, 1.0f, 0.05f, (Color){ 140, 147, 160, 255 });
 }
 
 

apps/demos/scenery/scenes/title.c

@@ -16,15 +16,13 @@ static void title_tick(State *state) {
         return;
     }
 
-
     m_sprite("/assets/title.png", ((Rect) {
-            ((float)ctx.base_draw_w / 2) - ((float)320 / 2), 64, 320, 128 }));
-    
+            ((float)ctx.resolution.x / 2) - ((float)320 / 2), 64, 320, 128 }));
 
     /* draw the tick count as an example of dynamic text */
-    size_t text_str_len = snprintf(NULL, 0, "%lu", state->ctx->tick_count) + 1;
+    size_t text_str_len = snprintf(NULL, 0, "%lu", state->ctx->frame_number) + 1;
     char *text_str = cmalloc(text_str_len);
-    snprintf(text_str, text_str_len, "%lu", state->ctx->tick_count);
+    snprintf(text_str, text_str_len, "%lu", state->ctx->frame_number);
 
     const char *font = "/fonts/kenney-pixel.ttf";
     int text_h = 32;
@@ -39,6 +37,7 @@ static void title_tick(State *state) {
         },
         (Color) { 0, 0, 0, 255 }
     );
+
     draw_text(text_str, (Vec2){ 0, 0 }, text_h, (Color) { 255, 255, 255, 255 }, font);
 
     free(text_str);

docs/getting_and_compiling.txt

@@ -1,6 +1,7 @@
 firstly, make sure to pull git-lfs references with: :git lfs fetch origin main:
+you might have to run `git lfs install` before that
 install cmake and sdl2-dev packages in manner suitable to your distribution
-add /tools/ directory to your $PATH, for example, with :source hooks:
+add /bin/ directory to your $PATH, you can do it cleanly with :source hooks: command
 navigate to one of /apps/ folders for demos
 run `twn build` to build
 runnable apps should have the same name as app folder it is in

docs/interop.txt

@@ -4,6 +4,7 @@ for that certain steps are taken:
 * number of public api calls is kept at the minimum
 * procedure signatures can only use basic types, no aggregates, with exception of Vec/Matrix types and alike,
   with no expectation on new additions (see /include/twn_types.h)
+* optionals can be expressed via pointer passage of value primitives, with NULL expressive default
 * /include/twn_game_api.json file is hand-kept with a schema to aid automatic generation and other tooling
 
 one of main inspirations for that is opengl model

include/twn_camera.h

@@ -1,7 +1,7 @@
 #ifndef TWN_CAMERA_H
 #define TWN_CAMERA_H
 
-#include "twn_util.h"
+#include "twn_types.h"
 #include "twn_engine_api.h"
 
 /* TODO: make it cached? */

include/twn_context.h

@@ -1,47 +1,46 @@
 #ifndef TWN_CONTEXT_H
 #define TWN_CONTEXT_H
 
-#include "twn_input.h"
+#include "twn_types.h"
 #include "twn_engine_api.h"
 
 #include <stdbool.h>
 #include <stdint.h>
 
 
-/* context that is valid for current frame */
-/* changes to it should not have an effect, unless specified */
-/* TODO: ensure the statement above */
+/* context that is only valid for current frame */
+/* any changes to it will be dropped, unless explicitly stated */
 typedef struct Context {
-    /* you may read from and write to these from game code */
+    /* you may read from and write to this one from game code */
+    /* it is ensured to persist between initializations */
     void *udata;
 
-    /* TODO: is it what we actually want? */
-    int64_t delta_time; /* preserves real time frame delta with no manipilation */
-    uint64_t tick_count;
+    /* which frame is it, starting from 0 at startup */
+    uint64_t frame_number;
 
-    Vec2i mouse_window_position;
-    Vec2i mouse_relative_position;
+    /* real time spent on one frame (in seconds) */
+    /* townengine is fixed step based, so you don't have */
+    /* TODO: actually set it */
+    float frame_duration;
 
-    /* set just once on startup */
+    /* resolution is set from config and dictates both logical and drawing space, as they're related */
+    /* even if scaling is done, game logic should never change over that */
+    Vec2i resolution;
+    Vec2i mouse_position;
+    Vec2i mouse_movement;
+
+    /* is set on startup, should be used as source of randomness */
     uint64_t random_seed;
 
-    /* this should be a multiple of the current ticks per second */
-    /* use it to simulate low framerate (e.g. at 60 tps, set to 2 for 30 fps) */
-    /* it can be changed at runtime; any resulting logic anomalies are bugs */
-    unsigned int update_multiplicity;
-
-    /* TODO: use Vec2i? */
-    int window_w;
-    int window_h;
-    int base_draw_w;
-    int base_draw_h;
-
+    /* whether debugging logic should be enabled in user code */
     bool debug;
-    bool is_running;
-    bool window_size_has_changed;
+
+    /* is set to true when state is invalidated and needs to be rebuilt */
+    /* watch for it and handle properly! */
     bool initialization_needed;
 } Context;
 
+/* when included after twn_engine_context there's an 'ctx' defined already */
 #ifndef TWN_ENGINE_CONTEXT_C_H
 TWN_API extern Context ctx;
 #endif

include/twn_draw.h

@@ -1,7 +1,7 @@
 #ifndef TWN_DRAW_H
 #define TWN_DRAW_H
 
-#include "twn_util.h"
+#include "twn_types.h"
 #include "twn_option.h"
 #include "twn_camera.h"
 #include "twn_engine_api.h"

include/twn_game_api.h

@@ -1,15 +1,15 @@
 /* include this header in game code to get the usable parts of the engine */
-#ifndef GAME_API_H
-#define GAME_API_H
-
+#ifndef TWN_GAME_API_H
+#define TWN_GAME_API_H
 
+#include "twn_input.h"
 #include "twn_context.h"
 #include "twn_draw.h"
 #include "twn_audio.h"
-#include "twn_util.h"
-#include "twn_input.h"
 #include "twn_engine_api.h"
+#include "twn_util.h"
 
+#ifndef TWN_NOT_C
 
    /* sole game logic and display function.
       all state must be used from and saved to supplied state pointer. */
@@ -18,5 +18,6 @@ TWN_API extern void game_tick(void);
    /* called when application is closing. */
    TWN_API extern void game_end(void);
 
+#endif
 
 #endif

include/twn_util.h

@@ -1,23 +1,15 @@
-#ifndef UTIL_H
-#define UTIL_H
+#ifndef TWN_UTIL_H
+#define TWN_UTIL_H
 
 #include "twn_types.h"
 #include "twn_engine_api.h"
-#include "twn_types.h"
 
 #include <stdint.h>
+#include <stddef.h>
 #include <stdbool.h>
 #include <math.h>
 
 
-/* DON'T FORGET ABOUT DOUBLE EVALUATION */
-/* YOU THINK YOU WON'T, AND THEN YOU DO */
-/* C23's typeof could fix it, so i will */
-/* leave them as macros to be replaced. */
-/* use the macro in tgmath.h for floats */
-#define MAX SDL_max
-#define MIN SDL_min
-
 #ifndef M_PI
 #define M_PI 3.14159265358979323846264338327950288   /**< pi */
 #endif
@@ -26,16 +18,13 @@
 #define DEG2RAD (M_PI / 180)
 #define RAD2DEG (180 / M_PI)
 
+#ifndef TWN_NOT_C
 
-/*                   */
-/* GENERAL UTILITIES */
-/*                   */
+    TWN_API void *cmalloc(size_t size);
+    TWN_API void *crealloc(void *ptr, size_t size);
+    TWN_API void *ccalloc(size_t num, size_t size);
 
-TWN_API void cry_impl(const char *file, const int line, const char *title, const char *text);
-#define CRY(title, text) cry_impl(__FILE__, __LINE__, title, text)
-#define CRY_SDL(title) cry_impl(__FILE__, __LINE__, title, SDL_GetError())
-#define CRY_PHYSFS(title)                                               \
-cry_impl(__FILE__, __LINE__, title, PHYSFS_getErrorByCode(PHYSFS_getLastErrorCode()))
+#endif /* TWN_NOT_C */
 
 
 TWN_API void log_info(const char *restrict format, ...);
@@ -43,18 +32,6 @@ TWN_API void log_critical(const char *restrict format, ...);
 TWN_API void log_warn(const char *restrict format, ...);
 
 
-/* for when there's absolutely no way to continue */
-TWN_API _Noreturn void die_abruptly(void);
-
-
-/* "critical" allocation functions which will log and abort() on failure. */
-/* if it is reasonable to handle this gracefully, use the standard versions. */
-/* the stb implementations will be configured to use these */
-TWN_API void *cmalloc(size_t size);
-TWN_API void *crealloc(void *ptr, size_t size);
-TWN_API void *ccalloc(size_t num, size_t size);
-
-
 /* TODO: this is why generics were invented. sorry, i'm tired today */
 TWN_API double clamp(double d, double min, double max);
 TWN_API float clampf(float f, float min, float max);

src/game_object/twn_linux_game_object.c

@@ -1,5 +1,6 @@
 #include "twn_game_object_c.h"
 #include "twn_engine_context_c.h"
+#include "twn_util_c.h"
 
 #include <x-watcher.h>
 #include <SDL2/SDL.h>
@@ -57,7 +58,7 @@ static void load_game_object(void) {
 
     handle = new_handle;
 
-    if (ctx.game.tick_count != 0)
+    if (ctx.game.frame_number != 0)
         log_info("Game object was reloaded\n");
 
     return;
@@ -84,7 +85,7 @@ static void watcher_callback(XWATCHER_FILE_EVENT event,
     switch(event) {
         case XWATCHER_FILE_MODIFIED:
             SDL_LockMutex(lock);
-            last_tick_modified = ctx.game.tick_count;
+            last_tick_modified = ctx.game.frame_number;
             loaded_after_modification = false;
             SDL_UnlockMutex(lock);
             break;
@@ -129,7 +130,7 @@ bool game_object_try_reloading(void) {
 
     /* only load the modified library after some time, as compilers make a lot of modifications */
     SDL_LockMutex(lock);
-    if (ctx.game.tick_count - last_tick_modified > MODIFIED_TICKS_MERGED &&
+    if (ctx.game.frame_number - last_tick_modified > MODIFIED_TICKS_MERGED &&
             !loaded_after_modification) {
         load_game_object();
         loaded_after_modification = true;

src/game_object/twn_win32_game_object.c

@@ -1,5 +1,6 @@
 #include "twn_game_object_c.h"
 #include "twn_engine_context_c.h"
+#include "twn_util_c.h"
 
 #include <errhandlingapi.h>
 #include <libloaderapi.h>
@@ -48,7 +49,7 @@ static void load_game_object(void) {
 
     handle = new_handle;
 
-    if (ctx.game.tick_count != 0)
+    if (ctx.game.frame_number != 0)
         log_info("Game object was reloaded\n");
 
     return;

src/rendering/twn_draw.c

@@ -250,23 +250,23 @@ void render(void) {
     textures_update_atlas(&ctx.texture_cache);
 
     /* fit rendering context onto the resizable screen */
-    if (ctx.game.window_size_has_changed) {
-        if ((float)ctx.game.window_w / (float)ctx.game.window_h > (float)ctx.base_render_width / (float)ctx.base_render_height) {
-            float ratio = (float)ctx.game.window_h / (float)ctx.base_render_height;
+    if (ctx.window_size_has_changed) {
+        if ((float)ctx.window_dims.x / (float)ctx.window_dims.y > (float)ctx.base_render_width / (float)ctx.base_render_height) {
+            float ratio = (float)ctx.window_dims.y / (float)ctx.base_render_height;
             int w = (int)((float)ctx.base_render_width * ratio);
             setup_viewport(
-                ctx.game.window_w / 2 - w / 2,
+                ctx.window_dims.x / 2 - w / 2,
                 0,
                 w,
-                ctx.game.window_h
+                ctx.window_dims.y
             );
         } else {
-            float ratio = (float)ctx.game.window_w / (float)ctx.base_render_width;
+            float ratio = (float)ctx.window_dims.x / (float)ctx.base_render_width;
             int h = (int)((float)ctx.base_render_height * ratio);
             setup_viewport(
                 0,
-                ctx.game.window_h / 2 - h / 2,
-                ctx.game.window_w,
+                ctx.window_dims.y / 2 - h / 2,
+                ctx.window_dims.x,
                 h
             );
         }

src/rendering/twn_gl_15_gpu_texture.c

@@ -1,5 +1,5 @@
 #include "twn_gpu_texture_c.h"
-#include "twn_util.h"
+#include "twn_util_c.h"
 
 
 GPUTexture create_gpu_texture(TextureFilter filter, bool generate_mipmaps) {

src/rendering/twn_gl_any_rendering.c

@@ -1,6 +1,6 @@
 #include "twn_draw_c.h"
 #include "twn_engine_context_c.h"
-#include "twn_util.h"
+#include "twn_util_c.h"
 
 #ifdef EMSCRIPTEN
 #include <GLES2/gl2.h>

src/rendering/twn_text.c

@@ -1,6 +1,7 @@
 #include "twn_draw_c.h"
 #include "twn_draw.h"
 #include "twn_util.h"
+#include "twn_util_c.h"
 #include "twn_engine_context_c.h"
 
 #include <stb_truetype.h>

src/twn_audio.c

@@ -1,6 +1,7 @@
 #include "twn_audio_c.h"
 #include "twn_engine_context_c.h"
 #include "twn_util.h"
+#include "twn_util_c.h"
 
 #include <SDL2/SDL.h>
 #include <stb_ds.h>

src/twn_engine_context_c.h

@@ -17,6 +17,8 @@
 
 typedef struct EngineContext {
     /* user code facing context */
+    Context game_copy;
+    /* engine-side context, copied to `game_copy` before every frame */
     Context game;
 
     InputState input;
@@ -27,6 +29,8 @@ typedef struct EngineContext {
     /* where the app was run from, used as the root for packs */
     char *base_dir;
 
+    Vec2i window_dims;
+
     /* configuration */
     toml_table_t *config_table;
     int64_t base_render_width;
@@ -52,6 +56,7 @@ typedef struct EngineContext {
     uint8_t audio_stream_channel_count;
 
     /* main loop machinery */
+    int64_t delta_time; /* preserves real time frame delta with no manipilation */
     int64_t clocks_per_second;
     int64_t prev_frame_time;
     int64_t desired_frametime;  /* how long one tick should be */
@@ -59,10 +64,17 @@ typedef struct EngineContext {
     int64_t delta_averager_residual;
     int64_t time_averager[4];
 
+    /* this should be a multiple of the current ticks per second */
+    /* use it to simulate low framerate (e.g. at 60 tps, set to 2 for 30 fps) */
+    /* it can be changed at runtime; any resulting logic anomalies are bugs */
+    uint32_t update_multiplicity;
+
     SDL_GLContext *gl_context;
     SDL_Window *window;
     uint32_t window_id;
 
+    bool is_running;
+    bool window_size_has_changed;
     bool resync_flag;
     bool was_successful;
 } EngineContext;

src/twn_input.c

@@ -194,8 +194,8 @@ void input_state_update(InputState *input) {
     SDL_GetRelativeMouseState(&input->mouse_relative_position.x,
                               &input->mouse_relative_position.y);
 
-    ctx.game.mouse_window_position = input->mouse_window_position;
-    ctx.game.mouse_relative_position = input->mouse_relative_position;
+    ctx.game.mouse_position = input->mouse_window_position;
+    ctx.game.mouse_movement = input->mouse_relative_position;
 
     for (size_t i = 0; i < shlenu(input->action_hash); ++i) {
         Action *action = &input->action_hash[i].value;

src/twn_loop.c

@@ -2,6 +2,7 @@
 #include "twn_engine_context_c.h"
 #include "twn_input_c.h"
 #include "twn_util.h"
+#include "twn_util_c.h"
 #include "twn_game_object_c.h"
 #include "twn_audio_c.h"
 #include "twn_textures_c.h"
@@ -36,8 +37,8 @@ static int event_callback(void *userdata, SDL_Event *event) {
 
         switch (event->window.event) {
         case SDL_WINDOWEVENT_SIZE_CHANGED:
-            ctx.game.window_w = event->window.data1;
-            ctx.game.window_h = event->window.data2;
+            ctx.window_dims.x = event->window.data1;
+            ctx.window_dims.y = event->window.data2;
             ctx.resync_flag = true;
             break;
 
@@ -59,12 +60,12 @@ static int event_callback(void *userdata, SDL_Event *event) {
 static void poll_events(void) {
     SDL_Event e;
 
-    ctx.game.window_size_has_changed = false;
+    ctx.window_size_has_changed = false;
 
     while (SDL_PollEvent(&e)) {
         switch (e.type) {
         case SDL_QUIT:
-            ctx.game.is_running = false;
+            ctx.is_running = false;
             break;
 
         case SDL_WINDOWEVENT:
@@ -73,7 +74,7 @@ static void poll_events(void) {
 
             switch (e.window.event) {
             case SDL_WINDOWEVENT_SIZE_CHANGED:
-                ctx.game.window_size_has_changed = true;
+                ctx.window_size_has_changed = true;
                 break;
 
             default:
@@ -111,6 +112,11 @@ static void APIENTRY opengl_log(GLenum source,
 #endif
 
 
+void preserve_persistent_ctx_fields(void) {
+    ctx.game.udata = ctx.game_copy.udata;
+}
+
+
 static void main_loop(void) {
     /*
     if (!ctx.is_running) {
@@ -124,7 +130,7 @@ static void main_loop(void) {
     int64_t current_frame_time = SDL_GetPerformanceCounter();
     int64_t delta_time = current_frame_time - ctx.prev_frame_time;
     ctx.prev_frame_time = current_frame_time;
-    ctx.game.delta_time = delta_time;
+    ctx.delta_time = delta_time;
 
     /* handle unexpected timer anomalies (overflow, extra slow frames, etc) */
     if (delta_time > ctx.desired_frametime * 8) { /* ignore extra-slow frames */
@@ -188,24 +194,23 @@ static void main_loop(void) {
         ctx.resync_flag = false;
     }
 
+    ctx.game_copy = ctx.game;
+
     /* finally, let's get to work */
     int frames = 0;
-    while (ctx.frame_accumulator >= ctx.desired_frametime * ctx.game.update_multiplicity) {
+    while (ctx.frame_accumulator >= ctx.desired_frametime * ctx.update_multiplicity) {
         frames += 1;
-        for (size_t i = 0; i < ctx.game.update_multiplicity; ++i) {
+        for (size_t i = 0; i < ctx.update_multiplicity; ++i) {
             /* TODO: disable rendering pushes on not-last ? */
             render_queue_clear();
-
             poll_events();
-
             input_state_update(&ctx.input);
-
             game_object_tick();
+            preserve_persistent_ctx_fields();
 
             ctx.frame_accumulator -= ctx.desired_frametime;
-            ctx.game.tick_count = (ctx.game.tick_count % ULLONG_MAX) + 1;
+            ctx.game.frame_number = (ctx.game.frame_number % ULLONG_MAX) + 1;
             ctx.game.initialization_needed = false;
-
         }
     }
 
@@ -439,7 +444,7 @@ static bool initialize(void) {
             goto fail;
         }
         ctx.base_render_width = datum_base_render_width.u.i;
-        ctx.game.base_draw_w = (int)ctx.base_render_width;
+        ctx.game.resolution.x = (int)ctx.base_render_width;
 
         toml_datum_t datum_base_render_height = toml_int_in(game, "base_render_height");
         if (!datum_base_render_height.ok) {
@@ -447,7 +452,7 @@ static bool initialize(void) {
             goto fail;
         }
         ctx.base_render_height = datum_base_render_height.u.i;
-        ctx.game.base_draw_h = (int)ctx.base_render_height;
+        ctx.game.resolution.y = (int)ctx.base_render_height;
 
         ctx.window = SDL_CreateWindow(datum_title.u.s,
                                       SDL_WINDOWPOS_CENTERED,
@@ -503,8 +508,8 @@ static bool initialize(void) {
 
     /* TODO: */
     // SDL_GetRendererOutputSize(ctx.renderer, &ctx.window_w, &ctx.window_h);
-    ctx.game.window_w = (int)ctx.base_render_width;
-    ctx.game.window_h = (int)ctx.base_render_height;
+    ctx.window_dims.x = (int)ctx.base_render_width;
+    ctx.window_dims.y = (int)ctx.base_render_height;
 
     /* add a watcher for immediate updates on window size */
     SDL_AddEventWatch(event_callback, NULL);
@@ -532,7 +537,7 @@ static bool initialize(void) {
     }
 
     /* you could change this at runtime if you wanted */
-    ctx.game.update_multiplicity = 1;
+    ctx.update_multiplicity = 1;
 
 #ifndef EMSCRIPTEN
     /* hook up opengl debugging callback */
@@ -561,13 +566,13 @@ static bool initialize(void) {
         }
     }
 
-    ctx.game.is_running = true;
+    ctx.is_running = true;
     ctx.resync_flag = true;
     ctx.clocks_per_second = SDL_GetPerformanceFrequency();
     ctx.prev_frame_time = SDL_GetPerformanceCounter();
     ctx.desired_frametime = ctx.clocks_per_second / ctx.ticks_per_second;
     ctx.frame_accumulator = 0;
-    ctx.game.tick_count = 0;
+    ctx.game.frame_number = 0;
 
     /* delta time averaging */
     ctx.delta_averager_residual = 0;
@@ -772,7 +777,7 @@ int enter_loop(int argc, char **argv) {
     ctx.was_successful = true;
     ctx.game.initialization_needed = true;
 
-    while (ctx.game.is_running) {
+    while (ctx.is_running) {
         if (game_object_try_reloading()) {
             ctx.game.initialization_needed = true;
             reset_state();

src/twn_util.c

@@ -273,11 +273,11 @@ void tick_timer(int *value) {
 }
 
 void tick_ftimer(float *value) {
-    *value = MAX(*value - ((float)ctx.game.delta_time / (float)ctx.clocks_per_second), 0.0f);
+    *value = MAX(*value - ((float)ctx.delta_time / (float)ctx.clocks_per_second), 0.0f);
 }
 
 bool repeat_ftimer(float *value, float at) {
-    *value -= (float)ctx.game.delta_time / (float)ctx.clocks_per_second;
+    *value -= (float)ctx.delta_time / (float)ctx.clocks_per_second;
     if (*value < 0.0f) {
         *value += at;
         return true;

src/twn_util_c.h

@@ -3,6 +3,23 @@
 
 #include "twn_types.h"
 
+#include <SDL2/SDL.h>
+
+#include <stdbool.h>
+
+
+#define MAX SDL_max
+#define MIN SDL_min
+
+void cry_impl(const char *file, const int line, const char *title, const char *text);
+#define CRY(title, text) cry_impl(__FILE__, __LINE__, title, text)
+#define CRY_SDL(title) cry_impl(__FILE__, __LINE__, title, SDL_GetError())
+#define CRY_PHYSFS(title)                                               \
+cry_impl(__FILE__, __LINE__, title, PHYSFS_getErrorByCode(PHYSFS_getLastErrorCode()))
+
+/* for when there's absolutely no way to continue */
+_Noreturn void die_abruptly(void);
+
 /* note: you must free the returned string */
 char *expand_asterisk(const char *mask, const char *to);
 
@@ -22,7 +39,7 @@ static inline float fast_sqrt(float x)
 
 
 static inline Vec2 fast_cossine(float a) {
-    const float s = sinf(a);
+    const float s = SDL_sinf(a);
     return (Vec2){
         .x = fast_sqrt(1.0f - s * s) * (a >= (float)M_PI_2 && a < (float)(M_PI + M_PI_2) ? -1 : 1),
         .y = s