idk

.gitignore

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

.gitmodules

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

CMakeLists.txt

@@ -8,10 +8,14 @@ set(CMAKE_C_STANDARD 99)
 set(CMAKE_C_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED True)
-set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake/modules/")
 
 # 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}")
@@ -23,12 +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")
 
-# Add CMake Tools
-add_subdirectory(cmake)
-
-set(DAWN_BUILD_BINARY ${DAWN_BUILD_DIR}/src/${DAWN_BUILDING}/${DAWN_TARGET_NAME})
-
-# Initialize Project First.
+# Initialize Project.
 project(Dawn
   VERSION 1.0.0
   LANGUAGES C CXX

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
+  ]
+}

ci/build-tools.sh

@@ -1,5 +0,0 @@
-#!/bin/bash
-mkdir tools
-cd tools
-cmake .. -DDAWN_BUILD_TARGET=target-tools
-make

ci/install-libraries.sh

@@ -1,2 +0,0 @@
-#!/bin/bash
-git submodule update --init --recursive

ci/install-linux-toolchain.sh

@@ -1,2 +0,0 @@
-#!/bin/bash
-sudo apt install build-essential

ci/install-vita-toolchain.sh

@@ -1,38 +0,0 @@
-#!/bin/bash
-sudo apt-get install cmake libarchive-tools
-git clone https://github.com/vitasdk/vdpm ~/vdpm
-cd ~/vdpm
-./bootstrap-vitasdk.sh
-export PATH=$VITASDK/bin:$PATH
-
-git clone https://github.com/vitasdk/packages.git ~/vitapackages
-cd ~/vitapackages
-
-dir_array=(
-  zlib
-  bzip2
-  henkaku
-  taihen
-  kubridge
-  openal-soft
-  openssl
-  curl
-  curlpp
-  expat
-  opus
-  opusfile
-  glm
-  kuio
-  vitaShaRK
-  libmathneon
-  vitaGL
-  SceShaccCgExt
-)
-
-curdir=$(pwd)
-for d in "${dir_array[@]}";do
-  echo "${curdir}${d}"
-  cd "${curdir}/${d}"
-  vita-makepkg
-  vdpm *-arm.tar.xz
-done

ci/quick-vita-build.sh

@@ -1,10 +0,0 @@
-#!/bin/bash
-mkdir -p vita/build
-cd vita/build
-if [ ! -d "src" ]
-then
-  cmake ../.. -DDAWN_BUILD_TARGET=target-helloworld-vita -DCMAKE_BUILD_TYPE=Debug
-fi
-make
-cp ./src/dawnvita/*.vpk ../
-cd ../..

cmake/CMakeLists.txt

@@ -1,8 +0,0 @@
-# Copyright (c) 2022 Dominic Masters
-# 
-# This software is released under the MIT License.
-# https://opensource.org/licenses/MIT
-
-# Includes
-add_subdirectory(hosts)
-add_subdirectory(targets)

cmake/hosts/CMakeLists.txt

@@ -1,15 +0,0 @@
-# Copyright (c) 2022 Dominic Masters
-# 
-# This software is released under the MIT License.
-# https://opensource.org/licenses/MIT
-
-# Check for build target, or default
-if(WIN32)
-  set(DAWN_BUILD_HOST "build-host-win32")
-elseif(UNIX AND NOT APPLE)
-  set(DAWN_BUILD_HOST "build-host-linux")
-elseif(UNIX AND APPLE)
-  set(DAWN_BUILD_HOST "build-host-osx")
-endif()
-
-add_subdirectory(${DAWN_BUILD_HOST})

cmake/hosts/README.md

@@ -1,4 +0,0 @@
-# CMake Hosts
-CMake Hosts help the build system define how a HOST (Not the target/client) does
-its building. Host would be the system you are using, right now, to do the build
-with.

cmake/hosts/build-host-linux/CMakeLists.txt

@@ -1,6 +0,0 @@
-# Copyright (c) 2022 Dominic Masters
-# 
-# This software is released under the MIT License.
-# https://opensource.org/licenses/MIT
-
-set(DAWN_BUILD_HOST_LIBS "m" CACHE INTERNAL ${DAWN_CACHE_TARGET})

cmake/hosts/build-host-osx/CMakeLists.txt

@@ -1,6 +0,0 @@
-# Copyright (c) 2022 Dominic Masters
-# 
-# This software is released under the MIT License.
-# https://opensource.org/licenses/MIT
-
-set(DAWN_BUILD_HOST_LIBS "" CACHE INTERNAL ${DAWN_CACHE_TARGET})

cmake/hosts/build-host-win32/CMakeLists.txt

@@ -1,6 +0,0 @@
-# Copyright (c) 2022 Dominic Masters
-# 
-# This software is released under the MIT License.
-# https://opensource.org/licenses/MIT
-
-set(DAWN_BUILD_HOST_LIBS "" CACHE INTERNAL ${DAWN_CACHE_TARGET})

cmake/modules/FindGLFW.cmake

@@ -1,49 +0,0 @@
-find_path(GLFW_INCLUDE_DIR GLFW/glfw3.h
-  HINTS
-    ENV GLFWDIR
-  PATHS
-    "/usr"
-    "/usr/local"
-    "~/Library/Frameworks"
-    "/Library/Frameworks"
-    "/opt"
-    "$ENV{PROGRAMFILES}/glfw"
-    "$ENV{PROGRAMFILES}/glfw3"
-  PATH_SUFFIXES
-    include
-)
-
-# Search for the library
-FIND_LIBRARY(GLFW_LIBRARY
-  NAMES
-    glfw glfw3 GLFW GLFW3
-  HINTS
-    ENV GLFWDIR
-  PATHS
-    "/usr"
-    "/usr/local"
-    "~/Library/Frameworks"
-    "/Library/Frameworks"
-    "/opt"
-    "$ENV{PROGRAMFILES}/glfw"
-    "$ENV{PROGRAMFILES}/glfw3"
-  PATH_SUFFIXES
-    lib
-    lib32
-    lib64
-    libs
-    lib-vc2012
-    lib-vc2013
-    lib-vc2015
-    lib-vc2017
-    lib-vc2019
-    lib-vc2022
-)
-
-INCLUDE(FindPackageHandleStandardArgs)
-FIND_PACKAGE_HANDLE_STANDARD_ARGS(
-  GLFW
-  REQUIRED_VARS GLFW_LIBRARY GLFW_INCLUDE_DIR
-)
-
-mark_as_advanced(GLFW_LIBRARY GLFW_INCLUDE_DIR)

cmake/modules/FindOpenAL.cmake

@@ -1,49 +0,0 @@
-find_path(OPENAL_INCLUDE_DIR al.h
-  HINTS
-    ENV OPENALDIR
-  PATHS
-    "/usr"
-    "/usr/local"
-    "~/Library/Frameworks"
-    "/Library/Frameworks"
-    "/opt"
-    "$ENV{PROGRAMFILES}/openal"
-    "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Creative\ Labs\\OpenAL\ 1.1\ Software\ Development\ Kit\\1.00.0000;InstallDir]"
-  PATH_SUFFIXES
-    include/AL
-    AL/AL
-    include/OpenAL
-    include
-    AL
-    OpenAL
-)
-
-# Search for the library
-FIND_LIBRARY(OPENAL_LIBRARY
-  NAMES
-    OpenAL al openal OpenAL32
-  HINTS
-    ENV OPENALDIR
-  PATHS
-    "/usr"
-    "/usr/local"
-    "~/Library/Frameworks"
-    "/Library/Frameworks"
-    "/opt"
-    "$ENV{PROGRAMFILES}/openal"
-    "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Creative\ Labs\\OpenAL\ 1.1\ Software\ Development\ Kit\\1.00.0000;InstallDir]"
-  PATH_SUFFIXES
-    lib
-    lib32
-    lib64
-    libs
-    ${_OpenAL_ARCH_DIR}
-)
-
-INCLUDE(FindPackageHandleStandardArgs)
-FIND_PACKAGE_HANDLE_STANDARD_ARGS(
-  OpenAL
-  REQUIRED_VARS OPENAL_LIBRARY OPENAL_INCLUDE_DIR
-)
-
-mark_as_advanced(OPENAL_LIBRARY OPENAL_INCLUDE_DIR)

cmake/targets/CMakeLists.txt

@@ -1,14 +0,0 @@
-# Copyright (c) 2022 Dominic Masters
-# 
-# This software is released under the MIT License.
-# https://opensource.org/licenses/MIT
-
-# Now validate we have a build target for real
-if(NOT DEFINED DAWN_BUILD_TARGET)
-  set(DAWN_BUILD_TARGET "target-rpg-linux-glfw" CACHE INTERNAL ${DAWN_CACHE_TARGET})
-endif()
-
-message("Building target ${DAWN_BUILD_TARGET}")
-
-# Include the build target
-add_subdirectory(${DAWN_BUILD_TARGET})

cmake/targets/README.md

@@ -1,40 +0,0 @@
-# CMake Targets
-CMake Targets decide what you are intending to build. Targets are (usually) a 
-specific system, like vita, 3ds, switch, or a specific OS with a library, e.g.
-targetting vulkan on linux vs targetting opengl on linux, or targetting opengl
-on windows, etc.
-
-In addition the target also decides what project(s) to build. Usually this is
-just the specific game and/or systems to be built, so if you are building a VN
-game the target would need to let the build system know you want to rollup the
-VN parts of the engine also.
-
-Note this is one of the very few build args that is required during the 
-configuration of cmake to make it build properly, failure to specify a target
-will result in a build error.
-
-```
--DDAWN_BUILD_TARGET=target-helloworld-linux64-glfw
-```
-
-## Target Systems
-- vita
-- linux
-- osx
-- windows
-- emscripten (Web)
-
-## Target Libraries
-- vita (Includes OGL)
-- glfw (Includes OGL)
-- sdl2 (Includes OGL)
-
-## Target games
-- liminal
-- helloworld
-
-## Target Arcitectures
-- vita (form of armv7)
-- linux (x64 only)
-- windows (x64 only)
-- osx (targetting arm64 currently)

cmake/targets/target-helloworld-emscripten/CMakeLists.txt

@@ -1,15 +0,0 @@
-# Copyright (c) 2023 Dominic Masters
-# 
-# This software is released under the MIT License.
-# https://opensource.org/licenses/MIT
-
-set(DAWN_BUILDING dawnhelloworld CACHE INTERNAL ${DAWN_CACHE_TARGET})
-set(DAWN_BUILD_HOST_LIBS "" CACHE INTERNAL ${DAWN_CACHE_TARGET})
-set(DAWN_TARGET_EMSCRIPTEN true CACHE INTERNAL ${DAWN_CACHE_TARGET})
-set(DAWN_TARGET_GLFW true CACHE INTERNAL ${DAWN_CACHE_TARGET})
-set(DAWN_TARGET_NAME "HelloWorld" CACHE INTERNAL ${DAWN_CACHE_TARGET})
-
-set(DAWN_EMSCRIPTEN_FLAGS "" CACHE INTERNAL ${DAWN_CACHE_TARGET})
-
-# Ensures a .HTML file is generated.
-set(CMAKE_EXECUTABLE_SUFFIX ".html" CACHE INTERNAL ${DAWN_CACHE_TARGET})

cmake/targets/target-helloworld-linux-glfw/CMakeLists.txt

@@ -1,10 +0,0 @@
-# Copyright (c) 2023 Dominic Masters
-# 
-# This software is released under the MIT License.
-# https://opensource.org/licenses/MIT
-
-set(DAWN_BUILDING dawnhelloworld CACHE INTERNAL ${DAWN_CACHE_TARGET})
-set(DAWN_TARGET_LINUX true CACHE INTERNAL ${DAWN_CACHE_TARGET})
-set(DAWN_TARGET_GLFW true CACHE INTERNAL ${DAWN_CACHE_TARGET})
-set(DAWN_TARGET_NAME "HelloWorld" CACHE INTERNAL ${DAWN_CACHE_TARGET})
-set(DAWN_TARGET_ARCHIVE true CACHE INTERNAL ${DAWN_CACHE_TARGET})

cmake/targets/target-helloworld-vita/CMakeLists.txt

@@ -1,21 +0,0 @@
-# Copyright (c) 2023 Dominic Masters
-# 
-# This software is released under the MIT License.
-# https://opensource.org/licenses/MIT
-
-set(DAWN_BUILDING dawnhelloworld CACHE INTERNAL ${DAWN_CACHE_TARGET})
-set(DAWN_TARGET_VITA true CACHE INTERNAL ${DAWN_CACHE_TARGET})
-set(DAWN_BUILD_HOST_LIBS "" CACHE INTERNAL ${DAWN_CACHE_TARGET})
-set(DAWN_TARGET_NAME "HelloWorld" CACHE INTERNAL ${DAWN_CACHE_TARGET})
-
-# Properties
-set(DAWN_VITA_APP_NAME "Hello Vita" CACHE INTERNAL ${DAWN_CACHE_TARGET})
-set(DAWN_VITA_TITLEID  "DAWN00000" CACHE INTERNAL ${DAWN_CACHE_TARGET})
-set(DAWN_VITA_VERSION  "01.00" CACHE INTERNAL ${DAWN_CACHE_TARGET})
-
-# Toolchain
-if(DEFINED ENV{VITASDK})
-  set(CMAKE_TOOLCHAIN_FILE "$ENV{VITASDK}/share/vita.toolchain.cmake" CACHE INTERNAL ${DAWN_CACHE_TARGET})
-else()
-  message(FATAL_ERROR "VITASDK Environment variable is missing! Either you do not have the VITASDK installed, or it is not set up with the env vars correctly.")
-endif()

cmake/targets/target-rpg-linux-glfw/CMakeLists.txt

@@ -1,11 +0,0 @@
-# Copyright (c) 2023 Dominic Masters
-# 
-# This software is released under the MIT License.
-# https://opensource.org/licenses/MIT
-
-set(DAWN_BUILDING dawnrpg CACHE INTERNAL ${DAWN_CACHE_TARGET})
-set(DAWN_TARGET_LINUX true CACHE INTERNAL ${DAWN_CACHE_TARGET})
-set(DAWN_TARGET_GLFW true CACHE INTERNAL ${DAWN_CACHE_TARGET})
-set(DAWN_TARGET_NAME "DawnRPG" CACHE INTERNAL ${DAWN_CACHE_TARGET})
-set(DAWN_TARGET_ARCHIVE true CACHE INTERNAL ${DAWN_CACHE_TARGET})
-set(DAWN_TARGET_TRUETYPE false CACHE INTERNAL ${DAWN_CACHE_TARGET})

docs/COMPILING.md

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

lib/CMakeLists.txt

@@ -3,51 +3,40 @@
 # This software is released under the MIT License.
 # https://opensource.org/licenses/MIT
 
-# GLFW
-if(DAWN_TARGET_GLFW)
-  if(${CMAKE_SYSTEM_NAME} MATCHES "Emscripten")
-    set(DAWN_EMSCRIPTEN_FLAGS "${DAWN_EMSCRIPTEN_FLAGS} -s USE_GLFW=3" CACHE INTERNAL ${DAWN_CACHE_TARGET})
-    add_subdirectory(glad)
-  else()
-    add_subdirectory(glad)
-    add_subdirectory(glfw)
-  endif()
-endif()
-
-# SDL
-if(DAWN_TARGET_SDL2)
-  add_subdirectory(glad)
-  add_subdirectory(SDL)
-endif()
+include(FetchContent)
 
 # GLM
-add_subdirectory(glm)
+FetchContent_Declare(
+  glm
+  GIT_REPOSITORY  https://github.com/g-truc/glm.git
+  GIT_TAG         bf71a834948186f4097caa076cd2663c69a10e1e
+)
+FetchContent_MakeAvailable(glm)
 
-# FreeType
-if(${CMAKE_SYSTEM_NAME} MATCHES "Emscripten")
-  set(DAWN_EMSCRIPTEN_FLAGS "${DAWN_EMSCRIPTEN_FLAGS} -s USE_FREETYPE=1" CACHE INTERNAL ${DAWN_CACHE_TARGET})
-else()
-  add_subdirectory(freetype)
-endif()
+# 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
-if(DAWN_TARGET_ARCHIVE)
-  add_subdirectory(libarchive)
-endif()
+FetchContent_Declare(libarchive URL https://github.com/libarchive/libarchive/releases/download/v3.7.6/libarchive-3.7.6.tar.xz)
+FetchContent_MakeAvailable(libarchive)
 
-# OpenAL
-if(DAWN_TARGET_OPENAL)
-  set(LIBTYPE "STATIC")
-  add_subdirectory(openal-soft)
+# 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)
 
-  set(BUILD_TESTS OFF CACHE BOOL "Build tests" FORCE)
-  set(BUILD_EXAMPLES OFF CACHE BOOL "Build examples" FORCE) 
-  add_subdirectory(AudioFile)
-endif()
+# if(DAWN_TARGET_OPENAL)
+#   set(LIBTYPE "STATIC")
+#   add_subdirectory(openal-soft)
 
-# Emscripten (TESTING ONLY)
-if(DEFINED DAWN_EMSCRIPTEN_FLAGS)
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${DAWN_EMSCRIPTEN_FLAGS}" CACHE INTERNAL ${DAWN_CACHE_TARGET})
-  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${DAWN_EMSCRIPTEN_FLAGS}" CACHE INTERNAL ${DAWN_CACHE_TARGET})
-  set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${DAWN_EMSCRIPTEN_FLAGS}" CACHE INTERNAL ${DAWN_CACHE_TARGET})
-endif()
+#   set(BUILD_TESTS OFF CACHE BOOL "Build tests" FORCE)
+#   set(BUILD_EXAMPLES OFF CACHE BOOL "Build examples" FORCE) 
+#   add_subdirectory(AudioFile)
+# endif()

src/CMakeLists.txt

@@ -3,75 +3,21 @@
 # This software is released under the MIT License.
 # https://opensource.org/licenses/MIT
 
-# Custom variables
-set(
-  DAWN_TARGET_DEPENDENCIES_LAST
-  CACHE INTERNAL ${DAWN_CACHE_TARGET}
-)
-
 # Build Project
 add_executable(${DAWN_TARGET_NAME})
 
-# Change what we are building. Pulled from the cmake/targets dir.
-if(DEFINED DAWN_BUILDING)
-  add_subdirectory(${DAWN_BUILDING})
-endif()
-
-# Validate game project includes the target name
-if(DEFINED DAWN_TARGET_NAME)
 # Add in base library
 add_subdirectory(dawn)
 
 # Compile entry targets
-  if(DAWN_TARGET_WIN32)
-    add_subdirectory(dawnwin32)
-  elseif(DAWN_TARGET_LINUX)
+if(DAWN_TARGET STREQUAL "linux-x64-glfw")
   add_subdirectory(dawnlinux)
-  elseif(DAWN_TARGET_OSX)
-    add_subdirectory(dawnosx)
-  elseif(DAWN_TARGET_VITA)
-    add_subdirectory(dawnvita)
-  elseif(DAWN_TARGET_EMSCRIPTEN)
-    add_subdirectory(dawnemscripten)
+  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
-  if(DAWN_TARGET_GLFW)
-    add_subdirectory(dawnglfw)
-    add_subdirectory(dawnopengl)
-  endif()
-
-  if(DAWN_TARGET_TRUETYPE)
-    add_subdirectory(dawntruetype)
-  endif()
-
-  if(DAWN_TARGET_SDL2)
-    add_subdirectory(dawnsdl2)
-    add_subdirectory(dawnopengl)
-  endif()
-
-  if(DAWN_TARGET_VITA)
-    add_subdirectory(dawnopengl)
-  endif()
-
-  if(DAWN_TARGET_OPENAL)
-    add_subdirectory(dawnopenal)
-  endif()
-
-  # Late definitions, used by tools
-  if(NOT DAWN_TARGET_DEPENDENCIES_LAST)
-  else()
-    add_dependencies(${DAWN_TARGET_NAME} ${DAWN_TARGET_DEPENDENCIES_LAST})
-  endif()
-
 # Compress the game assets.
 add_dependencies(${DAWN_TARGET_NAME} dawnassets)
-endif()

src/dawn/CMakeLists.txt

@@ -6,8 +6,10 @@
 # Libraries
 target_link_libraries(${DAWN_TARGET_NAME}
   PUBLIC
-    glm
+    glm::glm
     archive_static
+    freetype
+    nlohmann_json::nlohmann_json
 )
 
 # Includes
@@ -29,6 +31,7 @@ add_subdirectory(game)
 add_subdirectory(locale)
 add_subdirectory(prefab)
 # add_subdirectory(physics)
+add_subdirectory(poker)
 add_subdirectory(save)
 add_subdirectory(scene)
 # add_subdirectory(state)

src/dawn/assert/assert.hpp

@@ -84,6 +84,17 @@ void assertTrueImplement(
   map.find(key) != map.end(), __VA_ARGS__ \
 )
 
+/**
+ * Asserts that a given map does not have a specific key.
+ * @param map Map to check.
+ * @param key Key to check for.
+ * @param message Message (sprintf format) to send to the logger.
+ * @param args Optional TParam args for the sprintf message to accept.
+ */
+#define assertMapNotHasKey(map, key, ...) assertTrue( \
+  map.find(key) == map.end(), __VA_ARGS__ \
+)
+
 /**
  * Asserts that a given value has a specific flag turned off.
  * 

src/dawn/asset/AssetManager.cpp

@@ -5,6 +5,8 @@
 
 #include "AssetManager.hpp"
 #include "loaders/TextureLoader.hpp"
+#include "loaders/TrueTypeLoader.hpp"
+#include "loaders/JSONLoader.hpp"
 
 using namespace Dawn;
 
@@ -59,6 +61,41 @@ bool_t AssetManager::isLoaded(const std::string filename) {
   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

@@ -28,7 +28,7 @@ namespace Dawn {
           }
         );
 
-        if(existing == finishedAssetLoaders.end()) {
+        if(existing == pendingAssetLoaders.end()) {
           existing = std::find_if(
             finishedAssetLoaders.begin(), finishedAssetLoaders.end(),
             [&](auto &loader) {
@@ -80,6 +80,7 @@ namespace Dawn {
        * 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>

src/dawn/asset/loaders/CMakeLists.txt

@@ -7,4 +7,6 @@
 target_sources(${DAWN_TARGET_NAME}
   PRIVATE
     TextureLoader.cpp
+    TrueTypeLoader.cpp
+    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/TrueTypeLoader.cpp

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

src/dawn/asset/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/component/CMakeLists.txt

@@ -11,3 +11,4 @@ target_sources(${DAWN_TARGET_NAME}
 # Subdirs
 add_subdirectory(display)
 add_subdirectory(ui)
+add_subdirectory(vn)

src/dawn/component/ui/UICanvas.cpp

@@ -142,3 +142,8 @@ void UICanvas::flushPass() {
 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

@@ -69,5 +69,12 @@ 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);
   };
 }

src/dawn/component/vn/CMakeLists.txt

@@ -5,5 +5,5 @@
 
 target_sources(${DAWN_TARGET_NAME}
   PRIVATE
-    GameInit.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/dawnlibs.hpp

@@ -48,3 +48,6 @@ extern "C" {
 #include <glm/gtc/type_ptr.hpp>
 #define GLM_ENABLE_EXPERIMENTAL 1
 #include <glm/gtx/matrix_decompose.hpp>
+
+#include <nlohmann/json.hpp>
+using json = nlohmann::json;

src/dawn/display/CMakeLists.txt

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

src/dawn/display/font/CMakeLists.txt

@@ -5,5 +5,5 @@
 
 target_sources(${DAWN_TARGET_NAME}
   PRIVATE
-    HelloWorldScene.cpp
+    TrueTypeTexture.cpp
 )

src/dawn/display/font/TrueTypeCharacter.hpp

@@ -0,0 +1,16 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "dawnlibs.hpp"
+
+namespace Dawn {
+  struct TrueTypeCharacter {
+    glm::vec2 advance;
+    glm::vec2 size;
+    glm::vec2 offset;
+    glm::vec4 quad;
+  };
+}

src/dawn/display/font/TrueTypeTexture.cpp

@@ -0,0 +1,198 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "TrueTypeTexture.hpp"
+#include "assert/assert.hpp"
+#include "util/Math.hpp"
+#include "display/mesh/QuadMesh.hpp"
+
+using namespace Dawn;
+
+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) {
+  this->face = face;
+  assertTrue(fontSize < 256, "Font size cannot be greater than 256");
+
+  // Set freetype font size prior to baking.
+  auto ret = FT_Set_Pixel_Sizes(face, 0, fontSize);
+  if(ret != 0) {
+    assertUnreachable("Failed to set font size %i", ret);
+  }
+  
+  // Set the texture size
+  texture->setSize(
+    fontSize * 24,
+    fontSize * 24,
+    TextureFormat::R,
+    TextureDataFormat::UNSIGNED_BYTE
+  );
+
+  // Texture buffer
+  uint8_t *buffer = new uint8_t[texture->getWidth() * texture->getHeight()];
+  // Fill with zeros
+  std::memset(buffer, 0, texture->getWidth() * texture->getHeight());
+
+  size_t offset = 0;
+  struct TrueTypeCharacter info;
+  int32_t textureX = 0, textureY = 0;
+  int32_t rowHeight = 0;
+
+  // Character sets
+  std::vector<wchar_t> characterBlocks;
+  // Latin
+  for(wchar_t c = 0x0020; c < 0x007F; c++) characterBlocks.push_back(c);
+  // Latin-1 Supplement
+  for(wchar_t c = 0x00A0; c < 0x00FF; c++) characterBlocks.push_back(c);
+  // Latin Extended-A
+  for(wchar_t c = 0x0100; c < 0x017F; c++) characterBlocks.push_back(c);
+  // Latin Extended-B
+  for(wchar_t c = 0x0180; c < 0x024F; c++) characterBlocks.push_back(c);
+  // Hiragana
+  for(wchar_t c = 0x3040; c < 0x309F; c++) characterBlocks.push_back(c);
+  // Katakana
+  for(wchar_t c = 0x30A0; c < 0x30FF; c++) characterBlocks.push_back(c);
+
+  // For each character in the character set
+  for(wchar_t c : characterBlocks) {
+    // Load the character
+    if(FT_Load_Char(face, c, FT_LOAD_RENDER)) {
+      assertUnreachable("Failed to load character (1)");
+    }
+
+    // Store the character information
+    info.advance.x = (float_t)(face->glyph->advance.x >> 6);
+    info.advance.y = (float_t)(face->glyph->advance.y >> 6);
+    info.size = glm::vec2(face->glyph->bitmap.width, face->glyph->bitmap.rows);
+
+    // Determine the texture position
+    if(textureX + face->glyph->bitmap.width >= texture->getWidth()) {
+      textureX = 0;
+      textureY += rowHeight + 2;// Tiny gap between rows
+      rowHeight = face->glyph->bitmap.rows;
+    } else {
+      rowHeight = Math::max<int32_t>(rowHeight, face->glyph->bitmap.rows);
+    }
+
+    // Set the quad positions
+    info.offset = glm::vec2(
+      face->glyph->bitmap_left,
+      -face->glyph->bitmap_top
+    );
+    info.quad = glm::vec4(
+      textureX,
+      textureY,
+      textureX + face->glyph->bitmap.width,
+      textureY + face->glyph->bitmap.rows
+    ) / glm::vec4(
+      texture->getWidth(),
+      texture->getHeight(),
+      texture->getWidth(),
+      texture->getHeight()
+    );
+
+    // Store the cached character data.
+    this->characterData[c] = info;
+
+    // Determine pixel offset.
+    offset = textureX + (textureY * texture->getWidth());
+    assertTrue(
+      offset + (face->glyph->bitmap.rows * texture->getWidth()) <=
+      texture->getWidth() * texture->getHeight(),
+      "Font texture buffer overflow will occur."
+    );
+
+    // Buffer pixels, we have to do this one row at a time due to the 
+    // differences in width between the glyph and the texture.
+    const size_t countPerRow = face->glyph->bitmap.width;
+    int32_t i = 0;
+    while(i != face->glyph->bitmap.rows) {
+      std::memcpy(
+        buffer + offset + (i * texture->getWidth()),
+        face->glyph->bitmap.buffer + (i * countPerRow),
+        countPerRow
+      );
+      i++;
+    }
+
+    // Increment textureX
+    textureX += face->glyph->bitmap.width + 2;// I add a tiny gap between chars
+  }
+
+  this->texture->buffer(buffer);
+  delete[] buffer;
+}
+
+struct TrueTypeCharacter TrueTypeTexture::getCharacterData(wchar_t c) {
+  return this->characterData[c];
+}
+
+glm::vec2 TrueTypeTexture::bufferStringToMesh(
+  std::shared_ptr<Mesh> mesh,
+  const std::wstring text,
+  glm::vec2 &position,
+  bool_t flipY
+) {
+  assertNotNull(mesh, "Mesh must be supplied and not null");
+  assertTrue(text.size() > 0, "Text must be at least one character long.");
+
+  // Create mesh buffers
+  mesh->createBuffers(
+    text.length() * QUAD_VERTICE_COUNT,
+    text.length() * QUAD_INDICE_COUNT
+  );
+  
+  // Foreach char
+  size_t i = 0;
+  glm::vec2 size = { 0, 0 };
+  for(wchar_t c : text) {
+    // Get the character data
+    auto info = this->getCharacterData(c);
+
+    // Buffer the quad
+    glm::vec4 quad = glm::vec4(
+      position.x,
+      position.y,
+      position.x + info.size.x,
+      position.y + info.size.y
+    );
+    if(flipY) {
+      QuadMesh::buffer(
+        mesh,
+        quad,
+        glm::vec4(
+          info.quad.x,
+          info.quad.w,
+          info.quad.z,
+          info.quad.y
+        ),
+        i * QUAD_VERTICE_COUNT,
+        i * QUAD_INDICE_COUNT
+      );
+    } else {
+      QuadMesh::buffer(
+        mesh,
+        quad,
+        info.quad,
+        i * QUAD_VERTICE_COUNT,
+        i * QUAD_INDICE_COUNT
+      );
+    }
+    position += info.advance;
+    size += info.advance;
+
+    i++;
+  }
+
+  return size;
+}
+
+TrueTypeTexture::~TrueTypeTexture() {
+}

src/dawn/display/font/TrueTypeTexture.hpp

@@ -0,0 +1,66 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "display/Texture.hpp"
+#include "TrueTypeCharacter.hpp"
+#include "display/mesh/Mesh.hpp"
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+namespace Dawn {
+  class TrueTypeTexture final {
+    private:
+      FT_Face face;
+
+    public:
+      uint32_t fontSize;
+      std::shared_ptr<Texture> texture;
+      std::unordered_map<wchar_t, struct TrueTypeCharacter> characterData;
+
+      /**
+       * Construct a new New True Type Face Texture object
+       * 
+       * @param fontSize Size of the font.
+       */
+      TrueTypeTexture(const uint32_t fontSize);
+
+      /**
+       * Sets the face for this texture.
+       * 
+       * @param face Face to set.
+       */
+      void setFace(const FT_Face face);
+
+      /**
+       * Returns the character data for the given character.
+       * 
+       * @param c Character to get data for.
+       * @return The Character data for the given character.
+       */
+      struct TrueTypeCharacter getCharacterData(wchar_t c);
+
+      /**
+       * Buffers a string to the given mesh.
+       * 
+       * @param mesh Mesh to buffer to.
+       * @param text Text to buffer.
+       * @param position Position to buffer to.
+       * @param flipY Whether or not to flip the Y axis.
+       * @return The size of the string.
+       */
+      glm::vec2 bufferStringToMesh(
+        std::shared_ptr<Mesh> mesh,
+        const std::wstring text,
+        glm::vec2 &position,
+        bool_t flipY = false
+      );
+
+      /**
+       * Destroys this true type face texture.
+       */
+      ~TrueTypeTexture();
+  };
+}

src/dawn/game/Game.cpp

@@ -18,8 +18,8 @@ void Game::init() {
   inputManager.init(shared_from_this());
   saveManager.init(shared_from_this());
 
-  auto initialScene = GameInit::getInitialScene();
-  nextFrameScene = std::make_shared<Scene>(shared_from_this(), initialScene);
+  auto initialScene = Scene::getInitialScene();
+  this->nextFrameScene = std::make_shared<Scene>(shared_from_this(), initialScene);
 }
 
 void Game::update() {
@@ -32,6 +32,7 @@ void Game::update() {
   }
 
   timeManager.update();
+  inputManager.update();
   if(currentScene) currentScene->update();
   renderHost.update(shared_from_this());
 }
@@ -47,4 +48,9 @@ std::shared_ptr<Scene> Game::getCurrentScene() {
 }
 
 Game::~Game() {
+  currentScene = nullptr;
+  nextFrameScene = nullptr;
+  
+  assertTrue(SCENE_ITEMS_ACTIVE == 0, "Some scene items are still active?");
+  assertTrue(SCENE_COMPONENTS_ACTIVE == 0, "Some scene components are still active?");
 }

src/dawn/input/IInputManager.hpp

@@ -5,17 +5,17 @@
 
 #pragma once
 #include "util/Math.hpp"
+#include "input/InputBinds.hpp"
 
 namespace Dawn {
   class DawnGame;
-  typedef int_fast16_t inputbind_t;
 
   template<typename T>
   class IInputManager {
     protected:
-      std::unordered_map<inputbind_t, std::vector<T>> binds;
-      std::unordered_map<inputbind_t, float_t> valuesLeft;
-      std::unordered_map<inputbind_t, float_t> valuesRight;
+      std::unordered_map<enum InputBind, std::vector<T>> binds;
+      std::unordered_map<enum InputBind, float_t> valuesLeft;
+      std::unordered_map<enum InputBind, float_t> valuesRight;
       bool_t currentIsLeft = true;
 
       /**
@@ -34,7 +34,7 @@ namespace Dawn {
        * @param bind Bind to bind the axis to.
        * @param axis Axis to use for this bind.
        */
-      void bind(const inputbind_t bind, const T axis) {
+      void bind(const enum InputBind bind, const T axis) {
         this->binds[bind].push_back(axis);
       }
 
@@ -43,7 +43,7 @@ namespace Dawn {
        * 
        * @param bind Bind to remove all binds from.
        */
-      void unbind(const inputbind_t bind) {
+      void unbind(const enum InputBind bind) {
         this->binds[bind].clear();
       }
 
@@ -61,7 +61,7 @@ namespace Dawn {
        * @param bind Bind to get the value of.
        * @return The current input state (between 0 and 1).
        */
-      float_t getValue(const inputbind_t bind) {
+      float_t getValue(const enum InputBind bind) {
         if(this->currentIsLeft) {
           auto exist = this->valuesLeft.find(bind);
           return exist == this->valuesLeft.end() ? 0.0f : exist->second;
@@ -77,7 +77,7 @@ namespace Dawn {
        * @param bind Bind to get the value of.
        * @return The value of the bind, last frame.
        */
-      float_t getValueLastUpdate(const inputbind_t bind) {
+      float_t getValueLastUpdate(const enum InputBind bind) {
         if(this->currentIsLeft) {
           auto exist = this->valuesRight.find(bind);
           return exist == this->valuesRight.end() ? 0.0f : exist->second;
@@ -99,15 +99,15 @@ namespace Dawn {
        * @param positive Bind to use for the positive axis.
        * @return A value between -1 and 1.
        */
-      float_t getAxis(const inputbind_t negative, const inputbind_t positive) {
+      float_t getAxis(const enum InputBind negative, const enum InputBind positive) {
         return -getValue(negative) + getValue(positive);
       }
 
       glm::vec2 getAxis2D(
-        const inputbind_t negativeX,
-        const inputbind_t positiveX,
-        const inputbind_t negativeY,
-        const inputbind_t positiveY
+        const enum InputBind negativeX,
+        const enum InputBind positiveX,
+        const enum InputBind negativeY,
+        const enum InputBind positiveY
       ) {
         return glm::vec2(
           getAxis(negativeX, positiveX),
@@ -122,7 +122,7 @@ namespace Dawn {
        * @param y Y Axis bind.
        * @return 2D vector of the two given input binds.
        */
-      glm::vec2 getAxis2D(const inputbind_t x, const inputbind_t y) {
+      glm::vec2 getAxis2D(const enum InputBind x, const enum InputBind y) {
         return glm::vec2(getValue(x), getValue(y));
       }
 
@@ -133,7 +133,7 @@ namespace Dawn {
        * @param bind Bind to check if pressed.
        * @return True if value is non-zero, or false for zero.
        */
-      bool_t isDown(const inputbind_t bind) {
+      bool_t isDown(const enum InputBind bind) {
         return this->getValue(bind) != 0.0f;
       }
 
@@ -144,7 +144,7 @@ namespace Dawn {
        * @param bind Bind to check if pressed.
        * @return True if down this frame and not down last frame.
        */
-      bool_t isPressed(const inputbind_t bind) {
+      bool_t isPressed(const enum InputBind bind) {
         return this->getValue(bind) != 0 && this->getValueLastUpdate(bind) == 0;
       }
 
@@ -155,7 +155,7 @@ namespace Dawn {
        * @param bind Bind to check if released.
        * @return True if up this frame, and down last frame.
        */
-      bool_t wasReleased(const inputbind_t bind) {
+      bool_t wasReleased(const enum InputBind bind) {
         return this->getValue(bind) == 0 && this->getValueLastUpdate(bind) != 0;
       }
 

src/dawn/poker/CMakeLists.txt

@@ -0,0 +1,15 @@
+# Copyright (c) 2022 Dominic Masters
+# 
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+# Sources
+target_sources(${DAWN_TARGET_NAME}
+  PRIVATE
+    Card.cpp
+    PokerPot.cpp
+    PokerPlayer.cpp
+    PokerGame.cpp
+    PokerWinning.cpp
+    PokerTurn.cpp
+)

src/dawn/poker/Card.cpp

@@ -0,0 +1,94 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "Card.hpp"
+#include "util/Random.hpp"
+
+using namespace Dawn;
+
+void Card::shuffle(std::vector<struct Card> &deck) {
+  for(uint8_t i = 0; i < deck.size(); i++) {
+    uint8_t swap = Random::random<uint8_t>(0, deck.size() - 1);
+    struct Card tmp = deck[i];
+    deck[i] = deck[swap];
+    deck[swap] = tmp;
+  }
+}
+
+void Card::fillDeck(std::vector<struct Card> &deck) {
+  deck.clear();
+  for(uint8_t i = 0; i < CARD_DECK_SIZE; i++) {
+    deck.push_back(Card(i));
+  }
+}
+
+int32_t Card::contains(
+  const std::vector<struct Card> &deck,
+  const struct Card c
+) {
+  if(deck.size() == 0) return -1;
+
+  return std::distance(
+    deck.begin(),
+    std::find_if(
+      deck.begin(),
+      deck.end(),
+      [c](struct Card card) {
+        return card.cardValue == c.cardValue;
+      }
+    )
+  );
+}
+
+int32_t Card::containsValue(
+  const std::vector<struct Card> &deck,
+  const enum CardValue number
+) {
+  if(deck.size() == 0) return -1;
+
+  return std::distance(
+    deck.begin(),
+    std::find_if(
+      deck.begin(),
+      deck.end(),
+      [number](struct Card c) {
+        return c.getValue() == number;
+      }
+    )
+  );
+}
+
+std::vector<struct Card> Card::countPairs(
+  const std::vector<struct Card> &deck,
+  const enum CardValue val
+) {
+  std::vector<struct Card> pairs;
+  
+  std::for_each(
+    deck.begin(),
+    deck.end(),
+    [&pairs, val](struct Card c) {
+      if(c.getValue() == val) pairs.push_back(c);
+    }
+  );
+
+  return pairs;
+}
+
+bool_t Card::cardSorter(struct Card left, struct Card right) {
+  return left.cardValue < right.cardValue;
+}
+
+void Card::sort(std::vector<struct Card> &deck) {
+  std::sort(deck.begin(), deck.end(), &Card::cardSorter);
+}
+
+enum CardValue Card::getValue() {
+  return (enum CardValue)(cardValue % CARD_COUNT_PER_SUIT);
+}
+
+enum CardSuit Card::getSuit() {
+  return (enum CardSuit)(cardValue / CARD_COUNT_PER_SUIT);
+}

src/dawn/poker/Card.hpp

@@ -0,0 +1,151 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "dawnlibs.hpp"
+#include "assert/assert.hpp"
+
+namespace Dawn {
+  enum class CardSuit : uint8_t {
+    Clubs = 0,
+    Diamonds = 1,
+    Hearts = 2,
+    Spades = 3,
+  };
+
+  enum class CardValue : uint8_t {
+    Two = 0,
+    Three = 1,
+    Four = 2,
+    Five = 3,
+    Six = 4,
+    Seven = 5,
+    Eight = 6,
+    Nine = 7,
+    Ten = 8,
+    Jack = 9,
+    Queen = 10,
+    King = 11,
+    Ace = 12,
+    Invalid = 0xFF
+  };
+
+  /** Count of cards in each suit */
+  #define CARD_COUNT_PER_SUIT 13
+
+  /** Count of suits */
+  #define CARD_SUIT_COUNT 4
+
+  /** Standard Card Deck Size */
+  #define CARD_DECK_SIZE CARD_COUNT_PER_SUIT*CARD_SUIT_COUNT
+
+  struct Card {
+    public:
+      uint8_t cardValue;
+
+      /**
+       * Shuffles a hand / deck
+       * 
+       * @param deck Array of cards to shuffle.
+       */
+      static void shuffle(std::vector<struct Card> &deck);
+
+      /**
+       * Fills a vector with all of the cards in a deck, in order.
+       * 
+       * @param deck Deck to fill.
+       */
+      static void fillDeck(std::vector<struct Card> &deck); 
+
+      /**
+       * Check if an array of cards contains a specific card.
+       * 
+       * @param deck Deck/Hand/Array of cards to check.
+       * @param card Card to look for
+       * @returns The index within the array that the card is. -1 if not found.
+       */
+      static int32_t contains(
+        const std::vector<struct Card> &deck,
+        const struct Card card
+      );
+
+      /**
+       * Check if the array of cards contains a specific number.
+       * 
+       * @param deck Array of cards to check
+       * @param number The number to look for.
+       * @returns The index that the first card is. -1 if not found.
+       */
+      static int32_t containsValue(
+        const std::vector<struct Card> &deck,
+        const enum CardValue number
+      );
+
+      /**
+       * Counts the amount of times a card's number appears within the given 
+       * hand.
+       * 
+       * @param deck The hand to check
+       * @param val Value of pairs to find.
+       * @return Card pairs in the deck.
+       */
+      static std::vector<struct Card> countPairs(
+        const std::vector<struct Card> &deck,
+        const enum CardValue val
+      );
+
+      /**
+       * Sorter for the cardSorter function.
+       * 
+       * @param left Left card to compare.
+       * @param right Right card to compare.
+       * @returns True if left is less than right.
+       */
+      static bool_t cardSorter(struct Card left, struct Card right);
+
+      /**
+       * Sort a hand of cards. Cards are ordered in descending weight, aces are
+       * high. Cards will be grouped by their suits, e.g. CARD_CLUBS_TWO will
+       * appear before CARD_DIAMONDS_KING.
+       * 
+       * @param deck Hand of cards to sort.
+       */
+      static void sort(std::vector<struct Card> &deck);
+
+      /**
+       * Constructor for the Card class.
+       * 
+       * @param suit Suit of the card.
+       * @param num Number of the card.
+       */
+      Card(const CardSuit suit, const CardValue num) :
+        Card(
+          ((uint8_t)suit * CARD_COUNT_PER_SUIT) + (uint8_t)num
+        )
+      {
+      }
+
+      /**
+       * Constructor for the Card class.
+       * 
+       * @param cv Card value.
+       */
+      Card(const uint8_t cv) : cardValue(cv) {
+      }
+
+      /**
+       * Returns the number of a given card.
+       * @returns The card number.
+       */
+      enum CardValue getValue();
+
+      /**
+       * Returns the suit of a given card.
+       * @returns The suit.
+       */
+      enum CardSuit getSuit();
+  };
+
+}

src/dawn/poker/PokerGame.cpp

@@ -0,0 +1,197 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "PokerGame.hpp"
+
+using namespace Dawn;
+
+std::shared_ptr<PokerPlayer> PokerGame::addNewPlayer() {
+  auto player = std::make_shared<PokerPlayer>(
+    weak_from_this(), this->players.size()
+  );
+  assertFalse(this->players.size() == PLAYER_COUNT_MAX, "Too many players.");
+  this->players.push_back(player);
+  return player;
+}
+
+std::shared_ptr<PokerPlayer> PokerGame::getCurrentBetter() {
+  auto nextIndex = this->getNextBetterIndex();
+  if(nextIndex == 0xFF) return nullptr;
+  return this->players[nextIndex];
+}
+
+void PokerGame::newGame() {
+  assertTrue(this->players.size() >= PLAYER_COUNT_MIN, "Not enough players.");
+  this->newRound();
+  this->smallBlind = POKER_BLIND_SMALL_DEFAULT;
+  this->bigBlind = POKER_BLIND_BIG_DEFAULT;
+
+  auto it = this->players.begin();
+  while(it != this->players.end()) {
+    auto player = *it;
+    player->setChips(POKER_PLAYER_CHIPS_DEFAULT);
+    player->isOut = false;
+    ++it;
+  }
+  
+  this->setDealer(0x00);
+}
+
+void PokerGame::newRound() {
+  this->deck.clear();
+  Card::fillDeck(this->deck);
+
+  this->grave.clear();
+  this->community.clear();
+  this->pots.clear();
+  this->pots.push_back(PokerPot());
+
+  this->hasFlopped = false;
+  this->hasTurned = false;
+  this->hasRivered = false;
+
+  auto it = this->players.begin();
+  while(it != this->players.end()) {
+    auto player = *it;
+    player->hand.clear();
+    player->currentBet = 0;
+    player->isFolded = false;
+    player->isShowingHand = false;
+    player->hasBetThisRound = false;
+    player->timesRaised = 0;
+    player->currentBet = 0;
+    ++it;
+  }
+
+  this->setDealer(this->dealerIndex + 0x01);
+}
+
+void PokerGame::newBettingRound() {
+  auto it = this->players.begin();
+  while(it != this->players.end()) {
+    auto player = *it;
+    player->hasBetThisRound = false;
+    player->timesRaised = 0;
+    ++it;
+  }
+
+  this->betterIndex = this->bigBlindIndex;
+  this->betterIndex = this->getNextBetterIndex();
+}
+
+uint8_t PokerGame::getNextBetterIndex() {
+  uint8_t j, i;
+  for(i = 0; i < this->players.size(); i++) {
+    j = (i + this->betterIndex) % this->players.size();
+    auto player = this->players[j];
+    if(player->needsToBetThisRound()) return j;
+  }
+  return 0xFF;
+}
+
+void PokerGame::takeBlinds() {
+  auto playerSmallBlind = this->players[this->smallBlindIndex];
+  auto playerBigBlind = this->players[this->bigBlindIndex];
+
+  playerSmallBlind->bet(this->smallBlind);
+  playerBigBlind->bet(this->bigBlind);
+
+  playerSmallBlind->hasBetThisRound = false;
+  playerBigBlind->hasBetThisRound = false;
+}
+
+void PokerGame::setDealer(const uint8_t dealer) {
+  uint8_t i, k;
+  std::shared_ptr<PokerPlayer> player;
+  bool_t foundDealer;
+  bool_t foundSmall;
+
+  foundDealer = false;
+  foundSmall = false;
+  this->dealerIndex = dealer;
+
+  for(i = 0; i < this->players.size(); i++) {
+    k = (dealer + i) % this->players.size();
+    player = this->players[k];
+    if(player->isOut) continue;
+    if(!foundDealer) {
+      this->dealerIndex = k;
+      foundDealer = true;
+    } else if(!foundSmall) {
+      this->smallBlindIndex = k;
+      foundSmall = true;
+    } else {
+      this->bigBlindIndex = k;
+      break;
+    }
+  }
+}
+
+uint8_t PokerGame::getRemainingBettersCount() {
+  uint8_t count = 0;
+  auto it = this->players.begin();
+  while(it != this->players.end()) {
+    if((*it)->needsToBetThisRound()) count++;
+    ++it;
+  }
+  return count;
+}
+
+uint8_t PokerGame::getRemainingPlayersCount() {
+  uint8_t count = 0;
+  auto it = this->players.begin();
+  while(it != this->players.end()) {
+    if(!(*it)->isFolded && !(*it)->isOut) count++;
+    ++it;
+  }
+  return count;
+}
+
+int32_t PokerGame::getCurrentCallValue() {
+  assertTrue(this->pots.size() > 0, "No pots?");
+  return this->pots.back().call;
+}
+
+void PokerGame::burnCard() {
+  assertTrue(this->deck.size() > 0, "No cards to burn.");
+  auto card = this->deck.back();
+  this->deck.pop_back();
+  this->grave.push_back(card);
+}
+
+void PokerGame::dealCard(PokerPlayer &player) {
+  assertTrue(this->deck.size() > 0, "No cards to deal.");
+  auto card = this->deck.back();
+  this->deck.pop_back();
+  player.hand.push_back(card);
+}
+
+void PokerGame::dealToEveryone(const uint8_t count) {
+  for(uint8_t i = 0; i < count; i++) {
+    auto it = this->players.begin();
+    while(it != this->players.end()) {
+      this->dealCard(*(*it));
+      ++it;
+    }
+  }
+}
+
+void PokerGame::turn(const uint8_t count) {
+  uint8_t c = count;
+  if(c == 0xFF) c = this->getCountOfCardsToTurn();
+  assertTrue(this->deck.size() >= c, "Not enough cards to turn.");
+  for(uint8_t i = 0; i < c; i++) {
+    auto card = this->deck.back();
+    this->deck.pop_back();
+    this->community.push_back(card);
+  }
+}
+
+uint8_t PokerGame::getCountOfCardsToTurn() {
+  if(!this->hasFlopped) return 3;
+  if(!this->hasTurned) return 1;
+  if(!this->hasRivered) return 1;
+  assertUnreachable("No more cards to turn.");
+}

src/dawn/poker/PokerGame.hpp

@@ -0,0 +1,151 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "PokerPlayer.hpp"
+
+/** The default blind cost for the big blind. */
+#define POKER_BLIND_BIG_DEFAULT 600
+/** The default blind cost for the small blind. (Defaults half big blind) */
+#define POKER_BLIND_SMALL_DEFAULT (POKER_BLIND_BIG_DEFAULT/2)
+
+/** How many cards are dealt for the flop, turn and river */
+#define POKER_FLOP_CARD_COUNT 3
+#define POKER_TURN_CARD_COUNT 1
+#define POKER_RIVER_CARD_COUNT 1
+
+#define PLAYER_COUNT_MAX 8
+#define PLAYER_COUNT_MIN 2
+
+namespace Dawn {
+  class PokerGame : public std::enable_shared_from_this<PokerGame> {
+    protected:
+      std::vector<struct Card> deck;
+      std::vector<struct Card> grave;
+      uint8_t dealerIndex;
+      uint8_t smallBlindIndex;
+      uint8_t bigBlindIndex;
+      int32_t smallBlind = POKER_BLIND_SMALL_DEFAULT;
+      int32_t bigBlind = POKER_BLIND_BIG_DEFAULT;
+
+      bool_t hasFlopped = false;
+      bool_t hasTurned = false;
+      bool_t hasRivered = false;
+
+    public:
+      std::vector<std::shared_ptr<PokerPlayer>> players;
+      std::vector<struct PokerPot> pots;
+      std::vector<struct Card> community;
+      uint8_t betterIndex;
+
+      /**
+       * Creates and adds a new player to the game.
+       */
+      std::shared_ptr<PokerPlayer> addNewPlayer();
+
+      /**
+       * Returns the player that is currently the better.
+       * 
+       * @return The player that is currently the better.
+       */
+      std::shared_ptr<PokerPlayer> getCurrentBetter();
+
+      /**
+       * Starts a new game of poker.
+       */
+      void newGame();
+
+      /**
+       * Starts a new round of poker.
+       */
+      void newRound();
+
+      /**
+       * Starts a new betting round.
+       */
+      void newBettingRound();
+
+      /**
+       * Takes the blinds from the players.
+       */
+      void takeBlinds();
+
+      /**
+       * Sets the blinds for the game.
+       * 
+       * @param small The cost of the small blind.
+       * @param big The cost of the big blind.
+       */
+      void setBlinds(const int32_t small, const int32_t big);
+
+      /**
+       * Returns the count of players that still need to bet this round.
+       * 
+       * @return The count of players that still need to bet this round.
+       */
+      uint8_t getRemainingBettersCount();
+
+      /**
+       * Returns the current call value for the game.
+       * 
+       * @return The current call value for the game.
+       */
+      int32_t getCurrentCallValue();
+
+      /**
+       * Returns the next better index.
+       * 
+       * @return The next better index.
+       */
+      uint8_t getNextBetterIndex();
+
+      /**
+       * Sets the dealer for the game.
+       * 
+       * @param dealer The index of the dealer.
+       */
+      void setDealer(const uint8_t dealer);
+
+      /**
+       * Sends a card to the burn pile.
+       */
+      void burnCard();
+
+      /**
+       * Deals a card to a player.
+       * 
+       * @param player The player to deal the card to.
+       */
+      void dealCard(PokerPlayer &player);
+
+      /**
+       * Deals a card to each player.
+       * 
+       * @param count The count of cards to deal.
+       */
+      void dealToEveryone(const uint8_t count);
+
+      /**
+       * Deals a card to the community.
+       * 
+       * @param count The count of cards to turn.
+       */
+      void turn(const uint8_t count = 0xFF);
+
+      /**
+       * Returns the count of cards that need to be turned.
+       * 
+       * @return The count of cards that need to be turned.
+       */
+      uint8_t getCountOfCardsToTurn();
+
+      /**
+       * Returns the count of players that are still in the game.
+       * 
+       * @return The count of players that are still in the game.
+       */
+      uint8_t getRemainingPlayersCount();
+  };
+}

src/dawn/poker/PokerPlayer.cpp

@@ -0,0 +1,481 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "PokerPlayer.hpp"
+#include "PokerGame.hpp"
+#include "util/Math.hpp"
+#include "util/Random.hpp"
+#include "util/Easing.hpp"
+
+using namespace Dawn;
+
+PokerPlayer::PokerPlayer(
+  const std::weak_ptr<PokerGame> pokerGame,
+  const uint8_t playerIndex
+) {
+  this->pokerGame = pokerGame;
+  this->playerIndex = playerIndex;
+  this->chips = POKER_PLAYER_CHIPS_DEFAULT;
+}
+
+void PokerPlayer::addChips(const int32_t chips) {
+  assertTrue(chips > 0, "Must add a positive amount of chips.");
+
+  this->chips += chips;
+  if(this->chips > 0) this->isOut = false;
+  
+  this->eventChipsChanged.emit();
+}
+
+void PokerPlayer::setChips(const int32_t chips) {
+  this->chips = 0;
+  this->addChips(chips);
+}
+
+bool_t PokerPlayer::needsToBetThisRound() {
+  if(this->isFolded) return false;
+  if(this->chips <= 0) return false;
+  if(!this->hasBetThisRound) return true;
+  auto pg = this->pokerGame.lock();
+  assertNotNull(pg, "PokerGame has become invalid.");
+  if(this->currentBet < pg->getCurrentCallValue()) return true;
+  return false;
+}
+
+void PokerPlayer::bet(
+  struct PokerPot &pot,
+  const int32_t chips
+) {
+  assertTrue(chips >= 0, "Chips must be a positive value.");
+  assertTrue(!this->isFolded, "Cannot bet if player is folded.");
+  assertTrue(!this->isOut, "Cannot bet if player is out.");
+
+  this->setChips(this->chips - chips);
+  this->currentBet += chips;
+  this->hasBetThisRound = true;
+  if(chips > 0) {
+    this->timesRaised++;
+  } else {
+    this->timesRaised = 0;
+  }
+
+  pot.chips += chips;
+  pot.call = Math::max<int32_t>(pot.call, this ->currentBet);
+
+  auto existing = std::find(pot.players.begin(), pot.players.end(), shared_from_this());
+  if(existing == pot.players.end()) pot.players.push_back(shared_from_this());
+}
+
+void PokerPlayer::bet(const int32_t chips) {
+  auto pg = this->pokerGame.lock();
+  assertNotNull(pg, "PokerGame has become invalid.");
+  assertTrue(pg->pots.size() > 0, "PokerGame has no pots?");
+  this->bet(pg->pots.back(), chips);
+}
+
+void PokerPlayer::fold() {
+  this->isFolded = true;
+  this->hasBetThisRound = true;
+  this->timesRaised = 0;
+}
+
+bool_t PokerPlayer::canCheck() {
+  if(this->isFolded) return false;
+  if(this->isOut) return false;
+
+  auto pg = this->pokerGame.lock();
+  assertNotNull(pg, "PokerGame has become invalid.");
+  return pg->getCurrentCallValue() == this->currentBet;
+}
+
+struct PokerTurn PokerPlayer::getAITurn() {
+  struct PokerTurn turn;
+  float_t confidence;
+  int32_t callBet;
+  float_t potOdds;
+
+  auto pg = this->pokerGame.lock();
+  assertNotNull(pg, "PokerGame has become invalid.");
+
+  // Can the player do anything?
+  if(this->isFolded || this->isOut) {
+    turn.type = PokerTurnType::Out;
+    return turn;
+  }
+
+  // The following logic is heavily inspired by;
+  // https://github.com/gorel/C-Poker-AI/blob/master/src/common/pokerai.c
+  // But with some changes and smarts added by me. The original source code will
+  // essentially just run a crap tun of simulated games and get the times that
+  // they are expected to win from those games, but I'm just going to use the
+  // odds of the winning hand.
+
+
+  // Is this preflop?
+  if(pg->community.size() == 0) {
+    assertTrue(
+      this->hand.size() == POKER_PLAYER_HAND_SIZE_MAX,
+      "Invalid hand size."
+    );
+
+    // Get the hand weight
+    auto cardNumber0 = this->hand[0].getValue();
+    auto suitNumber0 = this->hand[0].getSuit();
+    auto cardNumber1 = this->hand[1].getValue();
+    auto suitNumber1 = this->hand[1].getSuit();
+
+    // Get delta between cards
+    auto i = (uint8_t)Math::abs<int8_t>(
+      (int8_t)cardNumber0 - (int8_t)cardNumber1
+    );
+
+    // Get card weight
+    confidence = (float_t)cardNumber0 + (float_t)cardNumber1;
+    if(cardNumber0 == cardNumber1) {// Pairs
+      confidence += 6;
+    } else if(suitNumber0 == suitNumber1) {// Same suit
+      confidence += 4;
+    }
+
+    // Get difference from cards for guessing flush
+    if(i > 4) {
+      confidence -= 4;
+    } else if(i > 2) {
+      confidence -= i;
+    }
+
+    // Get the confidence delta 0-1
+    confidence = confidence / 30.0f;
+
+    // This may change in future, but I was finding the AI did not want to bet
+    // during the preflop enough, this curves the AI to want to preflop call 
+    // often.
+    confidence = Easing::easeOutCubic(confidence);
+  } else {
+    // Simulate my hand being the winning hand, use that as the confidence
+    auto winning = this->getWinning();
+    confidence = PokerWinning::getWinningTypeConfidence(winning.type);
+  }
+
+  // Now we know how confident the AI is, let's put a chip value to that weight
+  // How many chips to call?
+  callBet = this->getCallBet();
+
+  // Do they need chips to call, or is it possible to check?
+  if(callBet > 0) {
+    potOdds = (float_t)callBet / (
+      (float_t)callBet +
+      (float_t)this->getSumOfChips()
+    );
+  } else {
+    potOdds = 1.0f / (float_t)pg->getRemainingBettersCount();
+  }
+
+  // Now determine the expected ROI
+  auto expectedGain = confidence / potOdds;
+
+  // Now get a random 0-100
+  auto random = Random::random<int32_t>() % 100;
+
+  // Determine the max bet that the AI is willing to make
+  auto maxBet = (int32_t)((float_t)this->chips / 1.75f) - (random / 2);
+  maxBet -= callBet;
+
+  // Determine what's a good bluff bet.
+  auto bluffBet = random * maxBet / 100 / 2;
+
+  // Now prep the output
+  auto isBluff = false;
+  auto amount = 0;
+
+  // Now the actual AI can happen. This is basically a weight to confidence
+  // ratio. The higher the gains and the confidence then the more likely the AI
+  // is to betting. There are also bluff chances within here.
+  if(expectedGain < 0.8f && confidence < 0.8f) {
+    if(random < 85) {
+      amount = 0;
+    } else {
+      amount = bluffBet;
+      isBluff = true;
+    }
+  } else if((expectedGain < 1.0f && confidence < 0.85f) || confidence < 0.1f) {
+    if(random < 80) {
+      amount = 0;
+    } else if(random < 5) {
+      amount = callBet;
+      isBluff = true;
+    } else {
+      amount = bluffBet;
+      isBluff = true;
+    }
+  } else if((expectedGain < 1.3f && confidence < 0.9f) || confidence < 0.5f) {
+    if(random < 60 || confidence < 0.5f) {
+      amount = callBet;
+    } else {
+      amount = maxBet;
+    }
+  } else if(confidence < 0.95f || pg->community.size() < 4) {
+    if(random < 20) {
+      amount = callBet;
+    } else {
+      amount = maxBet;
+    }
+  } else {
+    amount = (this->chips - callBet) * 9 / 10;
+  }
+  
+  // TODO: We can nicely round the amounts here to get us to a more "human"
+  // number.
+
+  // If this is the first round... make it a lot less likely I'll bet
+  if(pg->community.size() == 0 && amount > callBet) {
+    if(random > 5) amount = callBet;
+  }
+
+  // Did we actually bet?
+  if(amount > 0) {
+    std::cout << "AI is betting " << amount << " chips, bluff:" <<  isBluff << std::endl;
+
+    // Let's not get caught in a raising loop with AI.
+    if(this->timesRaised >= POKER_PLAYER_MAX_RAISES) {
+      amount = callBet;
+    }
+
+    amount = Math::max<int32_t>(amount, callBet);
+    turn = PokerTurn::bet(shared_from_this(), amount);
+    turn.confidence = confidence;
+  } else if(this->canCheck()) {
+    turn = PokerTurn::bet(shared_from_this(), 0);
+    turn.confidence = 1;
+  } else {
+    turn = PokerTurn::fold(shared_from_this());
+    turn.confidence = 1 - confidence;
+  }
+
+  return turn;
+}
+
+int32_t PokerPlayer::getCallBet() {
+  auto pg = this->pokerGame.lock();
+  assertNotNull(pg, "PokerGame has become invalid.");
+  return pg->getCurrentCallValue() - this->currentBet;
+}
+
+int32_t PokerPlayer::getSumOfChips() {
+  auto pg = this->pokerGame.lock();
+  assertNotNull(pg, "PokerGame has become invalid.");
+  int32_t count = 0;
+  auto it = pg->pots.begin();
+  while(it != pg->pots.end()) {
+    if(std::find(
+      it->players.begin(), it->players.end(), shared_from_this()
+    ) != it->players.end()) {
+      count += it->chips;
+    }
+    ++it;
+  }
+  return count;
+}
+
+struct PokerWinning PokerPlayer::getWinning() {
+  struct PokerWinning winning;
+  struct Card card(0x00);
+  uint8_t i, j;
+  int32_t index;
+  enum CardValue number, look;
+  enum CardSuit suit;
+  std::vector<struct Card> pairs;
+
+  auto pg = this->pokerGame.lock();
+  assertNotNull(pg, "PokerGame has become invalid.");
+
+  winning.player = shared_from_this();
+
+  // Get the full poker hand (should be a 7 card hand, but MAY not be)
+  for(i = 0; i < pg->community.size(); i++) {
+    winning.full.push_back(pg->community[i]);
+  }
+  for(i = 0; i < this->hand.size(); i++) {
+    winning.full.push_back(this->hand[i]);
+  }
+  Card::sort(winning.full);
+  
+  //////////////////////// Now look for the winning set ////////////////////////
+
+  // Royal / Straight Flush
+  for(i = 0; i < winning.full.size(); i++) {
+    card = winning.full[i];
+    number = card.getValue();
+    if(number < CardValue::Five) continue;
+
+    suit = card.getSuit();
+    
+    winning.set.clear();
+    winning.set.push_back(card);
+
+    // Now look for the matching cards (Reverse order to order from A to 10)
+    for(j = 1; j <= 4; j++) {
+      // Ace low.
+      look = (
+        number == CardValue::Five && j == 4 ? 
+        (enum CardValue)CardValue::Ace :
+        (enum CardValue)((uint8_t)number - j)
+      );
+      index = Card::contains(winning.full, Card(suit, look));
+      if(index == -1) break;
+      winning.set.push_back(winning.full[index]);
+    }
+
+    // Check if has all necessary cards.
+    if(winning.set.size() < POKER_WINNING_SET_SIZE) continue;
+
+    // Add self to array
+    winning.type = (
+      number == CardValue::Ace ? PokerWinningType::RoyalFlush : 
+      PokerWinningType::StraightFlush
+    );
+    winning.fillRemaining();
+    return winning;
+  }
+
+  // Four of a kind.
+  for(i = 0; i < winning.full.size(); i++) {
+    card = winning.full[i];
+    number = card.getValue();
+    pairs = Card::countPairs(winning.full, number);
+    if(pairs.size() < CARD_SUIT_COUNT) continue;
+
+    winning.set = pairs;
+    winning.type = PokerWinningType::FourOfAKind;
+    winning.fillRemaining();
+    return winning;
+  }
+
+  // Full House
+  winning.set.clear();
+  for(i = 0; i < winning.full.size(); i++) {
+    // Check we haven't already added this card.
+    card = winning.full[i];
+    if(Card::contains(winning.set, card) != -1) {
+      continue;
+    }
+
+    number = card.getValue();
+    pairs = Card::countPairs(winning.full, number);
+
+    // Did we find either two pair or three pair?
+    if(pairs.size() != 2 && pairs.size() != 3) continue;
+    if(winning.set.size() == 3) {//Clamp to 5 max.
+      pairs.pop_back();
+    }
+
+    // Copy found pairs.
+    for(j = 0; j < pairs.size(); j++) {
+      winning.set.push_back(pairs[j]);
+    }
+
+    // Winned?
+    if(winning.set.size() != POKER_WINNING_SET_SIZE) continue;
+    winning.type = PokerWinningType::FullHouse;
+    winning.fillRemaining();
+    return winning;
+  }
+
+  // Flush (5 same suit)
+  for(i = 0; i < winning.full.size(); i++) {
+    card = winning.full[i];
+    suit = card.getSuit();
+    
+    winning.set.clear();
+    winning.set.push_back(card);
+
+    for(j = i+1; j < winning.full.size(); j++) {
+      if(winning.full[j].getSuit() != suit) continue;
+      winning.set.push_back(winning.full[j]);
+      if(winning.set.size() == POKER_WINNING_SET_SIZE) break;
+    }
+    if(winning.set.size() < POKER_WINNING_SET_SIZE) continue;
+    winning.type = PokerWinningType::Flush;
+    winning.fillRemaining();
+    return winning;
+  }
+
+  // Straight (sequence any suit)
+  for(i = 0; i < winning.full.size(); i++) {
+    card = winning.full[i];
+    number = card.getValue();
+    if(number < CardValue::Five) continue;
+
+    winning.set.clear();
+    winning.set.push_back(card);
+    
+    for(j = 1; j <= 4; j++) {
+      // Ace low.
+      look = (
+        number == CardValue::Five && j == 4 ?
+        (enum CardValue)CardValue::Ace :
+        (enum CardValue)((uint8_t)number - j)
+      );
+      index = Card::containsValue(winning.full, look);
+      if(index == -1) break;
+      winning.set.push_back(winning.full[index]);
+    }
+
+    // Check if has all necessary cards.
+    if(winning.set.size() < POKER_WINNING_SET_SIZE) continue;
+    winning.type = PokerWinningType::Straight;
+    winning.fillRemaining();
+    return winning;
+  }
+
+  // Three of a kind
+  for(i = 0; i < winning.full.size(); i++) {
+    card = winning.full[i];
+    number = card.getValue();
+    pairs = Card::countPairs(winning.full, number);
+    if(pairs.size() != 3) continue;
+
+    winning.set = pairs;
+    winning.type = PokerWinningType::ThreeOfAKind;
+    winning.fillRemaining();
+    return winning;
+  }
+
+  // Two Pair
+  winning.set.clear();
+  for(i = 0; i < winning.full.size(); i++) {
+    card = winning.full[i];// Check we haven't already added this card.
+    if(
+      winning.set.size() > 0 &&
+      Card::contains(winning.set, card) != -1
+    ) {
+      continue;
+    }
+
+    number = card.getValue();
+    pairs = Card::countPairs(winning.full, number);
+    if(pairs.size() != 2) continue;
+    for(j = 0; j < pairs.size(); j++) {
+      winning.set.push_back(pairs[j]);
+    }
+    if(winning.set.size() != 4) continue;
+    winning.type = PokerWinningType::TwoPair;
+    winning.fillRemaining();
+    return winning;
+  }
+
+  // Pair
+  if(winning.set.size() == 2) {
+    winning.type = PokerWinningType::Pair;
+    winning.fillRemaining();
+    return winning;
+  }
+
+  // High card
+  winning.set.clear();
+  winning.fillRemaining();
+  winning.type = PokerWinningType::HighCard;
+  return winning;
+}

src/dawn/poker/PokerPlayer.hpp

@@ -0,0 +1,131 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "Card.hpp"
+#include "PokerPot.hpp"
+#include "PokerWinning.hpp"
+#include "PokerTurn.hpp"
+#include "event/Event.hpp"
+
+#define POKER_PLAYER_CHIPS_DEFAULT 10000
+
+/** Maximum cards a players' hand can hold */
+#define POKER_PLAYER_HAND_SIZE_MAX 2
+
+#define POKER_PLAYER_MAX_RAISES 0x02
+
+namespace Dawn {
+  class PokerGame;
+
+  class PokerPlayer : public std::enable_shared_from_this<PokerPlayer> {
+    public:
+      std::weak_ptr<PokerGame> pokerGame;
+      uint8_t playerIndex;
+      int32_t chips = 0;
+      int32_t currentBet = 0;
+      uint8_t timesRaised = 0;
+      bool_t isFolded = false;
+      bool_t isOut = false;
+      bool_t hasBetThisRound = false;
+      bool_t isShowingHand = false;
+      bool_t isHuman = false;
+      std::vector<struct Card> hand;
+
+      Event<> eventChipsChanged;
+
+      /**
+       * Constructor for the PokerPlayer class.
+       * 
+       * @param pokerGame Poker game this player is a part of.
+       * @param playerIndex Index of the player in the game.
+       */
+      PokerPlayer(
+        const std::weak_ptr<PokerGame> pokerGame,
+        const uint8_t playerIndex
+      );
+
+      /**
+       * Adds chips to the player. This will also update the players' state.
+       * 
+       * @param chips Count of chips to add.
+       */
+      void addChips(const int32_t chips);
+
+      /**
+       * Sets the chips a player has.
+       * 
+       * @param chips Chips to set to the player.
+       */
+      void setChips(const int32_t chips);
+
+      /**
+       * Returns true if the player still needs to bet this betting round.
+       * 
+       * @return True if betting is still required by this player.
+       */
+      bool_t needsToBetThisRound();
+
+      /**
+       * Let a player bet chips into the pot.
+       * 
+       * @param pot Poker pot to bet in to.
+       * @param amount The amount of chips the player is betting.
+       */
+      void bet(struct PokerPot &pot, const int32_t amount);
+
+      /**
+       * Let a player bet chips into the current pot.
+       * 
+       * @param amount The amount of chips the player is betting.
+       */
+      void bet(const int32_t amount);
+
+      /**
+       * Player folds.
+       */
+      void fold();
+
+      /**
+       * Returns the AI result for a turn done by a non human player.
+       * 
+       * @return Some information about the move the player is trying to perform
+       */
+      struct PokerTurn getAITurn();
+
+      /**
+       * Calculates and returns the winning state for a given player
+       * 
+       * @return The winning state for this current players hand.
+       */
+      struct PokerWinning getWinning();
+
+      /**
+       * Returns the sum of chips in the pot(s) that the specified player is in.
+       * This does not consider the pot, player or hand, just the pure sum of
+       * chips.
+       * 
+       * @return The sum of chips from the pots the player is within.
+       */
+      int32_t getSumOfChips();
+
+      /**
+       * Get the bet necessary for a specific player to make a call. This takes
+       * the players current bet and the bet necessary to call into the pot and
+       * will return the difference.
+       * 
+       * @return The count of chips needed to call into the current active pot.
+       */
+      int32_t getCallBet();
+
+      /**
+       * Returns whether or not the player can check, or if they need to either
+       * fold, call or bet.
+       * 
+       * @return True if they can check.
+       */
+      bool_t canCheck();
+  };
+}

src/dawn/poker/PokerPot.cpp

@@ -0,0 +1,111 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "PokerPot.hpp"
+#include "PokerGame.hpp"
+#include "PokerPlayer.hpp"
+
+using namespace Dawn;
+
+void PokerPotWinning::award() {
+  auto it = this->winners.begin();
+  while(it != this->winners.end()) {
+    if(it == this->winners.begin()) {
+      (*it)->addChips(this->chipsEach + this->chipsOverflow);
+    } else {
+      (*it)->addChips(this->chipsEach);
+    }
+    ++it;
+  }
+}
+
+struct PokerPotWinning PokerPot::getWinners() {
+  struct PokerPotWinning winning;
+
+  winning.pot = this;
+  
+  // Calculate the winnings first.
+  auto it = this->players.begin();
+  while(it != this->players.end()) {
+    auto player = *it;
+
+    if(player->isOut || player->isFolded) {
+      ++it;
+      continue;
+    }
+
+    winning.participants.push_back(player);
+    winning.winnings[player] = player->getWinning();
+    ++it;
+  }
+
+  // Compare participating players
+  auto it2 = winning.participants.begin();
+  while(it2 != winning.participants.end()) {
+    auto playerLeft = *it2;
+    auto winnerLeft = &winning.winnings[playerLeft];
+    bool_t isWinner = true;
+    enum CardValue highNumber = CardValue::Invalid;
+    enum CardValue number = CardValue::Invalid;
+    struct Card highCard(0xFF);
+    struct Card card(0xFF);
+
+    auto it3 = winning.participants.begin();
+    while(it3 != winning.participants.end()) {
+      if(it2 == it3) {
+        ++it3;
+        continue;
+      }
+
+      auto playerRight = *it3;
+      auto winnerRight = &winning.winnings[playerRight];
+
+      // Am I the better hand / Is it the better hand?
+      if(winnerLeft->type < winnerRight->type) {
+        ++it3;
+        continue;
+      }
+      if(winnerLeft->type > winnerRight->type) {
+        isWinner = false;
+        break;
+      }
+
+      // Equal, compare hands.
+      card = PokerWinning::compare(*winnerLeft, *winnerRight);
+      if(card.cardValue == 0xFF) {
+        isWinner = false;
+        break;
+      }
+
+      // Determine high card.
+      number = card.getValue();
+      if(
+        highNumber == CardValue::Invalid ||
+        number == CardValue::Ace ||
+        number > highNumber
+      ) {
+        highCard = card;
+        highNumber = number;
+      }
+      ++it3;
+    }
+
+    if(!isWinner) {
+      ++it2;
+      continue;
+    }
+
+    winnerLeft->kicker = highCard;
+    winning.winners.push_back(playerLeft);
+    ++it2;
+  }
+
+  winning.chipsEach = this->chips / (int32_t)winning.winners.size();
+  winning.chipsOverflow = this->chips - (
+    winning.chipsEach * (int32_t)winning.winners.size()
+  );
+
+  return winning;
+}

src/dawn/poker/PokerPot.hpp

@@ -0,0 +1,39 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "PokerWinning.hpp"
+
+namespace Dawn {
+  class PokerPlayer;
+  class PokerGame;
+  struct PokerPot;
+
+  struct PokerPotWinning {
+    public:
+      std::map<std::shared_ptr<PokerPlayer>, struct PokerWinning> winnings;
+      std::vector<std::shared_ptr<PokerPlayer>> winners;
+      std::vector<std::shared_ptr<PokerPlayer>> participants;
+      struct PokerPot *pot;
+      int32_t chipsEach;
+      int32_t chipsOverflow;
+
+      void award();
+  };
+  
+  struct PokerPot {
+    public:
+      int32_t chips;
+      int32_t call;
+      std::vector<std::shared_ptr<PokerPlayer>> players;
+
+      /**
+       * Get the winners of the pot.
+       * 
+       * @return The winning state of the pot.
+       */
+      struct PokerPotWinning getWinners();
+  };
+}

src/dawn/poker/PokerTurn.cpp

@@ -0,0 +1,77 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "PokerTurn.hpp"
+#include "PokerPlayer.hpp"
+#include "PokerGame.hpp"
+
+using namespace Dawn;
+
+struct PokerTurn PokerTurn::bet(
+  std::shared_ptr<PokerPlayer> player,
+  const int32_t chips
+) {
+  struct PokerTurn turn;
+  int32_t i;
+
+  assertNotNull(player, "Player cannot be null.");
+  assertTrue(chips >= 0, "Chips must be greater than or equal to 0.");
+
+  turn.player = player;
+  turn.confidence = 1;
+
+  if(chips == 0) {
+    turn.type = PokerTurnType::Check;
+    turn.chips = 0;
+  } else if(player->chips <= chips) {
+    turn.chips = player->chips;
+    turn.type = PokerTurnType::AllIn;
+  } else {
+    turn.chips = chips;
+    turn.type = PokerTurnType::Bet;
+
+    auto pg = player->pokerGame.lock();
+    assertNotNull(pg, "Player must be in a game.");
+
+    i = pg->getCurrentCallValue();
+
+    if(chips == (i - player->currentBet)) turn.type = PokerTurnType::Call;
+  }
+
+  return turn;
+}
+
+struct PokerTurn PokerTurn::fold(std::shared_ptr<PokerPlayer> player) {
+  struct PokerTurn turn;
+  turn.player = player;
+  turn.chips = 0;
+  turn.confidence = 1;
+  turn.type = PokerTurnType::Fold;
+  return turn;
+}
+
+void PokerTurn::action() {
+  assertNotNull(this->player, "Player cannot be null.");
+
+  switch(this->type) {
+    case PokerTurnType::Bet:
+    case PokerTurnType::Call:
+    case PokerTurnType::AllIn:
+      this->player->bet(this->chips);
+      break;
+
+    case PokerTurnType::Check:
+      player->bet(0);
+      break;
+
+    case PokerTurnType::Fold:
+      player->fold();
+      break;
+    
+    default:
+      assertUnreachable("Unknown turn type.");
+      break;
+  }
+}

src/dawn/poker/PokerTurn.hpp

@@ -0,0 +1,55 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "dawnlibs.hpp"
+
+namespace Dawn {
+  class PokerPlayer;
+
+  enum class PokerTurnType : uint8_t {
+    Out = 0,
+    Fold = 1,
+    Bet = 2,
+    Call = 3,
+    Check = 4,
+    AllIn = 5
+  };
+
+  struct PokerTurn {
+    public:
+      /** What type of action the turn is */
+      enum PokerTurnType type;
+      /** How many chips they did in their turn (if applicable) */
+      int32_t chips;
+      /** How confident the AI is about their turn. 0 = none, 1 = full */
+      float_t confidence;
+      /** Player that this action belongs to */
+      std::shared_ptr<PokerPlayer> player;
+
+      /**
+       * Generate a turn action for betting as a player.
+       * 
+       * @param player Player index who is betting.
+       * @param chips Chips to raise by.
+       * @return A turn for a bet action.
+       */
+      static struct PokerTurn bet(
+        std::shared_ptr<PokerPlayer> player, const int32_t chips
+      );
+
+      /**
+       * Return a turn action for the given player to fold.
+       * 
+       * @return A turn for a fold action.
+       */
+      static struct PokerTurn fold(std::shared_ptr<PokerPlayer> player);
+
+      /**
+       * Actions / Performs this turn against the defined player.
+       */
+      void action();
+  };
+}

src/dawn/poker/PokerWinning.cpp

@@ -0,0 +1,157 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "PokerWinning.hpp"
+#include "PokerPlayer.hpp"
+
+using namespace Dawn;
+
+float_t PokerWinning::getWinningTypeConfidence(enum PokerWinningType type) {
+  switch(type) {
+    case PokerWinningType::RoyalFlush:
+      return POKER_WINNING_CONFIDENCE_ROYAL_FLUSH;
+    case PokerWinningType::StraightFlush:
+      return POKER_WINNING_CONFIDENCE_STRAIGHT_FLUSH;
+    case PokerWinningType::FourOfAKind:
+      return POKER_WINNING_CONFIDENCE_FOUR_OF_A_KIND;
+    case PokerWinningType::FullHouse:
+      return POKER_WINNING_CONFIDENCE_FULL_HOUSE;
+    case PokerWinningType::Flush:
+      return POKER_WINNING_CONFIDENCE_FLUSH;
+    case PokerWinningType::Straight:
+      return POKER_WINNING_CONFIDENCE_STRAIGHT;
+    case PokerWinningType::ThreeOfAKind:
+      return POKER_WINNING_CONFIDENCE_THREE_OF_A_KIND;
+    case PokerWinningType::TwoPair:
+      return POKER_WINNING_CONFIDENCE_TWO_PAIR;
+    case PokerWinningType::Pair:
+      return POKER_WINNING_CONFIDENCE_PAIR;
+    default:
+      return POKER_WINNING_CONFIDENCE_HIGH_CARD;
+  }
+}
+
+struct Card PokerWinning::compare(
+  const struct PokerWinning &left,
+  const struct PokerWinning &right
+) {
+  uint8_t i;
+  enum CardValue number = CardValue::Invalid;
+  enum CardValue highNumberLeft = CardValue::Invalid;
+  enum CardValue highNumberRight = CardValue::Invalid;
+  struct Card card(0xFF), highCardLeft(0xFF), highCardRight(0xFF);
+  int32_t index;
+  uint8_t countCardsSame;
+
+  countCardsSame = 0;
+
+  for(i = 0; i < left.set.size(); i++) {
+    card = left.set[i];
+    number =  card.getValue();
+    // Quick check
+    if(highNumberLeft != CardValue::Invalid && number < highNumberLeft) continue;
+
+    // Check if this number is within the other hand or not
+    index = Card::containsValue(right.set, number);
+    if(index != -1) {
+      // This number IS within the other hand, let's check that the EXACT card
+      // is a match/isn't a match.
+      index = Card::contains(right.set, card);
+
+      // Exact card match
+      if(index != -1) {
+        countCardsSame++;
+        continue;
+      }
+      // Not exact card match.. ?
+    }
+
+    if(
+      highNumberLeft == CardValue::Invalid ||
+      number == CardValue::Ace ||
+      highNumberLeft < number
+    ) {
+      highNumberLeft = number;
+      highCardLeft = card;
+    }
+  }
+  
+  for(i = 0; i < right.set.size(); i++) {
+    card = right.set[i];
+    number = card.getValue();
+    if(highNumberRight != CardValue::Invalid && number < highNumberRight) {
+      continue;
+    }
+    
+    index = Card::containsValue(left.set, number);
+    if(index != -1) {
+      index = Card::contains(left.set, card);
+      if(index != -1) continue;
+    }
+
+    if(
+      highNumberRight == CardValue::Invalid ||
+      number == CardValue::Ace || highNumberRight < number
+    ) {
+      highNumberRight = number;
+      highCardRight = card;
+    }
+  }
+
+
+  if(countCardsSame == left.set.size()) {
+    for(i = 0; i < left.set.size(); i++) {
+      card = left.set[i];
+      number = card.getValue();
+      if(
+        highNumberLeft == CardValue::Invalid ||
+        number == CardValue::Ace ||
+        highNumberLeft < number
+      ) {
+        highNumberLeft = number;
+        highCardLeft = card;
+      }
+    }
+    return highCardLeft;
+  }
+
+  if(highCardLeft.cardValue == 0xFF) return 0xFF;
+  if(highNumberLeft < highNumberRight) return 0xFF;
+  return highCardLeft;// Greater or Equal to.
+}
+
+void PokerWinning::fillRemaining() {
+  uint8_t i;
+  CardValue highest, current;
+  struct Card highestCard(0x00);
+  struct Card currentCard(0x00);
+
+  // Set the kicker
+  this->kicker = 0xFF;
+
+  // Fill the remaining cards
+  while(this->set.size() < POKER_WINNING_SET_SIZE) {
+    highest = CardValue::Invalid;
+
+    for(i = 0; i < this->full.size(); i++) {
+      currentCard = this->full[i];
+      if(Card::contains(this->set, currentCard) != -1) continue;
+
+      if(highest == CardValue::Invalid) {
+        highestCard = currentCard;
+        highest = highestCard.getValue();
+      } else {
+        current = currentCard.getValue();
+        if(current != CardValue::Ace && current < highest) continue;
+        highestCard = currentCard;
+        highest = current;
+      }
+    }
+
+    if(highest == CardValue::Invalid) break;
+    this->set.push_back(highestCard);
+  }
+  Card::sort(this->set);
+}

src/dawn/poker/PokerWinning.hpp

@@ -0,0 +1,86 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "dawnlibs.hpp"
+#include "Card.hpp"
+
+#define POKER_WINNING_CONFIDENCE_ROYAL_FLUSH 1.0f
+#define POKER_WINNING_CONFIDENCE_STRAIGHT_FLUSH 0.99f
+#define POKER_WINNING_CONFIDENCE_FOUR_OF_A_KIND 0.9f
+#define POKER_WINNING_CONFIDENCE_FULL_HOUSE 0.85f
+#define POKER_WINNING_CONFIDENCE_FLUSH 0.8f
+#define POKER_WINNING_CONFIDENCE_STRAIGHT 0.7f
+#define POKER_WINNING_CONFIDENCE_THREE_OF_A_KIND 0.5f
+#define POKER_WINNING_CONFIDENCE_TWO_PAIR 0.4f
+#define POKER_WINNING_CONFIDENCE_PAIR 0.2f
+#define POKER_WINNING_CONFIDENCE_HIGH_CARD 0.1f
+
+/** How many cards in the winning set */
+#define POKER_WINNING_SET_SIZE 5
+
+namespace Dawn {
+  class PokerPlayer;
+
+  enum class PokerWinningType {
+    Null,
+    RoyalFlush,
+    StraightFlush,
+    FourOfAKind,
+    FullHouse,
+    Flush,
+    Straight,
+    ThreeOfAKind,
+    TwoPair,
+    Pair,
+    HighCard
+  };
+
+  struct PokerWinning {
+    public:
+      /**
+       * Get the confidence of the bet for a given winning type.
+       * 
+       * @param type Winning type type.
+       * @return The confidence.
+       */
+      static float_t getWinningTypeConfidence(enum PokerWinningType type);
+
+      /**
+       * Compares two winning sets. The returned card is the kicker if the LEFT
+       * side is the winner. If LEFT is not a winner then 0xFF will be returned.
+       * 
+       * @param left Left winning set.
+       * @param right Right winning set.
+       * @return The kicker card from left's hand or 0xFF if not the winner.
+       */
+      static struct Card compare(
+        const struct PokerWinning &left,
+        const struct PokerWinning &right
+      );
+
+      /** Winning Type */
+      enum PokerWinningType type;
+      /** The full set of both the dealer and player's hand */
+      std::vector<struct Card> full;
+      /** Holds the winning set */
+      std::vector<struct Card> set;
+      /** If there was a kicker card it will be here */
+      struct Card kicker;
+      /* The player this winning state belongs to */
+      std::shared_ptr<PokerPlayer> player;
+      
+      PokerWinning() : kicker(0xFF) {}
+
+      /**
+       * Fills the remaining cards for a given poker player winning hand.
+       * Essentially this will just take the highest cards and slot them into
+       * the array. This also sorts the cards.
+       * 
+       * @param winning Pointer to the poker winning to fill out.
+       */
+      void fillRemaining();
+  };
+}

src/dawn/prefab/Prefab.hpp

@@ -1,4 +1,4 @@
-// Copyright (c) 2023 Dominic Masters
+// Copyright (c) 2024 Dominic Masters
 // 
 // This software is released under the MIT License.
 // https://opensource.org/licenses/MIT
@@ -7,5 +7,8 @@
 #include "scene/Scene.hpp"
 
 namespace Dawn {
-  void helloWorldScene(Scene &s);
+  struct Prefab {
+    public:
+      std::shared_ptr<SceneItem> item;
+  };
 }

src/dawn/prefab/SimpleSpinningCube.cpp

@@ -4,32 +4,32 @@
 // https://opensource.org/licenses/MIT
 
 #include "SimpleSpinningCube.hpp"
-#include "component/display/MeshRenderer.hpp"
-#include "component/display/material/SimpleTexturedMaterial.hpp"
 #include "display/mesh/CubeMesh.hpp"
 #include "component/SimpleComponent.hpp"
 
 using namespace Dawn;
 
-std::shared_ptr<SceneItem> Dawn::createSimpleSpinningCube(Scene &s) {
+struct SimpleSpinningCube Dawn::createSimpleSpinningCube(Scene &s) {
+  struct SimpleSpinningCube cube;
+
   // Create the scene item.
-  auto cubeItem = s.createSceneItem();
+  cube.item = s.createSceneItem();
 
   // Create a simple cube mesh.
-  auto cubeMesh = std::make_shared<Mesh>();
-  cubeMesh->createBuffers(CUBE_VERTICE_COUNT, CUBE_INDICE_COUNT);
-  CubeMesh::buffer(cubeMesh, glm::vec3(-1, -1, -1), glm::vec3(2, 2, 2), 0, 0);
+  cube.mesh = std::make_shared<Mesh>();
+  cube.mesh->createBuffers(CUBE_VERTICE_COUNT, CUBE_INDICE_COUNT);
+  CubeMesh::buffer(cube.mesh, glm::vec3(-1, -1, -1), glm::vec3(2, 2, 2), 0, 0);
 
   // Add a renderer to the scene item.
-  auto cubeMeshRenderer = cubeItem->addComponent<MeshRenderer>();
-  cubeMeshRenderer->mesh = cubeMesh;
+  cube.meshRenderer = cube.item->addComponent<MeshRenderer>();
+  cube.meshRenderer->mesh = cube.mesh;
 
   // Add a material to the scene item.
-  auto cubeMaterial = cubeItem->addComponent<SimpleTexturedMaterial>();
-  cubeMaterial->setColor(COLOR_MAGENTA);
+  cube.material = cube.item->addComponent<SimpleTexturedMaterial>();
+  cube.material->setColor(COLOR_MAGENTA);
 
   // Add a simple event listener component to the scene item.
-  addSimpleComponent(cubeItem, [](auto &cmp, auto &events) {
+  addSimpleComponent(cube.item, [](auto &cmp, auto &events) {
     // Note that add component cannot receive a self reference, so we must
     // capture the component by reference instead.
     events.push_back(cmp.getScene()->onUnpausedUpdate.listen([&](
@@ -45,5 +45,5 @@ std::shared_ptr<SceneItem> Dawn::createSimpleSpinningCube(Scene &s) {
     }));
   });
 
-  return cubeItem;
+  return cube;
 }

src/dawn/prefab/SimpleSpinningCube.hpp

@@ -4,8 +4,23 @@
 // https://opensource.org/licenses/MIT
 
 #pragma once
-#include "scene/Scene.hpp"
+#include "prefab/Prefab.hpp"
+#include "component/display/MeshRenderer.hpp"
+#include "component/display/material/SimpleTexturedMaterial.hpp"
 
 namespace Dawn {
-  std::shared_ptr<SceneItem> createSimpleSpinningCube(Scene &s);
+  struct SimpleSpinningCube : public Prefab {
+    public:
+      std::shared_ptr<Mesh> mesh;
+      std::shared_ptr<MeshRenderer> meshRenderer;
+      std::shared_ptr<SimpleTexturedMaterial> material;
+  };
+
+  /**
+   * Creates a simple spinning cube prefab on the scene.
+   * 
+   * @param s Scene to add the simple spinning cube to.
+   * @return The simple spinning cube prefab.
+   */
+  struct SimpleSpinningCube createSimpleSpinningCube(Scene &s);
 }

src/dawn/scene/Scene.cpp

@@ -67,4 +67,6 @@ void Scene::removeItem(const std::shared_ptr<SceneItem> item) {
 }
 
 Scene::~Scene() {
+  sceneItemsToRemove.clear();
+  sceneItems.clear();
 }

src/dawn/scene/Scene.hpp

@@ -31,6 +31,13 @@ namespace Dawn {
       TimeoutEvent onTimeout;
       IntervalEvent onInterval;
 
+      /**
+       * Returns the initial scene for the game.
+       * 
+       * @return Initial scene function.
+       */
+      static const std::function<void(Scene&)> getInitialScene();
+
       /**
        * Constructs a scene object.
        * 

src/dawn/scene/SceneComponent.cpp

@@ -10,7 +10,11 @@
 
 using namespace Dawn;
 
+uint64_t SCENE_COMPONENTS_ACTIVE = 0;
+
 void SceneComponent::init(const std::shared_ptr<SceneItem> item) {
+  SCENE_COMPONENTS_ACTIVE++;
+
   assertFlagOff(
     sceneComponentState,
     SCENE_COMPONENT_STATE_INIT,
@@ -39,22 +43,33 @@ void SceneComponent::dispose() {
     sceneComponentState,
     SCENE_COMPONENT_STATE_DISPOSED
   );
+
+  // Clear Listeners
+  for(auto &listener : this->listeners) listener();
+  this->listeners.clear();
+
   this->onDispose();
   this->item.reset();
 }
 
 std::shared_ptr<SceneItem> SceneComponent::getItem() {
-  return this->item.lock();
+  auto item = this->item.lock();
+  assertNotNull(item, "Item cannot be null?");
+  return item;
 }
 
 std::shared_ptr<Scene> SceneComponent::getScene() {
   auto item = this->getItem();
-  return item->getScene();
+  auto scene = item->getScene();
+  assertNotNull(scene, "Scene cannot be null?");
+  return scene;
 }
 
 std::shared_ptr<Game> SceneComponent::getGame() {
   auto scene = this->getScene();
-  return scene->getGame();
+  auto game = scene->getGame();
+  assertNotNull(game, "Game cannot be null?");
+  return game;
 }
 
 SceneComponent::~SceneComponent() {
@@ -68,4 +83,7 @@ SceneComponent::~SceneComponent() {
       "SceneComponent is initialized but was not properly disposed!"
     );
   }
+
+  this->item.reset();
+  SCENE_COMPONENTS_ACTIVE--;
 }

src/dawn/scene/SceneComponent.hpp

@@ -9,10 +9,13 @@
 #define SCENE_COMPONENT_STATE_INIT 0x01
 #define SCENE_COMPONENT_STATE_DISPOSED 0x02
 
+extern uint64_t SCENE_COMPONENTS_ACTIVE;
+
 namespace Dawn {
   class Game;
   class Scene;
   class SceneItem;
+  class SceneItemComponents;
 
   class SceneComponent : std::enable_shared_from_this<SceneComponent> {
     private:
@@ -20,6 +23,8 @@ namespace Dawn {
       uint_fast8_t sceneComponentState = 0;
 
     protected:
+      std::vector<std::function<void()>> listeners;
+
       /**
        * Custom component listener that is invoked when the component is meant
        * to initialize.
@@ -70,5 +75,8 @@ namespace Dawn {
        * Disposes this scene component.
        */
       virtual ~SceneComponent();
+
+      friend class SceneItem;
+      friend class SceneItemComponents;
   };
 }

src/dawn/scene/SceneItem.cpp

@@ -8,11 +8,14 @@
 
 using namespace Dawn;
 
+uint64_t SCENE_ITEMS_ACTIVE = 0;
+
 SceneItem::SceneItem(const std::weak_ptr<Scene> scene) :
   scene(scene),
   SceneItemTransform(),
   SceneItemComponents()
 {
+  SCENE_ITEMS_ACTIVE++;
 }
 
 std::shared_ptr<SceneItem> SceneItem::sceneItemComponentsSelf() {
@@ -37,11 +40,5 @@ void SceneItem::remove() {
 }
 
 SceneItem::~SceneItem() {
-  std::for_each(
-    components.begin(),
-    components.end(),
-    [](auto &component) {
-      component->dispose();
-    }
-  );
+  SCENE_ITEMS_ACTIVE--;
 }

src/dawn/scene/SceneItem.hpp

@@ -7,6 +7,8 @@
 #include "scene/item/SceneItemTransform.hpp"
 #include "scene/item/SceneItemComponents.hpp"
 
+extern uint64_t SCENE_ITEMS_ACTIVE;
+
 namespace Dawn {
   class Scene;
 

src/dawn/scene/item/SceneItemComponents.cpp

@@ -21,5 +21,11 @@ void SceneItemComponents::removeComponent(
 }
 
 SceneItemComponents::~SceneItemComponents() {
-
+  auto it = components.begin();
+  while(it != components.end()) {
+    auto component = *it;
+    component->dispose();
+    ++it;
+  }
+  components.clear();
 }

src/dawn/scene/item/SceneItemComponents.hpp

@@ -43,6 +43,7 @@ namespace Dawn {
         this->components.push_back(
           static_pointer_cast<SceneComponent>(component)
         );
+        component->item = this->sceneItemComponentsSelf();
         return component;
       }
 

src/dawn/scene/item/SceneItemTransform.cpp

@@ -123,6 +123,32 @@ glm::quat SceneItemTransform::getLocalRotation() {
   return this->localRotation;
 }
 
+void SceneItemTransform::setParent(std::shared_ptr<SceneItem> parent) {
+  if(this->parent.lock() == parent) return;
+
+  auto self = dynamic_cast<SceneItem*>(this);
+  assertNotNull(self, "Cannot set parent of null item?");
+
+  if(auto oldParent = this->parent.lock()) {
+    auto &children = oldParent->children;
+    children.erase(
+      std::remove_if(
+        children.begin(),
+        children.end(),
+        [self](std::weak_ptr<SceneItem> &item) {
+          return item.lock() == self->shared_from_this();
+        }
+      ),
+      children.end()
+    );
+  }
+  this->parent = parent;
+  if(auto newParent = this->parent.lock()) {
+    newParent->children.push_back(self->shared_from_this());
+  }
+  this->updateWorldTransformFromParent();
+}
+
 void SceneItemTransform::setLocalTransform(const glm::mat4 transform) {
   this->transformLocal = transform;
   this->updateLocalValuesFromLocalTransform();
@@ -168,6 +194,25 @@ void SceneItemTransform::lookAt(
   this->setWorldTransform(glm::lookAt(position, target, up));
 }
 
+float_t SceneItemTransform::lookAtPixelPerfect(
+  const glm::vec3 &position,
+  const glm::vec3 &look,
+  const float_t viewportHeight,
+  const float_t fov,
+  const float_t scale
+) {
+  float_t z = (
+    tanf((glm::radians(180.0f) - fov) / 2.0f) *
+    (viewportHeight/2.0f)
+  ) / scale;
+  this->lookAt(
+    glm::vec3(position.x, position.y, position.z + z),
+    look,
+    glm::vec3(0, 1, 0)
+  );
+  return z;
+}
+
 SceneItemTransform::~SceneItemTransform() {
   std::for_each(
     this->children.begin(),
@@ -179,4 +224,6 @@ SceneItemTransform::~SceneItemTransform() {
       }
     }
   );
+  this->children.clear();
+  this->parent.reset();
 }

src/dawn/scene/item/SceneItemTransform.hpp

@@ -107,6 +107,13 @@ namespace Dawn {
        */
       glm::quat getLocalRotation();
       
+      /**
+       * Sets the parent of this item.
+       * 
+       * @param parent Parent of this item.
+       */
+      void setParent(std::shared_ptr<SceneItem> parent);
+
       /**
        * Sets the transform of this item within local space (relative to parent)
        * 
@@ -164,6 +171,24 @@ namespace Dawn {
         const glm::vec3 up
       );
 
+      /**
+       * Shorthand combined for lookAt and perspectivePixelPerfectDistance
+       * to allow you to create pixel perfect lookAt camera view matricies.
+       * 
+       * @param position Position of the camera. Z is for an offset.
+       * @param look Position in world space this transform looks at.
+       * @param viewportHeight Height of the viewport.
+       * @param fov Field of view (in radians).
+       * @return The Z distance that was calculated.
+       */
+      float_t lookAtPixelPerfect(
+        const glm::vec3 &position,
+        const glm::vec3 &look,
+        const float_t viewportHeight,
+        const float_t fov,
+        const float_t scale = 1.0f
+      );
+
       virtual ~SceneItemTransform();
   };
 }

src/dawn/ui/UIAlignableElement.cpp

@@ -200,25 +200,20 @@ void UIAlignableElement::updateSelfAlignment(
 }
 
 bool_t UIAlignableElement::hasExplicitWidth() {
-  if(size.x == 0.0f) return false;
-  if(
-    (alignX == UIAlignmentType::STRETCH) ||
-    (alignX == UIAlignmentType::END)
-  ) {
-    return align[0] != UI_ALIGN_SIZE_AUTO;
-  }
-  return align[2] != UI_ALIGN_SIZE_AUTO;
-}
-
-bool_t UIAlignableElement::hasExplicitHeight() {
-  if(size.y == 0.0f) return false;
-  if(
-    (alignY == UIAlignmentType::STRETCH) ||
-    (alignY == UIAlignmentType::END)
-  ) {
+  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) {
+    return align[0] != UI_ALIGN_SIZE_AUTO;
+  }
+  return align[2] != UI_ALIGN_SIZE_AUTO;
 }
 
 float_t UIAlignableElement::getWidth() {

src/dawn/ui/elements/CMakeLists.txt

@@ -5,5 +5,6 @@
 
 target_sources(${DAWN_TARGET_NAME}
   PRIVATE
+    UILabel.cpp
     UIRectangle.cpp
 )

src/dawn/ui/elements/UILabel.cpp

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

src/dawn/ui/elements/UILabel.hpp

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

src/dawn/util/CMakeLists.txt

@@ -5,5 +5,7 @@
 
 target_sources(${DAWN_TARGET_NAME}
   PRIVATE
+    Easing.cpp
     String.cpp
+    Random.cpp
 )

src/dawn/util/Easing.cpp

@@ -0,0 +1,99 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "Easing.hpp"
+
+using namespace Dawn;
+
+float_t Easing::linear(float_t t) {
+  return t;
+}
+
+float_t Easing::easeInQuad(float_t t) {
+  return t * t;
+}
+
+float_t Easing::easeOutQuad(float_t t) {
+  return t * (2 - t);
+}
+
+float_t Easing::easeInOutQuad(float_t t) {
+  return t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t;
+}
+
+float_t Easing::easeInCubic(float_t t) {
+  return t * t * t;
+}
+
+float_t Easing::easeOutCubic(float_t t) {
+  return (--t) * t * t + 1;
+}
+
+float_t Easing::easeInOutCubic(float_t t) {
+  return t < 0.5 ? 4 * t * t * t : (t - 1) * (2 * t - 2) * (2 * t - 2) + 1;
+}
+
+float_t Easing::easeInQuart(float_t t) {
+  return t * t * t * t;
+}
+
+float_t Easing::easeOutQuart(float_t t) {
+  return 1 - (--t) * t * t * t;
+}
+
+float_t Easing::easeInOutQuart(float_t t) {
+  return t < 0.5 ? 8 * t * t * t * t : 1 - 8 * (--t) * t * t * t;
+}
+
+float_t Easing::easeInQuint(float_t t) {
+  return t * t * t * t * t;
+}
+
+float_t Easing::easeOutQuint(float_t t) {
+  return 1 + (--t) * t * t * t * t;
+}
+
+float_t Easing::easeInOutQuint(float_t t) {
+  return t < 0.5 ? 16 * t * t * t * t * t : 1 + 16 * (--t) * t * t * t * t;
+}
+
+float_t Easing::easeInSine(float_t t) {
+  return 1 - cos(t * M_PI_2);
+}
+
+float_t Easing::easeOutSine(float_t t) {
+  return sin(t * M_PI_2);
+}
+
+float_t Easing::easeInOutSine(float_t t) {
+  return 0.5 * (1 - cos(M_PI * t));
+}
+
+float_t Easing::easeInExpo(float_t t) {
+  return t == 0 ? 0 : pow(2, 10 * (t - 1));
+}
+
+float_t Easing::easeOutExpo(float_t t) {
+  return t == 1 ? 1 : 1 - pow(2, -10 * t);
+}
+
+float_t Easing::easeInOutExpo(float_t t) {
+  if(t == 0) return 0;
+  if(t == 1) return 1;
+  if(t < 0.5) return 0.5 * pow(2, 20 * t - 10);
+  return 1 - 0.5 * pow(2, -20 * t + 10);
+}
+
+float_t Easing::easeInCirc(float_t t) {
+  return 1 - sqrt(1 - t * t);
+}
+
+float_t Easing::easeOutCirc(float_t t) {
+  return sqrt(1 - (--t) * t);
+}
+
+float_t Easing::easeInOutCirc(float_t t) {
+  return t < 0.5 ? 0.5 * (1 - sqrt(1 - 4 * t * t)) : 0.5 * (sqrt(-((2 * t) - 3) * ((2 * t) - 1)) + 1);
+}

src/dawn/util/Easing.hpp

@@ -0,0 +1,188 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "dawnlibs.hpp"
+
+namespace Dawn {
+  class Easing final {
+    public:
+      /**
+       * Linear easing function.
+       * 
+       * @param t Time value between 0 and 1.
+       * @return Eased value.
+       */
+      static float_t linear(float_t t);
+
+      /**
+       * Quadratic easing function.
+       * 
+       * @param t Time value between 0 and 1.
+       * @return Eased value.
+       */
+      static float_t easeInQuad(float_t t);
+
+      /**
+       * Quadratic easing function.
+       * 
+       * @param t Time value between 0 and 1.
+       * @return Eased value.
+       */
+      static float_t easeOutQuad(float_t t);
+
+      /**
+       * Quadratic easing function.
+       * 
+       * @param t Time value between 0 and 1.
+       * @return Eased value.
+       */
+      static float_t easeInOutQuad(float_t t);
+
+      /**
+       * Cubic easing function.
+       * 
+       * @param t Time value between 0 and 1.
+       * @return Eased value.
+       */
+      static float_t easeInCubic(float_t t);
+      
+      /**
+       * Cubic easing function.
+       * 
+       * @param t Time value between 0 and 1.
+       * @return Eased value.
+       */
+      static float_t easeOutCubic(float_t t);
+
+      /**
+       * Cubic easing function.
+       * 
+       * @param t Time value between 0 and 1.
+       * @return Eased value.
+       */
+      static float_t easeInOutCubic(float_t t);
+
+      /**
+       * Quartic easing function.
+       * 
+       * @param t Time value between 0 and 1.
+       * @return Eased value.
+       */
+      static float_t easeInQuart(float_t t);
+
+      /**
+       * Quartic easing function.
+       * 
+       * @param t Time value between 0 and 1.
+       * @return Eased value.
+       */
+      static float_t easeOutQuart(float_t t);
+
+      /**
+       * Quartic easing function.
+       * 
+       * @param t Time value between 0 and 1.
+       * @return Eased value.
+       */
+      static float_t easeInOutQuart(float_t t);
+
+      /**
+       * Quintic easing function.
+       * 
+       * @param t Time value between 0 and 1.
+       * @return Eased value.
+       */
+      static float_t easeInQuint(float_t t);
+
+      /**
+       * Quintic easing function.
+       * 
+       * @param t Time value between 0 and 1.
+       * @return Eased value.
+       */
+      static float_t easeOutQuint(float_t t);
+
+      /**
+       * Quintic easing function.
+       * 
+       * @param t Time value between 0 and 1.
+       * @return Eased value.
+       */
+      static float_t easeInOutQuint(float_t t);
+
+      /**
+       * Sine easing function.
+       * 
+       * @param t Time value between 0 and 1.
+       * @return Eased value.
+       */
+      static float_t easeInSine(float_t t);
+
+      /**
+       * Sine easing function.
+       * 
+       * @param t Time value between 0 and 1.
+       * @return Eased value.
+       */
+      static float_t easeOutSine(float_t t);
+
+      /**
+       * Sine easing function.
+       * 
+       * @param t Time value between 0 and 1.
+       * @return Eased value.
+       */
+      static float_t easeInOutSine(float_t t);
+
+      /**
+       * Exponential easing function.
+       * 
+       * @param t Time value between 0 and 1.
+       * @return Eased value.
+       */
+      static float_t easeInExpo(float_t t);
+
+      /**
+       * Exponential easing function.
+       * 
+       * @param t Time value between 0 and 1.
+       * @return Eased value.
+       */
+      static float_t easeOutExpo(float_t t);
+
+      /**
+       * Exponential easing function.
+       * 
+       * @param t Time value between 0 and 1.
+       * @return Eased value.
+       */
+      static float_t easeInOutExpo(float_t t);
+
+      /**
+       * Circular easing function.
+       * 
+       * @param t Time value between 0 and 1.
+       * @return Eased value.
+       */
+      static float_t easeInCirc(float_t t);
+
+      /**
+       * Circular easing function.
+       * 
+       * @param t Time value between 0 and 1.
+       * @return Eased value.
+       */
+      static float_t easeOutCirc(float_t t);
+
+      /**
+       * Circular easing function.
+       * 
+       * @param t Time value between 0 and 1.
+       * @return Eased value.
+       */
+      static float_t easeInOutCirc(float_t t);
+  };
+}

src/dawn/util/Random.cpp

@@ -0,0 +1,16 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "Random.hpp"
+
+using namespace Dawn;
+
+void Random::seed(const uint64_t seed) {
+  srand(seed);
+}
+
+uint64_t Random::next() {
+  return rand();
+}

src/dawn/util/Random.hpp

@@ -0,0 +1,59 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "dawnlibs.hpp"
+
+namespace Dawn {
+  class Random final {
+    public:
+      /**
+       * Seeds the random number generator with the provided seed.
+       * 
+       * @param seed Seed to use for the random number generator.
+       */
+      static void seed(const uint64_t seed);
+
+      /**
+       * Returns the next random number from the generator.
+       * 
+       * @return The next random number.
+       */
+      static uint64_t next();
+
+      /**
+       * Returns a random number between 0 and RAND_MAX.
+       * 
+       * @return Random number between 0 and RAND_MAX.
+       */
+      template<typename T>
+      static T random() {
+        return (T)next();
+      }
+
+      /**
+       * Returns a random number between the provided min and max values.
+       * 
+       * @param min Minimum value for the random number.
+       * @param max Maximum value for the random number.
+       * @return Random number between min and max.
+       */
+      static float_t random(float_t min, float_t max) {
+        return min + (float_t)next() / (float_t)RAND_MAX * (max - min);
+      }
+
+      /**
+       * Returns a random number between the provided min and max values.
+       * 
+       * @param min Minimum value for the random number.
+       * @param max Maximum value for the random number.
+       * @return Random number between min and max.
+       */
+      template<typename T>
+      static T random(T min, T max) {
+        return (T)(min + (next() % (max - min + 1)));
+      }
+  };
+}

src/dawnglfw/input/InputManager.cpp

@@ -17,6 +17,7 @@ void InputManager::init(const std::shared_ptr<Game> game) {
     double_t y
   ) {
     auto game = (Game*)glfwGetWindowUserPointer(window);
+    assertNotNull(game, "Game is not set on window user pointer.");
     game->inputManager.rawInputValues[INPUT_MANAGER_AXIS_MOUSE_X] = (float_t) x;
     game->inputManager.rawInputValues[INPUT_MANAGER_AXIS_MOUSE_Y] = (float_t) y;
   });
@@ -28,22 +29,55 @@ void InputManager::init(const std::shared_ptr<Game> game) {
     int32_t mods
   ) {
     auto game = (Game*)glfwGetWindowUserPointer(window);
-    game->inputManager.rawInputValues[INPUT_MANAGER_AXIS_MOUSE_0 + button] = (
-      action == GLFW_PRESS ? 1.0f : 0.0f
-    );
+    assertNotNull(game, "Game is not set on window user pointer.");
+    switch(action) {
+      case GLFW_PRESS:
+        game->inputManager.rawInputValues[INPUT_MANAGER_AXIS_MOUSE_0 + button] = 1.0f;
+        return;
+      case GLFW_RELEASE:
+        game->inputManager.rawInputValues[INPUT_MANAGER_AXIS_MOUSE_0 + button] = 0.0f;
+        return;
+      default:
+        return;
+    }
   });
 
-  glfwSetMouseButtonCallback(window, [](
+  glfwSetKeyCallback(window, [](
     GLFWwindow* window,
-    int32_t button,
+    int32_t key,
+    int32_t scancode,
     int32_t action,
     int32_t mods
   ) {
     auto game = (Game*)glfwGetWindowUserPointer(window);
-    game->inputManager.rawInputValues[button] = (
-      action == GLFW_PRESS ? 1.0f : 0.0f
-    );
+    assertNotNull(game, "Game is not set on window user pointer.");
+
+    switch(action) {
+      case GLFW_PRESS:
+        game->inputManager.rawInputValues[key] = 1.0f;
+        return;
+      case GLFW_RELEASE:
+        game->inputManager.rawInputValues[key] = 0.0f;
+        return;
+      default:
+        return;
+    }
   });
+
+  // Set default values
+  this->bind(InputBind::Up, GLFW_KEY_W);
+  this->bind(InputBind::Up, GLFW_KEY_UP);
+  this->bind(InputBind::Down, GLFW_KEY_S);
+  this->bind(InputBind::Down, GLFW_KEY_DOWN);
+  this->bind(InputBind::Left, GLFW_KEY_A);
+  this->bind(InputBind::Left, GLFW_KEY_LEFT);
+  this->bind(InputBind::Right, GLFW_KEY_D);
+  this->bind(InputBind::Right, GLFW_KEY_RIGHT);
+  this->bind(InputBind::Run, GLFW_KEY_LEFT_SHIFT);
+  this->bind(InputBind::Run, GLFW_KEY_RIGHT_SHIFT);
+  this->bind(InputBind::Action, GLFW_KEY_SPACE);
+  this->bind(InputBind::Action, GLFW_KEY_ENTER);
+  this->bind(InputBind::Action, GLFW_KEY_E);
 }
 
 float_t InputManager::getInputValue(int32_t axis) {

src/dawnrpg/CMakeLists.txt

@@ -9,9 +9,16 @@ target_include_directories(${DAWN_TARGET_NAME}
     ${CMAKE_CURRENT_LIST_DIR}
 )
 
+# Sources
+target_sources(${DAWN_TARGET_NAME}
+  PRIVATE
+    dawnrpg.cpp
+)
+
 # Subdirs
-add_subdirectory(game)
-add_subdirectory(scene)
+add_subdirectory(component)
+add_subdirectory(prefab)
+add_subdirectory(scenes)
 
 # Assets
-# include("${DAWN_ASSETS_SOURCE_DIR}/games/helloworld/CMakeLists.txt")
+include("${DAWN_ASSETS_SOURCE_DIR}/dawnrpg/CMakeLists.txt")

src/dawnrpg/component/CMakeLists.txt

@@ -0,0 +1,7 @@
+# Copyright (c) 2024 Dominic Masters
+# 
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+add_subdirectory(entity)
+add_subdirectory(world)

src/dawnrpg/component/entity/CMakeLists.txt

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

src/dawnrpg/component/entity/Entity.cpp

@@ -0,0 +1,133 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "Entity.hpp"
+#include "scene/Scene.hpp"
+#include "assert/assert.hpp"
+#include "util/Easing.hpp"
+#include "component/world/World.hpp"
+#include "component/world/Map.hpp"
+
+using namespace Dawn;
+
+void Entity::onInit() {
+  assertNotNull(this->getMap(), "Entity map cannot be null.");
+
+  // Listen for turn time
+  listeners.push_back(getScene()->onUnpausedUpdate.listen([this](float_t delta){
+    if(this->turnTime <= 0.0f) return;
+    this->turnTime -= delta;
+    if(this->turnTime <= 0) this->turnTime = 0.0f;
+  }));
+
+  // Listen for movement
+  listeners.push_back(getScene()->onUnpausedUpdate.listen([this](float_t delta){
+    if(this->stepTime <= 0.0f) return;
+    this->stepTime -= delta * this->stepSpeed;
+
+    glm::vec3 nextPosition = this->tilePosition.toWorldSpace();
+    
+    if(this->stepTime <= 0) {
+      this->getItem()->setLocalPosition(nextPosition);
+      this->stepTime = 0.0f;
+      this->eventMove.emit();
+      this->eventStepEnd.emit();
+      return;
+    }
+
+    float_t t = 1.0f - this->stepTime;
+    glm::vec3 lastPosition = this->lastTilePosition.toWorldSpace();
+    glm::vec3 newLocal = glm::mix(lastPosition, nextPosition, t);
+    this->getItem()->setLocalPosition(newLocal);
+    this->eventMove.emit();
+  }));
+
+  // Notify map.
+  getMap()->entityNotifyInit(this->getItem());
+}
+
+void Entity::onDispose() {
+  auto map = this->map.lock();
+  if(map) map->entityNotifyDispose(this->getItem());
+}
+
+std::shared_ptr<Map> Entity::getMap() {
+  auto map = this->map.lock();
+  assertNotNull(map, "Map cannot be null?");
+  return map;
+}
+
+std::shared_ptr<World> Entity::getWorld() {
+  return this->getMap()->getWorld();
+}
+
+struct EntityStepResult Entity::move(
+  const enum EntityDirection direction,
+  const float_t stepSpeed
+) {
+  assertFalse(this->isMoving(), "Entity is already moving.");
+  struct EntityStepResult result;
+
+  if(this->direction != direction) {
+    this->turn(direction);
+    result.type = EntityStepResultType::Turn;
+    return result;
+  }
+
+  auto map = this->getMap();
+  struct EntityTilePosition newPosition = (
+    entityDirectionGetRelativeTilePosition(
+      this->tilePosition,
+      direction
+    )
+  );
+
+  // Check for entity in way.
+  auto entityInWay = map->getEntityAt(newPosition);
+  if(entityInWay) {
+    result.type = EntityStepResultType::EntityInWay;
+    result.entityInWay = entityInWay;
+    return result;
+  }
+
+  // Get the tile at the destination, check for height if we are on stairs, etc.
+  // If the tile is not walkable, return early.
+  auto chunk = map->getChunkAtTile(newPosition);
+  auto tilePos = newPosition.toTilePosition();
+  auto tileAt = chunk->getTileAt(tilePos);
+  if(tileAt.isSolid()) {
+    result.type = EntityStepResultType::SolidTileInWay;
+    result.tileInWayChunk = chunk;
+    result.tileInWayPosition = tilePos;
+    return result;
+  }
+
+  // Move the entity to the new tile.
+  this->lastTilePosition = this->tilePosition;
+  this->tilePosition = newPosition;
+  this->stepTime = 1.0f;
+  this->stepSpeed = stepSpeed;
+
+  this->eventStepStart.emit();
+  return result;
+}
+
+void Entity::turn(const enum EntityDirection direction) {
+  this->direction = direction;
+  this->turnTime = ENTITY_TURN_TIME;
+  this->eventTurn.emit();
+}
+
+void Entity::setPosition(struct EntityTilePosition pos) {
+  this->stepTime = 0.0f;
+  this->tilePosition = pos;
+  this->lastTilePosition = pos;
+  this->getItem()->setLocalPosition(pos.toWorldSpace());
+  this->eventMove.emit();
+}
+
+bool_t Entity::isMoving() {
+  return this->stepTime > 0.0f || this->turnTime > 0.0f;
+}

src/dawnrpg/component/entity/Entity.hpp

@@ -0,0 +1,110 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "component/world/Map.hpp"
+#include "event/Event.hpp"
+#include "EntityDirection.hpp"
+
+#define ENTITY_STEP_SPEED_DEFAULT 3.0f
+#define ENTITY_STEP_SPEED_RUNNING 6.0f
+#define ENTITY_TURN_TIME 0.06f
+
+namespace Dawn {
+  class Entity;
+
+  enum class EntityStepResultType : uint8_t {
+    Turn,
+    Step,
+    EntityInWay,
+    SolidTileInWay
+  };
+
+  struct EntityStepResult {
+    enum EntityStepResultType type;
+
+    // I'd love to unionize this but it seems that it's not ideal rn.
+    std::shared_ptr<Entity> entityInWay;
+
+    std::shared_ptr<Chunk> tileInWayChunk;
+    struct TilePosition tileInWayPosition;
+  };
+
+  class Entity : public SceneComponent {
+    private:
+      float_t turnTime = 0.0f;
+
+      struct EntityTilePosition lastTilePosition;
+      float_t stepTime = 0.0f;
+      float_t stepSpeed = ENTITY_STEP_SPEED_DEFAULT;
+
+    protected:
+      enum EntityDirection direction = EntityDirection::Down;
+      struct EntityTilePosition tilePosition;
+
+    public:
+      std::weak_ptr<Map> map;
+      enum EntityID id = EntityID::Null;
+      
+      Event<> eventStepStart;
+      Event<> eventStepEnd;
+      Event<> eventMove;
+      Event<> eventTurn;
+      
+      void onInit() override;
+      void onDispose() override;
+
+      /**
+       * Gets the map that the entity is on.
+       * 
+       * @return The map that the entity is on.
+       */
+      std::shared_ptr<Map> getMap();
+
+      /**
+       * Gets the world that the entity is on.
+       * 
+       * @return The world that the entity is on.
+       */
+      std::shared_ptr<World> getWorld();
+
+      /**
+       * Moves the entity in the given direction.
+       * 
+       * @param direction The direction to move in.
+       * @param stepSpeed The speed to move at.
+       */
+      struct EntityStepResult move(
+        const enum EntityDirection direction,
+        const float_t stepSpeed = ENTITY_STEP_SPEED_DEFAULT
+      );
+
+      /**
+       * Turns the entity in the given direction. This will have a slight delay
+       * and count as moving.
+       * 
+       * @param direction The direction to turn in.
+       */
+      void turn(const enum EntityDirection direction);
+
+      /**
+       * Safely sets the position of the entity. This will invoke movement
+       * events but not step events, so steps may be cancelled in this context.
+       * 
+       * @param position The new position of the entity.
+       */
+      void setPosition(struct EntityTilePosition position);
+
+      /**
+       * Checks if the entity is currently moving (in a step).
+       * 
+       * @return True if the entity is moving, false otherwise.
+       */
+      bool_t isMoving();
+
+      friend class World;
+      friend class Map;
+  };
+}

src/dawnrpg/component/entity/EntityDirection.cpp

@@ -0,0 +1,39 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "assert/assert.hpp"
+#include "EntityDirection.hpp"
+
+using namespace Dawn;
+
+glm::vec3 entityDirectionGetVector(const EntityDirection &dir) {
+  switch(dir) {
+    case EntityDirection::Up: return glm::vec3(0.0f, 1.0f, 0.0f);
+    case EntityDirection::Down: return glm::vec3(0.0f, -1.0f, 0.0f);
+    case EntityDirection::Left: return glm::vec3(-1.0f, 0.0f, 0.0f);
+    case EntityDirection::Right: return glm::vec3(1.0f, 0.0f, 0.0f);
+    default:
+      assertUnreachable("Invalid direction: %d", dir);
+      return glm::vec3(0.0f, 0.0f, 0.0f);
+  }
+}
+
+struct EntityTilePosition entityDirectionGetRelativeTilePosition(
+  const EntityTilePosition &pos,
+  const EntityDirection &dir,
+  int32_t distance
+) {
+  struct EntityTilePosition result = pos;
+  switch(dir) {
+    case EntityDirection::Down: result.y -= distance; break;
+    case EntityDirection::Up: result.y += distance; break;
+    case EntityDirection::Left: result.x -= distance; break;
+    case EntityDirection::Right: result.x += distance; break;
+    default:
+      assertUnreachable("Invalid direction: %d", dir);
+      break;
+  }
+  return result;
+}

src/dawnrpg/component/entity/EntityDirection.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 "dawnlibs.hpp"
+#include "EntityTilePosition.hpp"
+
+enum class EntityDirection : uint8_t {
+  Up,
+  Down,
+  Left,
+  Right,
+};
+
+/**
+ * Gets the vector for the given direction.
+ * 
+ * @param dir The direction to get the vector for.
+ * @return The vector for the given direction.
+ */
+glm::vec3 entityDirectionGetVector(const EntityDirection &dir);
+
+/**
+ * Gets the relative tile position for the given direction.
+ * 
+ * @param pos The current position.
+ * @param dir The direction to get the relative position for.
+ * @param distance The distance to get the relative position for.
+ * @return The relative tile position for the given direction.
+ */
+struct Dawn::EntityTilePosition entityDirectionGetRelativeTilePosition(
+  const Dawn::EntityTilePosition &pos,
+  const EntityDirection &dir,
+  int32_t distance = 1
+);

src/dawnrpg/component/entity/EntityID.hpp

@@ -0,0 +1,15 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "dawnlibs.hpp"
+
+namespace Dawn {
+  enum class EntityID : uint32_t {
+    Null = 0,
+    Player = 1,
+    TestEntity = 2
+  };
+}