Technically working shaders.

.gitea/workflows/release.yml

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

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

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

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

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

.gitignore

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

.gitmodules

@@ -1,6 +0,0 @@
-[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,16 +7,12 @@ cmake_minimum_required(VERSION 3.13)
 set(CMAKE_C_STANDARD 99)
 set(CMAKE_C_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_STANDARD 20)
-set(CMAKE_CXX_STANDARD_REQUIRED True)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 # 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}")
@@ -27,7 +23,11 @@ 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")
 
-# Initialize Project.
+# Options
+option(DAWN_ENABLE_PHYSICS "Enable Physics" OFF)
+option(DAWN_DEBUG_SHADERS "Enable Debug Shaders" ON)
+
+# Initialize Project First.
 project(Dawn
   VERSION 1.0.0
   LANGUAGES C CXX

archive/Shader.hpp

@@ -87,6 +87,27 @@ namespace Dawn {
         assertNoGLError();
         assertTrue(status == GL_TRUE, "Failed to link shader program.");
 
+        std::vector<std::string> uniformNames;
+        GLint numUniforms = 0;
+
+        // Get the number of active uniforms
+        glGetProgramiv(shaderProgram, GL_ACTIVE_UNIFORMS, &numUniforms);
+        assertNoGLError();
+
+        // Iterate through each uniform
+        // for (GLint i = 0; i < numUniforms; ++i) {
+        //   char name[256];
+        //   GLsizei length;
+        //   GLint size;
+        //   GLenum type;
+
+        //   // Get the uniform name
+        //   glGetActiveUniform(shaderProgram, i, sizeof(name), &length, &size, &type, name);
+        //   assertNoGLError();
+        //   std::cout << "Uniform: " << i << ":" << name << std::endl;
+        //   // uniformNames.push_back(std::string(name));
+        // }
+
         // Map parameters correctly.
         std::for_each(
           parameters.begin(),

archive/ShaderStage.cpp

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

archive/ShaderStage.hpp

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

archive/ShaderStructure.hpp

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

archive/SimpleTexturedShader.cpp

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

archive/SimpleTexturedShader.hpp

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

archive/component/ui/UICanvas.cpp

@@ -139,11 +139,6 @@ void UICanvas::flushPass() {
   textureBindings.clear();
 }
 
-void UICanvas::addElement(std::shared_ptr<UIElement> element) {
+void UICanvas::addElement(const 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);
 }

archive/component/ui/UICanvas.hpp

@@ -68,13 +68,6 @@ namespace Dawn {
        * 
        * @param component The component to add.
        */
-      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);
+      void addElement(const std::shared_ptr<UIElement> component);
   };
 }

archive/ui/UIAlignableElement.cpp

@@ -200,22 +200,27 @@ void UIAlignableElement::updateSelfAlignment(
 }
 
 bool_t UIAlignableElement::hasExplicitWidth() {
-  if(alignX == UIAlignmentType::STRETCH) return true;
-  if(alignX == UIAlignmentType::END) {
-    return align[1] != UI_ALIGN_SIZE_AUTO;
-  }
-  return align[3] != UI_ALIGN_SIZE_AUTO;
-
-}
-
-bool_t UIAlignableElement::hasExplicitHeight() {
-  if(alignY == UIAlignmentType::STRETCH) return true;
-  if(alignY == UIAlignmentType::END) {
+  if(size.x == 0.0f) return false;
+  if(
+    (alignX == UIAlignmentType::STRETCH) ||
+    (alignX == UIAlignmentType::END)
+  ) {
     return align[0] != UI_ALIGN_SIZE_AUTO;
   }
   return align[2] != UI_ALIGN_SIZE_AUTO;
 }
 
+bool_t UIAlignableElement::hasExplicitHeight() {
+  if(size.y == 0.0f) return false;
+  if(
+    (alignY == UIAlignmentType::STRETCH) ||
+    (alignY == UIAlignmentType::END)
+  ) {
+    return align[1] != UI_ALIGN_SIZE_AUTO;
+  }
+  return align[3] != UI_ALIGN_SIZE_AUTO;
+}
+
 float_t UIAlignableElement::getWidth() {
   if(hasExplicitWidth()) return size.x;
   return getContentWidth();

assets/dawnrpg/CMakeLists.txt

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

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

assets/en.json

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

assets/maps/testmap.json

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

assets/materials/simple-textured.json

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

assets/prefabs/npc.json

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

assets/prefabs/rosa.json

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

assets/scenes/test_rpg_scene.json

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

assets/shaders/simple-textured.slang

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

lib/CMakeLists.txt

@@ -5,33 +5,65 @@
 
 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)
 
-# LibArchive
-FetchContent_Declare(libarchive URL https://github.com/libarchive/libarchive/releases/download/v3.7.6/libarchive-3.7.6.tar.xz)
-FetchContent_MakeAvailable(libarchive)
+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 URL https://psychz.dl.sourceforge.net/project/freetype/freetype2/2.13.3/freetype-2.13.3.tar.xz?viasf=1)
+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
+)
+FetchContent_MakeAvailable(libarchive)
+
+# JSON
+FetchContent_Declare(
+  json
+  URL https://github.com/nlohmann/json/releases/download/v3.11.3/json.tar.xz
+)
+FetchContent_MakeAvailable(json)
+
+# JOLT Physics
+if(DAWN_ENABLE_PHYSICS)
+  FetchContent_Declare(
+    JoltPhysics
+    GIT_REPOSITORY "https://github.com/jrouwe/JoltPhysics"
+    GIT_TAG "v5.2.0"
+    SOURCE_SUBDIR "Build"
+  )
+  FetchContent_MakeAvailable(JoltPhysics)
+endif()
+
+# SLANG
+set(SLANG_ENABLE_GFX ON CACHE BOOL "Enable GFX" FORCE)
+FetchContent_Declare(
+  slang
+  GIT_REPOSITORY https://github.com/shader-slang/slang
+  GIT_TAG v2024.17
+)
+FetchContent_MakeAvailable(slang)
+
+
+# OpenAL
 # if(DAWN_TARGET_OPENAL)
 #   set(LIBTYPE "STATIC")
 #   add_subdirectory(openal-soft)

lib/glad/include/KHR/khrplatform.h

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

src/CMakeLists.txt

@@ -6,18 +6,29 @@
 # 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)
 
-# 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")
+if(DAWN_ENABLE_PHYSICS)
+  add_subdirectory(dawnphysics)
 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,10 +6,11 @@
 # Libraries
 target_link_libraries(${DAWN_TARGET_NAME}
   PUBLIC
-    glm::glm
     archive_static
-    freetype
+    glm::glm
     nlohmann_json::nlohmann_json
+    freetype
+    slang
 )
 
 # Includes
@@ -18,6 +19,12 @@ 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)
@@ -26,15 +33,16 @@ 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(state)
+add_subdirectory(settings)
 add_subdirectory(time)
 add_subdirectory(util)
-add_subdirectory(ui)
+
+
+# Assets
+tool_copy(en en.json)
+tool_copy(simpleTexturedShader shaders/simple-textured.slang)
+
+add_dependencies(${DAWN_TARGET_NAME} dawnassets)

src/dawn/assert/assert.hpp

@@ -6,7 +6,7 @@
  */
 
 #pragma once
-#include "dawnlibs.hpp"
+#include "util/Flag.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( \
-  (value & flag) == 0, __VA_ARGS__ \
+  Flag::isOff(value, flag), __VA_ARGS__ \
 )
 
 /**
@@ -116,7 +116,7 @@ void assertTrueImplement(
  * @param args Optional TParam args for the sprintf message to accept.
  */
 #define assertFlagOn(value, flag, ...) assertTrue( \
-  (value & flag) == flag, __VA_ARGS__ \
+  Flag::isOn(value, flag), __VA_ARGS__ \
 )
 
 /**

src/dawn/asset/AssetDataLoader.cpp

@@ -60,24 +60,58 @@ int32_t assetDataLoaderArchiveClose(struct archive *a, void *d) {
 
 // // // // // // // // // // // // // // // // // // // // // // // // // // //
 
-AssetDataLoader::AssetDataLoader(std::string fileName) : fileName(fileName) {
+AssetDataLoader::AssetDataLoader(const std::string &fileName) :
+  fileName(fileName)
+{
   assertTrue(
     fileName.size() > 0,
     "IAssetDataLoader::IAssetDataLoader: fileName must be greater than 0"
   );
 }
 
+size_t AssetDataLoader::getSize() {
+  assertTrue(this->assetArchiveEntry != nullptr, "Entry is NULL!");
+  assertTrue(
+    archive_entry_size_is_set(assetArchiveEntry),
+    "Entry size is not set!"
+  );
+  return archive_entry_size(assetArchiveEntry);
+}
+
+size_t AssetDataLoader::getPosition() {
+  assertNotNull(this->assetArchiveFile, "File is not open!");
+  return this->position;
+}
+
+std::string AssetDataLoader::getEntireContentsAsString() {
+  if(!this->isOpen()) {
+    this->open();
+  } else {
+    this->rewind();
+  }
+
+  std::string buffer;
+  buffer.resize(this->getSize());
+  this->read((uint8_t*)buffer.data(), buffer.size());
+  this->close();
+  return buffer;
+}
+
+bool_t AssetDataLoader::isOpen() {
+  return this->assetArchive != nullptr;
+}
+
 void AssetDataLoader::open() {
-  assertNull(this->assetArchiveFile, "AssetDataLoader::open: File is already open");
-  assertNull(this->assetArchive, "AssetDataLoader::open: Archive is already open");
-  assertNull(this->assetArchiveEntry, "AssetDataLoader::open: Entry is already open");
+  assertNull(this->assetArchiveFile, "File is already open");
+  assertNull(this->assetArchive, "Archive is already open");
+  assertNull(this->assetArchiveEntry, "Entry is already open");
 
   this->assetArchiveFile = this->openAssetArchiveFile();
-  assertNotNull(this->assetArchiveFile, "AssetDataLoader::open: Failed to open archive file!");
+  assertNotNull(this->assetArchiveFile, "Failed to open archive file!");
 
   // Open archive reader
   assetArchive = archive_read_new();
-  assertNotNull(assetArchive, "AssetDataLoader::open: Failed to create archive reader");
+  assertNotNull(assetArchive, "Failed to create archive reader");
 
   // Set up the reader
   archive_read_support_format_tar(assetArchive);
@@ -90,28 +124,30 @@ void AssetDataLoader::open() {
   archive_read_set_callback_data(assetArchive, this);
 
   int32_t ret =  archive_read_open1(assetArchive);
-  assertTrue(ret == ARCHIVE_OK, "AssetDataLoader::open: Failed to open archive!");
+  assertTrue(ret == ARCHIVE_OK, "Failed to open archive!");
   position = 0;
 
   // Iterate over each file to find the one for this asset loader.
-  while(archive_read_next_header(assetArchive, &assetArchiveEntry) == ARCHIVE_OK) {
-    const char_t *headerFile = (char_t*)archive_entry_pathname(assetArchiveEntry);
+  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, "AssetDataLoader::open: Failed to skip data!");
+    assertTrue(ret == ARCHIVE_OK, "Failed to skip data!");
   }
 
-  assertUnreachable("AssetDataLoader::open: Failed to find file!");
+  assertUnreachable("Failed to find file!");
 }
 
 int32_t AssetDataLoader::close() {
-  assertNotNull(this->assetArchiveFile, "AssetDataLoader::close: File is NULL");
-  assertNotNull(this->assetArchive, "AssetDataLoader::close: Archive is NULL!");
-  assertNotNull(this->assetArchiveEntry, "AssetDataLoader::close: Entry is NULL!");
+  assertNotNull(this->assetArchiveFile, "File is NULL");
+  assertNotNull(this->assetArchive, "Archive is NULL!");
+  assertNotNull(this->assetArchiveEntry, "Entry is NULL!");
   
   // Close the archive
   int32_t ret = archive_read_free(this->assetArchive);
-  assertTrue(ret == ARCHIVE_OK, "AssetDataLoader::close: Failed to close archive!");
+  assertTrue(ret == ARCHIVE_OK, "Failed to close archive!");
 
   this->assetArchive = nullptr;
   this->assetArchiveEntry = nullptr;
@@ -122,11 +158,11 @@ int32_t AssetDataLoader::close() {
   return res;
 }
 
-size_t AssetDataLoader::read(uint8_t *buffer, size_t size) {
+size_t AssetDataLoader::read(uint8_t *buffer, const size_t &size) {
   assertNotNull(buffer, "Buffer is NULL!");
   assertTrue(size > 0, "Size must be greater than 0!");
-  assertNotNull(this->assetArchive, "assetRead: Archive is NULL!");
-  assertNotNull(this->assetArchiveEntry, "assetRead: Entry is NULL!");
+  assertNotNull(this->assetArchive, "Archive is NULL!");
+  assertNotNull(this->assetArchiveEntry, "Entry is NULL!");
 
   ssize_t read = archive_read_data(this->assetArchive, buffer, size);
   this->position += read;
@@ -135,8 +171,8 @@ size_t AssetDataLoader::read(uint8_t *buffer, size_t size) {
     assertUnreachable(archive_error_string(this->assetArchive));
   }
   
-  assertTrue(read != ARCHIVE_RETRY, "assetRead: Failed to read data (RETRY)!");
-  assertTrue(read != ARCHIVE_WARN, "assetRead: Failed to read data (WARN)!");
+  assertTrue(read != ARCHIVE_RETRY, "Failed to read data (RETRY)!");
+  assertTrue(read != ARCHIVE_WARN, "Failed to read data (WARN)!");
 
   return read;
 }
@@ -156,23 +192,19 @@ size_t AssetDataLoader::readUntil(
   return i;
 }
 
-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.");
+size_t AssetDataLoader::skip(const size_t &n) {
+  assertTrue(n >= 0, "Byte count must be greater than 0.");
+  assertTrue(n < (this->getSize() - this->position), "Cannot skip past EOF!");
 
   uint8_t dumpBuffer[ASSET_LOADER_BUFFER_SIZE];
   size_t skipped = 0;
-  size_t n2, n3;
-  while(n != 0) {
-    n2 = Math::min<size_t>(n, ASSET_LOADER_BUFFER_SIZE);
+  size_t n2, n3, n4;
+  n4 = n;
+  while(n4 != 0) {
+    n2 = Math::min<size_t>(n4, ASSET_LOADER_BUFFER_SIZE);
     n3 = this->read(dumpBuffer, n2);
-    assertTrue(n3 == n2, "AssetDataLoader::skip: Failed to skip bytes!");
-    n -= n3;
+    assertTrue(n3 == n2, "Failed to skip bytes!");
+    n4 -= n3;
   }
 
   return skipped;
@@ -185,16 +217,14 @@ 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 "dawnlibs.hpp"
+#include "dawn.hpp"
 
 extern "C" {
   #include <archive.h>
@@ -88,7 +88,34 @@ namespace Dawn {
        * 
        * @param fileName File name of the asset that is to be loaded.
        */
-      AssetDataLoader(std::string filename);
+      AssetDataLoader(const std::string &filename);
+      
+      /**
+       * Get the size of the asset.
+       * @return The size of the asset in bytes.
+       */
+      size_t getSize();
+
+      /**
+       * Returns the current position of the read head.
+       * 
+       * @return The current read head position.
+       */
+      size_t getPosition();
+
+      /**
+       * Get the entire contents of the asset as a string.
+       * 
+       * @return The entire contents of the asset as a string.
+       */
+      std::string getEntireContentsAsString();
+
+      /**
+       * Check if the asset is open.
+       * 
+       * @return True if the asset is open, otherwise false.
+       */
+      bool_t isOpen();
 
       /**
        * Platform-centric method to open a file buffer to an asset.
@@ -107,7 +134,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, size_t size);
+      size_t read(uint8_t *buffer, const size_t &size);
 
       /**
        * Reads bytes from the buffer until a given delimiter is found. Returned
@@ -123,12 +150,6 @@ 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.
@@ -136,7 +157,7 @@ namespace Dawn {
        * @param n Count of bytes to progress the read head by.
        * @return Count of bytes progressed.
        */
-      size_t skip(size_t n);
+      size_t skip(const size_t &n);
 
       /**
        * Rewind the read head to the beginning of the file.
@@ -151,13 +172,6 @@ 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,13 +5,38 @@
 
 #include "AssetLoader.hpp"
 #include "assert/assert.hpp"
+#include "asset/AssetManager.hpp"
 
 using namespace Dawn;
 
-AssetLoader::AssetLoader(const std::string name) : name(name) {
-  assertTrue(name.size() > 0, "Asset::Asset: Name cannot be empty");
+const std::string AssetLoader::ASSET_TYPE = "unknown";
+
+AssetLoader::AssetLoader(
+  const std::shared_ptr<AssetManager> assetManager,
+  const std::string name
+) :
+  assetManager(assetManager),
+  name(name)
+{
+  assertNotNull(assetManager, "AssetManager cannot be null");
+  assertTrue(name.size() > 0, "Name cannot be empty");
+
+  std::cout << "Loading: " << name << std::endl;
+}
+
+std::shared_ptr<AssetManager> AssetLoader::getAssetManager() {
+  auto am = this->assetManager.lock();
+  assertNotNull(am, "AssetManager is null");
+  return am;
+}
+
+void AssetLoader::loadImmediately() {
+  while(!this->loaded) {
+    this->getAssetManager()->update();
+  }
 }
 
 AssetLoader::~AssetLoader() {
   this->loaded = false;
+  std::cout << "Unloading: " << name << std::endl;
 }

src/dawn/asset/AssetLoader.hpp

@@ -4,11 +4,19 @@
 // https://opensource.org/licenses/MIT
 
 #pragma once
-#include "dawnlibs.hpp"
+#include "dawn.hpp"
 
 namespace Dawn {
+  class AssetManager;
+
   class AssetLoader {
+    private:
+      std::weak_ptr<AssetManager> assetManager;
+
     public:
+      std::string typetest;
+      const static std::string ASSET_TYPE;
+
       const std::string name;
       bool_t loaded = false;
 
@@ -17,7 +25,10 @@ namespace Dawn {
        * 
        * @param name Name of the asset.
        */
-      AssetLoader(const std::string name);
+      AssetLoader(
+        const std::shared_ptr<AssetManager> assetManager,
+        const std::string name
+      );
 
       /**
        * Virtual function that will be called by the asset manager on a 
@@ -32,6 +43,25 @@ 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,50 +4,61 @@
 // https://opensource.org/licenses/MIT
 
 #include "AssetManager.hpp"
-#include "loaders/TextureLoader.hpp"
-#include "loaders/TrueTypeLoader.hpp"
-#include "loaders/JSONLoader.hpp"
+#include "assert/assert.hpp"
 
 using namespace Dawn;
 
-void AssetManager::init() {
-
+void AssetManager::init(const std::shared_ptr<Game> &game) {
+  assertNotNull(game, "Game is NULL?");
+  this->game = game;
 }
 
 void AssetManager::update() {
-  auto itPending = pendingAssetLoaders.begin();
-  while(itPending != pendingAssetLoaders.end()) {
+  auto copyPendingAssets = pendingAssetLoaders;
+  auto itPending = copyPendingAssets.begin();
+  while(itPending != copyPendingAssets.end()) {
     auto loader = *itPending;
+    
     loader->updateSync();
     loader->updateAsync();
-    if(loader->loaded) {
-      finishedAssetLoaders.push_back(loader);
-      itPending = pendingAssetLoaders.erase(itPending);
-    } else {
-      itPending++;
+    loader->updateSync();
+
+    if(!loader->loaded) {
+      ++itPending;
+      continue;
     }
+    
+    finishedAssetLoaders.push_back(loader);
+    auto it = std::find(
+      pendingAssetLoaders.begin(),
+      pendingAssetLoaders.end(),
+      loader
+    );
+    assertTrue(it != pendingAssetLoaders.end(), "Loader not found?");
+    pendingAssetLoaders.erase(it);
+    ++itPending;
   }
 }
 
-void AssetManager::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);
+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;
   }
 
-  existing = std::find_if(
-    finishedAssetLoaders.begin(), finishedAssetLoaders.end(),
-    [&](auto &loader) {
-      return loader->name == filename;
-    }
-  );
-  if(existing != finishedAssetLoaders.end()) {
-    finishedAssetLoaders.erase(existing);
+  for(
+    auto it = finishedAssetLoaders.begin();
+    it != finishedAssetLoaders.end();
+    it++
+  ) {
+    if(it->lock() != loader) continue;
+    finishedAssetLoaders.erase(it);
+    return;
   }
 }
 
@@ -55,47 +66,12 @@ bool_t AssetManager::isEverythingLoaded() {
   return pendingAssetLoaders.size() == 0;
 }
 
-bool_t AssetManager::isLoaded(const std::string filename) {
-  auto existing = this->getExisting<AssetLoader>(filename);
-  if(existing) return existing->loaded;
-  return false;
+std::shared_ptr<Game> AssetManager::getGame() {
+  auto g = game.lock();
+  assertNotNull(g, "Game is NULL?");
+  return g;
 }
 
-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,14 +4,17 @@
 // https://opensource.org/licenses/MIT
 
 #pragma once
-#include "dawnlibs.hpp"
+#include "dawn.hpp"
 #include "asset/AssetLoader.hpp"
 
 namespace Dawn {
-  class AssetManager final {
+  class Game;
+
+  class AssetManager final : public std::enable_shared_from_this<AssetManager> {
     private:
+      std::weak_ptr<Game> game;
       std::vector<std::shared_ptr<AssetLoader>> pendingAssetLoaders;
-      std::vector<std::shared_ptr<AssetLoader>> finishedAssetLoaders;
+      std::vector<std::weak_ptr<AssetLoader>> finishedAssetLoaders;
 
       /**
        * Returns an existing asset loader if it exists.
@@ -20,26 +23,22 @@ namespace Dawn {
        * @return The asset loader if it exists, otherwise nullptr.
        */
       template<class T>
-      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;
+      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);
         }
 
-        return std::static_pointer_cast<T>(*existing);
+        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;
       }
 
       /**
@@ -47,13 +46,15 @@ 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();
+      void init(const std::shared_ptr<Game> &game);
 
       /**
        * Updates the asset manager.
@@ -68,36 +69,42 @@ 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);
+      std::shared_ptr<T> get(const std::string &filename) {
+        auto existing = this->getExisting<T>(filename);
+        if(existing) return existing;
+
+        std::shared_ptr<T> loader = std::make_shared<T>(
+          shared_from_this(),
+          filename
+        );
+        pendingAssetLoaders.push_back(
+          std::static_pointer_cast<AssetLoader>(loader)
+        );
+        return loader;
+      }
 
       /**
-       * Returns the asset loader for the given asset.
+       * Returns the game context that this asset manager is attached to.
        * 
-       * @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.
+       * @return The game context.
        */
-      template<class T>
-      std::shared_ptr<T> get(
-        const std::string filename,
-        const uint32_t fontSize
-      );
+      std::shared_ptr<Game> getGame();
+
+      /**
+       * Removes the given asset loader from the asset manager, assumes that
+       * nothing else needs to access it and any dangling shared_ptrs will have
+       * to remain in memory.
+       * 
+       * @param loader The asset loader to remove.
+       */
+      void remove(const std::shared_ptr<AssetLoader> loader);
 
       /**
        * Dispose the asset manager, and all attached assets.

src/dawn/asset/CMakeLists.txt

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

src/dawn/asset/loader/CMakeLists.txt

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

src/dawn/asset/loader/JSONLoader.cpp

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

src/dawn/asset/loader/JSONLoader.hpp

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

src/dawn/asset/loader/ShaderLoader.cpp

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

src/dawn/asset/loader/ShaderLoader.hpp

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

src/dawn/asset/loader/StringLoader.cpp

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

src/dawn/asset/loader/StringLoader.hpp

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

src/dawn/asset/loader/TextureLoader.cpp

@@ -8,13 +8,18 @@
 
 using namespace Dawn;
 
-TextureLoader::TextureLoader(const std::string name) :
-  AssetLoader(name),
-  loader(name + ".texture"),
+const std::string TextureLoader::ASSET_TYPE = "texture";
+
+TextureLoader::TextureLoader(
+  const std::shared_ptr<AssetManager> assetManager,
+  const std::string name
+) :
+  AssetLoader(assetManager, name),
+  loader(name),
   state(TextureLoaderLoadState::INITIAL)
 {
-  sharedTexture = std::make_shared<Texture>();
-  weakTexture = sharedTexture;
+  this->typetest = this->getAssetType();
+  texture = std::make_shared<Texture>();
 }
 
 void TextureLoader::updateAsync() {
@@ -114,34 +119,39 @@ void TextureLoader::updateSync() {
   if(this->state != TextureLoaderLoadState::ASYNC_DONE) return;
   this->state = TextureLoaderLoadState::SYNC_LOADING;
 
-  assertNotNull(this->sharedTexture, "Texture is null!");
+  assertNotNull(this->texture, "Texture is null!");
   assertNotNull(this->data, "Texture data is null!");
 
   // Setup Texture
-  this->sharedTexture->setSize(
+  this->texture->setSize(
     this->width,
     this->height,
     this->format,
     TextureDataFormat::UNSIGNED_BYTE
   );
-  this->sharedTexture->buffer(this->data);
+  this->texture->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->sharedTexture = nullptr;
+  this->texture = nullptr;
 }

src/dawn/asset/loader/TextureLoader.hpp

@@ -30,26 +30,26 @@ namespace Dawn {
       enum TextureWrapMode wrapY;
       enum TextureFilterMode filterMin;
       enum TextureFilterMode filterMag;
+      std::shared_ptr<Texture> texture;
 
     public:
-      std::shared_ptr<Texture> sharedTexture;
-      std::weak_ptr<Texture> weakTexture;
+      const static std::string ASSET_TYPE;
 
-      /**
-       * 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);
+      TextureLoader(
+        const std::shared_ptr<AssetManager> assetManager,
+        const std::string name
+      );
 
       void updateSync() override;
       void updateAsync() override;
+      std::string getAssetType() const override;
 
       /**
-       * Dispose / Cleanup the texture asset. Will also dispose the underlying
-       * texture itself.
+       * Get the texture asset.
+       * 
+       * @return Texture asset.
        */
+      std::shared_ptr<Texture> getTexture();
       ~TextureLoader();
   };
 }

src/dawn/asset/loader/TrueTypeLoader.cpp

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

src/dawn/asset/loader/TrueTypeLoader.hpp

@@ -27,16 +27,16 @@ namespace Dawn {
       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);
+      const static std::string ASSET_TYPE;
+
+      TrueTypeLoader(
+        const std::shared_ptr<AssetManager> assetManager,
+        const std::string name
+      );
 
       void updateSync() override;
       void updateAsync() override;
+      std::string getAssetType() const override;
 
       /**
        * Returns the texture for the given font size.
@@ -48,10 +48,6 @@ namespace Dawn {
         const uint32_t fontSize
       );
 
-      /**
-       * Dispose / Cleanup the truetype asset. Will also dispose the underlying
-       * truetype itself.
-       */
       ~TrueTypeLoader();
   };
 }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,44 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "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/JSONLoader.cpp

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

@@ -1,42 +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 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/TrueTypeLoader.hpp

@@ -1,57 +0,0 @@
-// 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 "dawnlibs.hpp"
+#include "dawn.hpp"
 
 namespace Dawn {
   class IAudioManager {

src/dawn/component/CMakeLists.txt

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

src/dawn/component/SceneComponentRegistry.cpp

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

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

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

@@ -1,31 +0,0 @@
-// 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,4 +10,5 @@ target_sources(${DAWN_TARGET_NAME}
 )
 
 # Subdirs
-add_subdirectory(material)
+add_subdirectory(material)
+add_subdirectory(mesh)