Interact

Bit more cleanup of floats
Fixed_t updates
2026-06-18 13:34:36 -05:00 · 2026-06-18 13:03:57 -05:00 · 2026-06-18 12:44:23 -05:00 · 2026-06-18 10:24:45 -05:00 · 2026-06-18 10:17:53 -05:00 · 2026-06-16 09:18:13 -05:00
314 changed files with 5312 additions and 11412 deletions
@@ -1,11 +1,8 @@
 name: Build Dusk
 on:
  push:
-    branches:
-      - main
-  pull_request:
-    branches:
-      - main
+    tags:
+      - '*'
 jobs:
  run-tests:
    runs-on: ubuntu-latest
@@ -0,0 +1,432 @@
+# Dusk — Claude Code rules
+
+## File headers
+Every C, H, and JS file starts with:
+
+```c
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+```
+
+JS files use `//` comment style instead.
+
+---
+
+## C conventions
+
+### Types
+Always use the project-defined aliases instead of bare C primitives:
+
+| Use       | Not          |
+|-----------|--------------|
+| `bool_t`  | `bool`       |
+| `int_t`   | `int`        |
+| `float_t` | `float`      |
+| `char_t`  | `char`       |
+
+Use `uint8_t`, `uint16_t`, `int32_t`, etc. for fixed-width integers.
+All struct and enum types end in `_t` (`animation_t`, `errorret_t`, …).
+
+### Naming
+- **Functions** — snake_case, prefixed with their module:
+  `assetLock()`, `entityPositionInit()`, `moduleAssetBatchCtor()`
+- **Struct fields** — camelCase: `keyframeCount`, `localPosition`
+- **Macros / constants** — UPPER_SNAKE_CASE:
+  `ENTITY_ID_INVALID`, `ERROR_OK`, `COMPONENT_TYPE_COUNT`
+- **Files** — snake_case matching the primary type: `entityposition.c`,
+  `moduleassetbatch.c`
+
+### Header files (`.h`)
+- Use `#pragma once` — no include guards.
+- Declare every public function, `#define`, and `extern` global.
+- Write a JSDoc block (`/** … */`) above every declaration explaining
+  purpose, `@param`s, and `@returns`.
+- Only include headers that the `.h` file itself strictly requires for
+  the types it exposes. Move everything else to the `.c` file.
+  Do not use forward declarations as a workaround — use the real
+  include in the `.c` file instead.
+
+### Implementation files (`.c`)
+- Contain function bodies only; no declarations.
+- Pull in whatever additional includes the implementation needs.
+- Do not use `static` or `inline` on **functions**. Every function,
+  including internal helpers, must be declared in the matching `.h` and
+  defined in the `.c` file. Internal helpers belong near the bottom of
+  the `.c` file, not at the top with a `static` qualifier.
+  `static` and `inline` on functions are only appropriate when the
+  function body is written directly inside a `.h` file.
+  `static` on **variables** (file-scope state) is fine and expected.
+
+### Formatting
+- Hard-wrap all lines at **80 characters**.
+
+### Error handling
+Return `errorret_t` from fallible functions. Use these macros:
+
+```c
+errorOk();                    // return success
+errorThrow("msg %d", val);    // return failure with message
+errorChain(someCall());       // propagate failure, continue on success
+errorIsOk(ret) / errorIsNotOk(ret)  // test a result
+errorCatch(ret);              // handle + free an error
+```
+
+Never return raw error codes or use `errno` for in-engine errors.
+
+### Memory
+Use the project allocator — never raw `malloc`/`free`:
+
+```c
+memoryAllocate(size)          // allocate
+memoryFree(ptr)               // free
+memoryZero(dest, size)        // zero a block
+memoryCopy(dest, src, size)   // copy
+```
+
+### Asserts
+Prefer specific assert macros over bare `assert()`:
+
+```c
+assertNotNull(ptr, "msg");
+assertTrue(cond, "msg");
+assertFalse(cond, "msg");
+assertUnreachable("msg");
+assertIsMainThread("msg");
+```
+
+---
+
+## Build system
+Each subdirectory has its own `CMakeLists.txt` that adds sources with:
+
+```cmake
+target_sources(${DUSK_LIBRARY_TARGET_NAME}
+  PUBLIC
+    myfile.c
+)
+```
+
+Never add source files to the root `CMakeLists.txt` directly.
+
+---
+
+## Platform support
+
+### Targets
+Set `DUSK_TARGET_SYSTEM` at CMake configure time to select a platform:
+
+| `DUSK_TARGET_SYSTEM` | Macro defined     | Platform         |
+|----------------------|-------------------|------------------|
+| `linux`              | `DUSK_LINUX`      | Linux desktop    |
+| `knulli`             | `DUSK_KNULLI`     | Knulli (handheld)|
+| `psp`                | `DUSK_PSP`        | Sony PSP         |
+| `vita`               | `DUSK_VITA`       | PlayStation Vita |
+| `gamecube`           | `DUSK_GAMECUBE`   | Nintendo GameCube|
+| `wii`                | `DUSK_WII`        | Nintendo Wii     |
+
+### Layer structure
+```
+src/dusk/          core, platform-agnostic game logic
+src/duskgl/        OpenGL abstraction (Linux, Knulli, PSP, Vita)
+src/dusksdl2/      SDL2 window + input (Linux, Knulli, PSP, Vita)
+src/dusklinux/     Linux + Knulli platform impl
+src/duskpsp/       PSP platform impl
+src/duskvita/      Vita platform impl
+src/duskdolphin/   GameCube / Wii platform impl (no SDL2/OpenGL)
+```
+
+Dolphin is the only target that bypasses SDL2 and OpenGL entirely —
+it uses native GameCube/Wii rendering and input APIs.
+
+### Platform guards
+Use the compile-time macros for platform-specific code:
+
+```c
+#ifdef DUSK_PSP
+  // PSP-only path
+#elif defined(DUSK_GAMECUBE) || defined(DUSK_WII)
+  // GameCube / Wii path
+#else
+  // Generic / Linux fallback
+#endif
+```
+
+Additional capability macros set per-target:
+`DUSK_SDL2`, `DUSK_OPENGL`, `DUSK_OPENGL_ES`, `DUSK_OPENGL_LEGACY`,
+`DUSK_INPUT_GAMEPAD`, `DUSK_INPUT_KEYBOARD`, `DUSK_INPUT_POINTER`,
+`DUSK_PLATFORM_ENDIAN_BIG` / `DUSK_PLATFORM_ENDIAN_LITTLE`.
+
+### Abstraction pattern
+Platform-specific implementations are wired in via `#define` macros in
+each platform's `displayplatform.h` / `inputplatform.h` etc., which
+the core calls through. Functions that a platform does not support are
+simply left undefined — the core guards calls with `#ifdef`.
+
+### Adding platform-specific code
+- Put it under `src/dusk<platform>/` in the matching subsystem folder.
+- Gate any core call-site with the appropriate `#ifdef DUSK_<PLATFORM>`
+  or capability macro.
+- Keep the `src/dusk/` core free of platform ifdefs — delegate through
+  the platform header macros instead.
+
+---
+
+## Adding a new asset loader type
+1. Add an enum value to `assetloadertype_t` (before `_COUNT`) in
+   `src/dusk/asset/loader/assetloader.h`.
+2. Add fields to the input/loading/output unions in `assetloader.h`.
+3. Implement `assetXxxLoaderSync`, `assetXxxLoaderAsync`, and
+   `assetXxxDispose` in a new `src/dusk/asset/loader/xxx/` directory.
+4. Register the three callbacks in `ASSET_LOADER_CALLBACKS[]` in
+   `src/dusk/asset/loader/assetloader.c`.
+5. If user-facing, create a JS module (see below) and a `.d.ts` file.
+
+---
+
+## Adding a new entity component
+1. Create `src/dusk/entity/component/<category>/entityMyComp.h/.c` with
+   struct `entityMyComp_t`, `entityMyCompInit()`, and optionally
+   `entityMyCompDispose()`.
+2. Add the include to `src/dusk/entity/componentlist.h` header block.
+3. Add a row to `src/dusk/entity/componentlist.h`:
+   ```c
+   X(MYCOMP, entityMyComp_t, myComp, entityMyCompInit, NULL, NULL)
+   ```
+   This auto-generates the enum, union field, and definition entry.
+4. If JS-facing, create the script module and `.d.ts` (see below).
+
+---
+
+## Adding a new script (JS) module
+1. Create `src/dusk/script/module/<category>/moduleMyMod.h/.c`.
+   - Declare `extern scriptproto_t MODULE_MYMOD_PROTO;` in the header.
+   - Use `moduleBaseFunction(name)` to define JS-callable functions.
+   - Register props/funcs in `moduleMyModInit()` with
+     `scriptProtoDefineProp` / `scriptProtoDefineFunc` /
+     `scriptProtoDefineStaticFunc`.
+2. `#include` the header in
+   `src/dusk/script/module/modulelist.c` and call
+   `moduleMyModInit()` in `moduleListInit()` (and `Dispose` in
+   `moduleListDispose()`).
+3. For component modules also register in
+   `src/dusk/script/module/entity/component/modulecomponentlist.c`
+   so `entity.add()` returns the typed wrapper.
+4. Create `types/<category>/mymod.d.ts` and add a
+   `/// <reference path="..." />` line to `types/index.d.ts`.
+
+---
+
+## Script module type declarations
+Whenever a `src/dusk/script/module/**/*.c` file is created or modified,
+check whether the corresponding `types/**/*.d.ts` needs updating and
+apply any changes before finishing the task.
+
+---
+
+## JavaScript (asset scripts)
+- Use `var` for module-level state; `const` for values that never
+  change.
+- Always use semicolons.
+- Scene objects are plain objects (`var scene = {}`) with assigned
+  methods.
+- Export via `module.exports = scene`.
+- Async scene init should use `async function` and `await`.
+
+---
+
+## Coding style
+
+### ASCII only
+Source files (`.c`, `.h`, `.js`) must contain only ASCII characters (U+0000–U+007F).
+Non-ASCII characters are banned even in comments and string literals.
+Use ASCII-only substitutes instead:
+- `--` or `-` instead of `—` (em dash)
+- `->` instead of `→` (arrow)
+- `x` or `*` instead of `×` (multiplication)
+
+Only non-script asset files (e.g. `.po` locale files) may contain non-ASCII text.
+
+### Indentation
+2 spaces. No tabs.
+
+### Keyword and operator spacing
+No space between a keyword or function name and its opening parenthesis:
+
+```c
+if(!ptr) return;
+for(uint8_t i = 0; i < count; i++) {
+while(entry->state != DONE) {
+switch(type) {
+sizeof(assetbatch_t)
+memoryZero(ptr, size)
+```
+
+Spaces around all binary operators and after every comma:
+
+```c
+pos->flags |= ENTITY_POSITION_FLAG_WORLD_DIRTY;
+(size_t)end - (size_t)start
+foo(a, b, c)
+```
+
+### Braces
+Opening brace on the **same line** as the statement (K&R style) for all
+constructs — functions, `if`, `else`, `for`, `while`, `switch`:
+
+```c
+void assetEntryLock(assetentry_t *entry) {
+  ...
+}
+
+if(dirty) {
+  ...
+} else {
+  ...
+}
+```
+
+### Guard returns
+Short guards go on one line with no braces:
+
+```c
+if(!ptr) return;
+if(!b || !b->batch) return jerry_undefined();
+if(!(flags & DIRTY)) return;
+```
+
+### Blank lines
+- One blank line between functions; no blank line at the start or end of
+  a function body.
+- One blank line between logical blocks inside a function body.
+- No trailing blank lines at the end of a file.
+
+### Pointer placement
+`*` is attached to the variable name, not the type:
+
+```c
+assetentry_t *entry
+const char_t *name
+void *ptr
+uint8_t *d = (uint8_t *)dest;
+```
+
+### Casts
+Space between cast and operand:
+
+```c
+(assetbatch_t *)user
+(uint8_t *)dest
+(textureformat_t)v
+```
+
+### Return
+No parentheses around the return value:
+
+```c
+return ptr;
+return MEMORY_POINTERS_IN_USE;
+```
+
+### switch / case
+`case` indented 2 spaces from `switch`; body indented 2 more from `case`:
+
+```c
+switch(type) {
+  case ASSET_LOADER_TYPE_TEXTURE:
+    descs[i].input.texture = (textureformat_t)v;
+    break;
+  default:
+    break;
+}
+```
+
+### Multi-line function signatures
+When parameters don't fit on one line, put each on its own line indented
+2 spaces; the closing `) {` (definition) or `);` (declaration) goes on
+its own line at column 0:
+
+```c
+void assetEntryInit(
+  assetentry_t *entry,
+  const char_t *name,
+  const assetloadertype_t type,
+  assetloaderinput_t *input
+) {
+
+errorret_t memoryCompare(
+  const void *a,
+  const void *b,
+  const size_t size
+);
+```
+
+### Structs and enums
+Anonymous inner struct or enum with a `typedef`, `_t` suffix, closing
+brace and name on the same line:
+
+```c
+typedef struct {
+  errorcode_t code;
+  char_t *message;
+} errorstate_t;
+
+typedef enum {
+  ASSET_LOADER_TYPE_NULL,
+  ASSET_LOADER_TYPE_COUNT
+} assetloadertype_t;
+```
+
+### Designated initialisers
+Spaces inside braces; `.field = value`:
+
+```c
+jsassetentry_t e = { .entry = entry };
+assetbatchloadedpend_t init = { .batch = batch };
+```
+
+### Ternary operator
+Spaces around `?` and `:`:
+
+```c
+const float val = psx > 0.0f ? pt[0][0] / psx : 0.0f;
+```
+
+### const placement
+`const` before the type, `*` attached to the variable:
+
+```c
+const char_t *name
+const void *src
+const size_t size
+```
+
+### Comments in `.c` files
+- Do not use section dividers (`/* ---- ... ---- */`). Just let the
+  functions follow one another with a single blank line between them.
+- Multi-line explanatory comments inside function bodies use `//` lines:
+  ```c
+  // Script modules are freed; orphaned JS wrapper objects now get GC'd
+  // so their finalizers fire before assetDispose() checks ref counts.
+  jerry_heap_gc(JERRY_GC_PRESSURE_HIGH);
+  ```
+- Do not use `/* */` for inline or inline-block comments inside `.c`
+  function bodies.
+
+### Comments in `.h` files
+Every public declaration gets a Javadoc block (`/** … */`) with
+`@param` and `@returns` where relevant. Keep it on the lines immediately
+above the declaration with no blank line in between.
+
+---
+
+## Tests
+- Tests live in `test/` mirroring `src/dusk/` structure.
+- Use cmocka; include `dusktest.h`.
+- Test functions: `static void test_something(void **state)`.
+- After each test, assert `memoryGetAllocatedCount() == 0` to catch
+  leaks.
+- Build with `-DDUSK_BUILD_TESTS=ON`.
@@ -16,7 +16,6 @@ typedef enum {

 typedef struct {
  rpgcameramode_t mode;
-
  union {
    worldpos_t free;
    struct {
@@ -1,3 +1,8 @@
+// Copyright (c) 2026 Dominic Masters
+//
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
 const platformNames = {
  [System.PLATFORM_LINUX]:    'Linux',
  [System.PLATFORM_KNULLI]:   'Knulli',
@@ -8,6 +13,8 @@ const platformNames = {

 Console.print('Platform: ' + (platformNames[System.platform] || 'Unknown'));

+UIFullboxOver.setColor(Color.BLACK);
+
 requireAsync('testscene.js').then(Scene.set).catch(err => {
  Console.print('Error loading scene: ' + err);
  Engine.exit();
@@ -0,0 +1,63 @@
+// Copyright (c) 2026 Dominic Masters
+//
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+const PLAYER_SPEED = 5.0;
+// 1 world unit = 16 pixels.
+const PIXEL_SCALE = 1.0 / 16.0;
+// Player sprite is 32x32 px (test.png dimensions).
+const PLAYER_W = 32 * PIXEL_SCALE;
+const PLAYER_H = 32 * PIXEL_SCALE;
+
+var player = {};
+
+player.getAssets = () => {
+  return [
+    { path: 'test.png', type: Asset.TYPE_TEXTURE, format: Texture.FORMAT_RGBA }
+  ];
+}
+
+player.init = function(scene) {
+  var texture = scene.assets.getAssetByPath('test.png');
+  Console.print('Player init: got texture ' + texture);
+
+  _entity   = Entity.create();
+  _position = _entity.add(Component.POSITION);
+  _physics  = _entity.add(Component.PHYSICS);
+
+  _physics.bodyType   = Physics.DYNAMIC;
+  _physics.shape      = Physics.SHAPE_CUBE;
+  _physics.gravityScale = 1.0;
+
+  var r       = _entity.add(Component.RENDERABLE);
+  r.texture   = texture.texture;
+  r.type      = Renderable.SPRITEBATCH;
+  r.color     = new Color(220, 80, 80);
+  // Upright quad centered on X, bottom-aligned on Y.
+  r.sprites = [[-PLAYER_W/2, 0, 0, PLAYER_W/2, PLAYER_H, 0, 0, 1, 1, 0]];
+
+  _position.localPosition = new Vec3(0, PLAYER_H, 0);
+};
+
+player.getPosition = function() {
+  return _position;
+};
+
+player.update = function() {
+  if(!_physics) return;
+  var vx = Input.axis(INPUT_ACTION_LEFT, INPUT_ACTION_RIGHT) * PLAYER_SPEED;
+  var vz = Input.axis(INPUT_ACTION_DOWN, INPUT_ACTION_UP) * PLAYER_SPEED;
+  // Preserve vertical velocity so gravity and landing work correctly.
+  var vy = _physics.velocity.y;
+  _physics.velocity = new Vec3(vx, vy, vz);
+};
+
+player.dispose = function() {
+  Entity.dispose(_entity);
+  _entity   = null;
+  _position = null;
+  _physics  = null;
+};
+
+module.exports = player;
@@ -1,48 +1,42 @@
-var scene = {};
+// Copyright (c) 2026 Dominic Masters
+//
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT

-// var assets = AssetBatch([
-//   { path: 'test.png', type: Asset.TYPE_TEXTURE, format: Texture.FORMAT_RGBA }
-// ]);
+var scene  = {};

-var cam;
-var camPos;
-var testEntity;
-var testPos;
-var testRenderable;
-var texEntry;
+// Pokemon DS-style camera: ~34 degrees elevation (atan(6/9)).
+// CAM_HEIGHT / CAM_DIST ratio controls the tilt - keep it under 0.7 for
+// the characteristically shallow DS angle.
+const CAM_HEIGHT = 6;
+const CAM_DIST   = 9;

-scene.init = function() {
-  // assets.lock();
-  // await assets.loaded();
-
-  Console.print('Scene Init');
-  // texEntry = assets.entry(0);
-
-  // Camera at (3, 3, 3) looking at origin
-  cam    = Entity.create();
-  camPos = cam.add(Component.POSITION);
-  cam.add(Component.CAMERA);
+scene.init = async function() {
+  // Camera
+  scene.cam = Entity.create();
+  var camPos = scene.cam.add(Component.POSITION);
+  var cam = scene.cam.add(Component.CAMERA);
  camPos.localPosition = new Vec3(3, 3, 3);
  camPos.lookAt(new Vec3(0, 0, 0));
+  
+  // Floor - large flat slab, no texture needed.
+  scene.floor = Entity.create();
+  var floorPos = scene.floor.add(Component.POSITION);
+  var floorR = scene.floor.add(Component.RENDERABLE);
+  floorR.type  = Renderable.SHADER_MATERIAL;
+  floorR.color = Color.BLUE;
+  // floorPos.localScale = new Vec3(16, 0.2, 16);
+  // floorPos.localPosition = new Vec3(0, -0.1, 0);

-  // Test entity with textured quad at origin
-  testEntity = Entity.create();
-  testPos = testEntity.add(Component.POSITION);
-  testRenderable = testEntity.add(Component.RENDERABLE);
-
-  // testRenderable.texture = texEntry.texture;
-  // testRenderable.type = Renderable.SPRITEBATCH;
-  // testRenderable.sprites = [
-  //   [0, 0, 1, 1, 0, 1, 1, 0]
-  // ];
-  // testPos.localPosition = new Vec3(0, 0, 0);
-}
-
-scene.dispose = function() {
-  Console.print('Scene Dispose');
-  Entity.dispose(cam);
-  Entity.dispose(testEntity);
-  // assets.unlock();
+  await UIFullboxOver.transition(Color.BLACK, Color.TRANSPARENT, 1.0);
 };

-module.exports = scene;
+scene.update = function() {
+};
+
+scene.dispose = function() {
+  Entity.dispose(scene.floor);
+  Entity.dispose(scene.cam);
+};
+
+module.exports = scene;
@@ -1,96 +0,0 @@
-# Copyright (c) 2026 Dominic Masters
-#
-# This software is released under the MIT License.
-# https://opensource.org/licenses/MIT
-
-# Turn things off we don't need
-set(JERRY_CMDLINE OFF CACHE BOOL "" FORCE)
-set(JERRY_EXT ON CACHE BOOL "" FORCE)
-set(JERRY_DEBUGGER OFF CACHE BOOL "" FORCE)
-set(JERRY_BUILTIN_DATE OFF CACHE BOOL "" FORCE)
-set(ENABLE_LTO OFF CACHE BOOL "" FORCE)
-
-# Fetch Jerry
-include(FetchContent)
-FetchContent_Declare(
-  jerryscript
-  GIT_REPOSITORY https://git.wish.moe/YourWishes/jerryscript
-  GIT_TAG float32-fix
-)
-FetchContent_MakeAvailable(jerryscript)
-
-# Mark found
-set(jerryscript_FOUND ON)
-
-# Define targets
-if(TARGET jerryscript-core)
-  set(JERRY_CORE_TARGET jerryscript-core)
-elseif(TARGET jerry-core)
-  set(JERRY_CORE_TARGET jerry-core)
-endif()
-
-if(TARGET jerryscript-ext)
-  set(JERRY_EXT_TARGET jerryscript-ext)
-elseif(TARGET jerry-ext)
-  set(JERRY_EXT_TARGET jerry-ext)
-endif()
-
-if(TARGET jerryscript-port-default)
-  set(JERRY_PORT_TARGET jerryscript-port-default)
-elseif(TARGET jerry-port-default)
-  set(JERRY_PORT_TARGET jerry-port-default)
-elseif(TARGET jerryscript-port)
-  set(JERRY_PORT_TARGET jerryscript-port)
-elseif(TARGET jerry-port)
-  set(JERRY_PORT_TARGET jerry-port)
-endif()
-
-if(NOT JERRY_CORE_TARGET)
-  message(FATAL_ERROR "JerryScript core target not found")
-endif()
-
-if(NOT JERRY_EXT_TARGET)
-  message(FATAL_ERROR "JerryScript ext target not found")
-endif()
-
-if(NOT JERRY_PORT_TARGET)
-  message(FATAL_ERROR "JerryScript port target not found")
-endif()
-
-foreach(tgt IN ITEMS
-  ${JERRY_CORE_TARGET}
-  ${JERRY_EXT_TARGET}
-  ${JERRY_PORT_TARGET}
-)
-  if(TARGET ${tgt})
-    set_property(TARGET ${tgt} PROPERTY INTERPROCEDURAL_OPTIMIZATION OFF)
-    target_compile_definitions(${JERRY_CORE_TARGET} PRIVATE
-      JERRY_NUMBER_TYPE_FLOAT64=0
-      JERRY_BUILTIN_DATE=0
-    )
-  endif()
-endforeach()
-
-# Export include dirs through the targets
-target_include_directories(${JERRY_CORE_TARGET} INTERFACE
-  ${jerryscript_SOURCE_DIR}/jerry-core/include
-)
-
-target_include_directories(${JERRY_EXT_TARGET} INTERFACE
-  ${jerryscript_SOURCE_DIR}/jerry-ext/include
-)
-
-target_include_directories(${JERRY_PORT_TARGET} INTERFACE
-  ${jerryscript_SOURCE_DIR}/jerry-port/default/include
-)
-
-# Suppress JerryScript-only warning
-if(CMAKE_C_COMPILER_ID MATCHES "GNU|Clang")
-  target_compile_options(${JERRY_CORE_TARGET} PRIVATE
-    -Wno-error
-  )
-endif()
-
-add_library(jerryscript::core ALIAS ${JERRY_CORE_TARGET})
-add_library(jerryscript::ext ALIAS ${JERRY_EXT_TARGET})
-add_library(jerryscript::port ALIAS ${JERRY_PORT_TARGET})
@@ -1,43 +0,0 @@
-# Copyright (c) 2026 Dominic Masters
-#
-# This software is released under the MIT License.
-# https://opensource.org/licenses/MIT
-
-# dusk_embed_js(TARGET JS_FILE [NAME identifier])
-#
-# Converts a JS file into a C string header in DUSK_GENERATED_HEADERS_DIR.
-# The generated header defines:
-#   static const char <NAME>[] = "...";
-#   static const size_t <NAME>_SIZE = sizeof(<NAME>) - 1;
-#
-# NAME defaults to the uppercase stem + "_JS" (e.g. scene.js -> SCENE_JS).
-function(dusk_embed_js TARGET JS_FILE)
-  cmake_parse_arguments(ARG "" "NAME" "" ${ARGN})
-
-  get_filename_component(JS_ABS "${JS_FILE}" ABSOLUTE)
-  get_filename_component(JS_STEM "${JS_FILE}" NAME_WE)
-
-  set(OUTPUT_HEADER "${DUSK_GENERATED_HEADERS_DIR}/${JS_STEM}_js.h")
-
-  set(NAME_ARG "")
-  if(ARG_NAME)
-    set(NAME_ARG "--name" "${ARG_NAME}")
-  endif()
-
-  add_custom_command(
-    OUTPUT "${OUTPUT_HEADER}"
-    COMMAND ${Python3_EXECUTABLE} -m tools.js2c
-      --input "${JS_ABS}"
-      --output "${OUTPUT_HEADER}"
-      ${NAME_ARG}
-    WORKING_DIRECTORY "${DUSK_ROOT_DIR}"
-    DEPENDS "${JS_ABS}"
-    COMMENT "js2c: ${JS_STEM}.js -> ${JS_STEM}_js.h"
-    VERBATIM
-  )
-
-  file(RELATIVE_PATH JS_REL "${DUSK_ROOT_DIR}" "${JS_ABS}")
-  string(MAKE_C_IDENTIFIER "dusk_js2c_${JS_REL}" JS_TARGET)
-  add_custom_target(${JS_TARGET} DEPENDS "${OUTPUT_HEADER}")
-  add_dependencies(${TARGET} ${JS_TARGET})
-endfunction()
@@ -1,3 +1,7 @@
 #!/bin/bash
 docker build -t dusk-linux -f docker/linux/Dockerfile .
-docker run --rm -v "$(pwd):/workdir" dusk-linux /bin/bash -c "./scripts/test-linux.sh"
+docker run \
+  --rm \
+  -v "${GITHUB_WORKSPACE}:/workdir" \
+  dusk-linux \
+  /bin/bash -c "./scripts/test-linux.sh"
@@ -32,15 +32,6 @@ if(NOT yyjson_FOUND)
  endif()
 endif()

-if(NOT jerryscript_FOUND)
-  find_package(jerryscript REQUIRED)
-  target_link_libraries(${DUSK_LIBRARY_TARGET_NAME} PUBLIC
-    jerryscript::core
-    jerryscript::ext
-    jerryscript::port
-  )
-endif()
-
 if(DUSK_BACKTRACE)
  target_link_options(${DUSK_LIBRARY_TARGET_NAME} PUBLIC -rdynamic)
  target_compile_definitions(${DUSK_BINARY_TARGET_NAME} PUBLIC
@@ -66,24 +57,19 @@ add_subdirectory(event)
 add_subdirectory(assert)
 add_subdirectory(asset)
 add_subdirectory(cutscene)
-add_subdirectory(item)
-add_subdirectory(story)
 add_subdirectory(console)
 add_subdirectory(display)
 add_subdirectory(log)
 add_subdirectory(engine)
-add_subdirectory(entity)
 add_subdirectory(error)
 add_subdirectory(input)
 add_subdirectory(locale)
-add_subdirectory(physics)
+add_subdirectory(rpg)
 add_subdirectory(scene)
-add_subdirectory(script)
 add_subdirectory(system)
 add_subdirectory(time)
 add_subdirectory(ui)
 add_subdirectory(network)
-add_subdirectory(overworld)
 add_subdirectory(save)
 add_subdirectory(util)
 add_subdirectory(thread)
@@ -6,7 +6,7 @@
 #include "animation.h"
 #include "assert/assert.h"
 #include "util/memory.h"
-#include "util/math.h"
+#include "util/fixed.h"

 void animationInit(
  animation_t *anim,
@@ -21,12 +21,12 @@ void animationInit(
  anim->keyframeCount = keyframeCount;
 }

-float_t animationGetValue(animation_t *anim, const float_t time) {
+fixed_t animationGetValue(animation_t *anim, const fixed_t time) {
  assertNotNull(anim, "Animation pointer cannot be null.");
  assertNotNull(anim->keyframes, "Keyframes pointer cannot be null.");
  assertTrue(anim->keyframeCount > 0, "Keyframe count invalid.");
  assertTrue(time >= 0, "Time must be non-negative.");
-  
+
  keyframe_t *start;
  keyframe_t *end;
  keyframe_t *last = anim->keyframes + anim->keyframeCount - 1;
@@ -47,6 +47,13 @@ float_t animationGetValue(animation_t *anim, const float_t time) {
    }
  } while(true);

-  float_t t = (time - start->time) / (end->time - start->time);
-  return mathLerp(start->value, end->value, easingApply(start->easing, t));
+  fixed_t span = fixedSub(end->time, start->time);
+  fixed_t progress = span != 0
+    ? fixedDiv(fixedSub(time, start->time), span)
+    : FIXED_ONE;
+  return fixedLerp(
+    start->value,
+    end->value,
+    easingApply(start->easing, progress)
+  );
 }
@@ -31,4 +31,4 @@ void animationInit(
 * @param time The time at which to get the value, in seconds.
 * @return The value of the animation at the given time.
 */
-float_t animationGetValue(animation_t *anim, const float_t time);
+fixed_t animationGetValue(animation_t *anim, const fixed_t time);
@@ -6,6 +6,11 @@
 #include "easing.h"
 #include "assert/assert.h"
 #include "util/math.h"
+#include "util/fixed.h"
+
+#define EASING_C1 1.70158f
+#define EASING_C2 (EASING_C1 * 1.525f)
+#define EASING_C3 (EASING_C1 + 1.0f)

 const easingfn_t EASING_FUNCTIONS[EASING_COUNT] = {
  easingLinear,
@@ -26,86 +31,101 @@ const easingfn_t EASING_FUNCTIONS[EASING_COUNT] = {
  easingInOutBack,
 };

-float_t easingApply(const easingtype_t type, const float_t t) {
+fixed_t easingApply(const easingtype_t type, const fixed_t t) {
  assertTrue(type < EASING_COUNT, "Invalid easing type");
  return EASING_FUNCTIONS[type](t);
 }

-float_t easingLinear(const float_t t) {
+fixed_t easingLinear(const fixed_t t) {
  return t;
 }

-float_t easingInSine(const float_t t) {
-  return 1.0f - cosf(t * MATH_PI * 0.5f);
+fixed_t easingInSine(const fixed_t t) {
+  float_t f = fixedToFloat(t);
+  return fixedFromFloat(1.0f - cosf(f * MATH_PI * 0.5f));
 }

-float_t easingOutSine(const float_t t) {
-  return sinf(t * MATH_PI * 0.5f);
+fixed_t easingOutSine(const fixed_t t) {
+  float_t f = fixedToFloat(t);
+  return fixedFromFloat(sinf(f * MATH_PI * 0.5f));
 }

-float_t easingInOutSine(const float_t t) {
-  return -(cosf(MATH_PI * t) - 1.0f) * 0.5f;
+fixed_t easingInOutSine(const fixed_t t) {
+  float_t f = fixedToFloat(t);
+  return fixedFromFloat(-(cosf(MATH_PI * f) - 1.0f) * 0.5f);
 }

-float_t easingInQuad(const float_t t) {
-  return t * t;
+fixed_t easingInQuad(const fixed_t t) {
+  float_t f = fixedToFloat(t);
+  return fixedFromFloat(f * f);
 }

-float_t easingOutQuad(const float_t t) {
-  float_t u = 1.0f - t;
-  return 1.0f - u * u;
+fixed_t easingOutQuad(const fixed_t t) {
+  float_t f = fixedToFloat(t);
+  float_t u = 1.0f - f;
+  return fixedFromFloat(1.0f - u * u);
 }

-float_t easingInOutQuad(const float_t t) {
-  if(t < 0.5f) return 2.0f * t * t;
-  float_t u = -2.0f * t + 2.0f;
-  return 1.0f - u * u * 0.5f;
+fixed_t easingInOutQuad(const fixed_t t) {
+  float_t f = fixedToFloat(t);
+  if(f < 0.5f) return fixedFromFloat(2.0f * f * f);
+  float_t u = -2.0f * f + 2.0f;
+  return fixedFromFloat(1.0f - u * u * 0.5f);
 }

-float_t easingInCubic(const float_t t) {
-  return t * t * t;
+fixed_t easingInCubic(const fixed_t t) {
+  float_t f = fixedToFloat(t);
+  return fixedFromFloat(f * f * f);
 }

-float_t easingOutCubic(const float_t t) {
-  float_t u = 1.0f - t;
-  return 1.0f - u * u * u;
+fixed_t easingOutCubic(const fixed_t t) {
+  float_t f = fixedToFloat(t);
+  float_t u = 1.0f - f;
+  return fixedFromFloat(1.0f - u * u * u);
 }

-float_t easingInOutCubic(const float_t t) {
-  if(t < 0.5f) return 4.0f * t * t * t;
-  float_t u = -2.0f * t + 2.0f;
-  return 1.0f - u * u * u * 0.5f;
+fixed_t easingInOutCubic(const fixed_t t) {
+  float_t f = fixedToFloat(t);
+  if(f < 0.5f) return fixedFromFloat(4.0f * f * f * f);
+  float_t u = -2.0f * f + 2.0f;
+  return fixedFromFloat(1.0f - u * u * u * 0.5f);
 }

-float_t easingInQuart(const float_t t) {
-  return t * t * t * t;
+fixed_t easingInQuart(const fixed_t t) {
+  float_t f = fixedToFloat(t);
+  return fixedFromFloat(f * f * f * f);
 }

-float_t easingOutQuart(const float_t t) {
-  float_t u = 1.0f - t;
-  return 1.0f - u * u * u * u;
+fixed_t easingOutQuart(const fixed_t t) {
+  float_t f = fixedToFloat(t);
+  float_t u = 1.0f - f;
+  return fixedFromFloat(1.0f - u * u * u * u);
 }

-float_t easingInOutQuart(const float_t t) {
-  if(t < 0.5f) return 8.0f * t * t * t * t;
-  float_t u = -2.0f * t + 2.0f;
-  return 1.0f - u * u * u * u * 0.5f;
+fixed_t easingInOutQuart(const fixed_t t) {
+  float_t f = fixedToFloat(t);
+  if(f < 0.5f) return fixedFromFloat(8.0f * f * f * f * f);
+  float_t u = -2.0f * f + 2.0f;
+  return fixedFromFloat(1.0f - u * u * u * u * 0.5f);
 }

-float_t easingInBack(const float_t t) {
-  return EASING_C3 * t * t * t - EASING_C1 * t * t;
+fixed_t easingInBack(const fixed_t t) {
+  float_t f = fixedToFloat(t);
+  return fixedFromFloat(EASING_C3 * f * f * f - EASING_C1 * f * f);
 }

-float_t easingOutBack(const float_t t) {
-  float_t u = t - 1.0f;
-  return 1.0f + EASING_C3 * u * u * u + EASING_C1 * u * u;
+fixed_t easingOutBack(const fixed_t t) {
+  float_t f = fixedToFloat(t);
+  float_t u = f - 1.0f;
+  return fixedFromFloat(1.0f + EASING_C3 * u * u * u + EASING_C1 * u * u);
 }

-float_t easingInOutBack(const float_t t) {
-  if(t < 0.5f) {
-    float_t u = 2.0f * t;
-    return u * u * ((EASING_C2 + 1.0f) * u - EASING_C2) * 0.5f;
+fixed_t easingInOutBack(const fixed_t t) {
+  float_t f = fixedToFloat(t);
+  if(f < 0.5f) {
+    float_t u = 2.0f * f;
+    return fixedFromFloat(u * u * ((EASING_C2 + 1.0f) * u - EASING_C2) * 0.5f);
  }
-  float_t u = 2.0f * t - 2.0f;
-  return (u * u * ((EASING_C2 + 1.0f) * u + EASING_C2) + 2.0f) * 0.5f;
+  float_t u = 2.0f * f - 2.0f;
+  return fixedFromFloat((u * u * ((EASING_C2 + 1.0f) * u + EASING_C2) + 2.0f) * 0.5f);
 }
@@ -5,11 +5,7 @@

 #pragma once
 #include "dusk.h"
-
-#define EASING_PI 3.14159265358979323846f
-#define EASING_C1 1.70158f
-#define EASING_C2 (EASING_C1 * 1.525f)
-#define EASING_C3 (EASING_C1 + 1.0f)
+#include "util/fixed.h"

 typedef enum {
  EASING_LINEAR,
@@ -32,32 +28,32 @@ typedef enum {
  EASING_COUNT
 } easingtype_t;

-typedef float_t (*easingfn_t)(const float_t t);
+typedef fixed_t (*easingfn_t)(const fixed_t t);

 extern const easingfn_t EASING_FUNCTIONS[EASING_COUNT];

 /**
 * Applies the specified easing function to t.
- * 
+ *
 * @param type The easing type to apply.
- * @param t The input time, in the range [0, 1].
- * @return The eased value, in the range [0, 1].
+ * @param t The input progress in [0, FIXED_ONE].
+ * @return The eased value in [0, FIXED_ONE].
 */
-float_t easingApply(const easingtype_t type, const float_t t);
+fixed_t easingApply(const easingtype_t type, const fixed_t t);

-float_t easingLinear(const float_t t);
-float_t easingInSine(const float_t t);
-float_t easingOutSine(const float_t t);
-float_t easingInOutSine(const float_t t);
-float_t easingInQuad(const float_t t);
-float_t easingOutQuad(const float_t t);
-float_t easingInOutQuad(const float_t t);
-float_t easingInCubic(const float_t t);
-float_t easingOutCubic(const float_t t);
-float_t easingInOutCubic(const float_t t);
-float_t easingInQuart(const float_t t);
-float_t easingOutQuart(const float_t t);
-float_t easingInOutQuart(const float_t t);
-float_t easingInBack(const float_t t);
-float_t easingOutBack(const float_t t);
-float_t easingInOutBack(const float_t t);
+fixed_t easingLinear(const fixed_t t);
+fixed_t easingInSine(const fixed_t t);
+fixed_t easingOutSine(const fixed_t t);
+fixed_t easingInOutSine(const fixed_t t);
+fixed_t easingInQuad(const fixed_t t);
+fixed_t easingOutQuad(const fixed_t t);
+fixed_t easingInOutQuad(const fixed_t t);
+fixed_t easingInCubic(const fixed_t t);
+fixed_t easingOutCubic(const fixed_t t);
+fixed_t easingInOutCubic(const fixed_t t);
+fixed_t easingInQuart(const fixed_t t);
+fixed_t easingOutQuart(const fixed_t t);
+fixed_t easingInOutQuart(const fixed_t t);
+fixed_t easingInBack(const fixed_t t);
+fixed_t easingOutBack(const fixed_t t);
+fixed_t easingInOutBack(const fixed_t t);
@@ -5,9 +5,10 @@

 #pragma once
 #include "easing.h"
+#include "util/fixed.h"

 typedef struct {
-  float_t time;
-  float_t value;
+  fixed_t time;
+  fixed_t value;
  easingtype_t easing;
 } keyframe_t;
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2023 Dominic Masters
+ * Copyright (c) 2026 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2023 Dominic Masters
+ * Copyright (c) 2026 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2025 Dominic Masters
+ * Copyright (c) 2026 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
@@ -173,7 +173,10 @@ void assetUnlock(const char_t *name) {

  assetentry_t *entry = ASSET.entries;
  do {
-    if(entry->type != ASSET_LOADER_TYPE_NULL && stringEquals(entry->name, name)) {
+    if(
+      entry->type != ASSET_LOADER_TYPE_NULL &&
+      stringEquals(entry->name, name)
+    ) {
      assetEntryUnlock(entry);
      return;
    }
@@ -408,21 +411,6 @@ errorret_t assetDispose(void) {
  assertIsMainThread("Must be called from the main thread.");
  threadStop(&ASSET.loadThread);

-  // Free any script read-buffers left behind by an in-flight async load
-  // that was interrupted before the sync eval phase ran.
-  for(size_t i = 0; i < ASSET_LOADING_COUNT_MAX; i++) {
-    assetloading_t *loading = &ASSET.loading[i];
-    if(
-      loading->entry != NULL &&
-      loading->type == ASSET_LOADER_TYPE_SCRIPT &&
-      loading->loading.script.buffer != NULL
-    ) {
-      memoryFree(loading->loading.script.buffer);
-      loading->loading.script.buffer = NULL;
-    }
-    threadMutexDispose(&loading->mutex);
-  }
-
  // Dispose every non-null entry so type-specific dispose callbacks
  // (e.g. assetScriptDispose freeing jerry values) run before the
  // scripting engine is torn down.
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2025 Dominic Masters
+ * Copyright (c) 2026 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
@@ -56,7 +56,7 @@ errorret_t assetInit(void);
 bool_t assetFileExists(const char_t *filename);

 /**
- * Gets, or creates, a new asset entry. Internal — prefer assetLock.
+ * Gets, or creates, a new asset entry. Internal - prefer assetLock.
 *
 * @param name Filename of the asset.
 * @param type Type of the asset.
@@ -11,38 +11,6 @@
 #include "util/memory.h"
 #include <unistd.h>

-/* ---- Per-entry event trampolines ----------------------------------------- */
-
-static void assetBatchEntryOnLoadedCb(void *params, void *user) {
-  assetentry_t *entry = (assetentry_t *)params;
-  assetbatch_t *batch = (assetbatch_t *)user;
-
-  batch->loadedCount++;
-  eventInvoke(&batch->onEntryLoaded, entry);
-
-  if((uint16_t)(batch->loadedCount + batch->errorCount) >= batch->count) {
-    if(batch->errorCount == 0) {
-      eventInvoke(&batch->onLoaded, batch);
-    } else {
-      eventInvoke(&batch->onError, batch);
-    }
-  }
-}
-
-static void assetBatchEntryOnErrorCb(void *params, void *user) {
-  assetentry_t *entry = (assetentry_t *)params;
-  assetbatch_t *batch = (assetbatch_t *)user;
-
-  batch->errorCount++;
-  eventInvoke(&batch->onEntryError, entry);
-
-  if((uint16_t)(batch->loadedCount + batch->errorCount) >= batch->count) {
-    eventInvoke(&batch->onError, batch);
-  }
-}
-
-/* ---- Public API ---------------------------------------------------------- */
-
 void assetBatchInit(
  assetbatch_t *batch,
  const uint16_t count,
@@ -51,7 +19,9 @@ void assetBatchInit(
  assertNotNull(batch, "Batch cannot be NULL.");
  assertNotNull(descs, "Descs cannot be NULL.");
  assertTrue(count > 0, "Count must be greater than 0.");
-  assertTrue(count <= ASSET_BATCH_COUNT_MAX, "Count exceeds ASSET_BATCH_COUNT_MAX.");
+  assertTrue(
+    count <= ASSET_BATCH_COUNT_MAX, "Count exceeds ASSET_BATCH_COUNT_MAX."
+  );

  memoryZero(batch, sizeof(assetbatch_t));
  batch->count = count;
@@ -62,7 +32,9 @@ void assetBatchInit(
  );
  eventInit(
    &batch->onEntryLoaded,
-    batch->onEntryLoadedCallbacks, batch->onEntryLoadedUsers, ASSET_BATCH_EVENT_MAX
+    batch->onEntryLoadedCallbacks,
+    batch->onEntryLoadedUsers,
+    ASSET_BATCH_EVENT_MAX
  );
  eventInit(
    &batch->onError,
@@ -70,15 +42,19 @@ void assetBatchInit(
  );
  eventInit(
    &batch->onEntryError,
-    batch->onEntryErrorCallbacks, batch->onEntryErrorUsers, ASSET_BATCH_EVENT_MAX
+    batch->onEntryErrorCallbacks,
+    batch->onEntryErrorUsers,
+    ASSET_BATCH_EVENT_MAX
  );

  for(uint16_t i = 0; i < count; i++) {
    batch->inputs[i] = descs[i].input;
-    batch->entries[i] = assetLock(descs[i].path, descs[i].type, &batch->inputs[i]);
+    batch->entries[i] = assetLock(
+      descs[i].path, descs[i].type, &batch->inputs[i]
+    );

    if(batch->entries[i]->state == ASSET_ENTRY_STATE_LOADED) {
-      /* Already loaded (cached) — count it now, no subscription needed. */
+      // Already loaded (cached) - count it now, no subscription needed.
      batch->loadedCount++;
    } else if(batch->entries[i]->state == ASSET_ENTRY_STATE_ERROR) {
      batch->errorCount++;
@@ -151,11 +127,39 @@ void assetBatchDispose(assetbatch_t *batch) {
  assertNotNull(batch, "Batch cannot be NULL.");
  for(uint16_t i = 0; i < batch->count; i++) {
    if(batch->entries[i]) {
-      /* Unsubscribe while we still hold a lock so the entry is guaranteed live. */
+      // Unsubscribe while we still hold a lock so the entry is live.
      eventUnsubscribe(&batch->entries[i]->onLoaded, assetBatchEntryOnLoadedCb);
-      eventUnsubscribe(&batch->entries[i]->onError,  assetBatchEntryOnErrorCb);
+      eventUnsubscribe(&batch->entries[i]->onError, assetBatchEntryOnErrorCb);
      assetUnlockEntry(batch->entries[i]);
    }
  }
  memoryZero(batch, sizeof(assetbatch_t));
 }
+
+void assetBatchEntryOnLoadedCb(void *params, void *user) {
+  assetentry_t *entry = (assetentry_t *)params;
+  assetbatch_t *batch = (assetbatch_t *)user;
+
+  batch->loadedCount++;
+  eventInvoke(&batch->onEntryLoaded, entry);
+
+  if((uint16_t)(batch->loadedCount + batch->errorCount) >= batch->count) {
+    if(batch->errorCount == 0) {
+      eventInvoke(&batch->onLoaded, batch);
+    } else {
+      eventInvoke(&batch->onError, batch);
+    }
+  }
+}
+
+void assetBatchEntryOnErrorCb(void *params, void *user) {
+  assetentry_t *entry = (assetentry_t *)params;
+  assetbatch_t *batch = (assetbatch_t *)user;
+
+  batch->errorCount++;
+  eventInvoke(&batch->onEntryError, entry);
+
+  if((uint16_t)(batch->loadedCount + batch->errorCount) >= batch->count) {
+    eventInvoke(&batch->onError, batch);
+  }
+}
@@ -26,17 +26,17 @@ typedef struct {
  uint16_t loadedCount;
  uint16_t errorCount;

-  /** Fires once when every entry has loaded successfully. params = assetbatch_t * */
+  /** Fires once when every entry loaded. params = assetbatch_t * */
  event_t onLoaded;
  eventcallback_t onLoadedCallbacks[ASSET_BATCH_EVENT_MAX];
  void *onLoadedUsers[ASSET_BATCH_EVENT_MAX];

-  /** Fires each time a single entry finishes loading. params = assetentry_t * */
+  /** Fires each time a single entry loads. params = assetentry_t * */
  event_t onEntryLoaded;
  eventcallback_t onEntryLoadedCallbacks[ASSET_BATCH_EVENT_MAX];
  void *onEntryLoadedUsers[ASSET_BATCH_EVENT_MAX];

-  /** Fires once when all entries have finished (any with errors). params = assetbatch_t * */
+  /** Fires when all entries finish (any with errors). params: assetbatch_t * */
  event_t onError;
  eventcallback_t onErrorCallbacks[ASSET_BATCH_EVENT_MAX];
  void *onErrorUsers[ASSET_BATCH_EVENT_MAX];
@@ -104,3 +104,21 @@ errorret_t assetBatchRequireLoaded(assetbatch_t *batch);
 * @param batch Batch to dispose.
 */
 void assetBatchDispose(assetbatch_t *batch);
+
+/**
+ * Event trampoline invoked when a batch entry finishes loading.
+ * Increments the loaded counter and fires batch-level events.
+ *
+ * @param params The loaded assetentry_t pointer.
+ * @param user   The owning assetbatch_t pointer.
+ */
+void assetBatchEntryOnLoadedCb(void *params, void *user);
+
+/**
+ * Event trampoline invoked when a batch entry fails to load.
+ * Increments the error counter and fires batch-level events.
+ *
+ * @param params The errored assetentry_t pointer.
+ * @param user   The owning assetbatch_t pointer.
+ */
+void assetBatchEntryOnErrorCb(void *params, void *user);
@@ -125,7 +125,10 @@ errorret_t assetFileReadEntire(
  assertNotNull(file, "Asset file cannot be NULL.");
  assertNotNull(outBuffer, "outBuffer cannot be NULL.");
  assertNotNull(outSize, "outSize cannot be NULL.");
-  assertTrue(file->size > 0, "Asset file has no size; call assetFileInit first.");
+  assertTrue(
+    file->size > 0,
+    "Asset file has no size; call assetFileInit first."
+  );

  // File should be closed currently.
  assertNull(file->zipFile, "Asset file must be closed before reading entire.");
@@ -14,5 +14,4 @@ target_sources(${DUSK_LIBRARY_TARGET_NAME}
 # Subdirs
 add_subdirectory(display)
 add_subdirectory(locale)
-add_subdirectory(json)
-add_subdirectory(script)
+add_subdirectory(json)
@@ -39,10 +39,4 @@ assetloadercallbacks_t ASSET_LOADER_CALLBACKS[ASSET_LOADER_TYPE_COUNT] = {
    .loadAsync = assetJsonLoaderAsync,
    .dispose = assetJsonDispose
  },
-
-  [ASSET_LOADER_TYPE_SCRIPT] = {
-    .loadSync = assetScriptLoaderSync,
-    .loadAsync = assetScriptLoaderAsync,
-    .dispose = assetScriptDispose
-  },
 };
@@ -11,7 +11,6 @@
 #include "asset/loader/display/assettilesetloader.h"
 #include "asset/loader/locale/assetlocaleloader.h"
 #include "asset/loader/json/assetjsonloader.h"
-#include "asset/loader/script/assetscriptloader.h"

 typedef enum {
  ASSET_LOADER_TYPE_NULL,
@@ -21,7 +20,6 @@ typedef enum {
  ASSET_LOADER_TYPE_TILESET,
  ASSET_LOADER_TYPE_LOCALE,
  ASSET_LOADER_TYPE_JSON,
-  ASSET_LOADER_TYPE_SCRIPT,

  ASSET_LOADER_TYPE_COUNT
 } assetloadertype_t;
@@ -32,7 +30,6 @@ typedef union {
  assettilesetloaderinput_t tileset;
  assetlocaleloaderinput_t locale;
  assetjsonloaderinput_t json;
-  assetscriptloaderinput_t script;
 } assetloaderinput_t;

 typedef union {
@@ -41,7 +38,6 @@ typedef union {
  assettilesetloaderloading_t tileset;
  assetlocaleloaderloading_t locale;
  assetjsonloaderloading_t json;
-  assetscriptloaderloading_t script;
 } assetloaderloading_t;

 typedef union {
@@ -50,7 +46,6 @@ typedef union {
  assettilesetoutput_t tileset;
  assetlocaleoutput_t locale;
  assetjsonoutput_t json;
-  assetscriptoutput_t script;
 } assetloaderoutput_t;

 typedef struct assetloading_s assetloading_t;
@@ -23,7 +23,9 @@ errorret_t assetMeshLoaderAsync(assetloading_t *loading) {
  assetfile_t *file = &loading->loading.mesh.file;
  assetmeshinputaxis_t axis = loading->entry->inputData.mesh;

-  assetLoaderErrorChain(loading, assetFileInit(file, loading->entry->name, NULL, NULL));
+  assetLoaderErrorChain(loading,
+    assetFileInit(file, loading->entry->name, NULL, NULL)
+  );
  assetLoaderErrorChain(loading, assetFileOpen(file));

  // Skip the 80-byte STL header.
@@ -33,7 +35,9 @@ errorret_t assetMeshLoaderAsync(assetloading_t *loading) {
  }

  uint32_t triangleCount;
-  assetLoaderErrorChain(loading, assetFileRead(file, &triangleCount, sizeof(uint32_t)));
+  assetLoaderErrorChain(loading,
+    assetFileRead(file, &triangleCount, sizeof(uint32_t))
+  );
  if(file->lastRead != sizeof(uint32_t)) {
    assetLoaderErrorThrow(loading, "Failed to read tri count");
  }
@@ -75,7 +79,9 @@ errorret_t assetMeshLoaderAsync(assetloading_t *loading) {
      verts[i * 3 + j].uv[1] = 0.0f;

      for(uint8_t k = 0; k < 3; k++) {
-        verts[i * 3 + j].pos[k] = endianLittleToHostFloat(triData.positions[j][k]);
+        verts[i * 3 + j].pos[k] = endianLittleToHostFloat(
+          triData.positions[j][k]
+        );
      }

      switch(axis) {
@@ -103,7 +103,9 @@ errorret_t assetTextureLoaderAsync(assetloading_t *loading) {
  // Ensure we loaded correctly.
  if(loading->loading.texture.data == NULL) {
    const char_t *errorStr = stbi_failure_reason();
-    assetLoaderErrorThrow(loading, "Failed to load texture from file %s.", errorStr);
+    assetLoaderErrorThrow(
+      loading, "Failed to load texture from file %s.", errorStr
+    );
  }

  // Fixes a specific bug probably with Dolphin but for now just assuming endian
@@ -23,14 +23,19 @@ errorret_t assetTilesetLoaderAsync(assetloading_t *loading) {
  assertNull(loading->loading.tileset.data, "Data already defined?");

  assetfile_t *file = &loading->loading.tileset.file;
-  assetLoaderErrorChain(loading, assetFileInit(file, loading->entry->name, NULL, NULL));
+  assetLoaderErrorChain(loading,
+    assetFileInit(file, loading->entry->name, NULL, NULL)
+  );

  uint8_t *data = memoryAllocate(file->size);
  assetLoaderErrorChain(loading, assetFileOpen(file));
  assetLoaderErrorChain(loading, assetFileRead(file, data, file->size));
  assetLoaderErrorChain(loading, assetFileClose(file));
  assetLoaderErrorChain(loading, assetFileDispose(file));
-  assertTrue(file->lastRead == file->size, "Failed to read entire tileset file.");
+  assertTrue(
+    file->lastRead == file->size,
+    "Failed to read entire tileset file."
+  );

  loading->loading.tileset.data = data;
  loading->loading.tileset.state = ASSET_TILESET_LOADING_STATE_PARSE;
@@ -22,7 +22,9 @@ errorret_t assetJsonLoaderAsync(assetloading_t *loading) {
  assertNull(loading->loading.json.buffer, "Buffer already defined?");

  assetfile_t *file = &loading->loading.json.file;
-  assetLoaderErrorChain(loading, assetFileInit(file, loading->entry->name, NULL, NULL));
+  assetLoaderErrorChain(loading,
+    assetFileInit(file, loading->entry->name, NULL, NULL)
+  );

  if(file->size > ASSET_JSON_FILE_SIZE_MAX) {
    assetLoaderErrorThrow(loading, "JSON exceeds maximum allowed size");
@@ -24,12 +24,18 @@ errorret_t assetLocaleLoaderAsync(assetloading_t *loading) {

  assetlocalefile_t *localeFile = &loading->entry->data.locale;
  memoryZero(localeFile, sizeof(assetlocalefile_t));
-  assetLoaderErrorChain(loading, assetFileInit(&localeFile->file, loading->entry->name, NULL, NULL));
+  assetLoaderErrorChain(loading, assetFileInit(
+    &localeFile->file, loading->entry->name, NULL, NULL
+  ));
  assetLoaderErrorChain(loading, assetFileOpen(&localeFile->file));

  char_t buffer[1024];
-  assetLoaderErrorChain(loading, assetLocaleGetString(localeFile, "", 0, buffer, sizeof(buffer)));
-  assetLoaderErrorChain(loading, assetLocaleParseHeader(localeFile, buffer, sizeof(buffer)));
+  assetLoaderErrorChain(loading, assetLocaleGetString(
+    localeFile, "", 0, buffer, sizeof(buffer)
+  ));
+  assetLoaderErrorChain(loading, assetLocaleParseHeader(
+    localeFile, buffer, sizeof(buffer)
+  ));

  loading->loading.locale.state = ASSET_LOCALE_LOADER_STATE_DONE;
  loading->entry->state = ASSET_ENTRY_STATE_PENDING_SYNC;
@@ -810,17 +816,24 @@ errorret_t assetLocaleGetStringWithArgs(
        case 'f':
          if(
            args[nextArg].type != ASSET_LOCALE_ARG_FLOAT &&
-            args[nextArg].type != ASSET_LOCALE_ARG_INT
+            args[nextArg].type != ASSET_LOCALE_ARG_INT &&
+            args[nextArg].type != ASSET_LOCALE_ARG_FIXED
          ) {
            memoryFree(format);
-            errorThrow("Expected float or int locale argument for ID: %s", id);
+            errorThrow(
+              "Expected float, fixed, or int locale argument for ID: %s",
+              id
+            );
          }

-          float_t floatValue = (
-            args[nextArg].type == ASSET_LOCALE_ARG_FLOAT ?
-            args[nextArg].floatValue :
-            (float_t)args[nextArg].intValue
-          );
+          float_t floatValue;
+          if(args[nextArg].type == ASSET_LOCALE_ARG_FLOAT) {
+            floatValue = args[nextArg].floatValue;
+          } else if(args[nextArg].type == ASSET_LOCALE_ARG_FIXED) {
+            floatValue = fixedToFloat(args[nextArg].fixedValue);
+          } else {
+            floatValue = (float_t)args[nextArg].intValue;
+          }

          written = snprintf(
            valueBuffer,
@@ -7,11 +7,12 @@

 #pragma once
 #include "asset/assetfile.h"
+#include "util/fixed.h"

 typedef struct assetloading_s assetloading_t;
 typedef struct assetentry_s assetentry_t;

-/** Input passed to the locale loader — currently unused. */
+/** Input passed to the locale loader - currently unused. */
 typedef struct { void *nothing; } assetlocaleloaderinput_t;

 typedef enum {
@@ -51,7 +52,8 @@ typedef enum {
 typedef enum {
  ASSET_LOCALE_ARG_STRING,
  ASSET_LOCALE_ARG_INT,
-  ASSET_LOCALE_ARG_FLOAT
+  ASSET_LOCALE_ARG_FLOAT,
+  ASSET_LOCALE_ARG_FIXED
 } assetlocaleargtype_t;

 /**
@@ -67,6 +69,7 @@ typedef struct {
    const char_t *stringValue;
    int32_t intValue;
    float_t floatValue;
+    fixed_t fixedValue;
  };
 } assetlocalearg_t;

@@ -100,7 +103,7 @@ typedef struct {
  uint8_t pluralDefaultIndex;
 } assetlocalefile_t;

-/** Convenience alias — the loaded output type of a locale asset entry. */
+/** Convenience alias - the loaded output type of a locale asset entry. */
 typedef assetlocalefile_t assetlocaleoutput_t;

 /**
@@ -189,7 +192,7 @@ errorret_t assetLocaleLineSkipBlanks(
 *
 * @param reader  Line reader positioned at the line containing the opening
 *                quote (e.g. `msgstr "..."`).
- * @param lineBuffer  Buffer the reader fills on each @ref assetFileLineReaderNext
+ * @param lineBuffer  Buffer filled on each @ref assetFileLineReaderNext
 *                    call; also used to detect continuation lines.
 * @param stringBuffer  Destination for the unescaped string content.
 * @param stringBufferSize  Capacity of `stringBuffer` in bytes.
@@ -1,9 +0,0 @@
-# Copyright (c) 2026 Dominic Masters
-#
-# This software is released under the MIT License.
-# https://opensource.org/licenses/MIT
-
-target_sources(${DUSK_LIBRARY_TARGET_NAME}
-  PUBLIC
-    assetscriptloader.c
-)
@@ -1,137 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- *
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "assetscriptloader.h"
-#include "asset/loader/assetloading.h"
-#include "asset/loader/assetentry.h"
-#include "asset/loader/assetloader.h"
-#include "script/module/require/modulerequire.h"
-#include "util/memory.h"
-#include "assert/assert.h"
-#include <jerryscript.h>
-
-errorret_t assetScriptLoaderAsync(assetloading_t *loading) {
-  assertNotNull(loading, "Loading cannot be NULL");
-  assertNotMainThread("Async loader should not be on main thread.");
-
-  if(loading->loading.script.state != ASSET_SCRIPT_LOADING_STATE_READ_FILE) {
-    errorOk();
-  }
-
-  assertNull(loading->loading.script.buffer, "Buffer already defined?");
-
-  assetfile_t *file = &loading->loading.script.file;
-  assetLoaderErrorChain(
-    loading, assetFileInit(file, loading->entry->name, NULL, NULL)
-  );
-
-  uint8_t *buffer = NULL;
-  size_t size = 0;
-  assetLoaderErrorChain(loading, assetFileReadEntire(file, &buffer, &size));
-  assetLoaderErrorChain(loading, assetFileDispose(file));
-
-  // Null-terminate for jerry_eval.
-  memoryResize((void **)&buffer, size, size + 1);
-  buffer[size] = '\0';
-
-  loading->loading.script.buffer = buffer;
-  loading->loading.script.size = size;
-  loading->loading.script.state = ASSET_SCRIPT_LOADING_STATE_EXEC;
-  loading->entry->state = ASSET_ENTRY_STATE_PENDING_SYNC;
-  errorOk();
-}
-
-errorret_t assetScriptLoaderSync(assetloading_t *loading) {
-  assertNotNull(loading, "Loading cannot be NULL");
-  assertTrue(loading->type == ASSET_LOADER_TYPE_SCRIPT, "Invalid type.");
-  assertIsMainThread("Must be called from the main thread.");
-
-  switch(loading->loading.script.state) {
-    case ASSET_SCRIPT_LOADING_STATE_INITIAL:
-      loading->loading.script.state = ASSET_SCRIPT_LOADING_STATE_READ_FILE;
-      loading->entry->state = ASSET_ENTRY_STATE_PENDING_ASYNC;
-      errorOk();
-      break;
-
-    case ASSET_SCRIPT_LOADING_STATE_EXEC:
-      break;
-
-    default:
-      errorOk();
-  }
-
-  // Get read buffer
-  uint8_t *buffer = loading->loading.script.buffer;
-  assertNotNull(buffer, "Script buffer should have been loaded by now.");
-
-  // Get the current global script realm
-  jerry_value_t global = jerry_current_realm();
-
-  // Replace globalThis.module with a new `module = {}`
-  jerry_value_t oldModule = jerry_object_get_sz(global, "module");
-
-  jerry_value_t module = jerry_object();
-  jerry_object_set_sz(global, "module", module);
-
-  // Eval the script, we handle failure later down the code.
-  jerry_value_t result = jerry_eval(
-    buffer,
-    loading->loading.script.size,
-    JERRY_PARSE_NO_OPTS
-  );
-
-  // Free the read buffer
-  memoryFree(buffer);
-  loading->loading.script.buffer = NULL;
-
-  // Restore globalThis.module
-  jerry_object_set_sz(global, "module", oldModule);
-  jerry_value_free(oldModule);
-  jerry_value_free(global);
-
-  if(jerry_value_is_exception(result)) {
-    jerry_value_free(module);
-
-    loading->entry->data.script.exports = jerry_undefined();
-    loading->entry->state = ASSET_ENTRY_STATE_ERROR;
-
-    // Get error string
-    char_t buf[256];
-    moduleBaseExceptionMessage(result, buf, sizeof(buf));
-    jerry_value_free(result);
-    assetLoaderErrorThrow(
-      loading,
-      "Script execution failed: %s: %s", loading->entry->name, buf
-    );
-  }
-  
-  // Get module.exports
-  jerry_value_t exports = jerry_object_get_sz(module, "exports");
-  jerry_value_free(result);
-  jerry_value_free(module);
-
-  // Store the exports.
-  loading->entry->data.script.exports = exports;
-  loading->entry->state = ASSET_ENTRY_STATE_LOADED;
-  errorOk();
-}
-
-errorret_t assetScriptDispose(assetentry_t *entry) {
-  assertNotNull(entry, "Asset entry cannot be NULL");
-  assertTrue(entry->type == ASSET_LOADER_TYPE_SCRIPT, "Invalid type.");
-  assertIsMainThread("Must be called from the main thread.");
-
-  if(
-    entry->data.script.exports != 0 &&
-    !jerry_value_is_undefined(entry->data.script.exports)
-  ) {
-    jerry_value_free(entry->data.script.exports);
-    entry->data.script.exports = 0;
-  }
-  
-  errorOk();
-}
@@ -1,60 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- *
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "asset/assetfile.h"
-#include "script/scriptmodule.h"
-
-#define ASSET_SCRIPT_CHUNK_SIZE 1024
-
-typedef struct assetloading_s assetloading_t;
-typedef struct assetentry_s assetentry_t;
-
-typedef struct {
-  void *nothing;
-} assetscriptloaderinput_t;
-
-typedef scriptmodule_t assetscriptoutput_t;
-
-typedef enum {
-  ASSET_SCRIPT_LOADING_STATE_INITIAL,
-  ASSET_SCRIPT_LOADING_STATE_READ_FILE,
-  ASSET_SCRIPT_LOADING_STATE_EXEC,
-  ASSET_SCRIPT_LOADING_STATE_DONE
-} assetscriptloadingstate_t;
-
-typedef struct {
-  assetfile_t file;
-  assetscriptloadingstate_t state;
-  uint8_t *buffer;
-  size_t size;
-} assetscriptloaderloading_t;
-
-/**
- * Asynchronous loader for a script asset/module.
- * 
- * @param loading The loading context.
- * @returns An error code and state.
- */
-errorret_t assetScriptLoaderAsync(assetloading_t *loading);
-
-/**
- * Synchronous loader for a script asset/module. This executes the script after
- * it has been loaded by the async loader.
- * 
- * @param loading The loading context.
- * @returns An error code and state.
- */
-errorret_t assetScriptLoaderSync(assetloading_t *loading);
-
-/**
- * Disposes of a loaded script asset/module.
- * 
- * @param entry The asset entry to dispose.
- * @returns An error code and state.
- */
-errorret_t assetScriptDispose(assetentry_t *entry);
@@ -20,6 +20,7 @@ console_t CONSOLE;

 void consoleInit(void) {
  memoryZero(&CONSOLE, sizeof(console_t));
+  CONSOLE.visible = true;

  #ifdef DUSK_CONSOLE_POSIX
    threadMutexInit(&CONSOLE.printMutex);
@@ -69,7 +70,7 @@ errorret_t consoleDraw(void) {
    errorChain(textDraw(
      0, FONT_DEFAULT.tileset->tileHeight * i,
      CONSOLE.line[i],
-      COLOR_WHITE,
+      COLOR_RED,
      &FONT_DEFAULT
    ));
  }
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2025 Dominic Masters
+ * Copyright (c) 2026 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
@@ -38,6 +38,10 @@ errorret_t displayInit(void) {
    &TEXTURE_WHITE, 4, 4,
    TEXTURE_FORMAT_RGBA, (texturedata_t){ .rgbaColors = TEXTURE_WHITE_PIXELS }
  ));
+  errorChain(textureInit(
+    &TEXTURE_TEST, 4, 4,
+    TEXTURE_FORMAT_RGBA, (texturedata_t){ .rgbaColors = TEXTURE_TEST_PIXELS }
+  ));

  // Standard meshes
  errorChain(quadInit());
@@ -100,6 +104,8 @@ errorret_t displayDispose(void) {
  errorChain(spriteBatchDispose());
  screenDispose();
  errorChain(textDispose());
+  errorChain(textureDispose(&TEXTURE_WHITE));
+  errorChain(textureDispose(&TEXTURE_TEST));
  
  #ifdef displayPlatformDispose
    displayPlatformDispose();
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2025 Dominic Masters
+ * Copyright (c) 2026 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2025 Dominic Masters
+ * Copyright (c) 2026 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2025 Dominic Masters
+ * Copyright (c) 2026 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2025 Dominic Masters
+ * Copyright (c) 2026 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
@@ -1,4 +1,4 @@
-// Copyright (c) 2025 Dominic Masters
+// Copyright (c) 2026 Dominic Masters
 // 
 // This software is released under the MIT License.
 // https://opensource.org/licenses/MIT
@@ -74,7 +74,7 @@ void planeBuffer(
  const float_t u0 = uvMin[0], u1 = uvMax[0];
  const float_t v0 = uvMin[1], v1 = uvMax[1];

-  switch (axis) {
+  switch(axis) {
    case PLANE_AXIS_XY: {
      /* Flat in XY at z = min[2]; spans X and Y. */
      const float_t z = min[2];
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2025 Dominic Masters
+ * Copyright (c) 2026 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2025 Dominic Masters
+ * Copyright (c) 2026 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2025 Dominic Masters
+ * Copyright (c) 2026 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2025 Dominic Masters
+ * Copyright (c) 2026 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2025 Dominic Masters
+ * Copyright (c) 2026 Dominic Masters
 *
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
@@ -50,70 +50,95 @@ errorret_t spriteBatchBuffer(
  }

  // Buffer the vertices.
-  for(uint32_t i = 0; i < count; i++ ){
-    spritebatchsprite_t sprite = sprites[i];
+  uint32_t remaining = count;
+  do {
+    uint32_t spritesBeforeFlush = (
+      SPRITEBATCH_SPRITES_MAX_PER_FLUSH - SPRITEBATCH.spriteCount
+    );

+    if(spritesBeforeFlush == 0) {
+      // Flush if we have no capacity before flushing.
+      errorChain(spriteBatchFlush());
+      spritesBeforeFlush = SPRITEBATCH_SPRITES_MAX_PER_FLUSH;
+    }
+
+    // Many we buffering?
+    const uint32_t batchCount = mathMin(
+      remaining,
+      spritesBeforeFlush
+    );
+
+    // Destination
    meshvertex_t *v = &SPRITEBATCH_VERTICES[
      (SPRITEBATCH.spriteCount + (SPRITEBATCH.spriteFlush *
      SPRITEBATCH_SPRITES_MAX_PER_FLUSH)) * QUAD_VERTEX_COUNT
    ];
+
+    // Buffer to the mesh vertices.
+    spriteBatchBufferToMesh(
+      sprites, batchCount, v, batchCount * QUAD_VERTEX_COUNT
+    );
+    SPRITEBATCH.spriteCount += batchCount;
+    remaining -= batchCount;
+  } while(remaining > 0);
+  
+  errorOk();
+}
+
+void spriteBatchBufferToMesh(
+  const spritebatchsprite_t *sprites,
+  const uint32_t count,
+  meshvertex_t *vertices,
+  const uint32_t verticesSize
+) {
+  assertNotNull(sprites, "Sprites cannot be null");
+  assertTrue(count > 0, "Count must be greater than zero");
+  assertNotNull(vertices, "Vertices cannot be null");
+  assertTrue(
+    verticesSize >= count * QUAD_VERTEX_COUNT, "Vertices array too small"
+  );
+  
+  for(uint32_t i = 0; i < count; i++ ){
+    spritebatchsprite_t sprite = sprites[i];
+    meshvertex_t *v = &vertices[i * QUAD_VERTEX_COUNT];
    
    // Buffer the quad
    v[0].pos[0] = sprite.min[0];
    v[0].pos[1] = sprite.min[1];
    v[0].pos[2] = sprite.min[2];
-
    v[0].uv[0] = sprite.uvMin[0];
    v[0].uv[1] = sprite.uvMin[1];

-
    v[1].pos[0] = sprite.max[0];
    v[1].pos[1] = sprite.min[1];
    v[1].pos[2] = sprite.min[2];
-
    v[1].uv[0] = sprite.uvMax[0];
    v[1].uv[1] = sprite.uvMin[1];

-
    v[2].pos[0] = sprite.max[0];
    v[2].pos[1] = sprite.max[1];
    v[2].pos[2] = sprite.max[2];
-
    v[2].uv[0] = sprite.uvMax[0];
    v[2].uv[1] = sprite.uvMax[1];

-
    v[3].pos[0] = sprite.min[0];
    v[3].pos[1] = sprite.min[1];
    v[3].pos[2] = sprite.min[2];
-
    v[3].uv[0] = sprite.uvMin[0];
    v[3].uv[1] = sprite.uvMin[1];

-
    v[4].pos[0] = sprite.max[0];
    v[4].pos[1] = sprite.max[1];
    v[4].pos[2] = sprite.max[2];
-
    v[4].uv[0] = sprite.uvMax[0];
    v[4].uv[1] = sprite.uvMax[1];

-
    v[5].pos[0] = sprite.min[0];
    v[5].pos[1] = sprite.max[1];
    v[5].pos[2] = sprite.max[2];
-
    v[5].uv[0] = sprite.uvMin[0];
    v[5].uv[1] = sprite.uvMax[1];
-
-    // Do we need to flush?
-    SPRITEBATCH.spriteCount++;
-    if(SPRITEBATCH.spriteCount >= SPRITEBATCH_SPRITES_MAX_PER_FLUSH) {
-      errorChain(spriteBatchFlush());
-    }
  }
-  
-  errorOk();
 }

 void spriteBatchClear() {
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2025 Dominic Masters
+ * Copyright (c) 2026 Dominic Masters
 *
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
@@ -47,7 +47,7 @@ errorret_t spriteBatchInit();
 /**
 * Lowest-level buffer function. Writes sprites into the internal vertex buffer.
 * Flushes automatically when the per-flush capacity is reached. Does not
- * modify material state — call spriteBatchSetState or use a high-level push
+ * modify material state - call spriteBatchSetState or use a high-level push
 * function before buffering.
 *
 * @param sprites Pointer to the sprite array.
@@ -63,6 +63,26 @@ errorret_t spriteBatchBuffer(
  const shadermaterial_t material
 );

+/**
+ * Buffers an array of sprites to a given array of mesh vertices. This is the
+ * internal method that is used to buffer to the internal spritebatch mesh, but
+ * you can use it to achieve sprite buffering to a mesh you own.
+ * 
+ * verticesSize is the size of the vertices array, we use this to ensure no 
+ * buffer overflows.
+ * 
+ * @param sprites Pointer to the sprite array.
+ * @param count Number of sprites to buffer.
+ * @param vertices Pointer to the vertex array to write to.
+ * @param verticesSize Size of the vertex array, in number of vertices.
+ */
+void spriteBatchBufferToMesh(
+  const spritebatchsprite_t *sprites,
+  const uint32_t count,
+  meshvertex_t *vertices,
+  const uint32_t verticesSize
+);
+
 /**
 * Resets sprite and flush counters and clears the current material state.
 * Calling spriteBatchFlush after this renders nothing.
@@ -93,15 +93,6 @@ errorret_t textDraw(
  float_t posX = x;
  float_t posY = y;

-  errorChain(shaderSetTexture(
-    &SHADER_UNLIT, SHADER_UNLIT_TEXTURE, font->texture
-  ));
-
-  #if MESH_ENABLE_COLOR
-  #else
-    errorChain(shaderSetColor(&SHADER_UNLIT, SHADER_UNLIT_COLOR, color));
-  #endif
-
  char_t c;
  int32_t i = 0;
  while((c = text[i++]) != '\0') {
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2025 Dominic Masters
+ * Copyright (c) 2026 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
@@ -19,6 +19,14 @@ color_t TEXTURE_WHITE_PIXELS[4*4] = {
  COLOR_WHITE, COLOR_WHITE, COLOR_WHITE, COLOR_WHITE,
 };

+texture_t TEXTURE_TEST;
+color_t TEXTURE_TEST_PIXELS[4*4] = {
+  COLOR_BLACK, COLOR_MAGENTA, COLOR_BLACK, COLOR_MAGENTA,
+  COLOR_MAGENTA, COLOR_BLACK, COLOR_MAGENTA, COLOR_BLACK,
+  COLOR_BLACK, COLOR_MAGENTA, COLOR_BLACK, COLOR_MAGENTA,
+  COLOR_MAGENTA, COLOR_BLACK, COLOR_MAGENTA, COLOR_BLACK,
+};
+
 errorret_t textureInit(
  texture_t *texture,
  const int32_t width,
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2025 Dominic Masters
+ * Copyright (c) 2026 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
@@ -30,6 +30,8 @@ typedef union texturedata_u {

 extern texture_t TEXTURE_WHITE;
 extern color_t TEXTURE_WHITE_PIXELS[4*4];
+extern texture_t TEXTURE_TEST;
+extern color_t TEXTURE_TEST_PIXELS[4*4];

 /**
 * Initializes a texture.
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2025 Dominic Masters
+ * Copyright (c) 2026 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2025 Dominic Masters
+ * Copyright (c) 2026 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2025 Dominic Masters
+ * Copyright (c) 2026 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2025 Dominic Masters
+ * Copyright (c) 2026 Dominic Masters
 *
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
@@ -10,6 +10,7 @@
 #include "time/time.h"
 #include "input/input.h"
 #include "locale/localemanager.h"
+#include "rpg/rpg.h"
 #include "display/display.h"
 #include "scene/scene.h"
 #include "cutscene/cutscene.h"
@@ -17,14 +18,9 @@
 #include "ui/ui.h"
 #include "ui/uitextbox.h"
 #include "assert/assert.h"
-#include "entity/entitymanager.h"
-#include "entity/component/physics/entityphysics.h"
-#include "physics/physicsmanager.h"
 #include "network/network.h"
 #include "system/system.h"
 #include "console/console.h"
-#include "script/script.h"
-#include "item/backpack.h"
 #include "save/save.h"

 engine_t ENGINE;
@@ -49,15 +45,13 @@ errorret_t engineInit(const int32_t argc, const char_t **argv) {
  errorChain(uiInit());
  errorChain(uiTextboxInit());
  errorChain(cutsceneInit());
-  entityManagerInit();
-  backpackInit();
-  physicsManagerInit();
+  errorChain(rpgInit());
  errorChain(networkInit());
-  errorChain(scriptInit());
  errorChain(sceneInit());

  consolePrint("Engine initialized");
-  errorChain(scriptExecFile("init.js"));
+  sceneSet(SCENE_TYPE_OVERWORLD);
+  

  errorOk();
 }
@@ -68,16 +62,15 @@ errorret_t engineUpdate(void) {
  timeUpdate();
  inputUpdate();
  consoleUpdate();
-  entityManagerUpdate();
+  errorChain(rpgUpdate());
  uiUpdate();
  errorChain(uiTextboxUpdate());
-  physicsManagerUpdate();
-  errorChain(displayUpdate());
  errorChain(cutsceneUpdate());
  errorChain(sceneUpdate());
  errorChain(assetUpdate());
-  errorChain(scriptUpdate());

+  // Render
+  errorChain(displayUpdate());
  if(inputPressed(INPUT_ACTION_RAGEQUIT)) ENGINE.running = false;
  errorOk();
 }
@@ -90,9 +83,8 @@ errorret_t engineDispose(void) {
  uiTextboxDispose();
  cutsceneDispose();
  errorChain(sceneDispose());
-  errorChain(scriptDispose());
  errorChain(networkDispose());
-  entityManagerDispose();
+  errorChain(rpgDispose());
  localeManagerDispose();
  uiDispose();
  consoleDispose();
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2025 Dominic Masters
+ * Copyright (c) 2026 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
@@ -1,147 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "entitymanager.h"
-#include "assert/assert.h"
-#include "util/memory.h"
-
-componentdefinition_t COMPONENT_DEFINITIONS[] = {
-  [COMPONENT_TYPE_NULL] = { 0 },
-
-  #define X(enm, type, field, iMethod, dMethod, rMethod) \
-    [COMPONENT_TYPE_##enm] = { \
-      .enumName = #enm, \
-      .name = #field, \
-      .init = iMethod, \
-      .dispose = dMethod, \
-      .render = rMethod \
-    },
-  
-  #include "componentlist.h"
-  #undef X
-
-  [COMPONENT_TYPE_COUNT] = { 0 }
-};
-
-void componentInit(
-  const entityid_t entityId,
-  const componentid_t componentId,
-  const componenttype_t type
-) {
-  assertTrue(entityId < ENTITY_COUNT_MAX, "Entity ID OOB");
-  assertTrue(componentId < ENTITY_COMPONENT_COUNT_MAX, "Component ID OOB");
-  assertTrue(type < COMPONENT_TYPE_COUNT, "Component type OOB");
-  assertTrue(type != COMPONENT_TYPE_NULL, "Cannot initialize null component");
-  
-  componentindex_t index = componentGetIndex(entityId, componentId);
-  component_t *cmp = &ENTITY_MANAGER.components[index];
-  memoryZero(cmp, sizeof(component_t));
-
-  cmp->type = type;
-  if(COMPONENT_DEFINITIONS[type].init) {
-    COMPONENT_DEFINITIONS[type].init(entityId, componentId);
-  }
-}
-
-void * componentGetData(
-  const entityid_t entityId,
-  const componentid_t componentId,
-  const componenttype_t type
-) {
-  assertTrue(entityId < ENTITY_COUNT_MAX, "Entity ID OOB");
-  assertTrue(componentId < ENTITY_COMPONENT_COUNT_MAX, "Component ID OOB");
-  assertTrue(type < COMPONENT_TYPE_COUNT, "Component type OOB");
-  assertTrue(type != COMPONENT_TYPE_NULL, "Cannot get data of null component");
-  
-  componentindex_t index = componentGetIndex(entityId, componentId);
-  component_t *cmp = &ENTITY_MANAGER.components[index];
-  assertTrue(cmp->type == type, "Component type mismatch");
-
-  return &cmp->data;
-}
-
-componentindex_t componentGetIndex(
-  const entityid_t entityId,
-  const componentid_t componentId
-) {
-  assertTrue(entityId < ENTITY_COUNT_MAX, "Entity ID OOB");
-  assertTrue(componentId < ENTITY_COMPONENT_COUNT_MAX, "Component ID OOB");
-  return (entityId * ENTITY_COMPONENT_COUNT_MAX) + componentId;
-}
-
-entityid_t componentGetEntitiesWithComponent(
-  const componenttype_t type,
-  entityid_t outEntities[ENTITY_COUNT_MAX],
-  componentid_t outComponents[ENTITY_COUNT_MAX]
-) {
-  assertTrue(type < COMPONENT_TYPE_COUNT, "Component type OOB");
-  assertTrue(type != COMPONENT_TYPE_NULL, "Cannot check NULL type");
-  assertNotNull(outEntities, "Output entities array cannot be null");
-  assertNotNull(outComponents, "Output components array cannot be null");
-
-  entityid_t written = 0;
-  for(entityid_t i = 0; i < ENTITY_COUNT_MAX; i++) {
-    componentid_t used = ENTITY_MANAGER.entitiesWithComponent[
-      type * ENTITY_COUNT_MAX + i
-    ];
-    if(used == COMPONENT_ID_INVALID) continue;
-    assertTrue(
-      ENTITY_MANAGER.components[componentGetIndex(i, used)].type == type,
-      "Component type mismatch in entitiesWithComponent lookup"
-    );
-    assertTrue(
-      (ENTITY_MANAGER.entities[i].state & ENTITY_STATE_ACTIVE) != 0,
-      "Inactive entity in entitiesWithComponent lookup"
-    );
-    assertTrue(
-      used < ENTITY_COMPONENT_COUNT_MAX,
-      "Component ID OOB in entitiesWithComponent lookup"
-    );
-    assertTrue(
-      componentGetIndex(i,used) < ENTITY_COUNT_MAX*ENTITY_COMPONENT_COUNT_MAX,
-      "Component index OOB in entitiesWithComponent lookup"
-    );
-    assertTrue(
-      ENTITY_MANAGER.components[componentGetIndex(i,used)].type == type,
-      "Component type mismatch in entitiesWithComponent lookup"
-    );
-    outComponents[written] = used;
-    outEntities[written++] = i;
-  }
-  return written;
-}
-
-errorret_t componentRenderAll(void) {
-  for(entityid_t eid = 0; eid < ENTITY_COUNT_MAX; eid++) {
-    if(!(ENTITY_MANAGER.entities[eid].state & ENTITY_STATE_ACTIVE)) continue;
-    for(componentid_t cid = 0; cid < ENTITY_COMPONENT_COUNT_MAX; cid++) {
-      component_t *cmp = &ENTITY_MANAGER.components[componentGetIndex(eid, cid)];
-      if(cmp->type == COMPONENT_TYPE_NULL) continue;
-      if(!COMPONENT_DEFINITIONS[cmp->type].render) continue;
-      errorChain(COMPONENT_DEFINITIONS[cmp->type].render(eid, cid));
-    }
-  }
-  errorOk();
-}
-
-void componentDispose(
-  const entityid_t entityId,
-  const componentid_t componentId
-) {
-  assertTrue(entityId < ENTITY_COUNT_MAX, "Entity ID OOB");
-  assertTrue(componentId < ENTITY_COMPONENT_COUNT_MAX, "Component ID OOB");
-  
-  componentindex_t index = componentGetIndex(entityId, componentId);
-  component_t *cmp = &ENTITY_MANAGER.components[index];
-  if(cmp->type == COMPONENT_TYPE_NULL) return;
-
-  if(COMPONENT_DEFINITIONS[cmp->type].dispose) {
-    COMPONENT_DEFINITIONS[cmp->type].dispose(entityId, componentId);
-  }
-  
-  cmp->type = COMPONENT_TYPE_NULL;
-}
@@ -1,120 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "entitybase.h"
-
-#define X(enumName, type, field, init, dispose, render) \
-  // do nothing
-#include "componentlist.h"
-#undef X
-
-typedef union {
-  #define X(enumName, type, field, init, dispose, render) type field;
-  #include "componentlist.h"
-  #undef X
-} componentdata_t;
-
-typedef struct {
-  const char_t *enumName;
-  const char_t *name;
-  void (*init)(const entityid_t, const componentid_t);
-  void (*dispose)(const entityid_t, const componentid_t);
-  errorret_t (*render)(const entityid_t, const componentid_t);
-} componentdefinition_t;
-
-typedef enum {
-  COMPONENT_TYPE_NULL,
-
-  #define X(enumName, type, field, init, dispose, render) \
-    COMPONENT_TYPE_##enumName,
-  #include "componentlist.h"
-  #undef X
-
-  COMPONENT_TYPE_COUNT
-} componenttype_t;
-
-typedef struct {
-  componenttype_t type;
-  componentdata_t data;
-} component_t;
-
-extern componentdefinition_t COMPONENT_DEFINITIONS[];
-
-/**
- * Initializes a component of the given type for the entity with component ID.
- * 
- * @param entityId The entity ID.
- * @param componentId The component ID.
- * @param type The type of the component to initialize.
- */
-void componentInit(
-  const entityid_t entityId,
-  const componentid_t componentId,
-  const componenttype_t type
-);
-
-/**
- * Gets the pointer to the data of a component for the entity with component ID.
- * 
- * @param entityId The entity ID.
- * @param componentId The component ID.
- * @param type The type of the component to get, only used for assertion.
- * @return A pointer to the component data.
- */
-void * componentGetData(
-  const entityid_t entityId,
-  const componentid_t componentId,
-  const componenttype_t type
-);
-
-/**
- * Gets the index of a component for the entity with component ID.
- * 
- * @param entityId The entity ID.
- * @param componentId The component ID.
- * @return The index of the component in the component array.
- */
-componentindex_t componentGetIndex(
-  const entityid_t entityId,
-  const componentid_t componentId
-);
-
-/**
- * Gets the entity IDs of all entities with a component of the given type.
- * 
- * @param type The type of the component to get entities for.
- * @param outEntities An array to write the entity IDs to, must be at least
- * ENTITY_COUNT_MAX in size.
- * @param outComponents An array to write the component IDs to.
- * @return The number of entity IDs written to outEntities.
- */
-entityid_t componentGetEntitiesWithComponent(
-  const componenttype_t type,
-  entityid_t outEntities[ENTITY_COUNT_MAX],
-  componentid_t outComponents[ENTITY_COUNT_MAX]
-);
-
-/**
- * Disposes of a component for the entity with component ID.
- *
- * @param entityId The entity ID.
- * @param componentId The component ID.
- */
-void componentDispose(
-  const entityid_t entityId,
-  const componentid_t componentId
-);
-
-/**
- * Calls the render callback on every active component that defines one.
- * Iterates all active entities and all their component slots. No-op for
- * components whose definition has render == NULL.
- *
- * @return Error state.
- */
-errorret_t componentRenderAll(void);
@@ -1,8 +0,0 @@
-# Copyright (c) 2026 Dominic Masters
-# 
-# This software is released under the MIT License.
-# https://opensource.org/licenses/MIT
-
-add_subdirectory(display)
-add_subdirectory(physics)
-add_subdirectory(trigger)
@@ -1,12 +0,0 @@
-# Copyright (c) 2026 Dominic Masters
-# 
-# This software is released under the MIT License.
-# https://opensource.org/licenses/MIT
-
-# Sources
-target_sources(${DUSK_LIBRARY_TARGET_NAME}
-  PUBLIC
-    entityposition.c
-    entitycamera.c
-    entityrenderable.c
-)
@@ -1,120 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "entity/entitymanager.h"
-#include "entity/entity.h"
-#include "entity/component/display/entityposition.h"
-#include "display/framebuffer/framebuffer.h"
-#include "display/screen/screen.h"
-
-void entityCameraInit(const entityid_t ent, const componentid_t comp) {
-  entitycamera_t *cam = (entitycamera_t *)componentGetData(
-    ent, comp, COMPONENT_TYPE_CAMERA
-  );
-  cam->nearClip = 0.1f;
-  cam->farClip = 5000.0f;
-  cam->projType = ENTITY_CAMERA_PROJECTION_TYPE_PERSPECTIVE;
-  cam->perspective.fov = glm_rad(45.0f);
-}
-
-void entityCameraGetProjection(
-  const entityid_t ent,
-  const componentid_t comp,
-  mat4 out
-) {
-  entitycamera_t *cam = (entitycamera_t *)componentGetData(
-    ent, comp, COMPONENT_TYPE_CAMERA
-  );
-
-  if(
-    cam->projType == ENTITY_CAMERA_PROJECTION_TYPE_PERSPECTIVE ||
-    cam->projType == ENTITY_CAMERA_PROJECTION_TYPE_PERSPECTIVE_FLIPPED
-  ) {
-    glm_mat4_identity(out);
-    glm_perspective(
-      cam->perspective.fov,
-      SCREEN.aspect,
-      cam->nearClip,
-      cam->farClip,
-      out
-    );
-
-    if(cam->projType == ENTITY_CAMERA_PROJECTION_TYPE_PERSPECTIVE_FLIPPED) {
-      out[1][1] *= -1.0f;
-    }
-  } else if(cam->projType == ENTITY_CAMERA_PROJECTION_TYPE_ORTHOGRAPHIC) {
-    glm_mat4_identity(out);
-    glm_ortho(
-      cam->orthographic.left,
-      cam->orthographic.right,
-      cam->orthographic.top,
-      cam->orthographic.bottom,
-      cam->nearClip,
-      cam->farClip,
-      out
-    );
-  }
-}
-
-entityid_t entityCameraGetCurrent(void) {
-  entityid_t camEnts[ENTITY_COUNT_MAX];
-  componentid_t camComps[ENTITY_COUNT_MAX];
-  entityid_t count = componentGetEntitiesWithComponent(
-    COMPONENT_TYPE_CAMERA, camEnts, camComps
-  );
-  if(count == 0) return ENTITY_ID_INVALID;
-  return camEnts[0];
-}
-
-void entityCameraGetForward(const entityid_t entityId, vec2 out) {
-  componentid_t posComp = entityGetComponent(entityId, COMPONENT_TYPE_POSITION);
-  entityposition_t *pos = entityPositionGet(entityId, posComp);
-  // View matrix column layout: M[col][row],
-  // forward = {-M[0][2], -M[1][2], -M[2][2]}
-  float_t fx = -pos->worldTransform[0][2];
-  float_t fz = -pos->worldTransform[2][2];
-  float_t len = sqrtf(fx * fx + fz * fz);
-  if(len > 1e-6f) { fx /= len; fz /= len; }
-  out[0] = fx;
-  out[1] = fz;
-}
-
-void entityCameraLookAtPixelPerfect(
-  const entityid_t ent,
-  const componentid_t posComp,
-  const componentid_t camComp,
-  const vec3 point,
-  const vec3 eyeOffset,
-  const float_t scale
-) {
-  entitycamera_t *cam = (entitycamera_t *)componentGetData(
-    ent, camComp, COMPONENT_TYPE_CAMERA
-  );
-  float_t dist = (
-    (float_t)SCREEN.height / (2.0f * scale * tanf(cam->perspective.fov * 0.5f))
-  );
-
-  vec3 eye = {
-    point[0] + eyeOffset[0],
-    point[1] + dist + eyeOffset[1],
-    point[2] + eyeOffset[2]
-  };
-  vec3 up = { 0.0f, 0.0f, -1.0f };
-  entityPositionLookAt(ent, posComp, eye, (float_t *)point, up);
-}
-
-void entityCameraGetRight(const entityid_t entityId, vec2 out) {
-  componentid_t posComp = entityGetComponent(entityId, COMPONENT_TYPE_POSITION);
-  entityposition_t *pos = entityPositionGet(entityId, posComp);
-  // View matrix column layout: right = {M[0][0], M[1][0], M[2][0]}
-  float_t rx = pos->worldTransform[0][0];
-  float_t rz = pos->worldTransform[2][0];
-  float_t len = sqrtf(rx * rx + rz * rz);
-  if(len > 1e-6f) { rx /= len; rz /= len; }
-  out[0] = rx;
-  out[1] = rz;
-}
@@ -1,99 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "entity/entitybase.h"
-
-typedef enum {
-  ENTITY_CAMERA_PROJECTION_TYPE_PERSPECTIVE,
-  ENTITY_CAMERA_PROJECTION_TYPE_PERSPECTIVE_FLIPPED,
-  ENTITY_CAMERA_PROJECTION_TYPE_ORTHOGRAPHIC
-} entitycameraprojectiontype_t;
-
-typedef struct {
-  union {
-    struct {
-      float_t fov;
-    } perspective;
-
-    struct {
-      float_t left;
-      float_t right;
-      float_t top;
-      float_t bottom;
-    } orthographic;
-  };
-
-  float_t nearClip;
-  float_t farClip;
-  entitycameraprojectiontype_t projType;  
-} entitycamera_t;
-
-/**
- * Initializes an entity camera component.
- * 
- * @param ent The entity ID.
- * @param comp The component ID.
- */
-void entityCameraInit(const entityid_t ent, const componentid_t comp);
-
-/**
- * Renders out the projection matrix for the given camera.
- *
- * @param ent The entity ID.
- * @param comp The component ID.
- * @param out The output projection matrix.
- */
-void entityCameraGetProjection(
-  const entityid_t ent,
-  const componentid_t comp,
-  mat4 out
-);
-
-/**
- * Returns the entity ID of the first active camera, or ENTITY_ID_INVALID if
- * none are active.
- */
-entityid_t entityCameraGetCurrent(void);
-
-/**
- * Gets the camera's horizontal forward direction (XZ plane) from its position
- * component. Automatically finds the position component on the entity.
- *
- * @param entityId The camera entity ID.
- * @param out Output vec2: {forwardX, forwardZ} normalized.
- */
-void entityCameraGetForward(const entityid_t entityId, vec2 out);
-
-/**
- * Gets the camera's horizontal right direction (XZ plane) from its position
- * component. Automatically finds the position component on the entity.
- *
- * @param entityId The camera entity ID.
- * @param out Output vec2: {rightX, rightZ} normalized.
- */
-void entityCameraGetRight(const entityid_t entityId, vec2 out);
-
-/**
- * Positions the camera to look at a 3D point at a pixel-perfect distance
- * derived from the camera's FOV and screen height.
- *
- * @param ent The camera entity ID.
- * @param posComp The position component ID.
- * @param camComp The camera component ID.
- * @param point World position to look at.
- * @param eyeOffset Offset added to the eye position only (not the target).
- * @param scale Pixels per world unit. 1.0 = pixel perfect, 2.0 = 2px per unit.
- */
-void entityCameraLookAtPixelPerfect(
-  const entityid_t ent,
-  const componentid_t posComp,
-  const componentid_t camComp,
-  const vec3 point,
-  const vec3 eyeOffset,
-  const float_t scale
-);
@@ -1,592 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- *
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "entity/entitymanager.h"
-
-// Decompose localTransform into the PRS cache. Only called when PRS_DIRTY.
-static void entityPositionEnsurePRS(entityposition_t *pos) {
-  if(!(pos->flags & ENTITY_POSITION_FLAG_PRS_DIRTY)) return;
-  entityPositionDecompose(pos);
-  pos->flags &= ~ENTITY_POSITION_FLAG_PRS_DIRTY;
-}
-
-// Rebuild localTransform from the PRS cache. Only rebuilds what changed.
-static void entityPositionEnsureLocal(entityposition_t *pos) {
-  const uint8_t dirty = pos->flags & (
-    ENTITY_POSITION_FLAG_ROTATION_DIRTY | ENTITY_POSITION_FLAG_POSITION_DIRTY
-  );
-  if(!dirty) return;
-
-  if(dirty & ENTITY_POSITION_FLAG_ROTATION_DIRTY) {
-    // Rotation or scale changed: rebuild columns 0-2 analytically (XYZ euler order).
-    const float c0 = cosf(pos->rotation[0]), s0 = sinf(pos->rotation[0]);
-    const float c1 = cosf(pos->rotation[1]), s1 = sinf(pos->rotation[1]);
-    const float c2 = cosf(pos->rotation[2]), s2 = sinf(pos->rotation[2]);
-    const float s0s1 = s0 * s1;
-    const float c0s1 = c0 * s1;
-
-    pos->localTransform[0][0] =  c1 * c2                  * pos->scale[0];
-    pos->localTransform[0][1] = (c0 * s2 + s0s1 * c2)     * pos->scale[0];
-    pos->localTransform[0][2] = (s0 * s2 - c0s1 * c2)     * pos->scale[0];
-    pos->localTransform[0][3] = 0.0f;
-
-    pos->localTransform[1][0] = -c1 * s2                  * pos->scale[1];
-    pos->localTransform[1][1] = (c0 * c2 - s0s1 * s2)     * pos->scale[1];
-    pos->localTransform[1][2] = (s0 * c2 + c0s1 * s2)     * pos->scale[1];
-    pos->localTransform[1][3] = 0.0f;
-
-    pos->localTransform[2][0] =  s1                        * pos->scale[2];
-    pos->localTransform[2][1] = -s0 * c1                   * pos->scale[2];
-    pos->localTransform[2][2] =  c0 * c1                   * pos->scale[2];
-    pos->localTransform[2][3] = 0.0f;
-  }
-
-  if(dirty & ENTITY_POSITION_FLAG_POSITION_DIRTY) {
-    // Only position changed: update column 3 only (no trig needed).
-    pos->localTransform[3][0] = pos->position[0];
-    pos->localTransform[3][1] = pos->position[1];
-    pos->localTransform[3][2] = pos->position[2];
-    pos->localTransform[3][3] = 1.0f;
-  }
-
-  pos->flags &= ~(ENTITY_POSITION_FLAG_ROTATION_DIRTY | ENTITY_POSITION_FLAG_POSITION_DIRTY);
-}
-
-// Recompute worldTransform from the parent chain. Only called when WORLD_DIRTY.
-static void entityPositionEnsureWorld(entityposition_t *pos) {
-  if(!(pos->flags & ENTITY_POSITION_FLAG_WORLD_DIRTY)) return;
-  entityPositionEnsureLocal(pos);
-
-  if(pos->parentEntityId != ENTITY_ID_INVALID) {
-    // Parented: world = parent.world × local. worldTransform must be written
-    // because children (and this node's getters) read it.
-    entityposition_t *parent = componentGetData(
-      pos->parentEntityId, pos->parentComponentId, COMPONENT_TYPE_POSITION
-    );
-    entityPositionEnsureWorld(parent);
-    glm_mat4_mul(parent->worldTransform, pos->localTransform, pos->worldTransform);
-  } else if(pos->childCount > 0) {
-    // Parentless root with children: children need a valid worldTransform to
-    // multiply against, but world == local, so just copy.
-    glm_mat4_copy(pos->localTransform, pos->worldTransform);
-  }
-  // Parentless leaf: world == local. Getters read localTransform directly;
-  // no copy needed.
-
-  pos->flags &= ~ENTITY_POSITION_FLAG_WORLD_DIRTY;
-}
-
-void entityPositionMarkDirty(entityposition_t *pos) {
-  if(pos->flags & ENTITY_POSITION_FLAG_WORLD_DIRTY) return;
-  pos->flags |= ENTITY_POSITION_FLAG_WORLD_DIRTY;
-  for(uint8_t i = 0; i < pos->childCount; i++) {
-    entityposition_t *child = componentGetData(
-      pos->childEntityIds[i], pos->childComponentIds[i], COMPONENT_TYPE_POSITION
-    );
-    entityPositionMarkDirty(child);
-  }
-}
-
-void entityPositionInit(
-  const entityid_t entityId,
-  const componentid_t componentId
-) {
-  entityposition_t *pos = componentGetData(
-    entityId, componentId, COMPONENT_TYPE_POSITION
-  );
-
-  pos->flags = 0;
-  pos->parentEntityId = ENTITY_ID_INVALID;
-  pos->parentComponentId = COMPONENT_ID_INVALID;
-  pos->childCount = 0;
-  glm_vec3_zero(pos->position);
-  glm_vec3_zero(pos->rotation);
-  glm_vec3_one(pos->scale);
-  glm_mat4_identity(pos->localTransform);
-  glm_mat4_identity(pos->worldTransform);
-}
-
-void entityPositionLookAt(
-  const entityid_t entityId,
-  const componentid_t componentId,
-  vec3 eye,
-  vec3 target,
-  vec3 up
-) {
-  entityposition_t *pos = componentGetData(
-    entityId, componentId, COMPONENT_TYPE_POSITION
-  );
-  glm_lookat(eye, target, up, pos->localTransform);
-  // localTransform is now authoritative; PRS cache is stale.
-  pos->flags = (pos->flags | ENTITY_POSITION_FLAG_PRS_DIRTY)
-             & ~(ENTITY_POSITION_FLAG_ROTATION_DIRTY | ENTITY_POSITION_FLAG_POSITION_DIRTY);
-  entityPositionMarkDirty(pos);
-}
-
-void entityPositionGetTransform(
-  const entityid_t entityId,
-  const componentid_t componentId,
-  mat4 dest
-) {
-  entityposition_t *pos = componentGetData(
-    entityId, componentId, COMPONENT_TYPE_POSITION
-  );
-  entityPositionEnsureWorld(pos);
-  glm_mat4_copy(
-    pos->parentEntityId == ENTITY_ID_INVALID ? pos->localTransform : pos->worldTransform,
-    dest
-  );
-}
-
-void entityPositionGetLocalTransform(
-  const entityid_t entityId,
-  const componentid_t componentId,
-  mat4 dest
-) {
-  entityposition_t *pos = componentGetData(
-    entityId, componentId, COMPONENT_TYPE_POSITION
-  );
-  entityPositionEnsureLocal(pos);
-  glm_mat4_copy(pos->localTransform, dest);
-}
-
-void entityPositionGetLocalPosition(
-  const entityid_t entityId,
-  const componentid_t componentId,
-  vec3 dest
-) {
-  entityposition_t *pos = componentGetData(
-    entityId, componentId, COMPONENT_TYPE_POSITION
-  );
-  entityPositionEnsurePRS(pos);
-  glm_vec3_copy(pos->position, dest);
-}
-
-void entityPositionGetWorldPosition(
-  const entityid_t entityId,
-  const componentid_t componentId,
-  vec3 dest
-) {
-  entityposition_t *pos = componentGetData(
-    entityId, componentId, COMPONENT_TYPE_POSITION
-  );
-  if(pos->parentEntityId == ENTITY_ID_INVALID) {
-    entityPositionEnsurePRS(pos);
-    glm_vec3_copy(pos->position, dest);
-    return;
-  }
-  entityPositionEnsureWorld(pos);
-  dest[0] = pos->worldTransform[3][0];
-  dest[1] = pos->worldTransform[3][1];
-  dest[2] = pos->worldTransform[3][2];
-}
-
-void entityPositionSetWorldPosition(
-  const entityid_t entityId,
-  const componentid_t componentId,
-  vec3 position
-) {
-  entityposition_t *pos = componentGetData(
-    entityId, componentId, COMPONENT_TYPE_POSITION
-  );
-  if(pos->parentEntityId == ENTITY_ID_INVALID) {
-    glm_vec3_copy(position, pos->position);
-    pos->flags = (pos->flags | ENTITY_POSITION_FLAG_POSITION_DIRTY)
-               & ~ENTITY_POSITION_FLAG_PRS_DIRTY;
-    entityPositionMarkDirty(pos);
-    return;
-  }
-  entityposition_t *parent = componentGetData(
-    pos->parentEntityId, pos->parentComponentId, COMPONENT_TYPE_POSITION
-  );
-  entityPositionEnsureWorld(parent);
-  mat4 invParent;
-  glm_mat4_inv(parent->worldTransform, invParent);
-  vec3 localPos;
-  glm_mat4_mulv3(invParent, position, 1.0f, localPos);
-  glm_vec3_copy(localPos, pos->position);
-  pos->flags = (pos->flags | ENTITY_POSITION_FLAG_POSITION_DIRTY)
-             & ~ENTITY_POSITION_FLAG_PRS_DIRTY;
-  entityPositionMarkDirty(pos);
-}
-
-void entityPositionSetLocalPosition(
-  const entityid_t entityId,
-  const componentid_t componentId,
-  vec3 position
-) {
-  entityposition_t *pos = componentGetData(
-    entityId, componentId, COMPONENT_TYPE_POSITION
-  );
-  glm_vec3_copy(position, pos->position);
-  pos->flags = (pos->flags | ENTITY_POSITION_FLAG_POSITION_DIRTY)
-             & ~ENTITY_POSITION_FLAG_PRS_DIRTY;
-  entityPositionMarkDirty(pos);
-}
-
-void entityPositionGetLocalRotation(
-  const entityid_t entityId,
-  const componentid_t componentId,
-  vec3 dest
-) {
-  entityposition_t *pos = componentGetData(
-    entityId, componentId, COMPONENT_TYPE_POSITION
-  );
-  entityPositionEnsurePRS(pos);
-  glm_vec3_copy(pos->rotation, dest);
-}
-
-void entityPositionGetWorldRotation(
-  const entityid_t entityId,
-  const componentid_t componentId,
-  vec3 dest
-) {
-  entityposition_t *pos = componentGetData(
-    entityId, componentId, COMPONENT_TYPE_POSITION
-  );
-  if(pos->parentEntityId == ENTITY_ID_INVALID) {
-    entityPositionEnsurePRS(pos);
-    glm_vec3_copy(pos->rotation, dest);
-    return;
-  }
-  entityPositionEnsureWorld(pos);
-  const float (*wt)[4] = pos->worldTransform;
-  const float sx = sqrtf(wt[0][0]*wt[0][0] + wt[0][1]*wt[0][1] + wt[0][2]*wt[0][2]);
-  const float sy = sqrtf(wt[1][0]*wt[1][0] + wt[1][1]*wt[1][1] + wt[1][2]*wt[1][2]);
-  const float sz = sqrtf(wt[2][0]*wt[2][0] + wt[2][1]*wt[2][1] + wt[2][2]*wt[2][2]);
-  const float r00 = sx > 0.0f ? wt[0][0]/sx : 0.0f;
-  const float r10 = sy > 0.0f ? wt[1][0]/sy : 0.0f;
-  const float r20 = sz > 0.0f ? wt[2][0]/sz : 0.0f;
-  const float r01 = sx > 0.0f ? wt[0][1]/sx : 0.0f;
-  const float r11 = sy > 0.0f ? wt[1][1]/sy : 0.0f;
-  const float r21 = sz > 0.0f ? wt[2][1]/sz : 0.0f;
-  const float r22 = sz > 0.0f ? wt[2][2]/sz : 0.0f;
-  const float sinBeta = glm_clamp(r20, -1.0f, 1.0f);
-  dest[1] = asinf(sinBeta);
-  const float cosBeta = cosf(dest[1]);
-  if(fabsf(cosBeta) > 1e-6f) {
-    dest[0] = atan2f(-r21, r22);
-    dest[2] = atan2f(-r10, r00);
-  } else {
-    dest[2] = 0.0f;
-    dest[0] = (sinBeta > 0.0f) ? atan2f(r01, r11) : -atan2f(r01, r11);
-  }
-}
-
-void entityPositionSetLocalRotation(
-  const entityid_t entityId,
-  const componentid_t componentId,
-  vec3 rotation
-) {
-  entityposition_t *pos = componentGetData(
-    entityId, componentId, COMPONENT_TYPE_POSITION
-  );
-  glm_vec3_copy(rotation, pos->rotation);
-  pos->flags = (pos->flags | ENTITY_POSITION_FLAG_ROTATION_DIRTY)
-             & ~ENTITY_POSITION_FLAG_PRS_DIRTY;
-  entityPositionMarkDirty(pos);
-}
-
-void entityPositionSetWorldRotation(
-  const entityid_t entityId,
-  const componentid_t componentId,
-  vec3 rotation
-) {
-  entityposition_t *pos = componentGetData(
-    entityId, componentId, COMPONENT_TYPE_POSITION
-  );
-  if(pos->parentEntityId == ENTITY_ID_INVALID) {
-    glm_vec3_copy(rotation, pos->rotation);
-    pos->flags = (pos->flags | ENTITY_POSITION_FLAG_ROTATION_DIRTY)
-               & ~ENTITY_POSITION_FLAG_PRS_DIRTY;
-    entityPositionMarkDirty(pos);
-    return;
-  }
-  entityposition_t *parent = componentGetData(
-    pos->parentEntityId, pos->parentComponentId, COMPONENT_TYPE_POSITION
-  );
-  entityPositionEnsureWorld(parent);
-
-  // Build target world rotation matrix (unit scale) from XYZ euler.
-  const float c0 = cosf(rotation[0]), s0 = sinf(rotation[0]);
-  const float c1 = cosf(rotation[1]), s1 = sinf(rotation[1]);
-  const float c2 = cosf(rotation[2]), s2 = sinf(rotation[2]);
-  const float s0s1 = s0*s1, c0s1 = c0*s1;
-  // Named wr[col_stored][row_stored] matching cglm column-major layout.
-  const float wr00 =  c1*c2,             wr01 =  c0*s2 + s0s1*c2,  wr02 =  s0*s2 - c0s1*c2;
-  const float wr10 = -c1*s2,             wr11 =  c0*c2 - s0s1*s2,  wr12 =  s0*c2 + c0s1*s2;
-  const float wr20 =  s1,                wr21 = -s0*c1,             wr22 =  c0*c1;
-
-  // Normalize parent world columns to extract pure rotation.
-  const float (*pt)[4] = parent->worldTransform;
-  const float psx = sqrtf(pt[0][0]*pt[0][0] + pt[0][1]*pt[0][1] + pt[0][2]*pt[0][2]);
-  const float psy = sqrtf(pt[1][0]*pt[1][0] + pt[1][1]*pt[1][1] + pt[1][2]*pt[1][2]);
-  const float psz = sqrtf(pt[2][0]*pt[2][0] + pt[2][1]*pt[2][1] + pt[2][2]*pt[2][2]);
-  const float pr00 = psx > 0.f ? pt[0][0]/psx : 0.f;
-  const float pr01 = psx > 0.f ? pt[0][1]/psx : 0.f;
-  const float pr02 = psx > 0.f ? pt[0][2]/psx : 0.f;
-  const float pr10 = psy > 0.f ? pt[1][0]/psy : 0.f;
-  const float pr11 = psy > 0.f ? pt[1][1]/psy : 0.f;
-  const float pr12 = psy > 0.f ? pt[1][2]/psy : 0.f;
-  const float pr20 = psz > 0.f ? pt[2][0]/psz : 0.f;
-  const float pr21 = psz > 0.f ? pt[2][1]/psz : 0.f;
-  const float pr22 = psz > 0.f ? pt[2][2]/psz : 0.f;
-
-  // local_R = parent_R^T * world_R  (R^-1 == R^T for orthogonal matrices).
-  // Compute only the 7 entries of the local rotation matrix needed for XYZ
-  // euler extraction (stored column-major: [col][row] = math [row][col]).
-  // sinBeta  = stored[2][0] = math[0][2]
-  // r21/r22  = stored[2][1..2] = math[1..2][2]
-  // r10/r00  = stored[1][0], stored[0][0] = math[0][1], math[0][0]
-  // gimbal   = stored[0][1], stored[1][1] = math[1][0], math[1][1]
-  const float lr00  = pr00*wr00 + pr01*wr10 + pr02*wr20;  // math[0][0]
-  const float lr10  = pr00*wr01 + pr01*wr11 + pr02*wr21;  // math[0][1]
-  const float lr20  = pr00*wr02 + pr01*wr12 + pr02*wr22;  // math[0][2] → sinBeta
-  const float lr01  = pr10*wr00 + pr11*wr10 + pr12*wr20;  // math[1][0]
-  const float lr11  = pr10*wr01 + pr11*wr11 + pr12*wr21;  // math[1][1]
-  const float lr21  = pr10*wr02 + pr11*wr12 + pr12*wr22;  // math[1][2] → r21
-  const float lr22  = pr20*wr02 + pr21*wr12 + pr22*wr22;  // math[2][2] → r22
-
-  const float sinBeta = glm_clamp(lr20, -1.0f, 1.0f);
-  pos->rotation[1] = asinf(sinBeta);
-  const float cosBeta = cosf(pos->rotation[1]);
-  if(fabsf(cosBeta) > 1e-6f) {
-    pos->rotation[0] = atan2f(-lr21, lr22);
-    pos->rotation[2] = atan2f(-lr10, lr00);
-  } else {
-    pos->rotation[2] = 0.0f;
-    pos->rotation[0] = (sinBeta > 0.0f) ? atan2f(lr01, lr11) : -atan2f(lr01, lr11);
-  }
-  pos->flags = (pos->flags | ENTITY_POSITION_FLAG_ROTATION_DIRTY)
-             & ~ENTITY_POSITION_FLAG_PRS_DIRTY;
-  entityPositionMarkDirty(pos);
-}
-
-void entityPositionGetLocalScale(
-  const entityid_t entityId,
-  const componentid_t componentId,
-  vec3 dest
-) {
-  entityposition_t *pos = componentGetData(
-    entityId, componentId, COMPONENT_TYPE_POSITION
-  );
-  entityPositionEnsurePRS(pos);
-  glm_vec3_copy(pos->scale, dest);
-}
-
-void entityPositionGetWorldScale(
-  const entityid_t entityId,
-  const componentid_t componentId,
-  vec3 dest
-) {
-  entityposition_t *pos = componentGetData(
-    entityId, componentId, COMPONENT_TYPE_POSITION
-  );
-  if(pos->parentEntityId == ENTITY_ID_INVALID) {
-    entityPositionEnsurePRS(pos);
-    glm_vec3_copy(pos->scale, dest);
-    return;
-  }
-  entityPositionEnsureWorld(pos);
-  const float (*wt)[4] = pos->worldTransform;
-  dest[0] = sqrtf(wt[0][0]*wt[0][0] + wt[0][1]*wt[0][1] + wt[0][2]*wt[0][2]);
-  dest[1] = sqrtf(wt[1][0]*wt[1][0] + wt[1][1]*wt[1][1] + wt[1][2]*wt[1][2]);
-  dest[2] = sqrtf(wt[2][0]*wt[2][0] + wt[2][1]*wt[2][1] + wt[2][2]*wt[2][2]);
-}
-
-void entityPositionSetLocalScale(
-  const entityid_t entityId,
-  const componentid_t componentId,
-  vec3 scale
-) {
-  entityposition_t *pos = componentGetData(
-    entityId, componentId, COMPONENT_TYPE_POSITION
-  );
-  glm_vec3_copy(scale, pos->scale);
-  pos->flags = (pos->flags | ENTITY_POSITION_FLAG_ROTATION_DIRTY)
-             & ~ENTITY_POSITION_FLAG_PRS_DIRTY;
-  entityPositionMarkDirty(pos);
-}
-
-void entityPositionSetWorldScale(
-  const entityid_t entityId,
-  const componentid_t componentId,
-  vec3 scale
-) {
-  entityposition_t *pos = componentGetData(
-    entityId, componentId, COMPONENT_TYPE_POSITION
-  );
-  if(pos->parentEntityId == ENTITY_ID_INVALID) {
-    glm_vec3_copy(scale, pos->scale);
-    pos->flags = (pos->flags | ENTITY_POSITION_FLAG_ROTATION_DIRTY)
-               & ~ENTITY_POSITION_FLAG_PRS_DIRTY;
-    entityPositionMarkDirty(pos);
-    return;
-  }
-  entityposition_t *parent = componentGetData(
-    pos->parentEntityId, pos->parentComponentId, COMPONENT_TYPE_POSITION
-  );
-  entityPositionEnsureWorld(parent);
-  const float (*pt)[4] = parent->worldTransform;
-  const float psx = sqrtf(pt[0][0]*pt[0][0] + pt[0][1]*pt[0][1] + pt[0][2]*pt[0][2]);
-  const float psy = sqrtf(pt[1][0]*pt[1][0] + pt[1][1]*pt[1][1] + pt[1][2]*pt[1][2]);
-  const float psz = sqrtf(pt[2][0]*pt[2][0] + pt[2][1]*pt[2][1] + pt[2][2]*pt[2][2]);
-  pos->scale[0] = psx > 0.0f ? scale[0] / psx : scale[0];
-  pos->scale[1] = psy > 0.0f ? scale[1] / psy : scale[1];
-  pos->scale[2] = psz > 0.0f ? scale[2] / psz : scale[2];
-  pos->flags = (pos->flags | ENTITY_POSITION_FLAG_ROTATION_DIRTY)
-             & ~ENTITY_POSITION_FLAG_PRS_DIRTY;
-  entityPositionMarkDirty(pos);
-}
-
-void entityPositionSetParent(
-  const entityid_t entityId,
-  const componentid_t componentId,
-  const entityid_t parentEntityId,
-  const componentid_t parentComponentId
-) {
-  entityposition_t *pos = componentGetData(
-    entityId, componentId, COMPONENT_TYPE_POSITION
-  );
-
-  // Remove from old parent's child list.
-  if(pos->parentEntityId != ENTITY_ID_INVALID) {
-    entityposition_t *oldParent = componentGetData(
-      pos->parentEntityId, pos->parentComponentId, COMPONENT_TYPE_POSITION
-    );
-    for(uint8_t i = 0; i < oldParent->childCount; i++) {
-      if(
-        oldParent->childEntityIds[i] == entityId &&
-        oldParent->childComponentIds[i] == componentId
-      ) {
-        oldParent->childCount--;
-        for(uint8_t j = i; j < oldParent->childCount; j++) {
-          oldParent->childEntityIds[j]    = oldParent->childEntityIds[j + 1];
-          oldParent->childComponentIds[j] = oldParent->childComponentIds[j + 1];
-        }
-        break;
-      }
-    }
-  }
-
-  pos->parentEntityId    = parentEntityId;
-  pos->parentComponentId = parentComponentId;
-
-  // Register with new parent.
-  if(parentEntityId != ENTITY_ID_INVALID) {
-    entityposition_t *parent = componentGetData(
-      parentEntityId, parentComponentId, COMPONENT_TYPE_POSITION
-    );
-    if(parent->childCount < ENTITY_POSITION_CHILDREN_MAX) {
-      parent->childEntityIds[parent->childCount]    = entityId;
-      parent->childComponentIds[parent->childCount] = componentId;
-      parent->childCount++;
-    }
-  }
-
-  entityPositionMarkDirty(pos);
-}
-
-entityposition_t *entityPositionGet(
-  const entityid_t entityId,
-  const componentid_t componentId
-) {
-  return componentGetData(
-    entityId, componentId, COMPONENT_TYPE_POSITION
-  );
-}
-
-void entityPositionRebuild(entityposition_t *pos) {
-  pos->flags = (pos->flags | ENTITY_POSITION_FLAG_ROTATION_DIRTY | ENTITY_POSITION_FLAG_POSITION_DIRTY)
-             & ~ENTITY_POSITION_FLAG_PRS_DIRTY;
-  entityPositionMarkDirty(pos);
-}
-
-void entityPositionDisposeDeep(
-  const entityid_t entityId,
-  const componentid_t componentId
-) {
-  entityposition_t *pos = entityPositionGet(entityId, componentId);
-
-  // Detach from parent so the parent's child list stays consistent.
-  if(pos->parentEntityId != ENTITY_ID_INVALID) {
-    entityPositionSetParent(entityId, componentId, ENTITY_ID_INVALID, COMPONENT_ID_INVALID);
-  }
-
-  // Copy the child list before disposing self (entityDispose invalidates pos).
-  uint8_t childCount = pos->childCount;
-  entityid_t childEntityIds[ENTITY_POSITION_CHILDREN_MAX];
-  componentid_t childComponentIds[ENTITY_POSITION_CHILDREN_MAX];
-  for(uint8_t i = 0; i < childCount; i++) {
-    childEntityIds[i]    = pos->childEntityIds[i];
-    childComponentIds[i] = pos->childComponentIds[i];
-    // Sever the child's parent link so it won't try to modify our disposed data.
-    entityposition_t *child = entityPositionGet(childEntityIds[i], childComponentIds[i]);
-    child->parentEntityId    = ENTITY_ID_INVALID;
-    child->parentComponentId = COMPONENT_ID_INVALID;
-  }
-
-  entityDispose(entityId);
-
-  for(uint8_t i = 0; i < childCount; i++) {
-    entityPositionDisposeDeep(childEntityIds[i], childComponentIds[i]);
-  }
-}
-
-void entityPositionDecompose(entityposition_t *pos) {
-  // Translation: column 3
-  pos->position[0] = pos->localTransform[3][0];
-  pos->position[1] = pos->localTransform[3][1];
-  pos->position[2] = pos->localTransform[3][2];
-
-  // Scale: length of each basis column (xyz only)
-  pos->scale[0] = sqrtf(
-    pos->localTransform[0][0] * pos->localTransform[0][0] +
-    pos->localTransform[0][1] * pos->localTransform[0][1] +
-    pos->localTransform[0][2] * pos->localTransform[0][2]
-  );
-  pos->scale[1] = sqrtf(
-    pos->localTransform[1][0] * pos->localTransform[1][0] +
-    pos->localTransform[1][1] * pos->localTransform[1][1] +
-    pos->localTransform[1][2] * pos->localTransform[1][2]
-  );
-  pos->scale[2] = sqrtf(
-    pos->localTransform[2][0] * pos->localTransform[2][0] +
-    pos->localTransform[2][1] * pos->localTransform[2][1] +
-    pos->localTransform[2][2] * pos->localTransform[2][2]
-  );
-
-  // Normalize columns to isolate the rotation matrix (9 floats, no mat4 needed).
-  const float invS0 = pos->scale[0] > 0.0f ? 1.0f / pos->scale[0] : 0.0f;
-  const float invS1 = pos->scale[1] > 0.0f ? 1.0f / pos->scale[1] : 0.0f;
-  const float invS2 = pos->scale[2] > 0.0f ? 1.0f / pos->scale[2] : 0.0f;
-
-  const float r00 = pos->localTransform[0][0] * invS0;
-  const float r01 = pos->localTransform[0][1] * invS0;
-  const float r02 = pos->localTransform[0][2] * invS0;
-  const float r10 = pos->localTransform[1][0] * invS1;
-  const float r11 = pos->localTransform[1][1] * invS1;
-  const float r20 = pos->localTransform[2][0] * invS2;
-  const float r21 = pos->localTransform[2][1] * invS2;
-  const float r22 = pos->localTransform[2][2] * invS2;
-
-  // Extract XYZ euler angles (R = Rx * Ry * Rz, column-major)
-  const float sinBeta = glm_clamp(r20, -1.0f, 1.0f);
-  pos->rotation[1] = asinf(sinBeta);
-  const float cosBeta = cosf(pos->rotation[1]);
-
-  if(fabsf(cosBeta) > 1e-6f) {
-    pos->rotation[0] = atan2f(-r21, r22);
-    pos->rotation[2] = atan2f(-r10, r00);
-  } else {
-    // Gimbal lock: pin Z to 0, recover X.
-    pos->rotation[2] = 0.0f;
-    pos->rotation[0] = (sinBeta > 0.0f)
-      ? atan2f(r01, r11)
-      : -atan2f(r01, r11);
-  }
-}
@@ -1,375 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- *
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "entity/entitybase.h"
-
-/** Maximum number of child position components this node can track. */
-#define ENTITY_POSITION_CHILDREN_MAX 8
-
-/**
- * PRS cache is stale. localTransform was written directly (e.g. lookAt) and
- * position/rotation/scale need to be decomposed before they can be read.
- */
-#define ENTITY_POSITION_FLAG_PRS_DIRTY   (1 << 0)
-
-/**
- * Columns 0-2 of localTransform are stale. Rotation or scale changed; the
- * basis vectors need to be rebuilt analytically before the matrix can be used.
- * Does not imply column 3 (translation) is stale.
- */
-#define ENTITY_POSITION_FLAG_ROTATION_DIRTY (1 << 1)
-
-/**
- * Column 3 of localTransform is stale. Position changed; only the translation
- * column needs to be written. Does not imply columns 0-2 are stale.
- */
-#define ENTITY_POSITION_FLAG_POSITION_DIRTY (1 << 2)
-
-/**
- * worldTransform is stale. Either the local matrix changed or an ancestor
- * moved; the full parent-chain multiply must be rerun before world data is read.
- */
-#define ENTITY_POSITION_FLAG_WORLD_DIRTY (1 << 3)
-
-typedef struct {
-  /*
-   * Hot fields — flag checks and parent/child traversal (markDirty, ensureWorld)
-   * only touch these. Kept at the front so they share the first cache line.
-   */
-
-  /** Bitmask of ENTITY_POSITION_FLAG_* values describing which caches are stale. */
-  uint8_t flags;
-  /** Entity ID of the parent node, or ENTITY_ID_INVALID if none. */
-  entityid_t parentEntityId;
-  /** Component ID of the parent position component, or COMPONENT_ID_INVALID if none. */
-  componentid_t parentComponentId;
-  /** Number of currently registered children. */
-  uint8_t childCount;
-  /** Entity IDs of child nodes. */
-  entityid_t childEntityIds[ENTITY_POSITION_CHILDREN_MAX];
-  /** Component IDs of child position components. */
-  componentid_t childComponentIds[ENTITY_POSITION_CHILDREN_MAX];
-
-  /*
-   * Warm fields — read/written by PRS getters/setters.
-   * Accessed more often than the matrices but less often than flags.
-   */
-
-  /** Cached local position (XYZ). May be stale when ENTITY_POSITION_FLAG_PRS_DIRTY is set. */
-  vec3 position;
-  /** Cached local euler rotation (XYZ, radians). May be stale when ENTITY_POSITION_FLAG_PRS_DIRTY is set. */
-  vec3 rotation;
-  /** Cached local scale (XYZ). May be stale when ENTITY_POSITION_FLAG_PRS_DIRTY is set. */
-  vec3 scale;
-
-  /*
-   * Cold fields — only touched when actually rebuilding transforms.
-   */
-
-  /** Local transform matrix, rebuilt lazily from position/rotation/scale. */
-  mat4 localTransform;
-  /** World transform matrix, recomputed lazily from the parent chain. */
-  mat4 worldTransform;
-} entityposition_t;
-
-/**
- * Initializes the entity position component, setting identity transforms and
- * zeroing all parent/child state.
- *
- * @param entityId The entity ID.
- * @param componentId The component ID.
- */
-void entityPositionInit(
-  const entityid_t entityId,
-  const componentid_t componentId
-);
-
-/**
- * Transforms the entity's local transform to look at a target point.
- *
- * @param entityId The entity ID.
- * @param componentId The component ID.
- * @param eye The eye/camera position.
- * @param target The target point to look at.
- * @param up The up vector.
- */
-void entityPositionLookAt(
-  const entityid_t entityId,
-  const componentid_t componentId,
-  vec3 eye,
-  vec3 target,
-  vec3 up
-);
-
-/**
- * Gets the world-space transform matrix, recomputing it lazily if dirty.
- *
- * @param entityId The entity ID.
- * @param componentId The component ID.
- * @param dest Destination matrix.
- */
-void entityPositionGetTransform(
-  const entityid_t entityId,
-  const componentid_t componentId,
-  mat4 dest
-);
-
-/**
- * Gets the local transform matrix (does not include parent transforms).
- *
- * @param entityId The entity ID.
- * @param componentId The component ID.
- * @param dest Destination matrix.
- */
-void entityPositionGetLocalTransform(
-  const entityid_t entityId,
-  const componentid_t componentId,
-  mat4 dest
-);
-
-/**
- * Gets the cached local position (XYZ). Decomposes localTransform into PRS
- * first if ENTITY_POSITION_FLAG_PRS_DIRTY is set; never triggers a matrix
- * rebuild or world-transform update.
- *
- * @param entityId The entity ID.
- * @param componentId The component ID.
- * @param dest Destination vector.
- */
-void entityPositionGetLocalPosition(
-  const entityid_t entityId,
-  const componentid_t componentId,
-  vec3 dest
-);
-
-/**
- * Gets the world-space position. For parentless entities this is the same as
- * the local position.
- *
- * @param entityId The entity ID.
- * @param componentId The component ID.
- * @param dest Destination vector.
- */
-void entityPositionGetWorldPosition(
-  const entityid_t entityId,
-  const componentid_t componentId,
-  vec3 dest
-);
-
-/**
- * Sets the world-space position. For parentless entities this is equivalent to
- * entityPositionSetLocalPosition. For parented entities the position is
- * converted to local space via the inverted parent world transform.
- *
- * @param entityId The entity ID.
- * @param componentId The component ID.
- * @param position The desired world-space position.
- */
-void entityPositionSetWorldPosition(
-  const entityid_t entityId,
-  const componentid_t componentId,
-  vec3 position
-);
-
-/**
- * Sets the local position, marks localTransform and worldTransform (self +
- * descendants) dirty.
- *
- * @param entityId The entity ID.
- * @param componentId The component ID.
- * @param position The new local position.
- */
-void entityPositionSetLocalPosition(
-  const entityid_t entityId,
-  const componentid_t componentId,
-  vec3 position
-);
-
-/**
- * Gets the cached local euler rotation (XYZ, radians). Decomposes
- * localTransform first if ENTITY_POSITION_FLAG_PRS_DIRTY is set.
- *
- * @param entityId The entity ID.
- * @param componentId The component ID.
- * @param dest Destination vector.
- */
-void entityPositionGetLocalRotation(
-  const entityid_t entityId,
-  const componentid_t componentId,
-  vec3 dest
-);
-
-/**
- * Gets the world-space euler rotation (XYZ, radians) by decomposing the world
- * transform. For parentless entities this is the same as local rotation.
- *
- * @param entityId The entity ID.
- * @param componentId The component ID.
- * @param dest Destination vector.
- */
-void entityPositionGetWorldRotation(
-  const entityid_t entityId,
-  const componentid_t componentId,
-  vec3 dest
-);
-
-/**
- * Sets the local euler rotation (XYZ, radians) and marks transforms dirty.
- *
- * @param entityId The entity ID.
- * @param componentId The component ID.
- * @param rotation The new local rotation.
- */
-void entityPositionSetLocalRotation(
-  const entityid_t entityId,
-  const componentid_t componentId,
-  vec3 rotation
-);
-
-/**
- * Sets the world-space euler rotation (XYZ, radians). For parentless entities
- * this is equivalent to entityPositionSetLocalRotation. For parented entities
- * the rotation is converted to local space by removing the parent world
- * rotation.
- *
- * @param entityId The entity ID.
- * @param componentId The component ID.
- * @param rotation The desired world-space euler rotation.
- */
-void entityPositionSetWorldRotation(
-  const entityid_t entityId,
-  const componentid_t componentId,
-  vec3 rotation
-);
-
-/**
- * Gets the cached local scale. Decomposes localTransform first if
- * ENTITY_POSITION_FLAG_PRS_DIRTY is set.
- *
- * @param entityId The entity ID.
- * @param componentId The component ID.
- * @param dest Destination vector.
- */
-void entityPositionGetLocalScale(
-  const entityid_t entityId,
-  const componentid_t componentId,
-  vec3 dest
-);
-
-/**
- * Gets the world-space scale by extracting column lengths from the world
- * transform. For parentless entities this is the same as local scale.
- *
- * @param entityId The entity ID.
- * @param componentId The component ID.
- * @param dest Destination vector.
- */
-void entityPositionGetWorldScale(
-  const entityid_t entityId,
-  const componentid_t componentId,
-  vec3 dest
-);
-
-/**
- * Sets the local scale and marks transforms dirty.
- *
- * @param entityId The entity ID.
- * @param componentId The component ID.
- * @param scale The new local scale.
- */
-void entityPositionSetLocalScale(
-  const entityid_t entityId,
-  const componentid_t componentId,
-  vec3 scale
-);
-
-/**
- * Sets the world-space scale. For parentless entities this is equivalent to
- * entityPositionSetLocalScale. For parented entities the scale is converted to
- * local space by dividing by the parent world scale (assumes no shear).
- *
- * @param entityId The entity ID.
- * @param componentId The component ID.
- * @param scale The desired world-space scale.
- */
-void entityPositionSetWorldScale(
-  const entityid_t entityId,
-  const componentid_t componentId,
-  vec3 scale
-);
-
-/**
- * Sets the parent of this entity's position component.
- * Pass ENTITY_ID_INVALID / COMPONENT_ID_INVALID to detach from any parent.
- *
- * @param entityId The child entity ID.
- * @param componentId The child component ID.
- * @param parentEntityId The parent entity ID.
- * @param parentComponentId The parent component ID.
- */
-void entityPositionSetParent(
-  const entityid_t entityId,
-  const componentid_t componentId,
-  const entityid_t parentEntityId,
-  const componentid_t parentComponentId
-);
-
-/**
- * Returns a direct pointer to the entity position component data.
- * After modifying localTransform directly, call entityPositionMarkDirty() to
- * set ENTITY_POSITION_FLAG_WORLD_DIRTY on self and descendants. After
- * modifying PRS directly, call entityPositionRebuild() instead.
- *
- * @param entityId The entity ID.
- * @param componentId The component ID.
- * @return Pointer to the component data.
- */
-entityposition_t *entityPositionGet(
-  const entityid_t entityId,
-  const componentid_t componentId
-);
-
-/**
- * Signals that the PRS cache was modified externally. Sets both
- * ENTITY_POSITION_FLAG_ROTATION_DIRTY and ENTITY_POSITION_FLAG_POSITION_DIRTY
- * so all of localTransform is rebuilt lazily on the next read, clears
- * ENTITY_POSITION_FLAG_PRS_DIRTY, and propagates ENTITY_POSITION_FLAG_WORLD_DIRTY
- * to self and all descendants.
- *
- * @param pos The position component whose PRS was modified.
- */
-void entityPositionRebuild(entityposition_t *pos);
-
-/**
- * Sets ENTITY_POSITION_FLAG_WORLD_DIRTY on this node and all descendants,
- * indicating that worldTransform must be recomputed before it is read.
- * Call this after modifying localTransform directly.
- *
- * @param pos The position component to mark dirty.
- */
-void entityPositionMarkDirty(entityposition_t *pos);
-
-/**
- * Disposes this entity and all of its position-component descendants
- * recursively. Detaches from any parent before destroying.
- *
- * @param entityId The root entity ID.
- * @param componentId The root position component ID.
- */
-void entityPositionDisposeDeep(
-  const entityid_t entityId,
-  const componentid_t componentId
-);
-
-/**
- * Decomposes the local transform matrix back into the position, rotation
- * (XYZ euler, radians), and scale cache fields.
- *
- * @param pos The position component to decompose.
- */
-void entityPositionDecompose(entityposition_t *pos);
@@ -1,142 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- *
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "entityrenderable.h"
-#include "entity/entitymanager.h"
-#include "display/shader/shadermaterial.h"
-#include "display/shader/shaderunlit.h"
-#include "display/display.h"
-#include "display/mesh/cube.h"
-#include "util/memory.h"
-#include "assert/assert.h"
-
-void entityRenderableInit(
-  const entityid_t entityId,
-  const componentid_t componentId
-) {
-  entityrenderable_t *r = componentGetData(
-    entityId, componentId, COMPONENT_TYPE_RENDERABLE
-  );
-  memoryZero(r, sizeof(entityrenderable_t));
-  r->type = ENTITY_RENDERABLE_TYPE_SHADER_MATERIAL;
-  r->data.material.shaderType = SHADER_LIST_SHADER_UNLIT;
-  r->data.material.material.unlit.color = COLOR_WHITE;
-  r->data.material.meshes[0] = &CUBE_MESH_SIMPLE;
-  r->data.material.meshOffsets[0] = 0;
-  r->data.material.meshCounts[0] = -1;
-  r->data.material.meshCount = 1;
-  r->data.material.state.flags = DISPLAY_STATE_FLAG_DEPTH_TEST;
-}
-
-void entityRenderableDispose(
-  const entityid_t entityId,
-  const componentid_t componentId
-) {
-}
-
-void entityRenderableSetType(
-  const entityid_t entityId,
-  const componentid_t componentId,
-  const entityrenderabletype_t type
-) {
-  entityrenderable_t *r = componentGetData(
-    entityId, componentId, COMPONENT_TYPE_RENDERABLE
-  );
-  r->type = type;
-}
-
-void entityRenderableSetPriority(
-  const entityid_t entityId,
-  const componentid_t componentId,
-  const int8_t priority
-) {
-  entityrenderable_t *r = componentGetData(
-    entityId, componentId, COMPONENT_TYPE_RENDERABLE
-  );
-  r->priority = priority;
-}
-
-void entityRenderableSetDraw(
-  const entityid_t entityId,
-  const componentid_t componentId,
-  errorret_t (*draw)(
-    const entityid_t entityId,
-    const componentid_t componentId,
-    void *user
-  ),
-  void *user
-) {
-  assertNotNull(draw, "Draw callback cannot be null");
-  entityrenderable_t *r = componentGetData(
-    entityId, componentId, COMPONENT_TYPE_RENDERABLE
-  );
-  r->type = ENTITY_RENDERABLE_TYPE_CUSTOM;
-  r->data.custom.draw = draw;
-  r->data.custom.drawUser = user;
-}
-
-static errorret_t entityRenderableDrawSpritebatch(
-  const entityrenderablespritebatch_t *sb
-) {
-  if(sb->spriteCount == 0) errorOk();
-
-  errorChain(displaySetState((displaystate_t){
-    .flags = DISPLAY_STATE_FLAG_BLEND
-  }));
-
-  spriteBatchClear();
-  shadermaterial_t mat;
-  memoryZero(&mat, sizeof(shadermaterial_t));
-  mat.unlit.texture = sb->texture;
-  mat.unlit.color = COLOR_WHITE;
-  errorChain(spriteBatchBuffer(
-    sb->sprites, sb->spriteCount,
-    SHADER_LIST_DEFS[SHADER_LIST_SHADER_UNLIT].shader, mat
-  ));
-  return spriteBatchFlush();
-}
-
-static errorret_t entityRenderableDrawMaterial(
-  const entityrenderablematerial_t *m
-) {
-  errorChain(displaySetState(m->state));
-  shader_t *shader = SHADER_LIST_DEFS[m->shaderType].shader;
-  assertNotNull(shader, "Shader cannot be null for material type");
-  errorChain(shaderBind(shader));
-  errorChain(shaderSetMaterial(shader, &m->material));
-  for(uint8_t i = 0; i < m->meshCount; i++) {
-    errorChain(meshDraw(m->meshes[i], m->meshOffsets[i], m->meshCounts[i]));
-  }
-  errorOk();
-}
-
-static errorret_t entityRenderableDrawCustom(
-  const entityid_t entityId,
-  const componentid_t componentId,
-  const entityrenderablecustom_t *custom
-) {
-  return custom->draw(entityId, componentId, custom->drawUser);
-}
-
-errorret_t entityRenderableDraw(
-  const entityid_t entityId,
-  const componentid_t componentId
-) {
-  entityrenderable_t *r = componentGetData(
-    entityId, componentId, COMPONENT_TYPE_RENDERABLE
-  );
-  switch(r->type) {
-    case ENTITY_RENDERABLE_TYPE_SPRITEBATCH:
-      return entityRenderableDrawSpritebatch(&r->data.spritebatch);
-    case ENTITY_RENDERABLE_TYPE_SHADER_MATERIAL:
-      return entityRenderableDrawMaterial(&r->data.material);
-    case ENTITY_RENDERABLE_TYPE_CUSTOM:
-      return entityRenderableDrawCustom(entityId, componentId, &r->data.custom);
-    default:
-      assertUnreachable("Invalid renderable type");
-  }
-}
@@ -1,147 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- *
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "entity/entitybase.h"
-#include "display/mesh/mesh.h"
-#include "display/shader/shadermaterial.h"
-#include "display/spritebatch/spritebatch.h"
-#include "display/displaystate.h"
-
-#define ENTITY_RENDERABLE_SPRITEBATCH_SPRITES_MAX 64
-#define ENTITY_RENDERABLE_MESHES_MAX 8
-
-typedef enum {
-  ENTITY_RENDERABLE_TYPE_CUSTOM = 0,
-  ENTITY_RENDERABLE_TYPE_SPRITEBATCH,
-  ENTITY_RENDERABLE_TYPE_SHADER_MATERIAL,
-} entityrenderabletype_t;
-
-typedef struct {
-  spritebatchsprite_t sprites[ENTITY_RENDERABLE_SPRITEBATCH_SPRITES_MAX];
-  uint32_t spriteCount;
-  texture_t *texture;
-} entityrenderablespritebatch_t;
-
-typedef struct {
-  mesh_t *meshes[ENTITY_RENDERABLE_MESHES_MAX];
-  int32_t meshOffsets[ENTITY_RENDERABLE_MESHES_MAX];
-  int32_t meshCounts[ENTITY_RENDERABLE_MESHES_MAX];
-  uint8_t meshCount;
-  shaderlistshader_t shaderType;
-  shadermaterial_t material;
-  displaystate_t state;
-} entityrenderablematerial_t;
-
-typedef struct {
-  errorret_t (*draw)(
-    const entityid_t entityId,
-    const componentid_t componentId,
-    void *user
-  );
-  void *drawUser;
-} entityrenderablecustom_t;
-
-typedef union entityrenderabledata_u {
-  entityrenderablespritebatch_t spritebatch;
-  entityrenderablematerial_t material;
-  entityrenderablecustom_t custom;
-} entityrenderabledata_t;
-
-typedef struct {
-  entityrenderabletype_t type;
-  entityrenderabledata_t data;
-  
-  /**
-   * Render priority. 0 = auto (derived from type/flags). Higher values render
-   * later (on top of lower values). Range: [-128..127] with 0 is auto.
-   */
-  int8_t priority;
-} entityrenderable_t;
-
-/**
- * Initializes the entity renderable component. Defaults to
- * ENTITY_RENDERABLE_TYPE_SHADER_MATERIAL with the unlit shader, a white cube,
- * and depth-test enabled.
- *
- * @param entityId The entity to initialize the component for.
- * @param componentId The renderable component of the entity.
- */
-void entityRenderableInit(
-  const entityid_t entityId,
-  const componentid_t componentId
-);
-
-/**
- * Disposes the entity renderable component.
- *
- * @param entityId The entity to dispose the component for.
- * @param componentId The renderable component of the entity.
- */
-void entityRenderableDispose(
-  const entityid_t entityId,
-  const componentid_t componentId
-);
-
-/**
- * Sets the rendering type for the renderable component. Resets type-specific
- * data to zero.
- *
- * @param entityId The entity to configure.
- * @param componentId The renderable component.
- * @param type The rendering type to use.
- */
-void entityRenderableSetType(
-  const entityid_t entityId,
-  const componentid_t componentId,
-  const entityrenderabletype_t type
-);
-
-/**
- * Sets the render priority. 0 = auto (derived from type/flags). Higher values
- * render later (on top). Use non-zero to force ordering.
- *
- * @param entityId The entity to configure.
- * @param componentId The renderable component.
- * @param priority The priority value, or 0 for auto.
- */
-void entityRenderableSetPriority(
-  const entityid_t entityId,
-  const componentid_t componentId,
-  const int8_t priority
-);
-
-/**
- * Sets the draw callback, switching the type to ENTITY_RENDERABLE_TYPE_CUSTOM.
- *
- * @param entityId The entity to configure.
- * @param componentId The renderable component of the entity.
- * @param draw The draw callback to assign.
- * @param user Userdata passed to the callback.
- */
-void entityRenderableSetDraw(
-  const entityid_t entityId,
-  const componentid_t componentId,
-  errorret_t (*draw)(
-    const entityid_t entityId,
-    const componentid_t componentId,
-    void *user
-  ),
-  void *user
-);
-
-/**
- * Draws the entity using its renderable component data.
- *
- * @param entityId The entity to draw.
- * @param componentId The renderable component of the entity.
- * @return Any error state that happened.
- */
-errorret_t entityRenderableDraw(
-  const entityid_t entityId,
-  const componentid_t componentId
-);
@@ -1,126 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- *
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "entityphysics.h"
-#include "entity/entitymanager.h"
-#include "entity/component/display/entityposition.h"
-#include "physics/physicsmanager.h"
-#include "assert/assert.h"
-#include "util/memory.h"
-
-void entityPhysicsInit(
-  const entityid_t entityId,
-  const componentid_t componentId
-) {
-  entityphysics_t *phys = entityPhysicsGet(entityId, componentId);
-  assertNotNull(phys, "Failed to get physics component data");
-
-  memoryZero(phys, sizeof(entityphysics_t));
-  
-  // Default to cube
-  phys->type = PHYSICS_BODY_DYNAMIC;
-  phys->shape.type = PHYSICS_SHAPE_CUBE;
-  phys->shape.data.cube.halfExtents[0] = 0.5f;
-  phys->shape.data.cube.halfExtents[1] = 0.5f;
-  phys->shape.data.cube.halfExtents[2] = 0.5f;
-  phys->gravityScale = 1.0f;
-  phys->onGround = false;
-}
-
-entityphysics_t *entityPhysicsGet(
-  const entityid_t entityId,
-  const componentid_t componentId
-) {
-  return componentGetData(entityId, componentId, COMPONENT_TYPE_PHYSICS);
-}
-
-void entityPhysicsSetShape(
-  const entityid_t entityId,
-  const componentid_t componentId,
-  const physicsshape_t shape
-) {
-  entityphysics_t *phys = entityPhysicsGet(entityId, componentId);
-  assertNotNull(phys, "Failed to get physics component data");
-  phys->shape = shape;
-  // TODO: Do I need to reset the state for ground/active?
-}
-
-physicsshape_t entityPhysicsGetShape(
-  const entityid_t entityId,
-  const componentid_t componentId
-) {
-  entityphysics_t *phys = entityPhysicsGet(entityId, componentId);
-  assertNotNull(phys, "Failed to get physics component data");
-  return phys->shape;
-}
-
-void entityPhysicsGetVelocity(
-  const entityid_t entityId,
-  const componentid_t componentId,
-  vec3 dest
-) {
-  entityphysics_t *phys = entityPhysicsGet(entityId, componentId);
-  assertNotNull(phys, "Failed to get physics component data");
-
-  glm_vec3_copy(phys->velocity, dest);
-}
-
-void entityPhysicsSetVelocity(
-  const entityid_t entityId,
-  const componentid_t componentId,
-  vec3 velocity
-) {
-  entityphysics_t *phys = entityPhysicsGet(entityId, componentId);
-  assertNotNull(phys, "Failed to get physics component data");
-  glm_vec3_copy(velocity, phys->velocity);
-}
-
-void entityPhysicsApplyImpulse(
-  const entityid_t entityId,
-  const componentid_t componentId,
-  vec3 impulse
-) {
-  entityphysics_t *phys = entityPhysicsGet(entityId, componentId);
-  assertNotNull(phys, "Failed to get physics component data");
-
-  if(phys->type == PHYSICS_BODY_STATIC) return;
-  glm_vec3_add(phys->velocity, impulse, phys->velocity);
-}
-
-bool_t entityPhysicsIsOnGround(
-  const entityid_t entityId,
-  const componentid_t componentId
-) {
-  entityphysics_t *phys = entityPhysicsGet(entityId, componentId);
-  assertNotNull(phys, "Failed to get physics component data");
-  return phys->onGround;
-}
-
-void entityPhysicsSetBodyType(
-  const entityid_t entityId,
-  const componentid_t componentId,
-  const physicsbodytype_t type
-) {
-  entityphysics_t *phys = entityPhysicsGet(entityId, componentId);
-  assertNotNull(phys, "Failed to get physics component data");
-  phys->type = type;
-}
-
-physicsbodytype_t entityPhysicsGetBodyType(
-  const entityid_t entityId,
-  const componentid_t componentId
-) {
-  entityphysics_t *phys = entityPhysicsGet(entityId, componentId);
-  assertNotNull(phys, "Failed to get physics component data");
-  return phys->type;
-}
-
-void entityPhysicsDispose(
-  const entityid_t entityId,
-  const componentid_t componentId
-) {
-}
@@ -1,157 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- *
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "entity/entitybase.h"
-#include "physics/physicsshape.h"
-#include "physics/physicsbodytype.h"
-
-typedef struct {
-  physicsbodytype_t type;
-  physicsshape_t shape;
-  vec3 velocity;
-  float_t gravityScale;
-  bool_t onGround;
-} entityphysics_t;
-
-/**
- * Initializes the physics component: allocates a body in PHYSICS_WORLD.
- * Asserts if the world body limit is reached.
- */
-void entityPhysicsInit(
-  const entityid_t entityId,
-  const componentid_t componentId
-);
-
-/**
- * Gets the underlying physics structure (temporarily) for the given entity.
- * This is really just intended for doing operations faster than using the
- * getters and setters, but it is preferred that you use those.
- * 
- * @param entityId The entity ID.
- * @param componentId The component ID.
- * @return The physics component data for the given entity and component ID.
- */
-entityphysics_t *entityPhysicsGet(
-  const entityid_t entityId,
-  const componentid_t componentId
-);
-
-/**
- * Sets the shape of the entity's physics body. This will not reset the body
- * state, so if you change from a cube to a sphere, it will keep the same
- * velocity and onGround state.
- *
- * @param entityId The entity ID.
- * @param componentId The component ID.
- * @param shape The new shape to set on the physics body.
- */
-void entityPhysicsSetShape(
-  const entityid_t entityId,
-  const componentid_t componentId,
-  const physicsshape_t shape
-);
-
-/**
- * Gets the shape of the entity's physics body.
- *
- * @param entityId The entity ID.
- * @param componentId The component ID.
- * @return The shape of the physics body.
- */
-physicsshape_t entityPhysicsGetShape(
-  const entityid_t entityId,
-  const componentid_t componentId
-);
-
-/**
- * Gets the velocity of the entity's physics body.
- *
- * @param entityId The entity ID.
- * @param componentId The component ID.
- * @param dest The destination vec3 to write the velocity to.
- */
-void entityPhysicsGetVelocity(
-  const entityid_t entityId,
-  const componentid_t componentId,
-  vec3 dest
-);
-
-/**
- * Sets the velocity of the entity's physics body. This is not an impulse, so
- * it will be affected by mass and drag.
- *
- * @param entityId The entity ID.
- * @param componentId The component ID.
- * @param velocity The new velocity to set on the physics body.
- */
-void entityPhysicsSetVelocity(
-  const entityid_t entityId,
-  const componentid_t componentId,
-  vec3 velocity
-);
-
-/**
- * Applies an impulse to the entity's physics body. This is an immediate
- * velocity change that is not affected by mass or drag. No-op on STATIC bodies.
- *
- * @param entityId The entity ID.
- * @param componentId The component ID.
- * @param impulse The impulse to apply to the physics body.
- */
-void entityPhysicsApplyImpulse(
-  const entityid_t entityId,
-  const componentid_t componentId,
-  vec3 impulse
-);
-
-/**
- * Returns true if the entity's physics body rested on a surface during the last
- * step or move.
- *
- * @param entityId The entity ID.
- * @param componentId The component ID.
- * @return True if the body is on the ground, false otherwise.
- */
-bool_t entityPhysicsIsOnGround(
-  const entityid_t entityId,
-  const componentid_t componentId
-);
-
-/**
- * Sets the body type of the entity's physics body.
- *
- * @param entityId The entity ID.
- * @param componentId The component ID.
- * @param type The body type to set.
- */
-void entityPhysicsSetBodyType(
-  const entityid_t entityId,
-  const componentid_t componentId,
-  const physicsbodytype_t type
-);
-
-/**
- * Gets the body type of the entity's physics body.
- *
- * @param entityId The entity ID.
- * @param componentId The component ID.
- * @return The body type of the physics body.
- */
-physicsbodytype_t entityPhysicsGetBodyType(
-  const entityid_t entityId,
-  const componentid_t componentId
-);
-
-/**
- * Releases the body slot back to PHYSICS_WORLD. Called automatically when
- * the component is disposed via the component system.
- */
-void entityPhysicsDispose(
-  const entityid_t entityId,
-  const componentid_t componentId
-);
@@ -1,54 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- *
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "entity/entitymanager.h"
-
-void entityTriggerInit(
-  const entityid_t entityId,
-  const componentid_t componentId
-) {
-  entitytrigger_t *t = componentGetData(
-    entityId, componentId, COMPONENT_TYPE_TRIGGER
-  );
-  glm_vec3_zero(t->min);
-  glm_vec3_zero(t->max);
-}
-
-entitytrigger_t * entityTriggerGet(
-  const entityid_t entityId,
-  const componentid_t componentId
-) {
-  return componentGetData(entityId, componentId, COMPONENT_TYPE_TRIGGER);
-}
-
-bool_t entityTriggerContains(
-  const entityid_t entityId,
-  const componentid_t componentId,
-  const vec3 point
-) {
-  entitytrigger_t *t = componentGetData(
-    entityId, componentId, COMPONENT_TYPE_TRIGGER
-  );
-  return (
-    point[0] >= t->min[0] && point[0] <= t->max[0] &&
-    point[1] >= t->min[1] && point[1] <= t->max[1] &&
-    point[2] >= t->min[2] && point[2] <= t->max[2]
-  );
-}
-
-void entityTriggerSetBounds(
-  const entityid_t entityId,
-  const componentid_t componentId,
-  const vec3 min,
-  const vec3 max
-) {
-  entitytrigger_t *t = componentGetData(
-    entityId, componentId, COMPONENT_TYPE_TRIGGER
-  );
-  glm_vec3_copy((float_t*)min, t->min);
-  glm_vec3_copy((float_t*)max, t->max);
-}
@@ -1,49 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- *
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "entity/entitybase.h"
-
-typedef struct {
-  vec3 min;
-  vec3 max;
-} entitytrigger_t;
-
-/**
- * Initializes the trigger component with zeroed bounds.
- */
-void entityTriggerInit(
-  const entityid_t entityId,
-  const componentid_t componentId
-);
-
-/**
- * Returns a pointer to the trigger component data.
- */
-entitytrigger_t * entityTriggerGet(
-  const entityid_t entityId,
-  const componentid_t componentId
-);
-
-/**
- * Returns true if the given world-space point lies within [min, max].
- */
-bool_t entityTriggerContains(
-  const entityid_t entityId,
-  const componentid_t componentId,
-  const vec3 point
-);
-
-/**
- * Sets both bounds at once.
- */
-void entityTriggerSetBounds(
-  const entityid_t entityId,
-  const componentid_t componentId,
-  const vec3 min,
-  const vec3 max
-);
@@ -1,25 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- *
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "entity/component/display/entityposition.h"
-#include "entity/component/display/entitycamera.h"
-#include "entity/component/display/entityrenderable.h"
-#include "entity/component/physics/entityphysics.h"
-#include "entity/component/trigger/entitytrigger.h"
-
-// Name (Uppercase)
-// Structure
-// Field name (lowercase)
-// Init function (optional)
-// Dispose function (optional)
-// Render function (optional)
-
-X(POSITION, entityposition_t, position, entityPositionInit, NULL, NULL)
-X(CAMERA, entitycamera_t, camera, entityCameraInit, NULL, NULL)
-X(RENDERABLE, entityrenderable_t, renderable, entityRenderableInit, entityRenderableDispose, NULL)
-X(PHYSICS, entityphysics_t, physics, entityPhysicsInit, entityPhysicsDispose, NULL)
-X(TRIGGER, entitytrigger_t, trigger, entityTriggerInit, NULL, NULL)
@@ -1,171 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "entitymanager.h"
-#include "component/display/entityposition.h"
-#include "util/memory.h"
-#include "assert/assert.h"
-
-void entityInit(const entityid_t entityId) {
-  entity_t *ent = &ENTITY_MANAGER.entities[entityId];
-  
-  memoryZero(ent, sizeof(entity_t));
-
-  // Mark all component types not using this entity.
-  for(
-    componenttype_t compType = 0;
-    compType < COMPONENT_TYPE_COUNT;
-    compType++
-  ) {
-    ENTITY_MANAGER.entitiesWithComponent[
-      compType * ENTITY_COUNT_MAX + entityId
-    ] = COMPONENT_ID_INVALID;
-  }
-
-  ent->state |= ENTITY_STATE_ACTIVE;
-}
-
-componentid_t entityAddComponent(
-  const entityid_t entityId,
-  const componenttype_t type
-) {
-  componentindex_t compInd;
-  entity_t *ent = &ENTITY_MANAGER.entities[entityId];
-
-  for(componentid_t i = 0; i < ENTITY_COMPONENT_COUNT_MAX; i++) {
-    compInd = componentGetIndex(entityId, i);
-    if(ENTITY_MANAGER.components[compInd].type != COMPONENT_TYPE_NULL) {
-      assertTrue(
-        ENTITY_MANAGER.components[compInd].type != type,
-        "Entity already has component of this type"
-      );
-      continue;
-    }
-    componentInit(entityId, i, type);
-    ENTITY_MANAGER.entitiesWithComponent[
-      type * ENTITY_COUNT_MAX + entityId
-    ] = i;
-    return i;
-  }
-
-  assertUnreachable("Entity has no more component slots available");
-  return COMPONENT_ID_INVALID;
-}
-
-componentid_t entityGetComponent(
-  const entityid_t entityId,
-  const componenttype_t type
-) {
-  componentid_t compId = ENTITY_MANAGER.entitiesWithComponent[
-    type * ENTITY_COUNT_MAX + entityId
-  ];
-  if(compId == COMPONENT_ID_INVALID) return compId;
-  assertTrue(
-    ENTITY_MANAGER.components[componentGetIndex(entityId, compId)].type == type,
-    "Component type mismatch"
-  );
-  return compId;
-}
-
-void entityDisposeDeep(const entityid_t entityId) {
-  componentid_t posComp = entityGetComponent(entityId, COMPONENT_TYPE_POSITION);
-  if(posComp != COMPONENT_ID_INVALID) {
-    entityPositionDisposeDeep(entityId, posComp);
-  } else {
-    entityDispose(entityId);
-  }
-}
-
-void entityUpdate(const entityid_t entityId) {
-  entity_t *ent = &ENTITY_MANAGER.entities[entityId];
-  for(uint8_t i = 0; i < ent->updateCount; i++) {
-    ent->onUpdate[i](entityId, ent->updateComponentId[i], ent->updateUser[i]);
-  }
-}
-
-void entityDispose(const entityid_t entityId) {
-  componentindex_t compInd;
-  entity_t *ent = &ENTITY_MANAGER.entities[entityId];
-
-  for(uint8_t i = 0; i < ent->disposeCount; i++) {
-    ent->onDispose[i](entityId, ent->disposeComponentId[i], ent->disposeUser[i]);
-  }
-
-  for(componentid_t i = 0; i < ENTITY_COMPONENT_COUNT_MAX; i++) {
-    compInd = componentGetIndex(entityId, i);
-    componenttype_t type = ENTITY_MANAGER.components[compInd].type;
-    if(type == COMPONENT_TYPE_NULL) continue;
-    ENTITY_MANAGER.entitiesWithComponent[
-      type * ENTITY_COUNT_MAX + entityId
-    ] = COMPONENT_ID_INVALID;
-    componentDispose(entityId, i);
-  }
-
-  ent->state = 0;
-}
-
-void entityUpdateAdd(
-  const entityid_t entityId,
-  const entitycallback_t callback,
-  const componentid_t componentId,
-  void *user
-) {
-  entity_t *ent = &ENTITY_MANAGER.entities[entityId];
-  assertTrue(
-    ent->updateCount < ENTITY_UPDATE_CALLBACK_COUNT_MAX,
-    "Entity update callback slots full"
-  );
-  ent->onUpdate[ent->updateCount] = callback;
-  ent->updateComponentId[ent->updateCount] = componentId;
-  ent->updateUser[ent->updateCount] = user;
-  ent->updateCount++;
-}
-
-void entityUpdateRemove(const entityid_t entityId, const entitycallback_t callback) {
-  entity_t *ent = &ENTITY_MANAGER.entities[entityId];
-  for(uint8_t i = 0; i < ent->updateCount; i++) {
-    if(ent->onUpdate[i] != callback) continue;
-    ent->updateCount--;
-    for(uint8_t j = i; j < ent->updateCount; j++) {
-      ent->onUpdate[j]        = ent->onUpdate[j + 1];
-      ent->updateComponentId[j] = ent->updateComponentId[j + 1];
-      ent->updateUser[j]      = ent->updateUser[j + 1];
-    }
-    return;
-  }
-}
-
-void entityDisposeAdd(
-  const entityid_t entityId,
-  const entitycallback_t callback,
-  const componentid_t componentId,
-  void *user
-) {
-  entity_t *ent = &ENTITY_MANAGER.entities[entityId];
-  assertTrue(
-    ent->disposeCount < ENTITY_DISPOSE_CALLBACK_COUNT_MAX,
-    "Entity dispose callback slots full"
-  );
-  ent->onDispose[ent->disposeCount] = callback;
-  ent->disposeComponentId[ent->disposeCount] = componentId;
-  ent->disposeUser[ent->disposeCount] = user;
-  ent->disposeCount++;
-}
-
-void entityDisposeRemove(const entityid_t entityId, const entitycallback_t callback) {
-  entity_t *ent = &ENTITY_MANAGER.entities[entityId];
-  for(uint8_t i = 0; i < ent->disposeCount; i++) {
-    if(ent->onDispose[i] != callback) continue;
-    ent->disposeCount--;
-    for(uint8_t j = i; j < ent->disposeCount; j++) {
-      ent->onDispose[j]         = ent->onDispose[j + 1];
-      ent->disposeComponentId[j] = ent->disposeComponentId[j + 1];
-      ent->disposeUser[j]       = ent->disposeUser[j + 1];
-    }
-    return;
-  }
-}
@@ -1,131 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "component.h"
-
-#define ENTITY_STATE_ACTIVE (1 << 0)
-
-#define ENTITY_UPDATE_CALLBACK_COUNT_MAX  5
-#define ENTITY_DISPOSE_CALLBACK_COUNT_MAX 5
-
-typedef void (*entitycallback_t)(
-  const entityid_t entityId,
-  const componentid_t componentId,
-  void *user
-);
-
-typedef struct {
-  uint8_t state;
-  uint8_t updateCount;
-  uint8_t disposeCount;
-  entitycallback_t onUpdate[ENTITY_UPDATE_CALLBACK_COUNT_MAX];
-  componentid_t updateComponentId[ENTITY_UPDATE_CALLBACK_COUNT_MAX];
-  void *updateUser[ENTITY_UPDATE_CALLBACK_COUNT_MAX];
-  entitycallback_t onDispose[ENTITY_DISPOSE_CALLBACK_COUNT_MAX];
-  componentid_t disposeComponentId[ENTITY_DISPOSE_CALLBACK_COUNT_MAX];
-  void *disposeUser[ENTITY_DISPOSE_CALLBACK_COUNT_MAX];
-} entity_t;
-
-/**
- * Initializes an entity with the given ID.
- * 
- * @param entityId The ID of the entity to initialize.
- */
-void entityInit(const entityid_t entityId);
-
-/**
- * Adds a component of the given type  to the entity with the given ID.
- * 
- * @param entityId The ID of the entity to add the component to.
- * @param type The type of the component to add.
- * @return The ID of the entity with component.
- */
-componentid_t entityAddComponent(
-  const entityid_t entityId,
-  const componenttype_t type
-);
-
-/**
- * Gets the ID of the component of the given type on the entity with the given
- * ID, or COMPONENT_ID_INVALID if the entity lacks the component.
- * 
- * @param entityId The ID of the entity to get the component from.
- * @param type The type of the component to get.
- * @return The ID of the component.
- */
-componentid_t entityGetComponent(
-  const entityid_t entityId,
-  const componenttype_t type
-);
-
-/**
- * Runs all registered update callbacks for the entity.
- *
- * @param entityId The ID of the entity to update.
- */
-void entityUpdate(const entityid_t entityId);
-
-/**
- * Disposes of an entity with the given ID. Fires all dispose callbacks before
- * cleaning up components and state.
- *
- * @param entityId The ID of the entity to dispose of.
- */
-void entityDispose(const entityid_t entityId);
-
-/**
- * Disposes of an entity and all of its position-component descendants
- * recursively. If the entity has no position component, behaves like
- * entityDispose.
- *
- * @param entityId The root entity ID.
- */
-void entityDisposeDeep(const entityid_t entityId);
-
-/**
- * Registers an update callback, invoked each time entityUpdate is called.
- *
- * @param entityId The entity to register on.
- * @param callback The function to call.
- */
-void entityUpdateAdd(
-  const entityid_t entityId,
-  const entitycallback_t callback,
-  const componentid_t componentId,
-  void *user
-);
-
-/**
- * Removes a previously registered update callback.
- *
- * @param entityId The entity to remove from.
- * @param callback The function to remove.
- */
-void entityUpdateRemove(const entityid_t entityId, const entitycallback_t callback);
-
-/**
- * Registers a dispose callback, invoked at the start of entityDispose before
- * any component or state cleanup.
- *
- * @param entityId The entity to register on.
- * @param callback The function to call.
- */
-void entityDisposeAdd(
-  const entityid_t entityId,
-  const entitycallback_t callback,
-  const componentid_t componentId,
-  void *user
-);
-
-/**
- * Removes a previously registered dispose callback.
- *
- * @param entityId The entity to remove from.
- * @param callback The function to remove.
- */
-void entityDisposeRemove(const entityid_t entityId, const entitycallback_t callback);
@@ -1,19 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "dusk.h"
-
-#define ENTITY_COUNT_MAX 64
-#define ENTITY_COMPONENT_COUNT_MAX 16
-
-#define ENTITY_ID_INVALID 0xFF
-#define COMPONENT_ID_INVALID 0xFF
-
-typedef uint8_t entityid_t;
-typedef uint8_t componentid_t;
-typedef uint16_t componentindex_t;
@@ -1,54 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "entitymanager.h"
-#include "assert/assert.h"
-#include "util/memory.h"
-#include "console/console.h"
-
-entitymanager_t ENTITY_MANAGER;
-
-void entityManagerInit(void) {
-  memoryZero(&ENTITY_MANAGER, sizeof(entitymanager_t));
-  memorySet(
-    ENTITY_MANAGER.entitiesWithComponent, COMPONENT_ID_INVALID,
-    sizeof(componentid_t) * COMPONENT_TYPE_COUNT * ENTITY_COUNT_MAX
-  );
-
-  consolePrint(
-    "Entity Manager size: %zu bytes (%.2f KB)",
-    sizeof(entitymanager_t),
-    sizeof(entitymanager_t) / 1024.0f
-  );
-}
-
-entityid_t entityManagerAdd() {
-  for(entityid_t i = 0; i < ENTITY_COUNT_MAX; i++) {
-    if((ENTITY_MANAGER.entities[i].state & ENTITY_STATE_ACTIVE) != 0) continue;
-    entityInit(i);
-    return i;
-  }
-  assertUnreachable("No more entity IDs available");
-  return ENTITY_ID_INVALID;
-}
-
-void entityManagerUpdate(void) {
-  entityid_t i = 0;
-  while(i < ENTITY_COUNT_MAX) {
-    if((ENTITY_MANAGER.entities[i].state & ENTITY_STATE_ACTIVE) != 0) {
-      entityUpdate(i);
-    }
-    i++;
-  }
-}
-
-void entityManagerDispose(void) {
-  for(entityid_t i = 0; i < ENTITY_COUNT_MAX; i++) {
-    if((ENTITY_MANAGER.entities[i].state & ENTITY_STATE_ACTIVE) == 0) continue;
-    entityDispose(i);
-  }
-}
@@ -1,39 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "entity.h"
-
-typedef struct {
-  entity_t entities[ENTITY_COUNT_MAX];
-  component_t components[ENTITY_COUNT_MAX * ENTITY_COMPONENT_COUNT_MAX];
-  componentid_t entitiesWithComponent[COMPONENT_TYPE_COUNT * ENTITY_COUNT_MAX];
-} entitymanager_t;
-
-extern entitymanager_t ENTITY_MANAGER;
-
-/**
- * Initializes the entity manager.
- */
-void entityManagerInit(void);
-
-/**
- * Adds / Reserves a new entity ID.
- * 
- * @return The new entity ID.
- */
-entityid_t entityManagerAdd();
-
-/**
- * Updates all active entities.
- */
-void entityManagerUpdate(void);
-
-/**
- * Disposes of the entity manager, in turn freeing all entities and components.
- */
-void entityManagerDispose(void);
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2025 Dominic Masters
+ * Copyright (c) 2026 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2025 Dominic Masters
+ * Copyright (c) 2026 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
@@ -9,7 +9,12 @@
 #include "assert/assert.h"
 #include "util/memory.h"

-void eventInit(event_t *event, eventcallback_t *callbacks, void **users, size_t size) {
+void eventInit(
+  event_t *event,
+  eventcallback_t *callbacks,
+  void **users,
+  size_t size
+) {
  assertNotNull(event, "event must not be NULL");
  assertNotNull((void *)callbacks, "callbacks must not be NULL");
  assertTrue(size > 0, "size must be greater than 0");
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2025 Dominic Masters
+ * Copyright (c) 2026 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2025 Dominic Masters
+ * Copyright (c) 2026 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2025 Dominic Masters
+ * Copyright (c) 2026 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2025 Dominic Masters
+ * Copyright (c) 2026 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2025 Dominic Masters
+ * Copyright (c) 2026 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2025 Dominic Masters
+ * Copyright (c) 2026 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2025 Dominic Masters
+ * Copyright (c) 2026 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2025 Dominic Masters
+ * Copyright (c) 2026 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2025 Dominic Masters
+ * Copyright (c) 2026 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2025 Dominic Masters
+ * Copyright (c) 2026 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
@@ -1,17 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- *
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "facingdir.h"
-
-void facingDirToVec2(facingdir_t facing, vec2 dest) {
-  switch(facing) {
-    case FACING_DIR_UP:    dest[0] =  0.0f; dest[1] = -1.0f; return;
-    case FACING_DIR_LEFT:  dest[0] = -1.0f; dest[1] =  0.0f; return;
-    case FACING_DIR_RIGHT: dest[0] =  1.0f; dest[1] =  0.0f; return;
-    default:               dest[0] =  0.0f; dest[1] =  1.0f; return;
-  }
-}
@@ -1,28 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- *
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "dusk.h"
-
-typedef enum {
-  FACING_DIR_DOWN  = 0,
-  FACING_DIR_UP    = 1,
-  FACING_DIR_LEFT  = 2,
-  FACING_DIR_RIGHT = 3,
-  FACING_DIR_SOUTH = FACING_DIR_DOWN,
-  FACING_DIR_NORTH = FACING_DIR_UP,
-  FACING_DIR_WEST  = FACING_DIR_LEFT,
-  FACING_DIR_EAST  = FACING_DIR_RIGHT,
-} facingdir_t;
-
-/**
- * Converts a facing direction to a normalized XZ vec2.
- *
- * @param facing The facing direction.
- * @param dest   Output vec2 — [0] is X, [1] is Z.
- */
-void facingDirToVec2(facingdir_t facing, vec2 dest);
@@ -1,151 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- *
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "map.h"
-#include "assert/assert.h"
-#include "asset/assetfile.h"
-#include "util/memory.h"
-#include "util/string.h"
-#include "console/console.h"
-
-map_t MAP;
-
-chunkindex_t mapChunkRelToIndex(
-  chunkunit_t rx,
-  chunkunit_t ry,
-  chunkunit_t rz
-) {
-  return (chunkindex_t)(
-    rz * (MAP_CHUNKS_WIDE * MAP_CHUNKS_HIGH) +
-    ry *  MAP_CHUNKS_WIDE +
-    rx
-  );
-}
-
-void mapInit(void) {
-  memoryZero(&MAP, sizeof(map_t));
-}
-
-errorret_t mapLoad(const char_t *handle) {
-  assertStrLenMin(handle, 1, "Map handle cannot be empty");
-  assertStrLenMax(handle, MAP_HANDLE_MAX - 1, "Map handle too long");
-
-  if(mapIsLoaded()) mapDispose();
-
-  memoryZero(&MAP, sizeof(map_t));
-  stringCopy(MAP.handle, handle, MAP_HANDLE_MAX);
-
-  char_t path[ASSET_FILE_NAME_MAX];
-  stringFormat(path, sizeof(path), "maps/%s/init.js", handle);
-
-  consolePrint("Map loaded: %s", handle);
-  errorOk();
-}
-
-bool_t mapIsLoaded(void) {
-  return MAP.loaded;
-}
-
-errorret_t mapPositionSet(tilepos_t tilePos) {
-  assertTrue(MAP.chunkTileWidth  > 0, "chunkTileWidth not set");
-  assertTrue(MAP.chunkTileHeight > 0, "chunkTileHeight not set");
-  assertTrue(MAP.chunkTileDepth  > 0, "chunkTileDepth not set");
-
-  // Convert tile position to chunk-space window origin.
-  chunkpos_t newPos = {
-    .x = (chunkunit_t)(tilePos.x / MAP.chunkTileWidth),
-    .y = (chunkunit_t)(tilePos.y / MAP.chunkTileHeight),
-    .z = (chunkunit_t)(tilePos.z / MAP.chunkTileDepth),
-  };
-
-  if(MAP.loaded && chunkPosEqual(MAP.chunkPosition, newPos)) errorOk();
-
-  // Categorise existing chunks as remaining or freed.
-  chunkindex_t remaining[MAP_CHUNKS_COUNT];
-  chunkindex_t freed[MAP_CHUNKS_COUNT];
-  chunkindex_t remainingCount = 0;
-  chunkindex_t freedCount = 0;
-
-  for(chunkindex_t i = 0; i < MAP_CHUNKS_COUNT; i++) {
-    mapchunk_t *chunk = &MAP.chunks[i];
-    chunkpos_t p = chunk->position;
-
-    bool_t stays = MAP.loaded &&
-      p.x >= newPos.x && p.x < newPos.x + MAP_CHUNKS_WIDE &&
-      p.y >= newPos.y && p.y < newPos.y + MAP_CHUNKS_HIGH &&
-      p.z >= newPos.z && p.z < newPos.z + MAP_CHUNKS_DEEP;
-
-    if(stays) {
-      remaining[remainingCount++] = i;
-    } else {
-      if(MAP.loaded) mapChunkUnload(chunk);
-      freed[freedCount++] = i;
-    }
-  }
-
-  // Build chunkOrder for the new window, loading into freed slots as needed.
-  chunkindex_t orderIndex = 0;
-  for(chunkunit_t zOff = 0; zOff < MAP_CHUNKS_DEEP;  zOff++) {
-  for(chunkunit_t yOff = 0; yOff < MAP_CHUNKS_HIGH;  yOff++) {
-  for(chunkunit_t xOff = 0; xOff < MAP_CHUNKS_WIDE;  xOff++) {
-    chunkpos_t target = {
-      .x = (chunkunit_t)(newPos.x + xOff),
-      .y = (chunkunit_t)(newPos.y + yOff),
-      .z = (chunkunit_t)(newPos.z + zOff),
-    };
-
-    // Check if the target chunk is already loaded.
-    chunkindex_t poolIdx = -1;
-    for(chunkindex_t r = 0; r < remainingCount; r++) {
-      if(chunkPosEqual(MAP.chunks[remaining[r]].position, target)) {
-        poolIdx = remaining[r];
-        break;
-      }
-    }
-
-    // Otherwise recycle a freed slot.
-    if(poolIdx == -1) {
-      poolIdx = freed[--freedCount];
-      MAP.chunks[poolIdx].position = target;
-      errorChain(mapChunkLoad(&MAP.chunks[poolIdx]));
-    }
-
-    MAP.chunkOrder[orderIndex++] = &MAP.chunks[poolIdx];
-  }}}
-
-  MAP.chunkPosition = newPos;
-  MAP.loaded = true;
-  errorOk();
-}
-
-mapchunk_t *mapGetChunkAt(chunkpos_t pos) {
-  if(!MAP.loaded) return NULL;
-  chunkpos_t p = MAP.chunkPosition;
-  if(
-    pos.x < p.x || pos.x >= p.x + MAP_CHUNKS_WIDE ||
-    pos.y < p.y || pos.y >= p.y + MAP_CHUNKS_HIGH ||
-    pos.z < p.z || pos.z >= p.z + MAP_CHUNKS_DEEP
-  ) return NULL;
-  chunkindex_t idx = mapChunkRelToIndex(
-    pos.x - p.x, pos.y - p.y, pos.z - p.z
-  );
-  return MAP.chunkOrder[idx];
-}
-
-errorret_t mapUpdate(void) {
-  if(!MAP.loaded) errorOk();
-  errorOk();
-}
-
-void mapDispose(void) {
-  consolePrint("Map disposing: %s", MAP.handle);
-  if(!MAP.loaded) return;
-  for(chunkindex_t i = 0; i < MAP_CHUNKS_COUNT; i++) {
-    mapChunkUnload(&MAP.chunks[i]);
-  }
-  MAP.loaded = false;
-}
@@ -1,97 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- *
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "mapchunk.h"
-#include "error/error.h"
-
-#define MAP_NAME_MAX     64
-#define MAP_HANDLE_MAX   32
-#define MAP_CHUNKS_WIDE  3
-#define MAP_CHUNKS_HIGH  3
-#define MAP_CHUNKS_DEEP  2
-#define MAP_CHUNKS_COUNT (MAP_CHUNKS_WIDE * MAP_CHUNKS_HIGH * MAP_CHUNKS_DEEP)
-
-typedef struct {
-  char_t name[MAP_NAME_MAX];
-  char_t handle[MAP_HANDLE_MAX];
-  uint16_t chunkTileWidth;
-  uint16_t chunkTileHeight;
-  uint16_t chunkTileDepth;
-  mapchunk_t  chunks[MAP_CHUNKS_COUNT];
-  mapchunk_t *chunkOrder[MAP_CHUNKS_COUNT];
-  chunkpos_t chunkPosition;
-  bool_t loaded;
-} map_t;
-
-extern map_t MAP;
-
-/**
- * Initializes the map, zeroing all state.
- */
-void mapInit(void);
-
-/**
- * Prepares the map for use with the given handle. If a map is already loaded
- * it is disposed first. Chunk positions are not set until mapPositionSet is
- * called.
- *
- * @param handle Short identifier for this map (max MAP_HANDLE_MAX - 1 chars).
- * @return An error code.
- */
-errorret_t mapLoad(const char_t *handle);
-
-/**
- * Returns true if a map is currently loaded.
- *
- * @return true if a map is loaded, false otherwise.
- */
-bool_t mapIsLoaded(void);
-
-/**
- * Converts a chunk position relative to the window origin to its pool index.
- *
- * @param rx Relative chunk X offset within the window.
- * @param ry Relative chunk Y offset within the window.
- * @param rz Relative chunk Z offset within the window.
- * @return The flat pool index for that relative position.
- */
-chunkindex_t mapChunkRelToIndex(
-  chunkunit_t rx,
-  chunkunit_t ry,
-  chunkunit_t rz
-);
-
-/**
- * Slides the loaded chunk window so its origin is the chunk that contains
- * the given tile-space position. Only the delta is loaded/unloaded.
- *
- * @param tilePos Tile-space position of the new window origin.
- * @return An error code.
- */
-errorret_t mapPositionSet(tilepos_t tilePos);
-
-/**
- * Updates the map each frame.
- *
- * @return An error code.
- */
-errorret_t mapUpdate(void);
-
-/**
- * Disposes the map, unloading all chunks.
- */
-void mapDispose(void);
-
-/**
- * Returns the chunk at the given absolute chunk-space position, or NULL if
- * it is outside the currently loaded window.
- *
- * @param pos Absolute chunk-space position to look up.
- * @return Pointer to the chunk, or NULL if not loaded.
- */
-mapchunk_t *mapGetChunkAt(chunkpos_t pos);
@@ -1,56 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- *
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "mapchunk.h"
-#include "map.h"
-#include "entity/entitymanager.h"
-#include "util/memory.h"
-#include "util/string.h"
-#include "asset/asset.h"
-#include "console/console.h"
-
-errorret_t mapChunkLoad(mapchunk_t *chunk) {
-  chunk->entityCount = 0;
-  memoryZero(chunk->entities, sizeof(chunk->entities));
-
-  if(MAP.handle[0] == '\0') errorOk();
-
-  char_t path[ASSET_FILE_NAME_MAX];
-  stringFormat(
-    path, sizeof(path),
-    "maps/%s/chunks/%d_%d_%d.js",
-    MAP.handle,
-    (int)chunk->position.x,
-    (int)chunk->position.y,
-    (int)chunk->position.z
-  );
-
-  if(!assetFileExists(path)) errorOk();
-
-  consolePrint(
-    "Chunk loaded: %s [%d,%d,%d]",
-    path,
-    (int)chunk->position.x,
-    (int)chunk->position.y,
-    (int)chunk->position.z
-  );
-  errorOk();
-}
-
-void mapChunkUnload(mapchunk_t *chunk) {
-  consolePrint(
-    "Chunk unloading: [%d,%d,%d]",
-    (int)chunk->position.x,
-    (int)chunk->position.y,
-    (int)chunk->position.z
-  );
-
-  for(uint8_t i = 0; i < chunk->entityCount; i++) {
-    entityDispose(chunk->entities[i]);
-  }
-  chunk->entityCount = 0;
-}
@@ -1,34 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- *
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "maptypes.h"
-#include "entity/entitybase.h"
-#include "error/error.h"
-
-#define MAP_CHUNK_ENTITY_COUNT_MAX 64
-
-typedef struct {
-  chunkpos_t position;
-  entityid_t entities[MAP_CHUNK_ENTITY_COUNT_MAX];
-  uint8_t entityCount;
-} mapchunk_t;
-
-/**
- * Loads content into a chunk at its current position.
- *
- * @param chunk The chunk to load.
- * @return An error code.
- */
-errorret_t mapChunkLoad(mapchunk_t *chunk);
-
-/**
- * Disposes all entities owned by the chunk and resets its state.
- *
- * @param chunk The chunk to unload.
- */
-void mapChunkUnload(mapchunk_t *chunk);
@@ -1,12 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- *
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "maptypes.h"
-
-bool_t chunkPosEqual(chunkpos_t a, chunkpos_t b) {
-  return a.x == b.x && a.y == b.y && a.z == b.z;
-}
@@ -1,30 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- *
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "dusk.h"
-
-typedef int16_t chunkunit_t;
-typedef int16_t chunkindex_t;
-typedef int32_t tileunit_t;
-
-typedef struct {
-  chunkunit_t x, y, z;
-} chunkpos_t;
-
-typedef struct {
-  tileunit_t  x, y, z;
-} tilepos_t;
-
-/**
- * Checks if two chunk positions are equal.
- * 
- * @param a The first chunk position.
- * @param b The second chunk position.
- * @return true if the positions are equal, false otherwise.
- */
-bool_t chunkPosEqual(chunkpos_t a, chunkpos_t b);
@@ -1,12 +0,0 @@
-# Copyright (c) 2026 Dominic Masters
-# 
-# This software is released under the MIT License.
-# https://opensource.org/licenses/MIT
-
-# Sources
-target_sources(${DUSK_LIBRARY_TARGET_NAME}
-  PUBLIC
-    physicsmanager.c
-    physicsworld.c
-    physicstest.c
-)
@@ -1,27 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- *
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "dusk.h"
-
-typedef enum {
-  /**
-   * Never moves. Acts as an immovable collision surface.
-   */
-  PHYSICS_BODY_STATIC,
-
-  /**
-   * Simulated by the world step: gravity, forces, and collision response.
-   */
-  PHYSICS_BODY_DYNAMIC,
-  
-  /**
-   * Moved programmatically via physicsWorldMoveBody; collides but is not
-   * driven by the simulation. Typical use: player character controller.
-   */
-  PHYSICS_BODY_KINEMATIC
-} physicsbodytype_t;
@@ -1,21 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- *
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "physicsmanager.h"
-#include "time/time.h"
-
-void physicsManagerInit(void) {
-  physicsWorldInit();
-}
-
-void physicsManagerUpdate() {
-  #if DUSK_TIME_DYNAMIC
-    if(TIME.dynamicUpdate) return; // Don't update on dynamic updates.
-  #endif
-
-  physicsWorldStep(TIME.delta);
-}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
YourWishes	6135d60ddc	Interact Build Dusk / run-tests (push) Failing after 4m13s Details Build Dusk / build-linux (push) Failing after 55s Details Build Dusk / build-psp (push) Failing after 47s Details Build Dusk / build-knulli (push) Failing after 42s Details Build Dusk / build-gamecube (push) Failing after 47s Details Build Dusk / build-gamecube-iso (push) Failing after 49s Details Build Dusk / build-wii (push) Failing after 42s Details Build Dusk / build-wii-iso (push) Failing after 39s Details	2026-06-18 13:34:36 -05:00
YourWishes	4c2a883038	Bit more cleanup of floats	2026-06-18 13:03:57 -05:00
YourWishes	c88b672f42	Fixed_t updates	2026-06-18 12:44:23 -05:00
YourWishes	a162002af2	Show player pos, fix chunks off screen	2026-06-18 10:24:45 -05:00
YourWishes	9810fd51ab	Compiles again	2026-06-18 10:17:53 -05:00
YourWishes	857c6b3d47	Fuck	2026-06-16 09:18:13 -05:00
YourWishes	e1498f538d	Optimize chunk tile mesh	2026-06-11 14:45:53 -05:00
YourWishes	aa246eff94	RPG stuff	2026-06-11 12:18:13 -05:00
YourWishes	5be21a21d5	prog	2026-06-10 19:06:19 -05:00
YourWishes	8131bcd4d4	Build on github tag	2026-06-09 15:43:31 -05:00
YourWishes	4ba11e3363	Test Build Dusk / run-tests (push) Failing after 15m50s Details	2026-06-08 18:01:19 -05:00
YourWishes	acf2be3f66	Try set Build Dusk / run-tests (push) Failing after 7s Details	2026-06-08 17:04:07 -05:00
YourWishes	f5df0195e2	Docker compose Build Dusk / run-tests (push) Failing after 7s Details	2026-06-08 17:02:58 -05:00
YourWishes	d26995b48d	pwd Build Dusk / run-tests (push) Failing after 6s Details	2026-06-08 16:59:39 -05:00
YourWishes	617f8120ae	Docker exec Build Dusk / run-tests (push) Failing after 14s Details	2026-06-08 16:48:17 -05:00
YourWishes	06c517c9aa	chmod Build Dusk / run-tests (push) Failing after 7s Details	2026-06-08 16:47:45 -05:00
YourWishes	593ed6408c	test2 Build Dusk / run-tests (push) Successful in 7s Details	2026-06-08 16:47:03 -05:00
YourWishes	fb7d3ed122	LS stuff Build Dusk / run-tests (push) Successful in 7s Details	2026-06-08 16:45:59 -05:00
YourWishes	19b88ec858	Test linux? Build Dusk / run-tests (push) Failing after 6s Details	2026-06-08 16:08:24 -05:00
YourWishes	160e65be7f	Run on ubuntu-latest Build Dusk / run-tests (push) Failing after 16s Details	2026-06-08 15:34:31 -05:00
YourWishes	079b0d2cf6	Update test script back to what it was Build Dusk / run-tests (push) Has been cancelled Details	2026-06-08 15:18:40 -05:00
YourWishes	78f1310f41	Update test script Build Dusk / run-tests (push) Failing after 7s Details	2026-06-08 15:14:53 -05:00
YourWishes	eb1974c113	Update to docker-host Build Dusk / run-tests (push) Failing after 6m15s Details	2026-06-08 14:55:31 -05:00
YourWishes	551409a023	Force run again Build Dusk / run-tests (push) Failing after 9m15s Details	2026-06-08 13:58:11 -05:00
YourWishes	a11e14daac	Try without setup docker Build Dusk / run-tests (push) Failing after 8m28s Details	2026-06-08 13:15:15 -05:00
YourWishes	7441e15e76	Run on ubuntu-latest Build Dusk / run-tests (push) Failing after 3m15s Details	2026-06-08 13:09:53 -05:00
YourWishes	46506228a6	One thing at a time Build Dusk / run-tests (push) Has been cancelled Details	2026-06-08 12:46:38 -05:00
YourWishes	17c49c74cf	Try tests updated Build Dusk / build-linux (push) Failing after 29s Details Build Dusk / build-psp (push) Failing after 1m13s Details Build Dusk / run-tests (push) Has been cancelled Details Build Dusk / build-gamecube (push) Has been cancelled Details Build Dusk / build-gamecube-iso (push) Has been cancelled Details Build Dusk / build-knulli (push) Has been cancelled Details Build Dusk / build-wii (push) Has been cancelled Details Build Dusk / build-wii-iso (push) Has been cancelled Details	2026-06-08 12:44:22 -05:00
YourWishes	3f8024d4db	Workflows Build Dusk / run-tests (push) Failing after 58s Details Build Dusk / build-linux (push) Failing after 1m11s Details Build Dusk / build-psp (push) Failing after 46s Details Build Dusk / build-knulli (push) Failing after 53s Details Build Dusk / build-gamecube (push) Failing after 47s Details Build Dusk / build-gamecube-iso (push) Failing after 49s Details Build Dusk / build-wii (push) Failing after 49s Details Build Dusk / build-wii-iso (push) Failing after 1m14s Details	2026-06-08 12:25:48 -05:00
YourWishes	8675e44d28	GitTea actions	2026-06-08 12:24:09 -05:00
YourWishes	1301d9a718	idk why I btoher with github actions	2026-06-08 12:23:18 -05:00
YourWishes	da3db50ca8	Want to test this in PSP	2026-06-08 11:32:59 -05:00
YourWishes	2ca6780305	Just trying to fix things now	2026-06-08 09:39:09 -05:00
YourWishes	be68fe5a35	Emdashless	2026-06-07 21:27:59 -05:00
YourWishes	dc41c0e302	Cleanup	2026-06-07 21:16:46 -05:00
YourWishes	51388c90d5	we ball I guess	2026-06-07 19:51:54 -05:00
YourWishes	f8c9d33df2	Fix some script bugs	2026-06-07 18:47:34 -05:00