twn_filewatch.c: file and directory change api, initial support for texture reload

src/twn_filewatch.c

@@ -0,0 +1,171 @@
+#include "twn_filewatch_c.h"
+#include "twn_util.h"
+#include "twn_engine_context_c.h"
+
+#include <x-watcher.h>
+#include <stb_ds.h>
+#include <SDL2/SDL.h>
+
+
+struct FilewatchPathToCallback {
+    char *path;
+    FileatchCallback callback;
+    float tick_last_reported;
+    enum FilewatchAction action_pending : 3;
+    bool action_processed : 1;
+};
+
+static struct FilewatchPathToCallback *filewatch_directories;
+static struct FilewatchPathToCallback *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;
+
+/* 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;
+
+    enum FilewatchAction action;
+
+    switch (event) {
+    case XWATCHER_FILE_CREATED:
+        action = FILEWATCH_ACTION_FILE_CREATED;
+        break;
+    case XWATCHER_FILE_REMOVED:
+        action = FILEWATCH_ACTION_FILE_DELETED;
+        break;
+    case XWATCHER_FILE_MODIFIED:
+        action = 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;
+
+    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;
+
+    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) {
+    SDL_assert(dir && callback);
+
+    struct FilewatchPathToCallback const w = {
+        .callback = callback,
+        .path = SDL_strdup(dir),
+        .action_processed = true,
+        .tick_last_reported = ctx.game.frame_number,
+    };
+    arrpush(filewatch_directories, w);
+
+    return filewatcher_rebuild();
+}
+
+
+bool filewatch_add_file(char *filepath, FileatchCallback callback) {
+    SDL_assert(filepath && callback);
+
+    struct FilewatchPathToCallback const f = {
+        .callback = callback,
+        .path = SDL_strdup(filepath),
+        .action_processed = true,
+        .tick_last_reported = ctx.game.frame_number,
+    };
+    arrpush(filewatch_files, f);
+
+    return filewatcher_rebuild();
+}
+
+
+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;
+        }
+    }
+
+    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;
+        }
+    }
+
+    SDL_UnlockMutex(filewatcher_lock);
+}