From b7440c1e4c182ad977996d91bfb8125091ffae92 Mon Sep 17 00:00:00 2001 From: Cliff Click Date: Thu, 12 Nov 2026 23:28:58 -0800 Subject: ch31 early push needs review --- chapter31/src/main/c/simple_graphics.c | 58 +++++++++++++++++++++++++++----- chapter31/src/main/c/simple_graphics.h | 3 +- chapter31/src/main/c/simple_minifb.c | 36 +++++++++++--------- chapter31/src/main/c/simple_time.c | 61 ++++++++++++++++++++++++++++++++++ 4 files changed, 133 insertions(+), 25 deletions(-) create mode 100644 chapter31/src/main/c/simple_time.c (limited to 'chapter31/src/main/c') diff --git a/chapter31/src/main/c/simple_graphics.c b/chapter31/src/main/c/simple_graphics.c index 41073470..40d66ba9 100644 --- a/chapter31/src/main/c/simple_graphics.c +++ b/chapter31/src/main/c/simple_graphics.c @@ -1,8 +1,48 @@ +#define _POSIX_C_SOURCE 200809L #include "simple_graphics.h" #include #include #include #include +#include + +#ifdef __CYGWIN__ +#define BACKEND_NAME "simple_minifb.dll" +#define BACKEND_ABI "x86_64_v2_win64" +#else +#define BACKEND_NAME "libsimple_minifb.so" +#define BACKEND_ABI "x86_64_v2_SystemV" +#endif + +// Executable-relative paths work even when launched outside the checkout. +// Working-directory paths also cover test executables and chapter/root shells. +static void *find_backend(void) { + char executable[4096], path[8192]; + ssize_t n=readlink("/proc/self/exe",executable,sizeof(executable)-1); + if (n>0 && n<(ssize_t)sizeof(executable)-1) { + executable[n]=0; + char *slash=strrchr(executable,'/'); + if (slash) { + *slash=0; + const char *relative[]={"/" BACKEND_NAME, + "/../../release/" BACKEND_ABI "/" BACKEND_NAME, + "/../release/" BACKEND_ABI "/" BACKEND_NAME}; + for (unsigned i=0;iversion != SIMPLE_GRAPHICS_VERSION || !candidate->open || !candidate->present || !candidate->poll || !candidate->mouse_x || !candidate->mouse_y || !candidate->button || - !candidate->key || !candidate->close) { + !candidate->key || !candidate->close || !candidate->wait) { fprintf(stderr, "Simple graphics: incompatible MiniFB backend '%s'. Rebuild with make graphics.\n", path); dlclose(library); library = NULL; @@ -58,3 +99,4 @@ int32_t simple_gfx_mouse_y(void) { return api ? api->mouse_y() : 0; } int32_t simple_gfx_button(int32_t button) { return api ? api->button(button) : 0; } int32_t simple_gfx_key(int32_t key) { return api ? api->key(key) : 0; } int32_t simple_gfx_close(void) { if (api) api->close(); return 0; } +int32_t simple_gfx_wait(int64_t timeout) { return api ? api->wait(timeout) : -1; } diff --git a/chapter31/src/main/c/simple_graphics.h b/chapter31/src/main/c/simple_graphics.h index 35a0aa08..370256be 100644 --- a/chapter31/src/main/c/simple_graphics.h +++ b/chapter31/src/main/c/simple_graphics.h @@ -14,6 +14,7 @@ struct simple_graphics_api { int32_t (*button)(int32_t); int32_t (*key)(int32_t); void (*close)(void); + int32_t (*wait)(int64_t); }; -#define SIMPLE_GRAPHICS_VERSION 1 +#define SIMPLE_GRAPHICS_VERSION 2 #endif diff --git a/chapter31/src/main/c/simple_minifb.c b/chapter31/src/main/c/simple_minifb.c index 34663e2e..2117f0d2 100644 --- a/chapter31/src/main/c/simple_minifb.c +++ b/chapter31/src/main/c/simple_minifb.c @@ -3,11 +3,15 @@ #include #include #include +#include #ifdef _WIN32 #include #else #include #include +#include +#include "WindowData.h" +#include "x11/WindowData_X11.h" #endif // One fixed-size window for now. No Simple pointer survives a native call: @@ -73,27 +77,27 @@ static int32_t present(const uint32_t *pixels, uint32_t count) { return status(mfb_update_ex(window, frame, width, height)); } -static int32_t poll_events(int32_t wait) { +static int32_t wait_events(int64_t timeout) { if (!window) return 1; - if (wait) { - // mfb_wait_sync returns false for both destruction and errors that - // leave the window alive. Use a short OS wait, then the status-bearing - // event API, so we know whether the window still needs destruction. + if (timeout < -1) return -1; + // May return early; the game recomputes its deadlines after every wakeup. + int ms=timeout>INT_MAX ? INT_MAX : (int)timeout; #ifdef _WIN32 - Sleep(17); + if (MsgWaitForMultipleObjectsEx(0,NULL,ms<0 ? INFINITE : (DWORD)ms, + QS_ALLINPUT,MWMO_INPUTAVAILABLE)==WAIT_FAILED) return -1; #else - struct timespec delay = {0, 16666667}; - while (nanosleep(&delay, &delay) < 0) { - if (errno != EINTR) { - perror("Simple graphics: event wait"); - close_window(); - return -1; - } - } -#endif + // The pinned MiniFB X11 backend owns this connection. Check already queued + // Xlib events before waiting on its socket; no new event thread is needed. + SWindowData *data=(SWindowData *)window; + SWindowData_X11 *native=(SWindowData_X11 *)data->specific; + if (!XPending(native->display)) { + struct pollfd fd={ConnectionNumber(native->display),POLLIN,0}; + if (poll(&fd,1,ms)<0 && errno!=EINTR) return -1; } +#endif return status(mfb_update_events(window)); } +static int32_t poll_events(int32_t wait) { return wait_events(wait ? 17 : 0); } static int32_t mouse_x(void) { return window ? mfb_get_mouse_x(window) : 0; } static int32_t mouse_y(void) { return window ? mfb_get_mouse_y(window) : 0; } static int32_t button(int32_t b) { @@ -105,7 +109,7 @@ static int32_t key(int32_t k) { static const struct simple_graphics_api api = { SIMPLE_GRAPHICS_VERSION, open_window, present, poll_events, - mouse_x, mouse_y, button, key, close_window + mouse_x, mouse_y, button, key, close_window, wait_events }; #ifdef _WIN32 __declspec(dllexport) diff --git a/chapter31/src/main/c/simple_time.c b/chapter31/src/main/c/simple_time.c new file mode 100644 index 00000000..2e579922 --- /dev/null +++ b/chapter31/src/main/c/simple_time.c @@ -0,0 +1,61 @@ +#define _POSIX_C_SOURCE 200809L +#include +#include +#include + +// Fixed-width bridge; no native struct layout or retained Simple pointers. +static int64_t clock_value(clockid_t clock, int64_t scale) { + struct timespec t; + if (clock_gettime(clock,&t)) return -1; + if (t.tv_sec>INT64_MAX/scale || t.tv_secINT64_MAX-fraction) { errno=EOVERFLOW; return -1; } + return base+fraction; +} +int64_t simple_time_now(void) { return clock_value(CLOCK_REALTIME,1000); } +int64_t simple_time_mono(void) { return clock_value(CLOCK_MONOTONIC,1000); } +int64_t simple_time_nano(void) { return clock_value(CLOCK_MONOTONIC,1000000000); } +int32_t simple_time_sleep(int64_t ms, int32_t absolute) { + if (ms<0) { errno=EINVAL; return -1; } + struct timespec t={ms/1000,(ms%1000)*1000000}; + int result; + if (!absolute) { + // Retry the remaining duration after signals; no busy waiting. + do { result=nanosleep(&t,&t); } while (result && errno==EINTR); + return result; + } + do { result=clock_nanosleep(CLOCK_MONOTONIC,TIMER_ABSTIME,&t,NULL); } while (result==EINTR); + if (result) { errno=result; return -1; } + return 0; +} +static int leap(int y) { return y%4==0 && (y%100!=0 || y%400==0); } +static int local_fields(int64_t ms, struct tm *local, struct tm *utc) { + tzset(); + int64_t sec=ms/1000; + if (ms%1000<0) --sec; + time_t t=(time_t)sec; + if ((int64_t)t!=sec || !localtime_r(&t,local) || !gmtime_r(&t,utc)) return -1; + if (local->tm_year < -1899 || local->tm_year > 8099) { errno=EOVERFLOW; return -1; } + return 0; +} +int32_t simple_time_local(int64_t ms, int64_t *out) { + struct tm t,u; + if (local_fields(ms,&t,&u)) return -1; + int days=t.tm_yday-u.tm_yday; + if (t.tm_year>u.tm_year) days+=365+leap(u.tm_year+1900); + if (t.tm_year0; + return 0; +} +int32_t simple_time_zone(int64_t ms, char *out, uint32_t capacity) { + struct tm t,u; + if (!capacity || local_fields(ms,&t,&u)) return -1; + return (int32_t)strftime(out,capacity,"%Z",&t); +} -- cgit v1.2.3