Add some script modules

This reverts commit efd31237be.

.ci/dolphin/Dockerfile

@@ -1,5 +0,0 @@
-FROM devkitpro/devkitppc
-
-RUN apt update && \
-    apt install -y python3 python3-pip python3-polib python3-pil python3-dotenv python3-pyqt5 python3-opengl && \
-    dkp-pacman -S --needed --noconfirm gamecube-sdl2 ppc-liblzma ppc-libzip

.ci/dolphin/build-gamecube.sh

@@ -1,20 +0,0 @@
-#!/bin/bash
-docker build -t myapp:latest -f ./.ci/dolphin/Dockerfile .
-docker run -v ./:/gamecube myapp:latest /bin/bash -c ' \
-  export PATH="$DEVKITPPC/bin:$PATH" && \
-  echo "Inside Docker container:" && \
-  ls -l && \
-  echo "Current directory:" && \
-  realpath . && \
-  echo "Listing /:" && \
-  ls / && \
-  echo "Changing to /gamecube" && \
-  cd /gamecube && \
-  echo "Contents of /gamecube:" && \
-  ls -l && \
-  rm -rf build-gamecube && \
-  mkdir -p build-gamecube && \
-  cmake -S. -Bbuild-gamecube -DDUSK_TARGET_SYSTEM=gamecube -DCMAKE_TOOLCHAIN_FILE="$DEVKITPRO/cmake/GameCube.cmake" && \
-  cd build-gamecube && \
-  make VERBOSE=1
-'

.ci/dolphin/build-wii.sh

@@ -1,13 +0,0 @@
-#!/bin/bash
-docker build -t myapp:latest -f .ci/dolphin/Dockerfile .
-docker run -v ./:/workdir myapp:latest /bin/bash -c ' \
-  export PATH="$DEVKITPPC/bin:$PATH" && \
-  cd /workdir && \
-  rm -rf build-wii && \
-  mkdir -p build-wii && \
-  cmake -S. -Bbuild-wii -DDUSK_TARGET_SYSTEM=wii -DCMAKE_TOOLCHAIN_FILE="$DEVKITPRO/cmake/Wii.cmake" && \
-  cd build-wii && \
-  make VERBOSE=1 && \
-  mv ./Dusk.dol ./boot.dol
-'
-# docker run -it -v ./:/workdir myapp:latest /bin/bash

.gitea/workflows/build.yml

@@ -1,147 +0,0 @@
-name: Build Dusk
-
-on:
-  push:
-    branches:
-      - main
-  pull_request:
-    branches:
-      - main
-
-jobs:
-  build-gamecube:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v5
-      - name: Install dependencies
-        run: |
-          apt-get update
-          sudo apt remove $(dpkg --get-selections docker.io docker-compose docker-compose-v2 docker-doc podman-docker containerd runc | cut -f1)
-          # Add Docker's official GPG key:
-          sudo apt update
-          sudo apt install ca-certificates curl
-          sudo install -m 0755 -d /etc/apt/keyrings
-          sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
-          sudo chmod a+r /etc/apt/keyrings/docker.asc
-
-          # Add the repository to Apt sources:
-          sudo tee /etc/apt/sources.list.d/docker.sources <<EOF
-          Types: deb
-          URIs: https://download.docker.com/linux/ubuntu
-          Suites: $(. /etc/os-release && echo "${UBUNTU_CODENAME:-$VERSION_CODENAME}")
-          Components: stable
-          Signed-By: /etc/apt/keyrings/docker.asc
-          EOF
-
-          sudo apt update --yes
-          sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin --yes
-      - name: Build GameCube
-        run: |
-          echo "ls -l ."
-          ls -l
-          echo "Current directory:"
-          realpath .
-          echo "ls /"
-          ls /
-          echo "Run GameCube build script"
-          .ci/dolphin/build-gamecube.sh
-      - name: Copy gamecube
-        run: |
-          mkdir -p build/gitea/Gamecube/Dusk
-          mv build/Dusk.dol build/gitea/Gamecube/Dusk/Dusk.dol
-          mv build/dusk.dsk build/gitea/Gamecube/Dusk/dusk.dsk
-      - name: Upload GameCube Binary
-        uses: actions/upload-artifact@v3
-        with:
-          name: dusk-gamecube
-          path: build/gitea/Gamecube
-          if-no-files-found: error
-        
-  # build-wii:
-  #   runs-on: ubuntu-latest
-  #   steps:
-  #     - name: Checkout repository
-  #       uses: actions/checkout@v5
-  #     - name: Install dependencies
-  #       run: |
-  #         apt-get update
-  #         apt-get install -y docker.io  
-  #     - name: Build Wii
-  #       run: |
-  #         ./.ci/dolphin/build-wii.sh
-  #     - name: Copy wii
-  #       run: |
-  #         mkdir -p build/gitea/Wii/apps/Dusk
-  #         mv build/Dusk.dol build/gitea/Wii/apps/Dusk/boot.dol
-  #         mv build/dusk.dsk build/gitea/Wii/apps/Dusk/dusk.dsk
-  #     - name: Upload Wii Binary
-  #       uses: actions/upload-artifact@v3
-  #       with:
-  #         name: dusk-wii
-  #         path: build/gitea/Wii
-  #         if-no-files-found: error
-
-  run-tests:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v5
-      - name: Install dependencies
-        run: |
-          apt-get update
-          apt-get install -y build-essential cmake python3 python3-pip python3-polib python3-pil libsdl2-dev libgl1-mesa-dev libzip-dev python3-dotenv python3-pyqt5 python3-opengl liblua5.3-dev
-      - name: Configure CMake for tests
-        run: cmake -S . -B build -DDUSK_BUILD_TESTS=ON -DDUSK_TARGET_SYSTEM=linux
-      - name: Build tests
-        run: cmake --build build -- -j$(nproc)
-      - name: Run tests
-        run: ctest --output-on-failure --test-dir build
-
-  build-linux:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v5
-      - name: Install dependencies
-        run: |
-          apt-get update
-          apt-get install -y build-essential cmake python3 python3-pip python3-polib python3-pil libsdl2-dev libgl1-mesa-dev libzip-dev python3-dotenv python3-pyqt5 python3-opengl liblua5.3-dev
-      - name: Configure CMake
-        run: cmake -S . -B build -DDUSK_TARGET_SYSTEM=linux
-      - name: Build
-        run: cmake --build build -- -j$(nproc)
-      - name: List build output
-        run: ls -lh build
-      - name: Upload Linux binary
-        uses: actions/upload-artifact@v3
-        with:
-          name: dusk-linux
-          path: build/Dusk
-          if-no-files-found: error
-
-  build-psp:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v5
-      - name: Install dependencies
-        run: |
-          apt-get update
-          apt-get install -y build-essential cmake python3 python3-pip python3-polib python3-pil libsdl2-dev libgl1-mesa-dev libzip-dev python3-dotenv python3-pyqt5 python3-opengl liblua5.3-dev
-      - name: Configure CMake
-        run: cmake -S . -B build -DDUSK_TARGET_SYSTEM=psp -DENABLE_TESTS=OFF
-      - name: Build
-        run: cmake --build build -- -j$(nproc)
-      - name: Move EBOOT.PBP to Dusk subfolder
-        run: |
-          mkdir -p build/gitea/Dusk
-          mv build/EBOOT.PBP build/gitea/Dusk/EBOOT.PBP
-      - name: List build output
-        run: ls -lh build/gitea/Dusk
-      - name: Upload PSP binary
-        uses: actions/upload-artifact@v3
-        with:
-          name: dusk-psp
-          path: build/gitea/
-          if-no-files-found: error

.github/workflows/build.yml

@@ -0,0 +1,177 @@
+name: Build Dusk
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+jobs:
+  run-tests:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+      - name: Set up Docker
+        uses: docker/setup-docker-action@v5
+      - name: Run tests in Docker
+        run: ./scripts/test-linux-docker.sh
+
+  build-linux:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+      - name: Set up Docker
+        uses: docker/setup-docker-action@v5
+      - name: Build Linux
+        run: ./scripts/build-linux-docker.sh
+      - name: Upload Linux binary
+        uses: actions/upload-artifact@v6
+        with:
+          name: dusk-linux
+          path: build-linux/Dusk
+          if-no-files-found: error
+
+  build-psp:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+      - name: Set up Docker
+        uses: docker/setup-docker-action@v5
+      - name: Build psp
+        run: ./scripts/build-psp-docker.sh
+      - name: Move EBOOT.PBP to Dusk subfolder
+        run: |
+          mkdir -p ./git-artifcats/Dusk/PSP/GAME/Dusk
+          cp build-psp/EBOOT.PBP ./git-artifcats/Dusk/PSP/GAME/Dusk/EBOOT.PBP
+      - name: Upload psp binary
+        uses: actions/upload-artifact@v6
+        with:
+          name: dusk-psp
+          path: ./git-artifcats/Dusk
+          if-no-files-found: error
+
+  # build-vita:
+  #   runs-on: ubuntu-latest
+  #   steps:
+  #     - name: Checkout repository
+  #       uses: actions/checkout@v6
+  #     - name: Set up Docker
+  #       uses: docker/setup-docker-action@v5
+  #     - name: Build Vita
+  #       run: ./scripts/build-vita-docker.sh
+  #     - name: Upload Vita binary
+  #       uses: actions/upload-artifact@v6
+  #       with:
+  #         name: dusk-vita
+  #         path: build-vita/Dusk.vpk
+  #         if-no-files-found: error
+
+  build-knulli:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+      - name: Set up Docker
+        uses: docker/setup-docker-action@v5
+      - name: Build knulli
+        run: ./scripts/build-knulli-docker.sh
+      - name: Move output to Dusk subfolder
+        run: |
+          mkdir -p ./git-artifcats/Dusk
+          cp -r build-knulli/dusk ./git-artifcats/Dusk
+      - name: Upload knulli binary
+        uses: actions/upload-artifact@v6
+        with:
+          name: dusk-knulli
+          path: ./git-artifcats/Dusk
+          if-no-files-found: error
+
+  build-gamecube:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+      - name: Set up Docker
+        uses: docker/setup-docker-action@v5
+      - name: Build GameCube
+        run: ./scripts/build-gamecube-docker.sh
+      - name: Copy output files.
+        run: |
+          mkdir -p ./git-artifcats/Dusk
+          cp build-gamecube/Dusk.dol ./git-artifcats/Dusk/Dusk.dol
+          cp build-gamecube/dusk.dsk ./git-artifcats/Dusk/dusk.dsk
+      - name: Upload GameCube binary
+        uses: actions/upload-artifact@v6
+        with:
+          name: dusk-gamecube
+          path: ./git-artifcats/Dusk
+          if-no-files-found: error
+
+  build-gamecube-iso:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+      - name: Set up Docker
+        uses: docker/setup-docker-action@v5
+      - name: Build GameCube ISO
+        run: ./scripts/build-gamecube-iso-docker.sh
+      - name: Copy output files.
+        run: |
+          mkdir -p ./git-artifcats/Dusk
+          cp build-gamecube-iso/Dusk-NTSC-J.iso ./git-artifcats/Dusk/Dusk-NTSC-J.iso
+          cp build-gamecube-iso/Dusk-NTSC-U.iso ./git-artifcats/Dusk/Dusk-NTSC-U.iso
+          cp build-gamecube-iso/Dusk-PAL.iso    ./git-artifcats/Dusk/Dusk-PAL.iso
+      - name: Upload GameCube ISO
+        uses: actions/upload-artifact@v6
+        with:
+          name: dusk-gamecube-iso
+          path: ./git-artifcats/Dusk
+          if-no-files-found: error
+
+  build-wii:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+      - name: Set up Docker
+        uses: docker/setup-docker-action@v5
+      - name: Build Wii
+        run: ./scripts/build-wii-docker.sh
+      - name: Copy output files.
+        run: |
+          mkdir -p ./git-artifcats/Dusk/apps/Dusk
+          cp build-wii/boot.dol ./git-artifcats/Dusk/apps/Dusk/boot.dol
+          cp build-wii/dusk.dsk ./git-artifcats/Dusk/apps/Dusk/dusk.dsk
+          cp build-wii/meta.xml ./git-artifcats/Dusk/apps/Dusk/meta.xml
+      - name: Upload Wii binary
+        uses: actions/upload-artifact@v6
+        with:
+          name: dusk-wii
+          path: ./git-artifcats/Dusk
+          if-no-files-found: error
+
+  build-wii-iso:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+      - name: Set up Docker
+        uses: docker/setup-docker-action@v5
+      - name: Build Wii ISO
+        run: ./scripts/build-wii-iso-docker.sh
+      - name: Copy output files.
+        run: |
+          mkdir -p ./git-artifcats/Dusk
+          cp build-wii-iso/Dusk-NTSC-J.iso ./git-artifcats/Dusk/Dusk-NTSC-J.iso
+          cp build-wii-iso/Dusk-NTSC-U.iso ./git-artifcats/Dusk/Dusk-NTSC-U.iso
+          cp build-wii-iso/Dusk-PAL.iso    ./git-artifcats/Dusk/Dusk-PAL.iso
+      - name: Upload Wii ISO
+        uses: actions/upload-artifact@v6
+        with:
+          name: dusk-wii-iso
+          path: ./git-artifcats/Dusk
+          if-no-files-found: error

.gitignore

@@ -83,7 +83,6 @@ assets/borrowed
 .VSCode*
 
 /vita
-
 ._*
 
 *~
@@ -104,4 +103,7 @@ yarn.lock
 .venv
 
 /build2
-/build*
+/build*
+/assets/test
+/tools_old
+/assets/test.png

CMakeLists.txt

@@ -4,13 +4,21 @@
 # https://opensource.org/licenses/MIT
 
 # Setup
-cmake_minimum_required(VERSION 3.18)
+cmake_minimum_required(VERSION 3.13)
 
 set(CMAKE_C_STANDARD 11)
 set(CMAKE_C_STANDARD_REQUIRED ON)
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules)
+cmake_policy(SET CMP0079 NEW)
+# set(FETCHCONTENT_UPDATES_DISCONNECTED ON)
 
-option(ENABLE_TESTS "Enable tests" OFF)
+option(DUSK_BUILD_TESTS "Enable tests" OFF)
+
+# Game identity — override these per-project
+set(DUSK_GAME_NAME              "Dusk"               CACHE STRING "Game display name")
+set(DUSK_GAME_AUTHOR            "YouWish"             CACHE STRING "Game author / coder")
+set(DUSK_GAME_SHORT_DESCRIPTION "Dusk game"           CACHE STRING "One-line description")
+set(DUSK_GAME_LONG_DESCRIPTION  "No description yet." CACHE STRING "Full description")
 
 # Prep cache
 set(DUSK_CACHE_TARGET "dusk-target")
@@ -30,184 +38,94 @@ set(DUSK_BUILD_BINARY ${DUSK_BUILD_DIR}/Dusk CACHE INTERNAL ${DUSK_CACHE_TARGET}
 set(DUSK_ASSETS "" CACHE INTERNAL ${DUSK_CACHE_TARGET})
 set(DUSK_LIBRARY_TARGET_NAME "DuskCore" CACHE INTERNAL ${DUSK_CACHE_TARGET})
 set(DUSK_BINARY_TARGET_NAME "Dusk" CACHE INTERNAL ${DUSK_CACHE_TARGET})
-
-# Create directories
-file(MAKE_DIRECTORY ${DUSK_GENERATED_HEADERS_DIR})
-
-# Find packages
-find_package(Python3 COMPONENTS Interpreter REQUIRED)
-
-# Set target system
-# message(FATAL_ERROR "DISABLED FOR NOW2 ${DUSK_TARGET_SYSTEM}") 
+set(DUSK_ASSETS_ZIP "${DUSK_BUILD_DIR}/dusk.dsk" CACHE INTERNAL ${DUSK_CACHE_TARGET})
 
 if(NOT DEFINED DUSK_TARGET_SYSTEM)
   set(DUSK_TARGET_SYSTEM "linux")
-  # set(DUSK_TARGET_SYSTEM "psp")
 endif()
 
-# Toolchains
-if(DUSK_TARGET_SYSTEM STREQUAL "psp")
-  find_package(pspsdk REQUIRED)
-endif()
+# Create directories
+file(MAKE_DIRECTORY ${DUSK_GENERATED_HEADERS_DIR})
+file(MAKE_DIRECTORY ${DUSK_TEMP_DIR})
+file(MAKE_DIRECTORY ${DUSK_BUILT_ASSETS_DIR})
 
-if(DUSK_TARGET_SYSTEM STREQUAL "gamecube" OR DUSK_TARGET_SYSTEM STREQUAL "wii")
-  # Override to make library and binary be the same.
-  set(DUSK_LIBRARY_TARGET_NAME "${DUSK_LIBRARY_TARGET_NAME}.elf" CACHE INTERNAL ${DUSK_CACHE_TARGET})
-endif()
+# Required build packages
+find_package(Python3 COMPONENTS Interpreter REQUIRED)
 
 # Init Project.
 project(${DUSK_LIBRARY_TARGET_NAME}
   VERSION 1.0.0
-  LANGUAGES C CXX
+  LANGUAGES C
 )
 
 # Either, create library and binary separately (used for tests), or make them
-# one in the same so all code is in the binary.
-if(ENABLE_TESTS)
+# one in the same so all code is in the binary only.
+# Binary Executable
+add_executable(${DUSK_BINARY_TARGET_NAME} ${DUSK_SOURCES_DIR}/dusk/null.c)
+
+if(DUSK_BUILD_TESTS)
   # MainLibrary
   add_library(${DUSK_LIBRARY_TARGET_NAME} STATIC)
 
-  # Binary Executable
-  add_executable(${DUSK_BINARY_TARGET_NAME} ${DUSK_SOURCES_DIR}/null.c)
-
   # Link library to binary
   target_link_libraries(${DUSK_BINARY_TARGET_NAME}
     PUBLIC
       ${DUSK_LIBRARY_TARGET_NAME}
   )
 else()
-  set(DUSK_BINARY_TARGET_NAME "${DUSK_LIBRARY_TARGET_NAME}" CACHE INTERNAL ${DUSK_CACHE_TARGET})
-  add_executable(${DUSK_BINARY_TARGET_NAME} ${DUSK_SOURCES_DIR}/null.c)
+  set(DUSK_LIBRARY_TARGET_NAME "${DUSK_BINARY_TARGET_NAME}" CACHE INTERNAL ${DUSK_CACHE_TARGET})
 endif()
 
+if(NOT DEFINED DUSK_VERSION)
+  string(TIMESTAMP DUSK_VERSION "debug-%y%m%d%H%M%S")
+endif()
+
+# Definitions
+target_compile_definitions(${DUSK_LIBRARY_TARGET_NAME}
+  PUBLIC
+    DUSK_TARGET_SYSTEM="${DUSK_TARGET_SYSTEM}"
+    DUSK_GAME_NAME="${DUSK_GAME_NAME}"
+    DUSK_GAME_AUTHOR="${DUSK_GAME_AUTHOR}"
+    DUSK_GAME_SHORT_DESCRIPTION="${DUSK_GAME_SHORT_DESCRIPTION}"
+    DUSK_GAME_LONG_DESCRIPTION="${DUSK_GAME_LONG_DESCRIPTION}"
+    DUSK_VERSION="${DUSK_VERSION}"
+)
+
+# Toolchains
+include(cmake/targets/${DUSK_TARGET_SYSTEM}.cmake)
+
 # Add tools
 add_subdirectory(tools)
 
-# Assets
-add_subdirectory(assets)
-
-# Add libraries
-if(DUSK_TARGET_SYSTEM STREQUAL "linux")
-  find_package(SDL2 REQUIRED)
-  find_package(OpenGL REQUIRED)
-  target_link_libraries(${DUSK_LIBRARY_TARGET_NAME} PUBLIC 
-    SDL2
-    pthread
-    OpenGL::GL
-    GL
-    m
-  )
-
-elseif(DUSK_TARGET_SYSTEM STREQUAL "psp")
-  find_package(SDL2 REQUIRED)
-  find_package(OpenGL REQUIRED)
-  target_link_libraries(${DUSK_LIBRARY_TARGET_NAME} PUBLIC
-    ${SDL2_LIBRARIES}
-    SDL2
-    pthread
-    OpenGL::GL
-    zip
-    bz2
-    z
-    mbedtls
-    mbedcrypto
-    lzma
-    m
-  )
-  target_include_directories(${DUSK_LIBRARY_TARGET_NAME} PRIVATE
-    ${SDL2_INCLUDE_DIRS}
-  )
-
-elseif(DUSK_TARGET_SYSTEM STREQUAL "gamecube" OR DUSK_TARGET_SYSTEM STREQUAL "wii")
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-rtti -fno-exceptions")
-  configure_file(opengl.pc.in opengl.pc @ONLY)
-  find_package(PkgConfig REQUIRED)
-  pkg_check_modules(zip IMPORTED_TARGET libzip)
-  target_compile_definitions(${DUSK_LIBRARY_TARGET_NAME} PUBLIC
-    DOLPHIN
-  )
-
-  # Custom flags for cglm
-  set(CGLM_SHARED OFF CACHE BOOL "Build cglm shared" FORCE)
-  set(CGLM_STATIC ON  CACHE BOOL "Build cglm static" FORCE)
-  find_package(cglm REQUIRED)
-
-  # Compile lua
-  include(FetchContent)
-  FetchContent_Declare(
-    liblua
-    URL https://www.lua.org/ftp/lua-5.5.0.tar.gz
-  )
-  FetchContent_MakeAvailable(liblua)
-  set(LUA_SRC_DIR "${liblua_SOURCE_DIR}/src")
-  set(LUA_C_FILES 
-    lapi.c lauxlib.c lbaselib.c lcode.c lcorolib.c lctype.c ldblib.c ldebug.c
-    ldo.c ldump.c lfunc.c lgc.c linit.c liolib.c llex.c lmathlib.c lmem.c
-    loadlib.c lobject.c lopcodes.c loslib.c lparser.c lstate.c lstring.c
-    lstrlib.c ltable.c ltablib.c ltm.c lundump.c lutf8lib.c lvm.c lzio.c
-  )
-  list(TRANSFORM LUA_C_FILES PREPEND "${LUA_SRC_DIR}/")
-  add_library(liblua STATIC ${LUA_C_FILES})
-  target_include_directories(liblua PUBLIC "${LUA_SRC_DIR}")
-  target_compile_definitions(liblua PRIVATE LUA_USE_C89)
-  add_library(lua::lua ALIAS liblua)
-  set(Lua_FOUND TRUE CACHE BOOL "Lua found" FORCE)
-
-  target_link_libraries(${DUSK_LIBRARY_TARGET_NAME} PRIVATE
-    cglm
-    liblua
-    m
-    fat
-    PkgConfig::zip
-  )
-endif()
-
-# Force turn tests off for now
-set(ENABLE_TESTS OFF CACHE BOOL "Enable tests" FORCE)
-
-# Add code
-add_subdirectory(${DUSK_SOURCES_DIR})
-
-# Handle tests
-if(ENABLE_TESTS)
-  enable_testing()
-  add_subdirectory(test)
-endif()
-
-# Build assets
-dusk_run_python(
-  DUSK_ASSETS_BUILT
-  tools.asset.bundle
-    --assets ${DUSK_ASSETS_DIR}
-    --output-assets ${DUSK_BUILT_ASSETS_DIR}
-    --output-file ${DUSK_BUILD_DIR}/dusk.dsk
-    --headers-dir ${DUSK_GENERATED_HEADERS_DIR}
-    --input ${DUSK_ASSETS}
+# Include generated headers from tools.
+target_include_directories(${DUSK_LIBRARY_TARGET_NAME} PUBLIC
+  ${DUSK_GENERATED_HEADERS_DIR}
 )
-add_dependencies(${DUSK_LIBRARY_TARGET_NAME} DUSK_ASSETS_BUILT)
+
+# Add main code
+add_subdirectory(${DUSK_SOURCES_DIR})
 
 # Include generated headers
 target_include_directories(${DUSK_LIBRARY_TARGET_NAME} PUBLIC
   ${DUSK_GENERATED_HEADERS_DIR}
 )
 
-# Postbuild
-if(DUSK_TARGET_SYSTEM STREQUAL "psp")
-  create_pbp_file(
-    TARGET "${DUSK_BINARY_TARGET_NAME}"
-    ICON_PATH NULL
-    BACKGROUND_PATH NULL
-    PREVIEW_PATH NULL
-    TITLE "${DUSK_BINARY_TARGET_NAME}"
-    PSAR_PATH ${DUSK_BUILD_DIR}/dusk.dsk
-    VERSION 01.00
-  )
-elseif(DUSK_TARGET_SYSTEM STREQUAL "gamecube" OR DUSK_TARGET_SYSTEM STREQUAL "wii")
-  set(DUSK_BINARY_TARGET_NAME_DOL "${DUSK_BUILD_DIR}/Dusk.dol")
-  add_custom_command(TARGET ${DUSK_BINARY_TARGET_NAME} POST_BUILD
-    COMMAND elf2dol
-            "$<TARGET_FILE:${DUSK_BINARY_TARGET_NAME}>"
-            "${DUSK_BINARY_TARGET_NAME_DOL}"
-    COMMENT "Generating ${DUSK_BINARY_TARGET_NAME_DOL} from ${DUSK_BINARY_TARGET_NAME}"
-  )
+# Handle tests
+if(DUSK_BUILD_TESTS)
+  enable_testing()
+  add_subdirectory(test)
 endif()
+
+# Build assets
+file(GLOB_RECURSE DUSK_ASSET_FILES CONFIGURE_DEPENDS "${DUSK_ASSETS_DIR}/*")
+add_custom_command(
+  OUTPUT "${DUSK_ASSETS_ZIP}"
+  COMMAND ${CMAKE_COMMAND} -E make_directory "${DUSK_ASSETS_DIR}"
+  COMMAND ${CMAKE_COMMAND} -E rm -f "${DUSK_ASSETS_ZIP}"
+  COMMAND ${CMAKE_COMMAND} -E tar "cf" "${DUSK_ASSETS_ZIP}" --format=zip -- .
+  WORKING_DIRECTORY "${DUSK_ASSETS_DIR}"
+  DEPENDS ${DUSK_ASSET_FILES}
+  VERBATIM
+)
+add_custom_target(DUSK_ASSETS_BUILT DEPENDS "${DUSK_ASSETS_ZIP}")
+add_dependencies(${DUSK_LIBRARY_TARGET_NAME} DUSK_ASSETS_BUILT)

archive/asset/process/image.py

@@ -35,10 +35,24 @@ def processPalettizedImage(asset):
   imagePalette = extractPaletteFromImage(image)
 
   # Find palette that contains every color
-  for palette in palettes:
-    if all(color in palette['pixels'] for color in imagePalette):
+  palette = None
+  for p in palettes:
+    hasAllColors = True
+    for color in imagePalette:
+      for palColor in p['pixels']:
+        if color[0] == palColor[0] and color[1] == palColor[1] and color[2] == palColor[2] and color[3] == palColor[3]:
+          break
+        elif color[3] == 0 and palColor[3] == 0:
+          break
+      else:
+        print('Pallete {} does not contain color #{}'.format(p['paletteName'], '{:02x}{:02x}{:02x}{:02x}'.format(color[0], color[1], color[2], color[3])))
+        hasAllColors = False
+        break
+    if hasAllColors:
+      palette = p
       break
-  else:
+    
+  if palette is None:
     palette = palettes[0]  # Just to avoid reference error
     print(f"No matching palette found for {assetPath}!")
     # Find which pixel is missing

archive/asset/process/palette.py

@@ -1,3 +1,4 @@
+import json
 import os
 from PIL import Image
 import datetime
@@ -78,6 +79,7 @@ def processPalette(asset):
 
 def processPaletteList():
   data = f"// Auto-generated palette list\n"
+  print(f"Generating palette list with {len(palettes)} palettes.")
   for palette in palettes:
     data += f"#include \"{palette['headerFile']}\"\n"
   data += f"\n"

archive/asset/process/tileset.py

@@ -126,6 +126,7 @@ def processTileset(asset):
   data += f"#pragma once\n"
   data += f"#include \"display/tileset/tileset.h\"\n\n"
   data += f"static const tileset_t TILESET_{tilesetNameUpper} = {{\n"
+  data += f"  .name = {json.dumps(tilesetName)},\n"
   data += f"  .tileWidth = {tilesetData['tileWidth']},\n"
   data += f"  .tileHeight = {tilesetData['tileHeight']},\n"
   data += f"  .tileCount = {tilesetData['columns'] * tilesetData['rows']},\n"

archive/assetpalette.c

@@ -0,0 +1,47 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "assetpalette.h"
+#include "asset/assettype.h"
+#include "assert/assert.h"
+
+errorret_t assetPaletteLoad(assetentire_t entire) {
+  assertNotNull(entire.data, "Data pointer cannot be NULL.");
+  assertNotNull(entire.output, "Output pointer cannot be NULL.");
+
+  assetpalette_t *assetData = (assetpalette_t *)entire.data;
+  palette_t *palette = (palette_t *)entire.output;
+
+  // Read header and version (first 4 bytes)
+  if(
+    assetData->header[0] != 'D' || 
+    assetData->header[1] != 'P' ||
+    assetData->header[2] != 'F'
+  ) {
+    errorThrow("Invalid palette header");
+  }
+  
+  // Version (can only be 1 atm)
+  if(assetData->version != 0x01) {
+    errorThrow("Unsupported palette version");
+  }
+
+  // Check color count.
+  if(
+    assetData->colorCount == 0 || 
+    assetData->colorCount > PALETTE_COLOR_COUNT_MAX
+  ) {
+    errorThrow("Invalid palette color count");
+  }
+  
+  paletteInit(
+    palette,
+    assetData->colorCount,
+    assetData->colors
+  );
+  errorOk();
+}

archive/assetpalette.h

@@ -0,0 +1,30 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "error/error.h"
+#include "display/texture/palette.h"
+
+typedef struct assetentire_s assetentire_t;
+
+#pragma pack(push, 1)
+typedef struct {
+  char_t header[3];
+  uint8_t version;
+
+  uint8_t colorCount;
+  color_t colors[PALETTE_COLOR_COUNT_MAX];
+} assetpalette_t;
+#pragma pack(pop)
+
+/**
+ * Loads a palette from the given data pointer into the output palette.
+ *
+ * @param entire Data received from the asset loader system.
+ * @return An error code.
+ */
+errorret_t assetPaletteLoad(assetentire_t entire);

archive/camera/camera.c

@@ -0,0 +1,107 @@
+/**
+ * Copyright (c) 2025 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "camera.h"
+#include "display/display.h"
+#include "assert/assert.h"
+#include "display/framebuffer/framebuffer.h"
+#include "display/screen/screen.h"
+
+void cameraInit(camera_t *camera) {
+  cameraInitPerspective(camera);
+}
+
+void cameraInitPerspective(camera_t *camera) {
+  assertNotNull(camera, "Not a camera component");
+
+  camera->projType = CAMERA_PROJECTION_TYPE_PERSPECTIVE;
+  camera->perspective.fov = glm_rad(45.0f);
+  camera->nearClip = 0.1f;
+  camera->farClip = 10000.0f;
+
+  camera->viewType = CAMERA_VIEW_TYPE_LOOKAT;
+  glm_vec3_copy((vec3){ 5.0f, 5.0f, 5.0f }, camera->lookat.position);
+  glm_vec3_copy((vec3){ 0.0f, 1.0f, 0.0f }, camera->lookat.up);
+  glm_vec3_copy((vec3){ 0.0f, 0.0f, 0.0f }, camera->lookat.target);
+}
+
+void cameraInitOrthographic(camera_t *camera) {
+  assertNotNull(camera, "Not a camera component");
+
+  camera->projType = CAMERA_PROJECTION_TYPE_ORTHOGRAPHIC;
+  camera->orthographic.left = 0.0f;
+  camera->orthographic.right = SCREEN.width;
+  camera->orthographic.top = SCREEN.height;
+  camera->orthographic.bottom = 0.0f;
+  camera->nearClip = 0.1f;
+  camera->farClip = 1.0f;
+
+  camera->viewType = CAMERA_VIEW_TYPE_2D;
+  glm_vec2_copy((vec2){ 0.0f, 0.0f }, camera->_2d.position);
+  camera->_2d.zoom = 1.0f;
+}
+
+void cameraGetProjectionMatrix(camera_t *camera, mat4 dest) {
+  assertNotNull(camera, "Not a camera component");
+  assertNotNull(dest, "Destination matrix must not be null");
+
+  if(
+    camera->projType == CAMERA_PROJECTION_TYPE_PERSPECTIVE ||
+    camera->projType == CAMERA_PROJECTION_TYPE_PERSPECTIVE_FLIPPED
+  ) {
+    glm_mat4_identity(dest);
+    glm_perspective(
+      camera->perspective.fov,
+      SCREEN.aspect,
+      camera->nearClip,
+      camera->farClip,
+      dest
+    );
+
+    if(camera->projType == CAMERA_PROJECTION_TYPE_PERSPECTIVE_FLIPPED) {
+      dest[1][1] *= -1.0f;
+    }
+  } else if(camera->projType == CAMERA_PROJECTION_TYPE_ORTHOGRAPHIC) {
+    glm_mat4_identity(dest);
+    glm_ortho(
+      camera->orthographic.left,
+      camera->orthographic.right,
+      camera->orthographic.top,
+      camera->orthographic.bottom,
+      camera->nearClip,
+      camera->farClip,
+      dest
+    );
+  }
+}
+
+void cameraGetViewMatrix(camera_t *camera, mat4 dest) {
+  assertNotNull(camera, "Not a camera component");
+  assertNotNull(dest, "Destination matrix must not be null");
+
+  if(camera->viewType == CAMERA_VIEW_TYPE_MATRIX) {
+    glm_mat4_ucopy(camera->view, dest);
+  } else if(camera->viewType == CAMERA_VIEW_TYPE_LOOKAT) {
+    glm_mat4_identity(dest);
+    glm_lookat(
+      camera->lookat.position,
+      camera->lookat.target,
+      camera->lookat.up,
+      dest
+    );
+  } else if(camera->viewType == CAMERA_VIEW_TYPE_2D) {
+    glm_mat4_identity(dest);
+    glm_lookat(
+      (vec3){ camera->_2d.position[0], camera->_2d.position[1], 0.5f },
+      (vec3){ camera->_2d.position[0], camera->_2d.position[1], 0.0f },
+      (vec3){ 0.0f, 1.0f, 0.0f },
+      dest
+    );
+  } else if(camera->viewType == CAMERA_VIEW_TYPE_LOOKAT_PIXEL_PERFECT) {
+    assertUnreachable("LOOKAT_PIXEL_PERFECT view type is not implemented yet");
+  }
+}

archive/camera/camera.h

@@ -8,12 +8,12 @@
 #pragma once
 #include "dusk.h"
 #include "display/color.h"
+#include "display/camera/cameraplatform.h"
+
+#ifndef cameraPushMatrixPlatform
+  #error "cameraPushMatrixPlatform must be defined"
+#endif
 
-typedef enum {
-  CAMERA_PROJECTION_TYPE_PERSPECTIVE,
-  CAMERA_PROJECTION_TYPE_PERSPECTIVE_FLIPPED,
-  CAMERA_PROJECTION_TYPE_ORTHOGRAPHIC
-} cameraprojectiontype_t;
 
 typedef enum {
   CAMERA_VIEW_TYPE_MATRIX,
@@ -22,8 +22,7 @@ typedef enum {
   CAMERA_VIEW_TYPE_LOOKAT_PIXEL_PERFECT
 } cameraviewtype_t;
 
-typedef struct {
-
+typedef struct camera_s {
   union {
     mat4 view;
 
@@ -82,13 +81,17 @@ void cameraInitPerspective(camera_t *camera);
 void cameraInitOrthographic(camera_t *camera);
 
 /**
- * Pushes the camera's view matrix onto the matrix stack.
+ * Gets the projection matrix for a camera.
  * 
- * @param id The ID of the camera entity to use.
+ * @param camera Camera to get the projection matrix for
+ * @param dest Matrix to store the projection matrix in
  */
-void cameraPushMatrix(camera_t* camera);
+void cameraGetProjectionMatrix(camera_t *camera, mat4 dest);
 
 /**
- * Pops the camera's view matrix off the matrix stack.
+ * Gets the view matrix for a camera.
+ * 
+ * @param camera Camera to get the view matrix for
+ * @param dest Matrix to store the view matrix in
  */
-void cameraPopMatrix(void);
+void cameraGetViewMatrix(camera_t *camera, mat4 dest);

archive/dusk/map.py

@@ -156,7 +156,7 @@ class Map:
     newTopLeftChunkY = y // CHUNK_HEIGHT - (MAP_HEIGHT // 2)
     newTopLeftChunkZ = z // CHUNK_DEPTH - (MAP_DEPTH // 2)
 
-    if (newTopLeftChunkX != self.topLeftX or
+    if(newTopLeftChunkX != self.topLeftX or
         newTopLeftChunkY != self.topLeftY or
         newTopLeftChunkZ != self.topLeftZ):
       
@@ -166,7 +166,7 @@ class Map:
         chunkWorldX = chunk.x
         chunkWorldY = chunk.y
         chunkWorldZ = chunk.z
-        if (chunkWorldX < newTopLeftChunkX or
+        if(chunkWorldX < newTopLeftChunkX or
             chunkWorldX >= newTopLeftChunkX + MAP_WIDTH or
             chunkWorldY < newTopLeftChunkY or
             chunkWorldY >= newTopLeftChunkY + MAP_HEIGHT or

archive/loader/CMakeLists.txt

@@ -6,10 +6,8 @@
 # Sources
 target_sources(${DUSK_LIBRARY_TARGET_NAME}
   PUBLIC
-    assetalphaimage.c
-    assetpaletteimage.c
+    assettexture.c
+    assettileset.c
     assetlanguage.c
     assetscript.c
-    assetmap.c
-    assetmapchunk.c
 )

archive/loader/assetlanguage.c

@@ -0,0 +1,45 @@
+/**
+ * Copyright (c) 2025 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "asset/asset.h"
+#include "assert/assert.h"
+#include "locale/localemanager.h"
+
+errorret_t assetLanguageHandler(assetcustom_t custom) {
+  assertNotNull(custom.zipFile, "Custom asset zip file cannot be NULL");
+  assertNotNull(custom.output, "Custom asset output cannot be NULL");
+
+  assetlanguage_t *lang = (assetlanguage_t *)custom.output;
+  errorChain(assetLanguageInit(lang, custom.zipFile));
+
+  errorOk();
+}
+
+errorret_t assetLanguageInit(
+  assetlanguage_t *lang,
+  zip_file_t *zipFile
+) {
+  errorThrow("Language asset initialization is not yet implemented.");
+}
+
+errorret_t assetLanguageRead(
+  assetlanguage_t *lang,
+  const uint32_t key,
+  char_t *buffer,
+  const uint32_t bufferSize,
+  uint32_t *outLength
+) {
+  errorThrow("Language string reading is not yet implemented.");
+}
+
+void assetLanguageDispose(assetlanguage_t *lang) {
+  assertNotNull(lang, "Language asset cannot be NULL");
+
+  if(lang->zip) {
+    zip_fclose(lang->zip);
+  }
+}

archive/loader/assetlanguage.h

@@ -6,39 +6,13 @@
  */
 
 #pragma once
-#include "locale/language/keys.h"
 #include "error/error.h"
 #include "duskdefs.h"
 #include <zip.h>
 
-#define ASSET_LANG_CHUNK_CACHE 4 // Number of chunks to cache in memory
-
-#pragma pack(push, 1)
-typedef char assetlanguagechunk_t[ASSET_LANG_CHUNK_CHAR_COUNT];
-#pragma pack(pop)
-
-#pragma pack(push, 1)
-typedef struct {
-  uint32_t chunk;
-  uint32_t offset;
-  uint32_t length;
-} assetlanguagestring_t;
-#pragma pack(pop)
-
-#pragma pack(push, 1)
-typedef struct {
-  assetlanguagestring_t strings[LANG_KEY_COUNT];
-} assetlanguageheader_t;
-#pragma pack(pop)
-
 typedef struct {
   zip_file_t *zip;
-  assetlanguageheader_t header;
   zip_int64_t chunksOffset;
-
-  // Chunk cache
-  assetlanguagechunk_t chunks[ASSET_LANG_CHUNK_CACHE];
-  uint32_t chunkIndices[ASSET_LANG_CHUNK_CACHE];
 } assetlanguage_t;
 
 typedef struct assetcustom_s assetcustom_t;

archive/loader/assettexture.c

@@ -0,0 +1,78 @@
+/**
+ * Copyright (c) 2025 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "assettexture.h"
+#include "asset/assettype.h"
+#include "assert/assert.h"
+#include "display/texture/texture.h"
+#include "util/endian.h"
+
+errorret_t assetTextureLoad(assetentire_t entire) {
+  assertNotNull(entire.data, "Data pointer cannot be NULL.");
+  assertNotNull(entire.output, "Output pointer cannot be NULL.");
+
+  assettexture_t *assetData = (assettexture_t *)entire.data;
+  texture_t *texture = (texture_t *)entire.output;
+
+  // Read header and version (first 4 bytes)
+  if(
+    assetData->header[0] != 'D' || 
+    assetData->header[1] != 'T' ||
+    assetData->header[2] != 'X'
+  ) {
+    errorThrow("Invalid texture header");
+  }
+  
+  // Version (can only be 1 atm)
+  if(assetData->version != 0x01) {
+    errorThrow("Unsupported texture version");
+  }
+
+  // Fix endian
+  assetData->width = endianLittleToHost32(assetData->width);
+  assetData->height = endianLittleToHost32(assetData->height);
+
+  // Check dimensions.
+  if(
+    assetData->width == 0 || assetData->width > ASSET_TEXTURE_WIDTH_MAX ||
+    assetData->height == 0 || assetData->height > ASSET_TEXTURE_HEIGHT_MAX
+  ) {
+    errorThrow("Invalid texture dimensions");
+  }
+
+  // Validate format
+  textureformat_t format;
+  texturedata_t data;
+
+  switch(assetData->type) {
+    case 0x00: // RGBA8888
+      format = TEXTURE_FORMAT_RGBA;
+      data.rgbaColors = (color_t *)assetData->data;
+      break;
+
+    // case 0x01:
+    //   format = TEXTURE_FORMAT_RGB;
+    //   break;
+    
+    // case 0x02:
+    //   format = TEXTURE_FORMAT_RGB565;
+    //   break;
+
+    // case 0x03:
+    //   format = TEXTURE_FORMAT_RGB5A3;
+    //   break;
+
+    default:
+      errorThrow("Unsupported texture format");
+  }
+
+  errorChain(textureInit(
+    texture, assetData->width, assetData->height, format, data
+  ));
+
+  errorOk();
+}

archive/loader/assettexture.h

@@ -0,0 +1,39 @@
+/**
+ * Copyright (c) 2025 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "error/error.h"
+#include "display/color.h"
+
+#define ASSET_TEXTURE_WIDTH_MAX 2048
+#define ASSET_TEXTURE_HEIGHT_MAX 2048
+#define ASSET_TEXTURE_SIZE_MAX ( \
+  ASSET_TEXTURE_WIDTH_MAX * ASSET_TEXTURE_HEIGHT_MAX \
+)
+
+typedef struct assetentire_s assetentire_t;
+
+#pragma pack(push, 1)
+typedef struct {
+  char_t header[3];
+  uint8_t version;
+  uint8_t type;
+  uint32_t width;
+  uint32_t height;
+  uint8_t data[ASSET_TEXTURE_SIZE_MAX * sizeof(color4b_t)];
+} assettexture_t;
+#pragma pack(pop)
+
+/**
+ * Loads a palettized texture from the given data pointer into the output
+ * texture.
+ *
+ * @param data Pointer to the raw assettexture_t data.
+ * @param output Pointer to the texture_t to load the image into.
+ * @return An error code.
+ */
+errorret_t assetTextureLoad(assetentire_t entire);

archive/loader/assettileset.c

@@ -0,0 +1,70 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "asset/asset.h"
+#include "assert/assert.h"
+#include "display/texture/tileset.h"
+#include "util/memory.h"
+#include "util/endian.h"
+
+errorret_t assetTilesetLoad(assetentire_t entire) {
+  assertNotNull(entire.data, "Asset data cannot be null");
+  assertNotNull(entire.output, "Asset output cannot be null");
+
+  assettileset_t *tilesetData = (assettileset_t *)entire.data;
+  tileset_t *tileset = (tileset_t *)entire.output;
+
+  if(
+    tilesetData->header[0] != 'D' || 
+    tilesetData->header[1] != 'T' ||
+    tilesetData->header[2] != 'F'
+  ) {
+    errorThrow("Invalid tileset header");
+  }
+
+  if(tilesetData->version != 0x00) {
+    errorThrow("Unsupported tileset version");
+  }
+
+  // Fix endianness
+  tilesetData->tileWidth = endianLittleToHost16(tilesetData->tileWidth);
+  tilesetData->tileHeight = endianLittleToHost16(tilesetData->tileHeight);
+  tilesetData->columnCount = endianLittleToHost16(tilesetData->columnCount);
+  tilesetData->rowCount = endianLittleToHost16(tilesetData->rowCount);
+  tilesetData->right = endianLittleToHost16(tilesetData->right);
+  tilesetData->bottom = endianLittleToHost16(tilesetData->bottom);
+
+  if(tilesetData->tileWidth == 0) {
+    errorThrow("Tile width cannot be 0");
+  }
+  if(tilesetData->tileHeight == 0) {
+    errorThrow("Tile height cannot be 0");
+  }
+  if(tilesetData->columnCount == 0) {
+    errorThrow("Column count cannot be 0");
+  }
+  if(tilesetData->rowCount == 0) {
+    errorThrow("Row count cannot be 0");
+  }
+
+  tilesetData->u0 = endianLittleToHostFloat(tilesetData->u0);
+  tilesetData->v0 = endianLittleToHostFloat(tilesetData->v0);
+
+  if(tilesetData->v0 < 0.0f || tilesetData->v0 > 1.0f) {
+    errorThrow("Invalid v0 value in tileset");
+  }
+
+  // Setup tileset
+  tileset->tileWidth = tilesetData->tileWidth;
+  tileset->tileHeight = tilesetData->tileHeight;
+  tileset->tileCount = tilesetData->columnCount * tilesetData->rowCount;
+  tileset->columns = tilesetData->columnCount;
+  tileset->rows = tilesetData->rowCount;
+  tileset->uv[0] = tilesetData->u0;
+  tileset->uv[1] = tilesetData->v0;
+  errorOk();
+}

archive/loader/assettileset.h

@@ -0,0 +1,32 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "error/error.h"
+
+#pragma pack(push, 1)
+typedef struct {
+  char_t header[3];
+  uint8_t version;
+  uint16_t tileWidth;
+  uint16_t tileHeight;
+  uint16_t columnCount;
+  uint16_t rowCount;
+  uint16_t right;
+  uint16_t bottom;
+  float_t u0;
+  float_t v0;
+} assettileset_t;
+#pragma pack(pop)
+
+/**
+ * Loads a tileset from the given data pointer into the output tileset.
+ *
+ * @param entire Data received from the asset loader system.
+ * @return An error code.
+ */
+errorret_t assetTilesetLoad(assetentire_t entire);

archive/modulemap.h

@@ -22,13 +22,13 @@ int moduleMapLoad(lua_State *L) {
   // Potentially provide up to 3 params
   chunkpos_t initial = { .x = 0, .y = 0, .z = 0 };
   if(lua_isnumber(L, 2)) {
-    initial.x = (chunkunit_t)luaL_checkinteger(L, 2);
+    initial.x = (chunkunit_t)lua_tonumber(L, 2);
   }
   if(lua_isnumber(L, 3)) {
-    initial.y = (chunkunit_t)luaL_checkinteger(L, 3);
+    initial.y = (chunkunit_t)lua_tonumber(L, 3);
   }
   if(lua_isnumber(L, 4)) {
-    initial.z = (chunkunit_t)luaL_checkinteger(L, 4);
+    initial.z = (chunkunit_t)lua_tonumber(L, 4);
   }
 
   // Load the map.

archive/platform/CMakeLists.txt

@@ -6,5 +6,7 @@
 # Sources
 target_sources(${DUSK_LIBRARY_TARGET_NAME}
   PUBLIC
-    moduleinput.c
+    sdl2.c
+    psp.c
+    dolphin.c
 )

archive/platform/dolphin.c

@@ -0,0 +1,92 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "dolphin.h"
+
+void displayInitDolphin(void) {
+  VIDEO_Init();
+  DISPLAY.screenMode = VIDEO_GetPreferredMode(NULL);
+  DISPLAY.frameBuffer[0] = MEM_K0_TO_K1(
+    SYS_AllocateFramebuffer(DISPLAY.screenMode)
+  );
+  DISPLAY.frameBuffer[1] = MEM_K0_TO_K1(
+    SYS_AllocateFramebuffer(DISPLAY.screenMode)
+  );
+  VIDEO_Configure(DISPLAY.screenMode);
+
+  VIDEO_SetNextFramebuffer(DISPLAY.frameBuffer[DISPLAY.whichFrameBuffer]);
+  // VIDEO_SetPostRetraceCallback(copy_buffers);
+  VIDEO_SetBlack(FALSE);
+  VIDEO_Flush();
+  VIDEO_WaitVSync();
+  if(DISPLAY.screenMode->viTVMode & VI_NON_INTERLACE) VIDEO_WaitVSync();
+
+  DISPLAY.fifoBuffer = memalign(32, DISPLAY_FIFO_SIZE);
+  memoryZero(DISPLAY.fifoBuffer, DISPLAY_FIFO_SIZE);
+
+  GX_Init(DISPLAY.fifoBuffer, DISPLAY_FIFO_SIZE);
+
+  // This seems to be mostly related to interlacing vs progressive
+  GX_SetViewport(
+    0, 0,
+    DISPLAY.screenMode->fbWidth, DISPLAY.screenMode->efbHeight,
+    0, 1
+  );
+  float_t yscale = GX_GetYScaleFactor(
+    DISPLAY.screenMode->efbHeight, DISPLAY.screenMode->xfbHeight
+  );
+  uint32_t xfbHeight = GX_SetDispCopyYScale(yscale);
+  GX_SetScissor(
+    0, 0,
+    DISPLAY.screenMode->fbWidth, DISPLAY.screenMode->efbHeight
+  );
+  GX_SetDispCopySrc(
+    0, 0,
+    DISPLAY.screenMode->fbWidth, DISPLAY.screenMode->efbHeight
+  );
+  GX_SetDispCopyDst(DISPLAY.screenMode->fbWidth, xfbHeight);
+  GX_SetCopyFilter(
+    DISPLAY.screenMode->aa,
+    DISPLAY.screenMode->sample_pattern,
+    GX_TRUE,
+    DISPLAY.screenMode->vfilter
+  );
+  GX_SetFieldMode(
+    DISPLAY.screenMode->field_rendering,
+    (
+      (DISPLAY.screenMode->viHeight == 2 * DISPLAY.screenMode->xfbHeight) ?
+      GX_ENABLE :
+      GX_DISABLE
+    )
+  );
+
+  // Setup cull modes
+  GX_SetCullMode(GX_CULL_NONE);
+  GX_SetZMode(GX_FALSE, GX_ALWAYS, GX_FALSE);
+  GX_CopyDisp(DISPLAY.frameBuffer[DISPLAY.whichFrameBuffer], GX_TRUE);
+  GX_SetDispCopyGamma(GX_GM_1_0);
+
+  GX_ClearVtxDesc();
+  GX_SetVtxDesc(GX_VA_POS,  GX_INDEX16);
+  GX_SetVtxDesc(GX_VA_CLR0, GX_INDEX16);
+  GX_SetVtxDesc(GX_VA_TEX0, GX_INDEX16);
+  GX_SetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_POS_XYZ, GX_F32, 0);
+  GX_SetVtxAttrFmt(GX_VTXFMT0, GX_VA_CLR0, GX_CLR_RGBA, GX_U8, 0);
+  GX_SetVtxAttrFmt(GX_VTXFMT0, GX_VA_TEX0, GX_TEX_ST, GX_F32, 0);
+}
+
+void displayDolphinSwap(void) {
+  GX_DrawDone();
+
+  DISPLAY.whichFrameBuffer ^= 1;
+  GX_SetZMode(GX_TRUE, GX_LEQUAL, GX_TRUE);
+  GX_SetColorUpdate(GX_TRUE);
+  GX_CopyDisp(DISPLAY.frameBuffer[DISPLAY.whichFrameBuffer], GX_TRUE);
+  VIDEO_SetNextFramebuffer(DISPLAY.frameBuffer[DISPLAY.whichFrameBuffer]);
+  VIDEO_Flush();
+  VIDEO_WaitVSync();
+}

archive/platform/dolphin.h

@@ -0,0 +1,27 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "dusk.h"
+#include "display/displaydefs.h"
+
+typedef struct {
+  void *frameBuffer[2];// Double-Bufferred
+  int whichFrameBuffer;
+  GXRModeObj *screenMode;
+  void *fifoBuffer;
+} displaydolphin_t;
+
+/**
+ * Initializes the display for Dolphin.
+ */
+void displayDolphinInit(void);
+
+/**
+ * Swaps the back buffer to the front for Dolphin.
+ */
+void displayDolphinSwap(void);

archive/platform/psp.c

@@ -0,0 +1,12 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "psp.h"
+
+void displayInitPSP(void) {
+  DISPLAY.usingShaderedPalettes = false;
+}

archive/platform/psp.h

@@ -6,8 +6,8 @@
  */
 
 #pragma once
-#include "dusk.h"
 
-typedef struct {
-  const char_t *file;
-} localeinfo_t;
+/**
+ * Initializes the display for PSP.
+ */
+void displayInitPSP(void);

archive/platform/sdl2.c

@@ -0,0 +1,32 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "sdl2.h"
+
+void displaySDL2Update(void) {
+}
+
+void displaySDL2Swap(void) {
+  SDL_GL_SwapWindow(DISPLAY.window);
+
+  GLenum err;
+  while((err = glGetError()) != GL_NO_ERROR) {
+    debugPrint("GL Error: %d\n", err);
+  }
+}
+
+void displaySDL2Dispose(void) {
+  if(DISPLAY.glContext) {
+    SDL_GL_DeleteContext(DISPLAY.glContext);
+    DISPLAY.glContext = NULL;
+  }
+  if(DISPLAY.window) {
+    SDL_DestroyWindow(DISPLAY.window);
+    DISPLAY.window = NULL;
+  }
+  SDL_Quit();
+}

archive/platform/sdl2.h

@@ -0,0 +1,35 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "dusk.h"
+
+typedef struct {
+  SDL_Window *window;
+  SDL_GLContext glContext;
+  bool_t usingShaderedPalettes;
+} displaysdl2_t;
+
+/**
+ * Initializes the display for SDL2.
+ */
+void displaySDL2Init(void);
+
+/**
+ * Updates the display for SDL2.
+ */
+void displaySDL2Update(void);
+
+/**
+ * Swaps the display buffers for SDL2.
+ */
+void displaySDL2Swap(void);
+
+/**
+ * Disposes of the display for SDL2.
+ */
+void displaySDL2Dispose(void);

archive/scriptfuncentity.h

@@ -12,10 +12,9 @@
 
 int scriptFuncEntityAdd(lua_State *L) {
   assertNotNull(L, "Lua state cannot be NULL");
+  assertTrue(lua_isnumber(L, 1), "Expected integer entity type");
 
-  assertTrue(lua_isinteger(L, 1), "Expected integer entity type");
-
-  lua_Integer entityType = luaL_checkinteger(L, 1);
+  entitytype_t entityType = (entitytype_t)luaL_checknumber(L, 1);
   assertTrue(
     entityType >= ENTITY_TYPE_NULL && entityType < ENTITY_TYPE_COUNT,
     "Invalid entity type passed to scriptFuncEntityAdd"

assets/CMakeLists.txt

@@ -1,21 +0,0 @@
-# Copyright (c) 2025 Dominic Masters
-# 
-# This software is released under the MIT License.
-# https://opensource.org/licenses/MIT
-
-set(DUSK_GAME_ASSETS_DIR "${CMAKE_CURRENT_SOURCE_DIR}" CACHE INTERNAL "Game assets directory")
-
-# Palette asset needs to be added before any images.
-add_subdirectory(palette)
-
-# Languages need to be added before anything that uses text.
-add_subdirectory(locale)
-
-# Rest, order doesn't matter
-add_asset(SCRIPT init.lua)
-
-# Subdirs
-add_subdirectory(entity)
-add_subdirectory(map)
-add_subdirectory(ui)
-add_subdirectory(scene)

assets/entity/CMakeLists.txt

@@ -1,6 +0,0 @@
-# Copyright (c) 2025 Dominic Masters
-# 
-# This software is released under the MIT License.
-# https://opensource.org/licenses/MIT
-
-add_asset(TILESET entities.tsx)

assets/entity/entities.tsx

@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<tileset version="1.10" tiledversion="1.11.2" name="entities" tilewidth="16" tileheight="16" tilecount="64" columns="8">
- <image source="entities.png" width="128" height="128"/>
-</tileset>

assets/init.js

@@ -0,0 +1,12 @@
+Console.print('This is called from JavaScript');
+
+const platformNames = {
+  [System.PLATFORM_LINUX]:    'Linux',
+  [System.PLATFORM_KNULLI]:   'Knulli',
+  [System.PLATFORM_PSP]:      'PSP',
+  [System.PLATFORM_GAMECUBE]: 'GameCube',
+  [System.PLATFORM_WII]:      'Wii',
+};
+
+const platformName = platformNames[System.platform] || 'Unknown';
+Console.print('Platform: ' + platformName);

assets/init.lua

@@ -1,56 +0,0 @@
-module('platform')
-module('input')
-module('scene')
-module('locale')
-
--- Default Input bindings.
-if PLATFORM == "psp" then
-  inputBind("up", INPUT_ACTION_UP)
-  inputBind("down", INPUT_ACTION_DOWN)
-  inputBind("left", INPUT_ACTION_LEFT)
-  inputBind("right", INPUT_ACTION_RIGHT)
-  inputBind("circle", INPUT_ACTION_CANCEL)
-  inputBind("cross", INPUT_ACTION_ACCEPT)
-  inputBind("select", INPUT_ACTION_RAGEQUIT)
-  inputBind("lstick_up", INPUT_ACTION_UP)
-  inputBind("lstick_down", INPUT_ACTION_DOWN)
-  inputBind("lstick_left", INPUT_ACTION_LEFT)
-  inputBind("lstick_right", INPUT_ACTION_RIGHT)
-
-elseif PLATFORM == "gamecube" then
-  -- inputBind("start", INPUT_ACTION_RAGEQUIT)
-  -- inputBind("dpad_up", INPUT_ACTION_UP)
-  -- inputBind("dpad_down", INPUT_ACTION_DOWN)
-  -- inputBind("dpad_left", INPUT_ACTION_LEFT)
-  -- inputBind("dpad_right", INPUT_ACTION_RIGHT)
-  -- inputBind("button_b", INPUT_ACTION_CANCEL)
-  -- inputBind("button_a", INPUT_ACTION_ACCEPT)
-  -- inputBind("button_start", INPUT_ACTION_RAGEQUIT)
-  -- inputBind("lstick_up", INPUT_ACTION_UP)
-  -- inputBind("lstick_down", INPUT_ACTION_DOWN)
-  -- inputBind("lstick_left", INPUT_ACTION_LEFT)
-  -- inputBind("lstick_right", INPUT_ACTION_RIGHT)
-
-else
-  if INPUT_KEYBOARD then
-    inputBind("w", INPUT_ACTION_UP)
-    inputBind("s", INPUT_ACTION_DOWN)
-    inputBind("a", INPUT_ACTION_LEFT)
-    inputBind("d", INPUT_ACTION_RIGHT)
-
-    inputBind("left", INPUT_ACTION_LEFT)
-    inputBind("right", INPUT_ACTION_RIGHT)
-    inputBind("up", INPUT_ACTION_UP)
-    inputBind("down", INPUT_ACTION_DOWN)
-
-    inputBind("enter", INPUT_ACTION_ACCEPT)
-    inputBind("e", INPUT_ACTION_ACCEPT)
-    
-    inputBind("q", INPUT_ACTION_CANCEL)
-    
-    inputBind("escape", INPUT_ACTION_RAGEQUIT)
-  end 
-end
-
--- localeSet(DUSK_LOCALE_EN_US)
-sceneSet('scene/initial.dsf')

assets/locale/CMakeLists.txt

@@ -1,6 +0,0 @@
-# Copyright (c) 2025 Dominic Masters
-# 
-# This software is released under the MIT License.
-# https://opensource.org/licenses/MIT
-
-add_asset(LANGUAGE en_US.po)

assets/locale/en_US.po

@@ -1,15 +1,60 @@
-#
 msgid ""
 msgstr ""
-"Language: en_US\n"
+"Project-Id-Version: ExampleApp 1.0\n"
+"Language: en\n"
 "Content-Type: text/plain; charset=UTF-8\n"
-"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+"Plural-Forms: nplurals=4; plural=(n==1 ? 0 : n==2 ? 1 : (n<7 ? 2 : 3));\n"
 
-msgid "ui.test"
-msgstr "Hello this is a test."
+#: ui/menu.c:10
+msgid "ui.title"
+msgstr ""
+"Welcome"
 
-msgid "map.test"
-msgstr "This is a map test."
+#: ui/user.c:22
+msgid "ui.greeting"
+msgstr "Hello, %s!"
 
-msgid "test.test2"
-msgstr "This is another test."
+#: ui/files.c:40
+msgid "ui.file_status"
+msgstr "%s has %d files."
+
+#: ui/cart.c:55
+msgid "cart.item_count"
+msgid_plural "cart.item_count"
+msgstr[0] "%d item"
+msgstr[1] "%d items (dual)"
+msgstr[2] "%d items (few)"
+msgstr[3] "%d items (many)"
+
+#: ui/notifications.c:71
+msgid ""
+"ui.multiline_help"
+msgstr ""
+"Line one of the help text.\n"
+"Line two continues here.\n"
+"Line three ends here."
+
+#: ui/errors.c:90
+msgid ""
+"error.upload_failed.long"
+msgstr ""
+"Upload failed for file \"%s\".\n"
+"Please try again later or contact support."
+
+#: ui/messages.c:110
+msgid ""
+"user.invite_status"
+msgid_plural ""
+"user.invite_status"
+msgstr[0] ""
+"%s invited %d user.\n"
+"Please review the request."
+msgstr[1] ""
+"%s invited %d users (dual).\n"
+"Please review the requests."
+msgstr[2] ""
+"%s invited %d users (few).\n"
+"Please review the requests."
+msgstr[3] ""
+"%s invited %d users (many).\n"
+"Please review the requests."

assets/palette/CMakeLists.txt

@@ -1,6 +0,0 @@
-# Copyright (c) 2025 Dominic Masters
-# 
-# This software is released under the MIT License.
-# https://opensource.org/licenses/MIT
-
-add_asset(PALETTE palette0.png)

assets/scene/CMakeLists.txt

@@ -1,6 +0,0 @@
-# Copyright (c) 2025 Dominic Masters
-# 
-# This software is released under the MIT License.
-# https://opensource.org/licenses/MIT
-
-add_asset(SCRIPT initial.lua)

assets/scene/initial.lua

@@ -1,66 +0,0 @@
-module('spritebatch')
-module('camera')
-module('color')
--- module('ui')
-module('text')
-module('screen')
-module('time')
-module('map')
-module('glm')
-
-screenSetBackground(colorLime())
-mapCamera = cameraCreate()
-text = "Hello, Dusk!"
-
-x = -35
-y = 0
-
-function sceneDispose()
-end
-function sceneUpdate()
-end
-function sceneRender()
-  mapCamera.position = vec3(50, 50, 50)
-  cameraPushMatrix(mapCamera)
-  
-  textDraw(x, y, text, colorBlue())
-  
-  spriteBatchFlush()
-  cameraPopMatrix()
-end
-
-
--- screenSetBackground(colorBlack())
--- mapLoad('map/testmap/testmap.dmf')
--- camera = cameraCreate(CAMERA_PROJECTION_TYPE_ORTHOGRAPHIC)
--- mapCamera = cameraCreate()
-
--- text = "Hello World"
-
--- function sceneDispose()
--- end
-
--- function sceneUpdate()
--- end
-
--- function sceneRender()
---   -- Map Test
---   mapCamera.position = vec3(300, 300, 300)
---   cameraPushMatrix(mapCamera)
---   mapRender()
---   cameraPopMatrix()
-
---   -- UI Test
---   cameraPushMatrix(camera)
---   camera.bottom = screenGetHeight()
---   camera.right = screenGetWidth()
-
---   width, height = textMeasure(text)
---   x = (screenGetWidth() - width)
---   x = math.sin(TIME.time * 2) * (x / 2) + (x / 2)
---   y = (screenGetHeight() - height) / 2
---   y = math.cos(TIME.time * 3) * (y) + (y)
---   textDraw(x, y, text, colorMagenta())
-
---   cameraPopMatrix()
--- end

assets/testentity.js

@@ -0,0 +1,24 @@
+// Load rosa.
+Console.print('Asset time');
+const entry = Asset.lock('test.png', Asset.TYPE_TEXTURE, Texture.FORMAT_RGBA);
+Asset.requireLoaded(entry);
+Console.print('Asset loaded');
+
+// Camera at (3,3,3) looking at origin
+const cam = Entity.create();
+const camPos = cam.add(Component.POSITION);
+cam.add(Component.CAMERA);
+camPos.localPosition = new Vec3(3, 3, 3);
+camPos.lookAt(new Vec3(0, 0, 0));
+
+// Test entity at origin
+const testEntity = Entity.create();
+const testPos = testEntity.add(Component.POSITION);
+
+/** @type {RenderableSpritebatch} */
+const testRenderable = testEntity.add(Component.RENDERABLE);
+testRenderable.texture = entry.texture;
+testRenderable.sprites = [
+  [0, 0, 1, 1, 0, 1, 1, 0]
+];
+testPos.localPosition = new Vec3(0, 0, 0);

assets/tileset/prarie.tsx

@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<tileset version="1.10" tiledversion="1.11.2" name="prarie" tilewidth="16" tileheight="16" tilecount="21" columns="7">
- <image source="prarie.png" width="112" height="48"/>
-</tileset>