wanp/townengine
2
1
Fork 0
Code Issues 6 Pull Requests Packages Projects Releases Wiki Activity

ilimination of system code, removal of x-watcher and replacement of it by dmon, fixes in audio code, dynamic asset reload

Browse Source
This commit is contained in:
veclavtalica 2025-01-30 04:30:20 +03:00
parent 4b2a22bf3c
commit 74d7190c62
21 changed files with 2164 additions and 1427 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
CMakeLists.txt
View File

@ -64,18 +64,6 @@ set(PHYSFS_ARCHIVE_7Z OFF CACHE INTERNAL "")
add_subdirectory(third-party/physfs ${CMAKE_CURRENT_BINARY_DIR}/third-party/physfs SYSTEM)
add_subdirectory(third-party/libxm ${CMAKE_CURRENT_BINARY_DIR}/third-party/libxm SYSTEM)
if(LINUX)
set(SYSTEM_SOURCE_FILES
src/system/linux/twn_timer.c
$<$<BOOL:${TWN_FEATURE_DYNLIB_GAME}>:src/game_object/twn_linux_game_object.c>)
elseif(WIN32)
set(SYSTEM_SOURCE_FILES
$<$<BOOL:${TWN_FEATURE_DYNLIB_GAME}>:src/game_object/twn_win32_game_object.c>)
else()
set(SYSTEM_SOURCE_FILES)
endif()
if(EMSCRIPTEN)
set(TWN_RENDERING_API WEBGL1)
else()
@ -96,15 +84,19 @@ set(TWN_THIRD_PARTY_SOURCE_FILES
set(TWN_NONOPT_SOURCE_FILES
src/twn_stb.c
src/twn_loop.c
src/twn_main.c
src/twn_context.c include/twn_context.h
src/twn_audio.c include/twn_audio.h
src/twn_util.c include/twn_util.h
src/twn_input.c include/twn_input.h
src/twn_camera.c src/twn_camera_c.h
src/twn_textures.c src/twn_textures_c.h
src/twn_filewatch.c src/twn_filewatch_c.h
src/twn_context.c include/twn_context.h
src/twn_audio.c include/twn_audio.h
src/twn_util.c include/twn_util.h
src/twn_input.c include/twn_input.h
src/twn_loop.c src/twn_loop_c.h
src/twn_camera.c src/twn_camera_c.h
src/twn_textures.c src/twn_textures_c.h
src/twn_filewatch.c src/twn_filewatch_c.h
src/twn_filewatch.c src/twn_filewatch_c.h
src/twn_timer.c src/twn_timer_c.h
src/rendering/twn_draw.c src/rendering/twn_draw_c.h
src/rendering/twn_quads.c
@ -114,12 +106,14 @@ set(TWN_NONOPT_SOURCE_FILES
src/rendering/twn_triangles.c
src/rendering/twn_billboards.c
src/rendering/twn_circles.c
src/rendering/twn_skybox.c)
src/rendering/twn_skybox.c
)
set(TWN_SOURCE_FILES
$<IF:$<BOOL:${TWN_USE_AMALGAM}>,src/twn_amalgam.c src/twn_stb.c,${TWN_NONOPT_SOURCE_FILES}>
# for dynamic load based solution main is compiled in a separate target
$<$<BOOL:${TWN_FEATURE_DYNLIB_GAME}>:src/game_object/twn_dynamic_game_object.c>
$<$<NOT:$<BOOL:${TWN_FEATURE_DYNLIB_GAME}>>:src/twn_main.c
src/game_object/twn_static_game_object.c>
@ -258,7 +252,7 @@ function(include_deps target)
third-party/physfs/extras
third-party/libxm/include
third-party/stb
third-party/x-watcher
third-party/dmon
third-party/tomlc99
$<$<NOT:$<BOOL:${EMSCRIPTEN}>>:third-party/glad/include>)

98
src/game_object/twn_dynamic_game_object.c Normal file
View File

@ -0,0 +1,98 @@
#include "twn_game_object_c.h"
#include "twn_engine_context_c.h"
#include "twn_filewatch_c.h"
#include "twn_util_c.h"
#include "twn_util.h"
#include "twn_loop_c.h"
#include <SDL2/SDL.h>
#ifdef _WIN32
#define GAME_OBJECT_NAME "libgame.dll"
#else
#define GAME_OBJECT_NAME "libgame.so"
#endif
static void (*game_tick_callback)(void);
static void (*game_end_callback)(void);
static void *handle = NULL;
static void game_object_file_action(char const *path, enum FilewatchAction action) {
(void)action;
if (action == FILEWATCH_ACTION_FILE_DELETED)
return;
if (handle) {
SDL_UnloadObject(handle);
game_tick_callback = NULL;
game_end_callback = NULL;
handle = NULL;
}
handle = SDL_LoadObject(path);
if (!handle) {
CRY_SDL("Hot Reload Error: Cannot open game code shared object");
return;
}
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wpedantic"
game_tick_callback = (void (*)(void))SDL_LoadFunction(handle, "game_tick");
if (!game_tick_callback) {
CRY("Hot Reload Error", "game_tick_callback() symbol wasn't found");
goto ERR_GETTING_PROC;
}
game_end_callback = (void (*)(void))SDL_LoadFunction(handle, "game_end");
if (!game_end_callback) {
CRY("Hot Reload Error", "game_end_callback() symbol wasn't found");
goto ERR_GETTING_PROC;
}
#pragma GCC diagnostic pop
if (fabsf(0.0f - ctx.game.frame_number) > 0.00001f) {
log_info("Game object was reloaded\n");
reset_state();
}
return;
ERR_GETTING_PROC:
SDL_UnloadObject(handle);
handle = NULL;
game_tick_callback = NULL;
game_end_callback = NULL;
}
void game_object_load(void) {
static bool filewatch_attached;
if (!filewatch_attached) {
char *game_object_path;
SDL_asprintf(&game_object_path, "%s%s", ctx.base_dir, GAME_OBJECT_NAME);
filewatch_add_file(game_object_path, game_object_file_action);
game_object_file_action(game_object_path, FILEWATCH_ACTION_FILE_MODIFIED);
SDL_free(game_object_path);
filewatch_attached = true;
}
}
void game_object_unload(void) {
game_end_callback();
/* needs to be closed otherwise symbols aren't resolved again */
SDL_UnloadObject(handle);
game_tick_callback = NULL;
game_end_callback = NULL;
handle = NULL;
}
void game_object_tick(void) {
game_tick_callback();
}

161
src/game_object/twn_linux_game_object.c
View File

@ -1,161 +0,0 @@
#include "twn_game_object_c.h"
#include "twn_engine_context_c.h"
#include "twn_util_c.h"
#include "twn_util.h"
#include <x-watcher.h>
#include <SDL2/SDL.h>
#include <dlfcn.h>
#define GAME_OBJECT_NAME "libgame.so"
#define MODIFIED_TICKS_MERGED 10
static void (*game_tick_callback)(void);
static void (*game_end_callback)(void);
static x_watcher *watcher;
static void *handle = NULL;
static float last_tick_modified;
static bool loaded_after_modification = true;
static SDL_mutex *lock;
static char *game_object_path;
static void load_game_object(void) {
/* needs to be closed otherwise symbols aren't resolved again */
if (handle) {
dlclose(handle);
handle = NULL;
game_tick_callback = NULL;
game_end_callback = NULL;
}
void *new_handle = dlopen(game_object_path, RTLD_LAZY);
if (!new_handle) {
log_critical("Hot Reload Error: Cannot open game code shared object (%s)", dlerror());
goto ERR_OPENING_SO;
}
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wpedantic"
game_tick_callback = (void (*)(void))dlsym(new_handle, "game_tick");
if (!game_tick_callback) {
CRY("Hot Reload Error", "game_tick_callback() symbol wasn't found");
goto ERR_GETTING_PROC;
}
game_end_callback = (void (*)(void))dlsym(new_handle, "game_end");
if (!game_end_callback) {
CRY("Hot Reload Error", "game_end_callback() symbol wasn't found");
goto ERR_GETTING_PROC;
}
#pragma GCC diagnostic pop
handle = new_handle;
if (fabsf(0.0f - ctx.game.frame_number) > 0.00001f)
log_info("Game object was reloaded\n");
return;
ERR_GETTING_PROC:
dlclose(new_handle);
game_tick_callback = NULL;
game_end_callback = NULL;
ERR_OPENING_SO:
SDL_UnlockMutex(lock);
}
static void watcher_callback(XWATCHER_FILE_EVENT event,
const char *path,
int context,
void *data)
{
(void)context;
(void)path;
(void)data;
switch(event) {
case XWATCHER_FILE_CREATED:
case XWATCHER_FILE_MODIFIED:
SDL_LockMutex(lock);
last_tick_modified = ctx.game.frame_number;
loaded_after_modification = false;
SDL_UnlockMutex(lock);
break;
case XWATCHER_FILE_UNSPECIFIED:
case XWATCHER_FILE_REMOVED:
case XWATCHER_FILE_OPENED:
case XWATCHER_FILE_ATTRIBUTES_CHANGED:
case XWATCHER_FILE_NONE:
case XWATCHER_FILE_RENAMED:
default:
break;
}
}
void game_object_load(void) {
SDL_asprintf(&game_object_path, "%s%s", ctx.base_dir, GAME_OBJECT_NAME);
watcher = xWatcher_create();
xWatcher_reference dir;
dir.path = game_object_path;
dir.callback_func = watcher_callback;
xWatcher_appendFile(watcher, &dir);
xWatcher_start(watcher);
lock = SDL_CreateMutex();
load_game_object();
}
void game_object_unload(void) {
game_end_callback();
xWatcher_destroy(watcher);
watcher = NULL;
dlclose(handle);
handle = NULL;
game_tick_callback = NULL;
game_end_callback = NULL;
SDL_DestroyMutex(lock);
}
bool game_object_try_reloading(void) {
bool result = false;
/* only load the modified library after some time, as compilers make a lot of modifications */
SDL_LockMutex(lock);
if (ctx.game.frame_number - last_tick_modified > MODIFIED_TICKS_MERGED &&
!loaded_after_modification) {
load_game_object();
loaded_after_modification = true;
result = true;
} SDL_UnlockMutex(lock);
return result;
}
void game_object_tick(void) {
game_tick_callback();
}
void *game_object_get_game_tick_address(void) {
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wpedantic"
return (void *)&game_tick_callback;
#pragma GCC diagnostic pop
}

14
src/game_object/twn_static_game_object.c
View File

@ -5,24 +5,10 @@
void game_object_load(void) {
}
void game_object_unload(void) {
game_end();
}
bool game_object_try_reloading(void) {
return false;
}
void game_object_tick(void) {
game_tick();
}
void *game_object_get_game_tick_address(void) {
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wpedantic"
return (void *)&game_tick;
#pragma GCC diagnostic pop
}

90
src/game_object/twn_win32_game_object.c
View File

@ -1,90 +0,0 @@
#include "twn_game_object_c.h"
#include "twn_engine_context_c.h"
#include "twn_util_c.h"
#include "twn_util.h"
#include <errhandlingapi.h>
#include <libloaderapi.h>
#define GAME_OBJECT_PATH "libgame.dll"
static void (*game_tick_callback)(void);
static void (*game_end_callback)(void);
static void *handle = NULL;
static void load_game_object(void) {
/* needs to be closed otherwise symbols aren't resolved again */
if (handle) {
FreeLibrary(handle);
handle = NULL;
game_tick_callback = NULL;
game_end_callback = NULL;
}
void *new_handle = LoadLibraryA(GAME_OBJECT_PATH);
if (!new_handle) {
log_critical("Hot Reload Error: Cannot open game code shared object (%s)", GetLastError());
goto ERR_OPENING_SO;
}
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wpedantic"
game_tick_callback = (void (*)(void))GetProcAddress(new_handle, "game_tick");
if (!game_tick_callback) {
CRY("Hot Reload Error", "game_tick_callback() symbol wasn't found");
goto ERR_GETTING_PROC;
}
game_end_callback = (void (*)(void))GetProcAddress(new_handle, "game_end");
if (!game_end_callback) {
CRY("Hot Reload Error", "game_end_callback() symbol wasn't found");
goto ERR_GETTING_PROC;
}
#pragma GCC diagnostic pop
handle = new_handle;
if (ctx.game.frame_number != 0)
log_info("Game object was reloaded\n");
return;
ERR_GETTING_PROC:
FreeLibrary(new_handle);
game_tick_callback = NULL;
game_end_callback = NULL;
ERR_OPENING_SO:
die_abruptly();
}
void game_object_load(void) {
load_game_object();
}
void game_object_unload(void) {
game_end_callback();
FreeLibrary(handle);
handle = NULL;
game_tick_callback = NULL;
game_end_callback = NULL;
}
/* doesn't support reloading because of problems with file watching */
bool game_object_try_reloading(void) {
return false;
}
void game_object_tick(void) {
game_tick_callback();
}

76
src/system/linux/twn_timer.c
View File

@ -1,76 +0,0 @@
#include "../twn_timer.h"
#include "twn_engine_context_c.h"
#include <SDL_messagebox.h>
#include <signal.h>
#include <stdint.h>
#include <time.h>
#include <unistd.h>
#include <stdbool.h>
static timer_t timerid;
static struct sigaction sa;
static struct sigevent sev;
static bool created;
static uint64_t used_milliseconds_to_expire;
#define SANITY_TIMER_MESSAGE_FMT "Game tick exeeded its allocated time (%lu milliseconds), application is closing"
/* stop application */
static void sanity_timer_handler(int sig, siginfo_t *si, void *uc) {
(void)uc; (void)sig; (void)si;
size_t text_str_len = snprintf(NULL, 0, SANITY_TIMER_MESSAGE_FMT, used_milliseconds_to_expire) + 1;
char *text_str = SDL_malloc(text_str_len);
snprintf(text_str, text_str_len, SANITY_TIMER_MESSAGE_FMT, used_milliseconds_to_expire);
SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, "sanity timer", text_str, ctx.window);
SDL_free(text_str);
raise(SIGKILL);
}
bool start_sanity_timer(uint64_t milliseconds_to_expire) {
if (!created) {
sa.sa_flags = SA_SIGINFO;
sa.sa_sigaction = sanity_timer_handler;
sigemptyset(&sa.sa_mask);
if (sigaction(SIGRTMIN, &sa, NULL) == -1)
goto ERR_SIGACTION;
sev.sigev_notify = SIGEV_SIGNAL;
sev.sigev_signo = SIGRTMIN;
sev.sigev_value.sival_ptr = &timerid;
if (timer_create(CLOCK_MONOTONIC, &sev, &timerid) == -1)
goto ERR_TIMERCREATE;
created = true;
ERR_TIMERCREATE:
// ERR_SIGPROCMASK:
ERR_SIGACTION:
return false;
}
struct itimerspec its = {0};
its.it_value.tv_sec = milliseconds_to_expire / 1000;
its.it_value.tv_nsec = (milliseconds_to_expire * 1000000 % 1000000000);
if (timer_settime(timerid, 0, &its, NULL) == -1)
return false;
used_milliseconds_to_expire = milliseconds_to_expire;
return true;
}
bool end_sanity_timer(void) {
struct itimerspec its = {0};
its.it_value.tv_sec = 0;
its.it_value.tv_nsec = 0;
if (timer_settime(timerid, 0, &its, NULL) == -1)
return false;
return false;
}

1
src/twn_amalgam.c
View File

@ -10,6 +10,7 @@
#include "twn_textures.c"
#include "twn_util.c"
#include "twn_filewatch.c"
#include "twn_timer.c"
#include "rendering/twn_circles.c"
#include "rendering/twn_draw.c"

46
src/twn_audio.c
View File

@ -29,6 +29,7 @@ static const uint8_t audio_exts_len[AUDIO_FILE_TYPE_COUNT] = {
};
/* TODO: allow for vectorization and packed vectors (alignment care and alike) */
/* TODO: free channel name duplicates */
/* TODO: count frames without use, free the memory when threshold is met */
/* TODO: count repeated usages for sound effect cases with rendering to ram? */
@ -212,6 +213,7 @@ static void free_audio_channel(AudioChannel channel) {
SDL_assert_always(false);
break;
}
SDL_free(channel.path);
}
@ -283,32 +285,42 @@ void audio_play(const char *path,
/* create a channel if it doesn't exist */
if (!pair) {
AudioFileType const file_type = infer_audio_file_type(path);
AudioChannel new_channel = {
AudioChannel const new_channel = {
.file_type = file_type,
.context = init_audio_context(path, file_type),
.path = path,
.name = channel,
.path = SDL_strdup(path),
.repeat = repeat,
.volume = volume,
.panning = panning,
};
shput(ctx.audio_channels, channel, new_channel);
shput(ctx.audio_channels, SDL_strdup(channel), new_channel);
pair = shgetp_null(ctx.audio_channels, channel);
}
/* TODO: destroy and create new context when channel is reused for different file */
/* works for both restarts and new audio */
if (strcmp(pair->value.path, path) == 0)
/* repeat if so */
else if (strcmp(pair->value.path, path) == 0)
repeat_audio(&pair->value);
else {
/* start anew, reuse channel name */
free_audio_channel(pair->value);
AudioFileType const file_type = infer_audio_file_type(path);
AudioChannel const new_channel = {
.file_type = file_type,
.context = init_audio_context(path, file_type),
.path = SDL_strdup(path),
.repeat = repeat,
.volume = volume,
.panning = panning,
};
pair->value = new_channel;
}
} else {
/* audio without channel plays without repeat and ability to change parameters over its course, nor stop it */
AudioFileType const file_type = infer_audio_file_type(path);
AudioChannel new_channel = {
.file_type = file_type,
.context = init_audio_context(path, file_type),
.path = path,
.name = NULL,
.path = SDL_strdup(path),
.repeat = false,
.volume = volume,
.panning = panning,
@ -506,12 +518,12 @@ static void audio_sample_and_mixin_channel(AudioChannel *channel,
}
static void sanity_check_channel(const AudioChannel *channel) {
if (channel->volume < 0.0f || channel->volume > 1.0f)
log_warn("Volume argument is out of range for channel (%s)", channel->name);
static void sanity_check_channel(const AudioChannelItem channel) {
if (channel.value.volume < 0.0f || channel.value.volume > 1.0f)
log_warn("Volume argument is out of range for channel (%s)", channel.key ? channel.key : "unnamed");
if (channel->panning < -1.0f || channel->panning > 1.0f)
log_warn("Panning argument is out of range for channel (%s)", channel->name);
if (channel.value.panning < -1.0f || channel.value.panning > 1.0f)
log_warn("Panning argument is out of range for channel (%s)", channel.key ? channel.key : "unnamed");
}
@ -523,7 +535,7 @@ void audio_callback(void *userdata, uint8_t *stream, int len) {
size_t const audio_channels_len = shlen(ctx.audio_channels);
for (size_t i = 0; i < audio_channels_len; ++i) {
sanity_check_channel(&ctx.audio_channels[i].value);
sanity_check_channel(ctx.audio_channels[i]);
audio_sample_and_mixin_channel(&ctx.audio_channels[i].value,
stream, len,
i == audio_channels_len - 1);
@ -531,7 +543,7 @@ void audio_callback(void *userdata, uint8_t *stream, int len) {
size_t const unnamed_audio_channels_len = shlen(ctx.unnamed_audio_channels);
for (size_t i = 0; i < unnamed_audio_channels_len; ++i) {
sanity_check_channel(&ctx.unnamed_audio_channels[i]);
sanity_check_channel((AudioChannelItem){NULL, ctx.unnamed_audio_channels[i]});
audio_sample_and_mixin_channel(&ctx.unnamed_audio_channels[i],
stream, len,
i == unnamed_audio_channels_len - 1);

3
src/twn_audio_c.h
View File

@ -48,8 +48,7 @@ union AudioContext {
typedef struct AudioChannel {
AudioFileType file_type;
union AudioContext context; /* interpreted by `file_type` value */
const char *path;
const char *name;
char *path;
bool repeat;
float volume;
float panning;

160
src/twn_filewatch.c
View File

@ -2,169 +2,111 @@
#include "twn_util.h"
#include "twn_engine_context_c.h"
#include <x-watcher.h>
#define DMON_IMPL
#include <dmon.h>
#include <stb_ds.h>
#include <SDL2/SDL.h>
struct FilewatchPathToCallback {
struct FilewatchEntry {
char *path;
FileatchCallback callback;
float tick_last_reported;
enum FilewatchAction action_pending : 3;
bool action_processed : 1;
enum FilewatchAction *actions_pending;
};
static struct FilewatchPathToCallback *filewatch_directories;
static struct FilewatchPathToCallback *filewatch_files;
static struct FilewatchEntry *filewatch_directories;
static struct FilewatchEntry *filewatch_files;
/* note: it gets rebuilt on every addition, as api is such */
/* TODO: test whether it's possible to miss on update while watcher is being rebuilt */
/* we might have to enumerate things, just to make sure */
static x_watcher *filewatcher;
static SDL_mutex *filewatcher_lock;
static bool filewatcher_initialized;
/* TODO: check whether path and p->path match? */
static void filewatch_dispatch(XWATCHER_FILE_EVENT event,
const char *path,
int context,
void *additional_data
) {
(void)additional_data; (void)path;
static void filewatch_callback(dmon_watch_id watch_id,
dmon_action action,
const char* rootdir,
const char* filepath,
const char* oldfilepath,
void* user)
{
enum FilewatchAction faction;
enum FilewatchAction action;
switch (event) {
case XWATCHER_FILE_CREATED:
action = FILEWATCH_ACTION_FILE_CREATED;
switch (action) {
case DMON_ACTION_CREATE:
faction = FILEWATCH_ACTION_FILE_CREATED;
break;
case XWATCHER_FILE_REMOVED:
action = FILEWATCH_ACTION_FILE_DELETED;
case DMON_ACTION_DELETE:
faction = FILEWATCH_ACTION_FILE_DELETED;
break;
case XWATCHER_FILE_MODIFIED:
action = FILEWATCH_ACTION_FILE_MODIFIED;
case DMON_ACTION_MODIFY:
faction = FILEWATCH_ACTION_FILE_MODIFIED;
break;
case XWATCHER_FILE_NONE:
case XWATCHER_FILE_OPENED:
case XWATCHER_FILE_RENAMED:
case XWATCHER_FILE_UNSPECIFIED:
case XWATCHER_FILE_ATTRIBUTES_CHANGED:
default:
return;
}
SDL_LockMutex(filewatcher_lock);
struct FilewatchPathToCallback *p;
intptr_t const context = (intptr_t)user;
struct FilewatchEntry *p;
if (context < 0)
p = &filewatch_files[-context - 1];
else
p = &filewatch_directories[context];
p->tick_last_reported = ctx.game.frame_number;
p->action_processed = false;
p->action_pending = action;
arrpush(p->actions_pending, faction);
SDL_UnlockMutex(filewatcher_lock);
}
static bool filewatcher_rebuild(void) {
if (filewatcher)
xWatcher_destroy(filewatcher);
filewatcher = xWatcher_create();
if (!filewatcher) {
log_warn("Error creating xWatcher instance, no file watching is done");
return false;
}
int const filewatch_directories_len = arrlen(filewatch_directories);
for (int i = 0; i < filewatch_directories_len; ++i) {
xWatcher_reference ref = {
.path = filewatch_directories[i].path,
.callback_func = filewatch_dispatch,
.context = i,
};
if (!xWatcher_appendDir(filewatcher, &ref))
log_warn("Error watching dir contents: %s", filewatch_directories[i].path);
}
int const filewatch_files_len = arrlen(filewatch_files);
for (int i = 0; i < filewatch_files_len; ++i) {
xWatcher_reference ref = {
.path = filewatch_files[i].path,
.callback_func = filewatch_dispatch,
.context = -(i + 1), /* in negative range to allow inrefence */
};
if (!xWatcher_appendDir(filewatcher, &ref))
log_warn("Error watching file: %s", filewatch_files[i].path);
}
if (!xWatcher_start(filewatcher)) {
log_warn("Error creating xWatcher instance, no file watching is done");
xWatcher_destroy(filewatcher);
filewatcher = NULL;
return false;
}
return true;
}
bool filewatch_add_directory(char *dir, FileatchCallback callback) {
bool filewatch_add_directory(char const *dir, FileatchCallback callback) {
SDL_assert(dir && callback);
struct FilewatchPathToCallback const w = {
if (!filewatcher_initialized) {
dmon_init();
filewatcher_initialized = true;
}
struct FilewatchEntry const w = {
.callback = callback,
.path = SDL_strdup(dir),
.action_processed = true,
.tick_last_reported = ctx.game.frame_number,
.path = SDL_strdup(dir), /* TODO: free */
};
arrpush(filewatch_directories, w);
return filewatcher_rebuild();
dmon_watch(dir, filewatch_callback, DMON_WATCHFLAGS_RECURSIVE, (void *)(intptr_t)(arrlen(filewatch_directories) - 1));
}
bool filewatch_add_file(char *filepath, FileatchCallback callback) {
bool filewatch_add_file(char const *filepath, FileatchCallback callback) {
SDL_assert(filepath && callback);
struct FilewatchPathToCallback const f = {
if (!filewatcher_initialized) {
dmon_init();
filewatcher_initialized = true;
}
struct FilewatchEntry const f = {
.callback = callback,
.path = SDL_strdup(filepath),
.action_processed = true,
.tick_last_reported = ctx.game.frame_number,
.path = SDL_strdup(filepath), /* TODO: free */
};
arrpush(filewatch_files, f);
return filewatcher_rebuild();
dmon_watch("./", filewatch_callback, 0, (void *)(intptr_t)(-arrlen(filewatch_files)));
}
void filewatch_poll(void) {
SDL_LockMutex(filewatcher_lock);
int const filewatch_directories_len = arrlen(filewatch_directories);
for (int i = 0; i < filewatch_directories_len; ++i) {
if (!filewatch_directories[i].action_processed
&& (ctx.game.frame_number - filewatch_directories[i].tick_last_reported > FILEWATCH_MODIFIED_TICKS_MERGED)) {
SDL_assert(filewatch_directories[i].action_pending != FILEWATCH_ACTION_FILE_NONE);
filewatch_directories[i].callback(filewatch_directories[i].path, filewatch_directories[i].action_pending);
filewatch_directories[i].action_pending = FILEWATCH_ACTION_FILE_NONE;
filewatch_directories[i].action_processed = true;
}
for (int i = 0; i < arrlen(filewatch_directories); ++i) {
for (int u = 0; u < arrlen(filewatch_directories[i].actions_pending); ++u)
filewatch_directories[i].callback(filewatch_directories[i].path, filewatch_directories[i].actions_pending[u]);
arrfree(filewatch_directories[i].actions_pending);
}
int const filewatch_files_len = arrlen(filewatch_files);
for (int i = 0; i < filewatch_files_len; ++i) {
if (!filewatch_files[i].action_processed
&& (ctx.game.frame_number - filewatch_files[i].tick_last_reported > FILEWATCH_MODIFIED_TICKS_MERGED)) {
SDL_assert(filewatch_files[i].action_pending != FILEWATCH_ACTION_FILE_NONE);
filewatch_files[i].callback(filewatch_files[i].path, filewatch_files[i].action_pending);
filewatch_files[i].action_pending = FILEWATCH_ACTION_FILE_NONE;
filewatch_files[i].action_processed = true;
}
for (int i = 0; i < arrlen(filewatch_files); ++i) {
for (int u = 0; u < arrlen(filewatch_files[i].actions_pending); ++u)
filewatch_files[i].callback(filewatch_files[i].path, filewatch_files[i].actions_pending[u]);
arrfree(filewatch_files[i].actions_pending);
}
SDL_UnlockMutex(filewatcher_lock);

6
src/twn_filewatch_c.h
View File

@ -3,8 +3,6 @@
#include <stdbool.h>
#define FILEWATCH_MODIFIED_TICKS_MERGED 10
enum FilewatchAction {
FILEWATCH_ACTION_FILE_NONE,
FILEWATCH_ACTION_FILE_CREATED,
@ -14,9 +12,9 @@ enum FilewatchAction {
typedef void (*FileatchCallback)(char const *path, enum FilewatchAction action);
bool filewatch_add_directory(char *dir, FileatchCallback callback);
bool filewatch_add_directory(char const *dir, FileatchCallback callback);
bool filewatch_add_file(char *file, FileatchCallback callback);
bool filewatch_add_file(char const *file, FileatchCallback callback);
void filewatch_poll(void);

6
src/twn_game_object_c.h
View File

@ -11,13 +11,9 @@
void game_object_load(void);
/* note: it should be only called when application is closing */
void game_object_unload(void);
/* returns true if reload happened, otherwise false */
bool game_object_try_reloading(void);
void game_object_tick(void);
void *game_object_get_game_tick_address(void);
#endif

21
src/twn_loop.c
View File

@ -1,4 +1,4 @@
#include "twn_loop.h"
#include "twn_loop_c.h"
#include "twn_engine_context_c.h"
#include "twn_filewatch_c.h"
#include "twn_input_c.h"
@ -6,7 +6,7 @@
#include "twn_util_c.h"
#include "twn_game_object_c.h"
#include "twn_textures_c.h"
#include "system/twn_timer.h"
#include "twn_timer_c.h"
#include <SDL2/SDL.h>
#include <physfs.h>
@ -747,15 +747,20 @@ static void clean_up(void) {
}
static void reset_state(void) {
void reset_state(void) {
ctx.game.initialization_needed = true;
input_reset_state(&ctx.input);
textures_reset_state();
}
static void pack_contents_modified(char const *path, enum FilewatchAction action) {
log_info("Pack contents invalidated: %s, action: %i", path, action);
reset_state();
static uint32_t last_reset_tick;
if (last_reset_tick != (uint32_t)ctx.game.frame_number) {
log_info("Pack contents invalidated: %s, action: %i", path, action);
reset_state();
last_reset_tick = (uint32_t)ctx.game.frame_number;
}
}
@ -868,11 +873,7 @@ int enter_loop(int argc, char **argv) {
profile_end("startup");
while (ctx.is_running) {
if (game_object_try_reloading()) {
ctx.game.initialization_needed = true;
reset_state();
}
/* dispatch all filewatch driven events, such as game object and asset pack reload */
filewatch_poll();
main_loop();
}

2
include/twn_loop.h → src/twn_loop_c.h
View File

@ -6,5 +6,7 @@
TWN_API int enter_loop(int argc, char **argv);
TWN_API void reset_state(void);
#endif

2
src/twn_main.c
View File

@ -1,4 +1,4 @@
#include "twn_loop.h"
#include "twn_loop_c.h"
#ifndef EMSCRIPTEN
#define SDL_MAIN_HANDLED

38
src/twn_timer.c Normal file
View File

@ -0,0 +1,38 @@
#include "twn_timer_c.h"
#include "twn_engine_context_c.h"
#include <SDL2/SDL.h>
static SDL_TimerID sanity_timer;
#define SANITY_TIMER_MESSAGE_FMT "Game tick exeeded its allocated time (%u milliseconds), application is closing"
/* stop application */
static uint32_t sanity_timer_handler(uint32_t interval, void *data) {
(void)data;
size_t text_str_len = snprintf(NULL, 0, SANITY_TIMER_MESSAGE_FMT, interval) + 1;
char *text_str = SDL_malloc(text_str_len);
snprintf(text_str, text_str_len, SANITY_TIMER_MESSAGE_FMT, interval);
SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, "sanity timer", text_str, ctx.window);
SDL_free(text_str);
/* TODO: figure out the most portable way to do it */
/* TODO: different type of behavior is possible, especially for debugging */
quick_exit(EXIT_FAILURE);
}
bool start_sanity_timer(uint32_t milliseconds_to_expire) {
if (!sanity_timer) {
sanity_timer = SDL_AddTimer(milliseconds_to_expire, sanity_timer_handler, NULL);
}
return sanity_timer != 0;
}
bool end_sanity_timer(void) {
SDL_RemoveTimer(sanity_timer);
sanity_timer = 0;
}

2
src/system/twn_timer.h → src/twn_timer_c.h
View File

@ -4,7 +4,7 @@
#include <stdbool.h>
#include <stdbit.h>
bool start_sanity_timer(uint64_t milliseconds_to_expire);
bool start_sanity_timer(uint32_t milliseconds_to_expire);
bool end_sanity_timer(void);
#endif // TWN_TIMER_H

1748
third-party/dmon/dmon.h vendored Normal file
View File

File diff suppressed because it is too large Load Diff

164
third-party/dmon/dmon_extra.h vendored Normal file
View File

@ -0,0 +1,164 @@
#ifndef __DMON_EXTRA_H__
#define __DMON_EXTRA_H__
//
// Copyright 2023 Sepehr Taghdisian (septag@github). All rights reserved.
// License: https://github.com/septag/dmon#license-bsd-2-clause
//
// Extra header functionality for dmon.h for the backend based on inotify
//
// Add/Remove directory functions:
// dmon_watch_add: Adds a sub-directory to already valid watch_id. sub-directories are assumed to be relative to watch root_dir
// dmon_watch_add: Removes a sub-directory from already valid watch_id. sub-directories are assumed to be relative to watch root_dir
// Reason: The inotify backend does not work well when watching in recursive mode a root directory of a large tree, it may take
// quite a while until all inotify watches are established, and events will not be received in this time. Also, since one
// inotify watch will be established per subdirectory, it is possible that the maximum amount of inotify watches per user
// will be reached. The default maximum is 8192.
// When using inotify backend users may turn off the DMON_WATCHFLAGS_RECURSIVE flag and add/remove selectively the
// sub-directories to be watched based on application-specific logic about which sub-directory actually needs to be watched.
// The function dmon_watch_add and dmon_watch_rm are used to this purpose.
//
#ifndef __DMON_H__
#error "Include 'dmon.h' before including this file"
#endif
#ifdef __cplusplus
extern "C" {
#endif
DMON_API_DECL bool dmon_watch_add(dmon_watch_id id, const char* subdir);
DMON_API_DECL bool dmon_watch_rm(dmon_watch_id id, const char* watchdir);
#ifdef __cplusplus
}
#endif
#ifdef DMON_IMPL
#if DMON_OS_LINUX
DMON_API_IMPL bool dmon_watch_add(dmon_watch_id id, const char* watchdir)
{
DMON_ASSERT(id.id > 0 && id.id <= DMON_MAX_WATCHES);
bool skip_lock = pthread_self() == _dmon.thread_handle;
if (!skip_lock)
pthread_mutex_lock(&_dmon.mutex);
dmon__watch_state* watch = _dmon.watches[id.id - 1];
int dirlen, i, c;
// check if the directory exists
// if watchdir contains absolute/root-included path, try to strip the rootdir from it
// else, we assume that watchdir is correct, so save it as it is
struct stat st;
dmon__watch_subdir subdir;
if (stat(watchdir, &st) == 0 && (st.st_mode & S_IFDIR)) {
_dmon_strcpy(subdir.rootdir, sizeof(subdir.rootdir), watchdir);
if (strstr(subdir.rootdir, watch->rootdir) == subdir.rootdir) {
_dmon_strcpy(subdir.rootdir, sizeof(subdir.rootdir), watchdir + strlen(watch->rootdir));
}
} else {
char fullpath[DMON_MAX_PATH];
_dmon_strcpy(fullpath, sizeof(fullpath), watch->rootdir);
_dmon_strcat(fullpath, sizeof(fullpath), watchdir);
if (stat(fullpath, &st) != 0 || (st.st_mode & S_IFDIR) == 0) {
_DMON_LOG_ERRORF("Watch directory '%s' is not valid", watchdir);
if (!skip_lock)
pthread_mutex_unlock(&_dmon.mutex);
return false;
}
_dmon_strcpy(subdir.rootdir, sizeof(subdir.rootdir), watchdir);
}
dirlen = (int)strlen(subdir.rootdir);
if (subdir.rootdir[dirlen - 1] != '/') {
subdir.rootdir[dirlen] = '/';
subdir.rootdir[dirlen + 1] = '\0';
}
// check that the directory is not already added
for (i = 0, c = stb_sb_count(watch->subdirs); i < c; i++) {
if (strcmp(subdir.rootdir, watch->subdirs[i].rootdir) == 0) {
_DMON_LOG_ERRORF("Error watching directory '%s', because it is already added.", watchdir);
if (!skip_lock)
pthread_mutex_unlock(&_dmon.mutex);
return false;
}
}
const uint32_t inotify_mask = IN_MOVED_TO | IN_CREATE | IN_MOVED_FROM | IN_DELETE | IN_MODIFY;
char fullpath[DMON_MAX_PATH];
_dmon_strcpy(fullpath, sizeof(fullpath), watch->rootdir);
_dmon_strcat(fullpath, sizeof(fullpath), subdir.rootdir);
int wd = inotify_add_watch(watch->fd, fullpath, inotify_mask);
if (wd == -1) {
_DMON_LOG_ERRORF("Error watching directory '%s'. (inotify_add_watch:err=%d)", watchdir, errno);
if (!skip_lock)
pthread_mutex_unlock(&_dmon.mutex);
return false;
}
stb_sb_push(watch->subdirs, subdir);
stb_sb_push(watch->wds, wd);
if (!skip_lock)
pthread_mutex_unlock(&_dmon.mutex);
return true;
}
DMON_API_IMPL bool dmon_watch_rm(dmon_watch_id id, const char* watchdir)
{
DMON_ASSERT(id.id > 0 && id.id <= DMON_MAX_WATCHES);
bool skip_lock = pthread_self() == _dmon.thread_handle;
if (!skip_lock)
pthread_mutex_lock(&_dmon.mutex);
dmon__watch_state* watch = _dmon.watches[id.id - 1];
char subdir[DMON_MAX_PATH];
_dmon_strcpy(subdir, sizeof(subdir), watchdir);
if (strstr(subdir, watch->rootdir) == subdir) {
_dmon_strcpy(subdir, sizeof(subdir), watchdir + strlen(watch->rootdir));
}
int dirlen = (int)strlen(subdir);
if (subdir[dirlen - 1] != '/') {
subdir[dirlen] = '/';
subdir[dirlen + 1] = '\0';
}
int i, c = stb_sb_count(watch->subdirs);
for (i = 0; i < c; i++) {
if (strcmp(watch->subdirs[i].rootdir, subdir) == 0) {
break;
}
}
if (i >= c) {
_DMON_LOG_ERRORF("Watch directory '%s' is not valid", watchdir);
if (!skip_lock)
pthread_mutex_unlock(&_dmon.mutex);
return false;
}
inotify_rm_watch(watch->fd, watch->wds[i]);
/* Remove entry from subdirs and wds by swapping position with the last entry */
watch->subdirs[i] = stb_sb_last(watch->subdirs);
stb_sb_pop(watch->subdirs);
watch->wds[i] = stb_sb_last(watch->wds);
stb_sb_pop(watch->wds);
if (!skip_lock)
pthread_mutex_unlock(&_dmon.mutex);
return true;
}
#endif // DMON_OS_LINUX
#endif // DMON_IMPL
#endif // __DMON_EXTRA_H__

77
third-party/x-watcher/array.h vendored
View File

@ -1,77 +0,0 @@
#ifndef ARRAY_H
#define ARRAY_H
#include <string.h>
#include <stdlib.h>
struct _ArrayHeader {
size_t count, capacity;
};
#define ARRAY_INITIAL_SIZE 8
#define _arr_header(a) ((struct _ArrayHeader*)(a) - 1)
#define arr_init(a) arr_init_n((a), ARRAY_INITIAL_SIZE)
#define arr_init_n(a, n) do { \
struct _ArrayHeader *header; \
header = malloc(sizeof(*header) + (sizeof(*(a)) * (n))); \
header->count = 0; \
header->capacity = (n); \
(a) = (void*)(header + 1); \
} while(0)
#define arr_count(a) (_arr_header(a)->count)
#define arr_capacity(a) (_arr_header(a)->capacity)
#define arr_back(a) ((a)[arr_count(a) - 1])
#define arr_pop(a) ((a)[_arr_header(a)->count--])
#define arr_reserve(a, n) do { \
if(n <= arr_capacity(a)) break; \
struct _ArrayHeader *header = _arr_header(a); \
header->capacity = n; \
(a) = (void*)((struct _ArrayHeader*)realloc( \
header, sizeof(*header) + (sizeof(*(a)) * (n))) + 1); \
} while(0)
#define arr_resize(a, n) do { \
arr_reserve((a), (n)); \
_arr_header(a)->count = n; \
} while(0)
#define arr_resize_zero(a, n) do { \
size_t initial_count = arr_count(a); \
arr_resize((a), (n)); \
if(arr_count(a) > initial_count) \
memset( \
&(a)[initial_count], 0, \
(arr_count(a) - initial_count) * sizeof(*a)); \
} while(0)
// Take a vararg list to support compound literals
#define arr_add(a, ...) do { \
struct _ArrayHeader *header = _arr_header(a); \
if(header->count == header->capacity) \
arr_reserve((a), header->capacity << 1); \
(a)[_arr_header(a)->count++] = (__VA_ARGS__); \
} while(0)
#define arr_free(a) do { \
free(_arr_header(a)); \
} while(0)
#define arr_find(a, val, idx) do { \
*idx = -1; \
for(size_t i = 0; i < arr_count((a)); i++) { \
if((a)[i] == val) { \
*idx = i; \
break; \
} \
} \
} while(0)
#endif

838
third-party/x-watcher/x-watcher.h vendored
View File

@ -1,838 +0,0 @@
#ifndef __X_WATCHER_H
#define __X_WATCHER_H
// necessary includes for the public stuff
#include <pthread.h>
#include <stdbool.h>
#if defined(__linux__)
// noop
#elif defined(__WIN32__)
#include <windows.h>
#include <stdint.h>
#else
#error "Unsupported"
#endif
// PUBLIC STUFF
typedef enum event {
XWATCHER_FILE_UNSPECIFIED,
XWATCHER_FILE_REMOVED,
XWATCHER_FILE_CREATED,
XWATCHER_FILE_MODIFIED,
XWATCHER_FILE_OPENED,
XWATCHER_FILE_ATTRIBUTES_CHANGED,
XWATCHER_FILE_NONE,
XWATCHER_FILE_RENAMED,
// probs more but i couldn't care much
} XWATCHER_FILE_EVENT;
typedef struct xWatcher_reference {
char *path;
void (*callback_func)(
XWATCHER_FILE_EVENT event,
const char *path,
int context,
void *additional_data);
int context;
void *additional_data;
} xWatcher_reference;
typedef struct xWatcher_file {
// just the file name alone
char *name;
// used for adding (additional) context in the handler (if needed)
int context;
// in case you'd like to avoid global variables
void *additional_data;
void (*callback_func)(
XWATCHER_FILE_EVENT event,
const char *path,
int context,
void *additional_data);
} xWatcher_file;
typedef struct xWatcher_directory {
// list of files
struct xWatcher_file *files;
char *path;
// used for adding (additional) context in the handler (if needed)
int context;
// in case you'd like to avoid global variables
void *additional_data;
void (*callback_func)(
XWATCHER_FILE_EVENT event,
const char *path,
int context,
void *additional_data);
#if defined(__linux__)
// we need additional file descriptors (per directory basis)
int inotify_watch_fd;
#elif defined(__WIN32__)
HANDLE handle;
OVERLAPPED overlapped;
uint8_t *event_buffer;
#else
#error "Unsupported"
#endif
} xWatcher_directory;
typedef struct x_watcher {
struct xWatcher_directory *directories;
pthread_t thread;
int thread_id;
bool alive;
#if defined(__linux__)
int inotify_fd; // fd == file descriptor (a common UNIX thing)
#elif defined(__WIN32__)
// literal noop
#else
#error "Unsupported"
#endif
} x_watcher;
// PRIVATE STUFF
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "array.h"
#ifdef __linux__
#include <sys/types.h>
#include <sys/inotify.h>
#include <errno.h>
#include <unistd.h>
#include <poll.h> // for POLLIN
#include <fcntl.h> // for O_NONBLOCK
#define EVENT_SIZE (sizeof(struct inotify_event))
#define BUF_LEN (1024 * (EVENT_SIZE + 16))
#define DIRBRK '/'
static inline void *__internal_xWatcherProcess(void *argument) {
x_watcher *watcher = (x_watcher*) argument;
char buffer[BUF_LEN];
ssize_t lenght;
struct xWatcher_directory *directories = watcher->directories;
while(watcher->alive) {
// poll for events
struct pollfd pfd = { watcher->inotify_fd, POLLIN, 0 };
int ret = poll(&pfd, 1, 50); // timeout of 50ms
if (ret < 0) {
// oops
fprintf(stderr, "poll failed: %s\n", strerror(errno));
break;
} else if (ret == 0) {
// Timeout with no events, move on.
continue;
}
// wait for the kernel to do it's thing
lenght = read(watcher->inotify_fd, buffer, BUF_LEN);
if(lenght < 0) {
// something messed up clearly
perror("read");
return NULL;
}
// pointer to the event structure
ssize_t i = 0;
while(i < lenght) {
// the event list itself
struct inotify_event *event = (struct inotify_event *)
&buffer[i];
// find directory for which this even matches via the descriptor
struct xWatcher_directory *directory = NULL;
for(size_t j = 0; j < arr_count(directories); j++) {
if(directories[j].inotify_watch_fd == event->wd) {
directory = &directories[j];
}
}
if(directory == NULL) {
fprintf(stderr,
"MATCHING FILE DESCRIPTOR NOT FOUND! ERROR!\n");
// BAIL????
}
// find matching file (if any)
struct xWatcher_file *file = NULL;
for(size_t j = 0; j < arr_count(directory->files); j++) {
if(strcmp(directory->files[j].name, event->name) == 0) {
file = &directory->files[j];
}
}
XWATCHER_FILE_EVENT send_event = XWATCHER_FILE_NONE;
if(event->mask & IN_CREATE)
send_event = XWATCHER_FILE_CREATED;
if(event->mask & IN_MODIFY)
send_event = XWATCHER_FILE_MODIFIED;
if(event->mask & IN_DELETE)
send_event = XWATCHER_FILE_REMOVED;
if(event->mask & IN_CLOSE_WRITE ||
event->mask & IN_CLOSE_NOWRITE)
send_event = XWATCHER_FILE_REMOVED;
if(event->mask & IN_ATTRIB)
send_event = XWATCHER_FILE_ATTRIBUTES_CHANGED;
if(event->mask & IN_OPEN)
send_event = XWATCHER_FILE_OPENED;
// file found(?)
if(file != NULL) {
if(send_event != XWATCHER_FILE_NONE) {
// figure out the file path size
size_t filepath_size = strlen(directory->path);
filepath_size += strlen(file->name);
filepath_size += 2;
// create file path string
char *filepath = (char*)malloc(filepath_size);
snprintf(filepath, filepath_size, "%s/%s",
directory->path, file->name);
// callback
file->callback_func(send_event,
filepath,
file->context,
file->additional_data);
// free that garbage
free(filepath);
}
} else {
// Cannot find file, lets try directory
if(directory->callback_func != NULL &&
send_event != XWATCHER_FILE_NONE) {
directory->callback_func(send_event,
directory->path,
directory->context,
directory->additional_data);
}
}
i += EVENT_SIZE + event->len;
}
}
// cleanup time
for(size_t i = 0; i < arr_count(watcher->directories); i++) {
struct xWatcher_directory *directory = &watcher->directories[i];
for(size_t j = 0; j < arr_count(directory->files); j++) {
struct xWatcher_file *file = &directory->files[j];
free(file->name);
}
arr_free(directory->files);
free(directory->path);
inotify_rm_watch(watcher->inotify_fd, directory->inotify_watch_fd);
}
close(watcher->inotify_fd);
arr_free(watcher->directories);
// should we signify that the thread is dead?
return NULL;
}
#elif defined(__WIN32__)
#include <tchar.h>
#define BUF_LEN 1024
#define DIRBRK '\\'
static inline void *__internal_xWatcherProcess(void *argument) {
x_watcher *watcher = (x_watcher*) argument;
struct xWatcher_directory *directories = watcher->directories;
// create an event list so we can still make use of the Windows API
HANDLE events[arr_count(directories)];
for(int i = 0; i < arr_count(directories); i++) {
events[i] = directories[i].overlapped.hEvent;
}
// obv first check if we need to stay alive
while(watcher->alive) {
// wait for any of the objects to respond
DWORD result = WaitForMultipleObjects(arr_count(directories),
events, FALSE, 50 /** timeout of 50ms **/);
// test which object was it
int object_index = -1;
for(int i = 0; i < arr_count(directories); i++) {
if(result == (WAIT_OBJECT_0 + i)) {
object_index = i;
break;
}
}
if(object_index == -1) {
if(result == WAIT_TIMEOUT) {
// it just timed out, let's continue
continue;
} else {
// RUNTIME ERROR! Let's bail
ExitProcess(GetLastError());
}
}
// shorhand for convenience
struct xWatcher_directory *dir = &directories[object_index];
// retrieve event data
DWORD bytes_transferred;
GetOverlappedResult(dir->handle,
&dir->overlapped,
&bytes_transferred, FALSE);
// assign the data's pointer to a proper format for convenience
FILE_NOTIFY_INFORMATION *event = (FILE_NOTIFY_INFORMATION*)
dir->event_buffer;
// loop through the data
for (;;) {
// figure out the wchar string size and allocate as needed
DWORD name_len = event->FileNameLength / sizeof(wchar_t);
char *name_char = malloc(sizeof(char)*(name_len+1));
size_t converted_chars;
// convert wchar* filename to char*
wcstombs_s(&converted_chars, name_char,
name_len+1, event->FileName, name_len);
// convert to proper event type
XWATCHER_FILE_EVENT send_event = XWATCHER_FILE_NONE;
switch (event->Action) {
case FILE_ACTION_ADDED:
send_event = XWATCHER_FILE_CREATED;
break;
case FILE_ACTION_REMOVED:
send_event = XWATCHER_FILE_REMOVED;
break;
case FILE_ACTION_MODIFIED:
send_event = XWATCHER_FILE_MODIFIED;
break;
case FILE_ACTION_RENAMED_OLD_NAME:
case FILE_ACTION_RENAMED_NEW_NAME:
send_event = XWATCHER_FILE_RENAMED;
break;
default:
send_event = XWATCHER_FILE_UNSPECIFIED;
break;
}
// find matching file (if any)
struct xWatcher_file *file = NULL;
for(size_t j = 0; j < arr_count(dir->files); j++) {
if(strcmp(dir->files[j].name, name_char) == 0) {
file = &dir->files[j];
}
}
// file found(?)
if(file != NULL) {
if(send_event != XWATCHER_FILE_NONE) {
// figure out the file path size
size_t filepath_size = strlen(dir->path);
filepath_size += strlen(file->name);
filepath_size += 2;
// create file path string
char *filepath = (char*)malloc(filepath_size);
snprintf(filepath, filepath_size, "%s%c%s",
dir->path, DIRBRK, file->name);
// callback
file->callback_func(send_event,
filepath,
file->context,
file->additional_data);
// free that garbage
free(filepath);
}
} else {
// Cannot find file, lets try directory
if(dir->callback_func != NULL &&
send_event != XWATCHER_FILE_NONE) {
dir->callback_func(send_event,
dir->path,
dir->context,
dir->additional_data);
}
}
// free up the converted string
free(name_char);
// Are there more events to handle?
if (event->NextEntryOffset) {
*((uint8_t**)&event) += event->NextEntryOffset;
} else {
break;
}
}
DWORD dwNotifyFilter =
FILE_NOTIFY_CHANGE_FILE_NAME |
FILE_NOTIFY_CHANGE_DIR_NAME |
FILE_NOTIFY_CHANGE_ATTRIBUTES |
FILE_NOTIFY_CHANGE_SIZE |
FILE_NOTIFY_CHANGE_LAST_WRITE |
FILE_NOTIFY_CHANGE_LAST_ACCESS |
FILE_NOTIFY_CHANGE_CREATION |
FILE_NOTIFY_CHANGE_SECURITY;
BOOL recursive = FALSE;
// Queue the next event
BOOL success = ReadDirectoryChangesW(
dir->handle,
dir->event_buffer,
BUF_LEN,
recursive,
dwNotifyFilter,
NULL,
&dir->overlapped,
NULL);
if(!success) {
// get error code
DWORD error = GetLastError();
char *message;
// get error message
FormatMessage(
FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_IGNORE_INSERTS,
NULL,
error,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
(LPTSTR) &message,
0, NULL);
fprintf(stderr, "ReadDirectoryChangesW failed: %s\n",
message);
ExitProcess(error);
}
}
// cleanup time
for(size_t i = 0; i < arr_count(watcher->directories); i++) {
struct xWatcher_directory *directory = &watcher->directories[i];
for(size_t j = 0; j < arr_count(directory->files); j++) {
struct xWatcher_file *file = &directory->files[j];
free(file->name);
}
arr_free(directory->files);
free(directory->path);
free(directory->event_buffer);
CloseHandle(directory->handle);
}
arr_free(watcher->directories);
return NULL;
}
#else
#error "Unsupported"
#endif
static inline x_watcher *xWatcher_create(void) {
x_watcher *watcher = (x_watcher*)malloc(sizeof(x_watcher));
arr_init(watcher->directories);
#if defined(__WIN32__)
// literally noop
#elif defined(__linux__)
watcher->inotify_fd = inotify_init1(O_NONBLOCK);
if(watcher->inotify_fd < 0) {
perror("inotify_init");
return NULL;
}
#else
#error "Unsupported"
#endif
return watcher;
}
static inline bool xWatcher_appendFile(
x_watcher *watcher,
xWatcher_reference *reference) {
char *path = strdup(reference->path);
// the file MUST NOT contain slashed at the end
if(path[strlen(path)-1] == DIRBRK)
return false;
char *filename = NULL;
// we need to split the filename and path
for(size_t i = strlen(path)-1; i > 0; i--) {
if(path[i] == DIRBRK) {
path[i] = '\0'; // break the string, so it splits into two
filename = &path[i+1]; // set the rest of it as the filename
break;
}
}
// If the directory is specifically local, treat it as such.
if(filename == NULL) {
filename = path;
}
struct xWatcher_directory *dir = NULL;
// check against the database of (pre-existing) directories
for(size_t i = 0; i < arr_count(watcher->directories); i++) {
// paths match
if(strcmp(watcher->directories[i].path, path) == 0) {
dir = &watcher->directories[i];
}
}
// directory exists, check if an callback has been already added
if(dir == NULL) {
struct xWatcher_directory new_dir;
new_dir.callback_func = NULL; // DO NOT add callbacks if it's a file
new_dir.context = 0; // context should be invalid as well
new_dir.additional_data = NULL; // so should the data
new_dir.path = path; // add a path to the directory
#if defined(__linux__)
new_dir.inotify_watch_fd = -1; // invalidate inotify
#elif defined(__WIN32__)
new_dir.handle = NULL;
#else
#error "Unsupported"
#endif
// initialize file arrays
arr_init(new_dir.files);
// add the directory to the masses
arr_add(watcher->directories, new_dir);
// move the pointer to the newly added element
dir = &watcher->directories[arr_count(watcher->directories)-1];
}
// search for the file
struct xWatcher_file *file = NULL;
for(size_t i = 0; i < arr_count(dir->files); i++) {
if(strcmp(dir->files[i].name, filename) == 0) {
file = &dir->files[i];
}
}
if(file != NULL) {
return false; // file already exists, that's an ERROR
}
struct xWatcher_file new_file;
// avoid an invalid free because this shares the memory space
// of the full path string
new_file.name = strdup(filename);
new_file.context = reference->context;
new_file.additional_data = reference->additional_data;
new_file.callback_func = reference->callback_func;
// the the element
arr_add(dir->files, new_file);
// and move the pointer to the newly added element
file = &dir->files[arr_count(watcher->directories)-1];
// add the file watcher
#if defined(__linux__)
if(dir->inotify_watch_fd == -1) {
dir->inotify_watch_fd = inotify_add_watch(
watcher->inotify_fd,
path,
IN_ALL_EVENTS);
if(dir->inotify_watch_fd == -1) {
perror("inotify_watch_fd");
return false;
}
}
#elif defined(__WIN32__)
// add directory path
dir->handle = CreateFile(dir->path,
FILE_LIST_DIRECTORY,
FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
NULL,
OPEN_EXISTING,
FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OVERLAPPED,
NULL);
if(dir->handle == INVALID_HANDLE_VALUE) {
// get error code
DWORD error = GetLastError();
char *message;
// get error message
FormatMessage(
FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_IGNORE_INSERTS,
NULL,
error,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
(LPTSTR) &message,
0, NULL);
fprintf(stderr, "CreateFile failed: %s\n",
message);
return false;
}
// create event structure
dir->overlapped.hEvent = CreateEvent(NULL, FALSE, 0, NULL);
if(dir->overlapped.hEvent == NULL) {
// get error code
DWORD error = GetLastError();
char *message;
// get error message
FormatMessage(
FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_IGNORE_INSERTS,
NULL,
error,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
(LPTSTR) &message,
0, NULL);
fprintf(stderr, "CreateEvent failed: %s\n",
message);
return false;
}
// allocate the event buffer
dir->event_buffer = malloc(BUF_LEN);
if(dir->event_buffer == NULL) {
fprintf(stderr, "malloc failed at __FILE__:__LINE__!\n");
return false;
}
// set reading params
BOOL success = ReadDirectoryChangesW(
dir->handle, dir->event_buffer, BUF_LEN, TRUE,
FILE_NOTIFY_CHANGE_FILE_NAME |
FILE_NOTIFY_CHANGE_DIR_NAME |
FILE_NOTIFY_CHANGE_LAST_WRITE,
NULL, &dir->overlapped, NULL);
if(!success) {
// get error code
DWORD error = GetLastError();
char *message;
// get error message
FormatMessage(
FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_IGNORE_INSERTS,
NULL,
error,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
(LPTSTR) &message,
0, NULL);
fprintf(stderr, "ReadDirectoryChangesW failed: %s\n",
message);
return false;
}
#else
#error "Unsupported"
#endif
return true;
}
static inline bool xWatcher_appendDir(
x_watcher *watcher,
xWatcher_reference *reference) {
char *path = strdup(reference->path);
// inotify only works with directories that do NOT have a front-slash
// at the end, so we have to make sure to cut that out
if(path[strlen(path)-1] == DIRBRK)
path[strlen(path)-1] = '\0';
struct xWatcher_directory *dir = NULL;
// check against the database of (pre-existing) directories
for(size_t i=0; i < arr_count(watcher->directories); i++) {
// paths match
if(strcmp(watcher->directories[i].path, path) == 0) {
dir = &watcher->directories[i];
}
}
// directory exists, check if an callback has been already added
if(dir) {
// ERROR, CALLBACK EXISTS
if(dir->callback_func) {
return false;
}
dir->callback_func = reference->callback_func;
dir->context = reference->context;
dir->additional_data = reference->additional_data;
} else {
// keep an eye for this one as it's on the stack
struct xWatcher_directory dir;
dir.path = path;
dir.callback_func = reference->callback_func;
dir.context = reference->context;
dir.additional_data = reference->additional_data;
// initialize file arrays
arr_init(dir.files);
#if defined(__linux__)
dir.inotify_watch_fd = inotify_add_watch(
watcher->inotify_fd,
dir.path,
IN_ALL_EVENTS);
if(dir.inotify_watch_fd == -1) {
perror("inotify_watch_fd");
return false;
}
#elif defined(__WIN32__)
// add directory path
dir.handle = CreateFile(dir.path,
FILE_LIST_DIRECTORY,
FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
NULL,
OPEN_EXISTING,
FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OVERLAPPED,
NULL);
if(dir.handle == INVALID_HANDLE_VALUE) {
// get error code
DWORD error = GetLastError();
char *message;
// get error message
FormatMessage(
FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_IGNORE_INSERTS,
NULL,
error,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
(LPTSTR) &message,
0, NULL);
fprintf(stderr, "CreateFile failed: %s\n",
message);
return false;
}
// create event structure
dir.overlapped.hEvent = CreateEvent(NULL, FALSE, 0, NULL);
if(dir.overlapped.hEvent == NULL) {
// get error code
DWORD error = GetLastError();
char *message;
// get error message
FormatMessage(
FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_IGNORE_INSERTS,
NULL,
error,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
(LPTSTR) &message,
0, NULL);
fprintf(stderr, "CreateEvent failed: %s\n",
message);
return false;
}
// allocate the event buffer
dir.event_buffer = malloc(BUF_LEN);
if(dir.event_buffer == NULL) {
fprintf(stderr, "malloc failed at __FILE__:__LINE__!\n");
return false;
}
// set reading params
BOOL success = ReadDirectoryChangesW(
dir.handle, dir.event_buffer, BUF_LEN, TRUE,
FILE_NOTIFY_CHANGE_FILE_NAME |
FILE_NOTIFY_CHANGE_DIR_NAME |
FILE_NOTIFY_CHANGE_LAST_WRITE,
NULL, &dir.overlapped, NULL);
if(!success) {
// get error code
DWORD error = GetLastError();
char *message;
// get error message
FormatMessage(
FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_IGNORE_INSERTS,
NULL,
error,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
(LPTSTR) &message,
0, NULL);
fprintf(stderr, "ReadDirectoryChangesW failed: %s\n",
message);
return false;
}
#else
#error "Unsupported"
#endif
arr_add(watcher->directories, dir);
}
return true;
}
static inline bool xWatcher_start(x_watcher *watcher) {
watcher->alive = true;
// create watcher thread
watcher->thread_id = pthread_create(
&watcher->thread,
NULL,
__internal_xWatcherProcess,
watcher);
if(watcher->thread_id != 0) {
perror("pthread_create");
watcher->alive = false;
return false;
}
return true;
}
static inline void xWatcher_destroy(x_watcher *watcher) {
void *ret;
watcher->alive = false;
pthread_join(watcher->thread, &ret);
free(watcher);
}
#endif