--no-sanity-timer option and its use in twn gdb

CMakeLists.txt

@@ -97,7 +97,7 @@ set(TWN_NONOPT_SOURCE_FILES
         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/twn_workers.c         src/twn_workers_c.h
+        src/twn_workers.c       src/twn_workers_c.h
 
         src/rendering/twn_draw.c src/rendering/twn_draw_c.h
         src/rendering/twn_quads.c
@@ -108,7 +108,7 @@ set(TWN_NONOPT_SOURCE_FILES
         src/rendering/twn_billboards.c
         src/rendering/twn_circles.c
         src/rendering/twn_skybox.c
-        src/rendering/twn_model.c
+        src/rendering/twn_models.c
 )
 
 set(TWN_SOURCE_FILES
@@ -159,8 +159,6 @@ function(give_options_without_warnings target)
                 -O3
                 -flto=$<IF:$<STREQUAL:${CMAKE_C_COMPILER_ID},Clang>,thin,auto>
                 -mavx -mavx2
-                -fdata-sections
-                -ffunction-sections
                 -funroll-loops
                 -fomit-frame-pointer
                 $<$<STREQUAL:${CMAKE_C_COMPILER_ID},Gnu>:-s>)
@@ -173,6 +171,10 @@ function(give_options_without_warnings target)
 		$<$<BOOL:${TWN_SANITIZE}>:-fstack-protector-all -fsanitize=undefined -fsanitize=address>
                 $<$<BOOL:${EMSCRIPTEN}>:-gsource-map>)
 
+        set(LINK_FLAGS_RELEASE
+                $<$<STREQUAL:${CMAKE_C_COMPILER_ID},Clang>:-Wl,--strip-all>
+                ${BUILD_FLAGS_RELEASE})
+
         if (CMAKE_C_COMPILER_LINKER_ID MATCHES GNU OR CMAKE_C_COMPILER_LINKER_ID MATCHES GNUgold)
                 set(THINLTO_USAGE "-plugin-opt,")
         endif()
@@ -194,7 +196,7 @@ function(give_options_without_warnings target)
         target_link_options(${target} PUBLIC
                                       ${BUILD_FLAGS}
                                       # -Wl,--no-undefined # TODO: use later for implementing no-libc
-                                      $<$<CONFIG:Release>:${BUILD_FLAGS_RELEASE}>
+                                      $<$<CONFIG:Release>:${LINK_FLAGS_RELEASE}>
                                       $<$<CONFIG:Debug>:${BUILD_FLAGS_DEBUG}>
                                       -Bsymbolic-functions
                                       -Wl,--as-needed
@@ -207,6 +209,9 @@ function(give_options_without_warnings target)
 
                 target_link_options(${target} PUBLIC
                                               $<$<CONFIG:Release>:${BUILD_SHARED_LIBRARY_FLAGS_RELEASE}>)
+        elseif(CMAKE_BUILD_TYPE MATCHES Release)
+                target_compile_options(${target} PUBLIC
+                                                 $<$<STREQUAL:${CMAKE_C_COMPILER_ID},Clang>:-mllvm=--enable-gvn-hoist>)
         endif()
 
         target_compile_definitions(${target} PRIVATE
@@ -237,6 +242,7 @@ function(give_options target)
                 -Werror=vla
                 -Wno-missing-field-initializers
                 -Wunused-result
+                -Wno-pre-c11-compat
                 $<$<STREQUAL:${CMAKE_C_COMPILER_ID},Gnu>:-Wcast-align=strict>)
 
         target_compile_options(${target} PRIVATE

apps/demos/scenery/scenes/ingame.c

@@ -197,7 +197,9 @@ static void ingame_tick(State *state) {
     input_action("mouse_capture_toggle", "ESCAPE");
     input_action("toggle_camera_mode", "C");
 
-    draw_model("models/test.obj", (Vec3){0}, (Vec3){0,0,1}, (Vec3){1,1,1});
+    // draw_model("models/test.obj", (Vec3){0}, (Vec3){0,0,1}, (Vec3){1.f / 64,1.f / 64,1.f / 64});
+    // draw_model("models/test2.obj", (Vec3){0}, (Vec3){0,0,1}, (Vec3){1.f / 64,1.f / 64,1.f / 64});
+    // draw_model("models/bunny.obj", (Vec3){0}, (Vec3){0,0,1}, (Vec3){4.,4.,4.});
 
     if (scn->mouse_captured) {
         const float sensitivity = 0.4f * (float)DEG2RAD; /* TODO: put this in a better place */

apps/twnlua/CMakeLists.txt

@@ -13,7 +13,7 @@ set(FLAGS
 )
 
 add_custom_command(
-   OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/luabind.c
+   OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/game.c
    COMMAND ${PYTHON3} ${CMAKE_CURRENT_SOURCE_DIR}/bindgen.py $ENV{TWNROOT}/share/twn_api.json ${FLAGS} > ${CMAKE_CURRENT_SOURCE_DIR}/luabind.c
    DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/bindgen.py $ENV{TWNROOT}/share/twn_api.json
    CODEGEN
@@ -30,13 +30,11 @@ add_custom_target(
     DEPENDS ${TWN_OUT_DIR}/data/scripts/twnapi.lua
 )
 
-add_compile_definitions(LUA_32BITS)
+add_compile_definitions(LUA_32BITS=1)
 
 set(SOURCE_FILES
         game.c
         state.h
-        minilua.c
-        ${CMAKE_CURRENT_SOURCE_DIR}/luabind.c
 )
 
 use_townengine("${SOURCE_FILES}" ${TWN_OUT_DIR})

apps/twnlua/bindgen.py

@@ -36,7 +36,7 @@ def to_table(typedesc, variable, indent = 0):
     binding = ' ' * indent + "lua_createtable(L, 0, %i);\n" % len(typedesc["fields"])
     for field in typedesc["fields"]:
         if field["type"] == "float" or field["type"] == "uint8_t":
-            binding += ' ' * indent + "lua_pushnumber(L, (double)(%s));\n" % (variable + ".%s" % field["name"])
+            binding += ' ' * indent + "lua_pushnumber(L, (float)(%s));\n" % (variable + ".%s" % field["name"])
         elif field["type"] == "bool":
             binding += ' ' * indent + "lua_pushboolean(L, (%s));\n" % (variable + ".%s" % field["name"])
         elif field["type"] in api["types"]:
@@ -64,7 +64,7 @@ def from_table(typedesc, variable, indent = 0):
 
 
 print('#include "twn_game_api.h"\n')
-print('#include "minilua.h"\n')
+print('/* assumed to be included from game.c, where minilua.h is already present */\n')
 
 bindings, used_converters = [], {}
 for procedure, procedure_desc in api["procedures"].items():
@@ -109,7 +109,7 @@ for procedure, procedure_desc in api["procedures"].items():
         if procedure_desc["return"] == "bool":
             binding += "    lua_pushboolean(L, (int)(%s(%s)));\n" % (procedure, ", ".join(param["name"] for param in procedure_desc["params"]))
         elif procedure_desc["return"] == "float":
-            binding += "    lua_pushnumber(L, (double)(%s(%s)));\n" % (procedure, ", ".join(param["name"] for param in procedure_desc["params"]))
+            binding += "    lua_pushnumber(L, (float)(%s(%s)));\n" % (procedure, ", ".join(param["name"] for param in procedure_desc["params"]))
         elif procedure_desc["return"] == "char *":
             binding += "    lua_pushstring(L, %s(%s));\n" % (procedure, ", ".join(param["name"] for param in procedure_desc["params"]))
         elif type(procedure_desc["return"]) is dict or procedure_desc["return"] in api["types"]:

apps/twnlua/docgen.py

@@ -17,8 +17,6 @@ def to_lua_type_annot(typedesc):
         return "number"
     elif basetype == "bool":
         return "boolean"
-    elif basetype == "Control":
-        return "Control"
     elif basetype == "Vec2":
         return r"{ x: number, y: number }"
     elif basetype == "Vec3":
@@ -31,6 +29,7 @@ def to_lua_type_annot(typedesc):
         return "unknown"
         # raise BaseException("Unhandled type for annotation: %s" % typedesc)
 
+print("---@diagnostic disable")
 print("error(\"townengine lua api file is not supposed to be imported!\")")
 
 type_annotations = {}

apps/twnlua/game.c

@@ -1,7 +1,11 @@
 #include "twn_game_api.h"
-#include "state.h"
 
+#define LUA_IMPL
 #include "minilua.h"
+
+#include "state.h"
+#include "luabind.c"
+
 #include <SDL2/SDL.h>
 
 
@@ -43,10 +47,13 @@ static int physfs_loader(lua_State *L) {
     free(final_path);
 
     /* TODO: use reader interface for streaming instead */
-    int const result = luaL_loadbuffer(L, (char *)buf, buf_size, name) == LUA_OK;
+    int const result = luaL_loadbuffer(L, (char *)buf, buf_size, name);
     free(buf);
 
-    return result;
+    if (result != LUA_OK)
+        log_critical("%s", lua_tostring(L, -1));
+
+    return result == LUA_OK;
 }
 
 

apps/twnlua/minilua.c

@@ -1,2 +0,0 @@
-#define LUA_IMPL
-#include "minilua.h"

apps/twnlua/minilua.h

@@ -210,8 +210,9 @@ extern "C" {
 /*
 @@ LUA_32BITS enables Lua with 32-bit integers and 32-bit floats.
 */
+#if !defined(LUA_32BITS)
 #define LUA_32BITS	0
-
+#endif
 
 /*
 @@ LUA_C89_NUMBERS ensures that Lua uses the largest types available for
@@ -28631,696 +28632,6 @@ LUALIB_API void luaL_openlibs (lua_State *L) {
 #ifdef __cplusplus
 }
 #endif
-#ifdef LUA_MAKE_LUA
-/*
-** $Id: lua.c $
-** Lua stand-alone interpreter
-** See Copyright Notice in lua.h
-*/
-
-#define lua_c
-
-/*#include "lprefix.h"*/
-
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include <signal.h>
-
-/*#include "lua.h"*/
-
-/*#include "lauxlib.h"*/
-/*#include "lualib.h"*/
-
-
-#if !defined(LUA_PROGNAME)
-#define LUA_PROGNAME		"lua"
-#endif
-
-#if !defined(LUA_INIT_VAR)
-#define LUA_INIT_VAR		"LUA_INIT"
-#endif
-
-#define LUA_INITVARVERSION	LUA_INIT_VAR LUA_VERSUFFIX
-
-
-static lua_State *globalL = NULL;
-
-static const char *progname = LUA_PROGNAME;
-
-
-#if defined(LUA_USE_POSIX)   /* { */
-
-/*
-** Use 'sigaction' when available.
-*/
-static void setsignal (int sig, void (*handler)(int)) {
-  struct sigaction sa;
-  sa.sa_handler = handler;
-  sa.sa_flags = 0;
-  sigemptyset(&sa.sa_mask);  /* do not mask any signal */
-  sigaction(sig, &sa, NULL);
-}
-
-#else           /* }{ */
-
-#define setsignal            signal
-
-#endif                               /* } */
-
-
-/*
-** Hook set by signal function to stop the interpreter.
-*/
-static void lstop (lua_State *L, lua_Debug *ar) {
-  (void)ar;  /* unused arg. */
-  lua_sethook(L, NULL, 0, 0);  /* reset hook */
-  luaL_error(L, "interrupted!");
-}
-
-
-/*
-** Function to be called at a C signal. Because a C signal cannot
-** just change a Lua state (as there is no proper synchronization),
-** this function only sets a hook that, when called, will stop the
-** interpreter.
-*/
-static void laction (int i) {
-  int flag = LUA_MASKCALL | LUA_MASKRET | LUA_MASKLINE | LUA_MASKCOUNT;
-  setsignal(i, SIG_DFL); /* if another SIGINT happens, terminate process */
-  lua_sethook(globalL, lstop, flag, 1);
-}
-
-
-static void print_usage (const char *badoption) {
-  lua_writestringerror("%s: ", progname);
-  if (badoption[1] == 'e' || badoption[1] == 'l')
-    lua_writestringerror("'%s' needs argument\n", badoption);
-  else
-    lua_writestringerror("unrecognized option '%s'\n", badoption);
-  lua_writestringerror(
-  "usage: %s [options] [script [args]]\n"
-  "Available options are:\n"
-  "  -e stat   execute string 'stat'\n"
-  "  -i        enter interactive mode after executing 'script'\n"
-  "  -l mod    require library 'mod' into global 'mod'\n"
-  "  -l g=mod  require library 'mod' into global 'g'\n"
-  "  -v        show version information\n"
-  "  -E        ignore environment variables\n"
-  "  -W        turn warnings on\n"
-  "  --        stop handling options\n"
-  "  -         stop handling options and execute stdin\n"
-  ,
-  progname);
-}
-
-
-/*
-** Prints an error message, adding the program name in front of it
-** (if present)
-*/
-static void l_message (const char *pname, const char *msg) {
-  if (pname) lua_writestringerror("%s: ", pname);
-  lua_writestringerror("%s\n", msg);
-}
-
-
-/*
-** Check whether 'status' is not OK and, if so, prints the error
-** message on the top of the stack.
-*/
-static int report (lua_State *L, int status) {
-  if (status != LUA_OK) {
-    const char *msg = lua_tostring(L, -1);
-    if (msg == NULL)
-      msg = "(error message not a string)";
-    l_message(progname, msg);
-    lua_pop(L, 1);  /* remove message */
-  }
-  return status;
-}
-
-
-/*
-** Message handler used to run all chunks
-*/
-static int msghandler (lua_State *L) {
-  const char *msg = lua_tostring(L, 1);
-  if (msg == NULL) {  /* is error object not a string? */
-    if (luaL_callmeta(L, 1, "__tostring") &&  /* does it have a metamethod */
-        lua_type(L, -1) == LUA_TSTRING)  /* that produces a string? */
-      return 1;  /* that is the message */
-    else
-      msg = lua_pushfstring(L, "(error object is a %s value)",
-                               luaL_typename(L, 1));
-  }
-  luaL_traceback(L, L, msg, 1);  /* append a standard traceback */
-  return 1;  /* return the traceback */
-}
-
-
-/*
-** Interface to 'lua_pcall', which sets appropriate message function
-** and C-signal handler. Used to run all chunks.
-*/
-static int docall (lua_State *L, int narg, int nres) {
-  int status;
-  int base = lua_gettop(L) - narg;  /* function index */
-  lua_pushcfunction(L, msghandler);  /* push message handler */
-  lua_insert(L, base);  /* put it under function and args */
-  globalL = L;  /* to be available to 'laction' */
-  setsignal(SIGINT, laction);  /* set C-signal handler */
-  status = lua_pcall(L, narg, nres, base);
-  setsignal(SIGINT, SIG_DFL); /* reset C-signal handler */
-  lua_remove(L, base);  /* remove message handler from the stack */
-  return status;
-}
-
-
-static void print_version (void) {
-  lua_writestring(LUA_COPYRIGHT, strlen(LUA_COPYRIGHT));
-  lua_writeline();
-}
-
-
-/*
-** Create the 'arg' table, which stores all arguments from the
-** command line ('argv'). It should be aligned so that, at index 0,
-** it has 'argv[script]', which is the script name. The arguments
-** to the script (everything after 'script') go to positive indices;
-** other arguments (before the script name) go to negative indices.
-** If there is no script name, assume interpreter's name as base.
-** (If there is no interpreter's name either, 'script' is -1, so
-** table sizes are zero.)
-*/
-static void createargtable (lua_State *L, char **argv, int argc, int script) {
-  int i, narg;
-  narg = argc - (script + 1);  /* number of positive indices */
-  lua_createtable(L, narg, script + 1);
-  for (i = 0; i < argc; i++) {
-    lua_pushstring(L, argv[i]);
-    lua_rawseti(L, -2, i - script);
-  }
-  lua_setglobal(L, "arg");
-}
-
-
-static int dochunk (lua_State *L, int status) {
-  if (status == LUA_OK) status = docall(L, 0, 0);
-  return report(L, status);
-}
-
-
-static int dofile (lua_State *L, const char *name) {
-  return dochunk(L, luaL_loadfile(L, name));
-}
-
-
-static int dostring (lua_State *L, const char *s, const char *name) {
-  return dochunk(L, luaL_loadbuffer(L, s, strlen(s), name));
-}
-
-
-/*
-** Receives 'globname[=modname]' and runs 'globname = require(modname)'.
-** If there is no explicit modname and globname contains a '-', cut
-** the suffix after '-' (the "version") to make the global name.
-*/
-static int dolibrary (lua_State *L, char *globname) {
-  int status;
-  char *suffix = NULL;
-  char *modname = strchr(globname, '=');
-  if (modname == NULL) {  /* no explicit name? */
-    modname = globname;  /* module name is equal to global name */
-    suffix = strchr(modname, *LUA_IGMARK);  /* look for a suffix mark */
-  }
-  else {
-    *modname = '\0';  /* global name ends here */
-    modname++;  /* module name starts after the '=' */
-  }
-  lua_getglobal(L, "require");
-  lua_pushstring(L, modname);
-  status = docall(L, 1, 1);  /* call 'require(modname)' */
-  if (status == LUA_OK) {
-    if (suffix != NULL)  /* is there a suffix mark? */
-      *suffix = '\0';  /* remove suffix from global name */
-    lua_setglobal(L, globname);  /* globname = require(modname) */
-  }
-  return report(L, status);
-}
-
-
-/*
-** Push on the stack the contents of table 'arg' from 1 to #arg
-*/
-static int pushargs (lua_State *L) {
-  int i, n;
-  if (lua_getglobal(L, "arg") != LUA_TTABLE)
-    luaL_error(L, "'arg' is not a table");
-  n = (int)luaL_len(L, -1);
-  luaL_checkstack(L, n + 3, "too many arguments to script");
-  for (i = 1; i <= n; i++)
-    lua_rawgeti(L, -i, i);
-  lua_remove(L, -i);  /* remove table from the stack */
-  return n;
-}
-
-
-static int handle_script (lua_State *L, char **argv) {
-  int status;
-  const char *fname = argv[0];
-  if (strcmp(fname, "-") == 0 && strcmp(argv[-1], "--") != 0)
-    fname = NULL;  /* stdin */
-  status = luaL_loadfile(L, fname);
-  if (status == LUA_OK) {
-    int n = pushargs(L);  /* push arguments to script */
-    status = docall(L, n, LUA_MULTRET);
-  }
-  return report(L, status);
-}
-
-
-/* bits of various argument indicators in 'args' */
-#define has_error	1	/* bad option */
-#define has_i		2	/* -i */
-#define has_v		4	/* -v */
-#define has_e		8	/* -e */
-#define has_E		16	/* -E */
-
-
-/*
-** Traverses all arguments from 'argv', returning a mask with those
-** needed before running any Lua code or an error code if it finds any
-** invalid argument. In case of error, 'first' is the index of the bad
-** argument.  Otherwise, 'first' is -1 if there is no program name,
-** 0 if there is no script name, or the index of the script name.
-*/
-static int collectargs (char **argv, int *first) {
-  int args = 0;
-  int i;
-  if (argv[0] != NULL) {  /* is there a program name? */
-    if (argv[0][0])  /* not empty? */
-      progname = argv[0];  /* save it */
-  }
-  else {  /* no program name */
-    *first = -1;
-    return 0;
-  }
-  for (i = 1; argv[i] != NULL; i++) {  /* handle arguments */
-    *first = i;
-    if (argv[i][0] != '-')  /* not an option? */
-        return args;  /* stop handling options */
-    switch (argv[i][1]) {  /* else check option */
-      case '-':  /* '--' */
-        if (argv[i][2] != '\0')  /* extra characters after '--'? */
-          return has_error;  /* invalid option */
-        *first = i + 1;
-        return args;
-      case '\0':  /* '-' */
-        return args;  /* script "name" is '-' */
-      case 'E':
-        if (argv[i][2] != '\0')  /* extra characters? */
-          return has_error;  /* invalid option */
-        args |= has_E;
-        break;
-      case 'W':
-        if (argv[i][2] != '\0')  /* extra characters? */
-          return has_error;  /* invalid option */
-        break;
-      case 'i':
-        args |= has_i;  /* (-i implies -v) *//* FALLTHROUGH */
-      case 'v':
-        if (argv[i][2] != '\0')  /* extra characters? */
-          return has_error;  /* invalid option */
-        args |= has_v;
-        break;
-      case 'e':
-        args |= has_e;  /* FALLTHROUGH */
-      case 'l':  /* both options need an argument */
-        if (argv[i][2] == '\0') {  /* no concatenated argument? */
-          i++;  /* try next 'argv' */
-          if (argv[i] == NULL || argv[i][0] == '-')
-            return has_error;  /* no next argument or it is another option */
-        }
-        break;
-      default:  /* invalid option */
-        return has_error;
-    }
-  }
-  *first = 0;  /* no script name */
-  return args;
-}
-
-
-/*
-** Processes options 'e' and 'l', which involve running Lua code, and
-** 'W', which also affects the state.
-** Returns 0 if some code raises an error.
-*/
-static int runargs (lua_State *L, char **argv, int n) {
-  int i;
-  for (i = 1; i < n; i++) {
-    int option = argv[i][1];
-    lua_assert(argv[i][0] == '-');  /* already checked */
-    switch (option) {
-      case 'e':  case 'l': {
-        int status;
-        char *extra = argv[i] + 2;  /* both options need an argument */
-        if (*extra == '\0') extra = argv[++i];
-        lua_assert(extra != NULL);
-        status = (option == 'e')
-                 ? dostring(L, extra, "=(command line)")
-                 : dolibrary(L, extra);
-        if (status != LUA_OK) return 0;
-        break;
-      }
-      case 'W':
-        lua_warning(L, "@on", 0);  /* warnings on */
-        break;
-    }
-  }
-  return 1;
-}
-
-
-static int handle_luainit (lua_State *L) {
-  const char *name = "=" LUA_INITVARVERSION;
-  const char *init = getenv(name + 1);
-  if (init == NULL) {
-    name = "=" LUA_INIT_VAR;
-    init = getenv(name + 1);  /* try alternative name */
-  }
-  if (init == NULL) return LUA_OK;
-  else if (init[0] == '@')
-    return dofile(L, init+1);
-  else
-    return dostring(L, init, name);
-}
-
-
-/*
-** {==================================================================
-** Read-Eval-Print Loop (REPL)
-** ===================================================================
-*/
-
-#if !defined(LUA_PROMPT)
-#define LUA_PROMPT		"> "
-#define LUA_PROMPT2		">> "
-#endif
-
-#if !defined(LUA_MAXINPUT)
-#define LUA_MAXINPUT		512
-#endif
-
-
-/*
-** lua_stdin_is_tty detects whether the standard input is a 'tty' (that
-** is, whether we're running lua interactively).
-*/
-#if !defined(lua_stdin_is_tty)	/* { */
-
-#if defined(LUA_USE_POSIX)	/* { */
-
-#include <unistd.h>
-#define lua_stdin_is_tty()	isatty(0)
-
-#elif defined(LUA_USE_WINDOWS)	/* }{ */
-
-#include <io.h>
-#include <windows.h>
-
-#define lua_stdin_is_tty()	_isatty(_fileno(stdin))
-
-#else				/* }{ */
-
-/* ISO C definition */
-#define lua_stdin_is_tty()	1  /* assume stdin is a tty */
-
-#endif				/* } */
-
-#endif				/* } */
-
-
-/*
-** lua_readline defines how to show a prompt and then read a line from
-** the standard input.
-** lua_saveline defines how to "save" a read line in a "history".
-** lua_freeline defines how to free a line read by lua_readline.
-*/
-#if !defined(lua_readline)	/* { */
-
-#if defined(LUA_USE_READLINE)	/* { */
-
-#include <readline/readline.h>
-#include <readline/history.h>
-#define lua_initreadline(L)	((void)L, rl_readline_name="lua")
-#define lua_readline(L,b,p)	((void)L, ((b)=readline(p)) != NULL)
-#define lua_saveline(L,line)	((void)L, add_history(line))
-#define lua_freeline(L,b)	((void)L, free(b))
-
-#else				/* }{ */
-
-#define lua_initreadline(L)  ((void)L)
-#define lua_readline(L,b,p) \
-        ((void)L, fputs(p, stdout), fflush(stdout),  /* show prompt */ \
-        fgets(b, LUA_MAXINPUT, stdin) != NULL)  /* get line */
-#define lua_saveline(L,line)	{ (void)L; (void)line; }
-#define lua_freeline(L,b)	{ (void)L; (void)b; }
-
-#endif				/* } */
-
-#endif				/* } */
-
-
-/*
-** Return the string to be used as a prompt by the interpreter. Leave
-** the string (or nil, if using the default value) on the stack, to keep
-** it anchored.
-*/
-static const char *get_prompt (lua_State *L, int firstline) {
-  if (lua_getglobal(L, firstline ? "_PROMPT" : "_PROMPT2") == LUA_TNIL)
-    return (firstline ? LUA_PROMPT : LUA_PROMPT2);  /* use the default */
-  else {  /* apply 'tostring' over the value */
-    const char *p = luaL_tolstring(L, -1, NULL);
-    lua_remove(L, -2);  /* remove original value */
-    return p;
-  }
-}
-
-/* mark in error messages for incomplete statements */
-#define EOFMARK		"<eof>"
-#define marklen		(sizeof(EOFMARK)/sizeof(char) - 1)
-
-
-/*
-** Check whether 'status' signals a syntax error and the error
-** message at the top of the stack ends with the above mark for
-** incomplete statements.
-*/
-static int incomplete (lua_State *L, int status) {
-  if (status == LUA_ERRSYNTAX) {
-    size_t lmsg;
-    const char *msg = lua_tolstring(L, -1, &lmsg);
-    if (lmsg >= marklen && strcmp(msg + lmsg - marklen, EOFMARK) == 0) {
-      lua_pop(L, 1);
-      return 1;
-    }
-  }
-  return 0;  /* else... */
-}
-
-
-/*
-** Prompt the user, read a line, and push it into the Lua stack.
-*/
-static int pushline (lua_State *L, int firstline) {
-  char buffer[LUA_MAXINPUT];
-  char *b = buffer;
-  size_t l;
-  const char *prmt = get_prompt(L, firstline);
-  int readstatus = lua_readline(L, b, prmt);
-  if (readstatus == 0)
-    return 0;  /* no input (prompt will be popped by caller) */
-  lua_pop(L, 1);  /* remove prompt */
-  l = strlen(b);
-  if (l > 0 && b[l-1] == '\n')  /* line ends with newline? */
-    b[--l] = '\0';  /* remove it */
-  if (firstline && b[0] == '=')  /* for compatibility with 5.2, ... */
-    lua_pushfstring(L, "return %s", b + 1);  /* change '=' to 'return' */
-  else
-    lua_pushlstring(L, b, l);
-  lua_freeline(L, b);
-  return 1;
-}
-
-
-/*
-** Try to compile line on the stack as 'return <line>;'; on return, stack
-** has either compiled chunk or original line (if compilation failed).
-*/
-static int addreturn (lua_State *L) {
-  const char *line = lua_tostring(L, -1);  /* original line */
-  const char *retline = lua_pushfstring(L, "return %s;", line);
-  int status = luaL_loadbuffer(L, retline, strlen(retline), "=stdin");
-  if (status == LUA_OK) {
-    lua_remove(L, -2);  /* remove modified line */
-    if (line[0] != '\0')  /* non empty? */
-      lua_saveline(L, line);  /* keep history */
-  }
-  else
-    lua_pop(L, 2);  /* pop result from 'luaL_loadbuffer' and modified line */
-  return status;
-}
-
-
-/*
-** Read multiple lines until a complete Lua statement
-*/
-static int multiline (lua_State *L) {
-  for (;;) {  /* repeat until gets a complete statement */
-    size_t len;
-    const char *line = lua_tolstring(L, 1, &len);  /* get what it has */
-    int status = luaL_loadbuffer(L, line, len, "=stdin");  /* try it */
-    if (!incomplete(L, status) || !pushline(L, 0)) {
-      lua_saveline(L, line);  /* keep history */
-      return status;  /* cannot or should not try to add continuation line */
-    }
-    lua_pushliteral(L, "\n");  /* add newline... */
-    lua_insert(L, -2);  /* ...between the two lines */
-    lua_concat(L, 3);  /* join them */
-  }
-}
-
-
-/*
-** Read a line and try to load (compile) it first as an expression (by
-** adding "return " in front of it) and second as a statement. Return
-** the final status of load/call with the resulting function (if any)
-** in the top of the stack.
-*/
-static int loadline (lua_State *L) {
-  int status;
-  lua_settop(L, 0);
-  if (!pushline(L, 1))
-    return -1;  /* no input */
-  if ((status = addreturn(L)) != LUA_OK)  /* 'return ...' did not work? */
-    status = multiline(L);  /* try as command, maybe with continuation lines */
-  lua_remove(L, 1);  /* remove line from the stack */
-  lua_assert(lua_gettop(L) == 1);
-  return status;
-}
-
-
-/*
-** Prints (calling the Lua 'print' function) any values on the stack
-*/
-static void l_print (lua_State *L) {
-  int n = lua_gettop(L);
-  if (n > 0) {  /* any result to be printed? */
-    luaL_checkstack(L, LUA_MINSTACK, "too many results to print");
-    lua_getglobal(L, "print");
-    lua_insert(L, 1);
-    if (lua_pcall(L, n, 0, 0) != LUA_OK)
-      l_message(progname, lua_pushfstring(L, "error calling 'print' (%s)",
-                                             lua_tostring(L, -1)));
-  }
-}
-
-
-/*
-** Do the REPL: repeatedly read (load) a line, evaluate (call) it, and
-** print any results.
-*/
-static void doREPL (lua_State *L) {
-  int status;
-  const char *oldprogname = progname;
-  progname = NULL;  /* no 'progname' on errors in interactive mode */
-  lua_initreadline(L);
-  while ((status = loadline(L)) != -1) {
-    if (status == LUA_OK)
-      status = docall(L, 0, LUA_MULTRET);
-    if (status == LUA_OK) l_print(L);
-    else report(L, status);
-  }
-  lua_settop(L, 0);  /* clear stack */
-  lua_writeline();
-  progname = oldprogname;
-}
-
-/* }================================================================== */
-
-
-/*
-** Main body of stand-alone interpreter (to be called in protected mode).
-** Reads the options and handles them all.
-*/
-static int pmain (lua_State *L) {
-  int argc = (int)lua_tointeger(L, 1);
-  char **argv = (char **)lua_touserdata(L, 2);
-  int script;
-  int args = collectargs(argv, &script);
-  int optlim = (script > 0) ? script : argc; /* first argv not an option */
-  luaL_checkversion(L);  /* check that interpreter has correct version */
-  if (args == has_error) {  /* bad arg? */
-    print_usage(argv[script]);  /* 'script' has index of bad arg. */
-    return 0;
-  }
-  if (args & has_v)  /* option '-v'? */
-    print_version();
-  if (args & has_E) {  /* option '-E'? */
-    lua_pushboolean(L, 1);  /* signal for libraries to ignore env. vars. */
-    lua_setfield(L, LUA_REGISTRYINDEX, "LUA_NOENV");
-  }
-  luaL_openlibs(L);  /* open standard libraries */
-  createargtable(L, argv, argc, script);  /* create table 'arg' */
-  lua_gc(L, LUA_GCRESTART);  /* start GC... */
-  lua_gc(L, LUA_GCGEN, 0, 0);  /* ...in generational mode */
-  if (!(args & has_E)) {  /* no option '-E'? */
-    if (handle_luainit(L) != LUA_OK)  /* run LUA_INIT */
-      return 0;  /* error running LUA_INIT */
-  }
-  if (!runargs(L, argv, optlim))  /* execute arguments -e and -l */
-    return 0;  /* something failed */
-  if (script > 0) {  /* execute main script (if there is one) */
-    if (handle_script(L, argv + script) != LUA_OK)
-      return 0;  /* interrupt in case of error */
-  }
-  if (args & has_i)  /* -i option? */
-    doREPL(L);  /* do read-eval-print loop */
-  else if (script < 1 && !(args & (has_e | has_v))) { /* no active option? */
-    if (lua_stdin_is_tty()) {  /* running in interactive mode? */
-      print_version();
-      doREPL(L);  /* do read-eval-print loop */
-    }
-    else dofile(L, NULL);  /* executes stdin as a file */
-  }
-  lua_pushboolean(L, 1);  /* signal no errors */
-  return 1;
-}
-
-
-int main (int argc, char **argv) {
-  int status, result;
-  lua_State *L = luaL_newstate();  /* create state */
-  if (L == NULL) {
-    l_message(argv[0], "cannot create state: not enough memory");
-    return EXIT_FAILURE;
-  }
-  lua_gc(L, LUA_GCSTOP);  /* stop GC while building state */
-  lua_pushcfunction(L, &pmain);  /* to call 'pmain' in protected mode */
-  lua_pushinteger(L, argc);  /* 1st argument */
-  lua_pushlightuserdata(L, argv); /* 2nd argument */
-  status = lua_pcall(L, 2, 1, 0);  /* do the call */
-  result = lua_toboolean(L, -1);  /* get result */
-  report(L, status);
-  lua_close(L);
-  return (result && status == LUA_OK) ? EXIT_SUCCESS : EXIT_FAILURE;
-}
-
-#endif /* LUA_MAKE_LUA */
 
 /*
   MIT License

bin/twn

@@ -15,7 +15,7 @@ case "$1" in
                ;;
 
     gdb      ) unset DEBUGINFOD_URLS
-               $0 build && gdb --se=libgame.so -ex run --args "$(basename $PWD)" "${@:2}"
+               $0 build && gdb --se=libgame.so -ex run --args "$(basename $PWD)" --no-sanity-timer "${@:2}"
                ;;
 
     init     ) cp -r "$TWNROOT/apps/templates/$2" "$3"

docs/wiki/about-townengine.html

@@ -5,7 +5,7 @@
     <link rel="stylesheet" href="style.css">
   </head>
   <body>
-    <h1 style="margin-bottom:0in;">T1. About Townengine</h1>
+    <h1 style="margin-bottom:0in">T1. About Townengine<span style="float:right">{twn}</h1>
     <a href="index.html">Go back
     <p><a name="introduction"></a><strong>T1.1 </strong><strong>Introduction</strong>
     <blockquote>

docs/wiki/index.html

@@ -5,7 +5,7 @@
     <link rel="stylesheet" href="style.css">
   </head>
   <body>
-    <h1 style="margin-bottom:0in">Townengine Wiki</h1>
+    <h1 style="margin-bottom:0in">Townengine Wiki<span style="float:right">{twn}</span></h1>
     <a>Awesomeness</a>
     <table style="padding-top:1em">
         <tr><td>T1.</strong> <a href="#about-townengine">About Townengnine</a></td>

docs/wiki/input-system.html

@@ -5,7 +5,7 @@
     <link rel="stylesheet" href="style.css">
   </head>
   <body>
-    <h1 style="margin-bottom:0in;">T2. Input System</h1>
+    <h1 style="margin-bottom:0in">T2. Input System<span style="float:right">{twn}</span></h1>
     <a href="index.html">Go back
     <p><a name="design"></a><strong>T2.1 </strong><strong>Design</strong>
     <blockquote>

docs/wiki/template.html

@@ -5,7 +5,7 @@
     <link rel="stylesheet" href="style.css">
   </head>
   <body>
-    <h1 style="margin-bottom:0in;">X1. {About}</h1>
+    <h1 style="margin-bottom:0in">X1. {About}<span style="float:right">{twn}</span></h1>
     <a href="index.html">Go back
     <p><a name="{Section}"></a><strong>X1.1 </strong><strong>{Section}</strong>
     <blockquote>

src/game_object/twn_dynamic_game_object.c

@@ -22,7 +22,7 @@ static void *handle = NULL;
 static void game_object_file_action(char const *path, enum FilewatchAction action) {
     (void)action;
 
-    if (action == FILEWATCH_ACTION_FILE_DELETED)
+    if (action != FILEWATCH_ACTION_FILE_CREATED)
         return;
 
     if (handle) {
@@ -76,7 +76,7 @@ void game_object_load(void) {
         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);
+        game_object_file_action(game_object_path, FILEWATCH_ACTION_FILE_CREATED);
         SDL_free(game_object_path);
         filewatch_attached = true;
     }

src/rendering/twn_draw.c

@@ -415,7 +415,9 @@ static void render_space(void) {
 
 
 void render(void) {
+    models_update_pre_textures();
     textures_update_atlas(&ctx.texture_cache);
+    models_update_post_textures();
 
     /* fit rendering context onto the resizable screen */
     if (ctx.window_size_has_changed) {
@@ -471,7 +473,6 @@ void draw_camera(Vec3 position, Vec3 direction, Vec3 up, float fov, float zoom)
 
 
 /* TODO: https://stackoverflow.com/questions/62493770/how-to-add-roll-in-camera-class */
-/* TODO: check for NaNs and alike */
 /* TODOL call draw_camera() instead, to reuse the code */
 DrawCameraFromPrincipalAxesResult draw_camera_from_principal_axes(Vec3 position,
                                                                   float roll,
@@ -491,31 +492,19 @@ DrawCameraFromPrincipalAxesResult draw_camera_from_principal_axes(Vec3 position,
     sincosf(yaw + (float)M_PI_2, &yaws, &yawc);
     sincosf(pitch, &pitchs, &pitchc);
 
-    Camera const camera = {
-        .fov = fov,
-        .pos = position,
-        .target = vec3_norm(((Vec3){
-            yawc * pitchc,
-            pitchs,
-            yaws * pitchc,
-        })),
-        .up = (Vec3){0, 1, 0},
-        .viewbox = {
-            (Vec2){ 1/-zoom, 1/zoom },
-            (Vec2){ 1/zoom, 1/-zoom }
-        },
-    };
+    Vec3 const direction = vec3_norm(((Vec3){
+        yawc * pitchc,
+        pitchs,
+        yaws * pitchc,
+    }));
 
-    if (!orthographic)
-        camera_projection_matrix = camera_perspective(&camera);
-    else
-        camera_projection_matrix = camera_orthographic(&camera);
+    Vec3 const up = (Vec3){0, 1, 0};
 
-    camera_look_at_matrix = camera_look_at(&camera);
+    draw_camera(position, direction, up, fov, zoom);
 
     return (DrawCameraFromPrincipalAxesResult) {
-        .direction = camera.target,
-        .up = camera.up,
+        .direction = direction,
+        .up = up,
     };
 }
 

src/rendering/twn_draw_c.h

@@ -228,6 +228,8 @@ typedef struct ElementIndexedBillboard {
 } ElementIndexedBillboard;
 
 
+/* state */
+
 bool render_init(void);
 
 /* renders the background, then the primitives in all render queues */
@@ -236,26 +238,20 @@ void render(void);
 /* clears all render queues */
 void render_clear(void);
 
-/* fills two existing arrays with the geometry data of a circle */
-/* the size of indices must be at least 3 times the number of vertices */
-void create_circle_geometry(Vec2 position,
-                            float radius,
-                            size_t num_vertices,
-                            Vec2 vertices[]);
+void setup_viewport(int x, int y, int width, int height);
 
-struct QuadBatch {
-    size_t size;             /* how many primitives are in current batch */
-    TextureKey texture_key;
-    TextureMode mode;        /* how color should be applied */
-    bool constant_colored;   /* whether colored batch is uniformly colored */
-    bool repeat;             /* whether repeat is needed */
-    bool textured;
-} collect_quad_batch(const Primitive2D primitives[], size_t len);
-void render_quad_batch(const Primitive2D primitives[], struct QuadBatch batch);
-struct QuadBatch collect_sprite_batch(const Primitive2D primitives[], size_t len);
-struct QuadBatch collect_rect_batch(const Primitive2D primitives[], size_t len);
-void render_sprite_batch(const Primitive2D primitives[], struct QuadBatch batch);
-void render_rect_batch(const Primitive2D primitives[], struct QuadBatch batch);
+void clear_draw_buffer(void);
+void finally_clear_draw_buffer(DeferredCommandClear command);
+
+void swap_buffers(void);
+
+void set_depth_range(double low, double high);
+
+void start_render_frame(void);
+void end_render_frame(void);
+
+void finally_draw_command(DeferredCommandDraw command);
+void issue_deferred_draw_commands(void);
 
 /* text */
 
@@ -279,21 +275,32 @@ void delete_vertex_buffer(VertexBuffer buffer);
 
 void specify_vertex_buffer(VertexBuffer buffer, void const *data, size_t bytes);
 
-/* uses present in 1.5 buffer mapping feature */
 VertexBufferBuilder build_vertex_buffer(VertexBuffer buffer, size_t bytes);
 
 void finish_vertex_builder(VertexBufferBuilder *builder);
 
-/* state */
+/* 2d */
 
-void setup_viewport(int x, int y, int width, int height);
+/* fills two existing arrays with the geometry data of a circle */
+/* the size of indices must be at least 3 times the number of vertices */
+void create_circle_geometry(Vec2 position,
+                            float radius,
+                            size_t num_vertices,
+                            Vec2 vertices[]);
 
-void clear_draw_buffer(void);
-void finally_clear_draw_buffer(DeferredCommandClear command);
-
-void swap_buffers(void);
-
-void set_depth_range(double low, double high);
+struct QuadBatch {
+    size_t size;             /* how many primitives are in current batch */
+    TextureKey texture_key;
+    TextureMode mode;        /* how color should be applied */
+    bool constant_colored;   /* whether colored batch is uniformly colored */
+    bool repeat;             /* whether repeat is needed */
+    bool textured;
+} collect_quad_batch(const Primitive2D primitives[], size_t len);
+void render_quad_batch(const Primitive2D primitives[], struct QuadBatch batch);
+struct QuadBatch collect_sprite_batch(const Primitive2D primitives[], size_t len);
+struct QuadBatch collect_rect_batch(const Primitive2D primitives[], size_t len);
+void render_sprite_batch(const Primitive2D primitives[], struct QuadBatch batch);
+void render_rect_batch(const Primitive2D primitives[], struct QuadBatch batch);
 
 VertexBuffer get_quad_element_buffer(void);
 
@@ -318,30 +325,29 @@ void push_quad_payload_to_vertex_buffer_builder(struct QuadBatch batch,
                                                 Vec2 uv0, Vec2 uv1, Vec2 uv2, Vec2 uv3,
                                                 Color color);
 
+void finally_draw_text(FontData const *font_data,
+                       size_t len,
+                       Color color,
+                       VertexBuffer buffer);
+
+/* 3d */
+
 void finally_draw_uncolored_space_traingle_batch(MeshBatch const *batch,
                                                  TextureKey texture_key);
 
 void finally_draw_billboard_batch(MeshBatch const *batch,
                                   TextureKey texture_key);
 
-void finally_draw_text(FontData const *font_data,
-                       size_t len,
-                       Color color,
-                       VertexBuffer buffer);
-
 void render_skybox(void);
 void finally_render_skybox(DeferredCommandDrawSkybox);
 
-void start_render_frame(void);
-void end_render_frame(void);
-
-void finally_draw_command(DeferredCommandDraw command);
-
-void issue_deferred_draw_commands(void);
-
-bool model_load_workers_thread(void);
+bool models_load_workers_finished(void);
+bool models_load_workers_thread(void);
 void finally_draw_models(void);
 void free_model_cache(void);
-void model_state_deinit(void);
+void models_state_init(void);
+void models_state_deinit(void);
+void models_update_pre_textures(void);
+void models_update_post_textures(void);
 
 #endif

src/rendering/twn_gl_15_rendering.c

@@ -35,7 +35,7 @@ static void APIENTRY opengl_log(GLenum source,
 
 
 bool render_init(void) {
-    if (gladLoadGL() == 0) {
+    if (gladLoadGLLoader(&SDL_GL_GetProcAddress) == 0) {
         CRY("Init", "GLAD failed");
         return false;
     }
@@ -175,7 +175,7 @@ static void finally_use_2d_pipeline(void) {
     pipeline_last_used = PIPELINE_2D;
 }
 
-
+/* TODO: ensure we minimize depth func switching to enable Hi-Z (hierarchical depth) optimizations */
 static void finally_use_texture_mode(TextureMode mode) {
     if (texture_mode_last_used == mode)
         return;

src/rendering/twn_gl_any_rendering.c

@@ -119,11 +119,14 @@ GLuint get_scratch_vertex_array(void) {
 }
 
 
-GPUTexture create_gpu_texture(TextureFilter filter, bool generate_mipmaps) {
+GPUTexture create_gpu_texture(TextureFilter filter, bool generate_mipmaps, int channels, int width, int height) {
     GLuint texture;
     glGenTextures(1, &texture);
     glBindTexture(GL_TEXTURE_2D, texture);
 
+    SDL_assert(width > 0 && height > 0);
+    SDL_assert(channels > 0 && channels <= 4);
+
 #if !defined(EMSCRIPTEN)
     glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, (GLboolean)generate_mipmaps);
 #else
@@ -146,19 +149,6 @@ GPUTexture create_gpu_texture(TextureFilter filter, bool generate_mipmaps) {
     glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
 #endif
 
-    glBindTexture(GL_TEXTURE_2D, 0);
-    return texture;
-}
-
-
-void delete_gpu_texture(GPUTexture texture) {
-    glDeleteTextures(1, &texture);
-}
-
-
-void upload_gpu_texture(GPUTexture texture, void *pixels, int channels, int width, int height) {
-    glBindTexture(GL_TEXTURE_2D, texture);
-
     int format_internal, format;
     if (channels == 4) {
         #ifdef EMSCRIPTEN
@@ -179,9 +169,11 @@ void upload_gpu_texture(GPUTexture texture, void *pixels, int channels, int widt
         format = GL_ALPHA;
     } else {
         CRY("upload_gpu_texture", "Unsupported channel count");
-        return;
+        format_internal = GL_ALPHA;
+        format = GL_ALPHA;
     }
 
+    /* preallocate texture storage in advance */
     glTexImage2D(GL_TEXTURE_2D,
                  0,
                  format_internal,
@@ -190,7 +182,42 @@ void upload_gpu_texture(GPUTexture texture, void *pixels, int channels, int widt
                  0,
                  format,
                  GL_UNSIGNED_BYTE,
-                 pixels);
+                 NULL);
+
+    glBindTexture(GL_TEXTURE_2D, 0);
+    return texture;
+}
+
+
+void delete_gpu_texture(GPUTexture texture) {
+    glDeleteTextures(1, &texture);
+}
+
+
+void upload_gpu_texture(GPUTexture texture, void *pixels, int channels, int width, int height) {
+    glBindTexture(GL_TEXTURE_2D, texture);
+
+    int format;
+    if (channels == 4) {
+        format = GL_RGBA;
+    } else if (channels == 3) {
+        format = GL_RGB;
+    } else if (channels == 1) {
+        format = GL_ALPHA;
+    } else {
+        CRY("upload_gpu_texture", "Unsupported channel count");
+        return;
+    }
+
+    glTexSubImage2D(GL_TEXTURE_2D,
+                    0,
+                    0,
+                    0,
+                    width,
+                    height,
+                    format,
+                    GL_UNSIGNED_BYTE,
+                    pixels);
 
     glBindTexture(GL_TEXTURE_2D, 0);
 }

src/rendering/twn_gpu_texture_c.h

@@ -11,7 +11,8 @@ typedef enum TextureFilter {
     TEXTURE_FILTER_LINEAR,
 } TextureFilter;
 
-GPUTexture create_gpu_texture(TextureFilter filter, bool generate_mipmaps);
+/* allocate a texture storage with constant parameters */
+GPUTexture create_gpu_texture(TextureFilter filter, bool generate_mipmaps, int channels, int width, int height);
 
 void delete_gpu_texture(GPUTexture texture);
 

src/rendering/twn_model.c

@@ -1,6 +1,7 @@
 #include "twn_draw_c.h"
 #include "twn_draw.h"
 #include "twn_workers_c.h"
+#include "twn_textures_c.h"
 
 #define FAST_OBJ_IMPLEMENTATION
 #define FAST_OBJ_REALLOC SDL_realloc
@@ -29,6 +30,7 @@ static struct ModelDrawCommand {
 /* deferred queue of model files to load from worker threads */
 static SDL_mutex *model_load_mutex;
 static char const **model_load_queue;
+static size_t model_load_queued;
 static bool model_load_initialized;
 
 /* use streaming via callbacks to reduce memory congestion */
@@ -55,10 +57,11 @@ static unsigned long model_load_callback_size(void *handle, void *udata) {
 
 /* TODO: is there a way to do this nicely while locking main thread? */
 /*       sleeping over atomic counter might be good enough i guess */
+/* it's safe to access everything without lock after this returns true and no public api is possible to call */
 static bool model_load_workers_finished(void) {
     bool result;
     SDL_LockMutex(model_load_mutex);
-    result = arrlenu(model_load_queue) == 0;
+    result = model_load_queued == 0;
     SDL_UnlockMutex(model_load_mutex);
     return result;
 }
@@ -84,12 +87,12 @@ bool model_load_workers_thread(void) {
         .file_size = model_load_callback_size
     };
 
-    /* TODO: immediately create jobs for missing textures */
-    fastObjMesh *mesh = fast_obj_read_with_callbacks(load_request, &callbacks, NULL);
+    fastObjMesh *const mesh = fast_obj_read_with_callbacks(load_request, &callbacks, NULL);
 
     SDL_LockMutex(model_load_mutex);
     struct ModelCacheItem *item = shgetp(model_cache, load_request);
     item->value.mesh = mesh;
+    model_load_queued--;
     SDL_UnlockMutex(model_load_mutex);
 
     return true;
@@ -108,12 +111,14 @@ void draw_model(const char *model,
 
     struct ModelCacheItem const *item;
 
+    /* TODO: make it lockless */
     /* if model is missing, queue it up for loading */
     SDL_LockMutex(model_load_mutex);
     if (!(item = shgetp_null(model_cache, model))) {
         model = SDL_strdup(model);
         shput(model_cache, model, (struct ModelCacheItemValue){0});
         arrpush(model_load_queue, model);
+        model_load_queued++;
         SDL_SemPost(workers_job_semaphore);
     } else
         model = item->key;
@@ -130,14 +135,14 @@ void draw_model(const char *model,
 
 
 void finally_draw_models(void) {
-    while (!model_load_workers_finished()) {
-        (void)0;
-    }
+    while (!model_load_workers_finished())
+        SDL_Delay(1);
 
     /* TODO: have special path for them, preserving the buffers and potentially using instanced draw */
     for (int i = 0; i < arrlen(model_draw_commands); ++i) {
         struct ModelDrawCommand const *const command = &model_draw_commands[i];
         fastObjMesh const *const mesh = model_cache[shgeti(model_cache, command->model)].value.mesh;
+        SDL_assert(mesh);
         for (unsigned int g = 0; g < mesh->group_count; ++g) {
             fastObjGroup const *const group = &mesh->groups[g];
             unsigned int idx = 0;
@@ -208,9 +213,8 @@ void finally_draw_models(void) {
 
 /* drop model caches */
 void free_model_cache(void) {
-    while (!model_load_workers_finished()) {
-        (void)0;
-    }
+    while (!model_load_workers_finished())
+        SDL_Delay(1);
 
     for (size_t i = 0; i < shlenu(model_cache); ++i) {
         fast_obj_destroy(model_cache[i].value.mesh);
@@ -222,7 +226,8 @@ void free_model_cache(void) {
 
 
 void model_state_deinit(void) {
-    SDL_assert(model_load_initialized);
+    if (!model_load_initialized)
+        return;
     free_model_cache();
     arrfree(model_load_queue);
     SDL_DestroyMutex(model_load_mutex);

src/rendering/twn_models.c

@@ -0,0 +1,396 @@
+#include "twn_draw_c.h"
+#include "twn_draw.h"
+#include "twn_engine_context_c.h"
+#include "twn_util.h"
+#include "twn_workers_c.h"
+#include "twn_textures_c.h"
+
+#define FAST_OBJ_IMPLEMENTATION
+#define FAST_OBJ_REALLOC SDL_realloc
+#define FAST_OBJ_FREE SDL_free
+#include <fast_obj.h>
+#include <stb_ds.h>
+#include <physfs.h>
+#include <physfsrwops.h>
+#include <SDL2/SDL.h>
+
+/* TODO: it might make sense to have a separate path for really small models, collecting them together */
+
+static struct ModelCacheItem {
+    char *key;
+    struct ModelCacheItemValue {
+        /* UncoloredSpaceTriangle to use indices against */
+        VertexBuffer vertices;
+
+        /* array or uint16_t or uint32_t, depending on length */
+        /* populated in such way that shared textures are combined into continuous range */
+        VertexBuffer *indices;
+
+        // /* note: this whole scheme only works without taking normals into account, but it's quite fast */
+        // struct ModelCacheIndexRange {
+        //     Rect srcrect;
+        //     size_t offset;
+        //     size_t length;
+        //     TextureKey texture;
+        // } *ranges;
+
+        /* cached base command, modified for ranges */
+        DeferredCommand *commands;
+    } value;
+} *model_cache;
+
+/* TODO: store index to model cache instead */
+static struct ModelDrawCommand {
+    char *model;
+    Vec3 position;
+    Vec3 rotation;
+    Vec3 scale;
+} *model_draw_commands;
+
+/* deferred queue of model files to load from worker threads */
+static SDL_mutex *model_load_mutex;
+static struct ModelLoadRequest {
+    char const *path;
+    fastObjMesh *mesh;
+    enum {
+        /* not yet started, only path is available */
+        MODEL_LOAD_REQUEST_WAITING,
+        /* initial load of data, unrelated to graphics state and thus applicable to running in worker threads */
+        MODEL_LOAD_REQUEST_LOADING,
+        /* mesh is loaded and awaits to be prepared and loaded onto gpu */
+        MODEL_LOAD_REQUEST_LOADED,
+    } stage;
+} *model_load_queue;
+static bool model_load_initialized;
+
+
+/* use streaming via callbacks to reduce memory congestion */
+static void model_load_callback_close(void *handle, void *udata) {
+    (void)udata;
+    ((SDL_RWops *)handle)->close(handle);
+}
+
+static void *model_load_callback_open(const char *path, void *udata) {
+    (void)udata;
+    return PHYSFSRWOPS_openRead(path);
+}
+
+static size_t model_load_callback_read(void *handle, void *dst, size_t bytes, void *udata) {
+    (void)udata;
+    return ((SDL_RWops *)handle)->read(handle, dst, 1, bytes);
+}
+
+static unsigned long model_load_callback_size(void *handle, void *udata) {
+    (void)udata;
+    return ((SDL_RWops *)handle)->size(handle);
+}
+
+
+/* it's safe to access everything without lock after this returns true and no public api is possible to call */
+bool models_load_workers_finished(void) {
+    bool result = true;
+    SDL_LockMutex(model_load_mutex);
+    for (size_t i = 0; i < arrlenu(model_load_queue); ++i) {
+        if (model_load_queue[i].stage != MODEL_LOAD_REQUEST_LOADED) {
+            result = false;
+            break;
+        }
+    }
+    SDL_UnlockMutex(model_load_mutex);
+    return result;
+}
+
+
+/* entry point for workers, polled every time a job semaphore is posted */
+/* returns false if there was nothing to do */
+bool models_load_workers_thread(void) {
+    /* attempt to grab something to work on */
+    char const *request_path = NULL;
+    ssize_t queue_index = -1;
+    SDL_LockMutex(model_load_mutex);
+    for (size_t i = 0; i < arrlenu(model_load_queue); ++i) {
+        if (model_load_queue[i].stage == MODEL_LOAD_REQUEST_WAITING) {
+            request_path = model_load_queue[i].path;
+            queue_index = i;
+            model_load_queue[i].stage = MODEL_LOAD_REQUEST_LOADING;
+            break;
+        }
+    }
+    SDL_UnlockMutex(model_load_mutex);
+    /* nothing to do, bail */
+    if (queue_index == -1)
+        return false;
+
+    fastObjCallbacks const callbacks = {
+        .file_close = model_load_callback_close,
+        .file_open = model_load_callback_open,
+        .file_read = model_load_callback_read,
+        .file_size = model_load_callback_size
+    };
+
+    /* TODO: would be nice if we could start dependency texture load immediately */
+    fastObjMesh *const mesh = fast_obj_read_with_callbacks(request_path, &callbacks, NULL);
+
+    SDL_LockMutex(model_load_mutex);
+    model_load_queue[queue_index].mesh = mesh;
+    model_load_queue[queue_index].stage = MODEL_LOAD_REQUEST_LOADED;
+    SDL_UnlockMutex(model_load_mutex);
+
+    return true;
+}
+
+
+void draw_model(const char *model,
+                Vec3 position,
+                Vec3 rotation,
+                Vec3 scale)
+{
+    /* TODO: make this all work. */
+    SDL_assert_always(false);
+
+    /* if model is missing, queue it up for loading */
+    struct ModelCacheItem const *item;
+    /* reuse the key from model_cache */
+    char *modelcopy;
+    if (!(item = shgetp_null(model_cache, model))) {
+        modelcopy = SDL_strdup(model);
+        shput(model_cache, modelcopy, (struct ModelCacheItemValue) {0});
+        SDL_LockMutex(model_load_mutex);
+        struct ModelLoadRequest const request = {
+            .stage = MODEL_LOAD_REQUEST_WAITING,
+            .path = modelcopy,
+        };
+        arrpush(model_load_queue, request);
+        SDL_UnlockMutex(model_load_mutex);
+        SDL_SemPost(workers_job_semaphore);
+    } else
+        modelcopy = item->key;
+
+    struct ModelDrawCommand const command = {
+        .model = modelcopy,
+        .position = position,
+        .rotation = rotation,
+        .scale = scale
+    };
+
+    arrpush(model_draw_commands, command);
+}
+
+
+/* prepare vertex buffers before textures are ready */
+void models_update_pre_textures(void) {
+    /* TODO: instead of waiting for all we could start uploading when there's something to upload */
+    /*       it's unlikely to happen, but could improve the worst cases */
+    while (!models_load_workers_finished())
+        SDL_Delay(1);
+
+    /* TODO: it might be better to parallelize this part by sending buffer mappings to workers */
+    for (size_t i = 0; i < arrlenu(model_load_queue); ++i) {
+        fastObjMesh *const mesh = model_load_queue[i].mesh;
+        SDL_assert(mesh && model_load_queue[i].stage == MODEL_LOAD_REQUEST_LOADED);
+        struct ModelCacheItem *const item = shgetp(model_cache, model_load_queue[i].path);
+
+        /* calculate required vertex and index buffers */
+        /* texture specific index buffers, to later me merged */
+        uint32_t **indices = NULL;
+        arrsetlen(indices, mesh->texture_count);
+        SDL_memset(indices, 0, mesh->texture_count * sizeof (uint32_t *));
+
+        /* vertices are shared for all subcommands */
+        struct ModelVertex {
+            Vec3 position;
+            Vec2 uv;
+        } *vertices = NULL;
+
+        for (unsigned int o = 0; o < mesh->object_count; ++o) {
+            /* we assume that vertices are only shared within the same object, */
+            /* which allows us to keep hash table small in most cases */
+            /* it should work great for quake style brush based models */
+            struct ModelVertexIndexItem {
+                struct ModelVertexIndexItemKey {
+                    uint32_t vertex_index;
+                    uint32_t uv_index;
+                } key;
+                uint32_t value; /* index to vertex */
+            } *merge_hash = NULL;
+
+            fastObjGroup const *const object = &mesh->objects[o];
+            size_t idx = 0;
+
+            for (unsigned int f = 0; f < object->face_count; ++f) {
+                unsigned int const fv = mesh->face_vertices[object->face_offset + f];
+                unsigned int const mi = mesh->face_materials[object->face_offset + f];
+                /* TODO: handle missing */
+                fastObjMaterial const *const m = mesh->materials ? &mesh->materials[mi] : NULL;
+
+                /* unwrap polygon fans into triangles, first point is reused for all following */
+                fastObjIndex const i0 = mesh->indices[object->index_offset + idx];
+                ptrdiff_t i0_hash = hmgeti(merge_hash, ((struct ModelVertexIndexItemKey) { i0.p, i0.t }));
+                if (i0_hash == -1) {
+                    hmput(merge_hash, ((struct ModelVertexIndexItemKey) { i0.p, i0.t }), arrlenu(vertices));
+                    arrpush(vertices, ((struct ModelVertex) {
+                        (Vec3) { mesh->positions[3 * i0.p + 0] / 64, mesh->positions[3 * i0.p + 1] / 64, mesh->positions[3 * i0.p + 2] / 64 },
+                        (Vec2) { mesh->texcoords[2 * i0.t + 0], mesh->texcoords[2 * i0.t + 1] }
+                    }));
+                    i0_hash = hmlen(merge_hash) - 1;
+                    // i0_hash = arrlenu(vertices) - 1;
+                }
+
+                /* other fan points over shifting by 1 window */
+                for (unsigned int t = 0; t < fv - 2; ++t) {
+                    fastObjIndex const i1 = mesh->indices[object->index_offset + idx + 1 + t];
+                    ptrdiff_t i1_hash = hmgeti(merge_hash, ((struct ModelVertexIndexItemKey) { i1.p, i1.t }));
+                    if (i1_hash == -1) {
+                        hmput(merge_hash, ((struct ModelVertexIndexItemKey) { i1.p, i1.t }), arrlenu(vertices));
+                        arrpush(vertices, ((struct ModelVertex) {
+                            (Vec3) { mesh->positions[3 * i1.p + 0] / 64, mesh->positions[3 * i1.p + 1] / 64, mesh->positions[3 * i1.p + 2] / 64 },
+                            (Vec2) { mesh->texcoords[2 * i1.t + 0], mesh->texcoords[2 * i1.t + 1] }
+                        }));
+                        i1_hash = hmlen(merge_hash) - 1;
+                        // i1_hash = arrlenu(vertices) - 1;
+                    }
+
+                    fastObjIndex const i2 = mesh->indices[object->index_offset + idx + 2 + t];
+                    ptrdiff_t i2_hash = hmgeti(merge_hash, ((struct ModelVertexIndexItemKey) { i2.p, i2.t }));
+                    if (i2_hash == -1) {
+                        hmput(merge_hash, ((struct ModelVertexIndexItemKey) { i2.p, i2.t }), arrlenu(vertices));
+                        arrpush(vertices, ((struct ModelVertex) {
+                            (Vec3) { mesh->positions[3 * i2.p + 0] / 64, mesh->positions[3 * i2.p + 1] / 64, mesh->positions[3 * i2.p + 2] / 64 },
+                            (Vec2) { mesh->texcoords[2 * i2.t + 0], mesh->texcoords[2 * i2.t + 1] }
+                        }));
+                        i2_hash = hmlen(merge_hash) - 1;
+                        // i2_hash = arrlenu(vertices) - 1;
+                    }
+
+                    arrpush(indices[m->map_Kd], (uint32_t)i0_hash);
+                    arrpush(indices[m->map_Kd], (uint32_t)i1_hash);
+                    arrpush(indices[m->map_Kd], (uint32_t)i2_hash);
+                }
+
+                idx += fv;
+            }
+
+            hmfree(merge_hash);
+        }
+
+        if (mesh->color_count != 0)
+            log_warn("TODO: color in models isn't yet supported");
+
+        /* upload vertices */
+        VertexBuffer vertex_buffer = create_vertex_buffer();
+        specify_vertex_buffer(vertex_buffer, vertices, arrlenu(vertices) * sizeof (struct ModelVertex));
+        item->value.vertices = vertex_buffer;
+
+        /* collect texture usages into index ranges */
+        /* TODO: force repeating texture upload before its used in drawing */
+        for (size_t t = 0; t < arrlenu(indices); ++t) {
+            VertexBuffer index_buffer = create_vertex_buffer();
+            specify_vertex_buffer(index_buffer, indices[t], arrlenu(indices[i]) * sizeof (uint32_t));
+            arrpush(item->value.indices, index_buffer);
+
+            /* build command */
+            DeferredCommandDraw command = {0};
+
+            command.vertices = (AttributeArrayPointer) {
+                .arity = 3,
+                .type = TWN_FLOAT,
+                .stride = sizeof   (struct ModelVertex),
+                .offset = offsetof (struct ModelVertex, position),
+                .buffer = vertex_buffer
+            };
+
+            command.texcoords = (AttributeArrayPointer) {
+                .arity = 2,
+                .type = TWN_FLOAT,
+                .stride = sizeof   (struct ModelVertex),
+                .offset = offsetof (struct ModelVertex, uv),
+                .buffer = vertex_buffer
+            };
+
+            TextureKey const texture_key = textures_get_key(&ctx.texture_cache, mesh->textures[t].name);
+
+            command.textured = true;
+            command.texture_key = texture_key;
+            command.texture_repeat = true;
+
+            command.element_buffer = index_buffer;
+            command.element_count = (uint32_t)(arrlenu(indices[t]));
+            command.range_end = (uint32_t)(arrlenu(indices[t]));
+
+            /* TODO: support alpha blended case? */
+            TextureMode mode = textures_get_mode(&ctx.texture_cache, texture_key);
+            if (mode == TEXTURE_MODE_GHOSTLY)
+                mode = TEXTURE_MODE_SEETHROUGH;
+
+            command.texture_mode = mode;
+            command.pipeline = PIPELINE_SPACE;
+
+            command.depth_range_high = depth_range_high;
+            command.depth_range_low = depth_range_low;
+
+            DeferredCommand final_command = {
+                .type = DEFERRED_COMMAND_TYPE_DRAW,
+                .draw = command
+            };
+
+            arrpush(item->value.commands, final_command);
+
+            arrfree(indices[i]);
+        }
+
+        arrfree(vertices);
+        arrfree(indices);
+
+        /* TODO: sort ranges based on length in assumption that bigger mesh parts will occlude more */
+    }
+}
+
+
+/* adjust uvs into atlases when needed */
+void models_update_post_textures(void) {
+    SDL_assert(!ctx.texture_cache.is_dirty);
+
+    arrsetlen(model_load_queue, 0);
+}
+
+
+void finally_draw_models(void) {
+    for (int i = 0; i < arrlen(model_draw_commands); ++i) {
+        struct ModelDrawCommand *const command = &model_draw_commands[i];
+        struct ModelCacheItem *const cache = shgetp(model_cache, command->model);
+        for (int c = 0; c < arrlen(cache->value.commands); ++c) {
+            arrpush(deferred_commands, cache->value.commands[c]);
+        }
+    }
+
+    arrsetlen(model_draw_commands, 0);
+}
+
+
+/* drop model caches */
+void free_model_cache(void) {
+    for (size_t i = 0; i < shlenu(model_cache); ++i) {
+        // fast_obj_destroy(model_cache[i].value.mesh);
+        SDL_free(model_cache[i].key);
+    }
+
+    shfree(model_cache);
+}
+
+
+void models_state_init(void) {
+    if (model_load_initialized)
+        return;
+    model_load_mutex = SDL_CreateMutex();
+    model_load_initialized = true;
+}
+
+
+void models_state_deinit(void) {
+    if (!model_load_initialized)
+        return;
+    free_model_cache();
+    arrfree(model_load_queue);
+    SDL_DestroyMutex(model_load_mutex);
+    model_load_initialized = false;
+}

src/rendering/twn_text.c

@@ -150,7 +150,7 @@ static FontData *text_load_font_data(const char *path, int height_px) {
         stbtt_PackEnd(&pctx);
     }
 
-    font_data->texture = create_gpu_texture(ctx.font_filtering, true);
+    font_data->texture = create_gpu_texture(ctx.font_filtering, true, 1, (int)ctx.font_texture_size, (int)ctx.font_texture_size);
     upload_gpu_texture(
         font_data->texture,
         bitmap,

src/twn_amalgam.c

@@ -22,4 +22,4 @@
 #include "rendering/twn_quads.c"
 #include "rendering/twn_triangles.c"
 #include "rendering/twn_billboards.c"
-#include "rendering/twn_model.c"
+#include "rendering/twn_models.c"

src/twn_audio_c.h

@@ -1,7 +1,7 @@
 #ifndef TWN_AUDIO_C_H
 #define TWN_AUDIO_C_H
 
-#include <SDL2/SDL_audio.h>
+#include <SDL2/SDL.h>
 
 #define STB_VORBIS_HEADER_ONLY
 #include <stb_vorbis.c>

src/twn_engine_context_c.h

@@ -85,6 +85,7 @@ typedef struct EngineContext {
     bool audio_initialized;
     bool push_audio_model;
     bool cull_faces;
+    bool no_sanity_timer;
 } EngineContext;
 
 /* TODO: does it need to be marked with TWN_API? */

src/twn_loop.c

@@ -193,9 +193,9 @@ static void main_loop(void) {
         input_state_update(&ctx.input);
 
         profile_start("game tick");
-        start_sanity_timer(2000);
+        if (!ctx.no_sanity_timer) start_sanity_timer(2000);
         game_object_tick();
-        end_sanity_timer();
+        if (!ctx.no_sanity_timer) end_sanity_timer();
         profile_end("game tick");
 
         input_state_update_postframe(&ctx.input);
@@ -560,37 +560,22 @@ static bool initialize(void) {
     /* engine configuration */
     {
         toml_datum_t datum_texture_atlas_size = toml_int_in(engine, "texture_atlas_size");
-        if (!datum_texture_atlas_size.ok) {
+        if (!datum_texture_atlas_size.ok || datum_texture_atlas_size.u.i < 32) {
             ctx.texture_atlas_size = TEXTURE_ATLAS_SIZE_DEFAULT;
-        } else {
-            if (datum_texture_atlas_size.u.i < 32) {
-                ctx.texture_atlas_size = TEXTURE_ATLAS_SIZE_DEFAULT;
-            } else {
-                ctx.texture_atlas_size = datum_texture_atlas_size.u.i;
-            }
-        }
+        } else
+            ctx.texture_atlas_size = datum_texture_atlas_size.u.i;
 
         toml_datum_t datum_font_texture_size = toml_int_in(engine, "font_texture_size");
-        if (!datum_font_texture_size.ok) {
+        if (!datum_font_texture_size.ok || datum_font_texture_size.u.i < 1024) {
             ctx.font_texture_size = TEXT_FONT_TEXTURE_SIZE_DEFAULT;
-        } else {
-            if (datum_font_texture_size.u.i < 1024) {
-                ctx.font_texture_size = TEXT_FONT_TEXTURE_SIZE_DEFAULT;
-            } else {
-                ctx.font_texture_size = datum_font_texture_size.u.i;
-            }
-        }
+        } else
+            ctx.font_texture_size = datum_font_texture_size.u.i;
 
         toml_datum_t datum_font_oversampling = toml_int_in(engine, "font_oversampling");
-        if (!datum_font_oversampling.ok) {
+        if (!datum_font_oversampling.ok || datum_font_oversampling.u.i < 0) {
             ctx.font_oversampling = TEXT_FONT_OVERSAMPLING_DEFAULT;
-        } else {
-            if (datum_font_oversampling.u.i < 0) {
-                ctx.font_oversampling = TEXT_FONT_OVERSAMPLING_DEFAULT;
-            } else {
-                ctx.font_oversampling = datum_font_oversampling.u.i;
-            }
-        }
+        } else
+            ctx.font_oversampling = datum_font_oversampling.u.i;
 
         toml_datum_t datum_font_filtering = toml_string_in(engine, "font_filtering");
         if (!datum_font_filtering.ok) {
@@ -619,15 +604,10 @@ static bool initialize(void) {
 
         /* input */
         toml_datum_t datum_keybind_slots = toml_int_in(engine, "keybind_slots");
-        if (!datum_keybind_slots.ok) {
+        if (!datum_keybind_slots.ok || datum_keybind_slots.u.i < 1) {
             ctx.keybind_slots = KEYBIND_SLOTS_DEFAULT;
-        } else {
-            if (datum_keybind_slots.u.i < 1) {
-                ctx.keybind_slots = KEYBIND_SLOTS_DEFAULT;
-            } else {
-                ctx.keybind_slots = datum_keybind_slots.u.i;
-            }
-        }
+        } else
+            ctx.keybind_slots = datum_keybind_slots.u.i;
     }
 
     input_state_init(&ctx.input);
@@ -705,6 +685,7 @@ static bool initialize(void) {
     profile_start("texture and text cache initialization");
     textures_cache_init(&ctx.texture_cache, ctx.window);
     text_cache_init(&ctx.text_cache);
+    models_state_init();
     profile_end("texture and text cache initialization");
 
     return true;
@@ -726,11 +707,14 @@ static void clean_up(void) {
     toml_free(ctx.config_table);
     PHYSFS_deinit();
     workers_deinit();
-    model_state_deinit();
+    models_state_deinit();
     SDL_free(ctx.base_dir);
     SDL_free(ctx.title);
     SDL_GL_DeleteContext(ctx.gl_context);
     SDL_GL_UnloadLibrary();
+    SDL_QuitSubSystem(SDL_INIT_EVENTS);
+    if (ctx.audio_initialized)
+        SDL_QuitSubSystem(SDL_INIT_AUDIO);
     SDL_Quit();
 }
 
@@ -829,6 +813,12 @@ int enter_loop(int argc, char **argv) {
             force_release = true;
             continue;
         }
+
+        /* do not use sanity timer, useful with attached debugger */
+        if (SDL_strncmp(argv[i], "--no-sanity-timer", sizeof "--no-sanity-timer" - 1) == 0) {
+            ctx.no_sanity_timer = true;
+            continue;
+        }
     }
 
     /* data path not explicitly specified, look into convention defined places */

src/twn_stb.c

@@ -1,5 +1,7 @@
 /* single compilation unit for every stb implementation */
 
+#include <stdint.h>
+
 #define STB_DS_IMPLEMENTATION
 #define STBDS_ASSERT SDL_assert
 #define STBDS_REALLOC(context,ptr,size) ((void)(context), SDL_realloc(ptr, size))

src/twn_textures.c

@@ -2,6 +2,7 @@
 #include "twn_util.h"
 #include "twn_util_c.h"
 #include "twn_engine_context_c.h"
+#include "twn_workers_c.h"
 
 #include <SDL2/SDL.h>
 #include <physfs.h>
@@ -19,6 +20,18 @@ typedef struct {
 } TextureLoadingContext;
 
 
+static SDL_mutex *textures_load_mutex;
+static struct TextureLoadRequest {
+    Texture result; /* will be copied into cache when it's time, freeing us from locking */
+    size_t index; /* index into cache->hash to fill */
+    /* 0 = awaits processing */
+    /* 1 = in processing */
+    /* 2 = success */
+    /* 3 = failure */
+    uint8_t status;
+} *texture_load_queue;
+
+
 static int load_read_callback(void *user, char *data, int size) {
     TextureLoadingContext *context = user;
     int read = (int)SDL_RWread(context->rwops, data, 1, size);
@@ -42,7 +55,7 @@ static int load_eof_callback(void *user) {
 
 
 static SDL_Surface *missing_texture_surface;
-static uint16_t missing_texture_id;
+static uint16_t missing_texture_id = TEXTURE_KEY_INVALID.id;
 
 static SDL_Surface *gen_missing_texture_surface(void) {
     Uint32 rmask, gmask, bmask;
@@ -57,6 +70,8 @@ static SDL_Surface *gen_missing_texture_surface(void) {
         bmask = 0x00ff0000;
     #endif
 
+    SDL_LockMutex(textures_load_mutex);
+
     if (!missing_texture_surface) {
         uint8_t *data = SDL_malloc(64 * 64 * 3);
         for (int y = 0; y < 64; ++y) {
@@ -74,6 +89,8 @@ static SDL_Surface *gen_missing_texture_surface(void) {
                                                            rmask, gmask, bmask, 0);
     }
 
+    SDL_UnlockMutex(textures_load_mutex);
+
     return missing_texture_surface;
 }
 
@@ -174,9 +191,10 @@ static SDL_Surface *create_surface(int width, int height) {
 
 /* adds a new, blank atlas surface to the cache */
 static void add_new_atlas(TextureCache *cache) {
+    /* TODO: create a PBO surface if possible, reducing duplication */
     SDL_Surface *new_atlas = create_surface((int)ctx.texture_atlas_size, (int)ctx.texture_atlas_size);
     arrput(cache->atlas_surfaces, new_atlas);
-    arrput(cache->atlas_textures, create_gpu_texture(TEXTURE_FILTER_NEAREAST, true));
+    arrput(cache->atlas_textures, create_gpu_texture(TEXTURE_FILTER_NEAREAST, true, 4, (int)ctx.texture_atlas_size, (int)ctx.texture_atlas_size));
 }
 
 
@@ -196,9 +214,6 @@ static void recreate_current_atlas_texture(TextureCache *cache) {
     /*       for example, if full page of 64x64 tiles was already filled, there's no real reason to process them further */
     SDL_Surface *atlas_surface = cache->atlas_surfaces[cache->atlas_index];
 
-    /* clear */
-    SDL_FillRect(atlas_surface, NULL, 0);
-
     /* blit the texture surfaces onto the atlas */
     for (size_t i = 0; i < shlenu(cache->hash); ++i) {
         /* skip all that aren't part of currently built one */
@@ -230,10 +245,17 @@ static void recreate_current_atlas_texture(TextureCache *cache) {
 /* uses the textures currently in the cache to create an array of stbrp_rects */
 static stbrp_rect *create_rects_from_cache(TextureCache *cache) {
     stbrp_rect *rects = NULL;
+    bool missing_texture_used = false;
     for (size_t i = 0; i < shlenu(cache->hash); ++i) {
         if (cache->hash[i].value.loner_texture != 0)
             continue;
 
+        /* only put it once */
+        if (!missing_texture_used && cache->hash[i].value.data == missing_texture_surface) {
+            missing_texture_used = true;
+            continue;
+        }
+
         const SDL_Surface *surface_data = cache->hash[i].value.data;
         stbrp_rect new_rect = {
             .w = surface_data->w,
@@ -318,6 +340,7 @@ void textures_cache_init(TextureCache *cache, SDL_Window *window) {
     sh_new_arena(cache->hash);
 
     cache->node_buffer = SDL_malloc(ctx.texture_atlas_size * sizeof *cache->node_buffer);
+    textures_load_mutex = SDL_CreateMutex();
 
     add_new_atlas(cache);
 }
@@ -346,6 +369,9 @@ void textures_cache_deinit(TextureCache *cache) {
     }
     shfree(cache->hash);
 
+    SDL_DestroyMutex(textures_load_mutex);
+    arrfree(texture_load_queue);
+
     SDL_free(cache->node_buffer);
 }
 
@@ -377,49 +403,90 @@ static enum TextureMode infer_texture_mode(SDL_Surface *surface) {
     return result;
 }
 
+/* offloads surface load and transparency detection from main thread */
+bool textures_load_workers_thread(void) {
+    /* try grabbing some work */
+    ssize_t texture_id = -1;
+    ssize_t queue_index = -1;
+    char *path = NULL; /* copy of a key, as it's not stable in arena */
 
-static TextureKey textures_load(TextureCache *cache, const char *path) {
-    /* no need to do anything if it was loaded already */
-    const ptrdiff_t i = shgeti(cache->hash, path);
-    if (i >= 0)
-        return (TextureKey){ (uint16_t)i };
+    SDL_LockMutex(textures_load_mutex);
+    for (size_t i = 0; i < arrlenu(texture_load_queue); ++i) {
+        if (texture_load_queue[i].status == 0) {
+            texture_id = texture_load_queue[i].index;
+            path = SDL_strdup(ctx.texture_cache.hash[texture_id].key);
+            texture_load_queue[i].status = 1; /* mark as in process */
+            queue_index = i;
+            break;
+        }
+    }
+    SDL_UnlockMutex(textures_load_mutex);
+    /* nothing to do, bail */
+    if (queue_index == -1)
+        return false;
 
-    SDL_Surface *surface = textures_load_surface(path);
-    if (surface == missing_texture_surface && missing_texture_id != 0)
-        return (TextureKey){ missing_texture_id };
+    SDL_assert(texture_id != -1 && queue_index != -1);
 
-    Texture new_texture = {
+    SDL_Surface *const surface = textures_load_surface(path);
+    SDL_free(path);
+
+    Texture const response = {
         .data = surface,
         .mode = infer_texture_mode(surface),
     };
 
-    /* it's a "loner texture," it doesn't fit in an atlas so it's not in one */
-    if (surface->w >= (int)ctx.texture_atlas_size || surface->h >= (int)ctx.texture_atlas_size) {
-        if (ctx.game.debug) {
-            if (surface->w > 2048 || surface->h > 2048)
-                log_warn("Unportable texture dimensions for %s, use 2048x2048 at max", path);
-            if (!is_power_of_two(surface->w) || !is_power_of_two(surface->h))
-                log_warn("Unportable texture dimensions for %s, should be powers of 2", path);
+    SDL_LockMutex(textures_load_mutex);
+
+    texture_load_queue[queue_index].result = response;
+    texture_load_queue[queue_index].status = 2; /* mark success */
+
+    /* reuse this id in the future, allowing for draw call merging */
+    if (surface == missing_texture_surface && missing_texture_id == TEXTURE_KEY_INVALID.id)
+        missing_texture_id = (uint16_t)texture_id;
+
+    SDL_UnlockMutex(textures_load_mutex);
+
+    return true;
+}
+
+
+static TextureKey textures_load(TextureCache *cache, const char *path) {
+    /* at this point we assume that texture isn't loaded */
+
+    /* place a dummy for future lookups to know it will be loaded */
+    /* as well as a place for worker to fill in */
+    shput(cache->hash, path, (Texture){0});
+
+    /* append a new request, use stable indices */
+    struct TextureLoadRequest const request = {
+        .index = shlenu(cache->hash) - 1,
+    };
+    SDL_LockMutex(textures_load_mutex);
+    arrpush(texture_load_queue, request);
+    SDL_UnlockMutex(textures_load_mutex);
+
+    /* signal work to do */
+    SDL_SemPost(workers_job_semaphore);
+
+    cache->is_dirty = true;
+
+    /* report the newly created slot */
+    return (TextureKey){ (uint16_t)shlenu(cache->hash) - 1 };
+}
+
+
+/* it's safe to access everything without lock after this returns true and no public api is possible to call */
+static bool textures_load_workers_finished(void) {
+    bool result = true;
+    SDL_LockMutex(textures_load_mutex);
+    for (size_t i = 0; i < arrlenu(texture_load_queue); ++i) {
+        if (texture_load_queue[i].status == 0 || texture_load_queue[i].status == 1) {
+            result = false;
+            break;
         }
-        new_texture.loner_texture = create_gpu_texture(TEXTURE_FILTER_NEAREAST, true);
-        upload_texture_from_surface(new_texture.loner_texture, surface); 
-        new_texture.srcrect = (Rect) { .w = (float)surface->w, .h = (float)surface->h };
-
-    } else {
-        /* will be fully populated as the atlas updates */
-        new_texture.atlas_index = cache->atlas_index;
-        cache->is_dirty = true;
     }
-
-    shput(cache->hash, path, new_texture);
-
-    uint16_t const id = (uint16_t)shlenu(cache->hash) - 1;
-
-    /* reuse this id for every later missing texture */
-    if (surface == missing_texture_surface)
-        missing_texture_id = id;
-
-    return (TextureKey){ id };
+    SDL_UnlockMutex(textures_load_mutex);
+    return result;
 }
 
 
@@ -427,6 +494,37 @@ void textures_update_atlas(TextureCache *cache) {
     if (!cache->is_dirty)
         return;
 
+    while (!textures_load_workers_finished())
+        SDL_Delay(1);
+
+    /* collect results */
+    for (size_t i = 0; i < arrlenu(texture_load_queue); ++i) {
+        SDL_assert(texture_load_queue[i].status == 2);
+
+        Texture response = texture_load_queue[i].result;
+
+        /* it's a "loner texture," it doesn't fit in an atlas so it's not in one */
+        if (response.data->w >= (int)ctx.texture_atlas_size || response.data->h >= (int)ctx.texture_atlas_size) {
+            if (ctx.game.debug) {
+                if (response.data->w > 2048 || response.data->h > 2048)
+                    log_warn("Unportable texture dimensions for %s, use 2048x2048 at max", cache->hash[texture_load_queue[i].index].key);
+                if (!is_power_of_two(response.data->w) || !is_power_of_two(response.data->h))
+                    log_warn("Unportable texture dimensions for %s, should be powers of 2", cache->hash[texture_load_queue[i].index].key);
+            }
+            response.loner_texture = create_gpu_texture(TEXTURE_FILTER_NEAREAST, true, response.data->format->BytesPerPixel, response.data->w, response.data->h);
+            upload_texture_from_surface(response.loner_texture, response.data);
+            response.srcrect = (Rect) { .w = (float)response.data->w, .h = (float)response.data->h };
+
+        } else {
+            /* will be fully populated as the atlas updates */
+            response.atlas_index = cache->atlas_index;
+        }
+
+        cache->hash[texture_load_queue[i].index].value = response;
+    }
+
+    arrsetlen(texture_load_queue, 0);
+
     /* this function makes a lot more sense if you read stb_rect_pack.h */
     stbrp_context pack_ctx; /* target info */
     stbrp_init_target(&pack_ctx,
@@ -533,6 +631,7 @@ void textures_bind(const TextureCache *cache, TextureKey key) {
 
 
 /* TODO: alternative schemes, such as: array texture, fragment shader and geometry division */
+/* TODO: a way to trigger upload before it's used */
 void textures_bind_repeating(const TextureCache *cache, TextureKey key) {
     if (m_texture_key_is_valid(key)) {
         if (cache->hash[key.id].value.loner_texture == 0) {
@@ -545,10 +644,15 @@ void textures_bind_repeating(const TextureCache *cache, TextureKey key) {
 
             const Texture texture = cache->hash[key.id].value;
 
-            const GPUTexture repeating_texture = create_gpu_texture(TEXTURE_FILTER_NEAREAST, false);
+            const GPUTexture repeating_texture = create_gpu_texture(TEXTURE_FILTER_NEAREAST,
+                                                                    false,
+                                                                    texture.data->format->BytesPerPixel,
+                                                                    texture.data->w,
+                                                                    texture.data->h);
 
             SDL_LockSurface(texture.data);
 
+            /* TODO: optional glCopyImageSubData support, abstracted as copy_gpu_texture() */
             upload_gpu_texture(repeating_texture,
                                texture.data->pixels,
                                texture.data->format->BytesPerPixel,

src/twn_textures_c.h

@@ -46,7 +46,7 @@ typedef struct TextureCache {
     bool is_dirty;               /* current atlas needs to be recreated */
 } TextureCache;
 
-/* type safe structure for persistent texture handles */
+/* type safe structure for frame persistent texture handles */
 typedef struct TextureKey { uint16_t id; } TextureKey;
 
 /* tests whether given key structure corresponds to any texture */
@@ -56,17 +56,12 @@ typedef struct TextureKey { uint16_t id; } TextureKey;
 void textures_cache_init(struct TextureCache *cache, SDL_Window *window);
 void textures_cache_deinit(struct TextureCache *cache);
 
-/* loads an image if it isn't in the cache, otherwise a no-op. */
-/* can be called from anywhere at any time after init, useful if you want to */
-/* preload textures you know will definitely be used */
-// void textures_load(struct texture_cache *cache, const char *path);
-
 /* repacks the current texture atlas based on the texture cache if needed */
 /* any previously returned srcrect results are invalidated after that */
 /* call it every time before rendering */
 void textures_update_atlas(TextureCache *cache);
 
-/* returns a persistent handle to some texture in cache, loading it if needed */
+/* returns a frame persistent handle to some texture in cache, loading it if needed */
 /* check the result with m_texture_key_is_valid() */
 TextureKey textures_get_key(TextureCache *cache, const char *path);
 
@@ -96,4 +91,7 @@ void textures_reset_state(void);
 /* warn: surface->pixels must be freed along side the surface itself */
 SDL_Surface *textures_load_surface(const char *path);
 
+/* note: will only take an effect after `textures_update_atlas` */
+bool textures_load_workers_thread(void);
+
 #endif

src/twn_workers.c

@@ -27,7 +27,11 @@ static int worker_thread(void *udata) {
         if (SDL_SemWaitTimeout(workers_job_semaphore, 100) == SDL_MUTEX_TIMEDOUT)
             continue;
 
-        if (model_load_workers_thread())
+        /* process models, which will trigger texture loads  */
+        if (models_load_workers_thread())
+            continue;
+
+        if (textures_load_workers_thread())
             continue;
     }
 

third-party/glad/src/glad.c

@@ -25,138 +25,6 @@
 #include <string.h>
 #include <glad/glad.h>
 
-static void* get_proc(const char *namez);
-
-#if defined(_WIN32) || defined(__CYGWIN__)
-#ifndef _WINDOWS_
-#undef APIENTRY
-#endif
-#include <windows.h>
-static HMODULE libGL;
-
-typedef void* (APIENTRYP PFNWGLGETPROCADDRESSPROC_PRIVATE)(const char*);
-static PFNWGLGETPROCADDRESSPROC_PRIVATE gladGetProcAddressPtr;
-
-#ifdef _MSC_VER
-#ifdef __has_include
-  #if __has_include(<winapifamily.h>)
-    #define HAVE_WINAPIFAMILY 1
-  #endif
-#elif _MSC_VER >= 1700 && !_USING_V110_SDK71_
-  #define HAVE_WINAPIFAMILY 1
-#endif
-#endif
-
-#ifdef HAVE_WINAPIFAMILY
-  #include <winapifamily.h>
-  #if !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
-    #define IS_UWP 1
-  #endif
-#endif
-
-static
-int open_gl(void) {
-#ifndef IS_UWP
-    libGL = LoadLibraryW(L"opengl32.dll");
-    if(libGL != NULL) {
-        void (* tmp)(void);
-        tmp = (void(*)(void)) GetProcAddress(libGL, "wglGetProcAddress");
-        gladGetProcAddressPtr = (PFNWGLGETPROCADDRESSPROC_PRIVATE) tmp;
-        return gladGetProcAddressPtr != NULL;
-    }
-#endif
-
-    return 0;
-}
-
-static
-void close_gl(void) {
-    if(libGL != NULL) {
-        FreeLibrary((HMODULE) libGL);
-        libGL = NULL;
-    }
-}
-#else
-#include <dlfcn.h>
-static void* libGL;
-
-#if !defined(__APPLE__) && !defined(__HAIKU__)
-typedef void* (APIENTRYP PFNGLXGETPROCADDRESSPROC_PRIVATE)(const char*);
-static PFNGLXGETPROCADDRESSPROC_PRIVATE gladGetProcAddressPtr;
-#endif
-
-static
-int open_gl(void) {
-#ifdef __APPLE__
-    static const char *NAMES[] = {
-        "../Frameworks/OpenGL.framework/OpenGL",
-        "/Library/Frameworks/OpenGL.framework/OpenGL",
-        "/System/Library/Frameworks/OpenGL.framework/OpenGL",
-        "/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL"
-    };
-#else
-    static const char *NAMES[] = {"libGL.so.1", "libGL.so"};
-#endif
-
-    unsigned int index = 0;
-    for(index = 0; index < (sizeof(NAMES) / sizeof(NAMES[0])); index++) {
-        libGL = dlopen(NAMES[index], RTLD_NOW | RTLD_GLOBAL);
-
-        if(libGL != NULL) {
-#if defined(__APPLE__) || defined(__HAIKU__)
-            return 1;
-#else
-            gladGetProcAddressPtr = (PFNGLXGETPROCADDRESSPROC_PRIVATE)dlsym(libGL,
-                "glXGetProcAddressARB");
-            return gladGetProcAddressPtr != NULL;
-#endif
-        }
-    }
-
-    return 0;
-}
-
-static
-void close_gl(void) {
-    if(libGL != NULL) {
-        dlclose(libGL);
-        libGL = NULL;
-    }
-}
-#endif
-
-static
-void* get_proc(const char *namez) {
-    void* result = NULL;
-    if(libGL == NULL) return NULL;
-
-#if !defined(__APPLE__) && !defined(__HAIKU__)
-    if(gladGetProcAddressPtr != NULL) {
-        result = gladGetProcAddressPtr(namez);
-    }
-#endif
-    if(result == NULL) {
-#if defined(_WIN32) || defined(__CYGWIN__)
-        result = (void*)GetProcAddress((HMODULE) libGL, namez);
-#else
-        result = dlsym(libGL, namez);
-#endif
-    }
-
-    return result;
-}
-
-int gladLoadGL(void) {
-    int status = 0;
-
-    if(open_gl()) {
-        status = gladLoadGLLoader(&get_proc);
-        close_gl();
-    }
-
-    return status;
-}
-
 struct gladGLversionStruct GLVersion = { 0, 0 };
 
 #if defined(GL_ES_VERSION_3_0) || defined(GL_VERSION_3_0)

third-party/libxm/src/CMakeLists.txt

@@ -1,2 +1,2 @@
-ADD_LIBRARY(xms STATIC xm.c context.c load.c play.c)
+ADD_LIBRARY(xms STATIC xm.c)
 INCLUDE_DIRECTORIES(${XM_INCLUDE_DIRS})

third-party/libxm/src/context.c

@@ -1,256 +0,0 @@
-/* Author: Romain "Artefact2" Dalmaso <artefact2@gmail.com> */
-
-/* This program is free software. It comes without any warranty, to the
- * extent permitted by applicable law. You can redistribute it and/or
- * modify it under the terms of the Do What The Fuck You Want To Public
- * License, Version 2, as published by Sam Hocevar. See
- * http://sam.zoy.org/wtfpl/COPYING for more details. */
-
-#include "xm_internal.h"
-
-#define OFFSET(ptr) do {										\
-		(ptr) = (void*)((intptr_t)(ptr) + (intptr_t)(*ctxp));	\
-	} while(0)
-
-#define CHECK_CHANNEL(ctx, c) do { \
-		if(XM_DEBUG && ((c) == 0 || (c) > (ctx)->module.num_channels)) \
-			DEBUG("invalid channel %d", (c)); \
-	} while(0)
-
-#define CHECK_INSTRUMENT(ctx, i) do { \
-		if(XM_DEBUG && ((i) == 0 || (i) > (ctx)->module.num_instruments)) \
-			DEBUG("invalid instrument %d", (i)); \
-	} while(0)
-
-#define CHECK_SAMPLE(ctx, i, s) do {                                      \
-		CHECK_INSTRUMENT((ctx), (i)); \
-		if(XM_DEBUG && ((s) > (ctx)->module.instruments[(i)].num_samples)) \
-			DEBUG("invalid sample %d for instrument %d", (s), (i)); \
-	} while(0)
-
-
-
-int xm_create_context(xm_context_t** ctxp, const char* moddata, uint32_t rate) {
-	return xm_create_context_safe(ctxp, moddata, SIZE_MAX, rate);
-}
-
-int xm_create_context_safe(xm_context_t** ctxp, const char* moddata, size_t moddata_length, uint32_t rate) {
-	size_t bytes_needed;
-	char* mempool;
-	xm_context_t* ctx;
-
-	if(XM_DEFENSIVE) {
-		int ret;
-		if((ret = xm_check_sanity_preload(moddata, moddata_length))) {
-			DEBUG("xm_check_sanity_preload() returned %i, module is not safe to load", ret);
-			return 1;
-		}
-	}
-
-	bytes_needed = xm_get_memory_needed_for_context(moddata, moddata_length);
-	mempool = malloc(bytes_needed);
-	if(mempool == NULL && bytes_needed > 0) {
-		/* malloc() failed, trouble ahead */
-		DEBUG("call to malloc() failed, returned %p", (void*)mempool);
-		return 2;
-	}
-
-	/* Initialize most of the fields to 0, 0.f, NULL or false depending on type */
-	memset(mempool, 0, bytes_needed);
-
-	ctx = (*ctxp = (xm_context_t*)mempool);
-	ctx->ctx_size = bytes_needed; /* Keep original requested size for xmconvert */
-	mempool += sizeof(xm_context_t);
-
-	ctx->rate = rate;
-	mempool = xm_load_module(ctx, moddata, moddata_length, mempool);
-
-	ctx->channels = (xm_channel_context_t*)mempool;
-	mempool += ctx->module.num_channels * sizeof(xm_channel_context_t);
-
-	ctx->global_volume = 1.f;
-	ctx->amplification = .25f; /* XXX: some bad modules may still clip. Find out something better. */
-
-#if XM_RAMPING
-	ctx->volume_ramp = (1.f / 128.f);
-#endif
-
-	for(uint8_t i = 0; i < ctx->module.num_channels; ++i) {
-		xm_channel_context_t* ch = ctx->channels + i;
-
-		ch->ping = true;
-		ch->vibrato_waveform = XM_SINE_WAVEFORM;
-		ch->vibrato_waveform_retrigger = true;
-		ch->tremolo_waveform = XM_SINE_WAVEFORM;
-		ch->tremolo_waveform_retrigger = true;
-
-		ch->volume = ch->volume_envelope_volume = ch->fadeout_volume = 1.0f;
-		ch->panning = ch->panning_envelope_panning = .5f;
-		ch->actual_volume[0] = .0f;
-		ch->actual_volume[1] = .0f;
-	}
-
-	ctx->row_loop_count = (uint8_t*)mempool;
-	mempool += ctx->module.length * MAX_NUM_ROWS * sizeof(uint8_t);
-
-	if(XM_DEFENSIVE) {
-		int ret;
-		if((ret = xm_check_sanity_postload(ctx))) {
-			DEBUG("xm_check_sanity_postload() returned %i, module is not safe to play", ret);
-			xm_free_context(ctx);
-			return 1;
-		}
-	}
-
-	return 0;
-}
-
-void xm_free_context(xm_context_t* context) {
-	free(context);
-}
-
-void xm_set_max_loop_count(xm_context_t* context, uint8_t loopcnt) {
-	context->max_loop_count = loopcnt;
-}
-
-uint8_t xm_get_loop_count(xm_context_t* context) {
-	return context->loop_count;
-}
-
-
-
-void xm_seek(xm_context_t* ctx, uint8_t pot, uint8_t row, uint16_t tick) {
-	ctx->current_table_index = pot;
-	ctx->current_row = row;
-	ctx->current_tick = tick;
-	ctx->remaining_samples_in_tick = 0;
-}
-
-
-
-bool xm_mute_channel(xm_context_t* ctx, uint16_t channel, bool mute) {
-	CHECK_CHANNEL(ctx, channel);
-	bool old = ctx->channels[channel - 1].muted;
-	ctx->channels[channel - 1].muted = mute;
-	return old;
-}
-
-bool xm_mute_instrument(xm_context_t* ctx, uint16_t instr, bool mute) {
-	CHECK_INSTRUMENT(ctx, instr);
-	bool old = ctx->module.instruments[instr - 1].muted;
-	ctx->module.instruments[instr - 1].muted = mute;
-	return old;
-}
-
-
-
-#if XM_STRINGS
-const char* xm_get_module_name(xm_context_t* ctx) {
-	return ctx->module.name;
-}
-
-const char* xm_get_tracker_name(xm_context_t* ctx) {
-	return ctx->module.trackername;
-}
-#else
-const char* xm_get_module_name(xm_context_t* ctx) {
-	return NULL;
-}
-
-const char* xm_get_tracker_name(xm_context_t* ctx) {
-	return NULL;
-}
-#endif
-
-
-
-uint16_t xm_get_number_of_channels(xm_context_t* ctx) {
-	return ctx->module.num_channels;
-}
-
-uint16_t xm_get_module_length(xm_context_t* ctx) {
-	return ctx->module.length;
-}
-
-uint16_t xm_get_number_of_patterns(xm_context_t* ctx) {
-	return ctx->module.num_patterns;
-}
-
-uint16_t xm_get_number_of_rows(xm_context_t* ctx, uint16_t pattern) {
-	if(pattern < ctx->module.num_patterns)
-		return ctx->module.patterns[pattern].num_rows;
-	return DEFAULT_PATTERN_LENGTH;
-}
-
-uint16_t xm_get_number_of_instruments(xm_context_t* ctx) {
-	return ctx->module.num_instruments;
-}
-
-uint16_t xm_get_number_of_samples(xm_context_t* ctx, uint16_t instrument) {
-	CHECK_INSTRUMENT(ctx, instrument);
-	return ctx->module.instruments[instrument - 1].num_samples;
-}
-
-void* xm_get_sample_waveform(xm_context_t* ctx, uint16_t i, uint16_t s, size_t* size, uint8_t* bits) {
-	CHECK_SAMPLE(ctx, i, s);
-	*size = ctx->module.instruments[i - 1].samples[s].length;
-	*bits = ctx->module.instruments[i - 1].samples[s].bits;
-	return ctx->module.instruments[i - 1].samples[s].data8;
-}
-
-
-
-void xm_get_playing_speed(xm_context_t* ctx, uint16_t* bpm, uint16_t* tempo) {
-	if(bpm) *bpm = ctx->bpm;
-	if(tempo) *tempo = ctx->tempo;
-}
-
-void xm_get_position(xm_context_t* ctx, uint8_t* pattern_index, uint8_t* pattern, uint8_t* row, uint64_t* samples) {
-	if(pattern_index) *pattern_index = ctx->current_table_index;
-	if(pattern) *pattern = ctx->module.pattern_table[ctx->current_table_index];
-	if(row) *row = ctx->current_row;
-	if(samples) *samples = ctx->generated_samples;
-}
-
-uint64_t xm_get_latest_trigger_of_instrument(xm_context_t* ctx, uint16_t instr) {
-	CHECK_INSTRUMENT(ctx, instr);
-	return ctx->module.instruments[instr - 1].latest_trigger;
-}
-
-uint64_t xm_get_latest_trigger_of_sample(xm_context_t* ctx, uint16_t instr, uint16_t sample) {
-	CHECK_SAMPLE(ctx, instr, sample);
-	return ctx->module.instruments[instr - 1].samples[sample].latest_trigger;
-}
-
-uint64_t xm_get_latest_trigger_of_channel(xm_context_t* ctx, uint16_t chn) {
-	CHECK_CHANNEL(ctx, chn);
-	return ctx->channels[chn - 1].latest_trigger;
-}
-
-bool xm_is_channel_active(xm_context_t* ctx, uint16_t chn) {
-	CHECK_CHANNEL(ctx, chn);
-	xm_channel_context_t* ch = ctx->channels + (chn - 1);
-	return ch->instrument != NULL && ch->sample != NULL && ch->sample_position >= 0;
-}
-
-float xm_get_frequency_of_channel(xm_context_t* ctx, uint16_t chn) {
-	CHECK_CHANNEL(ctx, chn);
-	return ctx->channels[chn - 1].frequency;
-}
-
-float xm_get_volume_of_channel(xm_context_t* ctx, uint16_t chn) {
-	CHECK_CHANNEL(ctx, chn);
-	return ctx->channels[chn - 1].volume * ctx->global_volume;
-}
-
-float xm_get_panning_of_channel(xm_context_t* ctx, uint16_t chn) {
-	CHECK_CHANNEL(ctx, chn);
-	return ctx->channels[chn - 1].panning;
-}
-
-uint16_t xm_get_instrument_of_channel(xm_context_t* ctx, uint16_t chn) {
-	CHECK_CHANNEL(ctx, chn);
-	xm_channel_context_t* ch = ctx->channels + (chn - 1);
-	if(ch->instrument == NULL) return 0;
-	return 1 + (ch->instrument - ctx->module.instruments);
-}

third-party/libxm/src/load.c

@@ -1,416 +0,0 @@
-/* Author: Romain "Artefact2" Dalmaso <artefact2@gmail.com> */
-/* Contributor: Dan Spencer <dan@atomicpotato.net> */
-
-/* This program is free software. It comes without any warranty, to the
- * extent permitted by applicable law. You can redistribute it and/or
- * modify it under the terms of the Do What The Fuck You Want To Public
- * License, Version 2, as published by Sam Hocevar. See
- * http://sam.zoy.org/wtfpl/COPYING for more details. */
-
-#include "xm_internal.h"
-
-/* .xm files are little-endian. */
-
-/* Bounded reader macros.
- * If we attempt to read the buffer out-of-bounds, pretend that the buffer is
- * infinitely padded with zeroes.
- */
-#define READ_U8_BOUND(offset, bound) (((offset) < (bound)) ? (*(uint8_t*)(moddata + (offset))) : 0)
-#define READ_U16_BOUND(offset, bound) ((uint16_t)READ_U8_BOUND(offset, bound) | ((uint16_t)READ_U8_BOUND((offset) + 1, bound) << 8))
-#define READ_U32_BOUND(offset, bound) ((uint32_t)READ_U16_BOUND(offset, bound) | ((uint32_t)READ_U16_BOUND((offset) + 2, bound) << 16))
-#define READ_MEMCPY_BOUND(ptr, offset, length, bound) memcpy_pad(ptr, length, moddata, bound, offset)
-
-#define READ_U8(offset) READ_U8_BOUND(offset, moddata_length)
-#define READ_U16(offset) READ_U16_BOUND(offset, moddata_length)
-#define READ_U32(offset) READ_U32_BOUND(offset, moddata_length)
-#define READ_MEMCPY(ptr, offset, length) READ_MEMCPY_BOUND(ptr, offset, length, moddata_length)
-
-#define MIN(a, b) ((a) < (b) ? (a) : (b))
-
-static inline void memcpy_pad(void* dst, size_t dst_len, const void* src, size_t src_len, size_t offset) {
-	uint8_t* dst_c = dst;
-	const uint8_t* src_c = src;
-
-	/* how many bytes can be copied without overrunning `src` */
-	size_t copy_bytes = (src_len >= offset) ? (src_len - offset) : 0;
-	copy_bytes = copy_bytes > dst_len ? dst_len : copy_bytes;
-
-	memcpy(dst_c, src_c + offset, copy_bytes);
-	/* padded bytes */
-	memset(dst_c + copy_bytes, 0, dst_len - copy_bytes);
-}
-
-int xm_check_sanity_preload(const char* module, size_t module_length) {
-	if(module_length < 60) {
-		return 4;
-	}
-
-	if(memcmp("Extended Module: ", module, 17) != 0) {
-		return 1;
-	}
-
-	if(module[37] != 0x1A) {
-		return 2;
-	}
-
-	if(module[59] != 0x01 || module[58] != 0x04) {
-		/* Not XM 1.04 */
-		return 3;
-	}
-
-	return 0;
-}
-
-int xm_check_sanity_postload(xm_context_t* ctx) {
-	/* @todo: plenty of stuff to do here… */
-	return 0;
-}
-
-size_t xm_get_memory_needed_for_context(const char* moddata, size_t moddata_length) {
-	size_t memory_needed = 0;
-	size_t offset = 60; /* Skip the first header */
-	uint16_t num_channels;
-	uint16_t num_patterns;
-	uint16_t num_instruments;
-
-	/* Read the module header */
-
-	num_channels = READ_U16(offset + 8);
-	num_patterns = READ_U16(offset + 10);
-	memory_needed += num_patterns * sizeof(xm_pattern_t);
-
-	num_instruments = READ_U16(offset + 12);
-	memory_needed += num_instruments * sizeof(xm_instrument_t);
-
-	memory_needed += MAX_NUM_ROWS * READ_U16(offset + 4) * sizeof(uint8_t); /* Module length */
-
-	/* Header size */
-	offset += READ_U32(offset);
-
-	/* Read pattern headers */
-	for(uint16_t i = 0; i < num_patterns; ++i) {
-		uint16_t num_rows;
-
-		num_rows = READ_U16(offset + 5);
-		memory_needed += num_rows * num_channels * sizeof(xm_pattern_slot_t);
-
-		/* Pattern header length + packed pattern data size */
-		offset += READ_U32(offset) + READ_U16(offset + 7);
-	}
-
-	/* Read instrument headers */
-	for(uint16_t i = 0; i < num_instruments; ++i) {
-		uint16_t num_samples;
-		uint32_t sample_size_aggregate = 0;
-
-		num_samples = READ_U16(offset + 27);
-		memory_needed += num_samples * sizeof(xm_sample_t);
-
-		/* Instrument header size */
-		uint32_t ins_header_size = READ_U32(offset);
-		if (ins_header_size == 0 || ins_header_size > INSTRUMENT_HEADER_LENGTH)
-			ins_header_size = INSTRUMENT_HEADER_LENGTH;
-		offset += ins_header_size;
-
-		for(uint16_t j = 0; j < num_samples; ++j) {
-			uint32_t sample_size;
-
-			sample_size = READ_U32(offset);
-			sample_size_aggregate += sample_size;
-			memory_needed += sample_size;
-			offset += 40; /* See comment in xm_load_module() */
-		}
-
-		offset += sample_size_aggregate;
-	}
-
-	memory_needed += num_channels * sizeof(xm_channel_context_t);
-	memory_needed += sizeof(xm_context_t);
-
-	return memory_needed;
-}
-
-char* xm_load_module(xm_context_t* ctx, const char* moddata, size_t moddata_length, char* mempool) {
-	size_t offset = 0;
-	xm_module_t* mod = &(ctx->module);
-
-	/* Read XM header */
-#if XM_STRINGS
-	READ_MEMCPY(mod->name, offset + 17, MODULE_NAME_LENGTH);
-	READ_MEMCPY(mod->trackername, offset + 38, TRACKER_NAME_LENGTH);
-#endif
-	offset += 60;
-
-	/* Read module header */
-	uint32_t header_size = READ_U32(offset);
-
-	mod->length = READ_U16(offset + 4);
-	mod->restart_position = READ_U16(offset + 6);
-	mod->num_channels = READ_U16(offset + 8);
-	mod->num_patterns = READ_U16(offset + 10);
-	mod->num_instruments = READ_U16(offset + 12);
-
-	mod->patterns = (xm_pattern_t*)mempool;
-	mempool += mod->num_patterns * sizeof(xm_pattern_t);
-
-	mod->instruments = (xm_instrument_t*)mempool;
-	mempool += mod->num_instruments * sizeof(xm_instrument_t);
-
-	uint16_t flags = READ_U32(offset + 14);
-	mod->frequency_type = (flags & (1 << 0)) ? XM_LINEAR_FREQUENCIES : XM_AMIGA_FREQUENCIES;
-
-	ctx->tempo = READ_U16(offset + 16);
-	ctx->bpm = READ_U16(offset + 18);
-
-	READ_MEMCPY(mod->pattern_table, offset + 20, PATTERN_ORDER_TABLE_LENGTH);
-	offset += header_size;
-
-	/* Read patterns */
-	for(uint16_t i = 0; i < mod->num_patterns; ++i) {
-		uint16_t packed_patterndata_size = READ_U16(offset + 7);
-		xm_pattern_t* pat = mod->patterns + i;
-
-		pat->num_rows = READ_U16(offset + 5);
-
-		pat->slots = (xm_pattern_slot_t*)mempool;
-		mempool += mod->num_channels * pat->num_rows * sizeof(xm_pattern_slot_t);
-
-		/* Pattern header length */
-		offset += READ_U32(offset);
-
-		if(packed_patterndata_size == 0) {
-			/* No pattern data is present */
-			memset(pat->slots, 0, sizeof(xm_pattern_slot_t) * pat->num_rows * mod->num_channels);
-		} else {
-			/* This isn't your typical for loop */
-			for(uint16_t j = 0, k = 0; j < packed_patterndata_size; ++k) {
-				uint8_t note = READ_U8(offset + j);
-				xm_pattern_slot_t* slot = pat->slots + k;
-
-				if(note & (1 << 7)) {
-					/* MSB is set, this is a compressed packet */
-					++j;
-
-					if(note & (1 << 0)) {
-						/* Note follows */
-						slot->note = READ_U8(offset + j);
-						++j;
-					} else {
-						slot->note = 0;
-					}
-
-					if(note & (1 << 1)) {
-						/* Instrument follows */
-						slot->instrument = READ_U8(offset + j);
-						++j;
-					} else {
-						slot->instrument = 0;
-					}
-
-					if(note & (1 << 2)) {
-						/* Volume column follows */
-						slot->volume_column = READ_U8(offset + j);
-						++j;
-					} else {
-						slot->volume_column = 0;
-					}
-
-					if(note & (1 << 3)) {
-						/* Effect follows */
-						slot->effect_type = READ_U8(offset + j);
-						++j;
-					} else {
-						slot->effect_type = 0;
-					}
-
-					if(note & (1 << 4)) {
-						/* Effect parameter follows */
-						slot->effect_param = READ_U8(offset + j);
-						++j;
-					} else {
-						slot->effect_param = 0;
-					}
-				} else {
-					/* Uncompressed packet */
-					slot->note = note;
-					slot->instrument = READ_U8(offset + j + 1);
-					slot->volume_column = READ_U8(offset + j + 2);
-					slot->effect_type = READ_U8(offset + j + 3);
-					slot->effect_param = READ_U8(offset + j + 4);
-					j += 5;
-				}
-			}
-		}
-
-		offset += packed_patterndata_size;
-	}
-
-	/* Read instruments */
-	for(uint16_t i = 0; i < ctx->module.num_instruments; ++i) {
-		xm_instrument_t* instr = mod->instruments + i;
-
-		/* Original FT2 would load instruments with a direct read into the
-		   instrument data structure that was previously zeroed. This means
-		   that if the declared length was less than INSTRUMENT_HEADER_LENGTH,
-		   all excess data would be zeroed. This is used by the XM compressor
-		   BoobieSqueezer. To implement this, bound all reads to the header size. */
-		uint32_t ins_header_size = READ_U32(offset);
-		if (ins_header_size == 0 || ins_header_size > INSTRUMENT_HEADER_LENGTH)
-			ins_header_size = INSTRUMENT_HEADER_LENGTH;
-
-#if XM_STRINGS
-		READ_MEMCPY_BOUND(instr->name, offset + 4, INSTRUMENT_NAME_LENGTH, offset + ins_header_size);
-		instr->name[INSTRUMENT_NAME_LENGTH] = 0;
-#endif
-	    instr->num_samples = READ_U16_BOUND(offset + 27, offset + ins_header_size);
-
-		if(instr->num_samples > 0) {
-			/* Read extra header properties */
-			READ_MEMCPY_BOUND(instr->sample_of_notes, offset + 33, NUM_NOTES, offset + ins_header_size);
-
-			instr->volume_envelope.num_points = READ_U8_BOUND(offset + 225, offset + ins_header_size);
-			if (instr->volume_envelope.num_points > NUM_ENVELOPE_POINTS)
-				instr->volume_envelope.num_points = NUM_ENVELOPE_POINTS;
-
-			instr->panning_envelope.num_points = READ_U8_BOUND(offset + 226, offset + ins_header_size);
-			if (instr->panning_envelope.num_points > NUM_ENVELOPE_POINTS)
-				instr->panning_envelope.num_points = NUM_ENVELOPE_POINTS;
-
-			for(uint8_t j = 0; j < instr->volume_envelope.num_points; ++j) {
-				instr->volume_envelope.points[j].frame = READ_U16_BOUND(offset + 129 + 4 * j, offset + ins_header_size);
-				instr->volume_envelope.points[j].value = READ_U16_BOUND(offset + 129 + 4 * j + 2, offset + ins_header_size);
-			}
-
-			for(uint8_t j = 0; j < instr->panning_envelope.num_points; ++j) {
-				instr->panning_envelope.points[j].frame = READ_U16_BOUND(offset + 177 + 4 * j, offset + ins_header_size);
-				instr->panning_envelope.points[j].value = READ_U16_BOUND(offset + 177 + 4 * j + 2, offset + ins_header_size);
-			}
-
-			instr->volume_envelope.sustain_point = READ_U8_BOUND(offset + 227, offset + ins_header_size);
-			instr->volume_envelope.loop_start_point = READ_U8_BOUND(offset + 228, offset + ins_header_size);
-			instr->volume_envelope.loop_end_point = READ_U8_BOUND(offset + 229, offset + ins_header_size);
-
-			instr->panning_envelope.sustain_point = READ_U8_BOUND(offset + 230, offset + ins_header_size);
-			instr->panning_envelope.loop_start_point = READ_U8_BOUND(offset + 231, offset + ins_header_size);
-			instr->panning_envelope.loop_end_point = READ_U8_BOUND(offset + 232, offset + ins_header_size);
-
-			// Fix broken modules with loop points outside of defined points
-			if (instr->volume_envelope.num_points > 0) {
-				instr->volume_envelope.loop_start_point =
-					MIN(instr->volume_envelope.loop_start_point, instr->volume_envelope.num_points-1);
-				instr->volume_envelope.loop_end_point =
-					MIN(instr->volume_envelope.loop_end_point,   instr->volume_envelope.num_points-1);
-			}
-			if (instr->panning_envelope.num_points > 0) {
-				instr->panning_envelope.loop_start_point =
-					MIN(instr->panning_envelope.loop_start_point, instr->panning_envelope.num_points-1);
-				instr->panning_envelope.loop_end_point =
-					MIN(instr->panning_envelope.loop_end_point,   instr->panning_envelope.num_points-1);
-			}
-
-			uint8_t flags = READ_U8_BOUND(offset + 233, offset + ins_header_size);
-			instr->volume_envelope.enabled = flags & (1 << 0);
-			instr->volume_envelope.sustain_enabled = flags & (1 << 1);
-			instr->volume_envelope.loop_enabled = flags & (1 << 2);
-
-			flags = READ_U8_BOUND(offset + 234, offset + ins_header_size);
-			instr->panning_envelope.enabled = flags & (1 << 0);
-			instr->panning_envelope.sustain_enabled = flags & (1 << 1);
-			instr->panning_envelope.loop_enabled = flags & (1 << 2);
-
-			instr->vibrato_type = READ_U8_BOUND(offset + 235, offset + ins_header_size);
-			if(instr->vibrato_type == 2) {
-				instr->vibrato_type = 1;
-			} else if(instr->vibrato_type == 1) {
-				instr->vibrato_type = 2;
-			}
-			instr->vibrato_sweep = READ_U8_BOUND(offset + 236, offset + ins_header_size);
-			instr->vibrato_depth = READ_U8_BOUND(offset + 237, offset + ins_header_size);
-			instr->vibrato_rate = READ_U8_BOUND(offset + 238, offset + ins_header_size);
-			instr->volume_fadeout = READ_U16_BOUND(offset + 239, offset + ins_header_size);
-
-			instr->samples = (xm_sample_t*)mempool;
-			mempool += instr->num_samples * sizeof(xm_sample_t);
-		} else {
-			instr->samples = NULL;
-		}
-
-		/* Instrument header size */
-		offset += ins_header_size;
-
-		for(uint16_t j = 0; j < instr->num_samples; ++j) {
-			/* Read sample header */
-			xm_sample_t* sample = instr->samples + j;
-
-			sample->length = READ_U32(offset);
-			sample->loop_start = READ_U32(offset + 4);
-			sample->loop_length = READ_U32(offset + 8);
-			sample->loop_end = sample->loop_start + sample->loop_length;
-			sample->volume = (float)READ_U8(offset + 12) / (float)0x40;
-			sample->finetune = (int8_t)READ_U8(offset + 13);
-
-			/* Fix invalid loop definitions */
-			if (sample->loop_start > sample->length)
-				sample->loop_start = sample->length;
-			if (sample->loop_end > sample->length)
-				sample->loop_end = sample->length;
-			sample->loop_length = sample->loop_end - sample->loop_start;
-
-			uint8_t flags = READ_U8(offset + 14);
-			if((flags & 3) == 0 || sample->loop_length == 0) {
-				sample->loop_type = XM_NO_LOOP;
-			} else if((flags & 3) == 1) {
-				sample->loop_type = XM_FORWARD_LOOP;
-			} else {
-				sample->loop_type = XM_PING_PONG_LOOP;
-			}
-
-			sample->bits = (flags & (1 << 4)) ? 16 : 8;
-
-			sample->panning = (float)READ_U8(offset + 15) / (float)0xFF;
-			sample->relative_note = (int8_t)READ_U8(offset + 16);
-#if XM_STRINGS
-			READ_MEMCPY(sample->name, offset + 18, SAMPLE_NAME_LENGTH);
-			sample->name[SAMPLE_NAME_LENGTH] = 0;
-#endif
-			sample->data8 = (int8_t*)mempool;
-			mempool += sample->length;
-
-			if(sample->bits == 16) {
-				sample->loop_start >>= 1;
-				sample->loop_length >>= 1;
-				sample->loop_end >>= 1;
-				sample->length >>= 1;
-			}
-
-			/* Notice that, even if there's a "sample header size" in the
-			   instrument header, that value seems ignored, and might even
-			   be wrong in some corrupted modules. */
-			offset += 40;
-		}
-
-		for(uint16_t j = 0; j < instr->num_samples; ++j) {
-			/* Read sample data */
-			xm_sample_t* sample = instr->samples + j;
-			uint32_t length = sample->length;
-
-			if(sample->bits == 16) {
-				int16_t v = 0;
-				for(uint32_t k = 0; k < length; ++k) {
-					v = v + (int16_t)READ_U16(offset + (k << 1));
-					sample->data16[k] = v;
-				}
-				offset += sample->length << 1;
-			} else {
-				int8_t v = 0;
-				for(uint32_t k = 0; k < length; ++k) {
-					v = v + (int8_t)READ_U8(offset + k);
-					sample->data8[k] = v;
-				}
-				offset += sample->length;
-			}
-		}
-	}
-
-	return mempool;
-}