Technically working shaders.

.gitea/workflows/release.yml

@@ -0,0 +1,47 @@
+name: build-linux-glfw-x64
+on:
+  # ON tag
+  push:
+    tags:
+      - 'v*'
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+
+      - name: Install Dependencies
+        run: |
+          mkdir release
+          sudo apt-get update
+          sudo apt-get install -y \
+            build-essential \
+            cmake \
+            xorg-dev \
+            libglu1-mesa-dev \
+            libglfw3-dev \
+            libx11-dev \
+            libxkbcommon-dev \
+            python3-pil
+
+
+      - name: Build Linux GLFW x64
+        run: |
+          if [ -d "build" ]; then
+            rm -rf build
+          fi
+          mkdir build
+          mkdir release/linux-glfw-x64
+          cd build
+          cmake ..
+          make
+          cd ..
+          cp build/src/Dawn release/linux-glfw-x64/Dawn
+          cp build/dawn.tar release/linux-glfw-x64/dawn.tar
+
+      # - name: Release  
+      #   uses: akkuman/gitea-release-action@v1
+      #   with:
+      #     files: |-
+      #       release/

.github/workflows/build-helloworld-vita.yml

@@ -1,56 +0,0 @@
-name: build-helloworld-vita
-on:
-  push:
-    branches: [ master ]
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    env:
-      VITASDK: /usr/local/vitasdk
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-
-      - name: Cache VITASDK
-        id: cache-vitasdk-restore
-        uses: actions/cache/restore@v3
-        with:
-          path: /usr/local/vitasdk
-          key: ${{ runner.os }}-vitasdk
-
-      - name: Install Vita Toolchain
-        if: steps.cache-vitasdk.outputs.cache-hit != 'true'
-        run: ./ci/install-vita-toolchain.sh
-
-      - name: Save VITASDK
-        id: cache-vitasdk-save
-        uses: actions/cache/save@v3
-        with:
-          path: /usr/local/vitasdk
-          key: ${{ steps.cache-vitasdk-restore.outputs.cache-primary-key }}
-
-      - name: Install Libraries
-        run: ./ci/install-libraries.sh
-
-      - name: Build Tools
-        run: ./ci/build-tools.sh
-
-      - name: Build Game
-        run: |
-          export PATH=$VITASDK/bin:$PATH
-          mkdir build
-          cd build
-          cmake .. -DDAWN_BUILD_TARGET=target-helloworld-vita -DCMAKE_BUILD_TYPE=Debug
-          make
-
-      - name: Deploying
-        env:
-          DAWN_SSH_KEY: ${{ secrets.DAWN_SSH_KEY }}
-        run: |
-          mkdir -p ~/.ssh
-          echo -e "${DAWN_SSH_KEY}" > ~/.ssh/id_rsa
-          chmod og-rwx ~/.ssh/id_rsa
-          ssh-keyscan -H wish.moe >> ~/.ssh/known_hosts
-          ssh -t yourwishes@wish.moe "mkdir -p /home/yourwishes/Dawn/vita/debug"
-          scp ./build/src/dawnvita/HelloWorld.vpk yourwishes@wish.moe:/home/yourwishes/Dawn/vita/debug/

.github/workflows/build-liminal-glfw-linux64.yml

@@ -1,26 +0,0 @@
-name: build-liminal-glfw-linux64
-on:
-  push:
-    branches: [ master ]
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-
-      - name: Install Toolchain
-        run: ./ci/install-linux-toolchain.sh
-
-      - name: Install Libraries
-        run: ./ci/install-libraries.sh
-
-      - name: Build Tools
-        run: ./ci/build-tools.sh
-
-      - name: Build Game
-        run: |
-          mkdir build
-          cd build
-          cmake .. -DDAWN_BUILD_TARGET=target-liminial-linux64-glfw
-          make

.gitignore

@@ -86,6 +86,4 @@ assets/borrowed
 
 ._*
 
-*~
+*~
-
-archive/*

.gitmodules

@@ -1,24 +0,0 @@
-[submodule "lib/glfw"]
-	path = lib/glfw
-	url = https://github.com/glfw/glfw.git
-[submodule "lib/glm"]
-	path = lib/glm
-	url = https://github.com/g-truc/glm.git
-[submodule "lib/SDL"]
-	path = lib/SDL
-	url = https://github.com/libsdl-org/SDL.git
-[submodule "lib/openal-soft"]
-	path = lib/openal-soft
-	url = https://github.com/kcat/openal-soft
-[submodule "lib/AudioFile"]
-	path = lib/AudioFile
-	url = https://github.com/adamstark/AudioFile.git
-[submodule "lib/freetype"]
-	path = lib/freetype
-	url = https://gitlab.freedesktop.org/freetype/freetype.git
-[submodule "lib/libarchive"]
-	path = lib/libarchive
-	url = https://github.com/libarchive/libarchive
-[submodule "lib/boxer"]
-	path = lib/boxer
-	url = https://github.com/aaronmjacobs/Boxer

CMakeLists.txt

@@ -7,100 +7,37 @@ cmake_minimum_required(VERSION 3.13)
 set(CMAKE_C_STANDARD 99)
 set(CMAKE_C_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_STANDARD 20)
-set(CMAKE_CXX_STANDARD_REQUIRED True)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
-set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake/modules/")
-
-set(DAWN_PROJECT_NAME "Dawn")
-set(DAWN_PROJECT_VERSION "01.00")
 
 # Variable Caches
 set(DAWN_CACHE_TARGET "dawn-target")
-
+set(DAWN_TARGET_NAME "Dawn")
-# Build target
-if(DEFINED ENV{DAWN_BUILD_SYSTEM})
-  set(DAWN_BUILD_SYSTEM $ENV{DAWN_BUILD_SYSTEM} CACHE INTERNAL ${DAWN_CACHE_TARGET})
-else()
-  set(DAWN_BUILD_SYSTEM "linux" CACHE INTERNAL ${DAWN_CACHE_TARGET})
-endif()
-
-# Build tools specifics
-if(DAWN_BUILD_SYSTEM STREQUAL "vita")
-  if(NOT DEFINED CMAKE_TOOLCHAIN_FILE)
-    if(DEFINED ENV{VITASDK})
-      set(CMAKE_TOOLCHAIN_FILE "$ENV{VITASDK}/share/vita.toolchain.cmake" CACHE PATH "toolchain file")
-    else()
-      message(FATAL_ERROR "Please define VITASDK to point to your SDK path!")
-    endif()
-  endif()
-
-  include("$ENV{VITASDK}/share/vita.cmake" REQUIRED)
-
-  set(DAWN_VITA_APP_NAME "${DAWN_PROJECT_NAME}" CACHE INTERNAL ${DAWN_CACHE_TARGET})
-  set(DAWN_VITA_TITLEID  "YWSH00001" CACHE INTERNAL ${DAWN_CACHE_TARGET})
-  set(DAWN_VITA_VERSION  "${DAWN_PROJECT_VERSION}" CACHE INTERNAL ${DAWN_CACHE_TARGET})
-  set(VITA_MKSFOEX_FLAGS "${VITA_MKSFOEX_FLAGS} -d PARENTAL_LEVEL=1" CACHE INTERNAL ${DAWN_CACHE_TARGET})
-elseif(DAWN_BUILD_SYSTEM STREQUAL "psp")
-  if(NOT DEFINED CMAKE_TOOLCHAIN_FILE)
-    if(DEFINED ENV{PSPDEV})
-      set(CMAKE_TOOLCHAIN_FILE "$ENV{PSPDEV}/psp/share/pspdev.cmake" CACHE PATH "toolchain file")
-    else()
-      message(FATAL_ERROR "Please define PSPDEV to point to your SDK path!")
-    endif()
-  endif()
-
-  include("$ENV{PSPDEV}/psp/share/pspdev.cmake" REQUIRED)
-endif()
 
 # Set Common Build Variables
 set(DAWN_ROOT_DIR "${CMAKE_SOURCE_DIR}")
 set(DAWN_BUILD_DIR "${CMAKE_BINARY_DIR}")
 set(DAWN_SOURCES_DIR "${DAWN_ROOT_DIR}/src")
-set(DAWN_TEMP_DIR "${DAWN_BUILD_DIR}/temp")
 set(DAWN_TOOLS_DIR "${DAWN_ROOT_DIR}/tools")
-set(DAWN_ASSETS_DIR "${DAWN_ROOT_DIR}/assets")
+set(DAWN_ASSETS_SOURCE_DIR "${DAWN_ROOT_DIR}/assets")
 set(DAWN_ASSETS_BUILD_DIR "${DAWN_BUILD_DIR}/assets")
+set(DAWN_GENERATED_DIR "${DAWN_BUILD_DIR}/generated")
+set(DAWN_TEMP_DIR "${DAWN_BUILD_DIR}/temp")
 
-# Variables
+# Options
-set(DAWN_TARGET_NAME "Dawn" CACHE INTERNAL ${DAWN_CACHE_TARGET})
+option(DAWN_ENABLE_PHYSICS "Enable Physics" OFF)
-set(DAWN_ASSETS "" CACHE INTERNAL ${DAWN_CACHE_TARGET})
+option(DAWN_DEBUG_SHADERS "Enable Debug Shaders" ON)
-set(DAWN_BUILD_BINARY ${DAWN_BUILD_DIR}/Dawn CACHE INTERNAL ${DAWN_CACHE_TARGET})
 
 # Initialize Project First.
-project("${DAWN_PROJECT_NAME}"
+project(Dawn
-  VERSION "${DAWN_PROJECT_VERSION}"
+  VERSION 1.0.0
   LANGUAGES C CXX
 )
 
-add_executable(${DAWN_TARGET_NAME})
-
 # Add tools
 add_subdirectory(tools)
 
-# Libraries
+# Add Libraries
 add_subdirectory(lib)
 
-# Sources
+# Add Project Files
-add_subdirectory(src)
+add_subdirectory(src)
-
-# Append assets
-add_dependencies(${DAWN_TARGET_NAME} dawnassets)
-
-if(DAWN_BUILD_SYSTEM STREQUAL "vita")
-  vita_create_self(${DAWN_TARGET_NAME}.self ${DAWN_BUILD_BINARY})
-  vita_create_vpk(
-    ${DAWN_TARGET_NAME}.vpk
-    ${DAWN_VITA_TITLEID}
-    ${DAWN_TARGET_NAME}.self
-    VERSION ${DAWN_VITA_VERSION}
-    NAME ${DAWN_VITA_APP_NAME}
-  )
-elseif(DAWN_BUILD_SYSTEM STREQUAL "psp")
-  create_pbp_file(
-    TARGET ${PROJECT_NAME}
-    ICON_PATH NULL
-    BACKGROUND_PATH NULL
-    PREVIEW_PATH NULL
-    TITLE ${PROJECT_NAME}
-    VERSION ${DAWN_PROJECT_VERSION}
-  )
-endif()

archive/Shader.cpp

@@ -0,0 +1,8 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "Shader.hpp"
+
+using namespace Dawn;

archive/Shader.hpp

@@ -5,8 +5,9 @@
 
 #pragma once
 #include "display/shader/ShaderStage.hpp"
-#include "error/assert.hpp"
+#include "display/shader/IShader.hpp"
-#include "error/assertgl.hpp"
+#include "assert/assert.hpp"
+#include "assert/assertgl.hpp"
 #include "display/Color.hpp"
 #include "display/Texture.hpp"
 
@@ -20,22 +21,17 @@ namespace Dawn {
     GLSL_330_CORE
   };
 
-  class ShaderBase {
-
-  };
-
   template<typename T>
-  class Shader : public ShaderBase {
+  class Shader : public IShader<T> {
     private:
       std::vector<std::shared_ptr<ShaderStage>> stages;
       std::vector<struct ShaderParameter> parameters;
       std::vector<struct IShaderStructure> structures;
       enum ShaderOpenGLVariant variant;
+
       GLuint shaderProgram = -1;
 
     protected:
-      T data;
-
       /**
        * Overridable function to get the stages for the shader.
        * 
@@ -54,29 +50,11 @@ namespace Dawn {
       ) = 0;
 
     public:
-      /**
-       * Returns the currently uploaded data on the Shader.
-       * 
-       * @return The uploaded data.
-       */
-      T getData() {
-        return data;
-      }
-
-      /**
-       * Sets the entire data to be uploaded.
-       * 
-       * @param data Data to be uploaded.
-       */
-      void setData(const T data) {
-        this->data = data;
-      }
-
       /**
        * Initializes the shader, this needs to be called before the shader can
        * be used.
        */
-      void init() {
+      void init() override {
         // Determine which kind of OpenGL shader to use.
         variant = ShaderOpenGLVariant::GLSL_330_CORE;
 
@@ -109,6 +87,27 @@ namespace Dawn {
         assertNoGLError();
         assertTrue(status == GL_TRUE, "Failed to link shader program.");
 
+        std::vector<std::string> uniformNames;
+        GLint numUniforms = 0;
+
+        // Get the number of active uniforms
+        glGetProgramiv(shaderProgram, GL_ACTIVE_UNIFORMS, &numUniforms);
+        assertNoGLError();
+
+        // Iterate through each uniform
+        // for (GLint i = 0; i < numUniforms; ++i) {
+        //   char name[256];
+        //   GLsizei length;
+        //   GLint size;
+        //   GLenum type;
+
+        //   // Get the uniform name
+        //   glGetActiveUniform(shaderProgram, i, sizeof(name), &length, &size, &type, name);
+        //   assertNoGLError();
+        //   std::cout << "Uniform: " << i << ":" << name << std::endl;
+        //   // uniformNames.push_back(std::string(name));
+        // }
+
         // Map parameters correctly.
         std::for_each(
           parameters.begin(),
@@ -158,7 +157,7 @@ namespace Dawn {
        * Binds the shader as the current one, does not upload any data, somewhat
        * relies on something else uploading the data.
        */
-      void bind() {
+      void bind() override {
         glUseProgram(shaderProgram);
         assertNoGLError();
       }
@@ -166,7 +165,7 @@ namespace Dawn {
       /**
        * Uploads the data to the GPU.
        */
-      void upload() {
+      void upload() override {
         switch(this->variant) {
           case ShaderOpenGLVariant::GLSL_330_CORE:
             for(auto param : parameters) {
@@ -244,9 +243,6 @@ namespace Dawn {
         }
       }
 
-      /**
-       * Disposes of the shader.
-       */
       ~Shader() {
         // Delete the structures
         for(auto structure : structures) {
@@ -260,12 +256,4 @@ namespace Dawn {
         assertNoGLError();
       }
   };
-
-  /**
-   * Returns the size of the ShaderParameterType.
-   * 
-   * @param type The type to get the size of.
-   * @return Size of the type.
-   */
-  size_t shaderParameterTypeGetSize(const enum Dawn::ShaderParameterType type);
 }

archive/ShaderParameter.hpp

@@ -4,23 +4,10 @@
 // https://opensource.org/licenses/MIT
 
 #pragma once
-#include "dawn.hpp"
+#include "display/shader/IShader.hpp"
 #include "dawnopengl.hpp"
 
 namespace Dawn {
-  enum class ShaderParameterType {
-    VEC2,
-    VEC3,
-    VEC4,
-    MAT3,
-    MAT4,
-    COLOR,
-    FLOAT,
-    INT,
-    TEXTURE,
-    BOOLEAN
-  };
-
   struct ShaderParameter {
     std::string name;
     size_t offset;

archive/ShaderStage.cpp

@@ -0,0 +1,74 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "assert/assertgl.hpp"
+#include "assert/assert.hpp"
+#include "ShaderStage.hpp"
+
+using namespace Dawn;
+
+ShaderStage::ShaderStage(
+  const enum ShaderStageType type,
+  const std::string source
+) : IShaderStage(type) {
+  // Get OpenGL Shader Type
+  GLenum shaderType;
+  switch(this->type) {
+    case ShaderStageType::VERTEX:
+      shaderType = GL_VERTEX_SHADER;
+      break;
+
+    case ShaderStageType::FRAGMENT:
+      shaderType = GL_FRAGMENT_SHADER;
+      break;
+
+    // case ShaderStageType::COMPUTE:
+    //   shaderType = GL_COMPUTE;
+    //   break;
+
+    default:
+      assertUnreachable("Unknown ShaderStageType");
+  }
+
+  // Initialize the shader
+  this->id = glCreateShader(shaderType);
+  assertNoGLError();
+
+  // Compile the shader
+  auto cSource = source.c_str();
+  glShaderSource(this->id, 1, &cSource, NULL);
+  assertNoGLError();
+  glCompileShader(this->id);
+  assertNoGLError();
+  
+  // glShaderBinary(1, &this->id, GL_SHADER_BINARY_FORMAT_SPIR_V, source.data(), source.size());
+  // assertNoGLError();
+  // glSpecializeShader(this->id, "main", 0, NULL, NULL);
+  // assertNoGLError();
+
+  // Validate
+  GLint status;
+  glGetShaderiv(this->id, GL_COMPILE_STATUS, &status);
+  assertNoGLError();
+
+  if(!status) {
+    // Failed to compile
+    GLint logLength;
+    glGetShaderiv(this->id, GL_INFO_LOG_LENGTH, &logLength);
+    assertNoGLError();
+
+    GLchar *log = new GLchar[logLength];
+    glGetShaderInfoLog(this->id, logLength, NULL, log);
+    assertNoGLError();
+    assertUnreachable("Failed to compile shader stage %i:\n%s", type, log);
+  }
+}
+
+ShaderStage::~ShaderStage() {
+  if(this->id != -1) {
+    glDeleteShader(this->id);
+    assertNoGLError();
+  }
+}

archive/ShaderStage.hpp

@@ -0,0 +1,28 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "dawnopengl.hpp"
+#include "display/shader/IShaderStage.hpp"
+
+namespace Dawn {
+  class ShaderStage : public IShaderStage {
+    public:
+      GLuint id = -1;
+
+      /**
+       * Constructs a new ShaderStage.
+       * 
+       * @param type The type of shader this is.
+       * @param source The source code to compile.
+       */
+      ShaderStage(const enum ShaderStageType type, const std::string source);
+
+      /**
+       * Disposes of the shader stage.
+       */
+      ~ShaderStage();
+  };
+}

archive/ShaderStructure.hpp

@@ -39,6 +39,7 @@ namespace Dawn {
        * @param getParameters A callback that, when invoked, will populate the
        *                      parameters vector with the parameters for this
        *                      structure.
+       * @param count The number of structures to create.
        */
       ShaderStructure(
         const std::string &structureName,

archive/SimpleTexturedShader.cpp

@@ -0,0 +1,230 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "display/shader/SimpleTexturedShader.hpp"
+
+#include <fstream>
+#include "slang.h"
+#include "slang-gfx.h"
+using namespace slang;
+
+using namespace Dawn;
+
+void SimpleTexturedShader::getStages(
+  const enum ShaderOpenGLVariant variant,
+  const struct SimpleTexturedShaderData *rel,
+  std::vector<std::shared_ptr<ShaderStage>> &stages,
+  std::vector<struct ShaderParameter> &parameters,
+  std::vector<struct IShaderStructure> &structures
+) {
+  // Stages
+  std::shared_ptr<ShaderStage> vertex;
+  std::shared_ptr<ShaderStage> fragment;
+
+  std::string shader = R"(
+    cbuffer Uniforms {
+      float4x4 u_Projection;
+      float4x4 u_View;
+      float4x4 u_Model;
+      float4 u_Color;
+      bool u_HasTexture;
+      uniform Sampler2D u_Texture;
+    };
+
+    struct AssembledVertex {
+      float3 position : POSITION;
+      float2 texcoord : TEXCOORD;
+    };
+
+    struct Fragment {
+      float4 color;
+    };
+
+    struct VertexStageOutput {
+      float2 uv : UV;
+      float4 sv_position : SV_Position;
+    };
+
+    [shader("vertex")]
+    VertexStageOutput vertexMain(
+      AssembledVertex assembledVertex
+    ) {
+      VertexStageOutput output;
+
+      float3 position = assembledVertex.position;
+
+      output.uv = assembledVertex.texcoord;
+
+      output.sv_position = mul(
+        float4(position, 1.0),
+        mul(u_Model, mul(u_View, u_Projection))
+      );
+
+      return output;
+    }
+
+    [shader("fragment")]
+    Fragment fragmentMain(
+      float2 uv: UV
+    ) : SV_Target {
+      Fragment output;
+      if(u_HasTexture) {
+        output.color = u_Texture.Sample(uv) * u_Color;
+      } else {
+        output.color = u_Color;
+      }
+      return output;
+    }
+  )";
+  Slang::ComPtr<IGlobalSession> globalSession;
+  createGlobalSession(globalSession.writeRef());
+
+  SessionDesc sessionDesc;
+
+  TargetDesc targetDesc;
+  targetDesc.format = SLANG_GLSL;
+  targetDesc.profile = globalSession->findProfile("glsl_330");
+  sessionDesc.targets = &targetDesc;
+  sessionDesc.targetCount = 1;
+
+  Slang::ComPtr<IBlob> diagnostics;
+  const char* searchPaths[] = { "/home/yourwishes/htdocs/Dawn/assets/shaders/" };
+  sessionDesc.searchPaths = searchPaths;
+  sessionDesc.searchPathCount = 1;
+
+  Slang::ComPtr<ISession> session;
+  globalSession->createSession(sessionDesc, session.writeRef());
+  auto module = session->loadModuleFromSourceString(
+    "hello-world.slang",
+    "hello-world.slang",
+    shader.c_str(),
+    diagnostics.writeRef()
+  );
+  if(diagnostics) {
+    assertUnreachable("Failed to load module %s", (const char*) diagnostics->getBufferPointer());
+    return;
+  }
+
+  Slang::ComPtr<IEntryPoint> vertexEntryPoint;
+  Slang::ComPtr<IEntryPoint> fragEntryPoint;
+  module->findEntryPointByName("vertexMain", vertexEntryPoint.writeRef());
+  module->findEntryPointByName("fragmentMain", fragEntryPoint.writeRef());
+
+  IComponentType* components[] = { module, vertexEntryPoint, fragEntryPoint };
+  Slang::ComPtr<IComponentType> program;
+  session->createCompositeComponentType(
+    components,
+    sizeof(components) / sizeof(components[0]),
+    program.writeRef()
+  );
+
+  Slang::ComPtr<IComponentType> linkedProgram;
+  auto result = program->link(linkedProgram.writeRef(), diagnostics.writeRef());
+  std::cout << "Result: " << result << std::endl;
+  if(diagnostics) {
+    assertUnreachable("%s\n", (const char*) diagnostics->getBufferPointer());
+    return;
+  }
+
+  int entryPointIndex = 0;
+  int targetIndex = 0; // only one target
+  Slang::ComPtr<IBlob> vertexBlob;
+  result = linkedProgram->getEntryPointCode(
+    entryPointIndex,
+    targetIndex,
+    vertexBlob.writeRef(),
+    diagnostics.writeRef()
+  );
+  if(diagnostics) {
+    assertUnreachable("%s\n", (const char*) diagnostics->getBufferPointer());
+    return;
+  }
+
+  slang::ProgramLayout* layout = program->getLayout();
+  unsigned parameterCount = layout->getParameterCount();
+  for(unsigned pp = 0; pp < parameterCount; pp++) {
+    slang::VariableLayoutReflection* parameter = layout->getParameterByIndex(pp);
+    std::cout << "Parameter: " << parameter->getName() << std::endl;
+    
+    auto layout = parameter->getTypeLayout();
+    auto fields = layout->getFieldCount();
+    for(unsigned ff = 0; ff < fields; ff++) {
+      slang::VariableLayoutReflection* field = layout->getFieldByIndex(ff);
+      std::string fieldName = field->getName();
+      std::cout << "Field: " << fieldName << std::endl;
+    }
+  }
+
+  std::string vertexString = (const char*)vertexBlob->getBufferPointer();
+
+  entryPointIndex = 1;
+  Slang::ComPtr<IBlob> fragmentBlob;
+  result = linkedProgram->getEntryPointCode(
+    entryPointIndex,
+    targetIndex,
+    fragmentBlob.writeRef(),
+    diagnostics.writeRef()
+  );
+  if(diagnostics) {
+    assertUnreachable("%s\n", (const char*) diagnostics->getBufferPointer());
+    return;
+  }
+
+  std::string fragmentString = (const char*)fragmentBlob->getBufferPointer();
+
+  vertex = std::make_shared<ShaderStage>(
+    ShaderStageType::VERTEX, vertexString
+  );
+  stages.push_back(vertex);
+
+  fragment = std::make_shared<ShaderStage>(
+    ShaderStageType::FRAGMENT, fragmentString
+  );
+  stages.push_back(fragment);
+
+  structures.push_back(ShaderStructure<struct SimpleTexturedShaderDataSub>(
+    "block_SLANG_ParameterGroup_Uniforms_std140_0",
+    &rel->data,
+    ShaderOpenGLStructureType::STD140,
+    [](const SimpleTexturedShaderDataSub &data, std::vector<struct ShaderParameter> &parameters) {
+      parameters.push_back(ShaderParameter(
+        "u_Projection_0",
+        &data.projection,
+        ShaderParameterType::MAT4
+      ));
+
+      parameters.push_back(ShaderParameter(
+        "u_View_0",
+        &data.view,
+        ShaderParameterType::MAT4
+      ));
+
+      parameters.push_back(ShaderParameter(
+        "u_Model_0",
+        &data.model,
+        ShaderParameterType::MAT4
+      ));
+
+      parameters.push_back(ShaderParameter(
+        "u_Color_0",
+        &data.color,
+        ShaderParameterType::COLOR
+      ));
+
+      parameters.push_back(ShaderParameter(
+        "u_HasTexture_0",
+        &data.hasTexture,
+        ShaderParameterType::BOOLEAN
+      ));
+    }
+  ));
+
+  // Parameters
+  parameters.push_back(ShaderParameter(
+    "Uniforms_u_Texture_0",
+    &rel->texture,
+    ShaderParameterType::TEXTURE
+  ));
+}

archive/SimpleTexturedShader.hpp

@@ -7,12 +7,17 @@
 #include "display/shader/Shader.hpp"
 
 namespace Dawn {
-  struct SimpleTexturedShaderData {
+  struct SimpleTexturedShaderDataSub {
     glm::mat4 projection;
     glm::mat4 view;
     glm::mat4 model;
     struct Color color = COLOR_WHITE;
+
     bool hasTexture = false;
+  };
+
+  struct SimpleTexturedShaderData {
+    struct SimpleTexturedShaderDataSub data;
     shadertexturebinding_t texture = 0;
   };
 

archive/UIShader.cpp

@@ -0,0 +1,194 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "display/shader/UIShader.hpp"
+#include "util/Macro.hpp"
+
+using namespace Dawn;
+
+void UIShader::getStages(
+  const enum ShaderOpenGLVariant variant,
+  const struct UIShaderData *rel,
+  std::vector<std::shared_ptr<ShaderStage>> &stages,
+  std::vector<struct ShaderParameter> &parameters,
+  std::vector<struct IShaderStructure> &structures
+) {
+  // Stages
+  std::shared_ptr<ShaderStage> vertex;
+  std::shared_ptr<ShaderStage> fragment;
+
+  switch(variant) {
+    case ShaderOpenGLVariant::GLSL_330_CORE:
+      vertex = std::make_shared<ShaderStage>(
+        ShaderStageType::VERTEX,
+        "#version 330 core\n"
+        "layout (location = 0) in vec3 aPos;\n"
+        "layout (location = 1) in vec2 aTexCoord;\n"
+        "uniform mat4 u_Projection;\n"
+        "uniform mat4 u_View;\n"
+        "uniform mat4 u_Model;\n"
+        "struct UIShaderQuad {\n"
+          "vec4 quad;\n"
+          "vec4 uv;\n"
+          "vec4 color;\n"
+          "vec4 style;\n"
+        "};\n"
+        "layout (std140) uniform ub_Quad {\n"
+          "UIShaderQuad quads[" MACRO_STRINGIFY(UI_SHADER_QUAD_COUNT) "];\n"
+        "};\n"
+        "out vec2 v_TextCoord;\n"
+        "out vec4 v_Color;\n"
+        "out vec4 v_Style;\n"
+        "void main() {\n"
+          "vec4 pos;\n"
+          "vec2 coord;\n"
+          "int index = int(aPos.z);\n"
+          "int quadIndex = index / 4;\n"
+          "int vertexIndex = index % 4;\n"
+          "UIShaderQuad quad = quads[quadIndex];\n"
+          "if(vertexIndex == 0) {\n"
+            "pos.x = quad.quad.x;\n"
+            "pos.y = quad.quad.y;\n"
+            "coord.x = quad.uv.x;\n"
+            "coord.y = quad.uv.y;\n"
+          "} else if(vertexIndex == 1) {\n"
+            "pos.x = quad.quad.z;\n"
+            "pos.y = quad.quad.y;\n"
+            "coord.x = quad.uv.z;\n"
+            "coord.y = quad.uv.y;\n"
+          "} else if(vertexIndex == 2) {\n"
+            "pos.y = quad.quad.w;\n"
+            "pos.x = quad.quad.x;\n"
+            "coord.x = quad.uv.x;\n"
+            "coord.y = quad.uv.w;\n"
+          "} else if(vertexIndex == 3) {\n"
+            "pos.x = quad.quad.z;\n"
+            "pos.y = quad.quad.w;\n"
+            "coord.x = quad.uv.z;\n"
+            "coord.y = quad.uv.w;\n"
+          "}\n"
+          "pos.z = 0;\n"
+          "pos.w = 1;\n"
+          "gl_Position = u_Projection * u_View * u_Model * pos;\n"
+          "v_TextCoord = coord;\n"
+          "v_Color = quad.color;\n"
+          "v_Style = quad.style;\n"
+        "}"
+      );
+      
+      fragment = std::make_shared<ShaderStage>(
+        ShaderStageType::FRAGMENT,
+        "#version 330 core\n"
+        "in vec2 v_TextCoord;\n"
+        "in vec4 v_Color;\n"
+        "in vec4 v_Style;\n"
+        "uniform sampler2D u_Texture[" MACRO_STRINGIFY(UI_SHADER_TEXTURE_COUNT) "];\n"
+        "out vec4 o_Color;\n" 
+        "void main() {\n"
+          "vec4 texColor = vec4(1, 1, 1, 1);\n"
+          "int vStyle = int(round(v_Style[0]));\n"
+          "int vTextInd = int(round(v_Style[1]));\n"
+          "switch(vTextInd) {\n"
+            "case -1:\n"
+              "texColor = vec4(1, 1, 1, 1);\n"
+              "break;\n"
+            "case 0:\n"
+              "texColor = texture(u_Texture[0], v_TextCoord);\n"
+              "break;\n"
+            "case 1:\n"
+              "texColor = texture(u_Texture[1], v_TextCoord);\n"
+              "break;\n"
+            "case 2:\n"
+              "texColor = texture(u_Texture[2], v_TextCoord);\n"
+              "break;\n"
+            "case 3:\n"
+              "texColor = texture(u_Texture[3], v_TextCoord);\n"
+              "break;\n"
+            "case 4:\n"
+              "texColor = texture(u_Texture[4], v_TextCoord);\n"
+              "break;\n"
+            "case 5:\n"
+              "texColor = texture(u_Texture[5], v_TextCoord);\n"
+              "break;\n"
+          "}\n"
+          "switch(vStyle) {\n"
+            "case 0:\n"
+              "o_Color = texColor * v_Color;\n"
+              "break;\n"
+            "case 1:\n"
+              "o_Color.rgb = v_Color.rgb;\n"
+              "o_Color.a = texColor.r * v_Color.a;\n"
+              "break;\n"
+          "}\n"
+        "}\n"
+      );
+      break;
+
+    default:
+      assertUnreachable("Unsupported ShaderOpenGLVariant");
+  }
+
+  // Add stages
+  stages.push_back(vertex);
+  stages.push_back(fragment);
+
+  // Parameters
+  parameters.push_back(ShaderParameter(
+    "u_Projection",
+    &rel->projection,
+    ShaderParameterType::MAT4
+  ));
+
+  parameters.push_back(ShaderParameter(
+    "u_View",
+    &rel->view,
+    ShaderParameterType::MAT4
+  ));
+
+  parameters.push_back(ShaderParameter(
+    "u_Model",
+    &rel->model,
+    ShaderParameterType::MAT4
+  ));
+
+  parameters.push_back(ShaderParameter(
+    "u_Texture",
+    &rel->textures,
+    ShaderParameterType::TEXTURE,
+    UI_SHADER_TEXTURE_COUNT
+  ));
+  
+  structures.push_back(ShaderStructure<struct UIShaderQuad>(
+    "ub_Quad",
+    &rel->quads,
+    ShaderOpenGLStructureType::STD140,
+    [&](const struct UIShaderQuad &rel, std::vector<struct ShaderParameter> &parameters) {
+      parameters.push_back(ShaderParameter(
+        "quad",
+        &rel.quad,
+        ShaderParameterType::VEC4
+      ));
+
+      parameters.push_back(ShaderParameter(
+        "uv",
+        &rel.uv,
+        ShaderParameterType::VEC4
+      ));
+
+      parameters.push_back(ShaderParameter(
+        "color",
+        &rel.color,
+        ShaderParameterType::COLOR
+      ));
+
+      parameters.push_back(ShaderParameter(
+        "style",
+        &rel.style,
+        ShaderParameterType::VEC4
+      ));
+    },
+    UI_SHADER_QUAD_COUNT
+  ));
+}

archive/UIShader.hpp

@@ -0,0 +1,43 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "display/shader/Shader.hpp"
+
+namespace Dawn {
+  #define UI_SHADER_QUAD_COUNT 1024
+  #define UI_SHADER_TEXTURE_COUNT 16
+
+  enum class UIShaderQuadStyle {
+    TEXTURED = 0,
+    FONT = 1
+  };
+
+  struct UIShaderQuad {
+    glm::vec4 quad;
+    glm::vec4 uv;
+    struct Color color;
+    glm::vec4 style;
+  };
+  
+  struct UIShaderData {
+    glm::mat4 projection;
+    glm::mat4 view;
+    glm::mat4 model;
+    shadertexturebinding_t textures[UI_SHADER_TEXTURE_COUNT];
+    struct UIShaderQuad quads[UI_SHADER_QUAD_COUNT];
+  };
+
+  class UIShader : public Shader<UIShaderData> {
+    protected:
+      void getStages(
+        const enum ShaderOpenGLVariant variant,
+        const struct UIShaderData *rel,
+        std::vector<std::shared_ptr<ShaderStage>> &stages,
+        std::vector<struct ShaderParameter> &parameters,
+        std::vector<struct IShaderStructure> &structures
+      ) override;
+  };
+}

archive/component/ui/CMakeLists.txt

@@ -1,10 +1,9 @@
-# Copyright (c) 2023 Dominic Masters
+# Copyright (c) 2023 Dominic Masters
-# 
+# 
-# This software is released under the MIT License.
+# This software is released under the MIT License.
-# https://opensource.org/licenses/MIT
+# https://opensource.org/licenses/MIT
-
+
-# Sources
+target_sources(${DAWN_TARGET_NAME}
-target_sources(${DAWN_TARGET_NAME}
+  PRIVATE
-  PRIVATE
+    UICanvas.cpp
-    DawnGLFWHost.cpp
 )

archive/component/ui/UICanvas.cpp

@@ -0,0 +1,144 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "UICanvas.hpp"
+#include "display/pass/RenderPass.hpp"
+#include "display/mesh/QuadMesh.hpp"
+#include "ui/UIElement.hpp"
+
+using namespace Dawn;
+
+void UICanvas::onInit() {
+  mesh = std::make_shared<Mesh>();
+  mesh->createBuffers(
+    QUAD_VERTICE_COUNT * UI_SHADER_QUAD_COUNT,
+    QUAD_INDICE_COUNT * UI_SHADER_QUAD_COUNT
+  );
+
+  for(int32_t i = 0; i < UI_SHADER_QUAD_COUNT; i++) {
+    QuadMesh::bufferWithIndex(
+      mesh,
+      glm::vec4(0, 0, 1, 1),
+      glm::vec4(0, 0, 1, 1),
+      i * QUAD_VERTICE_COUNT,
+      i * QUAD_INDICE_COUNT,
+      i * QUAD_VERTICE_COUNT
+    );
+  }
+}
+
+void UICanvas::onDispose() {
+  mesh = nullptr;
+}
+
+std::vector<std::shared_ptr<IRenderPass>> UICanvas::getPasses(
+struct RenderPassContext &ctx
+) {
+  if(this->elements.empty()) return {};
+
+  glm::mat4 projection;
+  glm::mat4 view;
+  
+  // Setup the projection and views
+  data.projection = glm::ortho(
+    0.0f, ctx.renderTarget->getWidth(),
+    ctx.renderTarget->getHeight(), 0.0f,
+    0.0f, 1.0f
+  );
+  data.view = glm::mat4(1.0f);
+  data.model = glm::mat4(1.0f);
+
+  // Reset the passes
+  this->passes.clear();
+  this->textureBindings.clear();
+  this->textures.clear();
+  quadCount = 0;
+  nextBinding = 0;
+
+  // Alignment root
+  const glm::vec2 rootPosition = { 0, 0 };
+  const glm::vec2 rootSize = {
+    ctx.renderTarget->getWidth(),
+    ctx.renderTarget->getHeight()
+  };
+  const float_t rootScale = 1.0f;
+
+  // Get the quads for each component
+  auto itComponents = elements.begin();
+  auto self = std::ref(*this);
+  while(itComponents != elements.end()) {
+    auto component = *itComponents;
+    component->updateAlignment(rootPosition, rootSize, rootScale);
+    component->getQuads(self);
+    ++itComponents;
+  }
+
+  // Flush the remaining quads
+  flushPass();
+  return passes;
+}
+
+void UICanvas::addQuad(
+  const glm::vec4 quad,
+  const glm::vec4 uvs,
+  const struct Color color,
+  const enum UIShaderQuadStyle style,
+  const std::shared_ptr<Texture> text
+) {
+  glm::vec4 styleData;
+  styleData[0] = (float_t)style;
+
+  if(text == nullptr) {
+    styleData[1] = -1;
+  } else {
+    shadertexturebinding_t texture;
+    auto bindingIt = textureBindings.find(text);
+    if(bindingIt == textureBindings.end()) {
+      if(nextBinding >= UI_SHADER_TEXTURE_COUNT) {
+        flushPass();
+      }
+      textureBindings[text] = nextBinding;
+      textures[nextBinding] = text;
+      data.textures[nextBinding] = nextBinding;
+      texture = nextBinding++;
+    } else {
+      texture = bindingIt->second;
+    }
+    styleData[1] = (float_t)texture;
+  }
+
+  data.quads[quadCount] = {
+    quad,
+    uvs,
+    color,
+    styleData
+  };
+  quadCount++;
+  if(quadCount == UI_SHADER_QUAD_COUNT) flushPass();
+}
+
+void UICanvas::flushPass() {
+  if(quadCount == 0) return;
+
+  auto pass = createRenderPass<UIShader, UIShaderData>(
+    std::ref(*this),
+    data,
+    textures,
+    mesh,
+    MeshDrawMode::TRIANGLES,
+    0,
+    quadCount * QUAD_INDICE_COUNT
+  );
+  passes.push_back(pass);
+
+  quadCount = 0;
+  nextBinding = 0;
+  textures.clear();
+  textureBindings.clear();
+}
+
+void UICanvas::addElement(const std::shared_ptr<UIElement> element) {
+  elements.push_back(element);
+}

archive/component/ui/UICanvas.hpp

@@ -0,0 +1,73 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "scene/SceneItem.hpp"
+#include "component/display/IRenderableComponent.hpp"
+#include "display/shader/UIShader.hpp"
+
+namespace Dawn {
+  class UIElement;
+
+  class UICanvas :
+    public SceneComponent,
+    public IRenderableComponent
+  {
+    private:
+      std::shared_ptr<Mesh> mesh;
+      UIShaderData data;
+      std::vector<std::shared_ptr<UIElement>> elements;
+
+      size_t quadCount = 0;
+      shadertexturebinding_t nextBinding = 0;
+      std::unordered_map<
+        shadertexturebinding_t, std::shared_ptr<Texture>
+      > textures;
+      std::map<
+        std::shared_ptr<Texture>, shadertexturebinding_t
+      > textureBindings;
+      
+      std::vector<std::shared_ptr<IRenderPass>> passes;
+      
+    protected:
+      virtual void onInit() override;
+      virtual void onDispose() override;
+
+      /**
+       * Flushes all pending quads to the render pass. This doesn't actually
+       * render anything, it just flushes the data buffer to a new pass.
+       */
+      void flushPass();
+
+    public:
+      std::vector<std::shared_ptr<IRenderPass>> getPasses(
+        struct RenderPassContext &ctx
+      ) override;
+
+      /**
+       * Adds a quad to the canvas and performs a flush if necessary.
+       * 
+       * @param quad The quad to add.
+       * @param uvs The UVs to use for the quad.
+       * @param color The color to use for the quad.
+       * @param style Style that the quad should be rendered in.
+       * @param texture The texture to use for the quad, can be null.
+       */
+      void addQuad(
+        const glm::vec4 quad,
+        const glm::vec4 uvs,
+        const struct Color color,
+        const enum UIShaderQuadStyle style,
+        const std::shared_ptr<Texture> texture = nullptr
+      );
+
+      /**
+       * Adds a component to the canvas.
+       * 
+       * @param component The component to add.
+       */
+      void addElement(const std::shared_ptr<UIElement> component);
+  };
+}

archive/ui/CMakeLists.txt

@@ -0,0 +1,16 @@
+# Copyright (c) 2023 Dominic Masters
+# 
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+target_sources(${DAWN_TARGET_NAME}
+  PRIVATE
+    UIAlignableElement.cpp
+    UISubAlignableElement.cpp
+    UIElement.cpp
+    UIMenu.cpp
+)
+
+# Subdirs
+add_subdirectory(container)
+add_subdirectory(elements)

archive/ui/UIAlignableElement.cpp

@@ -0,0 +1,247 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "UIAlignableElement.hpp"
+
+using namespace Dawn;
+
+UIAlignableElement::UIAlignableElement() {
+  alignUnit[0] = UIAlignmentUnit::SCALE;
+  alignUnit[1] = UIAlignmentUnit::SCALE;
+  alignUnit[2] = UIAlignmentUnit::SCALE;
+  alignUnit[3] = UIAlignmentUnit::SCALE;
+
+  eventAlignmentUpdated = [&](const glm::vec2 p, const glm::vec2 s) {
+  };
+}
+
+void UIAlignableElement::updateSelfAlignment(
+  const glm::vec2 pPos,
+  const glm::vec2 pSize,
+  const float_t canvasScale
+) {
+  auto valueAxis = [&](
+    const enum UIAlignmentUnit unit,
+    const float_t alignment,
+    const float_t parentSize,
+    const float_t ratioSize,
+    const float_t contentSize
+  ) {
+    if(alignment == UI_ALIGN_SIZE_AUTO) return contentSize;
+
+    switch(unit) {
+      case UIAlignmentUnit::PIXEL:
+        return alignment;
+
+      case UIAlignmentUnit::SCALE:
+        return canvasScale * alignment;
+
+      case UIAlignmentUnit::PERCENT:
+        return parentSize * (alignment / 100.0f);
+
+      case UIAlignmentUnit::RATIO:
+        return (alignment / 100.0f) * ratioSize;
+      
+      default:
+        assertUnreachable("Invalid UIAlignmentType");
+        return 0.0f;
+    }
+  };
+
+  auto alignAxis = [&](
+    const enum UIAlignmentType type,
+    const enum UIAlignmentUnit unit0,
+    const enum UIAlignmentUnit unit1,
+    const float_t alignment0,
+    const float_t alignment1,
+    const float_t parentSize,
+    const float_t ratioSize,
+    const float_t contentSize,
+    float_t &outPosition,
+    float_t &outSize
+  ) {
+    switch(type) {
+      case UIAlignmentType::START:
+        outPosition = valueAxis(
+          unit0,
+          alignment0,
+          parentSize,
+          ratioSize,
+          contentSize
+        );
+        outSize = valueAxis(
+          unit1,
+          alignment1,
+          parentSize,
+          ratioSize,
+          contentSize
+        );
+        break;
+
+      case UIAlignmentType::MIDDLE:
+        outSize = valueAxis(
+          unit1,
+          alignment1,
+          parentSize,
+          ratioSize,
+          contentSize
+        );
+        outPosition = (parentSize / 2.0f) - (contentSize / 2.0f) + valueAxis(
+          unit0,
+          alignment0,
+          parentSize,
+          ratioSize,
+          contentSize
+        );
+        break;
+
+      case UIAlignmentType::END:
+        outSize = valueAxis(
+          unit0,
+          alignment0,
+          parentSize,
+          ratioSize,
+          contentSize
+        );
+        outPosition = parentSize - outSize - valueAxis(
+          unit1,
+          alignment1,
+          parentSize,
+          ratioSize,
+          contentSize
+        );
+        break;
+
+      case UIAlignmentType::STRETCH:
+        outPosition = valueAxis(
+          unit0,
+          alignment0,
+          parentSize,
+          ratioSize,
+          contentSize
+        );
+        outSize = parentSize - (outPosition + valueAxis(
+          unit1,
+          alignment1,
+          parentSize,
+          ratioSize,
+          contentSize
+        ));
+        break;
+
+      default:
+        assertUnreachable("Invalid UIAlignmentType");
+    }
+  };
+
+  bool_t heightFirst = (
+    alignUnit[0] == UIAlignmentUnit::RATIO ||
+    alignUnit[2] == UIAlignmentUnit::RATIO
+  );
+
+  if(heightFirst) {
+    // Align height first, this will define size.y which we can use as the ratio
+    // for the width/X axis alignment.
+    alignAxis(
+      alignY,
+      alignUnit[1],
+      alignUnit[3],
+      align[1],
+      align[3],
+      pSize.y,
+      0,
+      this->getContentHeight(),
+      position.y,
+      size.y
+    );
+    alignAxis(
+      alignX,
+      alignUnit[0],
+      alignUnit[2],
+      align[0],
+      align[2],
+      pSize.x,
+      size.y,
+      this->getContentWidth(),
+      position.x,
+      size.x
+    );
+  } else {
+    alignAxis(
+      alignX,
+      alignUnit[0],
+      alignUnit[2],
+      align[0],
+      align[2],
+      pSize.x,
+      0,
+      this->getContentWidth(),
+      position.x,
+      size.x
+    );
+    alignAxis(
+      alignY,
+      alignUnit[1],
+      alignUnit[3],
+      align[1],
+      align[3],
+      pSize.y,
+      size.x,
+      this->getContentHeight(),
+      position.y,
+      size.y
+    );
+  }
+
+  this->position += pPos;
+  this->eventAlignmentUpdated(position, size);
+}
+
+bool_t UIAlignableElement::hasExplicitWidth() {
+  if(size.x == 0.0f) return false;
+  if(
+    (alignX == UIAlignmentType::STRETCH) ||
+    (alignX == UIAlignmentType::END)
+  ) {
+    return align[0] != UI_ALIGN_SIZE_AUTO;
+  }
+  return align[2] != UI_ALIGN_SIZE_AUTO;
+}
+
+bool_t UIAlignableElement::hasExplicitHeight() {
+  if(size.y == 0.0f) return false;
+  if(
+    (alignY == UIAlignmentType::STRETCH) ||
+    (alignY == UIAlignmentType::END)
+  ) {
+    return align[1] != UI_ALIGN_SIZE_AUTO;
+  }
+  return align[3] != UI_ALIGN_SIZE_AUTO;
+}
+
+float_t UIAlignableElement::getWidth() {
+  if(hasExplicitWidth()) return size.x;
+  return getContentWidth();
+}
+
+float_t UIAlignableElement::getHeight() {
+  if(hasExplicitHeight()) return size.y;
+  return getContentHeight();
+}
+
+
+void UIAlignableElement::updateAlignment(
+  const glm::vec2 pPos,
+  const glm::vec2 pSize,
+  const float_t canvasScale
+) {
+  this->updateSelfAlignment(pPos, pSize, canvasScale);
+
+  // Now update children alignment
+  auto children = getChildren();
+  for(auto &c : children) {
+    c->updateAlignment(this->position, this->size, canvasScale);
+  }
+}

archive/ui/UIAlignableElement.hpp

@@ -0,0 +1,83 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "ui/UIElement.hpp"
+
+namespace Dawn {
+  #define UI_ALIGN_SIZE_AUTO -1.0f
+
+  enum class UIAlignmentType {
+    START,
+    MIDDLE,
+    END,
+    STRETCH
+  };
+
+  enum class UIAlignmentUnit {
+    PIXEL,
+    SCALE,
+    PERCENT,
+    RATIO
+  };
+
+  class UIAlignableElement : public UIElement {
+    protected:
+      glm::vec2 position;
+      glm::vec2 size;
+      
+      /**
+       * Updates the alignment of this element ONLY.
+       * 
+       * @param parentPosition The position of the parent.
+       * @param parentSize The size of the parent.
+       * @param canvasScale The scale of the canvas.
+       */
+      virtual void updateSelfAlignment(
+        const glm::vec2 parentPosition,
+        const glm::vec2 parentSize,
+        const float_t canvasScale
+      );
+
+      /**
+       * Returns true only if the width of this component is explicitly set.
+       * 
+       * @return True if the width of this component is explicitly set.
+       */
+      bool_t hasExplicitWidth();
+
+      /**
+       * Returns true only if the height of this component is explicitly set.
+       * 
+       * @return True if the height of this component is explicitly set.
+       */
+      bool_t hasExplicitHeight();
+
+    public:
+      // Primary alignment controls
+      glm::vec4 align = glm::vec4(0, 0, 0, 0);
+      enum UIAlignmentType alignX = UIAlignmentType::STRETCH;
+      enum UIAlignmentType alignY = UIAlignmentType::STRETCH;
+      enum UIAlignmentUnit alignUnit[4];
+      
+      std::function<
+        void(const glm::vec2, const glm::vec2)
+      > eventAlignmentUpdated;
+
+      /**
+       * Constructor for the UIAlignableElement.
+       */
+      UIAlignableElement();
+
+      float_t getWidth() override;
+      float_t getHeight() override;
+
+      void updateAlignment(
+        const glm::vec2 parentPosition,
+        const glm::vec2 parentSize,
+        const float_t canvasScale
+      ) override;
+  };
+}

archive/ui/UIElement.cpp

@@ -0,0 +1,53 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "UIElement.hpp"
+#include "assert/assert.hpp"
+
+using namespace Dawn;
+
+std::vector<std::shared_ptr<UIElement>> UIElement::getChildren() {
+  return {};
+}
+
+void UIElement::getSelfQuads(UICanvas &ctx) {
+  //Do nothing
+}
+
+float_t UIElement::getContentWidth() {
+  return 0.0f;
+}
+
+float_t UIElement::getContentHeight() {
+  return 0.0f;
+}
+
+float_t UIElement::getWidth() {
+  return this->getContentWidth();
+}
+
+float_t UIElement::getHeight() {
+  return this->getContentHeight();
+}
+
+void UIElement::getQuads(UICanvas &ctx) {
+  this->getSelfQuads(ctx);
+
+  auto children = getChildren();
+  for(auto &c : children) {
+    c->getQuads(ctx);
+  }
+}
+
+void UIElement::updateAlignment(
+  const glm::vec2 parentPosition,
+  const glm::vec2 parentSize,
+  const float_t canvasScale
+) {
+  auto children = getChildren();
+  for(auto &c : children) {
+    c->updateAlignment(parentPosition, parentSize, canvasScale);
+  }
+}

archive/ui/UIElement.hpp

@@ -0,0 +1,80 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "display/shader/UIShader.hpp"
+#include "component/ui/UICanvas.hpp"
+
+namespace Dawn {
+  class UIElement {
+    protected:
+      /**
+       * Virtual method overridden by the UIElement to get the quads for the
+       * component.
+       * 
+       * @param alignment The alignment of this component.
+       * @param ctx The canvas to add the quads to.
+       */
+      virtual void getSelfQuads(UICanvas &ctx);
+
+    public:
+      /**
+       * Overrided method by the UI Element that requests the minimum 
+       * width of the content.
+       * 
+       * @return The minimum width of the content.
+       */
+      virtual float_t getContentWidth();
+
+      /**
+       * Overrided method by the UI Element that requests the minimum 
+       * height of the content.
+       * 
+       * @return The minimum height of the content.
+       */
+      virtual float_t getContentHeight();
+
+      /**
+       * Returns the width of this component.
+       * 
+       * @return The width of this component.
+       */
+      virtual float_t getWidth();
+
+      /**
+       * Returns the height of this component.
+       * 
+       * @return The height of this component.
+       */
+      virtual float_t getHeight();
+
+      /**
+       * Virtual method overridden by the UIElement to get the children of
+       * this component.
+       */
+      virtual std::vector<std::shared_ptr<UIElement>> getChildren();
+
+      /**
+       * Method called by the UICanvas to get the quads for this component.
+       * 
+       * @param ctx The canvas to add the quads to.
+       */
+      void getQuads(UICanvas &ctx);
+
+      /**
+       * Updates the alignment of this component based on the parent. Typically
+       * left to the UIAlignableElement to implement, default implementation
+       * does nothing but invoke children.
+       * 
+       * @param parentPosition The position of the parent.
+       * @param parentSize The size of the parent.
+       */
+      virtual void updateAlignment(
+        const glm::vec2 parentPosition,
+        const glm::vec2 parentSize,
+        const float_t canvasScale
+      );
+  };
+}

archive/ui/UIMenu.cpp

@@ -0,0 +1,50 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "UIMenu.hpp"
+
+using namespace Dawn;
+
+void UIMenu::setPosition(int32_t x, int32_t y) {
+  assertTrue(x >= 0, "X position must be greater than or equal to 0.");
+  assertTrue(y >= 0, "Y position must be greater than or equal to 0.");
+  assertTrue(x < columns, "X must be less than the number of columns.");
+  assertTrue(y < rows, "Y must be less than the number of rows.");
+
+  if(this->x == x && this->y == y) return;
+
+  this->x = x;
+  this->y = y;
+
+  eventPositionChanged.emit(x, y);
+}
+
+void UIMenu::setSize(int32_t columns, int32_t rows) {
+  assertTrue(columns > 0, "Columns must be greater than 0.");
+  assertTrue(rows > 0, "Rows must be greater than 0.");
+  assertTrue(columns > x, "Columns must be greater than current x position.");
+  assertTrue(rows > y, "Rows must be greater than current y position.");
+
+  if(this->columns == columns && this->rows == rows) return;
+
+  this->columns = columns;
+  this->rows = rows;
+}
+
+int32_t UIMenu::getX() {
+  return x;
+}
+
+int32_t UIMenu::getY() {
+  return y;
+}
+
+int32_t UIMenu::getColumns() {
+  return columns;
+}
+
+int32_t UIMenu::getRows() {
+  return rows;
+}

archive/ui/UIMenu.hpp

@@ -0,0 +1,64 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "ui/UIElement.hpp"
+
+namespace Dawn {
+  class UIMenu final : public UIElement {
+    private:
+      int32_t x = 0;
+      int32_t y = 0;
+      int32_t columns = 1;
+      int32_t rows = 1;
+
+    public:
+      Event<int32_t, int32_t> eventPositionChanged;
+
+      /**
+       * Sets the position of this menu.
+       * 
+       * @param x The x position of this menu.
+       * @param y The y position of this menu.
+       */
+      void setPosition(int32_t x, int32_t y);
+
+      /**
+       * Sets the size of this menu.
+       * 
+       * @param columns The number of columns in this menu.
+       * @param rows The number of rows in this menu.
+       */
+      void setSize(int32_t columns, int32_t rows);
+
+      /**
+       * Gets the x position of this menu.
+       * 
+       * @return The x position of this menu.
+       */
+      int32_t getX();
+
+      /**
+       * Gets the y position of this menu.
+       * 
+       * @return The y position of this menu.
+       */
+      int32_t getY();
+
+      /**
+       * Gets the number of columns in this menu.
+       * 
+       * @return The number of columns in this menu.
+       */
+      int32_t getColumns();
+
+      /**
+       * Gets the number of rows in this menu.
+       * 
+       * @return The number of rows in this menu.
+       */
+      int32_t getRows();
+  };
+}

archive/ui/UISubAlignableElement.cpp

@@ -0,0 +1,68 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "UISubAlignableElement.hpp"
+
+using namespace Dawn;
+
+void UISubAlignableElement::updateAlignment(
+  const glm::vec2 parentPosition,
+  const glm::vec2 parentSize,
+  const float_t canvasScale
+) {
+  UIAlignableElement::updateAlignment(parentPosition, parentSize, canvasScale);
+  
+  switch(this->subAlignX) {
+    case UISubAlignment::START:
+      this->subAlignedPosition.x = this->position.x;
+      break;
+    
+    case UISubAlignment::MIDDLE:
+      this->subAlignedPosition.x = (
+        this->position.x +
+        (this->size.x / 2.0f) -
+        (this->getContentWidth() / 2.0f)
+      );
+      break;
+
+    case UISubAlignment::END:
+      this->subAlignedPosition.x = (
+        this->position.x +
+        this->size.x -
+        this->getContentWidth()
+      );
+      break;
+
+    default:
+      assertUnreachable("Unknown UISubAlignment!");
+  }
+
+  switch(this->subAlignY) {
+    case UISubAlignment::START:
+      this->subAlignedPosition.y = this->position.y;
+      break;
+    
+    case UISubAlignment::MIDDLE:
+      this->subAlignedPosition.y = (
+        this->position.y +
+        (this->size.y / 2.0f) -
+        (this->getContentHeight() / 2.0f)
+      );
+      break;
+
+    case UISubAlignment::END:
+      this->subAlignedPosition.y = (
+        this->position.y +
+        this->size.y -
+        this->getContentHeight()
+      );
+      break;
+
+    default:
+      assertUnreachable("Unknown UISubAlignment!");
+  }
+
+  this->eventSubAlignmentUpdated.emit(this->subAlignedPosition);
+}

archive/ui/UISubAlignableElement.hpp

@@ -0,0 +1,32 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "ui/UIAlignableElement.hpp"
+
+namespace Dawn {
+  enum class UISubAlignment {
+    START,
+    MIDDLE,
+    END
+  };
+
+  class UISubAlignableElement : public UIAlignableElement {
+    protected:
+      glm::vec2 subAlignedPosition;
+
+    public:
+      Event<glm::vec2> eventSubAlignmentUpdated;
+
+      enum UISubAlignment subAlignX = UISubAlignment::START;
+      enum UISubAlignment subAlignY = UISubAlignment::START;
+
+      void updateAlignment(
+        const glm::vec2 parentPosition,
+        const glm::vec2 parentSize,
+        const float_t canvasScale
+      ) override;
+  };
+}

archive/ui/container/CMakeLists.txt

@@ -0,0 +1,12 @@
+# Copyright (c) 2023 Dominic Masters
+# 
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+target_sources(${DAWN_TARGET_NAME}
+  PRIVATE
+    UIColumnContainer.cpp
+    UIContainer.cpp
+    UIPaddingContainer.cpp
+    UIRowContainer.cpp
+)

archive/ui/container/UIColumnContainer.cpp

@@ -0,0 +1,36 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "assert/assert.hpp"
+#include "UIColumnContainer.hpp"
+
+using namespace Dawn;
+
+void UIColumnContainer::updateAlignment(
+  const glm::vec2 parentPosition,
+  const glm::vec2 parentSize,
+  const float_t canvasScale
+) {
+  this->updateSelfAlignment(parentPosition, parentSize, canvasScale);
+
+  // Now we have our dimensions, divide evenly
+  auto children = this->getChildren();
+
+  float_t x = 0.0f;
+  float_t xPiece = this->size.x / (float_t)children.size();
+  
+  // Update all children
+  for(auto &child : children) {
+    child->updateAlignment(
+      this->position + glm::vec2(x, 0),
+      glm::vec2(
+        xPiece,
+        this->size.y
+      ),
+      canvasScale
+    );
+    x += xPiece;
+  }
+}

archive/ui/container/UIColumnContainer.hpp

@@ -0,0 +1,18 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "ui/container/UIContainer.hpp"
+
+namespace Dawn {
+  class UIColumnContainer final : public UIContainer {
+    public:
+      void updateAlignment(
+        const glm::vec2 parentPosition,
+        const glm::vec2 parentSize,
+        const float_t canvasScale
+      ) override;
+  };
+}

archive/ui/container/UIContainer.cpp

@@ -0,0 +1,47 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "assert/assert.hpp"
+#include "UIContainer.hpp"
+
+using namespace Dawn;
+
+std::vector<std::shared_ptr<UIElement>> UIContainer::getChildren() {
+  return this->children;
+}
+
+float_t UIContainer::getContentWidth() {
+  float_t width = 0;
+  auto children = this->getChildren();
+  for(auto child : children) {
+    width = Math::max(width, child->getWidth());
+  }
+  return width;
+}
+
+float_t UIContainer::getContentHeight() {
+  float_t height = 0;
+  auto children = this->getChildren();
+  for(auto child : children) {
+    height = Math::max(height, child->getHeight());
+  }
+  return height;
+}
+
+void UIContainer::appendChild(std::shared_ptr<UIElement> child) {
+  assertNotNull(child, "Cannot append a null child!");
+  this->children.push_back(child);
+}
+
+void UIContainer::removeChild(std::shared_ptr<UIElement> child) {
+  assertNotNull(child, "Cannot remove a null child!");
+  auto it = std::find(this->children.begin(), this->children.end(), child);
+  if(it == this->children.end()) return;
+  this->children.erase(it);
+}
+
+void UIContainer::clearChildren() {
+  this->children.clear();
+}

archive/ui/container/UIContainer.hpp

@@ -0,0 +1,39 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "ui/UIAlignableElement.hpp"
+
+namespace Dawn {
+  class UIContainer : public UIAlignableElement {
+    private:
+      std::vector<std::shared_ptr<UIElement>> children;
+
+    public:
+      std::vector<std::shared_ptr<UIElement>> getChildren() override;
+
+      float_t getContentWidth() override;
+      float_t getContentHeight() override;
+      
+      /**
+       * Appends a child to this container.
+       * 
+       * @param child Child to append.
+       */
+      void appendChild(std::shared_ptr<UIElement> child);
+
+      /**
+       * Removes a child from this container.
+       * 
+       * @param child Child to remove.
+       */
+      void removeChild(std::shared_ptr<UIElement> child);
+
+      /**
+       * Removes all children from this container.
+       */
+      void clearChildren();
+  };
+}

archive/ui/container/UIPaddingContainer.cpp

@@ -0,0 +1,38 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "UIPaddingContainer.hpp"
+
+using namespace Dawn;
+
+float_t UIPaddingContainer::getContentWidth() {
+  float_t width = 0.0f;
+  for(auto &child : getChildren()) {
+    width = Math::max(width, child->getWidth());
+  }
+  return width + padding.x + padding.z;
+}
+
+float_t UIPaddingContainer::getContentHeight() {
+  float_t height = 0.0f;
+  for(auto &child : getChildren()) {
+    height = Math::max(height, child->getHeight());
+  }
+  return height + padding.y + padding.w;
+}
+
+void UIPaddingContainer::updateAlignment(
+  const glm::vec2 parentPosition,
+  const glm::vec2 parentSize,
+  const float_t canvasScale
+) {
+  glm::vec2 childPosition = parentPosition + glm::vec2(padding.x, padding.y);
+  glm::vec2 childSize = parentSize - glm::vec2(padding.x + padding.z, padding.y + padding.w);
+
+  auto children = getChildren();
+  for(auto &child : children) {
+    child->updateAlignment(childPosition, childSize, canvasScale);
+  }
+}

archive/ui/container/UIPaddingContainer.hpp

@@ -0,0 +1,22 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "ui/container/UIContainer.hpp"
+
+namespace Dawn {
+  class UIPaddingContainer final : public UIContainer {
+    public:
+      glm::vec4 padding = { 0, 0, 0, 0 };
+
+      float_t getContentWidth() override;
+      float_t getContentHeight() override;
+      void updateAlignment(
+        const glm::vec2 parentPosition,
+        const glm::vec2 parentSize,
+        const float_t canvasScale
+      ) override;
+  };
+}

archive/ui/container/UIRowContainer.cpp

@@ -0,0 +1,51 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "UIRowContainer.hpp"
+
+using namespace Dawn;
+
+float_t UIRowContainer::getContentWidth() {
+  float_t width = 0.0f;
+  for(auto &child : this->getChildren()) {
+    width = Math::max(width, child->getWidth());
+  }
+  return width;
+}
+
+float_t UIRowContainer::getContentHeight() {
+  float_t height = 0.0f;
+  for(auto &child : this->getChildren()) {
+    height += child->getHeight();
+  }
+  return height;
+}
+
+void UIRowContainer::updateAlignment(
+  const glm::vec2 parentPosition,
+  const glm::vec2 parentSize,
+  const float_t canvasScale
+) {
+  this->updateSelfAlignment(parentPosition, parentSize, canvasScale);
+
+  // Now we have our dimensions, divide evenly
+  auto children = this->getChildren();
+
+  float_t y = 0.0f;
+  float_t yPiece = this->size.y / (float_t)children.size();
+  
+  // Update all children
+  for(auto &child : children) {
+    child->updateAlignment(
+      this->position + glm::vec2(0, y),
+      glm::vec2(
+        this->size.x,
+        yPiece
+      ),
+      canvasScale
+    );
+    y += yPiece;
+  }
+}

archive/ui/container/UIRowContainer.hpp

@@ -0,0 +1,20 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "ui/container/UIContainer.hpp"
+
+namespace Dawn {
+  class UIRowContainer final : public UIContainer {
+    public:
+      float_t getContentWidth() override;
+      float_t getContentHeight() override;
+      void updateAlignment(
+        const glm::vec2 parentPosition,
+        const glm::vec2 parentSize,
+        const float_t canvasScale
+      ) override;
+  };
+}

archive/ui/elements/CMakeLists.txt

@@ -0,0 +1,10 @@
+# Copyright (c) 2023 Dominic Masters
+# 
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+target_sources(${DAWN_TARGET_NAME}
+  PRIVATE
+    UILabel.cpp
+    UIRectangle.cpp
+)

archive/ui/elements/UILabel.cpp

@@ -0,0 +1,175 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "UILabel.hpp"
+
+using namespace Dawn;
+
+void UILabel::getSelfQuads(UICanvas &ctx) {
+  std::vector<struct UIShaderQuad> quads;
+  if(this->texture == nullptr || this->text.empty()) return;
+
+  glm::vec4 quad;
+  glm::vec2 pos = glm::vec2(0, this->texture->fontSize);
+  bool_t lastCharWasSpace = false;
+
+  for(size_t i = 0; i < text.size(); i++) {
+    wchar_t c = text[i];
+    auto info = texture->getCharacterData(c);
+
+    // Newline(s)
+    if(c == L'\n') {
+      pos.x = 0;
+      pos.y += this->texture->fontSize;
+      continue;
+    }
+
+    // Spaces
+    if(c == L' ') {
+      pos.x += info.advance.x;
+      lastCharWasSpace = true;
+      continue;
+    }
+
+    // Word Wrap
+    if(wordWrap) {
+      if(lastCharWasSpace) {
+        // Scan ahead to next space
+        float_t wordWidth = pos.x;// Start at current position and scan ahead.
+        for(size_t j = i; j < text.size(); j++) {
+          wchar_t c2 = text[j];
+          if(c2 == L' ' || c2 == L'\n') {
+            break;// If we hit another space, we are OK.
+          }
+
+          // Will this character fit on the row? If not the whole word will wrap.
+          auto info2 = texture->getCharacterData(c);
+          wordWidth += info.advance.x;
+          if(wordWidth > size.x) {
+            pos.x = 0;
+            pos.y += this->texture->fontSize;
+            break;
+          }
+        }
+
+        lastCharWasSpace = false;
+      }
+    // } else if(pos.x + info.size.x > subAlignedPosition.x + size.x) {
+    //   // Not word wrap, but instead just overflow characters.
+    //   pos.x = 0;
+    //   pos.y += this->texture->fontSize;
+    }
+
+    ctx.addQuad(
+      {
+        subAlignedPosition.x + pos.x + info.offset.x,
+        subAlignedPosition.y + pos.y + info.offset.y,
+        subAlignedPosition.x + pos.x + info.size.x + info.offset.x,
+        subAlignedPosition.y + pos.y + info.size.y + info.offset.y
+      },
+      {
+        info.quad.x,
+        info.quad.y,
+        info.quad.z,
+        info.quad.w
+      },
+      this->color,
+      UIShaderQuadStyle::FONT,
+      texture->texture
+    );
+    pos += info.advance;
+  }
+}
+
+float_t UILabel::getContentWidth() {
+  if(this->texture == nullptr || this->text.empty()) return 0.0f;
+
+  float_t lineWidth = 0.0f;
+  float_t width = 0.0f;
+  for(wchar_t c : text) {
+    if(c == L'\n') {
+      width = Math::max<float_t>(width, lineWidth);
+      lineWidth = 0.0f;
+      continue;
+    }
+
+    auto info = texture->getCharacterData(c);
+    lineWidth += info.advance.x;
+    if(
+      this->hasExplicitWidth() &&
+      lineWidth >= size.x
+    ) return size.x;
+  }
+  width = Math::max<float_t>(width, lineWidth);
+  return width;
+}
+
+float_t UILabel::getContentHeight() {
+  if(this->texture == nullptr || this->text.empty()) return 0.0f;
+
+  float_t height = this->texture->fontSize;
+  float_t lineWidth = 0.0f;
+  bool_t lastCharWasSpace = false;
+
+  for(wchar_t c : text) {
+    if(c == L'\n') {
+      height += this->texture->fontSize;
+      continue;
+    }
+
+    auto info = texture->getCharacterData(c);
+
+    if(c == L' ') {
+      lineWidth += info.advance.x;
+      lastCharWasSpace = true;
+      continue;
+    }
+
+    if(wordWrap) {
+      if(lastCharWasSpace) {
+        // Scan ahead to next space
+        float_t wordWidth = lineWidth;// Start at current position and scan ahead.
+        for(size_t j = 0; j < text.size(); j++) {
+          wchar_t c2 = text[j];
+          if(c2 == L' ' || c2 == L'\n') {
+            break;// If we hit another space, we are OK.
+          }
+
+          // Will this character fit on the row? If not the whole word will wrap.
+          auto info2 = texture->getCharacterData(c);
+          wordWidth += info.advance.x;
+          if(wordWidth > size.x) {
+            height += this->texture->fontSize;
+            lineWidth = 0.0f;
+            break;
+          }
+        }
+
+        lastCharWasSpace = false;
+      }
+    // } else if(lineWidth + info.size.x > size.x) {
+    //   height += this->texture->fontSize;
+    //   lineWidth = 0.0f;
+    }
+  }
+
+  return height;
+}
+
+std::shared_ptr<TrueTypeTexture> UILabel::getFont() {
+  return this->texture;
+}
+
+std::wstring UILabel::getText() {
+  return this->text;
+}
+
+void UILabel::setFont(std::shared_ptr<TrueTypeTexture> texture) {
+  this->texture = texture;
+}
+
+void UILabel::setText(const std::wstring &text) {
+  this->text = text;
+}

archive/ui/elements/UILabel.hpp

@@ -0,0 +1,54 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "ui/UISubAlignableElement.hpp"
+#include "display/font/TrueTypeTexture.hpp"
+
+namespace Dawn {
+  class UILabel final : public UISubAlignableElement {
+    private:
+      std::shared_ptr<TrueTypeTexture> texture = nullptr;
+      std::wstring text = L"Hello World";
+
+    protected:
+      void getSelfQuads(UICanvas &ctx) override;
+
+    public:
+      bool_t wordWrap = true;
+      struct Color color = COLOR_WHITE;
+
+      float_t getContentWidth() override;
+      float_t getContentHeight() override;
+
+      /**
+       * Returns the font used for this label.
+       * 
+       * @return The font used for this label.
+       */
+      std::shared_ptr<TrueTypeTexture> getFont();
+
+      /**
+       * Returns the text used for this label.
+       * 
+       * @return The text used for this label.
+       */
+      std::wstring getText();
+
+      /**
+       * Sets the font to use for this label.
+       * 
+       * @param texture TrueType texture to use for this label.
+       */
+      void setFont(std::shared_ptr<TrueTypeTexture> texture);
+
+      /**
+       * Sets the text to use for this label.
+       * 
+       * @param text The text to use for this label.
+       */
+      void setText(const std::wstring &text);
+  };
+}

archive/ui/elements/UIRectangle.cpp

@@ -0,0 +1,19 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "UIRectangle.hpp"
+
+using namespace Dawn;
+
+void UIRectangle::getSelfQuads(UICanvas &ctx) {
+  std::vector<struct UIShaderQuad> quads;
+  ctx.addQuad(
+    glm::vec4(position, position + size),
+    uv,
+    color,
+    UIShaderQuadStyle::TEXTURED,
+    texture
+  );
+}

archive/ui/elements/UIRectangle.hpp

@@ -0,0 +1,19 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "ui/UIAlignableElement.hpp"
+
+namespace Dawn {
+  class UIRectangle final : public UIAlignableElement {
+    protected:
+      void getSelfQuads(UICanvas &ctx) override;
+
+    public:
+      struct Color color = COLOR_WHITE;
+      std::shared_ptr<Texture> texture = nullptr;
+      glm::vec4 uv = glm::vec4(0,0,1,1);
+  };
+}

assets/en.json

@@ -0,0 +1,42 @@
+{
+  "main_menu": {
+    "new_game": "New Game",
+    "load_game": "Load Game",
+    "options": "Options",
+    "exit": "Exit"
+  },
+  "tiles": {
+    "water": {
+      "interact": "A refreshing body of water."
+    },
+    "lamp": {
+      "interact": "An electric lamp.\nA real lightbulb idea."
+    },
+    "rail": {
+      "interact": "Train tracks.\n...Better not cross them."
+    }
+  },
+  "entities": {
+    "sign": {
+      "name": "Sign"
+    }
+  },
+  "maps": {
+    "testmap": {
+      "bob": "Hello, I am Bob.",
+      "sign": "This is a sign.",
+      "sign2": {
+        "1": "This is another sign.",
+        "2": "It has two lines."
+      }
+    },
+    "train_station": {
+      "stair_sign": {
+        "0": "Stairs slippery when wet.\n\n<- West to Town.\n-> East to lakefront."
+      }
+    }
+  },
+  "battle": {
+    "start": "Battle Start!"
+  }
+}

assets/maps/testmap.json

@@ -0,0 +1,8 @@
+{
+  "name": "Test Map",
+  "layers": [
+    {
+
+    }
+  ]
+}

assets/materials/simple-textured.json

@@ -0,0 +1,8 @@
+{
+  "assets": {
+    "simpleTexturedShader": {
+      "type": "shader",
+      "path": "shaders/simple-textured.shader"
+    }
+  }
+}

assets/prefabs/npc.json

@@ -0,0 +1,26 @@
+{
+  "name": "Rosa",
+  
+  "assets": {
+    "rosa": {
+      "type": "texture",
+      "path": "rosa.texture"
+    }
+  },
+
+  "components": {
+    "mesh": {
+      "type": "QuadMesh"
+    },
+    "material": {
+      "type": "SimpleTexturedMaterial",
+      "texture": "rosa"
+    },
+    "meshRenderer": {
+      "type": "MeshRenderer"
+    },
+    "entity": {
+      "type": "RPGEntity"
+    }
+  }
+}

assets/prefabs/rosa.json

@@ -0,0 +1,29 @@
+{
+  "name": "Rosa",
+  
+  "assets": {
+    "rosa": {
+      "type": "texture",
+      "path": "rosa.texture"
+    }
+  },
+
+  "components": {
+    "mesh": {
+      "type": "QuadMesh"
+    },
+    "material": {
+      "type": "SimpleTexturedMaterial",
+      "texture": "rosa"
+    },
+    "meshRenderer": {
+      "type": "MeshRenderer"
+    },
+    "entity": {
+      "type": "RPGEntity"
+    },
+    "player": {
+      "type": "RPGPlayer"
+    }
+  }
+}

assets/scenes/test_rpg_scene.json

@@ -0,0 +1,47 @@
+{
+  "name": "Test RPG Scene",
+  
+  "assets": {
+    "rosa": {
+      "type": "prefab",
+      "path": "prefabs/rosa.json"
+    },
+    "npc": {
+      "type": "prefab",
+      "path": "prefabs/npc.json"
+    },
+    "rosatext": {
+      "type": "texture",
+      "path": "rosa.texture"
+    },
+    "simpleTexturedShader": {
+      "type": "shader",
+      "path": "shaders/simple-textured.slang"
+    }
+  },
+
+  "items": {
+    "camera": {
+      "components": {
+        "camera": {
+          "type": "camera"
+        }
+      }
+    },
+
+    "rosa": {
+      "prefab": "rosa",
+      "position": [ 0, 0, 0 ],
+      "components": {
+        "player": {
+          "camera": "camera"
+        }
+      }
+    },
+
+    "npc": {
+      "prefab": "npc",
+      "position": [ 32, 0, 0 ]
+    }
+  }
+}

assets/shaders/simple-textured.slang

@@ -0,0 +1,53 @@
+uniform float4x4 projection;
+uniform float4x4 view;
+uniform float4x4 model;
+uniform float4 color;
+uniform bool hasTexture;
+uniform Sampler2D texture;
+
+struct AssembledVertex {
+  float3 position : POSITION;
+  float2 texcoord : TEXCOORD;
+};
+
+struct Fragment {
+  float4 color;
+};
+
+struct VertexStageOutput {
+  float2 uv : UV;
+  float4 sv_position : SV_Position;
+};
+
+[shader("vertex")]
+VertexStageOutput vertexMain(
+  AssembledVertex assembledVertex
+) {
+  VertexStageOutput output;
+
+  float3 position = assembledVertex.position;
+
+  output.uv = assembledVertex.texcoord;
+
+  output.sv_position = mul(
+    float4(position, 1.0),
+    mul(model, mul(view, projection))
+  );
+
+  return output;
+}
+
+[shader("fragment")]
+Fragment fragmentMain(
+  float2 uv: UV
+) : SV_Target {
+  Fragment output;
+  
+  if (hasTexture) {
+    output.color = texture.Sample(uv) * color;
+  } else {
+    output.color = color;
+  }
+  
+  return output;
+}

ci/linux-x64/Dockerfile

@@ -1,3 +0,0 @@
-FROM debian:latest
-RUN apt update && apt upgrade -y && apt install -y git cmake build-essential libx11-dev libgtk-3-dev python3 python3-pip
-RUN ln -s /usr/bin/python3 /usr/bin/python

ci/linux-x64/docker-compose.yml

@@ -1,18 +0,0 @@
-services:
-  dawn-linux64:
-    build: .
-    volumes:
-      - ./../../:/Dawn
-    working_dir: /Dawn
-    command:
-      - /bin/sh
-      - -c
-      - |
-        ln -s /usr/bin/python3 /usr/bin/python
-        if [ ! -d ./lib/glfw ]; then
-          git submodule update --init
-        fi
-        mkdir -p ./build/linux-x64
-        cd ./build/linux-x64
-        cmake ../.. -DDAWN_BUILD_SYSTEM=linux -DGLFW_BUILD_X11=ON -DGLFW_BUILD_WAYLAND=OFF
-        make

ci/psp/Dockerfile

@@ -1,3 +0,0 @@
-FROM pspdev/pspdev
-RUN apk add --update --no-cache python3 && ln -sf python3 /usr/bin/python
-RUN psp-pacman -Sy pspgl glm

ci/psp/docker-compose.yml

@@ -1,14 +0,0 @@
-services:
-  dawn-psp:
-    build: .
-    volumes:
-      - ./../../:/Dawn
-    working_dir: /Dawn
-    command:
-      - /bin/bash
-      - -c
-      - |
-        mkdir -p ./build/psp
-        cd ./build/psp
-        psp-cmake ../.. -DDAWN_BUILD_SYSTEM=psp -DCMAKE_BUILD_TYPE=Debug
-        make

ci/vita/docker-compose.yml

@@ -1,15 +0,0 @@
-services:
-  dawn-vita:
-    image: gnuton/vitasdk-docker
-    volumes:
-      - ./../../:/Dawn
-    working_dir: /Dawn
-    command:
-      - /bin/bash
-      - -c
-      - |
-        rm -rf ./build/vita
-        mkdir -p ./build/vita
-        cd ./build/vita
-        cmake ../.. -DDAWN_BUILD_SYSTEM=vita -DCMAKE_BUILD_TYPE=Debug
-        make

docs/COMPILING.md

@@ -1,340 +0,0 @@
-# Compiling, Debugging and Running
-This document's purpose is to explain how to compile, debug and run the project
-on your machine. It is assumed that you have a basic understanding of the
-fundamentals of your operating system and how to use a terminal.
-
-## Preamble
-The Dawn project is written almost entirely in C and C++. This includes all of
-the tooling used to generate the project and assets. The only non-C/C++ code is
-used by CMake to generate the output compilation files. This provides the Dawn
-project an extremely high level of portability not typically seen in other
-projects.
-
-## TLDR; Version
-This document is going to go over the installation and configuration of the
-following items. If you are already familiar with these tools, you can skip to
-the "Downloading the Source Code" section.
-- C/C++ Compiler
-- CMake
-- Git
-- IDE
-You may also need *python*, since we depend on third-party libraries that may use
-python scripts to generate their own build files. This is not required for the
-Dawn project itself.
-
-## Pre-Configuration
-In order to compile the Dawn project, you are required to have the following
-tools installed on your machine. 
-
-### 1. A C/C++ Compiler
-The exact tool(s) will depend on your specific scenario. The compiler is used to
-take the .cpp/.hpp files and generating binaries that execute on the target
-machine. Typically you will use your own C/C++ compiler for the machine that you
-are currently running, e.g. if you are running Windows, you will use the Visual
-Studio compiler. If you are running Linux, you will use GCC or Clang. If you are
-running macOS, you will use Clang, and so-on.
-
-If you are intending to compile on a different machine than the one you are
-currently running, you will need to use a cross-compiler that is specific for
-your use-case. You will also need to refer to the documentation for creating a
-new Dawn engine target.
-
-Please follow the instructions for your specific operating system to install the
-appropriate C/C++ compiler.
-
-**Windows**
-You will need to download and install [Visual Studio](https://visualstudio.microsoft.com/downloads/).
-Visual Studio (not to be confused with Visual Studio Code) is a full IDE that 
-bundles the official Microsoft C/C++ compiler. It is the recommended compiler
-for building the Dawn project on Windows.
-
-Advanced used can also use [MinGW](http://www.mingw.org/) or another compiler if
-they wish, however this is not officially supported.
-
-After installing Visual Studio, you will need to install the C++ development
-tools. This can be done by opening the Visual Studio Installer and selecting
-the "Desktop development with C++" workload.
-
-**Linux**
-You will need to install the GCC and Clang compilers. The compilers are usually
-installed either by default or by installing the necessary packages for your
-Linux distribution.
-
-For example, on Ubuntu, you can install the GCC and Clang compilers by running
-the following command:
-```bash
-sudo apt install build-essential clang
-```
-
-On Arch Linux, you can install the GCC and Clang compilers by running the
-following command:
-```bash
-sudo pacman -S base-devel clang
-```
-
-And on Fedora, you can install the GCC and Clang compilers by running the
-following command:
-```bash
-sudo dnf install @development-tools clang
-```
-
-For other distributions, please refer to your distribution's documentation.
-
-**macOS**
-You will need to install the Xcode command line tools. This can be done by done
-by running the following command in your terminal:
-```bash
-xcode-select --install
-```
-
-Afterwards you will need to install and enable [Brew](https://brew.sh/). This
-can be done by running the following command in your terminal:
-```bash
-/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
-```
-
-
-### 2. CMake
-CMake is a tool that is used to generate the compilation files for the Dawn
-project. In short this is used to create versions of the Dawn project that can
-be compiled on all different sets of compilers, so if you are compiling on, for
-example, Windows, you can use CMake to generate the compilation files for the
-Visual Studio compiler, or if you are compiling on Linux, you can use CMake to
-generate the compilation files for the GCC or Clang compilers, and so-on.
-
-To install CMake, please follow the instructions for your specific operating
-system. All other operating systems can be found on the [CMake downloads page](https://cmake.org/download/).
-
-**Windows**
-You will need to download and install [CMake](https://cmake.org/download/). The
-installer will guide you through the installation process and will install the
-CMake executable to your system. It is recommended that you add CMake to your
-system PATH if requested by the installer.
-
-**Linux**
-Like installing the C/C++ compilers, you will need to install CMake using your
-specific Linux distribution's package manager, there is also a chance that CMake
-can be installed using flatpak or snap. Please refer to your distribution's
-documentation for more information.
-
-For Ubuntu and other Debian-based distributions, you can install CMake by using
-the following command:
-```bash
-sudo apt install cmake
-```
-
-For Arch Linux, you can install CMake by using the following command:
-```bash
-sudo pacman -S cmake
-```
-
-And for Fedora, you can install CMake by using the following command:
-```bash
-sudo dnf install cmake
-```
-
-**macOS**
-You will install CMake using brew. We detailed how to install brew in the C/C++
-compiler section. To install CMake, run the following command in your terminal:
-```bash
-brew install cmake
-```
-
-### 3. Git
-Git is a version control system that is used to manage the Dawn project's source
-code. It is used to download the source code, and to update the source code to
-the latest version. It is also used to manage the project's dependencies. Git is
-a standard tool in the programming industry and is used to manage complex 
-projects, especially those that are worked on by multiple people.
-
-Git, like all of the above tools, is installed slightly differently depending on
-your operating system. Please follow the instructions for your specific
-operating system.
-
-**Windows**
-You will need to download and install [Git](https://git-scm.com/downloads). The
-installer will guide you through the installation process and will install the
-Git executable to your system. It is recommended that you add Git to your system
-PATH if requested by the installer. You do not need to add the Context-menu 
-items to your system.
-
-**Linux**
-Like installing the C/C++ compilers, you will need to install Git using your 
-specific Linux distribution's package manager. It is also likely that git would
-have been installed by default. Please refer to your distribution's docs for
-more information.
-
-For Ubuntu and other Debian-based distributions, you can install Git by using
-the following command:
-```bash
-sudo apt install git
-```
-
-For Arch Linux, you can install Git by using the following command:
-```bash
-sudo pacman -S git
-```
-
-And for Fedora, you can install Git by using the following command:
-```bash
-sudo dnf install git
-```
-
-**macOS**
-You will install Git using brew. We detailed how to install brew in the C/C++
-compiler section. To install Git, run the following command in your terminal:
-```bash
-brew install git
-```
-
-### 4. An IDE
-An IDE (Integrated Development Environment) is a tool that is used to view and
-edit code of projects. While it is not required to use an IDE, it is recommended
-since it can make the process of editing and running the project much easier.
-
-There are many different IDEs available, and often people chose an IDE that will
-suit their preferences and needs, however if you are unsure of which IDE you
-should be using, the Dawn project recommends using [Visual Studio Code](https://code.visualstudio.com/),
-not to be confused with Visual Studio.
-
-Visual Studio Code is a free and open-source IDE that is widely used in the 
-industry for its simple, modern and configurable interface. For example you can
-configure VSCode to work on Web Projects, Game Projects, and more. It acts like
-a text editor with a bunch of extra tools.
-
-In addition to installing the VSCode IDE, we will add several recommended 
-plugins that will make editing the Dawn project easier and more seamless.
-
-To install VSCode follow the instructions for your specific operating system on
-the [VSCode downloads page](https://code.visualstudio.com/download), as it can
-vary a lot between operating systems.
-
-After installing VSCode, you will need to install the following plugins, by 
-clicking on the "Extensions" icon on the left-hand side of the VSCode window, 
-and searching for the following plugins. You may also be able to click on the
-following links to install the plugins directly, but it may not work.
-- [C/C++](https://marketplace.visualstudio.com/items?itemName=ms-vscode.cpptools)
-- [CMake](https://marketplace.visualstudio.com/items?itemName=twxs.cmake)
-- [CMake Tools](https://marketplace.visualstudio.com/items?itemName=ms-vscode.cmake-tools)
-
-## Downloading the Source Code
-Now that you have all of the necessary tools installed, you can download the
-source code of the project and using it to build. The source code contains all
-of the code of the project, as well as the assets and the build scripts. This is
-confidential information and should not be shared with anyone.
-
-### 1. Cloning the Repository
-We previously installed the git tool, which is used to download the source code
-of the project, and some third-party libraries. To download the source code, you
-will need to open a terminal and navigate to the directory where you want to
-download the source code to.
-
-Afterwards, you will need to run the following command:
-```bash
-git clone https://git.wish.moe/YourWishes/Dawn.git
-```
-This will download the source code of the project to a new subdirectory called 
-"Dawn" and put all of the projects' source code within there.
-
-### 2. Installing the Dependencies / Libraries.
-I try to keep dependencies on third-party libraries to a minimum, however there
-are a few libraries that are required to build the Dawn project. These libraries
-are not included in the source code, and must be downloaded separately. This is
-done using the git tool.
-
-After you have cloned the above repository, you will need to open a terminal and
-navigate to the directory where you downloaded the source code to. Afterwards,
-you will need to run the following command:
-```bash
-git submodule update --init --recursive
-```
-This will fetch all of the third-party libraries that are required to build the
-Dawn project. This may take a while depending on your internet connection.
-
-### 3. Loading the Project
-This step is semi-optional. We are aiming to build the project using CMake, and
-the easiest way to do this is to use the CMake Tools plugin for VSCode that we
-installed earlier. This plugin will automatically detect the CMake files in the
-project and will allow us to build the project using the VSCode interface.
-
-If you opted out of using VSCode, you will need to set up your CMake environment
-to suit your IDE or needs. This is outside of the scope of this document, and
-you will need to refer to your IDE's documentation for more information.
-
-To load the project, you will need to open VSCode and open the Dawn project
-directory. Most operating systems will allow you to do this by dragging the 
-Dawn project directory onto the VSCode window. If this does not work, you can
-open VSCode and click on the "File" menu, and click on "Open Folder". You will
-then need to navigate to the Dawn project directory and click "Open".
-
-Afterwards you will likely be prompted autometically to configure the CMake
-Tools plugin. If you are not, you can click on the "CMake" icon on the left-hand
-side of the VSCode window, and click on "Configure". This will configure the
-CMake Tools plugin to use the CMake files in the Dawn project directory.
-
-You may also be asked to select a compiler. If you are using Windows, you will
-need to select the Visual Studio compiler. If you are using Linux, you will need
-to select the GCC or Clang compiler. If you are using macOS, you will need to
-select the Clang compiler. If you are using a different compiler, you will need
-to select the appropriate compiler.
-
-If prompted to select a build type, select "Debug".
-
-## Compiling the Project
-Now that we have the project loaded into our IDE, we can compile the project.
-This is done using the CMake Tools plugin for VSCode. If you are not using
-VSCode you will need to refer to your IDE's documentation for more information.
-
-Firstly, you will need to create a settings file to configure the project. In
-VSCode you can create a new folder called `.vscode` (Including the leading `.`)
-in the Dawn project root directory. Afterwards, you will need to create a new
-file called `settings.json` in the `.vscode` directory. You will then need to
-paste the following into the file:
-```json
-{
-    "cmake.configureArgs": [
-      "-DDAWN_BUILD_TOOLS=true",
-      "-DDAWN_BUILD_TARGET=target-liminal-win32-glfw",
-      "-DDAWN_DEBUG_BUILD=true"
-    ]
-}
-```
-And save the file. You may want to alter the values to suit your needs. For
-example, if you are compiling on Linux, you will need to change 
-`target-liminal-win32-glfw` to `target-liminal-linux-glfw`. If you are compiling
-on macOS, you will need to change it to `target-liminal-osx-glfw`. The specific
-configure arguments are outside of the scope of this document, and you will need
-to refer to the specific target documentation for more information.
-
-After you have created the settings file, you will need to configure and build
-the project. To perform the build you need to click "Build" button the bottom of
-the VSCode window. This will compile the project and will output the resulting
-binaries in to a "build" directory within the Dawn project directory.
-
-Upon clicking the "Build" button, you will see an output panel appear at the
-bottom of the VSCode window. This will show the process of the build, and will
-show any errors that may occur. This is used to debug and fix any issues that
-may occur during the build process.
-
-If the build was successful, you will see a "Build finished" message in the
-output panel, typically read as;
-```bash
-[build] Build finished with exit code 0
-```
-If you do not see this message, or if the exit code is not 0, you will need to
-debug the issue. The output panel will show the error message which is helpful
-so we can debug the issue. If you are unable to debug the issue, you can ask for
-help in the Discord server.
-
-## Running the built project
-After the build process succeeds you will be able to run the project. This is
-done by clicking on the Run icon, which looks like a play button, on the bottom
-of the VSCode window. This will run the project in production mode and will not
-show any debug information.
-
-If the program hangs, crashes or does not run, you can click the Debug icon, 
-which looks like a ladybug, on the bottom of the VSCode window. This will run
-the project in debug mode and will show debug information and HALT the program
-if there is an error detected. If program HALTS in debug mode you can use this 
-information to debug the issue. If you are unable to debug the issue, you can
-ask for help in the Discord server.

lib/CMakeLists.txt

@@ -3,29 +3,72 @@
 # This software is released under the MIT License.
 # https://opensource.org/licenses/MIT
 
-# GLFW/GLAD
+include(FetchContent)
-if(DAWN_BUILD_SYSTEM STREQUAL "linux")
-  add_subdirectory(glad)
-  add_subdirectory(glfw)
-  add_subdirectory(libarchive)
-  add_subdirectory(glm)
 
-  set(LIBTYPE "STATIC")
+# GLFW
-  add_subdirectory(openal-soft)
+FetchContent_Declare(glfw URL https://github.com/glfw/glfw/releases/download/3.4/glfw-3.4.zip)
+FetchContent_MakeAvailable(glfw)
 
-  set(BUILD_TESTS OFF CACHE BOOL "Build tests" FORCE)
+add_subdirectory(glad)
-  set(BUILD_EXAMPLES OFF CACHE BOOL "Build examples" FORCE) 
-  add_subdirectory(AudioFile)
 
-  add_subdirectory(freetype)
+# GLM
+FetchContent_Declare(
+  glm
+  GIT_REPOSITORY  https://github.com/g-truc/glm
+  GIT_TAG         0af55ccecd98d4e5a8d1fad7de25ba429d60e863
+)
+FetchContent_MakeAvailable(glm)
 
-  add_subdirectory(boxer)
+# FreeType
-  target_compile_definitions(Boxer PRIVATE UNICODE)
+FetchContent_Declare(
+  freetype
+  GIT_REPOSITORY  https://gitlab.freedesktop.org/freetype/freetype
+  GIT_TAG         VER-2-13-3
+)
+FetchContent_MakeAvailable(freetype)
 
-elseif(DAWN_BUILD_SYSTEM STREQUAL "vita")
+#LibArchive
-  add_subdirectory(glm)
+FetchContent_Declare(
+  libarchive
+  GIT_REPOSITORY https://github.com/libarchive/libarchive
+  GIT_TAG        v3.7.6
+)
+FetchContent_MakeAvailable(libarchive)
 
-elseif(DAWN_BUILD_SYSTEM STREQUAL "psp")
+# JSON
-  add_subdirectory(glm)
+FetchContent_Declare(
+  json
+  URL https://github.com/nlohmann/json/releases/download/v3.11.3/json.tar.xz
+)
+FetchContent_MakeAvailable(json)
 
+# JOLT Physics
+if(DAWN_ENABLE_PHYSICS)
+  FetchContent_Declare(
+    JoltPhysics
+    GIT_REPOSITORY "https://github.com/jrouwe/JoltPhysics"
+    GIT_TAG "v5.2.0"
+    SOURCE_SUBDIR "Build"
+  )
+  FetchContent_MakeAvailable(JoltPhysics)
 endif()
+
+# SLANG
+set(SLANG_ENABLE_GFX ON CACHE BOOL "Enable GFX" FORCE)
+FetchContent_Declare(
+  slang
+  GIT_REPOSITORY https://github.com/shader-slang/slang
+  GIT_TAG v2024.17
+)
+FetchContent_MakeAvailable(slang)
+
+
+# OpenAL
+# if(DAWN_TARGET_OPENAL)
+#   set(LIBTYPE "STATIC")
+#   add_subdirectory(openal-soft)
+
+#   set(BUILD_TESTS OFF CACHE BOOL "Build tests" FORCE)
+#   set(BUILD_EXAMPLES OFF CACHE BOOL "Build examples" FORCE) 
+#   add_subdirectory(AudioFile)
+# endif()

lib/glad/include/KHR/khrplatform.h

@@ -153,6 +153,20 @@ typedef int64_t                 khronos_int64_t;
 typedef uint64_t                khronos_uint64_t;
 #define KHRONOS_SUPPORT_INT64   1
 #define KHRONOS_SUPPORT_FLOAT   1
+/*
+ * To support platform where unsigned long cannot be used interchangeably with
+ * inptr_t (e.g. CHERI-extended ISAs), we can use the stdint.h intptr_t.
+ * Ideally, we could just use (u)intptr_t everywhere, but this could result in
+ * ABI breakage if khronos_uintptr_t is changed from unsigned long to
+ * unsigned long long or similar (this results in different C++ name mangling).
+ * To avoid changes for existing platforms, we restrict usage of intptr_t to
+ * platforms where the size of a pointer is larger than the size of long.
+ */
+#if defined(__SIZEOF_LONG__) && defined(__SIZEOF_POINTER__)
+#if __SIZEOF_POINTER__ > __SIZEOF_LONG__
+#define KHRONOS_USE_INTPTR_T
+#endif
+#endif
 
 #elif defined(__VMS ) || defined(__sgi)
 
@@ -235,14 +249,21 @@ typedef unsigned short int     khronos_uint16_t;
  * pointers are 64 bits, but 'long' is still 32 bits. Win64 appears
  * to be the only LLP64 architecture in current use.
  */
-#ifdef _WIN64
+#ifdef KHRONOS_USE_INTPTR_T
+typedef intptr_t               khronos_intptr_t;
+typedef uintptr_t              khronos_uintptr_t;
+#elif defined(_WIN64)
 typedef signed   long long int khronos_intptr_t;
 typedef unsigned long long int khronos_uintptr_t;
-typedef signed   long long int khronos_ssize_t;
-typedef unsigned long long int khronos_usize_t;
 #else
 typedef signed   long  int     khronos_intptr_t;
 typedef unsigned long  int     khronos_uintptr_t;
+#endif
+
+#if defined(_WIN64)
+typedef signed   long long int khronos_ssize_t;
+typedef unsigned long long int khronos_usize_t;
+#else
 typedef signed   long  int     khronos_ssize_t;
 typedef unsigned long  int     khronos_usize_t;
 #endif

src/CMakeLists.txt

@@ -3,22 +3,32 @@
 # This software is released under the MIT License.
 # https://opensource.org/licenses/MIT
 
+# Build Project
+add_executable(${DAWN_TARGET_NAME})
 
-if(DAWN_BUILD_SYSTEM STREQUAL "linux")
+# Validate game project includes the target name
-  add_subdirectory(dawn)
+if(NOT DEFINED DAWN_TARGET_NAME)
-  add_subdirectory(dawnglfw)
+  message(FATAL_ERROR "You need to define a target name")
-  add_subdirectory(dawnlinux)
+endif()
-  add_subdirectory(dawnopengl)
+
-elseif(DAWN_BUILD_SYSTEM STREQUAL "vita")
+# Add in base library
-  add_subdirectory(dawn)
+add_subdirectory(dawn)
-  add_subdirectory(dawnvita)
+add_subdirectory(dawnrpg)
-  add_subdirectory(dawnopengl)
+
-elseif(DAWN_BUILD_SYSTEM STREQUAL "psp")
+if(DAWN_ENABLE_PHYSICS)
-  set(DAWN_OPENGL_SHADERS FALSE CACHE INTERNAL "${DAWN_CACHE_TARGET}")
+  add_subdirectory(dawnphysics)
-  set(DAWN_OPENGL_FRAMEBUFFERS FALSE CACHE INTERNAL "${DAWN_CACHE_TARGET}")
+endif()
-  set(DAWN_OPENGL_MIPMAPS FALSE CACHE INTERNAL "${DAWN_CACHE_TARGET}")
+
-  add_subdirectory(dawn)
+# Host Libraries
-  add_subdirectory(dawnpsp)
+target_link_libraries(${DAWN_TARGET_NAME}
-else()
+  PUBLIC
-  message(FATAL_ERROR "Unknown build system: ${DAWN_BUILD_SYSTEM}")
+    ${DAWN_BUILD_HOST_LIBS}
-endif()
+)
+
+# Compile support targets
+add_subdirectory(dawnglfw)
+add_subdirectory(dawnopengl)
+add_subdirectory(dawnlinux)
+
+# Compress the game assets.
+add_dependencies(${DAWN_TARGET_NAME} dawnassets)

src/dawn/CMakeLists.txt

@@ -1,35 +1,48 @@
-# Copyright (c) 2024 Dominic Masters
+# Copyright (c) 2022 Dominic Masters
-# 
+# 
-# This software is released under the MIT License.
+# This software is released under the MIT License.
-# https://opensource.org/licenses/MIT
+# https://opensource.org/licenses/MIT
-
+
-# Libraries
+# Libraries
-target_link_libraries(${DAWN_TARGET_NAME}
+target_link_libraries(${DAWN_TARGET_NAME}
-  PUBLIC
+  PUBLIC
-)
+    archive_static
-
+    glm::glm
-# Includes
+    nlohmann_json::nlohmann_json
-target_include_directories(${DAWN_TARGET_NAME}
+    freetype
-  PUBLIC
+    slang
-    ${CMAKE_CURRENT_LIST_DIR}
+)
-)
+
-
+# Includes
-# Sources
+target_include_directories(${DAWN_TARGET_NAME}
-target_sources(${DAWN_TARGET_NAME}
+  PUBLIC
-  PRIVATE
+    ${CMAKE_CURRENT_LIST_DIR}
-    
+)
-)
+
-
+# Definitions
-# Subdirs
+target_compile_definitions(${DAWN_TARGET_NAME}
-add_subdirectory(error)
+  PUBLIC
-add_subdirectory(game)
+    DAWN_DEBUG_SHADERS=$<BOOL:${DAWN_DEBUG_SHADERS}>
-add_subdirectory(locale)
+)
-add_subdirectory(scene)
+
-add_subdirectory(util)
+# Subdirs
-
+add_subdirectory(assert)
-# Textures
+add_subdirectory(asset)
-# tool_texture(texture_test
+add_subdirectory(audio)
-#   FILE=${DAWN_ASSETS_DIR}/texture_test.png
+add_subdirectory(component)
-#   FILTER_MIN=NEAREST
+add_subdirectory(display)
-#   FILTER_MAG=NEAREST
+add_subdirectory(environment)
-# )
+add_subdirectory(game)
+add_subdirectory(locale)
+add_subdirectory(save)
+add_subdirectory(scene)
+add_subdirectory(settings)
+add_subdirectory(time)
+add_subdirectory(util)
+
+
+# Assets
+tool_copy(en en.json)
+tool_copy(simpleTexturedShader shaders/simple-textured.slang)
+
+add_dependencies(${DAWN_TARGET_NAME} dawnassets)

src/dawn/assert/assert.cpp

@@ -0,0 +1,35 @@
+/**
+ * Copyright (c) 2022 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "assert.hpp"
+
+void assertTrueImplement(
+  const char *file,
+  const int32_t line,
+  const char *func,
+  const bool_t result,
+  const char *message,
+  ...
+) {
+  if(result) return;
+
+  // Print file info.
+  fprintf(
+    stderr,
+    "Assert failed in %s:%i :: %s\n",
+    file,
+    line,
+    func
+  );
+
+  va_list argptr;
+  va_start(argptr, message);
+  vfprintf(stderr, message, argptr);
+  va_end(argptr);
+  fprintf(stderr, "\n");
+  throw std::runtime_error("Assert failed.");
+}

src/dawn/assert/assert.hpp

@@ -6,7 +6,7 @@
  */
 
 #pragma once
-#include "dawn.hpp"
+#include "util/Flag.hpp"
 
 /**
  * Asserts that a given statement must evaluate to true or the assertion fails
@@ -84,6 +84,17 @@ void assertTrueImplement(
   map.find(key) != map.end(), __VA_ARGS__ \
 )
 
+/**
+ * Asserts that a given map does not have a specific key.
+ * @param map Map to check.
+ * @param key Key to check for.
+ * @param message Message (sprintf format) to send to the logger.
+ * @param args Optional TParam args for the sprintf message to accept.
+ */
+#define assertMapNotHasKey(map, key, ...) assertTrue( \
+  map.find(key) == map.end(), __VA_ARGS__ \
+)
+
 /**
  * Asserts that a given value has a specific flag turned off.
  * 
@@ -93,7 +104,7 @@ void assertTrueImplement(
  * @param args Optional TParam args for the sprintf message to accept.
  */
 #define assertFlagOff(value, flag, ...) assertTrue( \
-  (value & flag) == 0, __VA_ARGS__ \
+  Flag::isOff(value, flag), __VA_ARGS__ \
 )
 
 /**
@@ -105,7 +116,7 @@ void assertTrueImplement(
  * @param args Optional TParam args for the sprintf message to accept.
  */
 #define assertFlagOn(value, flag, ...) assertTrue( \
-  (value & flag) == flag, __VA_ARGS__ \
+  Flag::isOn(value, flag), __VA_ARGS__ \
 )
 
 /**

src/dawn/asset/AssetDataLoader.cpp

@@ -0,0 +1,230 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "assert/assert.hpp"
+#include "AssetDataLoader.hpp"
+#include "util/Math.hpp"
+
+using namespace Dawn;
+
+ssize_t assetDataLoaderArchiveRead(
+  struct archive *archive,
+  void *d,
+  const void **buffer
+) {
+  assertNotNull(archive, "Archive is NULL!");
+  assertNotNull(d, "Data is NULL!");
+  assertNotNull(buffer, "Buffer is NULL!");
+  AssetDataLoader *loader = (AssetDataLoader*)d;
+
+  *buffer = loader->buffer;
+  size_t read = fread(
+    loader->buffer, 1, ASSET_LOADER_BUFFER_SIZE, loader->assetArchiveFile
+  );
+  if(ferror(loader->assetArchiveFile)) return ARCHIVE_FATAL;
+  return read;
+}
+
+int64_t assetDataLoaderArchiveSeek(
+  struct archive *archive,
+  void *d,
+  int64_t offset,
+  int32_t whence
+) {
+  assertNotNull(archive, "Archive is NULL!");
+  assertNotNull(d, "Data is NULL!");
+  assertTrue(offset > 0, "Offset must be greater than 0!");
+  AssetDataLoader *loader = (AssetDataLoader*)d;
+  int32_t ret = fseek(loader->assetArchiveFile, offset, whence);
+  assertTrue(ret == 0, "Failed to seek!");
+  return ftell(loader->assetArchiveFile);
+}
+
+int32_t assetDataLoaderArchiveOpen(struct archive *a, void *d) {
+  assertNotNull(a, "Archive is NULL!");
+  assertNotNull(d, "Data is NULL!");
+  AssetDataLoader *loader = (AssetDataLoader*)d;
+
+  int32_t ret = fseek(loader->assetArchiveFile, 0, SEEK_SET);
+  assertTrue(ret == 0, "Failed to seek to start of file!");
+  return ARCHIVE_OK;
+}
+
+int32_t assetDataLoaderArchiveClose(struct archive *a, void *d) {
+  assertNotNull(a, "Archive is NULL!");
+  assertNotNull(d, "Data is NULL!");
+  return assetDataLoaderArchiveOpen(a, d);
+}
+
+// // // // // // // // // // // // // // // // // // // // // // // // // // //
+
+AssetDataLoader::AssetDataLoader(const std::string &fileName) :
+  fileName(fileName)
+{
+  assertTrue(
+    fileName.size() > 0,
+    "IAssetDataLoader::IAssetDataLoader: fileName must be greater than 0"
+  );
+}
+
+size_t AssetDataLoader::getSize() {
+  assertTrue(this->assetArchiveEntry != nullptr, "Entry is NULL!");
+  assertTrue(
+    archive_entry_size_is_set(assetArchiveEntry),
+    "Entry size is not set!"
+  );
+  return archive_entry_size(assetArchiveEntry);
+}
+
+size_t AssetDataLoader::getPosition() {
+  assertNotNull(this->assetArchiveFile, "File is not open!");
+  return this->position;
+}
+
+std::string AssetDataLoader::getEntireContentsAsString() {
+  if(!this->isOpen()) {
+    this->open();
+  } else {
+    this->rewind();
+  }
+
+  std::string buffer;
+  buffer.resize(this->getSize());
+  this->read((uint8_t*)buffer.data(), buffer.size());
+  this->close();
+  return buffer;
+}
+
+bool_t AssetDataLoader::isOpen() {
+  return this->assetArchive != nullptr;
+}
+
+void AssetDataLoader::open() {
+  assertNull(this->assetArchiveFile, "File is already open");
+  assertNull(this->assetArchive, "Archive is already open");
+  assertNull(this->assetArchiveEntry, "Entry is already open");
+
+  this->assetArchiveFile = this->openAssetArchiveFile();
+  assertNotNull(this->assetArchiveFile, "Failed to open archive file!");
+
+  // Open archive reader
+  assetArchive = archive_read_new();
+  assertNotNull(assetArchive, "Failed to create archive reader");
+
+  // Set up the reader
+  archive_read_support_format_tar(assetArchive);
+
+  // Open reader
+  archive_read_set_open_callback(assetArchive, &assetDataLoaderArchiveOpen);
+  archive_read_set_read_callback(assetArchive, &assetDataLoaderArchiveRead);
+  archive_read_set_seek_callback(assetArchive, &assetDataLoaderArchiveSeek);
+  archive_read_set_close_callback(assetArchive, &assetDataLoaderArchiveClose);
+  archive_read_set_callback_data(assetArchive, this);
+
+  int32_t ret =  archive_read_open1(assetArchive);
+  assertTrue(ret == ARCHIVE_OK, "Failed to open archive!");
+  position = 0;
+
+  // Iterate over each file to find the one for this asset loader.
+  while(archive_read_next_header(assetArchive, &assetArchiveEntry)==ARCHIVE_OK){
+    const char_t *headerFile = (char_t*)archive_entry_pathname(
+      assetArchiveEntry
+    );
+    if(std::string(headerFile) == this->fileName) return;
+    int32_t ret = archive_read_data_skip(assetArchive);
+    assertTrue(ret == ARCHIVE_OK, "Failed to skip data!");
+  }
+
+  assertUnreachable("Failed to find file!");
+}
+
+int32_t AssetDataLoader::close() {
+  assertNotNull(this->assetArchiveFile, "File is NULL");
+  assertNotNull(this->assetArchive, "Archive is NULL!");
+  assertNotNull(this->assetArchiveEntry, "Entry is NULL!");
+  
+  // Close the archive
+  int32_t ret = archive_read_free(this->assetArchive);
+  assertTrue(ret == ARCHIVE_OK, "Failed to close archive!");
+
+  this->assetArchive = nullptr;
+  this->assetArchiveEntry = nullptr;
+
+  // Close the file
+  int32_t res = fclose(this->assetArchiveFile);
+  this->assetArchiveFile = nullptr;
+  return res;
+}
+
+size_t AssetDataLoader::read(uint8_t *buffer, const size_t &size) {
+  assertNotNull(buffer, "Buffer is NULL!");
+  assertTrue(size > 0, "Size must be greater than 0!");
+  assertNotNull(this->assetArchive, "Archive is NULL!");
+  assertNotNull(this->assetArchiveEntry, "Entry is NULL!");
+
+  ssize_t read = archive_read_data(this->assetArchive, buffer, size);
+  this->position += read;
+  
+  if(read == ARCHIVE_FATAL) {
+    assertUnreachable(archive_error_string(this->assetArchive));
+  }
+  
+  assertTrue(read != ARCHIVE_RETRY, "Failed to read data (RETRY)!");
+  assertTrue(read != ARCHIVE_WARN, "Failed to read data (WARN)!");
+
+  return read;
+}
+
+size_t AssetDataLoader::readUntil(
+  uint8_t *buffer,
+  const size_t maxSize,
+  const char_t delimiter
+) {
+  size_t totalRead = this->read(buffer, maxSize);
+  size_t i = 0;
+  while(i < totalRead) {
+    if(buffer[i] == delimiter) break;
+    i++;
+  }
+  buffer[i++] = '\0';
+  return i;
+}
+
+size_t AssetDataLoader::skip(const size_t &n) {
+  assertTrue(n >= 0, "Byte count must be greater than 0.");
+  assertTrue(n < (this->getSize() - this->position), "Cannot skip past EOF!");
+
+  uint8_t dumpBuffer[ASSET_LOADER_BUFFER_SIZE];
+  size_t skipped = 0;
+  size_t n2, n3, n4;
+  n4 = n;
+  while(n4 != 0) {
+    n2 = Math::min<size_t>(n4, ASSET_LOADER_BUFFER_SIZE);
+    n3 = this->read(dumpBuffer, n2);
+    assertTrue(n3 == n2, "Failed to skip bytes!");
+    n4 -= n3;
+  }
+
+  return skipped;
+}
+
+size_t AssetDataLoader::setPosition(const size_t position) {
+  assertTrue(position >= 0, "Position must be greater than or equal to 0");
+  this->rewind();
+  return this->skip(position);
+}
+
+void AssetDataLoader::rewind() {
+  assertTrue(this->isOpen(), "Asset is not open!");
+  if(this->position == 0) return;
+
+  // TODO: See if I can optimize this
+  this->close();
+  this->open();
+}
+
+AssetDataLoader::~AssetDataLoader() {
+  if(this->assetArchiveFile != nullptr) this->close();
+}

src/dawn/asset/AssetDataLoader.hpp

@@ -0,0 +1,180 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "dawn.hpp"
+
+extern "C" {
+  #include <archive.h>
+  #include <archive_entry.h>
+}
+
+#define ASSET_LOADER_BUFFER_SIZE 32768
+
+/**
+ * Method invoked by the libarchive internals to read bytes from the archive
+ * file pointer.
+ * 
+ * @param archive Archive requesting the read. 
+ * @param data Data pointer passed to the archive.
+ * @param buffer Pointer to where the buffer pointer should be stored.
+ * @return Count of bytes read.
+ */
+ssize_t assetDataLoaderArchiveRead(
+  struct archive *archive,
+  void *data,
+  const void **buffer
+);
+
+/**
+ * Method invoked by the libarchive internals to seek the archive file pointer.
+ * 
+ * @param archive Archive requesting the seek.
+ * @param data Data pointer passed to the archive.
+ * @param offset Offset to seek to.
+ * @param whence Whence to seek from.
+ * @return The new offset.
+ */
+int64_t assetDataLoaderArchiveSeek(
+  struct archive *archive,
+  void *data,
+  int64_t offset,
+  int32_t whence
+);
+
+/**
+ * Method invoked by the libarchive internals to open the archive file pointer.
+ * 
+ * @param archive Archive requesting the open.
+ * @param data Data pointer passed to the archive.
+ * @return 0 if success, otherwise for failure.
+ */
+int32_t assetDataLoaderArchiveOpen(struct archive *a, void *data);
+
+/**
+ * Method invoked by the libarchive internals to close the archive file pointer.
+ * 
+ * @param archive Archive requesting the close.
+ * @param data Data pointer passed to the archive.
+ * @return 0 if success, otherwise for failure.
+ */
+int32_t assetDataLoaderArchiveClose(struct archive *a, void *data);
+
+namespace Dawn {
+  class AssetDataLoader {
+    protected:
+      struct archive *assetArchive = nullptr;
+      struct archive_entry *assetArchiveEntry = nullptr;
+      size_t position;
+      std::string fileName;
+
+    public:
+      uint8_t buffer[ASSET_LOADER_BUFFER_SIZE];
+      FILE *assetArchiveFile = nullptr;
+
+      /**
+       * Unimplemented method intended to be implemented by the platform that
+       * will be used to request a File pointer to the asset.
+       * 
+       * @return Pointer to the opened asset archive.
+       */
+      FILE * openAssetArchiveFile();
+      
+      /**
+       * Create a new asset loader. Asset Loaders can be used to load data from
+       * a file in a myriad of ways.
+       * 
+       * @param fileName File name of the asset that is to be loaded.
+       */
+      AssetDataLoader(const std::string &filename);
+      
+      /**
+       * Get the size of the asset.
+       * @return The size of the asset in bytes.
+       */
+      size_t getSize();
+
+      /**
+       * Returns the current position of the read head.
+       * 
+       * @return The current read head position.
+       */
+      size_t getPosition();
+
+      /**
+       * Get the entire contents of the asset as a string.
+       * 
+       * @return The entire contents of the asset as a string.
+       */
+      std::string getEntireContentsAsString();
+
+      /**
+       * Check if the asset is open.
+       * 
+       * @return True if the asset is open, otherwise false.
+       */
+      bool_t isOpen();
+
+      /**
+       * Platform-centric method to open a file buffer to an asset.
+       */
+      void open();
+
+      /**
+       * Closes the previously ppened asset.
+       * @return 0 if successful, otherwise false.
+       */
+      int32_t close();
+
+      /**
+       * Read bytes from buffer.
+       * @param buffer Pointer to a ubyte array to buffer data into.
+       * @param size Length of the data buffer (How many bytes to read).
+       * @return The count of bytes read.
+       */
+      size_t read(uint8_t *buffer, const size_t &size);
+
+      /**
+       * Reads bytes from the buffer until a given delimiter is found. Returned
+       * position will be the index of the delimiter within the buffer.
+       * 
+       * @param buffer Buffer to read into.
+       * @param maxSize Maximum size of the buffer.
+       * @param delimiter Delimiter to read until.
+       * @return The count of bytes read (including null terminator)
+       */
+      size_t readUntil(
+        uint8_t *buffer,
+        const size_t maxSize,
+        const char_t delimiter
+      );
+
+      /**
+       * Skips the read head forward to a given position.
+       * 
+       * @param n Count of bytes to progress the read head by.
+       * @return Count of bytes progressed.
+       */
+      size_t skip(const size_t &n);
+
+      /**
+       * Rewind the read head to the beginning of the file.
+       */
+      void rewind();
+
+      /**
+       * Sets the absolute position of the read head within the buffer of the
+       * file.
+       * 
+       * @param absolutePosition Absolute position to set the read head to.
+       */
+      size_t setPosition(const size_t absolutePosition);
+
+      /**
+       * Cleanup the asset loader.
+       */
+      virtual ~AssetDataLoader();
+  };
+}

src/dawn/asset/AssetLoader.cpp

@@ -0,0 +1,42 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "AssetLoader.hpp"
+#include "assert/assert.hpp"
+#include "asset/AssetManager.hpp"
+
+using namespace Dawn;
+
+const std::string AssetLoader::ASSET_TYPE = "unknown";
+
+AssetLoader::AssetLoader(
+  const std::shared_ptr<AssetManager> assetManager,
+  const std::string name
+) :
+  assetManager(assetManager),
+  name(name)
+{
+  assertNotNull(assetManager, "AssetManager cannot be null");
+  assertTrue(name.size() > 0, "Name cannot be empty");
+
+  std::cout << "Loading: " << name << std::endl;
+}
+
+std::shared_ptr<AssetManager> AssetLoader::getAssetManager() {
+  auto am = this->assetManager.lock();
+  assertNotNull(am, "AssetManager is null");
+  return am;
+}
+
+void AssetLoader::loadImmediately() {
+  while(!this->loaded) {
+    this->getAssetManager()->update();
+  }
+}
+
+AssetLoader::~AssetLoader() {
+  this->loaded = false;
+  std::cout << "Unloading: " << name << std::endl;
+}

src/dawn/asset/AssetLoader.hpp

@@ -0,0 +1,71 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "dawn.hpp"
+
+namespace Dawn {
+  class AssetManager;
+
+  class AssetLoader {
+    private:
+      std::weak_ptr<AssetManager> assetManager;
+
+    public:
+      std::string typetest;
+      const static std::string ASSET_TYPE;
+
+      const std::string name;
+      bool_t loaded = false;
+
+      /**
+       * Create an abstract Asset object.
+       * 
+       * @param name Name of the asset.
+       */
+      AssetLoader(
+        const std::shared_ptr<AssetManager> assetManager,
+        const std::string name
+      );
+
+      /**
+       * Virtual function that will be called by the asset manager on a 
+       * synchronous basis. This will only trigger if the blocks are false and
+       * the loaded is also false.
+       */
+      virtual void updateSync() = 0;
+
+      /**
+       * Virtual function called by the asset manager asynchronously every tick.
+       * This will only trigger if blocks are false and the loaded state is also
+       * false.
+       */
+      virtual void updateAsync() = 0;
+
+      /**
+       * Returns the asset type.
+       * 
+       * @return The asset type.
+       */
+      virtual std::string getAssetType() const = 0;
+
+      /**
+       * Returns the asset manager.
+       * 
+       * @return The asset manager.
+       */
+      std::shared_ptr<AssetManager> getAssetManager();
+
+      /**
+       * Load the asset immediately, this is blocking on the main thread.
+       */
+      void loadImmediately();
+      
+      /**
+       * Dispose the asset item.
+       */
+      virtual ~AssetLoader();
+  };
+}

src/dawn/asset/AssetManager.cpp

@@ -0,0 +1,77 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "AssetManager.hpp"
+#include "assert/assert.hpp"
+
+using namespace Dawn;
+
+void AssetManager::init(const std::shared_ptr<Game> &game) {
+  assertNotNull(game, "Game is NULL?");
+  this->game = game;
+}
+
+void AssetManager::update() {
+  auto copyPendingAssets = pendingAssetLoaders;
+  auto itPending = copyPendingAssets.begin();
+  while(itPending != copyPendingAssets.end()) {
+    auto loader = *itPending;
+    
+    loader->updateSync();
+    loader->updateAsync();
+    loader->updateSync();
+
+    if(!loader->loaded) {
+      ++itPending;
+      continue;
+    }
+    
+    finishedAssetLoaders.push_back(loader);
+    auto it = std::find(
+      pendingAssetLoaders.begin(),
+      pendingAssetLoaders.end(),
+      loader
+    );
+    assertTrue(it != pendingAssetLoaders.end(), "Loader not found?");
+    pendingAssetLoaders.erase(it);
+    ++itPending;
+  }
+}
+
+void AssetManager::remove(const std::shared_ptr<AssetLoader> loader) {
+  for(
+    auto it = pendingAssetLoaders.begin();
+    it != pendingAssetLoaders.end();
+    it++
+  ) {
+    if(*it != loader) continue;
+    pendingAssetLoaders.erase(it);
+    return;
+  }
+
+  for(
+    auto it = finishedAssetLoaders.begin();
+    it != finishedAssetLoaders.end();
+    it++
+  ) {
+    if(it->lock() != loader) continue;
+    finishedAssetLoaders.erase(it);
+    return;
+  }
+}
+
+bool_t AssetManager::isEverythingLoaded() {
+  return pendingAssetLoaders.size() == 0;
+}
+
+std::shared_ptr<Game> AssetManager::getGame() {
+  auto g = game.lock();
+  assertNotNull(g, "Game is NULL?");
+  return g;
+}
+
+AssetManager::~AssetManager() {
+  
+}

src/dawn/asset/AssetManager.hpp

@@ -0,0 +1,114 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "dawn.hpp"
+#include "asset/AssetLoader.hpp"
+
+namespace Dawn {
+  class Game;
+
+  class AssetManager final : public std::enable_shared_from_this<AssetManager> {
+    private:
+      std::weak_ptr<Game> game;
+      std::vector<std::shared_ptr<AssetLoader>> pendingAssetLoaders;
+      std::vector<std::weak_ptr<AssetLoader>> finishedAssetLoaders;
+
+      /**
+       * Returns an existing asset loader if it exists.
+       * 
+       * @param filename The filename of the asset to get.
+       * @return The asset loader if it exists, otherwise nullptr.
+       */
+      template<class T>
+      std::shared_ptr<T> getExisting(const std::string &filename) {
+        for(auto &loader : pendingAssetLoaders) {
+          if(loader->name != filename) continue;
+          if(loader->getAssetType() != T::ASSET_TYPE) continue;
+          return std::static_pointer_cast<T>(loader);
+        }
+
+        for(auto &wLoader : finishedAssetLoaders) {
+          auto loader = wLoader.lock();
+          if(!loader) continue;
+          if(loader->name != filename) continue;
+          if(loader->getAssetType() != T::ASSET_TYPE) continue;
+          return std::static_pointer_cast<T>(loader);
+        }
+        
+        return nullptr;
+      }
+
+      /**
+       * Removes an existing asset loader if it exists.
+       * 
+       * @param filename The filename of the asset to remove.
+       */
+      void removeExisting(const std::string &filename);
+
+    public:
+      /**
+       * Initializes this asset manager so it can begin accepting assets.
+       * 
+       * @param game Game context that this asset manager is attached to.
+       */
+      void init(const std::shared_ptr<Game> &game);
+
+      /**
+       * Updates the asset manager.
+       */
+      void update();
+
+      /**
+       * Returns whether the asset manager has loaded all of the currently
+       * managed assets.
+       * 
+       * @return True if all assets have been loaded.
+       */
+      bool_t isEverythingLoaded();
+
+      /**
+       * Returns the asset loader for the given asset.
+       * 
+       * @param filename The filename of the asset to get.
+       * @return The asset loader for the given asset.
+       */
+      template<class T>
+      std::shared_ptr<T> get(const std::string &filename) {
+        auto existing = this->getExisting<T>(filename);
+        if(existing) return existing;
+
+        std::shared_ptr<T> loader = std::make_shared<T>(
+          shared_from_this(),
+          filename
+        );
+        pendingAssetLoaders.push_back(
+          std::static_pointer_cast<AssetLoader>(loader)
+        );
+        return loader;
+      }
+
+      /**
+       * Returns the game context that this asset manager is attached to.
+       * 
+       * @return The game context.
+       */
+      std::shared_ptr<Game> getGame();
+
+      /**
+       * Removes the given asset loader from the asset manager, assumes that
+       * nothing else needs to access it and any dangling shared_ptrs will have
+       * to remain in memory.
+       * 
+       * @param loader The asset loader to remove.
+       */
+      void remove(const std::shared_ptr<AssetLoader> loader);
+
+      /**
+       * Dispose the asset manager, and all attached assets.
+       */
+      ~AssetManager();
+  };
+}

src/dawn/asset/CMakeLists.txt

@@ -0,0 +1,15 @@
+# Copyright (c) 2022 Dominic Msters
+# 
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+# Sources
+target_sources(${DAWN_TARGET_NAME}
+  PRIVATE
+    AssetLoader.cpp
+    AssetDataLoader.cpp
+    AssetManager.cpp
+)
+
+# Subdirs
+add_subdirectory(loader)

src/dawn/asset/loader/CMakeLists.txt

@@ -0,0 +1,17 @@
+# Copyright (c) 2022 Dominic Msters
+# 
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+# Sources
+target_sources(${DAWN_TARGET_NAME}
+  PRIVATE
+    TextureLoader.cpp
+    JSONLoader.cpp
+    TrueTypeLoader.cpp
+    ShaderLoader.cpp
+    StringLoader.cpp
+)
+
+# Subdirs
+add_subdirectory(scene)

src/dawn/asset/loader/JSONLoader.cpp

@@ -0,0 +1,43 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "JSONLoader.hpp"
+
+using namespace Dawn;
+
+const std::string JSONLoader::ASSET_TYPE = "json";
+
+JSONLoader::JSONLoader(
+  const std::shared_ptr<AssetManager> assetManager,
+  const std::string name
+) :
+  AssetLoader(assetManager, name),
+  loader(name),
+  state(JSONLoaderState::INITIAL)
+{
+  this->typetest = this->getAssetType();
+}
+
+void JSONLoader::updateAsync() {
+  if(this->state != JSONLoaderState::INITIAL) return;
+  
+  this->state = JSONLoaderState::LOADING_JSON;
+  std::string jsonContents = loader.getEntireContentsAsString();
+  this->data = json::parse(jsonContents);
+  this->state = JSONLoaderState::DONE;
+  this->loaded = true;
+}
+
+void JSONLoader::updateSync() {
+}
+
+std::string JSONLoader::getAssetType() const {
+  return JSONLoader::ASSET_TYPE;
+}
+
+JSONLoader::~JSONLoader() {
+  
+}
+

src/dawn/asset/loader/JSONLoader.hpp

@@ -0,0 +1,37 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "asset/AssetLoader.hpp"
+#include "asset/AssetDataLoader.hpp"
+
+
+namespace Dawn {
+  enum class JSONLoaderState {
+    INITIAL,
+    LOADING_JSON,
+    DONE
+  };
+
+  class JSONLoader : public AssetLoader {
+    protected:
+      AssetDataLoader loader;
+      enum JSONLoaderState state;
+
+    public:
+      const static std::string ASSET_TYPE;
+
+      json data;
+
+      JSONLoader(
+        const std::shared_ptr<AssetManager> assetManager,
+        const std::string name
+      );
+      void updateSync() override;
+      void updateAsync() override;
+      std::string getAssetType() const override;
+      ~JSONLoader();
+  };
+}

src/dawn/asset/loader/ShaderLoader.cpp

@@ -0,0 +1,60 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "ShaderLoader.hpp"
+#include "assert/assert.hpp"
+#include "asset/AssetManager.hpp"
+#include "game/Game.hpp"
+
+using namespace Dawn;
+
+const std::string ShaderLoader::ASSET_TYPE = "shader";
+
+ShaderLoader::ShaderLoader(
+  const std::shared_ptr<AssetManager> assetManager,
+  const std::string name
+) :
+  AssetLoader(assetManager, name),
+  state(ShaderLoaderState::INITIAL),
+  shader(std::make_shared<ShaderProgram>())
+{
+}
+
+void ShaderLoader::updateAsync() {
+}
+
+void ShaderLoader::updateSync() {
+  if(state != ShaderLoaderState::INITIAL) return;
+  this->state = ShaderLoaderState::LOADING;
+  assertFalse(loaded, "ShaderLoader already loaded.");
+
+  // Shorthand.
+  auto sm = this->getAssetManager()->getGame()->shaderManager;
+
+  // Load the shader string
+  Slang::ComPtr<IBlob> diagnostics;
+  auto module = sm->session->loadModule(
+    this->name.c_str(),
+    diagnostics.writeRef()
+  );
+  shader->init(module, sm->session);
+
+  // Finished loading.
+  this->state = ShaderLoaderState::LOADED;
+  this->loaded = true;
+}
+
+std::string ShaderLoader::getAssetType() const {
+  return ShaderLoader::ASSET_TYPE;
+}
+
+std::shared_ptr<ShaderProgram> ShaderLoader::getShader() {
+  assertNotNull(shader, "ShaderLoader shader is null.");
+  return shader;
+}
+
+ShaderLoader::~ShaderLoader() {
+  shader = nullptr;
+}

src/dawn/asset/loader/ShaderLoader.hpp

@@ -0,0 +1,44 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "asset/AssetLoader.hpp"
+#include "asset/AssetDataLoader.hpp"
+#include "display/shader/ShaderManager.hpp"
+#include "display/shader/ShaderProgram.hpp"
+
+namespace Dawn {
+  enum class ShaderLoaderState {
+    INITIAL,
+    LOADING,
+    LOADED
+  };
+
+  class ShaderLoader : public AssetLoader {
+    protected:
+      enum ShaderLoaderState state;
+      std::shared_ptr<ShaderProgram> shader;
+
+    public:
+      const static std::string ASSET_TYPE;
+
+      ShaderLoader(
+        const std::shared_ptr<AssetManager> assetManager,
+        const std::string name
+      );
+      void updateSync() override;
+      void updateAsync() override;
+      std::string getAssetType() const override;
+      
+      /**
+       * Retreives the shader program for this loader.
+       * 
+       * @return The shader program that this loader is managing.
+       */
+      std::shared_ptr<ShaderProgram> getShader();
+
+      ~ShaderLoader();
+  };
+}

src/dawn/asset/loader/StringLoader.cpp

@@ -0,0 +1,38 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "StringLoader.hpp"
+
+using namespace Dawn;
+
+const std::string StringLoader::ASSET_TYPE = "string";
+
+StringLoader::StringLoader(
+  const std::shared_ptr<AssetManager> assetManager,
+  const std::string name
+) :
+  AssetLoader(assetManager, name),
+  loader(name),
+  state(StringLoaderState::INITIAL)
+{
+}
+
+void StringLoader::updateSync() {
+}
+
+void StringLoader::updateAsync() {
+  if(this->state != StringLoaderState::INITIAL) return;
+  this->state = StringLoaderState::LOADING_STRING;
+  this->data = this->loader.getEntireContentsAsString();
+  this->state = StringLoaderState::DONE;
+  this->loaded = true;
+}
+
+std::string StringLoader::getAssetType() const {
+  return StringLoader::ASSET_TYPE;
+}
+
+StringLoader::~StringLoader() {
+}

src/dawn/asset/loader/StringLoader.hpp

@@ -0,0 +1,36 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "asset/AssetLoader.hpp"
+#include "asset/AssetDataLoader.hpp"
+
+namespace Dawn {
+  enum class StringLoaderState {
+    INITIAL,
+    LOADING_STRING,
+    DONE
+  };
+
+  class StringLoader : public AssetLoader {
+    protected:
+      AssetDataLoader loader;
+      enum StringLoaderState state;
+
+    public:
+      const static std::string ASSET_TYPE;
+
+      std::string data;
+
+      StringLoader(
+        const std::shared_ptr<AssetManager> assetManager,
+        const std::string name
+      );
+      void updateSync() override;
+      void updateAsync() override;
+      std::string getAssetType() const override;
+      ~StringLoader();
+  };
+}

src/dawn/asset/loader/TextureLoader.cpp

@@ -0,0 +1,157 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "TextureLoader.hpp"
+#include "assert/assert.hpp"
+
+using namespace Dawn;
+
+const std::string TextureLoader::ASSET_TYPE = "texture";
+
+TextureLoader::TextureLoader(
+  const std::shared_ptr<AssetManager> assetManager,
+  const std::string name
+) :
+  AssetLoader(assetManager, name),
+  loader(name),
+  state(TextureLoaderLoadState::INITIAL)
+{
+  this->typetest = this->getAssetType();
+  texture = std::make_shared<Texture>();
+}
+
+void TextureLoader::updateAsync() {
+  if(this->state != TextureLoaderLoadState::INITIAL) return;
+  this->state = TextureLoaderLoadState::ASYNC_LOADING;
+  this->loader.open();
+
+  // Read in the header.
+  uint8_t buffer[TEXTURE_LOADER_HEADER_SIZE];
+  size_t pos = 0;
+  
+  // Read Version
+  pos += this->loader.readUntil(buffer, TEXTURE_LOADER_HEADER_SIZE, '|');
+  std::string version = std::string((char*)buffer);
+  assertTrue(version == "DT_2.00", "Invalid Texture Version!");
+
+  // Read Texture Width
+  this->loader.setPosition(pos);
+  pos += this->loader.readUntil(buffer, TEXTURE_LOADER_HEADER_SIZE, '|');
+  width = std::stoi(std::string((char*)buffer));
+  assertTrue(width > 0, "Invalid Texture Width!");
+
+  // Read Texture Height
+  this->loader.setPosition(pos);
+  pos += this->loader.readUntil(buffer, TEXTURE_LOADER_HEADER_SIZE, '|');
+  height = std::stoi(std::string((char*)buffer));
+  assertTrue(height > 0, "Invalid Texture Height!");
+
+  // Texture Format (RGBA, RGB, etc)
+  this->loader.setPosition(pos);
+  pos += this->loader.readUntil(buffer, TEXTURE_LOADER_HEADER_SIZE, '|');
+  int32_t iFormat = std::stoi(std::string((char*)buffer));
+  switch(iFormat) {
+    case 1: format = TextureFormat::R; break;
+    case 2: format = TextureFormat::RG; break;
+    case 3: format = TextureFormat::RGB; break;
+    case 4: format = TextureFormat::RGBA; break;
+    default: assertUnreachable("Invalid Texture Format %i!", iFormat);
+  }
+
+  // Wrap X
+  this->loader.setPosition(pos);
+  pos += this->loader.readUntil(buffer, TEXTURE_LOADER_HEADER_SIZE, '|');
+  int32_t iWrapX = std::stoi(std::string((char*)buffer));
+  switch(iWrapX) {
+    case 0: wrapX = TextureWrapMode::REPEAT; break;
+    case 1: wrapX = TextureWrapMode::MIRRORED_REPEAT; break;
+    case 2: wrapX = TextureWrapMode::CLAMP_TO_EDGE; break;
+    case 3: wrapX = TextureWrapMode::CLAMP_TO_BORDER; break;
+    default: assertUnreachable("Invalid Texture Wrap X %i!", iWrapX);
+  }
+
+  // Wrap Y
+  this->loader.setPosition(pos);
+  pos += this->loader.readUntil(buffer, TEXTURE_LOADER_HEADER_SIZE, '|');
+  int32_t iWrapY = std::stoi(std::string((char*)buffer));
+  switch(iWrapY) {
+    case 0: wrapY = TextureWrapMode::REPEAT; break;
+    case 1: wrapY = TextureWrapMode::MIRRORED_REPEAT; break;
+    case 2: wrapY = TextureWrapMode::CLAMP_TO_EDGE; break;
+    case 3: wrapY = TextureWrapMode::CLAMP_TO_BORDER; break;
+    default: assertUnreachable("Invalid Texture Wrap Y %i!", iWrapY);
+  }
+
+  // Filter Min
+  this->loader.setPosition(pos);
+  pos += this->loader.readUntil(buffer, TEXTURE_LOADER_HEADER_SIZE, '|');
+  int32_t iFilterMin = std::stoi(std::string((char*)buffer));
+  switch(iFilterMin) {
+    case 0: filterMin = TextureFilterMode::NEAREST; break;
+    case 1: filterMin = TextureFilterMode::LINEAR; break;
+    default: assertUnreachable("Invalid Texture Filter Min %i!", iFilterMin);
+  }
+
+  // Filter Mag
+  this->loader.setPosition(pos);
+  pos += this->loader.readUntil(buffer, TEXTURE_LOADER_HEADER_SIZE, '|');
+  int32_t iFilterMag = std::stoi(std::string((char*)buffer));
+  switch(iFilterMag) {
+    case 0: filterMag = TextureFilterMode::NEAREST; break;
+    case 1: filterMag = TextureFilterMode::LINEAR; break;
+    default: assertUnreachable("Invalid Texture Filter Mag %i!", iFilterMag);
+  }
+
+  // Data begins here. This part is done synchronously directly to the GPU.
+  this->loader.setPosition(pos);
+  size_t bufferSize = width * height * iFormat;
+  data = new uint8_t[bufferSize];
+  assertNotNull(data, "Failed to allocate texture data!");
+  this->loader.read(data, bufferSize);
+
+  // Handoff to sync to buffer to GPU.
+  this->state = TextureLoaderLoadState::ASYNC_DONE;
+}
+
+void TextureLoader::updateSync() {
+  if(this->state != TextureLoaderLoadState::ASYNC_DONE) return;
+  this->state = TextureLoaderLoadState::SYNC_LOADING;
+
+  assertNotNull(this->texture, "Texture is null!");
+  assertNotNull(this->data, "Texture data is null!");
+
+  // Setup Texture
+  this->texture->setSize(
+    this->width,
+    this->height,
+    this->format,
+    TextureDataFormat::UNSIGNED_BYTE
+  );
+  this->texture->buffer(this->data);
+
+  // Free data buffer
+  delete[] this->data;
+  this->data = nullptr;
+
+  // Hand off and call done
+  this->state = TextureLoaderLoadState::SYNC_DONE;
+  this->loaded = true;
+}
+
+std::string TextureLoader::getAssetType() const {
+  return TextureLoader::ASSET_TYPE;
+}
+
+std::shared_ptr<Texture> TextureLoader::getTexture() {
+  return this->texture;
+}
+
+TextureLoader::~TextureLoader() {
+  if(this->data != nullptr) {
+    delete[] this->data;
+    this->data = nullptr;
+  }
+  this->texture = nullptr;
+}

src/dawn/asset/loader/TextureLoader.hpp

@@ -0,0 +1,55 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "asset/AssetLoader.hpp"
+#include "asset/AssetDataLoader.hpp"
+#include "display/Texture.hpp"
+
+#define TEXTURE_LOADER_HEADER_SIZE 256
+
+namespace Dawn {
+  enum class TextureLoaderLoadState {
+    INITIAL,
+    ASYNC_LOADING,
+    ASYNC_DONE,
+    SYNC_LOADING,
+    SYNC_DONE
+  };
+
+  class TextureLoader : public AssetLoader {
+    protected:
+      AssetDataLoader loader;
+      enum TextureLoaderLoadState state;
+      uint8_t *data = nullptr;
+      int32_t width = -1, height = -1;
+      enum TextureFormat format;
+      enum TextureWrapMode wrapX;
+      enum TextureWrapMode wrapY;
+      enum TextureFilterMode filterMin;
+      enum TextureFilterMode filterMag;
+      std::shared_ptr<Texture> texture;
+
+    public:
+      const static std::string ASSET_TYPE;
+
+      TextureLoader(
+        const std::shared_ptr<AssetManager> assetManager,
+        const std::string name
+      );
+
+      void updateSync() override;
+      void updateAsync() override;
+      std::string getAssetType() const override;
+
+      /**
+       * Get the texture asset.
+       * 
+       * @return Texture asset.
+       */
+      std::shared_ptr<Texture> getTexture();
+      ~TextureLoader();
+  };
+}

src/dawn/asset/loader/TrueTypeLoader.cpp

@@ -0,0 +1,107 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "TrueTypeLoader.hpp"
+#include "assert/assert.hpp"
+
+using namespace Dawn;
+
+const std::string TrueTypeLoader::ASSET_TYPE = "ttf";
+
+TrueTypeLoader::TrueTypeLoader(
+  const std::shared_ptr<AssetManager> assetManager,
+  const std::string name
+) :
+  AssetLoader(assetManager, name),
+  loader(name)
+{
+  this->typetest = this->getAssetType();
+  // Init the font.
+  auto ret = FT_Init_FreeType(&fontLibrary);
+  assertTrue(ret == 0, "Failed to initialize FreeType library.");
+}
+
+void TrueTypeLoader::updateSync() {
+  if(state != TrueTypeLoaderState::ASYNC_DONE) return;
+  state = TrueTypeLoaderState::SYNC_LOADING;
+
+  // Init all the textures.
+  auto it = textures.begin();
+  while(it != textures.end()) {
+    auto texture = it->second.lock();
+
+    if(texture) {
+      texture->setFace(face);
+      it++;
+      continue;
+    }
+
+    it = textures.erase(it);
+  }
+
+  // Done
+  state = TrueTypeLoaderState::SYNC_DONE;
+  this->loaded = true;
+}
+
+void TrueTypeLoader::updateAsync() {
+  if(state != TrueTypeLoaderState::INITIAL) return;
+  state = TrueTypeLoaderState::ASYNC_LOADING;
+
+  // Load the data.
+  this->loader.open();
+  size_t size = loader.getSize();
+  buffer = new uint8_t[size];
+
+  // Read the data.
+  size_t readSize = loader.read(buffer, size);
+  assertTrue(readSize == size, "Failed to read all data from TrueTypeLoader.");
+
+  // Init the font.
+  auto ret = FT_New_Memory_Face(fontLibrary, buffer, size, 0, &face);
+  assertTrue(ret == 0, "Failed to load font face.");
+
+  // Now close the asset loader
+  loader.close();
+  state = TrueTypeLoaderState::ASYNC_DONE;
+}
+
+std::string TrueTypeLoader::getAssetType() const {
+  return TrueTypeLoader::ASSET_TYPE;
+}
+
+std::shared_ptr<TrueTypeTexture> TrueTypeLoader::getTexture(
+  const uint32_t fontSize
+) {
+  // Check if we have the texture already and it hasn't gone stale.
+  auto it = textures.find(fontSize);
+  if(it != textures.end()) {
+    if(!it->second.expired()) return it->second.lock();
+    textures.erase(it);
+  }
+
+  // Create the texture.
+  auto texture = std::make_shared<TrueTypeTexture>(fontSize);
+  textures[fontSize] = texture;
+  if(this->loaded) texture->setFace(face);
+  return texture;
+}
+
+TrueTypeLoader::~TrueTypeLoader() {
+  if(
+    this->state == TrueTypeLoaderState::SYNC_DONE ||
+    this->state == TrueTypeLoaderState::SYNC_LOADING ||
+    this->state == TrueTypeLoaderState::ASYNC_DONE
+  ) {
+    FT_Done_Face(face);
+  }
+
+  FT_Done_FreeType(fontLibrary);
+
+  if(buffer != nullptr) {
+    delete[] buffer;
+    buffer = nullptr;
+  }
+}

src/dawn/asset/loader/TrueTypeLoader.hpp

@@ -0,0 +1,53 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "asset/AssetLoader.hpp"
+#include "asset/AssetDataLoader.hpp"
+#include "display/font/TrueTypeTexture.hpp"
+
+namespace Dawn {
+  enum class TrueTypeLoaderState {
+    INITIAL,
+    ASYNC_LOADING,
+    ASYNC_DONE,
+    SYNC_LOADING,
+    SYNC_DONE
+  };
+
+  class TrueTypeLoader : public AssetLoader {
+    protected:
+      FT_Library fontLibrary;
+      FT_Face face;
+      AssetDataLoader loader;
+      std::unordered_map<uint32_t, std::weak_ptr<TrueTypeTexture>> textures;
+      enum TrueTypeLoaderState state = TrueTypeLoaderState::INITIAL;
+      uint8_t *buffer = nullptr;
+
+    public:
+      const static std::string ASSET_TYPE;
+
+      TrueTypeLoader(
+        const std::shared_ptr<AssetManager> assetManager,
+        const std::string name
+      );
+
+      void updateSync() override;
+      void updateAsync() override;
+      std::string getAssetType() const override;
+
+      /**
+       * Returns the texture for the given font size.
+       * 
+       * @param fontSize Font size to get the texture for.
+       * @return Texture for the given character.
+       */
+      std::shared_ptr<TrueTypeTexture> getTexture(
+        const uint32_t fontSize
+      );
+
+      ~TrueTypeLoader();
+  };
+}

src/dawn/asset/loader/scene/CMakeLists.txt

@@ -0,0 +1,13 @@
+# Copyright (c) 2025 Dominic Msters
+# 
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+# Sources
+target_sources(${DAWN_TARGET_NAME}
+  PRIVATE
+    SceneLoader.cpp
+    LoaderForSceneItems.cpp
+    PrefabLoader.cpp
+    SceneLoadContext.cpp
+)

src/dawn/asset/loader/scene/LoaderForSceneItems.cpp

@@ -0,0 +1,76 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "LoaderForSceneItems.hpp"
+#include "asset/loader/TextureLoader.hpp"
+#include "asset/loader/scene/PrefabLoader.hpp"
+#include "asset/loader/ShaderLoader.hpp"
+
+using namespace Dawn;
+
+LoaderForSceneItems::LoaderForSceneItems(
+  const std::shared_ptr<AssetManager> assetManager,
+  const std::string name
+) :
+  AssetLoader(assetManager, name),
+  ctx(std::make_shared<SceneLoadContext>())
+{
+}
+
+void LoaderForSceneItems::setupDependencies() {
+  assertNotNull(this->jsonLoader, "JSON Loader is NULL?");
+  assertNotNull(ctx, "SceneLoadContext is NULL?");
+  assertTrue(this->jsonLoader->loaded, "JSON loader not loaded?");
+  
+  // Begin loading dependencies.
+  auto &data = this->jsonLoader->data;
+  if(data.contains("assets")) {
+    for(auto &asset : data["assets"].items()) {
+      auto &assetName = asset.key();
+      auto &assetData = asset.value();
+      assertTrue(assetData.contains("type"), "Asset missing type");
+      assertTrue(assetData.contains("path"), "Asset missing path");
+      auto type = assetData["type"].get<std::string>();
+      auto path = assetData["path"].get<std::string>();
+
+      // Is this asset already named?
+      if(ctx->assets.find(assetName) != ctx->assets.end()) {
+        // Check if path and type already the same.
+        auto &existing = ctx->assets[assetName];
+        assertTrue(
+          existing->name == path && existing->getAssetType() == type,
+          "Asset already exists with different path or type: %s",
+          assetName.c_str()
+        );
+        continue;
+      }
+
+      std::shared_ptr<AssetLoader> loader;
+      if(type == "texture") {
+        loader = getAssetManager()->get<TextureLoader>(path);
+
+      } else if(type == "json") {
+        loader = getAssetManager()->get<JSONLoader>(path);
+
+      } else if(type == "prefab") {
+        auto prefabLoader = getAssetManager()->get<PrefabLoader>(path);
+        prefabLoader->ctx->parent = ctx;
+        loader = prefabLoader;
+
+      } else if(type == "shader") {
+        loader = getAssetManager()->get<ShaderLoader>(path);
+
+      } else {
+        assertUnreachable("Unknown asset type: %s", type.c_str());
+      }
+
+      ctx->assets[assetName] = loader;
+    }
+  }
+}
+
+LoaderForSceneItems::~LoaderForSceneItems() {
+  jsonLoader = nullptr;
+}

src/dawn/asset/loader/scene/LoaderForSceneItems.hpp

@@ -0,0 +1,39 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "asset/loader/JSONLoader.hpp"
+#include "SceneLoadContext.hpp"
+
+namespace Dawn {
+  class LoaderForSceneitems;
+
+  class LoaderForSceneItems :
+    public AssetLoader,
+    public std::enable_shared_from_this<LoaderForSceneItems>
+  {
+    protected:
+      std::shared_ptr<JSONLoader> jsonLoader;
+
+      /**
+       * Loads the dependencies into the context for the data available in
+       * the jsonLoader.
+       */
+      void setupDependencies();
+
+    public:
+      const std::shared_ptr<SceneLoadContext> ctx;
+
+      LoaderForSceneItems(
+        const std::shared_ptr<AssetManager> assetManager,
+        const std::string name
+      );
+
+      ~LoaderForSceneItems();
+
+      friend class SceneLoader;
+      friend class PrefabLoader;
+  };
+}

src/dawn/asset/loader/scene/PrefabLoader.cpp

@@ -0,0 +1,69 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "PrefabLoader.hpp"
+#include "SceneLoader.hpp"
+#include "game/Game.hpp"
+#include "assert/assert.hpp"
+#include "asset/loader/TextureLoader.hpp"
+#include "scene/Scene.hpp"
+#include "component/SceneComponentRegistry.hpp"
+#include "util/JSON.hpp"
+
+using namespace Dawn;
+
+const std::string PrefabLoader::ASSET_TYPE = "prefab";
+
+PrefabLoader::PrefabLoader(
+  const std::shared_ptr<AssetManager> assetManager,
+  const std::string name
+) :
+  LoaderForSceneItems(assetManager, name)
+{
+  this->typetest = this->getAssetType();
+}
+
+void PrefabLoader::updateSync() {
+  switch(this->state) {
+    case PrefabLoaderState::INITIAL:
+      jsonLoader = getAssetManager()->get<JSONLoader>(this->name);
+      this->state = PrefabLoaderState::LOADING_JSON;
+      break;
+    
+    case PrefabLoaderState::LOADING_JSON:
+      assertNotNull(this->jsonLoader, "JSON Loader is NULL?");
+      if(!this->jsonLoader->loaded) return;
+      this->state = PrefabLoaderState::LOADING_DEPENDENCIES;
+      this->ctx->data = this->jsonLoader->data;
+      this->setupDependencies();
+      break;
+
+    case PrefabLoaderState::LOADING_DEPENDENCIES:
+      assertTrue(this->jsonLoader->loaded, "JSON loader not loaded?");
+
+      // Check if all dependencies are loaded.
+      for(auto &asset : ctx->assets) {
+        if(!asset.second->loaded) return;
+      }
+
+      this->state = PrefabLoaderState::DEPENDENCIES_LOADED;
+      this->loaded = true;
+      break;
+
+    default:
+      break;
+  }
+}
+
+void PrefabLoader::updateAsync() {
+}
+
+std::string PrefabLoader::getAssetType() const {
+  return PrefabLoader::ASSET_TYPE;
+}
+
+PrefabLoader::~PrefabLoader() {
+
+}

src/dawn/asset/loader/scene/PrefabLoader.hpp

@@ -0,0 +1,39 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "LoaderForSceneItems.hpp"
+#include "scene/Scene.hpp"
+
+namespace Dawn {
+  
+  enum class PrefabLoaderState {
+    INITIAL,
+    LOADING_JSON,
+    LOADING_DEPENDENCIES,
+    DEPENDENCIES_LOADED,
+    DONE
+  };
+
+  class PrefabLoader : public LoaderForSceneItems {
+    protected:
+      PrefabLoaderState state = PrefabLoaderState::INITIAL;
+      std::shared_ptr<SceneItem> item;
+
+    public:
+      const static std::string ASSET_TYPE;
+
+      PrefabLoader(
+        const std::shared_ptr<AssetManager> assetManager,
+        const std::string name
+      );
+      
+      void updateSync() override;
+      void updateAsync() override;
+      std::string getAssetType() const override;
+
+      ~PrefabLoader();
+  };
+}

src/dawn/asset/loader/scene/SceneLoadContext.cpp

@@ -0,0 +1,18 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "SceneLoadContext.hpp"
+
+using namespace Dawn;
+
+std::shared_ptr<SceneItem> SceneLoadContext::getItem(const std::string &j) {
+  auto it = items.find(j);
+  if(it == items.end()) {
+    auto parent = this->parent.lock();
+    assertNotNull(parent, "Couldn't find item.");
+    return parent->getItem(j);
+  }
+  return it->second;
+}

src/dawn/asset/loader/scene/SceneLoadContext.hpp

@@ -0,0 +1,85 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "dawn.hpp"
+#include "assert/assert.hpp"
+
+namespace Dawn {
+  class Scene;
+  class SceneItem;
+  class SceneComponent;
+  class AssetLoader;
+  class SceneLoadContext;
+
+  class PrefabLoader;
+  class LoaderForSceneItems;
+  class SceneLoader;
+
+  class SceneLoadContext {
+    private:
+      std::weak_ptr<SceneLoadContext> parent;
+      std::unordered_map<std::string, std::shared_ptr<SceneItem>> items;
+      std::unordered_map<std::string, std::shared_ptr<SceneComponent>> components;
+      std::unordered_map<std::string, std::shared_ptr<AssetLoader>> assets;
+      std::shared_ptr<Scene> currentScene;
+      std::shared_ptr<SceneItem> currentItem;
+      std::shared_ptr<SceneComponent> currentComponent;
+
+    public:
+      json data;
+
+      /**
+       * Gets an asset from the context.
+       * 
+       * @param j Name of the asset to get.
+       * @return Asset from the context.
+       */
+      template<class T>
+      std::shared_ptr<T> getAsset(const std::string &j) const {
+        auto it = assets.find(j);
+        if(it == assets.end()) {
+          auto parent = this->parent.lock();
+          assertNotNull(parent, "Couldn't find asset %s", j.c_str());
+          return parent->getAsset<T>(j);
+        }
+        auto asset = std::dynamic_pointer_cast<T>(it->second);
+        assertNotNull(asset, "Asset is not of the correct type.");
+        return asset;
+      }
+
+      /**
+       * Gets an item from the context.
+       * 
+       * @param j Name of the item to get.
+       * @return Item from the context.
+       */
+      std::shared_ptr<SceneItem> getItem(const std::string &j);
+
+      /**
+       * Gets a component from the context.
+       * 
+       * @param j Name of the component to get.
+       * @return Component from the context.
+       */
+      template<class T>
+      std::shared_ptr<T> getComponent(const std::string &j) const {
+        auto it = components.find(j);
+        if(it == components.end()) {
+          auto parent = this->parent.lock();
+          assertNotNull(parent, "Couldn't find component.");
+          return parent->getComponent<T>(j);
+        }
+        auto cmp = std::dynamic_pointer_cast<T>(it->second);
+        assertNotNull(cmp, "Component is not of the correct type.");
+        return cmp;
+      }
+
+      friend class PrefabLoader;
+      friend class LoaderForSceneItems;
+      friend class SceneLoader;
+      friend class SceneItem;
+  };
+}

src/dawn/asset/loader/scene/SceneLoader.cpp

@@ -0,0 +1,126 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "SceneLoader.hpp"
+#include "game/Game.hpp"
+#include "assert/assert.hpp"
+#include "scene/Scene.hpp"
+#include "util/JSON.hpp"
+#include "PrefabLoader.hpp"
+
+using namespace Dawn;
+
+const std::string SceneLoader::ASSET_TYPE = "scene";
+
+SceneLoader::SceneLoader(
+  const std::shared_ptr<AssetManager> assetManager,
+  const std::string name
+) :
+  LoaderForSceneItems(assetManager, name),
+  state(SceneLoaderState::INITIAL)
+{
+  this->typetest = this->getAssetType();
+}
+
+void SceneLoader::updateAsync() {
+  switch(this->state) {
+    case SceneLoaderState::INITIAL:
+      this->jsonLoader = getAssetManager()->get<JSONLoader>(this->name);
+      this->state = SceneLoaderState::LOADING_JSON;
+      break;
+    
+    case SceneLoaderState::LOADING_JSON:
+      assertNotNull(this->jsonLoader, "JSON Loader is NULL?");
+      if(!this->jsonLoader->loaded) return;
+      this->ctx->data = this->jsonLoader->data;
+      this->setupDependencies();
+      this->state = SceneLoaderState::LOADING_DEPENDENCIES;
+      break;
+
+    case SceneLoaderState::LOADING_DEPENDENCIES:
+      assertTrue(this->jsonLoader->loaded, "JSON loader not loaded?");
+      // Check if all dependencies are loaded.
+      for(auto &asset : ctx->assets) {
+        if(!asset.second->loaded) return;
+      }
+      ctx->currentScene = std::make_shared<Scene>(
+        this->getAssetManager()->getGame()
+      );
+      this->state = SceneLoaderState::PENDING_STAGE;
+      break;
+    
+    default:
+      break;
+  }
+}
+
+void SceneLoader::updateSync() {
+  if(this->state != SceneLoaderState::PENDING_STAGE) return;
+  assertNotNull(this->jsonLoader, "JSON Loader is NULL?");
+  assertNotNull(ctx, "SceneLoadContext is NULL?");
+  assertTrue(this->jsonLoader->loaded, "JSON loader not loaded?");
+
+  auto &data = this->jsonLoader->data;
+  if(data.contains("items")) {
+    // Create the scene items
+    for(auto &item : data["items"].items()) {
+      auto &itemName = item.key();
+      auto &itemData = item.value();
+      auto sceneItem = ctx->currentScene->createSceneItem();
+      ctx->items[itemName] = sceneItem;
+    }
+
+    // Add components to each scene item
+    for(auto &item : data["items"].items()) {
+      auto &itemName = item.key();
+      auto &itemData = item.value();
+      auto sceneItem = ctx->items[itemName];
+      sceneItem->name = itemName;
+
+      std::shared_ptr<SceneLoadContext> itemCtx;
+      if(itemData.contains("prefab")) {
+        auto prefabLoader = ctx->getAsset<PrefabLoader>(
+          itemData["prefab"].get<std::string>()
+        );
+        assertNotNull(prefabLoader, "Prefab loader not found");
+        assertTrue(prefabLoader->loaded, "Prefab loader not loaded");
+        assertNotNull(
+          prefabLoader->jsonLoader,
+          "Prefab JSON loader not found"
+        );
+        assertTrue(
+          prefabLoader->jsonLoader->loaded,
+          "Prefab JSON loader not loaded"
+        );
+        itemCtx = prefabLoader->ctx;
+        itemCtx->data = json(prefabLoader->jsonLoader->data);
+        itemCtx->parent = this->ctx;
+        JSON::mergeObjectsRecursive(itemCtx->data, itemData);
+      } else {
+        itemCtx = this->ctx;
+        itemCtx->data = json(itemData);
+      }
+
+      sceneItem->load(itemCtx);
+    }
+  }
+  
+  this->jsonLoader = nullptr;
+  this->state = SceneLoaderState::DONE;
+  this->loaded = true;
+}
+
+std::string SceneLoader::getAssetType() const {
+  return SceneLoader::ASSET_TYPE;
+}
+
+std::shared_ptr<Scene> SceneLoader::getScene() {
+  assertNotNull(ctx, "Context is NULL?");
+  assertNotNull(ctx->currentScene, "Scene not loaded?");
+  return ctx->currentScene;
+}
+
+SceneLoader::~SceneLoader() {
+}