idk

.gitea/workflows/release.yml

@@ -1,47 +0,0 @@
-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

@@ -0,0 +1,56 @@
+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

@@ -0,0 +1,26 @@
+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

@@ -65,7 +65,7 @@ CTestTestfile.cmake
 _deps
 
 # Custom
-build
+/build/*
 .vscode
 
 assets/testworld/tileset.png

.gitmodules

@@ -0,0 +1,6 @@
+[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

CMakeLists.txt

@@ -7,12 +7,16 @@ 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 ON)
+set(CMAKE_CXX_STANDARD_REQUIRED True)
 
 # Variable Caches
 set(DAWN_CACHE_TARGET "dawn-target")
 set(DAWN_TARGET_NAME "Dawn")
 
+if(NOT DEFINED DAWN_TARGET)
+  set(DAWN_TARGET linux-x64-glfw CACHE INTERNAL ${DAWN_CACHE_TARGET})
+endif()
+
 # Set Common Build Variables
 set(DAWN_ROOT_DIR "${CMAKE_SOURCE_DIR}")
 set(DAWN_BUILD_DIR "${CMAKE_BINARY_DIR}")
@@ -23,11 +27,7 @@ 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")
 
-# Options
-option(DAWN_ENABLE_PHYSICS "Enable Physics" OFF)
-option(DAWN_DEBUG_SHADERS "Enable Debug Shaders" ON)
-
-# Initialize Project First.
+# Initialize Project.
 project(Dawn
   VERSION 1.0.0
   LANGUAGES C CXX

archive/ShaderStage.cpp

@@ -1,74 +0,0 @@
-// 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

@@ -1,28 +0,0 @@
-// 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/SimpleTexturedShader.cpp

@@ -1,230 +0,0 @@
-// 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
-  ));
-}

assets/dawnrpg/CMakeLists.txt

@@ -0,0 +1,7 @@
+# Copyright (c) 2024 Dominic Masters
+# 
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+tool_truetype(font_silver "${CMAKE_CURRENT_LIST_DIR}/Silver.ttf")
+tool_copy(json_test "${CMAKE_CURRENT_LIST_DIR}/test.json" "${DAWN_ASSETS_BUILD_DIR}/test.json")

assets/dawnrpg/test.json

@@ -0,0 +1,11 @@
+{
+  "name": "Some Map",
+  "width": 3,
+  "height": 3,
+  "depth": 3,
+  "tiles": [
+    0, 0, 0,
+    0, 0, 0,
+    0, 0, 0
+  ]
+}

assets/en.json

@@ -1,42 +0,0 @@
-{
-  "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

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

assets/materials/simple-textured.json

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

assets/prefabs/npc.json

@@ -1,26 +0,0 @@
-{
-  "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

@@ -1,29 +0,0 @@
-{
-  "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

@@ -1,47 +0,0 @@
-{
-  "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

@@ -1,53 +0,0 @@
-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;
-}

lib/CMakeLists.txt

@@ -5,65 +5,33 @@
 
 include(FetchContent)
 
+# GLM
+FetchContent_Declare(
+  glm
+  GIT_REPOSITORY  https://github.com/g-truc/glm.git
+  GIT_TAG         bf71a834948186f4097caa076cd2663c69a10e1e
+)
+FetchContent_MakeAvailable(glm)
+
+# JSON
+FetchContent_Declare(json URL https://github.com/nlohmann/json/releases/download/v3.11.3/json.tar.xz)
+FetchContent_MakeAvailable(json)
+
+# GLAD
+add_subdirectory(glad)
+
 # GLFW
 FetchContent_Declare(glfw URL https://github.com/glfw/glfw/releases/download/3.4/glfw-3.4.zip)
 FetchContent_MakeAvailable(glfw)
 
-add_subdirectory(glad)
-
-# GLM
-FetchContent_Declare(
-  glm
-  GIT_REPOSITORY  https://github.com/g-truc/glm
-  GIT_TAG         0af55ccecd98d4e5a8d1fad7de25ba429d60e863
-)
-FetchContent_MakeAvailable(glm)
-
-# FreeType
-FetchContent_Declare(
-  freetype
-  GIT_REPOSITORY  https://gitlab.freedesktop.org/freetype/freetype
-  GIT_TAG         VER-2-13-3
-)
-FetchContent_MakeAvailable(freetype)
-
-#LibArchive
-FetchContent_Declare(
-  libarchive
-  GIT_REPOSITORY https://github.com/libarchive/libarchive
-  GIT_TAG        v3.7.6
-)
+# LibArchive
+FetchContent_Declare(libarchive URL https://github.com/libarchive/libarchive/releases/download/v3.7.6/libarchive-3.7.6.tar.xz)
 FetchContent_MakeAvailable(libarchive)
 
-# JSON
-FetchContent_Declare(
-  json
-  URL https://github.com/nlohmann/json/releases/download/v3.11.3/json.tar.xz
-)
-FetchContent_MakeAvailable(json)
+# FreeType
+FetchContent_Declare(freetype URL https://psychz.dl.sourceforge.net/project/freetype/freetype2/2.13.3/freetype-2.13.3.tar.xz?viasf=1)
+FetchContent_MakeAvailable(freetype)
 
-# 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)

lib/glad/include/KHR/khrplatform.h

@@ -153,20 +153,6 @@ 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)
 
@@ -249,21 +235,14 @@ 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 KHRONOS_USE_INTPTR_T
-typedef intptr_t               khronos_intptr_t;
-typedef uintptr_t              khronos_uintptr_t;
-#elif defined(_WIN64)
+#ifdef _WIN64
 typedef signed   long long int khronos_intptr_t;
 typedef unsigned long long int khronos_uintptr_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_intptr_t;
+typedef unsigned long  int     khronos_uintptr_t;
 typedef signed   long  int     khronos_ssize_t;
 typedef unsigned long  int     khronos_usize_t;
 #endif

src/CMakeLists.txt

@@ -6,29 +6,18 @@
 # Build Project
 add_executable(${DAWN_TARGET_NAME})
 
-# Validate game project includes the target name
-if(NOT DEFINED DAWN_TARGET_NAME)
-  message(FATAL_ERROR "You need to define a target name")
-endif()
-
 # Add in base library
 add_subdirectory(dawn)
-add_subdirectory(dawnrpg)
 
-if(DAWN_ENABLE_PHYSICS)
-  add_subdirectory(dawnphysics)
+# Compile entry targets
+if(DAWN_TARGET STREQUAL "linux-x64-glfw")
+  add_subdirectory(dawnlinux)
+  add_subdirectory(dawnglfw)
+  add_subdirectory(dawnopengl)
+  add_subdirectory(dawnrpg)
+else()
+  message(FATAL_ERROR "You need to define an entry target")
 endif()
 
-# Host Libraries
-target_link_libraries(${DAWN_TARGET_NAME}
-  PUBLIC
-    ${DAWN_BUILD_HOST_LIBS}
-)
-
-# 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

@@ -6,11 +6,10 @@
 # Libraries
 target_link_libraries(${DAWN_TARGET_NAME}
   PUBLIC
-    archive_static
     glm::glm
-    nlohmann_json::nlohmann_json
+    archive_static
     freetype
-    slang
+    nlohmann_json::nlohmann_json
 )
 
 # Includes
@@ -19,12 +18,6 @@ target_include_directories(${DAWN_TARGET_NAME}
     ${CMAKE_CURRENT_LIST_DIR}
 )
 
-# Definitions
-target_compile_definitions(${DAWN_TARGET_NAME}
-  PUBLIC
-    DAWN_DEBUG_SHADERS=$<BOOL:${DAWN_DEBUG_SHADERS}>
-)
-
 # Subdirs
 add_subdirectory(assert)
 add_subdirectory(asset)
@@ -33,16 +26,15 @@ add_subdirectory(component)
 add_subdirectory(display)
 add_subdirectory(environment)
 add_subdirectory(game)
+# add_subdirectory(games)
+# add_subdirectory(input)
 add_subdirectory(locale)
+add_subdirectory(prefab)
+# add_subdirectory(physics)
+add_subdirectory(poker)
 add_subdirectory(save)
 add_subdirectory(scene)
-add_subdirectory(settings)
+# add_subdirectory(state)
 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)
+add_subdirectory(ui)

src/dawn/assert/assert.hpp

@@ -6,7 +6,7 @@
  */
 
 #pragma once
-#include "util/Flag.hpp"
+#include "dawnlibs.hpp"
 
 /**
  * Asserts that a given statement must evaluate to true or the assertion fails
@@ -104,7 +104,7 @@ void assertTrueImplement(
  * @param args Optional TParam args for the sprintf message to accept.
  */
 #define assertFlagOff(value, flag, ...) assertTrue( \
-  Flag::isOff(value, flag), __VA_ARGS__ \
+  (value & flag) == 0, __VA_ARGS__ \
 )
 
 /**
@@ -116,7 +116,7 @@ void assertTrueImplement(
  * @param args Optional TParam args for the sprintf message to accept.
  */
 #define assertFlagOn(value, flag, ...) assertTrue( \
-  Flag::isOn(value, flag), __VA_ARGS__ \
+  (value & flag) == flag, __VA_ARGS__ \
 )
 
 /**

src/dawn/asset/AssetDataLoader.cpp

@@ -60,58 +60,24 @@ int32_t assetDataLoaderArchiveClose(struct archive *a, void *d) {
 
 // // // // // // // // // // // // // // // // // // // // // // // // // // //
 
-AssetDataLoader::AssetDataLoader(const std::string &fileName) :
-  fileName(fileName)
-{
+AssetDataLoader::AssetDataLoader(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");
+  assertNull(this->assetArchiveFile, "AssetDataLoader::open: File is already open");
+  assertNull(this->assetArchive, "AssetDataLoader::open: Archive is already open");
+  assertNull(this->assetArchiveEntry, "AssetDataLoader::open: Entry is already open");
 
   this->assetArchiveFile = this->openAssetArchiveFile();
-  assertNotNull(this->assetArchiveFile, "Failed to open archive file!");
+  assertNotNull(this->assetArchiveFile, "AssetDataLoader::open: Failed to open archive file!");
 
   // Open archive reader
   assetArchive = archive_read_new();
-  assertNotNull(assetArchive, "Failed to create archive reader");
+  assertNotNull(assetArchive, "AssetDataLoader::open: Failed to create archive reader");
 
   // Set up the reader
   archive_read_support_format_tar(assetArchive);
@@ -124,30 +90,28 @@ void AssetDataLoader::open() {
   archive_read_set_callback_data(assetArchive, this);
 
   int32_t ret =  archive_read_open1(assetArchive);
-  assertTrue(ret == ARCHIVE_OK, "Failed to open archive!");
+  assertTrue(ret == ARCHIVE_OK, "AssetDataLoader::open: 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
-    );
+  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!");
+    assertTrue(ret == ARCHIVE_OK, "AssetDataLoader::open: Failed to skip data!");
   }
 
-  assertUnreachable("Failed to find file!");
+  assertUnreachable("AssetDataLoader::open: 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!");
+  assertNotNull(this->assetArchiveFile, "AssetDataLoader::close: File is NULL");
+  assertNotNull(this->assetArchive, "AssetDataLoader::close: Archive is NULL!");
+  assertNotNull(this->assetArchiveEntry, "AssetDataLoader::close: Entry is NULL!");
   
   // Close the archive
   int32_t ret = archive_read_free(this->assetArchive);
-  assertTrue(ret == ARCHIVE_OK, "Failed to close archive!");
+  assertTrue(ret == ARCHIVE_OK, "AssetDataLoader::close: Failed to close archive!");
 
   this->assetArchive = nullptr;
   this->assetArchiveEntry = nullptr;
@@ -158,11 +122,11 @@ int32_t AssetDataLoader::close() {
   return res;
 }
 
-size_t AssetDataLoader::read(uint8_t *buffer, const size_t &size) {
+size_t AssetDataLoader::read(uint8_t *buffer, 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!");
+  assertNotNull(this->assetArchive, "assetRead: Archive is NULL!");
+  assertNotNull(this->assetArchiveEntry, "assetRead: Entry is NULL!");
 
   ssize_t read = archive_read_data(this->assetArchive, buffer, size);
   this->position += read;
@@ -171,8 +135,8 @@ size_t AssetDataLoader::read(uint8_t *buffer, const size_t &size) {
     assertUnreachable(archive_error_string(this->assetArchive));
   }
   
-  assertTrue(read != ARCHIVE_RETRY, "Failed to read data (RETRY)!");
-  assertTrue(read != ARCHIVE_WARN, "Failed to read data (WARN)!");
+  assertTrue(read != ARCHIVE_RETRY, "assetRead: Failed to read data (RETRY)!");
+  assertTrue(read != ARCHIVE_WARN, "assetRead: Failed to read data (WARN)!");
 
   return read;
 }
@@ -192,19 +156,23 @@ size_t AssetDataLoader::readUntil(
   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!");
+size_t AssetDataLoader::getSize() {
+  assertTrue(this->assetArchiveEntry != nullptr, "AssetDataLoader::getSize: Entry is NULL!");
+  assertTrue(archive_entry_size_is_set(assetArchiveEntry), "assetGetSize: Entry size is not set!");
+  return archive_entry_size(assetArchiveEntry);
+}
+
+size_t AssetDataLoader::skip(size_t n) {
+  assertTrue(n >= 0, "AssetDataLoader::skip: Byte count must be greater than 0.");
 
   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);
+  size_t n2, n3;
+  while(n != 0) {
+    n2 = Math::min<size_t>(n, ASSET_LOADER_BUFFER_SIZE);
     n3 = this->read(dumpBuffer, n2);
-    assertTrue(n3 == n2, "Failed to skip bytes!");
-    n4 -= n3;
+    assertTrue(n3 == n2, "AssetDataLoader::skip: Failed to skip bytes!");
+    n -= n3;
   }
 
   return skipped;
@@ -217,14 +185,16 @@ size_t AssetDataLoader::setPosition(const size_t 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();
 }
 
+size_t AssetDataLoader::getPosition() {
+  assertNotNull(this->assetArchiveFile, "AssetDataLoader::getPosition: File is not open!");
+  return this->position;
+}
+
 AssetDataLoader::~AssetDataLoader() {
   if(this->assetArchiveFile != nullptr) this->close();
 }

src/dawn/asset/AssetDataLoader.hpp

@@ -4,7 +4,7 @@
 // https://opensource.org/licenses/MIT
 
 #pragma once
-#include "dawn.hpp"
+#include "dawnlibs.hpp"
 
 extern "C" {
   #include <archive.h>
@@ -88,34 +88,7 @@ namespace Dawn {
        * 
        * @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();
+      AssetDataLoader(std::string filename);
 
       /**
        * Platform-centric method to open a file buffer to an asset.
@@ -134,7 +107,7 @@ namespace Dawn {
        * @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);
+      size_t read(uint8_t *buffer, size_t size);
 
       /**
        * Reads bytes from the buffer until a given delimiter is found. Returned
@@ -150,6 +123,12 @@ namespace Dawn {
         const size_t maxSize,
         const char_t delimiter
       );
+      
+      /**
+       * Get the size of the asset.
+       * @return The size of the asset in bytes.
+       */
+      size_t getSize();
 
       /**
        * Skips the read head forward to a given position.
@@ -157,7 +136,7 @@ namespace Dawn {
        * @param n Count of bytes to progress the read head by.
        * @return Count of bytes progressed.
        */
-      size_t skip(const size_t &n);
+      size_t skip(size_t n);
 
       /**
        * Rewind the read head to the beginning of the file.
@@ -172,6 +151,13 @@ namespace Dawn {
        */
       size_t setPosition(const size_t absolutePosition);
 
+      /**
+       * Returns the current position of the read head.
+       * 
+       * @return The current read head position.
+       */
+      size_t getPosition();
+
       /**
        * Cleanup the asset loader.
        */

src/dawn/asset/AssetLoader.cpp

@@ -5,38 +5,13 @@
 
 #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(const std::string name) : name(name) {
+  assertTrue(name.size() > 0, "Asset::Asset: Name cannot be empty");
 }
 
 AssetLoader::~AssetLoader() {
   this->loaded = false;
-  std::cout << "Unloading: " << name << std::endl;
 }

src/dawn/asset/AssetLoader.hpp

@@ -4,19 +4,11 @@
 // https://opensource.org/licenses/MIT
 
 #pragma once
-#include "dawn.hpp"
+#include "dawnlibs.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;
 
@@ -25,10 +17,7 @@ namespace Dawn {
        * 
        * @param name Name of the asset.
        */
-      AssetLoader(
-        const std::shared_ptr<AssetManager> assetManager,
-        const std::string name
-      );
+      AssetLoader(const std::string name);
 
       /**
        * Virtual function that will be called by the asset manager on a 
@@ -43,25 +32,6 @@ namespace Dawn {
        * 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.

src/dawn/asset/AssetManager.cpp

@@ -4,61 +4,50 @@
 // https://opensource.org/licenses/MIT
 
 #include "AssetManager.hpp"
-#include "assert/assert.hpp"
+#include "loaders/TextureLoader.hpp"
+#include "loaders/TrueTypeLoader.hpp"
+#include "loaders/JSONLoader.hpp"
 
 using namespace Dawn;
 
-void AssetManager::init(const std::shared_ptr<Game> &game) {
-  assertNotNull(game, "Game is NULL?");
-  this->game = game;
+void AssetManager::init() {
+
 }
 
 void AssetManager::update() {
-  auto copyPendingAssets = pendingAssetLoaders;
-  auto itPending = copyPendingAssets.begin();
-  while(itPending != copyPendingAssets.end()) {
+  auto itPending = pendingAssetLoaders.begin();
+  while(itPending != pendingAssetLoaders.end()) {
     auto loader = *itPending;
-    
     loader->updateSync();
     loader->updateAsync();
-    loader->updateSync();
-
-    if(!loader->loaded) {
-      ++itPending;
-      continue;
+    if(loader->loaded) {
+      finishedAssetLoaders.push_back(loader);
+      itPending = pendingAssetLoaders.erase(itPending);
+    } else {
+      itPending++;
     }
-    
-    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;
+void AssetManager::removeExisting(const std::string filename) {
+  auto existing = std::find_if(
+    pendingAssetLoaders.begin(), pendingAssetLoaders.end(),
+    [&](auto &loader) {
+      return loader->name == filename;
+    }
+  );
+  if(existing != pendingAssetLoaders.end()) {
+    pendingAssetLoaders.erase(existing);
   }
 
-  for(
-    auto it = finishedAssetLoaders.begin();
-    it != finishedAssetLoaders.end();
-    it++
-  ) {
-    if(it->lock() != loader) continue;
-    finishedAssetLoaders.erase(it);
-    return;
+  existing = std::find_if(
+    finishedAssetLoaders.begin(), finishedAssetLoaders.end(),
+    [&](auto &loader) {
+      return loader->name == filename;
+    }
+  );
+  if(existing != finishedAssetLoaders.end()) {
+    finishedAssetLoaders.erase(existing);
   }
 }
 
@@ -66,12 +55,47 @@ 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;
+bool_t AssetManager::isLoaded(const std::string filename) {
+  auto existing = this->getExisting<AssetLoader>(filename);
+  if(existing) return existing->loaded;
+  return false;
 }
 
+template<>
+std::shared_ptr<TrueTypeTexture> AssetManager::get<TrueTypeTexture>(
+  const std::string filename,
+  const uint32_t fontSize
+) {
+  auto existing = this->getExisting<TrueTypeLoader>(filename);
+  if(existing) {
+    // Check pointer hasn't gone stale, if it has remove it and create new.
+    auto texture = existing->getTexture(fontSize);
+    if(texture) return texture;
+    this->removeExisting(filename);
+  }
+
+  std::shared_ptr<TrueTypeLoader> loader = std::make_shared<TrueTypeLoader>(
+    filename
+  );
+  pendingAssetLoaders.push_back(std::static_pointer_cast<AssetLoader>(loader));
+  return loader->getTexture(fontSize);
+}
+
+template<>
+std::shared_ptr<json> AssetManager::get<json>(
+  const std::string filename
+) {
+  auto existing = this->getExisting<JSONLoader>(filename);
+  if(existing) return existing->data;
+
+  std::shared_ptr<JSONLoader> loader = std::make_shared<JSONLoader>(
+    filename
+  );
+  pendingAssetLoaders.push_back(std::static_pointer_cast<AssetLoader>(loader));
+  return loader->data;
+}
+
+
 AssetManager::~AssetManager() {
   
 }

src/dawn/asset/AssetManager.hpp

@@ -4,17 +4,14 @@
 // https://opensource.org/licenses/MIT
 
 #pragma once
-#include "dawn.hpp"
+#include "dawnlibs.hpp"
 #include "asset/AssetLoader.hpp"
 
 namespace Dawn {
-  class Game;
-
-  class AssetManager final : public std::enable_shared_from_this<AssetManager> {
+  class AssetManager final {
     private:
-      std::weak_ptr<Game> game;
       std::vector<std::shared_ptr<AssetLoader>> pendingAssetLoaders;
-      std::vector<std::weak_ptr<AssetLoader>> finishedAssetLoaders;
+      std::vector<std::shared_ptr<AssetLoader>> finishedAssetLoaders;
 
       /**
        * Returns an existing asset loader if it exists.
@@ -23,22 +20,26 @@ namespace Dawn {
        * @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);
+      std::shared_ptr<T> getExisting(const std::string filename) {
+        auto existing = std::find_if(
+          pendingAssetLoaders.begin(), pendingAssetLoaders.end(),
+          [&](auto &loader) {
+            return loader->name == filename;
+          }
+        );
+
+        if(existing == pendingAssetLoaders.end()) {
+          existing = std::find_if(
+            finishedAssetLoaders.begin(), finishedAssetLoaders.end(),
+            [&](auto &loader) {
+              return loader->name == filename;
+            }
+          );
+          
+          if(existing == finishedAssetLoaders.end()) return nullptr;
         }
 
-        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;
+        return std::static_pointer_cast<T>(*existing);
       }
 
       /**
@@ -46,15 +47,13 @@ namespace Dawn {
        * 
        * @param filename The filename of the asset to remove.
        */
-      void removeExisting(const std::string &filename);
+      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);
+      void init();
 
       /**
        * Updates the asset manager.
@@ -69,42 +68,36 @@ namespace Dawn {
        */
       bool_t isEverythingLoaded();
 
+      /**
+       * Returns whether the asset manager has loaded the given asset. 
+       * 
+       * @param filename The filename of the asset to check.
+       * @return True if the asset has been loaded.
+       */
+      bool_t isLoaded(const std::string filename);
+
       /**
        * Returns the asset loader for the given asset.
        * 
        * @param filename The filename of the asset to get.
+       * @param fontSize The font size to get the truetype asset of.
        * @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;
-      }
+      std::shared_ptr<T> get(const std::string filename);
 
       /**
-       * Returns the game context that this asset manager is attached to.
+       * Returns the asset loader for the given asset.
        * 
-       * @return The game context.
+       * @param filename The filename of the asset to get.
+       * @param fontSize The font size to get the truetype asset of.
+       * @return The asset loader for the given asset.
        */
-      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);
+      template<class T>
+      std::shared_ptr<T> get(
+        const std::string filename,
+        const uint32_t fontSize
+      );
 
       /**
        * Dispose the asset manager, and all attached assets.

src/dawn/asset/CMakeLists.txt

@@ -12,4 +12,4 @@ target_sources(${DAWN_TARGET_NAME}
 )
 
 # Subdirs
-add_subdirectory(loader)
+add_subdirectory(loaders)

src/dawn/asset/loader/JSONLoader.cpp

@@ -1,43 +0,0 @@
-// 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

@@ -1,37 +0,0 @@
-// 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

@@ -1,60 +0,0 @@
-// 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

@@ -1,44 +0,0 @@
-// 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

@@ -1,38 +0,0 @@
-// 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

@@ -1,36 +0,0 @@
-// 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/scene/CMakeLists.txt

@@ -1,13 +0,0 @@
-# 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

@@ -1,76 +0,0 @@
-// 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

@@ -1,39 +0,0 @@
-// 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

@@ -1,69 +0,0 @@
-// 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

@@ -1,39 +0,0 @@
-// 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

@@ -1,18 +0,0 @@
-// 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

@@ -1,85 +0,0 @@
-// 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

@@ -1,126 +0,0 @@
-// 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() {
-}

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

@@ -1,44 +0,0 @@
-// 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 SceneLoaderState {
-    INITIAL,
-    LOADING_JSON,
-    LOADING_DEPENDENCIES,
-    PENDING_STAGE,
-    DONE
-  };
-
-  class SceneLoader : public LoaderForSceneItems {
-    protected:
-      SceneLoaderState state;
-
-    public:
-      const static std::string ASSET_TYPE;
-
-      SceneLoader(
-        const std::shared_ptr<AssetManager> assetManager,
-        const std::string name
-      );
-      
-      void updateSync() override;
-      void updateAsync() override;
-      std::string getAssetType() const override;
-
-      /**
-       * Returns the Scene that was loaded, or nullptr if not loaded.
-       * 
-       * @return The loaded scene.
-       */
-      std::shared_ptr<Scene> getScene();
-
-      ~SceneLoader();
-  };
-}

src/dawn/asset/loaders/CMakeLists.txt

@@ -7,11 +7,6 @@
 target_sources(${DAWN_TARGET_NAME}
   PRIVATE
     TextureLoader.cpp
-    JSONLoader.cpp
     TrueTypeLoader.cpp
-    ShaderLoader.cpp
-    StringLoader.cpp
-)
-
-# Subdirs
-add_subdirectory(scene)
+    JSONLoader.cpp
+)

src/dawn/asset/loaders/JSONLoader.cpp

@@ -0,0 +1,46 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "JSONLoader.hpp"
+#include "assert/assert.hpp"
+
+using namespace Dawn;
+
+JSONLoader::JSONLoader(const std::string name) :
+  AssetLoader(name),
+  loader(name + ".json"),
+  state(JSONLoaderLoadState::INITIAL)
+{
+  data = std::make_shared<json>();
+}
+
+void JSONLoader::updateAsync() {
+  if(this->state != JSONLoaderLoadState::INITIAL) return;
+  this->state = JSONLoaderLoadState::LOADING_FILE;
+
+  this->loader.open();
+  auto size = this->loader.getSize();
+
+  auto buffer = new uint8_t[size + 1];
+  assertNotNull(buffer, "Failed to allocate buffer!");
+
+  this->state = JSONLoaderLoadState::PARSING_DATA;
+  auto read = this->loader.read(buffer, size);
+  assertTrue(read == size, "Failed to read entire file!");
+  buffer[size] = '\0';
+
+  *data = json::parse(buffer);
+  delete[] buffer;
+
+  this->state = JSONLoaderLoadState::DONE;
+  this->loaded = true;
+}
+
+void JSONLoader::updateSync() {
+}
+
+JSONLoader::~JSONLoader() {
+  this->data = nullptr;
+}

src/dawn/asset/loaders/JSONLoader.hpp

@@ -0,0 +1,42 @@
+// 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 JSONLoaderLoadState {
+    INITIAL,
+    LOADING_FILE,
+    PARSING_DATA,
+    DONE
+  };
+
+  class JSONLoader : public AssetLoader {
+    protected:
+      AssetDataLoader loader;
+      enum JSONLoaderLoadState state;
+
+    public:
+      std::shared_ptr<json> data;
+
+      /**
+       * Constructs a JSON asset loader. You should instead use the parent
+       * asset managers' abstracted load method
+       * 
+       * @param name File name asset to load, omitting the extension.
+       */
+      JSONLoader(const std::string name);
+
+      void updateSync() override;
+      void updateAsync() override;
+
+      /**
+       * Dispose / Cleanup the JSON asset.
+       */
+      ~JSONLoader();
+  };
+}

src/dawn/asset/loaders/TextureLoader.cpp

@@ -8,18 +8,13 @@
 
 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),
+TextureLoader::TextureLoader(const std::string name) :
+  AssetLoader(name),
+  loader(name + ".texture"),
   state(TextureLoaderLoadState::INITIAL)
 {
-  this->typetest = this->getAssetType();
-  texture = std::make_shared<Texture>();
+  sharedTexture = std::make_shared<Texture>();
+  weakTexture = sharedTexture;
 }
 
 void TextureLoader::updateAsync() {
@@ -119,39 +114,34 @@ void TextureLoader::updateSync() {
   if(this->state != TextureLoaderLoadState::ASYNC_DONE) return;
   this->state = TextureLoaderLoadState::SYNC_LOADING;
 
-  assertNotNull(this->texture, "Texture is null!");
+  assertNotNull(this->sharedTexture, "Texture is null!");
   assertNotNull(this->data, "Texture data is null!");
 
   // Setup Texture
-  this->texture->setSize(
+  this->sharedTexture->setSize(
     this->width,
     this->height,
     this->format,
     TextureDataFormat::UNSIGNED_BYTE
   );
-  this->texture->buffer(this->data);
+  this->sharedTexture->buffer(this->data);
 
   // Free data buffer
   delete[] this->data;
   this->data = nullptr;
 
+  // Leat go of the held pointer
+  this->sharedTexture = 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;
+  this->sharedTexture = nullptr;
 }

src/dawn/asset/loaders/TextureLoader.hpp

@@ -30,26 +30,26 @@ namespace Dawn {
       enum TextureWrapMode wrapY;
       enum TextureFilterMode filterMin;
       enum TextureFilterMode filterMag;
-      std::shared_ptr<Texture> texture;
 
     public:
-      const static std::string ASSET_TYPE;
+      std::shared_ptr<Texture> sharedTexture;
+      std::weak_ptr<Texture> weakTexture;
 
-      TextureLoader(
-        const std::shared_ptr<AssetManager> assetManager,
-        const std::string name
-      );
+      /**
+       * Constructs a texture asset loader. You should instead use the parent
+       * asset managers' abstracted load method
+       * 
+       * @param name File name asset to load, omitting the extension.
+       */
+      TextureLoader(const std::string name);
 
       void updateSync() override;
       void updateAsync() override;
-      std::string getAssetType() const override;
 
       /**
-       * Get the texture asset.
-       * 
-       * @return Texture asset.
+       * Dispose / Cleanup the texture asset. Will also dispose the underlying
+       * texture itself.
        */
-      std::shared_ptr<Texture> getTexture();
       ~TextureLoader();
   };
 }

src/dawn/asset/loaders/TrueTypeLoader.cpp

@@ -8,16 +8,10 @@
 
 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)
+TrueTypeLoader::TrueTypeLoader(const std::string name) :
+  AssetLoader(name),
+  loader(name + ".ttf")
 {
-  this->typetest = this->getAssetType();
   // Init the font.
   auto ret = FT_Init_FreeType(&fontLibrary);
   assertTrue(ret == 0, "Failed to initialize FreeType library.");
@@ -68,10 +62,6 @@ void TrueTypeLoader::updateAsync() {
   state = TrueTypeLoaderState::ASYNC_DONE;
 }
 
-std::string TrueTypeLoader::getAssetType() const {
-  return TrueTypeLoader::ASSET_TYPE;
-}
-
 std::shared_ptr<TrueTypeTexture> TrueTypeLoader::getTexture(
   const uint32_t fontSize
 ) {
@@ -104,4 +94,4 @@ TrueTypeLoader::~TrueTypeLoader() {
     delete[] buffer;
     buffer = nullptr;
   }
-}
+}

src/dawn/asset/loaders/TrueTypeLoader.hpp

@@ -0,0 +1,57 @@
+// 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:
+      /**
+       * Constructs a TrueTypeLoader. You should instead use the parent
+       * asset managers' abstracted load method
+       * 
+       * @param name File name asset to load, omitting the extension.
+       */
+      TrueTypeLoader(const std::string name);
+
+      void updateSync() override;
+      void updateAsync() 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
+      );
+
+      /**
+       * Dispose / Cleanup the truetype asset. Will also dispose the underlying
+       * truetype itself.
+       */
+      ~TrueTypeLoader();
+  };
+}

src/dawn/audio/IAudioManager.hpp

@@ -4,7 +4,7 @@
 // https://opensource.org/licenses/MIT
 
 #pragma once
-#include "dawn.hpp"
+#include "dawnlibs.hpp"
 
 namespace Dawn {
   class IAudioManager {

src/dawn/component/CMakeLists.txt

@@ -5,8 +5,10 @@
 
 target_sources(${DAWN_TARGET_NAME}
   PRIVATE
-    SceneComponentRegistry.cpp
+    SimpleComponent.cpp
 )
 
 # Subdirs
-add_subdirectory(display)
+add_subdirectory(display)
+add_subdirectory(ui)
+add_subdirectory(vn)

src/dawn/component/SceneComponentRegistry.cpp

@@ -1,33 +0,0 @@
-// Copyright (c) 2024 Dominic Masters
-// 
-// This software is released under the MIT License.
-// https://opensource.org/licenses/MIT
-
-#include "SceneComponentRegistry.hpp"
-
-
-using namespace Dawn;
-
-std::unordered_map<
-  std::string,
-  std::function<std::shared_ptr<SceneComponent>(
-    const std::shared_ptr<SceneItem> &
-  )>
-> SceneComponentRegistry::REGISTRY = {
-  
-};
-
-std::shared_ptr<SceneComponent> SceneComponentRegistry::createComponent(
-  const std::string &type,
-  const std::shared_ptr<SceneItem> &item
-) {
-  auto typeLower = String::toLowercase(type);
-  assertMapHasKey(
-    SceneComponentRegistry::REGISTRY,
-    typeLower,
-    "Component type not registered: %s",
-    type.c_str()
-  );
-
-  return SceneComponentRegistry::REGISTRY[typeLower](item);
-}

src/dawn/component/SceneComponentRegistry.hpp

@@ -1,45 +0,0 @@
-// Copyright (c) 2024 Dominic Masters
-// 
-// This software is released under the MIT License.
-// https://opensource.org/licenses/MIT
-
-#pragma once
-#include "scene/Scene.hpp"
-#include "util/String.hpp"
-
-namespace Dawn {
-  class SceneComponentRegistry final {
-    private:
-    
-    public:
-      static std::unordered_map<
-        std::string,
-        std::function<std::shared_ptr<SceneComponent>(
-          const std::shared_ptr<SceneItem> &
-        )>
-      > REGISTRY;
-      
-      template<class T>
-      static void reg(const std::string name) {
-        auto nameLower = String::toLowercase(name);
-        SceneComponentRegistry::REGISTRY[nameLower] = [](
-          const std::shared_ptr<SceneItem> &item
-        ) {
-          return item->addComponent<T>();
-        };
-      }
-
-      /**
-       * Creates a scene component by its type name. Type names are unique and
-       * must be registered in order to be constructed by their string name.
-       * 
-       * @param type Type name of the scene component to create.
-       * @param item Scene item that the component belongs to.
-       * @return The created scene component.
-       */
-      static std::shared_ptr<SceneComponent> createComponent(
-        const std::string &type,
-        const std::shared_ptr<SceneItem> &item
-      );
-  };
-}

src/dawn/component/SimpleComponent.cpp

@@ -0,0 +1,27 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "SimpleComponent.hpp"
+
+using namespace Dawn;
+
+void SimpleComponent::onInit() {
+  this->initMethod(*this, events);
+}
+
+void SimpleComponent::onDispose() {
+  for(auto &event : events) {
+    event();
+  }
+}
+
+std::shared_ptr<SimpleComponent> Dawn::addSimpleComponent(
+  std::shared_ptr<SceneItem> item,
+  std::function<void(SceneComponent&, std::vector<std::function<void()>>&)> init
+) {
+  auto cmp = item->addComponent<SimpleComponent>();
+  cmp->initMethod = init;
+  return cmp;
+}

src/dawn/component/SimpleComponent.hpp

@@ -0,0 +1,31 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "scene/Scene.hpp"
+
+namespace Dawn {
+  class SimpleComponent final : public SceneComponent {
+    private:
+      std::vector<std::function<void()>> events;
+
+    public:
+      std::function<void(
+        SceneComponent&,
+        std::vector<std::function<void()>>&
+      )> initMethod;
+
+      void onInit() override;
+      void onDispose() override;
+  };
+
+  std::shared_ptr<SimpleComponent> addSimpleComponent(
+    std::shared_ptr<SceneItem> item,
+    std::function<void(
+      SceneComponent&,
+      std::vector<std::function<void()>>&
+    )> init
+  );
+}

src/dawn/component/display/CMakeLists.txt

@@ -10,5 +10,4 @@ target_sources(${DAWN_TARGET_NAME}
 )
 
 # Subdirs
-add_subdirectory(material)
-add_subdirectory(mesh)
+add_subdirectory(material)

src/dawn/component/display/Camera.cpp

@@ -21,71 +21,9 @@ void Camera::onDispose() {
   renderTarget = nullptr;
 }
 
-void Camera::load(std::shared_ptr<SceneLoadContext> ctx) {
-  SceneComponent::load(ctx);
-
-  if(ctx->data.contains("fov")) {
-    this->fov = Math::deg2rad(ctx->data["fov"].get<float_t>());
-  }
-
-  if(ctx->data.contains("cameraType")) {
-    if(
-      ctx->data["cameraType"] == "orthogonal" ||
-      ctx->data["cameraType"] == "orthographic" ||
-      ctx->data["cameraType"] == "ortho"
-    ) {
-      this->type = CameraType::ORTHOGONAL;
-    } else if(ctx->data["cameraType"] == "perspective") {
-      this->type = CameraType::PERSPECTIVE;
-    } else {
-      assertUnreachable("Invalid Camera Type!");
-    }
-  }
-
-  if(ctx->data.contains("orthoLeft")) {
-    this->orthoLeft = ctx->data["orthoLeft"].get<float_t>();
-  } else if(ctx->data.contains("left")) {
-    this->orthoLeft = ctx->data["left"].get<float_t>();
-  }
-
-  if(ctx->data.contains("orthoRight")) {
-    this->orthoRight = ctx->data["orthoRight"].get<float_t>();
-  } else if(ctx->data.contains("right")) {
-    this->orthoRight = ctx->data["right"].get<float_t>();
-  }
-
-  if(ctx->data.contains("orthoBottom")) {
-    this->orthoBottom = ctx->data["orthoBottom"].get<float_t>();
-  } else if(ctx->data.contains("bottom")) {
-    this->orthoBottom = ctx->data["bottom"].get<float_t>();
-  }
-
-  if(ctx->data.contains("orthoTop")) {
-    this->orthoTop = ctx->data["orthoTop"].get<float_t>();
-  } else if(ctx->data.contains("top")) {
-    this->orthoTop = ctx->data["top"].get<float_t>();
-  }
-
-  if(ctx->data.contains("clipNear")) {
-    this->clipNear = ctx->data["clipNear"].get<float_t>();
-  } else if(ctx->data.contains("near")) {
-    this->clipNear = ctx->data["near"].get<float_t>();
-  } else if(ctx->data.contains("zNear")) {
-    this->clipNear = ctx->data["zNear"].get<float_t>();
-  }
-
-  if(ctx->data.contains("clipFar")) {
-    this->clipFar = ctx->data["clipFar"].get<float_t>();
-  } else if(ctx->data.contains("far")) {
-    this->clipFar = ctx->data["far"].get<float_t>();
-  } else if(ctx->data.contains("zFar")) {
-    this->clipFar = ctx->data["zFar"].get<float_t>();
-  }
-}
-
 std::shared_ptr<RenderTarget> Camera::getRenderTarget() {
   if(this->renderTarget) return this->renderTarget;
-  return getGame()->renderHost->getBackBufferRenderTarget();
+  return getGame()->renderHost.getBackBufferRenderTarget();
 }
 
 glm::mat4 Camera::getProjection() {
@@ -118,21 +56,7 @@ float_t Camera::getAspect() {
   return rt->getWidth() / rt->getHeight();
 }
 
-float_t Camera::lookAtPixelPerfect(
-  const glm::vec3 &position,
-  const glm::vec3 &look,
-  const float_t &scale
-) {
-  return this->getItem()->lookAtPixelPerfect(
-    position,
-    look,
-    this->getRenderTarget()->getHeight(),
-    this->fov,
-    scale
-  );
-}
-
-void Camera::setRenderTarget(const std::shared_ptr<RenderTarget> renderTarget) {
+void Camera::setRenderTarget(std::shared_ptr<RenderTarget> renderTarget) {
   onResizeListener();
   this->renderTarget = renderTarget;
   this->onResizeListener = this->getRenderTarget()->onResize.listen([&](

src/dawn/component/display/Camera.hpp

@@ -8,7 +8,7 @@
 #include "display/RenderTarget.hpp"
 
 namespace Dawn {
-  enum class CameraType {
+  enum CameraType {
     PERSPECTIVE,
     ORTHOGONAL
   };
@@ -33,7 +33,6 @@ namespace Dawn {
 
       void onInit() override;
       void onDispose() override;
-      void load(std::shared_ptr<SceneLoadContext> ctx) override;
 
       /**
        * Returns the aspect ratio that the camera is using. In future I may 
@@ -58,25 +57,11 @@ namespace Dawn {
        */
       glm::mat4 getProjection();
 
-      /**
-       * Shorthand for getItem()->lookAtPixelPerfect()
-       * 
-       * @param position Position to look from.
-       * @param look Position to look at.
-       * @param scale Scale to use. At scale 1 then the centerest pixel is 1:1.
-       * @return The Z distance that was calculated.
-       */
-      float_t lookAtPixelPerfect(
-        const glm::vec3 &position,
-        const glm::vec3 &look,
-        const float_t &scale = 1.0f
-      );
-
       /**
        * Sets the render target for this camera.
        * 
        * @param renderTarget The render target to set.
        */
-      void setRenderTarget(const std::shared_ptr<RenderTarget> renderTarget);
+      void setRenderTarget(std::shared_ptr<RenderTarget> renderTarget);
   };
 }

src/dawn/component/display/IRenderableComponent.hpp

@@ -17,7 +17,7 @@ namespace Dawn {
        * @param ctx Context for the render pass.
        * @return List of render passes.
        */
-      virtual std::vector<std::shared_ptr<RenderPass>> getPasses(
+      virtual std::vector<std::shared_ptr<IRenderPass>> getPasses(
         struct RenderPassContext &ctx
       ) = 0;
   };
@@ -31,26 +31,26 @@ namespace Dawn {
    * @param data Data to use for the render pass.
    * @return Created render pass.
    */
-  // template<class S, typename D>
-  // std::shared_ptr<IRenderPass> createRenderPass(
-  //   SceneComponent &self,
-  //   const D data,
-  //   const std::unordered_map<
-  //     shadertexturebinding_t, std::shared_ptr<Texture>
-  //   > textures = {},
-  //   const std::shared_ptr<Mesh> mesh = nullptr,
-  //   const enum MeshDrawMode drawMode = MeshDrawMode::TRIANGLES,
-  //   int32_t indiceStart = 0,
-  //   int32_t indiceCount = -1
-  // ) {
-  //   return std::make_shared<RenderPass<S,D>>(
-  //     self,
-  //     data,
-  //     textures,
-  //     mesh,
-  //     drawMode,
-  //     indiceStart,
-  //     indiceCount
-  //   );
-  // }
+  template<class S, typename D>
+  std::shared_ptr<IRenderPass> createRenderPass(
+    SceneComponent &self,
+    const D data,
+    const std::unordered_map<
+      shadertexturebinding_t, std::shared_ptr<Texture>
+    > textures = {},
+    const std::shared_ptr<Mesh> mesh = nullptr,
+    const enum MeshDrawMode drawMode = MeshDrawMode::TRIANGLES,
+    int32_t indiceStart = 0,
+    int32_t indiceCount = -1
+  ) {
+    return std::make_shared<RenderPass<S,D>>(
+      self,
+      data,
+      textures,
+      mesh,
+      drawMode,
+      indiceStart,
+      indiceCount
+    );
+  }
 }

src/dawn/component/display/material/Material.cpp

@@ -4,13 +4,13 @@
 // https://opensource.org/licenses/MIT
 
 #include "Material.hpp"
-#include "game/Game.hpp"
 
 using namespace Dawn;
 
 void Material::onInit() {
-  this->initShaderPrograms();
+
 }
 
 void Material::onDispose() {
+  
 }

src/dawn/component/display/material/Material.hpp

@@ -13,12 +13,6 @@ namespace Dawn {
     public IRenderableComponent
   {
     protected:
-      /**
-       * Load the shaders for this material.
-       */
-      virtual void initShaderPrograms(
-        
-      ) = 0;
 
     public:
       void onInit() override;

src/dawn/component/display/material/SimpleTexturedMaterial.cpp

@@ -4,92 +4,48 @@
 // https://opensource.org/licenses/MIT
 
 #include "SimpleTexturedMaterial.hpp"
-#include "util/JSON.hpp"
-#include "asset/loader/TextureLoader.hpp"
-#include "asset/loader/ShaderLoader.hpp"
 
 using namespace Dawn;
 
-void SimpleTexturedMaterial::initShaderPrograms() {
-  if(this->shader) return;
-
-  auto shaderFile = getGame()->assetManager->get<ShaderLoader>("shaders/simple-textured.slang");
-  this->shader = shaderFile->getShader();
-
-  auto structure = this->shader->getStructure();
-  this->data = structure->createData();
-
-  this->setColor(COLOR_WHITE);
-  this->setTexture(nullptr);
-}
-
-void SimpleTexturedMaterial::load(std::shared_ptr<SceneLoadContext> ctx) {
-  this->initShaderPrograms();
-
-  if(ctx->data.contains("color")) {
-    this->setColor(JSON::color(ctx->data["color"]));
-  }
-
-  if(ctx->data.contains("texture")) {
-    auto asset = ctx->getAsset<TextureLoader>(
-      ctx->data["texture"].get<std::string>()
-    );
-    this->setTexture(asset->getTexture());
-  }
-}
-
 struct Color SimpleTexturedMaterial::getColor() {
-  auto structure = this->shader->getStructure();
-  return data->get<struct Color>(structure->getOffset("color"));
+  return this->data.color;
 }
 
 std::shared_ptr<Texture> SimpleTexturedMaterial::getTexture() {
-  auto structure = this->shader->getStructure();
-  return data->get<std::shared_ptr<Texture>>(structure->getOffset("texture"));
+  return this->texture;
 }
 
-void SimpleTexturedMaterial::setTexture(
-  const std::shared_ptr<Texture> texture
-) {
-  auto structure = this->shader->getStructure();
-  data->set<std::shared_ptr<Texture>>(structure->getOffset("texture"), texture);
-  data->set<bool_t>(structure->getOffset("hasTexture"), texture != nullptr);
+void SimpleTexturedMaterial::setTexture(std::shared_ptr<Texture> texture) {
+  this->texture = texture;
 }
 
 void SimpleTexturedMaterial::setColor(const struct Color color) {
-  auto structure = this->shader->getStructure();
-  data->set<struct Color>(structure->getOffset("color"), color);
+  this->data.color = color;
 }
 
-std::vector<std::shared_ptr<RenderPass>> SimpleTexturedMaterial::getPasses(
+std::vector<std::shared_ptr<IRenderPass>> SimpleTexturedMaterial::getPasses(
   struct RenderPassContext &ctx
 ) {
-  auto structure = this->shader->getStructure();
-
-  data->set<glm::mat4>(
-    structure->getOffset("projection"),
-    ctx.camera->getProjection()
-  );
-
-  data->set<glm::mat4>(
-    structure->getOffset("view"),
-    ctx.camera->getItem()->getWorldTransform()
-  );
-
-  data->set<glm::mat4>(
-    structure->getOffset("model"),
-    this->getItem()->getWorldTransform()
-  );
+  this->data.model = this->getItem()->getWorldTransform();
+  this->data.projection = ctx.camera->getProjection();
+  this->data.view = ctx.camera->getItem()->getWorldTransform();
+  auto textures = std::unordered_map<
+    shadertexturebinding_t, std::shared_ptr<Texture>
+  >();
+  
+  if(this->texture) {
+    this->data.hasTexture = true;
+    this->data.texture = 0;
+    textures[this->data.texture] = this->texture;
+  } else {
+    this->data.hasTexture = false;
+  }
 
   return {
-    std::make_shared<RenderPass>(
+    createRenderPass<SimpleTexturedShader, struct SimpleTexturedShaderData>(
       *this,
-      nullptr,// Get mesh automatically.
-      MeshDrawMode::TRIANGLES,// Move this later.
-      0,// Move this later.
-      -1,// Move this later.
-      this->shader,
-      this->data
+      data,
+      textures
     )
   };
 }

src/dawn/component/display/material/SimpleTexturedMaterial.hpp

@@ -5,19 +5,16 @@
 
 #pragma once
 #include "component/display/material/Material.hpp"
+#include "display/shader/SimpleTexturedShader.hpp"
+#include "display/Texture.hpp"
 
 namespace Dawn {
   class SimpleTexturedMaterial : public Material {
     private:
-      std::shared_ptr<ShaderProgram> shader = nullptr;
-      std::shared_ptr<ShaderData> data;
-      
-    protected:
-      void initShaderPrograms() override;
+      struct SimpleTexturedShaderData data;
+      std::shared_ptr<Texture> texture;
 
     public:
-      void load(std::shared_ptr<SceneLoadContext> ctx) override;
-      
       /**
        * Returns the color of this material.
        */
@@ -35,7 +32,7 @@ namespace Dawn {
        * 
        * @param texture The texture to set.
        */
-      void setTexture(const std::shared_ptr<Texture> texture);
+      void setTexture(std::shared_ptr<Texture> texture);
 
       /**
        * Sets the color of this material.
@@ -44,7 +41,7 @@ namespace Dawn {
        */
       void setColor(const struct Color color);
 
-      std::vector<std::shared_ptr<RenderPass>> getPasses(
+      std::vector<std::shared_ptr<IRenderPass>> getPasses(
         struct RenderPassContext &ctx
       ) override;
   };

src/dawn/component/display/mesh/CMakeLists.txt

@@ -1,12 +0,0 @@
-# Copyright (c) 2024 Dominic Masters
-# 
-# This software is released under the MIT License.
-# https://opensource.org/licenses/MIT
-
-target_sources(${DAWN_TARGET_NAME}
-  PRIVATE
-    MeshComponent.cpp
-    CubeMeshComponent.cpp
-    QuadMeshComponent.cpp
-    PlaneMeshComponent.cpp
-)

src/dawn/component/display/mesh/CubeMeshComponent.cpp

@@ -1,33 +0,0 @@
-// Copyright (c) 2024 Dominic Masters
-// 
-// This software is released under the MIT License.
-// https://opensource.org/licenses/MIT
-
-#include "CubeMeshComponent.hpp"
-#include "display/mesh/CubeMesh.hpp"
-#include "util/JSON.hpp"
-
-using namespace Dawn;
-
-void CubeMeshComponent::meshBuffer(std::shared_ptr<Mesh> mesh) {
-  mesh->createBuffers(CUBE_VERTICE_COUNT, CUBE_INDICE_COUNT);
-  CubeMesh::buffer(
-    mesh,
-    -(size/2.0f),
-    size,
-    0, 0
-  );
-}
-
-void CubeMeshComponent::meshLoad(std::shared_ptr<SceneLoadContext> ctx) {
-  if(ctx->data.contains("size")) {
-    this->size = JSON::vec3(ctx->data["size"]);
-  } else {
-    this->size = glm::vec3(1.0f, 1.0f, 1.0f);
-  }
-}
-
-void CubeMeshComponent::setSize(const glm::vec3 &size) {
-  this->size = size;
-  this->invalidate();
-}

src/dawn/component/display/mesh/CubeMeshComponent.hpp

@@ -1,25 +0,0 @@
-// Copyright (c) 2024 Dominic Masters
-// 
-// This software is released under the MIT License.
-// https://opensource.org/licenses/MIT
-
-#pragma once
-#include "MeshComponent.hpp"
-
-namespace Dawn {
-  class CubeMeshComponent final : public MeshComponent {
-    protected:
-      glm::vec3 size;
-
-      void meshLoad(std::shared_ptr<SceneLoadContext> ctx) override;
-      void meshBuffer(std::shared_ptr<Mesh> mesh) override;
-
-    public:
-      /**
-       * Sets the size of the cube.
-       * 
-       * @param size Size of the cube.
-       */
-      void setSize(const glm::vec3 &size);
-  };
-}

src/dawn/component/display/mesh/MeshComponent.cpp

@@ -1,42 +0,0 @@
-// Copyright (c) 2024 Dominic Masters
-// 
-// This software is released under the MIT License.
-// https://opensource.org/licenses/MIT
-
-#include "MeshComponent.hpp"
-#include "scene/Scene.hpp"
-#include "component/display/MeshRenderer.hpp"
-
-using namespace Dawn;
-
-void MeshComponent::buffer() {
-  if(!mesh) mesh = std::make_shared<Mesh>();
-  this->meshBuffer(mesh);
-  this->valid = true;
-  events.clear();
-}
-
-void MeshComponent::invalidate() {
-  if(!valid) return;
-  valid = false;
-  events.push_back(getScene()->onNextFrame.listen([this]() {
-    this->buffer();
-    valid = true;
-  }));
-}
-
-void MeshComponent::onInit() {
-  this->buffer();
-  auto renderer = getItem()->getComponent<MeshRenderer>();
-  if(renderer) renderer->mesh = mesh;
-}
-
-void MeshComponent::onDispose() {
-  mesh = nullptr;
-}
-
-void MeshComponent::load(std::shared_ptr<SceneLoadContext> ctx) {
-  SceneComponent::load(ctx);
-  if(this->mesh == nullptr) this->mesh = std::make_shared<Mesh>();
-  this->meshLoad(ctx);
-}

src/dawn/component/display/mesh/MeshComponent.hpp

@@ -1,47 +0,0 @@
-// Copyright (c) 2024 Dominic Masters
-// 
-// This software is released under the MIT License.
-// https://opensource.org/licenses/MIT
-
-#pragma once
-#include "scene/SceneItem.hpp"
-#include "display/mesh/Mesh.hpp"
-
-namespace Dawn {
-  class MeshComponent : public SceneComponent {
-    private:
-      bool_t valid = false;
-
-      /**
-       * Buffers the mesh.
-       */
-      void buffer();
-
-    protected:
-      /**
-       * Called when the mesh should be loaded.
-       * 
-       * @param ctx Context to load the mesh from.
-       */
-      virtual void meshLoad(std::shared_ptr<SceneLoadContext> ctx) = 0;
-
-      /**
-       * Called when the mesh should be buffered.
-       * 
-       * @param mesh Mesh to buffer.
-       */
-      virtual void meshBuffer(std::shared_ptr<Mesh> mesh) = 0;
-
-      /**
-       * Invalidates the mesh.
-       */
-      void invalidate();
-
-    public:
-      std::shared_ptr<Mesh> mesh;
-
-      void onInit() override;
-      void onDispose() override;
-      void load(std::shared_ptr<SceneLoadContext> ctx) override;
-  };
-}

src/dawn/component/display/mesh/PlaneMeshComponent.cpp

@@ -1,93 +0,0 @@
-// Copyright (c) 2024 Dominic Masters
-// 
-// This software is released under the MIT License.
-// https://opensource.org/licenses/MIT
-
-#include "PlaneMeshComponent.hpp"
-#include "display/mesh/PlaneMesh.hpp"
-#include "util/JSON.hpp"
-
-using namespace Dawn;
-
-void PlaneMeshComponent::meshLoad(std::shared_ptr<SceneLoadContext> ctx) {
-  if(ctx->data.contains("columns")) {
-    columns = ctx->data["columns"];
-    assertTrue(columns > 0, "Columns must be greater than 0.");
-  } else {
-    columns = 10;
-  }
-
-  if(ctx->data.contains("rows")) {
-    rows = ctx->data["rows"];
-    assertTrue(rows > 0, "Rows must be greater than 0.");
-  } else {
-    rows = columns;
-  }
-
-  if(ctx->data.contains("cells")) {
-    assertTrue(
-      ctx->data["cells"].type() == json::value_t::array,
-      "Cells must be an array."
-    );
-    assertTrue(
-      ctx->data["cells"].size() == 2,
-      "Cells must be an array of 2 integers."
-    );
-    columns = ctx->data["cells"][0];
-    rows = ctx->data["cells"][1];
-    assertTrue(columns > 0, "Columns must be greater than 0.");
-    assertTrue(rows > 0, "Rows must be greater than 0.");
-  }
-
-  if(ctx->data.contains("planeSize")) {
-    planeSize = JSON::vec2(ctx->data["planeSize"]);
-    assertTrue(planeSize.x > 0.0f, "Plane size x must be greater than 0.");
-    assertTrue(planeSize.y > 0.0f, "Plane size y must be greater than 0.");
-  } else if(ctx->data.contains("size")) {
-    planeSize = JSON::vec2(ctx->data["size"]);
-    assertTrue(planeSize.x > 0.0f, "Size x must be greater than 0.");
-    assertTrue(planeSize.y > 0.0f, "Size y must be greater than 0.");
-  } else {
-    planeSize = glm::vec2(10.0f, 10.0f);
-  }
-
-  if(ctx->data.contains("uv")) {
-    uv = JSON::vec4(ctx->data["uv"]);
-  } else {
-    uv = glm::vec4(0.0f, 0.0f, 1.0f, 1.0f);
-  }
-}
-
-void PlaneMeshComponent::meshBuffer(std::shared_ptr<Mesh> mesh) {
-  PlaneMesh::buffer(
-    mesh,
-    planeSize,
-    columns, rows,
-    uv
-  );
-}
-
-void PlaneMeshComponent::setColumns(const int32_t columns) {
-  assertTrue(columns > 0, "Columns must be greater than 0.");
-  this->columns = columns;
-  this->invalidate();
-}
-
-
-void PlaneMeshComponent::setRows(const int32_t rows) {
-  assertTrue(rows > 0, "Rows must be greater than 0.");
-  this->rows = rows;
-  this->invalidate();
-}
-
-void PlaneMeshComponent::setPlaneSize(const glm::vec2 &planeSize) {
-  assertTrue(planeSize.x > 0.0f, "Plane size x must be greater than 0.");
-  assertTrue(planeSize.y > 0.0f, "Plane size y must be greater than 0.");
-  this->planeSize = planeSize;
-  this->invalidate();
-}
-
-void PlaneMeshComponent::setUV(const glm::vec4 &uv) {
-  this->uv = uv;
-  this->invalidate();
-}

src/dawn/component/display/mesh/PlaneMeshComponent.hpp

@@ -1,26 +0,0 @@
-// Copyright (c) 2024 Dominic Masters
-// 
-// This software is released under the MIT License.
-// https://opensource.org/licenses/MIT
-
-#pragma once
-#include "MeshComponent.hpp"
-
-namespace Dawn {
-  class PlaneMeshComponent final : public MeshComponent {
-    protected:
-      int32_t columns;
-      int32_t rows;
-      glm::vec2 planeSize;
-      glm::vec4 uv;
-
-      void meshLoad(std::shared_ptr<SceneLoadContext> ctx) override;
-      void meshBuffer(std::shared_ptr<Mesh> mesh) override;
-
-    public:
-      void setColumns(const int32_t columns);
-      void setRows(const int32_t rows);
-      void setPlaneSize(const glm::vec2 &planeSize);
-      void setUV(const glm::vec4 &uv);
-  };
-}

src/dawn/component/display/mesh/QuadMeshComponent.cpp

@@ -1,44 +0,0 @@
-// Copyright (c) 2024 Dominic Masters
-// 
-// This software is released under the MIT License.
-// https://opensource.org/licenses/MIT
-
-#include "QuadMeshComponent.hpp"
-#include "display/mesh/QuadMesh.hpp"
-#include "util/JSON.hpp"
-
-using namespace Dawn;
-
-void QuadMeshComponent::meshBuffer(std::shared_ptr<Mesh> mesh) {
-  mesh->createBuffers(QUAD_VERTICE_COUNT, QUAD_INDICE_COUNT);
-  QuadMesh::buffer(
-    mesh,
-    this->positions,
-    this->uvs,
-    0, 0
-  );
-}
-
-void QuadMeshComponent::meshLoad(std::shared_ptr<SceneLoadContext> ctx) {
-  if(ctx->data.contains("positions")) {
-    this->positions = JSON::vec4(ctx->data["positions"]);
-  } else {
-    this->positions = glm::vec4(0.0f, 0.0f, 1.0f, 1.0f);
-  }
-
-  if(ctx->data.contains("uvs")) {
-    this->uvs = JSON::vec4(ctx->data["uvs"]);
-  } else {
-    this->uvs = glm::vec4(0.0f, 0.0f, 1.0f, 1.0f);
-  }
-}
-
-void QuadMeshComponent::setPositions(const glm::vec4 &positions) {
-  this->positions = positions;
-  this->invalidate();
-}
-
-void QuadMeshComponent::setUVs(const glm::vec4 &uvs) {
-  this->uvs = uvs;
-  this->invalidate();
-}

src/dawn/component/display/mesh/QuadMeshComponent.hpp

@@ -1,33 +0,0 @@
-// Copyright (c) 2024 Dominic Masters
-// 
-// This software is released under the MIT License.
-// https://opensource.org/licenses/MIT
-
-#pragma once
-#include "MeshComponent.hpp"
-
-namespace Dawn {
-  class QuadMeshComponent final : public MeshComponent {
-    protected:
-      glm::vec4 positions;
-      glm::vec4 uvs;
-    
-      void meshLoad(std::shared_ptr<SceneLoadContext> ctx) override;
-      void meshBuffer(std::shared_ptr<Mesh> mesh) override;
-
-    public:
-      /**
-       * Sets the positions of the quad.
-       * 
-       * @param positions The positions of the quad.
-       */
-      void setPositions(const glm::vec4 &positions);
-
-      /**
-       * Sets the UVs of the quad.
-       * 
-       * @param uvs The UVs of the quad.
-       */
-      void setUVs(const glm::vec4 &uvs);
-  };
-}

src/dawn/component/ui/UICanvas.cpp

@@ -139,6 +139,11 @@ void UICanvas::flushPass() {
   textureBindings.clear();
 }
 
-void UICanvas::addElement(const std::shared_ptr<UIElement> element) {
+void UICanvas::addElement(std::shared_ptr<UIElement> element) {
   elements.push_back(element);
+}
+
+void UICanvas::removeElement(std::shared_ptr<UIElement> element) {
+  auto it = std::find(elements.begin(), elements.end(), element);
+  if(it != elements.end()) elements.erase(it);
 }

src/dawn/component/ui/UICanvas.hpp

@@ -68,6 +68,13 @@ namespace Dawn {
        * 
        * @param component The component to add.
        */
-      void addElement(const std::shared_ptr<UIElement> component);
+      void addElement(std::shared_ptr<UIElement> component);
+
+      /**
+       * Removes a component from the canvas.
+       * 
+       * @param component The component to remove.
+       */
+      void removeElement(std::shared_ptr<UIElement> component);
   };
 }

src/dawn/component/vn/CMakeLists.txt

@@ -5,7 +5,5 @@
 
 target_sources(${DAWN_TARGET_NAME}
   PRIVATE
-    Collider.cpp
-    CubeCollider.cpp
-    SphereCollider.cpp
+    VNManager.cpp
 )

src/dawn/component/vn/VNManager.cpp

@@ -0,0 +1,65 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "VNManager.hpp"
+
+using namespace Dawn;
+
+void VNManager::onInit() {
+  assertNotNull(canvas, "Canvas must be set.");
+  assertNotNull(texture, "Texture must be set.");
+
+  container = std::make_shared<UIContainer>();
+  container->align = { 0, 128, 0, 0 };
+  container->alignX = UIAlignmentType::STRETCH;
+  container->alignY = UIAlignmentType::END;
+
+  borders = std::make_shared<UIRectangle>();
+  borders->align = { 0, 0, 0, 0 };
+  borders->alignX = UIAlignmentType::STRETCH;
+  borders->alignY = UIAlignmentType::STRETCH;
+  borders->color = COLOR_BLUE;
+  container->appendChild(borders);
+
+  background = std::make_shared<UIRectangle>();
+  background->align = { 16, 16, 16, 16 };
+  background->alignX = UIAlignmentType::STRETCH;
+  background->alignY = UIAlignmentType::STRETCH;
+  background->color = COLOR_RED;
+  container->appendChild(background);
+  
+  label = std::make_shared<UILabel>();
+  label->align = { 16, 16, 16, 16 };
+  label->alignX = UIAlignmentType::STRETCH;
+  label->alignY = UIAlignmentType::STRETCH;
+  label->setFont(texture);
+  label->setText(text);
+  container->appendChild(label);
+
+  canvas->addElement(container);
+
+  listeners.push_back(getScene()->onUnpausedUpdate.listen([&](const float_t d) {
+    
+  }));
+
+  auto w = label->getWidth();
+  auto cw = container->getWidth();
+}
+
+void VNManager::onDispose() {
+  canvas->removeElement(container);
+
+  container = nullptr;
+  label = nullptr;
+  background = nullptr;
+  borders = nullptr;
+  texture = nullptr;
+  canvas = nullptr;
+}
+
+void VNManager::setText(const std::wstring &text) {
+  this->text = text;
+  if(label) label->setText(text);
+}

src/dawn/component/vn/VNManager.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 "scene/SceneItem.hpp"
+#include "ui/container/UIContainer.hpp"
+#include "ui/elements/UILabel.hpp"
+#include "ui/elements/UIRectangle.hpp"
+
+namespace Dawn {
+  class VNManager : public SceneComponent {
+    protected:
+      std::shared_ptr<UIContainer> container;
+      std::shared_ptr<UILabel> label;
+      std::shared_ptr<UIRectangle> borders;
+      std::shared_ptr<UIRectangle> background;
+      std::wstring text;
+
+    public:
+      std::shared_ptr<UICanvas> canvas;
+      std::shared_ptr<TrueTypeTexture> texture;
+
+
+      void onInit() override;
+      void onDispose() override;
+
+      /**
+       * Sets the text to display.
+       * 
+       * @param text The text to display.
+       */
+      void setText(const std::wstring &text);
+  };
+}

src/dawn/display/CMakeLists.txt

@@ -12,8 +12,6 @@ target_sources(${DAWN_TARGET_NAME}
 )
 
 # Subdirs
-add_subdirectory(mesh)
-add_subdirectory(shader)
 add_subdirectory(font)
-add_subdirectory(tileset)
-add_subdirectory(pass)
+add_subdirectory(mesh)
+add_subdirectory(shader)

src/dawn/display/Color.hpp

@@ -4,7 +4,7 @@
 // https://opensource.org/licenses/MIT
 
 #pragma once
-#include "dawn.hpp"
+#include "dawnlibs.hpp"
 
 namespace Dawn {
   struct ColorU8 {

src/dawn/display/IRenderHost.cpp

@@ -7,7 +7,7 @@
 
 using namespace Dawn;
 
-IRenderHost::IRenderHost() {
+IRenderHost::IRenderHost() : renderPipeline(), shaderManager() {
 }
 
 IRenderHost::~IRenderHost() {

src/dawn/display/IRenderHost.hpp

@@ -4,9 +4,10 @@
 // https://opensource.org/licenses/MIT
 
 #pragma once
-#include "dawn.hpp"
+#include "dawnlibs.hpp"
 #include "display/RenderTarget.hpp"
 #include "display/RenderPipeline.hpp"
+#include "display/shader/ShaderManager.hpp"
 
 namespace Dawn {
   class Game;
@@ -14,6 +15,7 @@ namespace Dawn {
   class IRenderHost {
     public:
       RenderPipeline renderPipeline;
+      ShaderManager shaderManager;
 
       /**
        * Creates a render host.

src/dawn/display/ITexture.hpp

@@ -33,12 +33,12 @@ namespace Dawn {
 
   class ITexture {
     public:
-      TextureWrapMode wrapModeX = TextureWrapMode::REPEAT;
-      TextureWrapMode wrapModeY = TextureWrapMode::REPEAT;
-      TextureFilterMode filterModeMin = TextureFilterMode::NEAREST;
-      TextureFilterMode filterModeMag = TextureFilterMode::NEAREST;
-      TextureFilterMode mipMapFilterModeMin = TextureFilterMode::NEAREST;
-      TextureFilterMode mipMapFilterModeMag = TextureFilterMode::NEAREST;
+      enum TextureWrapMode wrapModeX = TextureWrapMode::REPEAT;
+      enum TextureWrapMode wrapModeY = TextureWrapMode::REPEAT;
+      enum TextureFilterMode filterModeMin = TextureFilterMode::NEAREST;
+      enum TextureFilterMode filterModeMag = TextureFilterMode::NEAREST;
+      enum TextureFilterMode mipMapFilterModeMin = TextureFilterMode::NEAREST;
+      enum TextureFilterMode mipMapFilterModeMag = TextureFilterMode::NEAREST;
 
       /**
        * Returns the width of the texture.
@@ -65,8 +65,8 @@ namespace Dawn {
       virtual void setSize(
         const int32_t width,
         const int32_t height,
-        const TextureFormat format,
-        const TextureDataFormat dataFormat
+        const enum TextureFormat format,
+        const enum TextureDataFormat dataFormat
       ) = 0;
 
       /**

src/dawn/display/RenderPipeline.cpp

@@ -38,7 +38,7 @@ void RenderPipeline::renderScene(
 
   // Get a list of all cameras in the scene
   auto cameras = scene->findComponents<Camera>();
-  auto backBuffer = scene->getGame()->renderHost->getBackBufferRenderTarget();
+  auto backBuffer = scene->getGame()->renderHost.getBackBufferRenderTarget();
 
   std::shared_ptr<Camera> backbufferCamera = nullptr;
   for(auto camera : cameras) {
@@ -78,14 +78,12 @@ void RenderPipeline::renderSceneCamera(
   };
 
   // Get list of renderables
-  std::vector<std::shared_ptr<RenderPass>> renderPasses;
+  std::vector<std::shared_ptr<IRenderPass>> renderPasses;
   auto renderables = scene->findComponents<IRenderableComponent>();
   for(auto renderable : renderables) {
     auto rp = renderable->getPasses(ctx);
     renderPasses.insert(renderPasses.end(), rp.begin(), rp.end());
   }
-
-  // TODO: Sort the render passes by priority and z-index
   
   // TODO: Make clearing the buffers editable!
   renderTarget->bind();
@@ -95,6 +93,9 @@ void RenderPipeline::renderSceneCamera(
   );
   
   for(auto renderPass : renderPasses) {
+    renderPass->bind();
+    renderPass->setData();
+    renderPass->upload();
     renderPass->draw();
   }
 }

src/dawn/display/RenderPipeline.hpp

@@ -4,7 +4,7 @@
 // https://opensource.org/licenses/MIT
 
 #pragma once
-#include "dawn.hpp"
+#include "dawnlibs.hpp"
 
 namespace Dawn {
   class Game;

src/dawn/display/font/CMakeLists.txt

@@ -6,4 +6,4 @@
 target_sources(${DAWN_TARGET_NAME}
   PRIVATE
     TrueTypeTexture.cpp
-)
+)

src/dawn/display/font/TrueTypeCharacter.hpp

@@ -4,7 +4,7 @@
 // https://opensource.org/licenses/MIT
 
 #pragma once
-#include "dawn.hpp"
+#include "dawnlibs.hpp"
 
 namespace Dawn {
   struct TrueTypeCharacter {

src/dawn/display/font/TrueTypeTexture.cpp

@@ -10,14 +10,14 @@
 
 using namespace Dawn;
 
-TrueTypeTexture::TrueTypeTexture(const uint32_t &fontSize) :
+TrueTypeTexture::TrueTypeTexture(const uint32_t fontSize) :
   fontSize(fontSize)
 {
   assertTrue(fontSize > 0, "Font size cannot be zero");
   texture = std::make_shared<Texture>();
 }
 
-void TrueTypeTexture::setFace(const FT_Face &face) {
+void TrueTypeTexture::setFace(const FT_Face face) {
   this->face = face;
   assertTrue(fontSize < 256, "Font size cannot be greater than 256");
 
@@ -130,7 +130,7 @@ void TrueTypeTexture::setFace(const FT_Face &face) {
   delete[] buffer;
 }
 
-struct TrueTypeCharacter TrueTypeTexture::getCharacterData(const wchar_t &c) {
+struct TrueTypeCharacter TrueTypeTexture::getCharacterData(wchar_t c) {
   return this->characterData[c];
 }
 
@@ -138,7 +138,7 @@ glm::vec2 TrueTypeTexture::bufferStringToMesh(
   std::shared_ptr<Mesh> mesh,
   const std::wstring text,
   glm::vec2 &position,
-  const bool_t flipY
+  bool_t flipY
 ) {
   assertNotNull(mesh, "Mesh must be supplied and not null");
   assertTrue(text.size() > 0, "Text must be at least one character long.");
@@ -195,4 +195,4 @@ glm::vec2 TrueTypeTexture::bufferStringToMesh(
 }
 
 TrueTypeTexture::~TrueTypeTexture() {
-}
+}

src/dawn/display/font/TrueTypeTexture.hpp

@@ -25,14 +25,14 @@ namespace Dawn {
        * 
        * @param fontSize Size of the font.
        */
-      TrueTypeTexture(const uint32_t &fontSize);
+      TrueTypeTexture(const uint32_t fontSize);
 
       /**
        * Sets the face for this texture.
        * 
        * @param face Face to set.
        */
-      void setFace(const FT_Face &face);
+      void setFace(const FT_Face face);
 
       /**
        * Returns the character data for the given character.
@@ -40,7 +40,7 @@ namespace Dawn {
        * @param c Character to get data for.
        * @return The Character data for the given character.
        */
-      struct TrueTypeCharacter getCharacterData(const wchar_t &c);
+      struct TrueTypeCharacter getCharacterData(wchar_t c);
 
       /**
        * Buffers a string to the given mesh.
@@ -55,7 +55,7 @@ namespace Dawn {
         std::shared_ptr<Mesh> mesh,
         const std::wstring text,
         glm::vec2 &position,
-        const bool_t flipY = false
+        bool_t flipY = false
       );
 
       /**

src/dawn/display/mesh/CMakeLists.txt

@@ -8,6 +8,4 @@ target_sources(${DAWN_TARGET_NAME}
   PRIVATE
     CubeMesh.cpp
     QuadMesh.cpp
-    SphereMesh.cpp
-    PlaneMesh.cpp
 )