Separate engine and game

engine/breeze/core/logger.c

@@ -0,0 +1,139 @@
+#include "logger.h"
+
+#include "logger_module.h"
+#include "module_system.h"
+
+#include <stdio.h>
+#include <stdarg.h>
+#include <time.h>
+
+#define BZ_GET_LOGGER_MODULE() ((BzLoggerModule *) bzModuleRetrieve(BZ_MODULE_LOGGER))
+
+bool bzLoggerInit() {
+    if (bzModuleIsAllocated(BZ_MODULE_LOGGER))
+        return false;
+
+    BzLoggerModule *logger = bzModuleAllocate(BZ_MODULE_LOGGER, sizeof(*logger));
+    if (logger == NULL)
+        return false;
+
+    logger->level = BZ_LOG_INFO;
+    logger->silent = false;
+
+
+    return true;
+}
+
+void bzLoggerDeinit() {
+    BzLoggerModule *logger = BZ_GET_LOGGER_MODULE();
+    bzModuleFree(BZ_MODULE_LOGGER);
+}
+
+void bzLoggerEnableDefaultLog(bool enable) {
+    BZ_GET_LOGGER_MODULE()->silent = !enable;
+}
+
+void bzLoggerSetLevel(BzLoggerLevel level) {
+    BZ_GET_LOGGER_MODULE()->level = level;
+}
+
+BzLoggerLevel bzLoggerGetLevel() {
+    return BZ_GET_LOGGER_MODULE()->level;
+}
+
+
+static const char *LEVEL_STRINGS[] = {
+        "TRACE",
+        "DEBUG",
+        "INFO",
+        "WARN",
+        "ERROR",
+        "FATAL"
+};
+static const char *LEVEL_COLORS[] = {
+        "\x1b[90m", // TRACE  -> Bright black
+        "\x1b[96m", // DEBUG  -> Bright cyan
+        "\x1b[32m", // INFO   -> Green
+        "\x1b[33m", // WARN   -> Yellow
+        "\x1b[31m", // ERROR  -> Red
+        "\x1b[91m", // FATAL  -> Bright red
+};
+
+static void bzLoggerStdOutCallback(BzLoggerEvent *ev) {
+    va_list *ap = ev->apList;
+    fprintf(stderr, "%s %s%-5s\x1b[0m \x1b[90m%s:%d:\x1b[0m ",
+            ev->time, LEVEL_STRINGS[ev->level], LEVEL_COLORS[ev->level], ev->file, ev->line);
+    vfprintf(stderr, ev->fmt, *ap);
+    fprintf(stderr, "\n");
+    fflush(stderr);
+}
+
+static void bzLoggerFileCallback(BzLoggerEvent *ev) {
+    FILE *fp = ev->userData;
+    va_list *ap = ev->apList;
+    fprintf(fp, "%s %-5s %s:%d: ", ev->time, LEVEL_STRINGS[ev->level], ev->file, ev->line);
+    vfprintf(fp, ev->fmt, *ap);
+    fflush(fp);
+}
+
+void bzLoggerLog(BzLoggerLevel level, const char *file, int line, const char *fmt, ...) {
+    BzLoggerEvent event = {NULL,  NULL, level, file, line, fmt};
+    const int loggerLevel = bzLoggerGetLevel();
+
+    time_t t = time(NULL);
+    struct tm *lt = localtime(&t);
+    char timeBuf[16];
+    size_t lastIdx = strftime(timeBuf, sizeof(timeBuf), "%H:%M:%S", lt);
+    // TODO: Assert
+    timeBuf[lastIdx] = '\0';
+    event.time = timeBuf;
+
+    if (!BZ_GET_LOGGER_MODULE()->silent && level <= loggerLevel) {
+        event.userData = stderr;
+        va_list ap;
+        va_start(ap, fmt);
+
+        event.apList = &ap;
+        bzLoggerStdOutCallback(&event);
+
+        va_end(ap);
+    }
+
+    for (int i = 0; i < BZ_LOGGER_MAX_CALLBACKS; ++i) {
+        BzLoggerCallback cb = BZ_GET_LOGGER_MODULE()->callbacks[i];
+
+        if (level <= cb.level) {
+            event.userData = cb.userData;
+
+            va_list ap;
+            va_start(ap, fmt);
+
+            event.apList = &ap;
+            cb.callback(&event);
+
+            va_end(ap);
+        }
+    }
+
+}
+
+bool bzLoggerAddFP(void *fp, BzLoggerLevel level) {
+    return bzLoggerAddCB(&(BzLoggerCallback) {
+            .callback = bzLoggerFileCallback,
+            .level = level,
+            .userData = fp
+    });
+}
+
+bool bzLoggerAddCB(const BzLoggerCallback *callback) {
+    for (int i = 0; i < BZ_LOGGER_MAX_CALLBACKS; ++i) {
+        BzLoggerCallback *cbSlot = &BZ_GET_LOGGER_MODULE()->callbacks[i];
+
+        if (cbSlot->callback == NULL) {
+            *cbSlot = *callback;
+            return true;
+        }
+    }
+
+    return false;
+}

engine/breeze/core/logger.h

@@ -0,0 +1,53 @@
+#ifndef BREEZE_LOGGER_H
+#define BREEZE_LOGGER_H
+
+#include "../defines.h"
+
+typedef enum BzLoggerLevel {
+    BZ_LOG_TRACE,
+    BZ_LOG_DEBUG,
+    BZ_LOG_INFO,
+    BZ_LOG_WARN,
+    BZ_LOG_ERROR,
+    BZ_LOG_FATAL,
+} BzLoggerLevel;
+
+typedef struct BzLoggerEvent {
+    void *userData;
+
+    const char *time;
+    BzLoggerLevel level;
+    const char *file;
+    int line;
+
+    const char *fmt;
+    void *apList;
+} BzLoggerEvent;
+
+typedef struct BzLoggerCallback {
+    void (*callback)(BzLoggerEvent *ev);
+    enum BzLoggerLevel level;
+    void *userData;
+} BzLoggerCallback;
+
+bool bzLoggerInit();
+void bzLoggerDeinit();
+
+void bzLoggerEnableDefaultLog(bool enable);
+
+void bzLoggerSetLevel(BzLoggerLevel level);
+BzLoggerLevel bzLoggerGetLevel();
+
+void bzLoggerLog(BzLoggerLevel level, const char *file, int line, const char *fmt, ...);
+
+bool bzLoggerAddFP(void *fp, BzLoggerLevel level);
+bool bzLoggerAddCB(const BzLoggerCallback *callback);
+
+#define bzLogTrace(...) bzLoggerLog(BZ_LOG_TRACE, __FILE__, __LINE__, __VA_ARGS__)
+#define bzLogDebug( ...) bzLoggerLog(BZ_LOG_DEBUG, __FILE__, __LINE__, __VA_ARGS__)
+#define bzLogInfo(...) bzLoggerLog(BZ_LOG_INFO, __FILE__, __LINE__, __VA_ARGS__)
+#define bzLogWarn(...) bzLoggerLog(BZ_LOG_WARN, __FILE__, __LINE__, __VA_ARGS__)
+#define bzLogError(...) bzLoggerLog(BZ_LOG_ERROR, __FILE__, __LINE__, __VA_ARGS__)
+#define bzLogFatal(...) bzLoggerLog(BZ_LOG_FATAL, __FILE__, __LINE__, __VA_ARGS__)
+
+#endif //BREEZE_LOGGER_H

engine/breeze/core/logger_module.h

@@ -0,0 +1,15 @@
+#ifndef BREEZE_LOGGER_MODULE_H
+#define BREEZE_LOGGER_MODULE_H
+
+#include "logger.h"
+
+#define BZ_LOGGER_MAX_CALLBACKS 32
+
+typedef struct BzLoggerModule {
+    BzLoggerCallback callbacks[BZ_LOGGER_MAX_CALLBACKS];
+
+    int level;
+    bool silent;
+} BzLoggerModule;
+
+#endif //BREEZE_LOGGER_MODULE_H

engine/breeze/core/module_system.c

@@ -0,0 +1,27 @@
+#include "module_system.h"
+
+#include <malloc.h>
+
+void *BZ_MODULES[BZ_ENGINE_MODULE_COUNT] = {NULL,};
+
+bool bzModuleIsAllocated(BzModule module) {
+    return BZ_MODULES[module] != NULL;
+}
+
+void *bzModuleRetrieve(BzModule module) {
+    return BZ_MODULES[module];
+}
+
+void *bzModuleAllocate(BzModule module, size_t sizeBytes) {
+    if (bzModuleIsAllocated(module)) {
+        bzModuleFree(module);
+    }
+    BZ_MODULES[module] = calloc(1, sizeBytes);
+    return BZ_MODULES[module];
+}
+
+void bzModuleFree(BzModule module) {
+    if (bzModuleIsAllocated(module))
+        free(BZ_MODULES[module]);
+    BZ_MODULES[module] = NULL;
+}

engine/breeze/core/module_system.h

@@ -0,0 +1,18 @@
+#ifndef BREEZE_MODULE_H
+#define BREEZE_MODULE_H
+
+#include "../defines.h"
+
+typedef enum BzModule {
+    BZ_MODULE_LOGGER,
+    BZ_MODULE_APPLICATION,
+    BZ_MODULE_INPUT,
+    BZ_ENGINE_MODULE_COUNT
+} BzModule;
+
+bool bzModuleIsAllocated(BzModule module);
+void *bzModuleRetrieve(BzModule module);
+void *bzModuleAllocate(BzModule module, size_t sizeBytes);
+void bzModuleFree(BzModule module);
+
+#endif //BREEZE_MODULE_H