Add BigFile class

Reviewed-on: #2
Co-authored-by: Romain BOULLARD <romain.boullard@protonmail.com>
Co-committed-by: Romain BOULLARD <romain.boullard@protonmail.com>

.devcontainer/devcontainer.json

@@ -0,0 +1,4 @@
+{
+	"name": "Bigfoot",
+	"image": "git.romainboullard.com/bigfootdev/linuxbigfootbuilder:main"
+}

.gitea/workflows/ci.yml

@@ -0,0 +1,65 @@
+name: Bigfoot
+
+on:
+  push:
+    branches:
+      - '**'
+  workflow_dispatch:
+
+env:
+  CCACHE_BASEDIR: ${{ github.workspace }}
+
+jobs:
+  build-and-test:
+    runs-on: ubuntu-latest
+    timeout-minutes: 120
+    container:
+      image: git.romainboullard.com/bigfootdev/linuxbigfootbuilder:main
+    strategy:
+      matrix:
+        build_type: ["Debug", "RelWithDebInfo", "Release"]
+        unity_build: ["ON", "OFF"]
+    name: "Build & Test ${{ matrix.build_type }} (Unity Build: ${{ matrix.unity_build }})"
+    steps:
+      - name: Install Node.js
+        run: apt-get update && apt-get install -y nodejs
+
+      - name: Checkout repository
+        uses: actions/checkout@v6
+        with:
+          submodules: recursive
+
+      - name: Show ccache stats before
+        run: ccache --zero-stats
+
+      - name: Build
+        run: |
+            conan install . --deployer=full_deploy --deployer-folder=build --remote=bigfootpackages -pr:h=clang -pr:b=clang  --build=missing -s build_type=${{ matrix.build_type }} -o bigfoot/*:build_tests=True -o bigfoot/*:tracy=False -o bigfoot/*:build_tools=True -o bigfoot/*:vulkan=True -o bigfoot/*:build_benchmarks=True
+            cmake -S . -B ./build/${{ matrix.build_type }} --toolchain ./build/${{ matrix.build_type }}/generators/conan_toolchain.cmake -DCMAKE_BUILD_TYPE=${{ matrix.build_type }} -DCMAKE_UNITY_BUILD=${{ matrix.unity_build }} -G "Ninja"
+            cmake --build build/${{ matrix.build_type }} --parallel $(nproc)
+
+      - name: Show ccache stats after
+        run: ccache --show-stats
+
+      - name: Unit Tests
+        run: |
+            cd ./build/${{ matrix.build_type }}
+            xvfb-run ctest . --output-on-failure
+
+  clang-format:
+    runs-on: ubuntu-latest
+    timeout-minutes: 120
+    container:
+      image: git.romainboullard.com/bigfootdev/linuxbigfootbuilder:main
+    name: "Clang Format Checks"
+    steps:
+      - name: Install Node.js
+        run: apt-get update && apt-get install -y nodejs
+
+      - name: Checkout repository
+        uses: actions/checkout@v6
+        with:
+          submodules: recursive
+          
+      - name: Clang Format Checks
+        run: chmod +x format.sh && ./format.sh --check Bigfoot

.gitlab-ci.yml

@@ -1,79 +0,0 @@
-include: '/CI/templates.yml'
-
-variables:
-  SONAR_USER_HOME: "${CI_PROJECT_DIR}/.sonar"
-  GIT_SUBMODULE_STRATEGY: recursive
-  GIT_DEPTH: "0"
-
-stages:
-  - build
-  - build-unity
-  - unit-tests
-  - sonar
-
-# ******************************************DEBUG******************************************
-
-BuildDebug:
-  extends: .Build
-  variables:
-    BUILD_TYPE: 'Debug'
-
-BuildUnityDebug:
-  extends: .BuildUnity
-  variables:
-    BUILD_TYPE: 'Debug'
-
-UnitTestsDebug:
-  extends: .UnitTests
-  variables:
-    BUILD_TYPE: 'Debug'
-  needs:
-    - BuildUnityDebug
-
-# ******************************************RELWITHDEBINFO******************************************
-
-BuildRelWithDebInfo:
-  extends: .Build
-  variables:
-    BUILD_TYPE: 'RelWithDebInfo'
-
-BuildUnityRelWithDebInfo:
-  extends: .BuildUnity
-  variables:
-    BUILD_TYPE: 'RelWithDebInfo'
-
-UnitTestsRelWithDebInfo:
-  extends: .UnitTests
-  variables:
-    BUILD_TYPE: 'RelWithDebInfo'
-  needs:
-    - BuildUnityRelWithDebInfo
-
-# ******************************************RELEASE******************************************
-
-BuildRelease:
-  extends: .Build
-  variables:
-    BUILD_TYPE: 'Release'
-
-BuildUnityRelease:
-  extends: .BuildUnity
-  variables:
-    BUILD_TYPE: 'Release'
-
-UnitTestsRelease:
-  extends: .UnitTests
-  variables:
-    BUILD_TYPE: 'Release'
-  needs:
-    - BuildUnityRelease
-
-# ******************************************Sonar******************************************
-
-SonarCloud:
-  extends: .SonarCloud
-  dependencies: []
-  only:
-    - merge_requests
-    - main
-    - Development

Bigfoot/Sources/CMakeLists.txt

@@ -1,3 +1,3 @@
-add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/System)
 add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/Utils)
+add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/System)
 add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/Engine)

Bigfoot/Sources/Engine/BigFile/BigFile.cpp

@@ -0,0 +1,275 @@
+/*********************************************************************
+ * \file   BigFile.cpp
+ *
+ * \author Romain BOULLARD
+ * \date   October 2025
+ *********************************************************************/
+#include <Engine/BigFile/BigFile.hpp>
+
+#include <Engine/EngineAssertHandler.hpp>
+
+namespace Bigfoot
+{
+BigFile::BigFile(const File& p_file)
+{
+    [[maybe_unused]]
+    const int result = sqlite3_open_v2(p_file.Absolute().Path().data(), &m_db, SQLITE_OPEN_READWRITE, nullptr);
+    CRITICAL_ASSERT(EngineAssertHandler, result == SQLITE_OK, "Failed to open BigFile DB: {}", sqlite3_errmsg(m_db));
+}
+
+/****************************************************************************************/
+
+void BigFile::BeginTransaction()
+{
+    [[maybe_unused]]
+    const int result = sqlite3_exec(m_db, "BEGIN TRANSACTION;", nullptr, nullptr, nullptr);
+    ASSERT(EngineAssertHandler, result == SQLITE_OK, "Failed to begin transaction: {}", sqlite3_errmsg(m_db));
+}
+
+/****************************************************************************************/
+
+void BigFile::CommitTransaction()
+{
+    [[maybe_unused]]
+    const int result = sqlite3_exec(m_db, "COMMIT TRANSACTION;", nullptr, nullptr, nullptr);
+    ASSERT(EngineAssertHandler, result == SQLITE_OK, "Failed to commit: {}", sqlite3_errmsg(m_db));
+}
+
+/****************************************************************************************/
+
+void BigFile::RollbackTransaction()
+{
+    [[maybe_unused]]
+    const int result = sqlite3_exec(m_db, "ROLLBACK TRANSACTION;", nullptr, nullptr, nullptr);
+    ASSERT(EngineAssertHandler, result == SQLITE_OK, "Failed to rollback: {}", sqlite3_errmsg(m_db));
+}
+
+/****************************************************************************************/
+
+BigFile::~BigFile()
+{
+    [[maybe_unused]]
+    const int result = sqlite3_close_v2(m_db);
+    CRITICAL_ASSERT(EngineAssertHandler, result == SQLITE_OK, "Failed to close BigFile DB: {}", sqlite3_errmsg(m_db));
+}
+
+/****************************************************************************************/
+
+BigFile::Request::Request(const BigFile& p_bigFile, const eastl::string_view p_request):
+    m_db(p_bigFile.m_db)
+{
+    [[maybe_unused]]
+    const int result = sqlite3_prepare_v2(m_db,
+                                          p_request.data(),
+                                          static_cast<std::uint32_t>(p_request.size()),
+                                          &m_statement,
+                                          nullptr);
+    CRITICAL_ASSERT(EngineAssertHandler,
+                    result == SQLITE_OK,
+                    "Failed to create statement from BigFile DB: {}",
+                    sqlite3_errmsg(m_db));
+}
+
+/****************************************************************************************/
+
+void BigFile::Request::Bind(const std::uint32_t p_index, const std::int32_t p_value)
+{
+    ASSERT(EngineAssertHandler,
+           (p_index >= 1) && (p_index <= static_cast<std::uint32_t>(sqlite3_bind_parameter_count(m_statement))),
+           "Invalid index for statement");
+
+    [[maybe_unused]]
+    const int result = sqlite3_bind_int(m_statement, p_index, p_value);
+    ASSERT(EngineAssertHandler, result == SQLITE_OK, "Failed to bind value for statement: {}", sqlite3_errmsg(m_db));
+}
+
+/****************************************************************************************/
+
+void BigFile::Request::Bind(const std::uint32_t p_index, const std::uint32_t p_value)
+{
+    ASSERT(EngineAssertHandler,
+           (p_index >= 1) && (p_index <= static_cast<std::uint32_t>(sqlite3_bind_parameter_count(m_statement))),
+           "Invalid index for statement");
+
+    [[maybe_unused]]
+    const int result = sqlite3_bind_int(m_statement, p_index, p_value);
+    ASSERT(EngineAssertHandler, result == SQLITE_OK, "Failed to bind value for statement: {}", sqlite3_errmsg(m_db));
+}
+
+/****************************************************************************************/
+
+void BigFile::Request::Bind(const std::uint32_t p_index, const std::int64_t p_value)
+{
+    ASSERT(EngineAssertHandler,
+           (p_index >= 1) && (p_index <= static_cast<std::uint32_t>(sqlite3_bind_parameter_count(m_statement))),
+           "Invalid index for statement");
+
+    [[maybe_unused]]
+    const int result = sqlite3_bind_int64(m_statement, p_index, p_value);
+    ASSERT(EngineAssertHandler, result == SQLITE_OK, "Failed to bind value for statement: {}", sqlite3_errmsg(m_db));
+}
+
+/****************************************************************************************/
+
+void BigFile::Request::Bind(const std::uint32_t p_index, const float p_value)
+{
+    ASSERT(EngineAssertHandler,
+           (p_index >= 1) && (p_index <= static_cast<std::uint32_t>(sqlite3_bind_parameter_count(m_statement))),
+           "Invalid index for statement");
+
+    [[maybe_unused]]
+    const int result = sqlite3_bind_double(m_statement, p_index, p_value);
+    ASSERT(EngineAssertHandler, result == SQLITE_OK, "Failed to bind value for statement: {}", sqlite3_errmsg(m_db));
+}
+
+/****************************************************************************************/
+
+void BigFile::Request::Bind(const std::uint32_t p_index, const double p_value)
+{
+    ASSERT(EngineAssertHandler,
+           (p_index >= 1) && (p_index <= static_cast<std::uint32_t>(sqlite3_bind_parameter_count(m_statement))),
+           "Invalid index for statement");
+
+    [[maybe_unused]]
+    const int result = sqlite3_bind_double(m_statement, p_index, p_value);
+    ASSERT(EngineAssertHandler, result == SQLITE_OK, "Failed to bind value for statement: {}", sqlite3_errmsg(m_db));
+}
+
+/****************************************************************************************/
+
+void BigFile::Request::Bind(const std::uint32_t p_index, const eastl::string_view p_value, const CopyValue p_copy)
+{
+    ASSERT(EngineAssertHandler,
+           (p_index >= 1) && (p_index <= static_cast<std::uint32_t>(sqlite3_bind_parameter_count(m_statement))),
+           "Invalid index for statement");
+
+    [[maybe_unused]]
+    const int result = sqlite3_bind_text(m_statement,
+                                         p_index,
+                                         p_value.data(),
+                                         static_cast<std::uint32_t>(p_value.size()),
+                                         p_copy ? SQLITE_TRANSIENT : SQLITE_STATIC);
+    ASSERT(EngineAssertHandler, result == SQLITE_OK, "Failed to bind value for statement: {}", sqlite3_errmsg(m_db));
+}
+
+/****************************************************************************************/
+
+void BigFile::Request::Bind(const std::uint32_t p_index,
+                            const eastl::span<const std::byte> p_value,
+                            const CopyValue p_copy)
+{
+    ASSERT(EngineAssertHandler,
+           (p_index >= 1) && (p_index <= static_cast<std::uint32_t>(sqlite3_bind_parameter_count(m_statement))),
+           "Invalid index for statement");
+
+    [[maybe_unused]]
+    const int result = sqlite3_bind_blob(m_statement,
+                                         p_index,
+                                         p_value.data(),
+                                         static_cast<std::uint32_t>(p_value.size()),
+                                         p_copy ? SQLITE_TRANSIENT : SQLITE_STATIC);
+    ASSERT(EngineAssertHandler, result == SQLITE_OK, "Failed to bind value for statement: {}", sqlite3_errmsg(m_db));
+}
+
+/****************************************************************************************/
+
+bool BigFile::Request::Step()
+{
+    const int result = sqlite3_step(m_statement);
+    ASSERT(EngineAssertHandler,
+           (result == SQLITE_DONE) || (result == SQLITE_ROW),
+           "Failed to step through the statement: {}",
+           sqlite3_errmsg(m_db));
+
+    return result == SQLITE_ROW;
+}
+
+/****************************************************************************************/
+
+std::uint32_t BigFile::Request::Execute()
+{
+    [[maybe_unused]]
+    const int result = sqlite3_step(m_statement);
+    ASSERT(EngineAssertHandler, (result == SQLITE_DONE), "Failed to execute the statement: {}", sqlite3_errmsg(m_db));
+
+    return sqlite3_changes(m_db);
+}
+
+/****************************************************************************************/
+
+BigFile::Request::Column::Column(const Request& p_request, const std::uint32_t p_index):
+    m_statement(p_request.m_statement),
+    m_index(p_index)
+{
+}
+
+/****************************************************************************************/
+
+BigFile::Request::Column::operator std::int32_t() const
+{
+    return sqlite3_column_int(m_statement, m_index);
+}
+
+/****************************************************************************************/
+
+BigFile::Request::Column::operator std::uint32_t() const
+{
+    return sqlite3_column_int(m_statement, m_index);
+}
+
+/****************************************************************************************/
+
+BigFile::Request::Column::operator std::int64_t() const
+{
+    return sqlite3_column_int64(m_statement, m_index);
+}
+
+/****************************************************************************************/
+
+BigFile::Request::Column::operator float() const
+{
+    return static_cast<float>(sqlite3_column_double(m_statement, m_index));
+}
+
+/****************************************************************************************/
+
+BigFile::Request::Column::operator double() const
+{
+    return sqlite3_column_double(m_statement, m_index);
+}
+
+/****************************************************************************************/
+
+BigFile::Request::Column::operator eastl::string_view() const
+{
+    return eastl::string_view {reinterpret_cast<const char*>(sqlite3_column_text(m_statement, m_index)),
+                               static_cast<std::size_t>(sqlite3_column_bytes(m_statement, m_index))};
+}
+
+/****************************************************************************************/
+
+BigFile::Request::Column::operator eastl::span<const std::byte>() const
+{
+    return eastl::span<const std::byte> {static_cast<const std::byte*>(sqlite3_column_blob(m_statement, m_index)),
+                                         static_cast<std::size_t>(sqlite3_column_bytes(m_statement, m_index))};
+}
+
+/****************************************************************************************/
+
+BigFile::Request::Column BigFile::Request::Get(const std::uint32_t p_index) const
+{
+    ASSERT(EngineAssertHandler,
+           p_index < static_cast<std::uint32_t>(sqlite3_column_count(m_statement)),
+           "Invalid index for column!");
+    return {*this, p_index};
+}
+
+/****************************************************************************************/
+
+BigFile::Request::~Request()
+{
+    [[maybe_unused]]
+    const int result = sqlite3_finalize(m_statement);
+    CRITICAL_ASSERT(EngineAssertHandler, result == SQLITE_OK, "Failed to finalize statement: {}", sqlite3_errmsg(m_db));
+}
+}   // namespace Bigfoot

Bigfoot/Sources/Engine/BigFile/BigFileSchema.sql

@@ -1,11 +1,41 @@
 PRAGMA journal_mode=WAL;
+PRAGMA foreign_keys = ON;
 
-DROP TABLE IF EXISTS FsEntry;
+DROP TABLE IF EXISTS AssetHeader;
-CREATE TABLE IF NOT EXISTS FsEntry (
+CREATE TABLE IF NOT EXISTS AssetHeader (
     UUID              	BLOB        NOT NULL UNIQUE,
     Name            	TEXT        NOT NULL UNIQUE,
-    CreateTime      	INTEGER NOT NULL,
+    TypeID              INTEGER     NOT NULL,
-    ModificationTime    INTEGER NOT NULL,
+    TypeName            TEXT        NOT NULL,
-    Asset               BLOB,
+
+    CreateTime      	INTEGER     NOT NULL DEFAULT(CAST(unixepoch('subsec') AS INTEGER) * 1000000),
+    ModificationTime    INTEGER     NOT NULL DEFAULT(CAST(unixepoch('subsec') AS INTEGER) * 1000000),
+
     PRIMARY KEY(UUID)
 );
+
+CREATE TRIGGER IF NOT EXISTS AssetHeader_UpdateTime
+AFTER UPDATE OF Name, TypeID, TypeName ON AssetHeader FOR EACH ROW
+BEGIN
+    UPDATE AssetHeader
+    SET ModificationTime = CAST(unixepoch('subsec') AS INTEGER) * 1000000
+    WHERE UUID = NEW.UUID;
+END;
+
+DROP TABLE IF EXISTS Asset;
+CREATE TABLE IF NOT EXISTS Asset (
+    UUID              	BLOB        NOT NULL UNIQUE,
+
+    Asset               BLOB        NOT NULL,
+
+    PRIMARY KEY(UUID),
+    FOREIGN KEY(UUID) REFERENCES AssetHeader(UUID) ON DELETE CASCADE
+);
+
+CREATE TRIGGER IF NOT EXISTS Asset_UpdateTime
+AFTER UPDATE OF Asset ON Asset FOR EACH ROW
+BEGIN
+    UPDATE AssetHeader
+    SET ModificationTime = CAST(unixepoch('subsec') AS INTEGER) * 1000000
+    WHERE UUID = NEW.UUID;
+END;

Bigfoot/Sources/Engine/BigFile/Database.cpp

@@ -1,12 +0,0 @@
-/*********************************************************************
- * \file   Database.cpp
- *
- * \author Romain BOULLARD
- * \date   October 2025
- *********************************************************************/
-#include <Engine/BigFile/Database.hpp>
-
-namespace Bigfoot
-{
-
-}   // namespace Bigfoot

Bigfoot/Sources/Engine/CMakeLists.txt

@@ -1,9 +1,11 @@
 get_filename_component(PackageName ${CMAKE_CURRENT_SOURCE_DIR} NAME)
+project(${PackageName})
 
 set(PublicDependencies
         SQLite::SQLite3)
 set(PrivateDependencies)
 set(BigfootPublicDependencies
+        System
         Utils)
 set(BigfootPrivateDependencies)
 
@@ -11,12 +13,11 @@ set(BIGFOOT_MAJOR 0)
 set(BIGFOOT_MINOR 1)
 set(BIGFOOT_PATCH 0)
 set(BIGFOOT_NAME "Bigfoot")
-configure_file(${CMAKE_CURRENT_SOURCE_DIR}/Include/Engine/EngineInfo.generated.hpp.in ${CMAKE_CURRENT_SOURCE_DIR}/Include/Engine/EngineInfo.generated.hpp @ONLY)
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/Include/Engine/EngineInfo_generated.hpp.in ${CMAKE_CURRENT_SOURCE_DIR}/Include/Engine/EngineInfo_generated.hpp @ONLY)
 
-bigfoot_create_logger(${PackageName})
+bigfoot_create_logger()
 
 bigfoot_create_package_lib(
-    ${PackageName}
     "${PublicDependencies}"
     "${PrivateDependencies}"
     "${BigfootPublicDependencies}"

Bigfoot/Sources/Engine/Include/Engine/BigFile/BigFile.hpp

@@ -0,0 +1,262 @@
+/*********************************************************************
+ * \file   BigFile.hpp
+ *
+ * \author Romain BOULLARD
+ * \date   October 2025
+ *********************************************************************/
+#ifndef BIGFOOT_ENGINE_BIGFILE_HPP
+#define BIGFOOT_ENGINE_BIGFILE_HPP
+#include <System/File.hpp>
+
+#include <Utils/TaggedType.hpp>
+
+#include <EASTL/span.h>
+
+#include <sqlite3.h>
+
+namespace Bigfoot
+{
+class BigFile
+{
+  public:
+    /**
+     * Constructor
+     *
+     * \param p_file The file targetting the BigFile DB
+     */
+    BigFile(const File& p_file);
+
+    BigFile(const BigFile& p_bigFile) = default;
+    BigFile(BigFile&& p_bigFile) = default;
+
+    /**
+     * Begin a transaction
+     *
+     */
+    void BeginTransaction();
+
+    /**
+     * Commit a transaction
+     *
+     */
+    void CommitTransaction();
+
+    /**
+     * Rollback a transaction
+     *
+     */
+    void RollbackTransaction();
+
+    ~BigFile();
+
+    BigFile& operator=(const BigFile& p_bigFile) = default;
+    BigFile& operator=(BigFile&& p_bigFile) = default;
+
+    class Request
+    {
+      public:
+        /*
+         * Constructor
+         *
+         * \param p_bigFile The bigfile
+         * \param p_request The SQL request
+         */
+        Request(const BigFile& p_bigFile, const eastl::string_view p_request);
+
+        Request(const Request& p_request) = default;
+        Request(Request&& p_request) = default;
+
+        using CopyValue = TaggedType<bool>;
+
+        /*
+         * Bind a int32 value to the Request at index
+         *
+         * \param p_index The index to bind to
+         * \param p_value The value
+         */
+        void Bind(const std::uint32_t p_index, const std::int32_t p_value);
+
+        /*
+         * Bind a uint32 value to the Request at index
+         *
+         * \param p_index The index to bind to
+         * \param p_value The value
+         */
+        void Bind(const std::uint32_t p_index, const std::uint32_t p_value);
+
+        /*
+         * Bind a int64 value to the Request at index
+         *
+         * \param p_index The index to bind to
+         * \param p_value The value
+         */
+        void Bind(const std::uint32_t p_index, const std::int64_t p_value);
+
+        /*
+         * Bind a float value to the Request at index
+         *
+         * \param p_index The index to bind to
+         * \param p_value The value
+         */
+        void Bind(const std::uint32_t p_index, const float p_value);
+
+        /*
+         * Bind a double value to the Request at index
+         *
+         * \param p_index The index to bind to
+         * \param p_value The value
+         */
+        void Bind(const std::uint32_t p_index, const double p_value);
+
+        /*
+         * Bind a string value to the Request at index
+         *
+         * \param p_index The index to bind to
+         * \param p_value The value
+         * \param p_copy Should the memory be copied so that caller does not have to retain it
+         */
+        void Bind(const std::uint32_t p_index,
+                  const eastl::string_view p_value,
+                  const CopyValue p_copy = CopyValue {false});
+
+        /*
+         * Bind a blob value to the Request at index
+         *
+         * \param p_index The index to bind to
+         * \param p_value The value
+         * \param p_copy Should the memory be copied so that caller does not have to retain it
+         */
+        void Bind(const std::uint32_t p_index,
+                  const eastl::span<const std::byte> p_value,
+                  const CopyValue p_copy = CopyValue {false});
+
+        /*
+         * Step through the request
+         *
+         * \return True if the request can continue (get next row), false otherwise
+         */
+        [[nodiscard]]
+        bool Step();
+
+        /*
+         * Execute the request once
+         *
+         * The number of modified rows
+         */
+        [[maybe_unused]]
+        std::uint32_t Execute();
+
+        class Column
+        {
+          public:
+            /*
+             * Constructor
+             *
+             * \param p_request The request to get the column of
+             * \param p_index Column index
+             */
+            Column(const Request& p_request, const std::uint32_t p_index);
+
+            Column(const Column& p_column) = default;
+            Column(Column&& p_column) = default;
+
+            ~Column() = default;
+
+            Column& operator=(const Column& p_column) = default;
+            Column& operator=(Column&& p_column) = default;
+
+            /*
+             * Get value as a int32
+             *
+             * \return The value
+             */
+            operator std::int32_t() const;
+
+            /*
+             * Get value as a uint32
+             *
+             * \return The value
+             */
+            operator std::uint32_t() const;
+
+            /*
+             * Get value as a int64
+             *
+             * \return The value
+             */
+            operator std::int64_t() const;
+
+            /*
+             * Get value as a float
+             *
+             * \return The value
+             */
+            operator float() const;
+
+            /*
+             * Get value as a double
+             *
+             * \return The value
+             */
+            operator double() const;
+
+            /*
+             * Get value as a string
+             *
+             * \return The value
+             */
+            operator eastl::string_view() const;
+
+            /*
+             * Get value as a blob
+             *
+             * \return The value
+             */
+            operator eastl::span<const std::byte>() const;
+
+          private:
+            /*
+             * The statement
+             */
+            sqlite3_stmt* m_statement;
+
+            /*
+             * The column index
+             */
+            std::uint32_t m_index;
+        };
+
+        /*
+         * Get a column
+         *
+         * \param p_index Column index
+         */
+        [[nodiscard]]
+        Column Get(const std::uint32_t p_index) const;
+
+        ~Request();
+
+        Request& operator=(const Request& p_request) = default;
+        Request& operator=(Request&& p_request) = default;
+
+      private:
+        /*
+         * The database
+         */
+        sqlite3* m_db;
+
+        /*
+         * The statement
+         */
+        sqlite3_stmt* m_statement;
+    };
+
+  private:
+    /**
+     * The BigFile DB
+     */
+    sqlite3* m_db;
+};
+}   // namespace Bigfoot
+
+#endif

Bigfoot/Sources/Engine/Include/Engine/BigFile/BigFileInfo_generated.hpp.in

@@ -4,16 +4,16 @@
  * \file   BigFileInfo.generated.hpp
  *
  *********************************************************************/
-#ifndef BIGFOOT_ENGINE_BIGFILE_BIGFILEINFO_GENERATED_HPP
+#ifndef BIGFOOT_@BIGFILE_NAME@_BIGFILEINFO_GENERATED_HPP
-#define BIGFOOT_ENGINE_BIGFILE_BIGFILEINFO_GENERATED_HPP
+#define BIGFOOT_@BIGFILE_NAME@_BIGFILEINFO_GENERATED_HPP
 
-#include <string_view>
+#include <EASTL/string_view.h>
 
 namespace Bigfoot
 {
 /*
  * BigFile location
  */
-constexpr std::string_view BIGFILE_@BIGFILE_NAME@_LOCATION{"@BIGFILE_LOCATION@"};
+constexpr eastl::string_view BIGFILE_@BIGFILE_NAME@_LOCATION {"@BIGFILE_LOCATION@"};
-}
+}  // namespace Bigfoot
 #endif

Bigfoot/Sources/Engine/Include/Engine/BigFile/Database.hpp

@@ -1,19 +0,0 @@
-/*********************************************************************
- * \file   Database.hpp
- *
- * \author Romain BOULLARD
- * \date   October 2025
- *********************************************************************/
-#ifndef BIGFOOT_ENGINE_BIGFILE_DATABASE_HPP
-#define BIGFOOT_ENGINE_BIGFILE_DATABASE_HPP
-
-#include <sqlite3.h>
-
-#include <string_view>
-
-namespace Bigfoot
-{
-
-}   // namespace Bigfoot
-
-#endif

Bigfoot/Sources/Engine/Include/Engine/EngineAssertHandler.hpp

@@ -0,0 +1,60 @@
+/*********************************************************************
+ * \file   EngineAssertHandler.hpp
+ *
+ * \author Romain BOULLARD
+ * \date   December 2025
+ *********************************************************************/
+#ifndef BIGFOOT_ENGINE_ENGINEASSERTHANDLER_HPP
+#define BIGFOOT_ENGINE_ENGINEASSERTHANDLER_HPP
+#include <Utils/Assert.hpp>
+
+#include <Engine/EngineLogger_generated.hpp>
+
+#if defined BIGFOOT_NOT_OPTIMIZED
+#include <EASTL/utility.h>
+
+#include <format>
+#include <source_location>
+#include <string_view>
+
+namespace Bigfoot
+{
+class EngineAssertHandler
+{
+  public:
+    EngineAssertHandler() = delete;
+
+    EngineAssertHandler(const EngineAssertHandler& p_handler) = delete;
+    EngineAssertHandler(EngineAssertHandler&& p_handler) = delete;
+
+    ~EngineAssertHandler() = delete;
+
+    /**
+     * Handle an assertion.
+     *
+     * \param p_location Location of the assertion.
+     * \param p_stacktrace The stack trace
+     * \param p_format Format string for the assertion message.
+     * \param p_args Arguments for the format string.
+     */
+    template<typename... ARGS>
+    static void Handle(const std::source_location& p_location,
+                       const std::string_view p_stacktrace,
+                       std::format_string<ARGS...> p_format,
+                       ARGS&&... p_args)
+    {
+        BIGFOOT_LOG_FATAL(ENGINE_LOGGER,
+                          "Assert: {} (File:{}, Line:{}, Function:{}\n{}",
+                          std::format(p_format, eastl::forward<ARGS>(p_args)...),
+                          p_location.file_name(),
+                          p_location.line(),
+                          p_location.function_name(),
+                          p_stacktrace);
+    }
+
+    EngineAssertHandler& operator=(const EngineAssertHandler& p_handler) = delete;
+    EngineAssertHandler& operator=(EngineAssertHandler&& p_handler) = delete;
+};
+}   // namespace Bigfoot
+#endif
+#endif

Bigfoot/Sources/Engine/Include/Engine/EngineInfo_generated.hpp

@@ -1,13 +1,15 @@
 // AUTO-GENERATED DO NOT TOUCH
 
 /*********************************************************************
- * \file   EngineInfo.generated.hpp
+ * \file   EngineInfo_generated.hpp
  *
  *********************************************************************/
 #ifndef BIGFOOT_ENGINE_ENGINEINFO_GENERATED_HPP
 #define BIGFOOT_ENGINE_ENGINEINFO_GENERATED_HPP
 #include <Utils/Version.hpp>
 
+#include <EASTL/string_view.h>
+
 namespace Bigfoot
 {
 /*
@@ -18,6 +20,6 @@ constexpr Version BIGFOOT_VERSION{0, 1, 0};
 /*
  * Engine name
  */
-constexpr std::string_view BIGFOOT_NAME{"Bigfoot"};
+constexpr eastl::string_view BIGFOOT_NAME {"Bigfoot"};
-}
+}  // namespace Bigfoot
 #endif

Bigfoot/Sources/Engine/Include/Engine/EngineInfo_generated.hpp.in

@@ -1,13 +1,15 @@
 @AUTO_GENERATED_COMMENT@
 
 /*********************************************************************
- * \file   EngineInfo.generated.hpp
+ * \file   EngineInfo_generated.hpp
  *
  *********************************************************************/
 #ifndef BIGFOOT_ENGINE_ENGINEINFO_GENERATED_HPP
 #define BIGFOOT_ENGINE_ENGINEINFO_GENERATED_HPP
 #include <Utils/Version.hpp>
 
+#include <EASTL/string_view.h>
+
 namespace Bigfoot
 {
 /*
@@ -18,6 +20,6 @@ constexpr Version BIGFOOT_VERSION{@BIGFOOT_MAJOR@, @BIGFOOT_MINOR@, @BIGFOOT_PAT
 /*
  * Engine name
  */
-constexpr std::string_view BIGFOOT_NAME{"@BIGFOOT_NAME@"};
+constexpr eastl::string_view BIGFOOT_NAME {"@BIGFOOT_NAME@"};
-}
+}  // namespace Bigfoot
 #endif

Bigfoot/Sources/Engine/Include/Engine/EngineLogger_generated.hpp

@@ -6,7 +6,7 @@
  *********************************************************************/
 #ifndef BIGFOOT_ENGINELOGGER_GENERATED_HPP
 #define BIGFOOT_ENGINELOGGER_GENERATED_HPP
-#include <Utils/Log.hpp>
+#include <System/Log/Log.hpp>
 
 #if defined BIGFOOT_NOT_OPTIMIZED
 
@@ -15,7 +15,7 @@ namespace Bigfoot
 /*
  * Logger
  */
-inline Log::LoggerInfo ENGINE_LOGGER {"ENGINE_LOGGER", Log::LogLevel::Trace};
+inline Log::LoggerInfo ENGINE_LOGGER {"ENGINE_LOGGER", Flat::LogLevel::Trace};
-}
+}  // namespace Bigfoot
 #endif
 #endif

Bigfoot/Sources/System/CMakeLists.txt

@@ -1,26 +1,28 @@
 get_filename_component(PackageName ${CMAKE_CURRENT_SOURCE_DIR} NAME)
+project(${PackageName})
 
 set(PublicDependencies
+    $<$<CONFIG:Debug,RelWithDebInfo>:quill::quill>
     mimalloc
-    magic_enum::magic_enum
+    stduuid::stduuid)
-    unordered_dense::unordered_dense
-    EASTL::EASTL
-    stduuid::stduuid
-    $<$<BOOL:${TRACY}>:Tracy::TracyClient>)
 set(PrivateDependencies)
-set(BigfootPublicDependencies)
+set(BigfootPublicDependencies
+    Utils)
 set(BigfootPrivateDependencies)
 
 bigfoot_create_package_lib(
-    ${PackageName}
     "${PublicDependencies}"
     "${PrivateLibraries}"
     "${BigfootPublicDependencies}"
     "${BigfootPrivateDependencies}"
     "")
 
-target_compile_definitions(${PackageName}
+bigfoot_create_logger()
-        PUBLIC MI_SHARED_LIB
+
-        PUBLIC $<$<BOOL:${TRACY}>:TRACY>)
+target_compile_definitions(${PROJECT_NAME}
+        PUBLIC $<$<CONFIG:Debug,RelWithDebInfo>:QUILL_NO_EXCEPTIONS>
+        PUBLIC $<$<CONFIG:Debug,RelWithDebInfo>:QUILL_DISABLE_NON_PREFIXED_MACROS>
+
+        PUBLIC MI_SHARED_LIB)
 set_source_files_properties(${CMAKE_CURRENT_SOURCE_DIR}/MimallocImpl.cpp PROPERTIES SKIP_UNITY_BUILD_INCLUSION ON)
 

Bigfoot/Sources/System/File.cpp

@@ -0,0 +1,66 @@
+/*********************************************************************
+ * \file   File.cpp
+ *
+ * \author Romain BOULLARD
+ * \date   December 2025
+ *********************************************************************/
+#include <System/File.hpp>
+
+namespace Bigfoot
+{
+File::File(const eastl::string_view p_path):
+    m_path(p_path.data()),
+    m_pathString(p_path)
+{
+}
+
+/****************************************************************************************/
+
+bool File::IsAbsolute() const
+{
+    return m_path.is_absolute();
+}
+
+/****************************************************************************************/
+
+bool File::IsRelative() const
+{
+    return m_path.is_relative();
+}
+
+/****************************************************************************************/
+
+bool File::Exists() const
+{
+    return std::filesystem::exists(m_path);
+}
+
+/****************************************************************************************/
+
+eastl::string_view File::Path() const
+{
+    return m_pathString;
+}
+
+/****************************************************************************************/
+
+File File::Absolute() const
+{
+    return File {std::filesystem::absolute(m_path)};
+}
+
+/****************************************************************************************/
+
+File File::Relative() const
+{
+    return File {std::filesystem::relative(m_path)};
+}
+
+/****************************************************************************************/
+
+File::File(const std::filesystem::path& p_path):
+    m_path(p_path),
+    m_pathString(m_path.string().c_str())
+{
+}
+}   // namespace Bigfoot

Bigfoot/Sources/System/Include/System/File.hpp

@@ -0,0 +1,103 @@
+/*********************************************************************
+ * \file   File.hpp
+ *
+ * \author Romain BOULLARD
+ * \date   December 2025
+ *********************************************************************/
+#ifndef BIGFOOT_SYSTEM_FILE_HPP
+#define BIGFOOT_SYSTEM_FILE_HPP
+
+#include <EASTL/string.h>
+#include <EASTL/string_view.h>
+
+#include <filesystem>
+
+namespace Bigfoot
+{
+class File
+{
+  public:
+    /**
+     * Constructor
+     *
+     * \param p_path The path
+     */
+    File(const eastl::string_view p_path);
+
+    File(const File& p_path) = default;
+    File(File&& p_path) = default;
+
+    /**
+     * Check if the file is relative to the current executable
+     *
+     * \return True if the file is relative, false otherwise
+     */
+    [[nodiscard]]
+    bool IsRelative() const;
+
+    /**
+     * Check if the file is absolute
+     *
+     * \return True if the file is absolute, false otherwise
+     */
+    [[nodiscard]]
+    bool IsAbsolute() const;
+
+    /**
+     * Check if the file exists
+     *
+     * \return True if it exists, false otherwise
+     */
+    [[nodiscard]]
+    bool Exists() const;
+
+    /**
+     * Get the file path
+     *
+     * \return The path
+     */
+    [[nodiscard]]
+    eastl::string_view Path() const;
+
+    /**
+     * Get the same file, relative to the current executable
+     *
+     * \return The relative file
+     */
+    [[nodiscard]]
+    File Relative() const;
+
+    /**
+     * Get the same file, with an absolute path
+     *
+     * \return The absolute file
+     */
+    [[nodiscard]]
+    File Absolute() const;
+
+    ~File() = default;
+
+    File& operator=(const File& p_path) = default;
+    File& operator=(File&& p_path) = default;
+
+  private:
+    /**
+     * Constructor
+     *
+     * \param p_path The path
+     */
+    File(const std::filesystem::path& p_path);
+
+    /**
+     * The path
+     */
+    std::filesystem::path m_path;
+
+    /*
+     * The path as a string
+     */
+    eastl::string m_pathString;
+};
+}   // namespace Bigfoot
+
+#endif

Bigfoot/Sources/System/Include/System/Log/EASTLFormatters.hpp

@@ -0,0 +1,95 @@
+/*********************************************************************
+ * \file   EASTLFormatters.hpp
+ *
+ * \author Romain BOULLARD
+ * \date   December 2025
+ *********************************************************************/
+#ifndef BIGFOOT_SYSTEM_EASTLFORMATTERS_HPP
+#define BIGFOOT_SYSTEM_EASTLFORMATTERS_HPP
+#include <Utils/TargetMacros.h>
+
+#if defined(BIGFOOT_NOT_OPTIMIZED)
+#include <quill/DeferredFormatCodec.h>
+#endif
+
+#include <format>
+
+#include <EASTL/string.h>
+#include <EASTL/string_view.h>
+
+// STRING
+
+template<>
+struct std::formatter<eastl::string>
+{
+    constexpr auto parse(std::format_parse_context& ctx)
+    {
+        return ctx.begin();
+    }
+
+    template<typename FormatContext>
+    auto format(const eastl::string& p_string, FormatContext& ctx) const
+    {
+        return std::format_to(ctx.out(), "{}", p_string.c_str());
+    }
+};
+
+#if defined BIGFOOT_NOT_OPTIMIZED
+template<>
+struct fmtquill::formatter<eastl::string>
+{
+    constexpr auto parse(format_parse_context& ctx)
+    {
+        return ctx.begin();
+    }
+
+    auto format(const eastl::string& p_string, format_context& ctx) const
+    {
+        return fmtquill::format_to(ctx.out(), "{}", p_string.c_str());
+    }
+};
+
+template<>
+struct quill::Codec<eastl::string>: quill::DeferredFormatCodec<eastl::string>
+{
+};
+#endif
+
+// STRING_VIEW
+
+template<>
+struct std::formatter<eastl::string_view>
+{
+    constexpr auto parse(std::format_parse_context& ctx)
+    {
+        return ctx.begin();
+    }
+
+    template<typename FormatContext>
+    auto format(const eastl::string_view& p_stringView, FormatContext& ctx) const
+    {
+        return std::format_to(ctx.out(), "{}", p_stringView.data());
+    }
+};
+
+#if defined BIGFOOT_NOT_OPTIMIZED
+template<>
+struct fmtquill::formatter<eastl::string_view>
+{
+    constexpr auto parse(format_parse_context& ctx)
+    {
+        return ctx.begin();
+    }
+
+    auto format(const eastl::string_view& p_stringView, format_context& ctx) const
+    {
+        return fmtquill::format_to(ctx.out(), "{}", p_stringView.data());
+    }
+};
+
+template<>
+struct quill::Codec<eastl::string_view>: quill::DeferredFormatCodec<eastl::string_view>
+{
+};
+#endif
+#endif

Bigfoot/Sources/System/Include/System/Log/Log.fbs

@@ -0,0 +1,16 @@
+namespace Bigfoot.Flat;
+
+enum LogSinkType: byte
+{
+    Console
+}
+
+enum LogLevel: byte
+{
+    Debug,
+    Trace,
+    Info,
+    Warn,
+    Error,
+    Critical
+}

Bigfoot/Sources/System/Include/System/Log/Log.hpp

@@ -4,12 +4,16 @@
  * \author Romain BOULLARD
  * \date   October 2025
  *********************************************************************/
-#ifndef BIGFOOT_UTILS_LOG_HPP
+#ifndef BIGFOOT_SYSTEM_LOG_HPP
-#define BIGFOOT_UTILS_LOG_HPP
+#define BIGFOOT_SYSTEM_LOG_HPP
+#include <System/Log/EASTLFormatters.hpp>
+
 #if defined BIGFOOT_NOT_OPTIMIZED
+#include <System/Log/Log_generated.hpp>
+
 #include <Utils/Singleton.hpp>
 
-#include <magic_enum/magic_enum.hpp>
+#include <EASTL/array.h>
 
 #ifdef BIGFOOT_WINDOWS
 #pragma warning(disable: 4702)
@@ -28,20 +32,10 @@ namespace Bigfoot
 class Log
 {
   public:
-    enum class LogLevel
-    {
-        Debug,
-        Trace,
-        Info,
-        Warn,
-        Error,
-        Critical
-    };
-
     struct LoggerInfo
     {
         std::string m_name;
-        LogLevel m_level;
+        Flat::LogLevel m_level;
     };
 
     Log();
@@ -72,7 +66,13 @@ class Log
      * \param p_loggerInfo The logger to change
      * \param p_level The new level
      */
-    void ChangeLoggerLogLevel(LoggerInfo& p_loggerInfo, const LogLevel p_level);
+    void ChangeLoggerLogLevel(LoggerInfo& p_loggerInfo, const Flat::LogLevel p_level);
+
+    /*
+     * Flush all the loggers
+     *
+     */
+    void Flush();
 
     ~Log();
 
@@ -87,15 +87,10 @@ class Log
      */
     void SetLoggerLevel(const LoggerInfo& p_loggerInfo);
 
-    enum class SinkType
-    {
-        Console
-    };
-
     /*
      * The sinks
      */
-    std::array<std::shared_ptr<quill::Sink>, magic_enum::enum_count<SinkType>()> m_sinks;
+    eastl::array<std::shared_ptr<quill::Sink>, 1> m_sinks;
 };
 }   // namespace Bigfoot
 
@@ -182,6 +177,12 @@ class Log
                                fmt __VA_OPT__(, ) __VA_ARGS__);                                                        \
         }                                                                                                              \
     } while (0)
-
+#else
+#define BIGFOOT_LOG_DEBUG(loggerName, fmt, ...)
+#define BIGFOOT_LOG_TRACE(loggerName, fmt, ...)
+#define BIGFOOT_LOG_INFO(loggerName, fmt, ...)
+#define BIGFOOT_LOG_WARN(loggerName, fmt, ...)
+#define BIGFOOT_LOG_ERROR(loggerName, fmt, ...)
+#define BIGFOOT_LOG_FATAL(loggerName, fmt, ...)
 #endif
 #endif

Bigfoot/Sources/System/Include/System/Log/Log_generated.hpp

@@ -0,0 +1,136 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+
+#ifndef FLATBUFFERS_GENERATED_LOG_BIGFOOT_FLAT_H_
+#define FLATBUFFERS_GENERATED_LOG_BIGFOOT_FLAT_H_
+
+#include "flatbuffers/flatbuffers.h"
+
+// Ensure the included flatbuffers.h is the same version as when this file was
+// generated, otherwise it may not be compatible.
+static_assert(FLATBUFFERS_VERSION_MAJOR == 25 &&
+              FLATBUFFERS_VERSION_MINOR == 12 &&
+              FLATBUFFERS_VERSION_REVISION == 19,
+             "Non-compatible flatbuffers version included");
+
+#include "EASTL/unique_ptr.h"
+#include "EASTL/string.h"
+
+namespace Bigfoot {
+namespace Flat {
+
+enum class LogSinkType : int8_t {
+  Console = 0,
+  MIN = Console,
+  MAX = Console
+};
+
+inline const LogSinkType (&EnumValuesLogSinkType())[1] {
+  static const LogSinkType values[] = {
+    LogSinkType::Console
+  };
+  return values;
+}
+
+inline const char * const *EnumNamesLogSinkType() {
+  static const char * const names[2] = {
+    "Console",
+    nullptr
+  };
+  return names;
+}
+
+inline const char *EnumNameLogSinkType(LogSinkType e) {
+  if (::flatbuffers::IsOutRange(e, LogSinkType::Console, LogSinkType::Console)) return "";
+  const size_t index = static_cast<size_t>(e);
+  return EnumNamesLogSinkType()[index];
+}
+
+enum class LogLevel : int8_t {
+  Debug = 0,
+  Trace = 1,
+  Info = 2,
+  Warn = 3,
+  Error = 4,
+  Critical = 5,
+  MIN = Debug,
+  MAX = Critical
+};
+
+inline const LogLevel (&EnumValuesLogLevel())[6] {
+  static const LogLevel values[] = {
+    LogLevel::Debug,
+    LogLevel::Trace,
+    LogLevel::Info,
+    LogLevel::Warn,
+    LogLevel::Error,
+    LogLevel::Critical
+  };
+  return values;
+}
+
+inline const char * const *EnumNamesLogLevel() {
+  static const char * const names[7] = {
+    "Debug",
+    "Trace",
+    "Info",
+    "Warn",
+    "Error",
+    "Critical",
+    nullptr
+  };
+  return names;
+}
+
+inline const char *EnumNameLogLevel(LogLevel e) {
+  if (::flatbuffers::IsOutRange(e, LogLevel::Debug, LogLevel::Critical)) return "";
+  const size_t index = static_cast<size_t>(e);
+  return EnumNamesLogLevel()[index];
+}
+
+inline const ::flatbuffers::TypeTable *LogSinkTypeTypeTable() {
+  static const ::flatbuffers::TypeCode type_codes[] = {
+    { ::flatbuffers::ET_CHAR, 0, 0 }
+  };
+  static const ::flatbuffers::TypeFunction type_refs[] = {
+    Bigfoot::Flat::LogSinkTypeTypeTable
+  };
+  static const char * const names[] = {
+    "Console"
+  };
+  static const ::flatbuffers::TypeTable tt = {
+    ::flatbuffers::ST_ENUM, 1, type_codes, type_refs, nullptr, nullptr, names
+  };
+  return &tt;
+}
+
+inline const ::flatbuffers::TypeTable *LogLevelTypeTable() {
+  static const ::flatbuffers::TypeCode type_codes[] = {
+    { ::flatbuffers::ET_CHAR, 0, 0 },
+    { ::flatbuffers::ET_CHAR, 0, 0 },
+    { ::flatbuffers::ET_CHAR, 0, 0 },
+    { ::flatbuffers::ET_CHAR, 0, 0 },
+    { ::flatbuffers::ET_CHAR, 0, 0 },
+    { ::flatbuffers::ET_CHAR, 0, 0 }
+  };
+  static const ::flatbuffers::TypeFunction type_refs[] = {
+    Bigfoot::Flat::LogLevelTypeTable
+  };
+  static const char * const names[] = {
+    "Debug",
+    "Trace",
+    "Info",
+    "Warn",
+    "Error",
+    "Critical"
+  };
+  static const ::flatbuffers::TypeTable tt = {
+    ::flatbuffers::ST_ENUM, 6, type_codes, type_refs, nullptr, nullptr, names
+  };
+  return &tt;
+}
+
+}  // namespace Flat
+}  // namespace Bigfoot
+
+#endif  // FLATBUFFERS_GENERATED_LOG_BIGFOOT_FLAT_H_

Bigfoot/Sources/System/Include/System/Log/TargetLogger_generated.hpp.in

@@ -6,7 +6,7 @@
  *********************************************************************/
 #ifndef BIGFOOT_@LOGGER_FILENAME_UPPER@_GENERATED_HPP
 #define BIGFOOT_@LOGGER_FILENAME_UPPER@_GENERATED_HPP
-#include <Utils/Log.hpp>
+#include <System/Log/Log.hpp>
 
 #if defined BIGFOOT_NOT_OPTIMIZED
 
@@ -15,7 +15,7 @@ namespace Bigfoot
 /*
  * Logger
  */
-inline Log::LoggerInfo @LOGGER_NAME@ {"@LOGGER_NAME@", Log::LogLevel::Trace};
+inline Log::LoggerInfo @LOGGER_NAME@ {"@LOGGER_NAME@", Flat::LogLevel::Trace};
-}
+}  // namespace Bigfoot
 #endif
 #endif

Bigfoot/Sources/System/Include/System/SystemAssertHandler.hpp

@@ -0,0 +1,60 @@
+/*********************************************************************
+ * \file   SystemAssertHandler.hpp
+ *
+ * \author Romain BOULLARD
+ * \date   January 2026
+ *********************************************************************/
+#ifndef BIGFOOT_SYSTEM_SYSTEMASSERTHANDLER_HPP
+#define BIGFOOT_SYSTEM_SYSTEMASSERTHANDLER_HPP
+#include <Utils/Assert.hpp>
+
+#include <System/SystemLogger_generated.hpp>
+
+#if defined BIGFOOT_NOT_OPTIMIZED
+#include <EASTL/utility.h>
+
+#include <format>
+#include <source_location>
+#include <string_view>
+
+namespace Bigfoot
+{
+class SystemAssertHandler
+{
+  public:
+    SystemAssertHandler() = delete;
+
+    SystemAssertHandler(const SystemAssertHandler& p_handler) = delete;
+    SystemAssertHandler(SystemAssertHandler&& p_handler) = delete;
+
+    ~SystemAssertHandler() = delete;
+
+    /**
+     * Handle an assertion.
+     *
+     * \param p_location Location of the assertion.
+     * \param p_stacktrace The stack trace
+     * \param p_format Format string for the assertion message.
+     * \param p_args Arguments for the format string.
+     */
+    template<typename... ARGS>
+    static void Handle(const std::source_location& p_location,
+                       const std::string_view p_stacktrace,
+                       std::format_string<ARGS...> p_format,
+                       ARGS&&... p_args)
+    {
+        BIGFOOT_LOG_FATAL(SYSTEM_LOGGER,
+                          "Assert: {} (File:{}, Line:{}, Function:{}\n{}",
+                          std::format(p_format, eastl::forward<ARGS>(p_args)...),
+                          p_location.file_name(),
+                          p_location.line(),
+                          p_location.function_name(),
+                          p_stacktrace);
+    }
+
+    SystemAssertHandler& operator=(const SystemAssertHandler& p_handler) = delete;
+    SystemAssertHandler& operator=(SystemAssertHandler&& p_handler) = delete;
+};
+}   // namespace Bigfoot
+#endif
+#endif

Bigfoot/Sources/System/Include/System/SystemLogger_generated.hpp

@@ -1,12 +1,12 @@
 // AUTO-GENERATED DO NOT TOUCH
 
 /*********************************************************************
- * \file   UtilsTestsLogger.generated.hpp
+ * \file   SystemLogger.generated.hpp
  *
  *********************************************************************/
-#ifndef BIGFOOT_UTILSTESTSLOGGER_GENERATED_HPP
+#ifndef BIGFOOT_SYSTEMLOGGER_GENERATED_HPP
-#define BIGFOOT_UTILSTESTSLOGGER_GENERATED_HPP
+#define BIGFOOT_SYSTEMLOGGER_GENERATED_HPP
-#include <Utils/Log.hpp>
+#include <System/Log/Log.hpp>
 
 #if defined BIGFOOT_NOT_OPTIMIZED
 
@@ -15,7 +15,7 @@ namespace Bigfoot
 /*
  * Logger
  */
-inline Log::LoggerInfo UTILSTESTS_LOGGER {"UTILSTESTS_LOGGER", Log::LogLevel::Trace};
+inline Log::LoggerInfo SYSTEM_LOGGER {"SYSTEM_LOGGER", Flat::LogLevel::Trace};
-}
+}  // namespace Bigfoot
 #endif
 #endif

Bigfoot/Sources/System/Include/System/Time.hpp

@@ -0,0 +1,68 @@
+/*********************************************************************
+ * \file   Time.hpp
+ *
+ * \author Romain BOULLARD
+ * \date   December 2025
+ *********************************************************************/
+#ifndef BIGFOOT_SYSTEM_TIME_HPP
+#define BIGFOOT_SYSTEM_TIME_HPP
+#include <chrono>
+#include <compare>
+#include <cstdint>
+
+namespace Bigfoot
+{
+class Time
+{
+  public:
+    Time(const std::uint64_t p_epoch);
+
+    Time(const Time& p_time) = default;
+    Time(Time&& p_time) = default;
+
+    [[nodiscard]]
+    std::uint32_t Year() const;
+
+    [[nodiscard]]
+    std::uint32_t Month() const;
+
+    [[nodiscard]]
+    std::uint32_t Day() const;
+
+    [[nodiscard]]
+    std::uint32_t Hour() const;
+
+    [[nodiscard]]
+    std::uint32_t Minute() const;
+
+    [[nodiscard]]
+    std::uint32_t Second() const;
+
+    [[nodiscard]]
+    std::uint32_t Microsecond() const;
+
+    [[nodiscard]]
+    std::uint64_t Epoch() const;
+
+    ~Time() = default;
+
+    Time& operator=(const Time& p_time) = default;
+    Time& operator=(Time&& p_time) = default;
+
+    [[nodiscard]]
+    auto operator<=>(const Time& p_other) const
+    {
+        return m_epoch <=> p_other.m_epoch;
+    }
+
+    [[nodiscard]]
+    static Time Now();
+
+  private:
+    std::uint64_t m_epoch;
+    std::tm m_timeInfo;
+    std::chrono::microseconds m_microseconds;
+};
+}   // namespace Bigfoot
+
+#endif

Bigfoot/Sources/System/Include/System/UUID/FlatUUID.hpp

@@ -0,0 +1,18 @@
+/*********************************************************************
+ * \file   FlatUUID.hpp
+ *
+ * \author Romain BOULLARD
+ * \date   December 2025
+ *********************************************************************/
+#ifndef BIGFOOT_SYSTEM_FLATUUID_HPP
+#define BIGFOOT_SYSTEM_FLATUUID_HPP
+#include <System/UUID/UUID.hpp>
+#include <System/UUID/UUID_generated.hpp>
+
+namespace flatbuffers
+{
+Bigfoot::Flat::UUID Pack(const Bigfoot::UUID& p_uuid);
+Bigfoot::UUID UnPack(const Bigfoot::Flat::UUID& p_flatUUID);
+}   // namespace flatbuffers
+
+#endif

Bigfoot/Sources/System/Include/System/UUID/UUID.fbs

@@ -0,0 +1,8 @@
+native_include "System/UUID/FlatUUID.hpp";
+
+namespace Bigfoot.Flat;
+
+struct UUID (native_type: "::Bigfoot::UUID")
+{
+  bytes:[ubyte:16];
+}

Bigfoot/Sources/System/Include/System/UUID/UUID.hpp

@@ -37,9 +37,9 @@ class UUID
 
     ~UUID() = default;
 
-    [[nodiscard]] operator std::span<const std::byte, UUID_BYTE_SIZE>() const;
+    operator std::span<const std::byte, UUID_BYTE_SIZE>() const;
-    [[nodiscard]] operator std::string() const;
+    operator std::string() const;
-    [[nodiscard]] operator bool() const;
+    operator bool() const;
 
     UUID& operator=(const UUID& p_uuid) = default;
     UUID& operator=(UUID&& p_uuid) noexcept = default;
@@ -103,4 +103,42 @@ struct std::hash<Bigfoot::UUID>
     }
 };
 
+template<>
+struct std::formatter<Bigfoot::UUID, char>
+{
+    constexpr auto parse(std::format_parse_context& ctx)
+    {
+        return ctx.begin();
+    }
+
+    template<typename FormatContext>
+    auto format(const Bigfoot::UUID& p_uuid, FormatContext& ctx) const
+    {
+        return std::format_to(ctx.out(), "{}", static_cast<std::string>(p_uuid));
+    }
+};
+
+#if defined BIGFOOT_NOT_OPTIMIZED
+#include <quill/DeferredFormatCodec.h>
+
+template<>
+struct fmtquill::formatter<Bigfoot::UUID>
+{
+    constexpr auto parse(format_parse_context& ctx)
+    {
+        return ctx.begin();
+    }
+
+    auto format(const Bigfoot::UUID& p_uuid, format_context& ctx) const
+    {
+        return fmtquill::format_to(ctx.out(), "{}", static_cast<std::string>(p_uuid));
+    }
+};
+
+template<>
+struct quill::Codec<Bigfoot::UUID>: quill::DeferredFormatCodec<Bigfoot::UUID>
+{
+};
+#endif
+
 #endif

Bigfoot/Sources/System/Include/System/UUID/UUID_generated.hpp

@@ -0,0 +1,74 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+
+#ifndef FLATBUFFERS_GENERATED_UUID_BIGFOOT_FLAT_H_
+#define FLATBUFFERS_GENERATED_UUID_BIGFOOT_FLAT_H_
+
+#include "flatbuffers/flatbuffers.h"
+
+// Ensure the included flatbuffers.h is the same version as when this file was
+// generated, otherwise it may not be compatible.
+static_assert(FLATBUFFERS_VERSION_MAJOR == 25 &&
+              FLATBUFFERS_VERSION_MINOR == 12 &&
+              FLATBUFFERS_VERSION_REVISION == 19,
+             "Non-compatible flatbuffers version included");
+
+#include "System/UUID/FlatUUID.hpp"
+
+#include "EASTL/unique_ptr.h"
+#include "EASTL/string.h"
+
+namespace Bigfoot {
+namespace Flat {
+
+struct UUID;
+
+inline const ::flatbuffers::TypeTable *UUIDTypeTable();
+
+FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(1) UUID FLATBUFFERS_FINAL_CLASS {
+ private:
+  uint8_t bytes_[16];
+
+ public:
+  struct Traits;
+  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
+    return UUIDTypeTable();
+  }
+  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
+    return "Bigfoot.Flat.UUID";
+  }
+  UUID()
+      : bytes_() {
+  }
+  UUID(::flatbuffers::span<const uint8_t, 16> _bytes) {
+    ::flatbuffers::CastToArray(bytes_).CopyFromSpan(_bytes);
+  }
+  const ::flatbuffers::Array<uint8_t, 16> *bytes() const {
+    return &::flatbuffers::CastToArray(bytes_);
+  }
+};
+FLATBUFFERS_STRUCT_END(UUID, 16);
+
+struct UUID::Traits {
+  using type = UUID;
+};
+
+inline const ::flatbuffers::TypeTable *UUIDTypeTable() {
+  static const ::flatbuffers::TypeCode type_codes[] = {
+    { ::flatbuffers::ET_UCHAR, 1, -1 }
+  };
+  static const int16_t array_sizes[] = { 16,  };
+  static const int64_t values[] = { 0, 16 };
+  static const char * const names[] = {
+    "bytes"
+  };
+  static const ::flatbuffers::TypeTable tt = {
+    ::flatbuffers::ST_STRUCT, 1, type_codes, nullptr, array_sizes, values, names
+  };
+  return &tt;
+}
+
+}  // namespace Flat
+}  // namespace Bigfoot
+
+#endif  // FLATBUFFERS_GENERATED_UUID_BIGFOOT_FLAT_H_

Bigfoot/Sources/System/Log/Log.cpp

@@ -4,7 +4,7 @@
  * \author Romain BOULLARD
  * \date   October 2025
  *********************************************************************/
-#include <Utils/Log.hpp>
+#include <System/Log/Log.hpp>
 
 #if defined BIGFOOT_NOT_OPTIMIZED
 
@@ -14,16 +14,18 @@ Log::Log()
 {
     quill::Backend::start();
 
-    m_sinks[magic_enum::enum_integer(SinkType::Console)] = quill::Frontend::create_or_get_sink<quill::ConsoleSink>(
+    m_sinks[static_cast<std::size_t>(Flat::LogSinkType::Console)] =
-        std::string {magic_enum::enum_name(SinkType::Console)});
+        quill::Frontend::create_or_get_sink<quill::ConsoleSink>(
+            std::string {Flat::EnumNameLogSinkType(Flat::LogSinkType::Console)});
 }
 
 /****************************************************************************************/
 
 quill::Logger* Log::RegisterLogger(const LoggerInfo& p_loggerInfo)
 {
-    quill::Logger* logger = quill::Frontend::create_or_get_logger(p_loggerInfo.m_name,
+    quill::Logger* logger = quill::Frontend::create_or_get_logger(
-                                                                  m_sinks[magic_enum::enum_integer(SinkType::Console)]);
+        p_loggerInfo.m_name,
+        m_sinks[static_cast<std::size_t>(Flat::LogSinkType::Console)]);
     SetLoggerLevel(p_loggerInfo);
 
     return logger;
@@ -38,7 +40,7 @@ quill::Logger* Log::GetLogger(const LoggerInfo& p_loggerInfo)
 
 /****************************************************************************************/
 
-void Log::ChangeLoggerLogLevel(LoggerInfo& p_loggerInfo, const LogLevel p_level)
+void Log::ChangeLoggerLogLevel(LoggerInfo& p_loggerInfo, const Flat::LogLevel p_level)
 {
     p_loggerInfo.m_level = p_level;
     SetLoggerLevel(p_loggerInfo);
@@ -48,21 +50,21 @@ void Log::ChangeLoggerLogLevel(LoggerInfo& p_loggerInfo, const LogLevel p_level)
 
 void Log::SetLoggerLevel(const LoggerInfo& p_loggerInfo)
 {
-    constexpr auto logLevelToQuillLogLevel = [](const LogLevel p_level) constexpr -> quill::LogLevel
+    constexpr auto logLevelToQuillLogLevel = [](const Flat::LogLevel p_level) constexpr -> quill::LogLevel
     {
         switch (p_level)
         {
-        case LogLevel::Debug:
+        case Flat::LogLevel::Debug:
             return quill::LogLevel::Debug;
-        case LogLevel::Trace:
+        case Flat::LogLevel::Trace:
             return quill::LogLevel::TraceL3;
-        case LogLevel::Info:
+        case Flat::LogLevel::Info:
             return quill::LogLevel::Info;
-        case LogLevel::Warn:
+        case Flat::LogLevel::Warn:
             return quill::LogLevel::Warning;
-        case LogLevel::Error:
+        case Flat::LogLevel::Error:
             return quill::LogLevel::Error;
-        case LogLevel::Critical:
+        case Flat::LogLevel::Critical:
             return quill::LogLevel::Critical;
         }
 
@@ -77,6 +79,16 @@ void Log::SetLoggerLevel(const LoggerInfo& p_loggerInfo)
 
 /****************************************************************************************/
 
+void Log::Flush()
+{
+    for (quill::Logger* logger: quill::Frontend::get_all_loggers())
+    {
+        logger->flush_log();
+    }
+}
+
+/****************************************************************************************/
+
 Log::~Log()
 {
     for (quill::Logger* logger: quill::Frontend::get_all_loggers())

Bigfoot/Sources/System/Time.cpp

@@ -0,0 +1,121 @@
+/*********************************************************************
+ * \file   Time.cpp
+ *
+ * \author Romain BOULLARD
+ * \date   December 2025
+ *********************************************************************/
+#include <System/Time.hpp>
+
+#include <System/SystemAssertHandler.hpp>
+
+namespace
+{
+[[nodiscard]]
+std::tm GetTimeInfo(const std::time_t& p_time)
+{
+    std::tm timeInfo {};
+#ifdef BIGFOOT_WINDOWS
+    [[maybe_unused]]
+    const errno_t error = gmtime_s(&timeInfo, &p_time);
+    if (error != 0)
+    {
+        char errnoStr[256];
+        strerror_s(errnoStr, error);
+
+        CRITICAL_ASSERT(Bigfoot::SystemAssertHandler,
+                        false,
+                        "Failed to convert epoch time to calendar time. {}",
+                        errnoStr);
+    }
+#elif BIGFOOT_LINUX
+    [[maybe_unused]]
+    const std::tm* error = gmtime_r(&p_time, &timeInfo);
+    CRITICAL_ASSERT(Bigfoot::SystemAssertHandler, error, "Failed to convert epoch time to calendar time");
+#else
+    static_assert(false, "not implemented");
+#endif
+
+    return timeInfo;
+}
+}   // namespace
+
+namespace Bigfoot
+{
+Time::Time(const std::uint64_t p_epoch):
+    m_epoch(p_epoch),
+    m_timeInfo(GetTimeInfo(std::chrono::system_clock::to_time_t(
+        std::chrono::time_point<std::chrono::system_clock> {std::chrono::microseconds {m_epoch}}))),
+    m_microseconds(std::chrono::duration_cast<std::chrono::microseconds>(
+        std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::time_point<std::chrono::system_clock> {
+          std::chrono::microseconds {m_epoch}}.time_since_epoch()) %
+        std::chrono::seconds(1)))
+{
+}
+
+/****************************************************************************************/
+
+std::uint32_t Time::Year() const
+{
+    return m_timeInfo.tm_year + 1900;
+}
+
+/****************************************************************************************/
+
+std::uint32_t Time::Month() const
+{
+    return m_timeInfo.tm_mon + 1;
+}
+
+/****************************************************************************************/
+
+std::uint32_t Time::Day() const
+{
+    return m_timeInfo.tm_mday;
+}
+
+/****************************************************************************************/
+
+std::uint32_t Time::Hour() const
+{
+    return m_timeInfo.tm_hour;
+}
+
+/****************************************************************************************/
+
+std::uint32_t Time::Minute() const
+{
+    return m_timeInfo.tm_min;
+}
+
+/****************************************************************************************/
+
+std::uint32_t Time::Second() const
+{
+    return m_timeInfo.tm_sec;
+}
+
+/****************************************************************************************/
+
+std::uint32_t Time::Microsecond() const
+{
+    return static_cast<std::uint32_t>(m_microseconds.count());
+}
+
+/****************************************************************************************/
+
+std::uint64_t Time::Epoch() const
+{
+    return m_epoch;
+}
+
+/****************************************************************************************/
+
+Time Time::Now()
+{
+    const std::chrono::time_point<std::chrono::system_clock> time = std::chrono::system_clock::now();
+    const std::uint64_t epochInMicroSeconds =
+        std::chrono::duration_cast<std::chrono::microseconds>(time.time_since_epoch()).count();
+
+    return Time {epochInMicroSeconds};
+}
+}   // namespace Bigfoot

Bigfoot/Sources/System/UUID/FlatUUID.cpp

@@ -0,0 +1,27 @@
+/*********************************************************************
+ * \file   FlatUUID.cpp
+ *
+ * \author Romain BOULLARD
+ * \date   December 2025
+ *********************************************************************/
+#include <System/UUID/FlatUUID.hpp>
+
+namespace flatbuffers
+{
+Bigfoot::Flat::UUID Pack(const Bigfoot::UUID& p_uuid)
+{
+    const std::span<const std::byte, Bigfoot::UUID::UUID_BYTE_SIZE> bytes = p_uuid;
+    return Bigfoot::Flat::UUID {
+      std::span<const std::uint8_t, Bigfoot::UUID::UUID_BYTE_SIZE> {reinterpret_cast<const std::uint8_t*>(bytes.data()),
+                                                                    bytes.size()}};
+}
+
+/****************************************************************************************/
+
+Bigfoot::UUID UnPack(const Bigfoot::Flat::UUID& p_flatUUID)
+{
+    const std::span<const std::uint8_t, Bigfoot::UUID::UUID_BYTE_SIZE> bytesView {p_flatUUID.bytes()->data(),
+                                                                                  p_flatUUID.bytes()->size()};
+    return Bigfoot::UUID {std::as_bytes(bytesView)};
+}
+}   // namespace flatbuffers

Bigfoot/Sources/System/UUID/UUID.cpp

@@ -4,7 +4,7 @@
  * \author Romain BOULLARD
  * \date   October 2025
  *********************************************************************/
-#include <System/UUID.hpp>
+#include <System/UUID/UUID.hpp>
 
 namespace Bigfoot
 {

Bigfoot/Sources/Utils/CMakeLists.txt

@@ -1,21 +1,15 @@
 get_filename_component(PackageName ${CMAKE_CURRENT_SOURCE_DIR} NAME)
+project(${PackageName})
 
 set(PublicDependencies
-    $<$<CONFIG:Debug,RelWithDebInfo>:quill::quill>
     $<$<CONFIG:Debug,RelWithDebInfo>:cpptrace::cpptrace>)
 set(PrivateDependencies)
-set(BigfootPublicDependencies
+set(BigfootPublicDependencies)
-    System)
 set(BigfootPrivateDependencies)
 
 bigfoot_create_package_lib(
-    ${PackageName}
     "${PublicDependencies}"
     "${PrivateLibraries}"
     "${BigfootPublicDependencies}"
     "${BigfootPrivateDependencies}"
     "")
-
-target_compile_definitions(${PackageName}
-        PUBLIC $<$<CONFIG:Debug,RelWithDebInfo>:QUILL_NO_EXCEPTIONS>
-        PUBLIC $<$<CONFIG:Debug,RelWithDebInfo>:QUILL_DISABLE_NON_PREFIXED_MACROS>)

Bigfoot/Sources/Utils/Include/Utils/Assert.hpp

@@ -4,14 +4,14 @@
  * \author Romain BOULLARD
  * \date   October 2025
  *********************************************************************/
-#ifndef BIGFOOT_UTILS_ASSERT_HPP
+#ifndef BIGFOOT_SYSTEM_ASSERT_HPP
-#define BIGFOOT_UTILS_ASSERT_HPP
+#define BIGFOOT_SYSTEM_ASSERT_HPP
+#include <System/Log/Log.hpp>
 
 #if defined BIGFOOT_NOT_OPTIMIZED
 
 #include <cpptrace/cpptrace.hpp>
 
-#include <cstdint>
 #include <source_location>
 #include <string>
 
@@ -80,6 +80,10 @@
             };                                                                                                         \
                                                                                                                        \
             HANDLER::Handle(location, stacktrace(), p_message __VA_OPT__(, ) __VA_ARGS__);                             \
+            if (Bigfoot::Singleton<Bigfoot::Log>::HasInstance())                                                       \
+            {                                                                                                          \
+                Bigfoot::Singleton<Bigfoot::Log>::Instance().Flush();                                                  \
+            }                                                                                                          \
             BREAK;                                                                                                     \
             std::abort();                                                                                              \
         }                                                                                                              \

Bigfoot/Sources/Utils/Include/Utils/Caster.hpp

@@ -6,52 +6,41 @@
  *********************************************************************/
 #ifndef BIGFOOT_UTILS_CASTER_HPP
 #define BIGFOOT_UTILS_CASTER_HPP
-#include <Utils/UtilsAssertHandler.hpp>
+#include <EASTL/type_traits.h>
-
-#include <type_traits>
 
 namespace Bigfoot
 {
-template<class TO, class FROM>
+template<class TO,
+         class FROM,
+         eastl::enable_if_t<eastl::is_base_of_v<FROM, TO> || eastl::is_base_of_v<TO, FROM>, bool> = true>
 constexpr TO* Cast(FROM* p_object)
 {
-    constexpr bool same = std::is_base_of_v<FROM, TO> || std::is_base_of_v<TO, FROM>;
-    static_assert(same, "Trying to cast to an incompatible type!");
     return static_cast<TO*>(p_object);
 }
 
-template<class TO, class FROM>
+template<class TO,
+         class FROM,
+         eastl::enable_if_t<eastl::is_base_of_v<FROM, TO> || eastl::is_base_of_v<TO, FROM>, bool> = true>
 constexpr const TO* Cast(const FROM* p_object)
 {
-    constexpr bool same = std::is_base_of_v<FROM, TO> || std::is_base_of_v<TO, FROM>;
-    static_assert(same, "Trying to cast to an incompatible type!");
     return static_cast<const TO*>(p_object);
 }
 
-template<class TO, class FROM>
+template<class TO,
+         class FROM,
+         eastl::enable_if_t<eastl::is_base_of_v<FROM, TO> || eastl::is_base_of_v<TO, FROM>, bool> = true>
 constexpr TO& Cast(FROM& p_object)
 {
-    constexpr bool same = std::is_base_of_v<FROM, TO> || std::is_base_of_v<TO, FROM>;
-    static_assert(same, "Trying to cast to an incompatible type!");
     return static_cast<TO&>(p_object);
 }
 
-template<class TO, class FROM>
+template<class TO,
+         class FROM,
+         eastl::enable_if_t<eastl::is_base_of_v<FROM, TO> || eastl::is_base_of_v<TO, FROM>, bool> = true>
 constexpr const TO& Cast(const FROM& p_object)
 {
-    constexpr bool same = std::is_base_of_v<FROM, TO> || std::is_base_of_v<TO, FROM>;
-    static_assert(same, "Trying to cast to an incompatible type!");
     return static_cast<const TO&>(p_object);
 }
-
-template<typename TO, typename FROM, std::enable_if_t<std::is_integral_v<FROM> && std::is_integral_v<TO>, bool> = true>
-constexpr TO NumericCast(const FROM& p_from)
-{
-    const TO to = static_cast<TO>(p_from);
-    SOFT_ASSERT(UtilsAssertHandler, static_cast<FROM>(to) == p_from, "We are losing data for this cast!");
-
-    return to;
-}
 }   // namespace Bigfoot
 
 #define BIGFOOT_NUMERIC_CAST(p_to, p_data) Bigfoot::NumericCast<p_to>(p_data)

Bigfoot/Sources/Utils/Include/Utils/Singleton.hpp

@@ -6,10 +6,11 @@
  *********************************************************************/
 #ifndef BIGFOOT_UTILS_SINGLETON_HPP
 #define BIGFOOT_UTILS_SINGLETON_HPP
-#include <array>
+
-#include <bit>
+#include <EASTL/array.h>
-#include <type_traits>
+#include <EASTL/bit.h>
-#include <utility>
+#include <EASTL/type_traits.h>
+#include <EASTL/utility.h>
 
 namespace Bigfoot
 {
@@ -31,7 +32,17 @@ class Singleton
      */
     static constexpr TYPE& Instance()
     {
-        return *std::bit_cast<TYPE*>(ms_instance.data());
+        return *eastl::bit_cast<TYPE*>(ms_instance.data());
+    }
+
+    /**
+     * Is the instance initialized
+     *
+     * \return True if initialized, false otherwise
+     */
+    static constexpr bool HasInstance()
+    {
+        return ms_initialized;
     }
 
     class Lifetime
@@ -42,10 +53,11 @@ class Singleton
          *
          * \param p_args Arguments for the singleton
          */
-        template<typename... ARGS, typename = std::enable_if_t<!(std::is_same_v<Lifetime, std::decay_t<ARGS>> || ...)>>
+        template<typename... ARGS,
+                 typename = eastl::enable_if_t<!(eastl::is_same_v<Lifetime, eastl::decay_t<ARGS>> || ...)>>
         explicit Lifetime(ARGS&&... p_args)
         {
-            Initialize(std::forward<ARGS>(p_args)...);
+            Initialize(eastl::forward<ARGS>(p_args)...);
         }
 
         Lifetime(const Lifetime& p_lifetime) = delete;
@@ -76,7 +88,7 @@ class Singleton
     template<typename... ARGS>
     static void Initialize(ARGS&&... p_args)
     {
-        new (ms_instance.data()) TYPE(std::forward<ARGS>(p_args)...);
+        new (ms_instance.data()) TYPE(eastl::forward<ARGS>(p_args)...);
 
         ms_initialized = true;
     }
@@ -87,7 +99,7 @@ class Singleton
      */
     static void Finalize()
     {
-        std::bit_cast<TYPE*>(ms_instance.data())->~TYPE();
+        eastl::bit_cast<TYPE*>(ms_instance.data())->~TYPE();
 
         ms_initialized = false;
     }
@@ -95,7 +107,7 @@ class Singleton
     /**
      * The singleton.
      */
-    alignas(alignof(TYPE)) inline static std::array<std::byte, sizeof(TYPE)> ms_instance;
+    alignas(alignof(TYPE)) inline static eastl::array<std::byte, sizeof(TYPE)> ms_instance;
 
     /**
      * Is the singleton initialized?

Bigfoot/Sources/Utils/Include/Utils/TaggedType.hpp

@@ -0,0 +1,131 @@
+/*********************************************************************
+ * \file   TaggedType.h
+ *
+ * \author Romain BOULLARD
+ * \date   December 2025
+ *********************************************************************/
+#ifndef BIGFOOT_UTILS_TAGGEDTYPE_H
+#define BIGFOOT_UTILS_TAGGEDTYPE_H
+
+#include <compare>
+
+namespace Bigfoot
+{
+template<typename TYPE>
+class TaggedType
+{
+  public:
+    constexpr TaggedType() = default;
+
+    constexpr explicit TaggedType(TYPE p_value):
+        m_value(p_value)
+    {
+    }
+
+    constexpr TaggedType(const TaggedType& p_taggedType) = default;
+    constexpr TaggedType(TaggedType&& p_taggedType) noexcept = default;
+
+    ~TaggedType() = default;
+
+    constexpr TaggedType& operator=(const TaggedType& p_taggedType) = default;
+    constexpr TaggedType& operator=(TaggedType&& p_taggedType) noexcept = default;
+
+    constexpr TaggedType& operator=(const TYPE& p_value)
+    {
+        m_value = p_value;
+        return *this;
+    }
+
+    constexpr explicit operator TYPE() const
+    {
+        return m_value;
+    }
+
+    constexpr TYPE Get() const
+    {
+        return m_value;
+    }
+
+    constexpr auto operator<=>(const TaggedType& p_other) const = default;
+
+    constexpr TaggedType& operator+=(const TYPE& p_value)
+    {
+        m_value += p_value;
+        return *this;
+    }
+
+    constexpr TaggedType& operator-=(const TYPE& p_value)
+    {
+        m_value -= p_value;
+        return *this;
+    }
+
+    constexpr TaggedType& operator*=(const TYPE& p_value)
+    {
+        m_value *= p_value;
+        return *this;
+    }
+
+    constexpr TaggedType& operator/=(const TYPE& p_value)
+    {
+        m_value /= p_value;
+        return *this;
+    }
+
+    constexpr TaggedType& operator+=(const TaggedType& p_other)
+    {
+        m_value += p_other.m_value;
+        return *this;
+    }
+
+    constexpr TaggedType& operator-=(const TaggedType& p_other)
+    {
+        m_value -= p_other.m_value;
+        return *this;
+    }
+
+    constexpr TaggedType& operator*=(const TaggedType& p_other)
+    {
+        m_value *= p_other.m_value;
+        return *this;
+    }
+
+    constexpr TaggedType& operator/=(const TaggedType& p_other)
+    {
+        m_value /= p_other.m_value;
+        return *this;
+    }
+
+    template<typename L, typename R>
+    friend constexpr TaggedType operator+(L p_left, R p_right)
+    {
+        return p_left += p_right;
+    }
+
+    template<typename L, typename R>
+    friend constexpr TaggedType operator-(L p_left, R p_right)
+    {
+        return p_left -= p_right;
+    }
+
+    template<typename L, typename R>
+    friend constexpr TaggedType operator*(L p_left, R p_right)
+    {
+        return p_left *= p_right;
+    }
+
+    template<typename L, typename R>
+    friend constexpr TaggedType operator/(L p_left, R p_right)
+    {
+        return p_left /= p_right;
+    }
+
+  private:
+    /**
+     * The value
+     */
+    TYPE m_value {};
+};
+}   // namespace Bigfoot
+
+#endif

Bigfoot/Sources/Utils/Include/Utils/UtilsAssertHandler.hpp

@@ -1,49 +0,0 @@
-/*********************************************************************
- * \file   UtilsAssertHandler.hpp
- *
- * \author Romain BOULLARD
- * \date   October 2025
- *********************************************************************/
-#ifndef BIGFOOT_UTILS_UTILSASSERTHANDLER_HPP
-#define BIGFOOT_UTILS_UTILSASSERTHANDLER_HPP
-#include <Utils/Assert.hpp>
-
-#include <format>
-#include <source_location>
-#include <string_view>
-
-namespace Bigfoot
-{
-class UtilsAssertHandler
-{
-  public:
-    UtilsAssertHandler() = delete;
-
-    UtilsAssertHandler(const UtilsAssertHandler& p_handler) = delete;
-    UtilsAssertHandler(UtilsAssertHandler&& p_handler) = delete;
-
-    ~UtilsAssertHandler() = delete;
-
-    /**
-     * Handle an assertion.
-     *
-     * \param p_location Location of the assertion.
-     * \param p_stacktrace The stack trace
-     * \param p_format Format string for the assertion message.
-     * \param p_args Arguments for the format string.
-     */
-    template<typename... ARGS>
-    static void Handle([[maybe_unused]] const std::source_location& p_location,
-                       [[maybe_unused]] const std::string_view p_stacktrace,
-                       [[maybe_unused]] std::format_string<ARGS...> p_format,
-                       [[maybe_unused]] ARGS&&... p_args)
-    {
-        // We dont have access to logging capabilities here
-        // So no log
-    }
-
-    UtilsAssertHandler& operator=(const UtilsAssertHandler& p_handler) = delete;
-    UtilsAssertHandler& operator=(UtilsAssertHandler&& p_handler) = delete;
-};
-}   // namespace Bigfoot
-#endif

Bigfoot/Sources/Utils/Include/Utils/Version.hpp

@@ -57,7 +57,7 @@ class Version
     {
         constexpr std::uint32_t mask = 0b00000000111111110000000000000000;
 
-        return BIGFOOT_NUMERIC_CAST(std::uint8_t, (m_combined & mask) >> 16);
+        return static_cast<std::uint8_t>((m_combined & mask) >> 16);
     }
 
     /**
@@ -70,7 +70,7 @@ class Version
     {
         constexpr std::uint32_t mask = 0b00000000000000001111111100000000;
 
-        return BIGFOOT_NUMERIC_CAST(std::uint8_t, (m_combined & mask) >> 8);
+        return static_cast<std::uint8_t>((m_combined & mask) >> 8);
     }
 
     /**
@@ -83,7 +83,7 @@ class Version
     {
         constexpr std::uint32_t mask = 0b00000000000000000000000011111111;
 
-        return BIGFOOT_NUMERIC_CAST(std::uint8_t, (m_combined & mask));
+        return static_cast<std::uint8_t>(m_combined & mask);
     }
 
     [[nodiscard]]

Bigfoot/Tests/Engine/BigFile/BigFile.cpp

@@ -0,0 +1,158 @@
+/*********************************************************************
+ * \file   BigFile.cpp
+ *
+ * \author Romain BOULLARD
+ * \date   December 2025
+ *********************************************************************/
+#include <Engine/BigFile/BigFile.hpp>
+
+#include <System/Log/Log.hpp>
+#include <System/Time.hpp>
+#include <System/UUID/UUID.hpp>
+
+#include <Utils/Singleton.hpp>
+#include <Utils/TargetMacros.h>
+
+#include <EngineTests/BigFileInfo_generated.hpp>
+
+#include <gtest/gtest.h>
+
+namespace Bigfoot
+{
+class BigFileFixture: public ::testing::Test
+{
+  protected:
+    void SetUp() override
+    {
+        BigFile::Request deleteHeader {m_bigFile, "DELETE FROM AssetHeader"};
+        BigFile::Request deleteAsset {m_bigFile, "DELETE FROM AssetHeader"};
+
+        m_bigFile.BeginTransaction();
+        deleteHeader.Execute();
+        deleteAsset.Execute();
+        m_bigFile.CommitTransaction();
+    }
+
+    BIGFOOT_NOT_OPTIMIZED_ONLY(Singleton<Log>::Lifetime m_loggerLifetime;)
+
+    BigFile m_bigFile {File {BIGFILE_ENGINETESTS_LOCATION}};
+};
+
+/****************************************************************************************/
+
+TEST_F(BigFileFixture, Lol)
+{
+    UUID uuid;
+    UUID uuid2;
+
+    eastl::array<std::byte, 4> blob {std::byte {1}, std::byte {2}, std::byte {3}, std::byte {4}};
+    eastl::array<std::byte, 4> blob2 {std::byte {1}, std::byte {2}, std::byte {3}, std::byte {5}};
+    eastl::array<std::byte, 4> blob3 {std::byte {1}, std::byte {2}, std::byte {3}, std::byte {6}};
+
+    {
+        BigFile::Request assetHeaderRequest {
+          m_bigFile,
+          "INSERT INTO AssetHeader (UUID, Name, TypeID, TypeName) VALUES(?, ?, ?, ?)"};
+        assetHeaderRequest.Bind(1, static_cast<std::span<const std::byte, UUID::UUID_BYTE_SIZE>>(uuid));
+        assetHeaderRequest.Bind(2, "Test");
+        assetHeaderRequest.Bind(3, 42);
+        assetHeaderRequest.Bind(4, "TypeTest");
+
+        BigFile::Request assetRequest {m_bigFile, "INSERT INTO Asset (UUID, Asset) VALUES(?, ?)"};
+        assetRequest.Bind(1, static_cast<std::span<const std::byte, UUID::UUID_BYTE_SIZE>>(uuid));
+        assetRequest.Bind(2, blob);
+
+        BigFile::Request assetHeaderRequest2 {
+          m_bigFile,
+          "INSERT INTO AssetHeader (UUID, Name, TypeID, TypeName) VALUES(?, ?, ?, ?)"};
+        assetHeaderRequest2.Bind(1, static_cast<std::span<const std::byte, UUID::UUID_BYTE_SIZE>>(uuid2));
+        assetHeaderRequest2.Bind(2, "Test2");
+        assetHeaderRequest2.Bind(3, 42);
+        assetHeaderRequest2.Bind(4, "TypeTest");
+
+        BigFile::Request assetRequest2 {m_bigFile, "INSERT INTO Asset (UUID, Asset) VALUES(?, ?)"};
+        assetRequest2.Bind(1, static_cast<std::span<const std::byte, UUID::UUID_BYTE_SIZE>>(uuid2));
+        assetRequest2.Bind(2, blob3);
+
+        m_bigFile.BeginTransaction();
+        [[maybe_unused]]
+        std::uint32_t assetHeaderChangedCount = assetHeaderRequest.Execute();
+        [[maybe_unused]]
+        std::uint32_t assetChangedCount = assetRequest.Execute();
+
+        [[maybe_unused]]
+        std::uint32_t assetHeaderChangedCount2 = assetHeaderRequest2.Execute();
+        [[maybe_unused]]
+        std::uint32_t assetChangedCount2 = assetRequest2.Execute();
+
+        m_bigFile.CommitTransaction();
+    }
+
+    {
+        BigFile::Request updateAsset {m_bigFile, "UPDATE Asset SET Asset = ? WHERE UUID = ?"};
+        updateAsset.Bind(1, blob2);
+        updateAsset.Bind(2, static_cast<std::span<const std::byte, UUID::UUID_BYTE_SIZE>>(uuid));
+
+        m_bigFile.BeginTransaction();
+        [[maybe_unused]]
+        std::uint32_t updateAssetChangedCount = updateAsset.Execute();
+        m_bigFile.CommitTransaction();
+    }
+
+    {
+        BigFile::Request request {
+          m_bigFile,
+          "SELECT Name, TypeID, TypeName, CreateTime, ModificationTime FROM AssetHeader WHERE UUID = ?"};
+        request.Bind(1, static_cast<std::span<const std::byte, UUID::UUID_BYTE_SIZE>>(uuid));
+
+        [[maybe_unused]]
+        const bool get = request.Step();
+
+        [[maybe_unused]]
+        const eastl::string name {static_cast<eastl::string_view>(request.Get(0))};
+        [[maybe_unused]]
+        const std::uint32_t typeId = request.Get(1);
+        [[maybe_unused]]
+        const eastl::string typeName {static_cast<eastl::string_view>(request.Get(2))};
+        [[maybe_unused]]
+        const Time createTime = static_cast<std::int64_t>(request.Get(3));
+        [[maybe_unused]]
+        const Time modificationTime = static_cast<std::int64_t>(request.Get(4));
+
+        {
+            [[maybe_unused]]
+            const std::uint32_t year = createTime.Year();
+            [[maybe_unused]]
+            const std::uint32_t month = createTime.Month();
+            [[maybe_unused]]
+            const std::uint32_t day = createTime.Day();
+            [[maybe_unused]]
+            const std::uint32_t hour = createTime.Hour();
+            [[maybe_unused]]
+            const std::uint32_t minute = createTime.Minute();
+            [[maybe_unused]]
+            const std::uint32_t second = createTime.Second();
+            [[maybe_unused]]
+            const std::uint32_t microsecond = createTime.Microsecond();
+        }
+
+        {
+            [[maybe_unused]]
+            const std::uint32_t year = modificationTime.Year();
+            [[maybe_unused]]
+            const std::uint32_t month = modificationTime.Month();
+            [[maybe_unused]]
+            const std::uint32_t day = modificationTime.Day();
+            [[maybe_unused]]
+            const std::uint32_t hour = modificationTime.Hour();
+            [[maybe_unused]]
+            const std::uint32_t minute = modificationTime.Minute();
+            [[maybe_unused]]
+            const std::uint32_t second = modificationTime.Second();
+            [[maybe_unused]]
+            const std::uint32_t microsecond = modificationTime.Microsecond();
+        }
+    }
+}
+
+}   // namespace Bigfoot

Bigfoot/Tests/Engine/BigFile/Database.cpp

@@ -1 +0,0 @@
-

Bigfoot/Tests/Engine/CMakeLists.txt

@@ -1,7 +1,15 @@
 get_filename_component(PackageName ${CMAKE_CURRENT_SOURCE_DIR} NAME)
+project(${PackageName}Tests)
 
-bigfoot_create_bigfile(${PackageName}Tests "Tests/Bigfoot")
+set(BigfootDependencies
+        Engine
+        System
+        Utils)
+
+bigfoot_create_bigfile("Tests/Bigfoot")
 
 bigfoot_create_package_tests(
-    ${PackageName}
+    ""
-    "")
+    "${BigfootDependencies}")
+
+bigfoot_setup_dependencies("Tests/Bigfoot")

Bigfoot/Tests/Engine/Include/Bigfoot/BigFileInfo_generated.hpp

@@ -1,19 +0,0 @@
-// AUTO-GENERATED DO NOT TOUCH
-
-/*********************************************************************
- * \file   BigFileInfo.generated.hpp
- * 
- *********************************************************************/
-#ifndef BIGFOOT_BIGFOOT_BIGFILEINFO_GENERATED_HPP
-#define BIGFOOT_BIGFOOT_BIGFILEINFO_GENERATED_HPP
-
-#include <string_view>
-
-namespace Bigfoot
-{
-/*
- * BigFile location
- */
-constexpr std::string_view BIGFILE_BIGFOOT_LOCATION{"D:/Development/bigfootdev/bigfoot2/build/Bigfoot/Tests/Engine/Bigfoot-bigfile.db"};
-}
-#endif

Bigfoot/Tests/Engine/Include/EngineTests/BigFileInfo.generated.hpp

@@ -1,19 +0,0 @@
-// AUTO-GENERATED DO NOT TOUCH
-
-/*********************************************************************
- * \file   BigFileInfo.generated.hpp
- * 
- *********************************************************************/
-#ifndef BIGFOOT_ENGINE_BIGFILE_BIGFILEINFO_GENERATED_HPP
-#define BIGFOOT_ENGINE_BIGFILE_BIGFILEINFO_GENERATED_HPP
-
-#include <string_view>
-
-namespace Bigfoot
-{
-/*
- * BigFile location
- */
-constexpr std::string_view BIGFILE_ENGINETESTS_LOCATION{"D:/Development/bigfootdev/bigfoot2/build/Bigfoot/Tests/Engine/EngineTests-bigfile.db"};
-}
-#endif

Bigfoot/Tests/System/CMakeLists.txt

@@ -1,7 +1,14 @@
 get_filename_component(PackageName ${CMAKE_CURRENT_SOURCE_DIR} NAME)
+project(${PackageName}Tests)
 
-set(Dependencies)
+set(BigfootDependencies
+        System
+        Utils)
 
 bigfoot_create_package_tests(
-    ${PackageName}
+    ""
-    "")
+    "${BigfootDependencies}")
+
+bigfoot_create_logger()
+
+bigfoot_setup_dependencies("Tests/Bigfoot")

Bigfoot/Tests/System/File.cpp

@@ -0,0 +1,80 @@
+/*********************************************************************
+ * \file   File.cpp
+ *
+ * \author Romain BOULLARD
+ * \date   December 2025
+ *********************************************************************/
+#include <System/File.hpp>
+
+#include <gtest/gtest.h>
+
+namespace Bigfoot
+{
+class FileFixture: public ::testing::Test
+{
+  public:
+    File m_file {eastl::string_view {"Fixture/file"}};
+    File m_nonExistent {eastl::string_view {"Fixture/bigfoot"}};
+};
+
+/****************************************************************************************/
+
+TEST_F(FileFixture, IsRelative_ShouldReturnTrueOnRelativeFile)
+{
+    EXPECT_TRUE(m_file.IsRelative());
+}
+
+/****************************************************************************************/
+
+TEST_F(FileFixture, IsRelative_ShouldReturnFalseOnAbsoluteFile)
+{
+    EXPECT_FALSE(m_file.Absolute().IsRelative());
+}
+
+/****************************************************************************************/
+
+TEST_F(FileFixture, IsAbsolute_ShouldReturnTrueOnAbsoluteFile)
+{
+    EXPECT_TRUE(m_file.Absolute().IsAbsolute());
+}
+
+TEST_F(FileFixture, IsAbsolute_ShouldReturnFalseOnRelativeFile)
+{
+    EXPECT_FALSE(m_file.IsAbsolute());
+}
+
+/****************************************************************************************/
+
+TEST_F(FileFixture, Exists_ShouldReturnTrueOnExistingFile)
+{
+    EXPECT_TRUE(m_file.Exists());
+}
+
+/****************************************************************************************/
+
+TEST_F(FileFixture, Exists_ShouldReturnFalseOnNonExistingFile)
+{
+    EXPECT_FALSE(m_nonExistent.Exists());
+}
+
+/****************************************************************************************/
+
+TEST_F(FileFixture, Path_ShouldReturnThePath)
+{
+    EXPECT_STREQ(m_file.Path().data(), "Fixture/file");
+}
+
+/****************************************************************************************/
+
+TEST_F(FileFixture, Absolute_ShouldReturnTheAbsolutePath)
+{
+    EXPECT_STREQ(std::filesystem::absolute("Fixture/file").string().c_str(), m_file.Absolute().Path().data());
+}
+
+/****************************************************************************************/
+
+TEST_F(FileFixture, Relative_ShouldReturnTheRelativePath)
+{
+    EXPECT_STREQ(std::filesystem::relative("Fixture/file").string().c_str(), m_file.Relative().Path().data());
+}
+}   // namespace Bigfoot

Bigfoot/Tests/System/Include/SystemTests/SystemTestsLogger_generated.hpp

@@ -0,0 +1,21 @@
+// AUTO-GENERATED DO NOT TOUCH
+
+/*********************************************************************
+ * \file   SystemTestsLogger.generated.hpp
+ *
+ *********************************************************************/
+#ifndef BIGFOOT_SYSTEMTESTSLOGGER_GENERATED_HPP
+#define BIGFOOT_SYSTEMTESTSLOGGER_GENERATED_HPP
+#include <System/Log/Log.hpp>
+
+#if defined BIGFOOT_NOT_OPTIMIZED
+
+namespace Bigfoot
+{
+/*
+ * Logger
+ */
+inline Log::LoggerInfo SYSTEMTESTS_LOGGER {"SYSTEMTESTS_LOGGER", Flat::LogLevel::Trace};
+}  // namespace Bigfoot
+#endif
+#endif

Bigfoot/Tests/System/Log/Log.cpp

@@ -4,9 +4,11 @@
  * \author Romain BOULLARD
  * \date   December 2022
  *********************************************************************/
-#include <Utils/Log.hpp>
+#include <System/Log/Log.hpp>
 
-#include <UtilsTests/UtilsTestsLogger.generated.hpp>
+#include <Utils/Singleton.hpp>
+
+#include <SystemTests/SystemTestsLogger_generated.hpp>
 
 #if defined BIGFOOT_NOT_OPTIMIZED
 
@@ -19,51 +21,51 @@ class LogFixture: public ::testing::Test
   protected:
     void SetUp() override
     {
-        UTILSTESTS_LOGGER = {"UTILSTESTS_LOGGER", Log::LogLevel::Trace};
+        SYSTEMTESTS_LOGGER = {"UTILSTESTS_LOGGER", Flat::LogLevel::Trace};
     }
 
-    constexpr Log::LogLevel QuillLogLevelToLogLevel(const quill::LogLevel p_level)
+    static constexpr Flat::LogLevel QuillLogLevelToLogLevel(const quill::LogLevel p_level)
     {
         switch (p_level)
         {
         case quill::LogLevel::Debug:
-            return Log::LogLevel::Debug;
+            return Flat::LogLevel::Debug;
         case quill::LogLevel::TraceL3:
-            return Log::LogLevel::Trace;
+            return Flat::LogLevel::Trace;
         case quill::LogLevel::Info:
-            return Log::LogLevel::Info;
+            return Flat::LogLevel::Info;
         case quill::LogLevel::Warning:
-            return Log::LogLevel::Warn;
+            return Flat::LogLevel::Warn;
         case quill::LogLevel::Error:
-            return Log::LogLevel::Error;
+            return Flat::LogLevel::Error;
         case quill::LogLevel::Critical:
-            return Log::LogLevel::Critical;
+            return Flat::LogLevel::Critical;
         default:
             break;
         }
 
-        return Log::LogLevel::Trace;
+        return Flat::LogLevel::Trace;
     }
 
-    Singleton<Log>::Lifetime m_log;
+    Log m_log;
 };
 
 /****************************************************************************************/
 
 TEST_F(LogFixture, RegisterLogger_ShouldRegisterTheLogger)
 {
-    const quill::Logger* logger = Singleton<Log>::Instance().RegisterLogger(UTILSTESTS_LOGGER);
+    const quill::Logger* logger = m_log.RegisterLogger(SYSTEMTESTS_LOGGER);
     EXPECT_TRUE(logger);
-    EXPECT_EQ(logger, Singleton<Log>::Instance().GetLogger(UTILSTESTS_LOGGER));
+    EXPECT_EQ(logger, m_log.GetLogger(SYSTEMTESTS_LOGGER));
-    EXPECT_EQ(logger->get_logger_name(), UTILSTESTS_LOGGER.m_name);
+    EXPECT_EQ(logger->get_logger_name(), SYSTEMTESTS_LOGGER.m_name);
-    EXPECT_EQ(QuillLogLevelToLogLevel(logger->get_log_level()), UTILSTESTS_LOGGER.m_level);
+    EXPECT_EQ(QuillLogLevelToLogLevel(logger->get_log_level()), SYSTEMTESTS_LOGGER.m_level);
 }
 
 /****************************************************************************************/
 
 TEST_F(LogFixture, GetLogger_ShouldReturnNullptrIfTheLoggerDoesNotExist)
 {
-    EXPECT_FALSE(Singleton<Log>::Instance().GetLogger(UTILSTESTS_LOGGER));
+    EXPECT_FALSE(m_log.GetLogger(SYSTEMTESTS_LOGGER));
 }
 
 /****************************************************************************************/
@@ -71,60 +73,66 @@ TEST_F(LogFixture, GetLogger_ShouldReturnNullptrIfTheLoggerDoesNotExist)
 TEST_F(LogFixture, GetLogger_ShouldReturnTheLoggerIfItExists)
 {
     [[maybe_unused]]
-    const quill::Logger* logger = Singleton<Log>::Instance().RegisterLogger(UTILSTESTS_LOGGER);
+    const quill::Logger* logger = m_log.RegisterLogger(SYSTEMTESTS_LOGGER);
-    EXPECT_TRUE(Singleton<Log>::Instance().GetLogger(UTILSTESTS_LOGGER));
+    EXPECT_TRUE(m_log.GetLogger(SYSTEMTESTS_LOGGER));
 }
 
 /****************************************************************************************/
 
 TEST_F(LogFixture, ChangeLoggerLogLevel_ShouldChangeTheLoggerLogLevel)
 {
-    const quill::Logger* logger = Singleton<Log>::Instance().RegisterLogger(UTILSTESTS_LOGGER);
+    const quill::Logger* logger = m_log.RegisterLogger(SYSTEMTESTS_LOGGER);
 
-    Singleton<Log>::Instance().ChangeLoggerLogLevel(UTILSTESTS_LOGGER, Log::LogLevel::Critical);
+    m_log.ChangeLoggerLogLevel(SYSTEMTESTS_LOGGER, Flat::LogLevel::Critical);
-    EXPECT_EQ(QuillLogLevelToLogLevel(logger->get_log_level()), Log::LogLevel::Critical);
+    EXPECT_EQ(QuillLogLevelToLogLevel(logger->get_log_level()), Flat::LogLevel::Critical);
 }
 
 /****************************************************************************************/
 
 TEST_F(LogFixture, LogDebug)
 {
-    BIGFOOT_LOG_DEBUG(UTILSTESTS_LOGGER, "Hello");
+    Singleton<Log>::Lifetime singletonLifetime;
+    BIGFOOT_LOG_DEBUG(SYSTEMTESTS_LOGGER, "Hello");
 }
 
 /****************************************************************************************/
 
 TEST_F(LogFixture, LogTrace)
 {
-    BIGFOOT_LOG_TRACE(UTILSTESTS_LOGGER, "Hello");
+    Singleton<Log>::Lifetime singletonLifetime;
+    BIGFOOT_LOG_TRACE(SYSTEMTESTS_LOGGER, "Hello");
 }
 
 /****************************************************************************************/
 
 TEST_F(LogFixture, LogInfo)
 {
-    BIGFOOT_LOG_INFO(UTILSTESTS_LOGGER, "Hello");
+    Singleton<Log>::Lifetime singletonLifetime;
+    BIGFOOT_LOG_INFO(SYSTEMTESTS_LOGGER, "Hello");
 }
 
 /****************************************************************************************/
 
 TEST_F(LogFixture, LogWarn)
 {
-    BIGFOOT_LOG_WARN(UTILSTESTS_LOGGER, "Hello");
+    Singleton<Log>::Lifetime singletonLifetime;
+    BIGFOOT_LOG_WARN(SYSTEMTESTS_LOGGER, "Hello");
 }
 
 /****************************************************************************************/
 
 TEST_F(LogFixture, LogError)
 {
-    BIGFOOT_LOG_ERROR(UTILSTESTS_LOGGER, "Hello");
+    Singleton<Log>::Lifetime singletonLifetime;
+    BIGFOOT_LOG_ERROR(SYSTEMTESTS_LOGGER, "Hello");
 }
 
 /****************************************************************************************/
 
 TEST_F(LogFixture, LogFatal)
 {
-    BIGFOOT_LOG_FATAL(UTILSTESTS_LOGGER, "Hello");
+    Singleton<Log>::Lifetime singletonLifetime;
+    BIGFOOT_LOG_FATAL(SYSTEMTESTS_LOGGER, "Hello");
 }
 }   // namespace Bigfoot
 #endif

Bigfoot/Tests/System/Time.cpp

@@ -0,0 +1,67 @@
+/*********************************************************************
+ * \file   Time.cpp
+ *
+ * \author Romain BOULLARD
+ * \date   December 2025
+ *********************************************************************/
+#include <System/Time.hpp>
+
+#include <gtest/gtest.h>
+
+namespace Bigfoot
+{
+class TimeFixture: public ::testing::Test
+{
+  public:
+    Time m_time {1'767'643'746'680'609};
+};
+
+/****************************************************************************************/
+
+TEST_F(TimeFixture, Year_ShouldReturnTheYear)
+{
+    EXPECT_EQ(m_time.Year(), 2026);
+}
+
+/****************************************************************************************/
+
+TEST_F(TimeFixture, Month_ShouldReturnTheMonth)
+{
+    EXPECT_EQ(m_time.Month(), 1);
+}
+
+/****************************************************************************************/
+
+TEST_F(TimeFixture, Day_ShouldReturnTheDay)
+{
+    EXPECT_EQ(m_time.Day(), 5);
+}
+
+/****************************************************************************************/
+
+TEST_F(TimeFixture, Hour_ShouldReturnTheHour)
+{
+    EXPECT_EQ(m_time.Hour(), 20);
+}
+
+/****************************************************************************************/
+
+TEST_F(TimeFixture, Minute_ShouldReturnTheMinute)
+{
+    EXPECT_EQ(m_time.Minute(), 9);
+}
+
+/****************************************************************************************/
+
+TEST_F(TimeFixture, Second_ShouldReturnTheSecond)
+{
+    EXPECT_EQ(m_time.Second(), 6);
+}
+
+/****************************************************************************************/
+
+TEST_F(TimeFixture, Microsecond_ShouldReturnTheMicrosecond)
+{
+    EXPECT_EQ(m_time.Microsecond(), 680'609);
+}
+}   // namespace Bigfoot

Bigfoot/Tests/System/UUID/UUID.cpp

@@ -4,7 +4,7 @@
  * \author Romain BOULLARD
  * \date   October 2025
  *********************************************************************/
-#include <System/UUID.hpp>
+#include <System/UUID/UUID.hpp>
 
 #include <ankerl/unordered_dense.h>
 

Bigfoot/Tests/Utils/CMakeLists.txt

@@ -1,9 +1,11 @@
 get_filename_component(PackageName ${CMAKE_CURRENT_SOURCE_DIR} NAME)
+project(${PackageName}Tests)
 
-set(Dependencies)
+set(BigfootDependencies
-
+        Utils)
-bigfoot_create_logger(${PackageName}Tests)
 
 bigfoot_create_package_tests(
-    ${PackageName}
+    ""
-    "")
+    "${BigfootDependencies}")
+
+bigfoot_setup_dependencies("Tests/Bigfoot")

Bigfoot/Tests/Utils/Caster.cpp

@@ -99,23 +99,4 @@ TEST_F(CasterFixture, ObjectCast)
     const Parent& parent = BIGFOOT_OBJECT_CAST(Parent, m_b);
     EXPECT_EQ(parent.GetParentValue(), 34);
 }
-
-/****************************************************************************************/
-
-TEST_F(CasterFixture, NumericCast)
-{
-    const std::uint32_t a = 128;
-    const std::uint8_t b = BIGFOOT_NUMERIC_CAST(std::uint8_t, a);
-    EXPECT_EQ(a, b);
-}
-
-/****************************************************************************************/
-
-#ifdef BIGFOOT_NOT_OPTIMIZED
-TEST_F(CasterFixture, NumericCast_ShouldAssertIfWeLoseDataDuringTheCast)
-{
-    const std::uint32_t a = 1000;
-    EXPECT_DEATH(BIGFOOT_NUMERIC_CAST(std::uint8_t, a), "");
-}
-#endif
 }   // namespace Bigfoot

CI/templates.yml

@@ -1,121 +0,0 @@
-.Build:
-  variables:
-    BUILD_TYPE: 'Release'
-    CCACHE_BASEDIR: $CI_PROJECT_DIR
-    CCACHE_DIR: $CI_PROJECT_DIR/ccache
-    CCACHE_COMPILERCHECK: "content"
-  image: registry.gitlab.com/bigfootdev/docker/linuxbigfootbuilder:main
-  stage: build
-  before_script:
-    - ccache --zero-stats
-  script:
-    - conan install . --deployer=full_deploy --deployer-folder=build --remote=bigfootpackages -pr:h=clang -pr:b=clang  --build=missing -s build_type=$BUILD_TYPE -o bigfoot/*:unity_build=False -o bigfoot/*:build_tests=True -o bigfoot/*:sample_app=True -o bigfoot/*:tracy=False -o bigfoot/*:build_tools=True -o bigfoot/*:vulkan=True -o bigfoot/*:build_benchmarks=True -o bigfoot/*:build_benchmarks_lto=True -o bigfoot/*:render_doc=True
-    - cmake -S . -B ./build/$BUILD_TYPE --toolchain ./build/$BUILD_TYPE/generators/conan_toolchain.cmake -DCMAKE_BUILD_TYPE=$BUILD_TYPE -G "Ninja"
-    - cmake --build build/$BUILD_TYPE --parallel $(nproc)
-  after_script:
-    - ccache --show-stats
-  dependencies: []
-  artifacts:
-    when: always
-    name: Build$BUILD_TYPE
-    paths:
-      - build/$BUILD_TYPE
-    expire_in: 1 week
-  cache:
-    - key: "$CI_JOB_NAME"
-      paths:
-        - $CCACHE_DIR
-  tags:
-    - linux
-    - c++
-    - bigfootdev
-
-.BuildUnity:
-  variables:
-    BUILD_TYPE: 'Release'
-    CCACHE_BASEDIR: $CI_PROJECT_DIR
-    CCACHE_DIR: $CI_PROJECT_DIR/ccache
-    CCACHE_COMPILERCHECK: "content"
-  image: registry.gitlab.com/bigfootdev/docker/linuxbigfootbuilder:main
-  stage: build-unity
-  before_script:
-    - ccache --zero-stats
-  script:
-    - conan install . --deployer=full_deploy --deployer-folder=build --remote=bigfootpackages -pr:h=clang -pr:b=clang  --build=missing -s build_type=$BUILD_TYPE -o bigfoot/*:unity_build=True -o bigfoot/*:build_tests=True -o bigfoot/*:sample_app=True -o bigfoot/*:tracy=False -o bigfoot/*:build_tools=True -o bigfoot/*:vulkan=True -o bigfoot/*:build_benchmarks=True -o bigfoot/*:build_benchmarks_lto=True -o bigfoot/*:render_doc=True
-    - cmake -S . -B ./build/$BUILD_TYPE --toolchain ./build/$BUILD_TYPE/generators/conan_toolchain.cmake -DCMAKE_BUILD_TYPE=$BUILD_TYPE -G "Ninja"
-    - cmake --build build/$BUILD_TYPE --parallel $(nproc)
-  after_script:
-    - ccache --show-stats
-  dependencies: []
-  artifacts:
-    when: always
-    name: Build$BUILD_TYPE
-    paths:
-      - build/$BUILD_TYPE
-    expire_in: 1 week
-  cache:
-    - key: "$CI_JOB_NAME"
-      paths:
-        - $CCACHE_DIR
-  tags:
-    - linux
-    - c++
-    - bigfootdev
-
-.UnitTests:
-  variables:
-    BUILD_TYPE: 'Release'
-  image: registry.gitlab.com/bigfootdev/docker/linuxbigfootbuilder:main
-  stage: unit-tests
-  script:
-    - cd ./build/$BUILD_TYPE
-    - xvfb-run ctest . --output-on-failure
-  artifacts:
-    when: always
-    name: Test$BUILD_TYPE
-    paths:
-      - build/$BUILD_TYPE
-    reports:
-      junit: ./build/$BUILD_TYPE/TestResults/*.xml
-  tags:
-    - linux
-    - c++
-    - bigfootdev
-
-.SonarCloud:
-  variables:
-    CCACHE_BASEDIR: $CI_PROJECT_DIR
-    CCACHE_DIR: $CI_PROJECT_DIR/ccache
-    CCACHE_COMPILERCHECK: "content"
-  image: registry.gitlab.com/bigfootdev/docker/linuxbigfootcoveragebuilder:main
-  stage: sonar
-  before_script:
-    - ccache --zero-stats
-    - curl -sSLo ./sonar-scanner.zip 'https://binaries.sonarsource.com/Distribution/sonar-scanner-cli/sonar-scanner-cli-7.2.0.5079-linux-x64.zip'
-    - unzip -o sonar-scanner.zip
-    - mv sonar-scanner-7.2.0.5079-linux-x64 sonar-scanner
-    - curl -sSLo ./build-wrapper-linux-x86.zip "${SONAR_HOST_URL}/static/cpp/build-wrapper-linux-x86.zip"
-    - unzip -oj build-wrapper-linux-x86.zip -d ./build-wrapper
-  script:
-    - conan install . --deployer=full_deploy --deployer-folder=build --remote=bigfootpackages -pr:h=gcc_coverage -pr:b=gcc_coverage --build=missing -s build_type=Debug -o bigfoot/*:unity_build=False -o bigfoot/*:build_tests=True -o bigfoot/*:sample_app=False -o bigfoot/*:tracy=False -o bigfoot/*:build_tools=True -o bigfoot/*:vulkan=True -o bigfoot/*:build_benchmarks=False -o bigfoot/*:build_benchmarks_lto=False -o bigfoot/*:render_doc=False
-    - cmake -S . -B ./build/Debug --toolchain ./build/Debug/generators/conan_toolchain.cmake -DCMAKE_BUILD_TYPE=Debug -G "Ninja"
-    - ./build-wrapper/build-wrapper-linux-x86-64 --out-dir bw-output cmake --build ./build/Debug --parallel $(nproc)
-    - chmod +x sonarqube.sh && xvfb-run ./sonarqube.sh
-    - ./sonar-scanner/bin/sonar-scanner -Dsonar.host.url="${SONAR_HOST_URL}" -Dsonar.token="${SONAR_BIGFOOT2_TOKEN}" -Dsonar.cfamily.compile-commands=bw-output/compile_commands.json -Dsonar.coverageReportPaths=SonarqubeResult/CoverageReport/coverage.xml -Dsonar.cfamily.cppunit.reportsPath=SonarqubeResult/UnitTests/Merged/CPPUnit
-  after_script:
-    - ccache --show-stats
-  artifacts:
-    when: always
-    name: BuildAndCoverage
-    paths:
-      - build/Debug
-      - SonarqubeResult
-    expire_in: 1 week
-  cache:
-    - key: "$CI_JOB_NAME"
-      paths:
-        - $CCACHE_DIR
-  tags:
-    - linux
-    - c++
-    - bigfootdev

CMake/FindDependencies.cmake

@@ -8,20 +8,18 @@ endif()
 find_package(EASTL REQUIRED)
 find_package(unordered_dense REQUIRED)
 find_package(mimalloc REQUIRED)
-find_package(magic_enum REQUIRED)
 find_package(stduuid REQUIRED)
 find_package(SQLite3 REQUIRED)
 find_package(CLI11 REQUIRED)
-find_package(xxHash REQUIRED)
+find_package(rapidhash REQUIRED)
 find_package(effolkronium_random REQUIRED)
-find_package(zeus_expected REQUIRED)
 find_package(flatbuffers CONFIG REQUIRED)
 
 if(TRACY)
     find_package(Tracy REQUIRED)
 endif()
 
-if(${is_multi_config})
+if(${IS_MULTI_CONFIG})
     find_package(quill REQUIRED)
     find_package(cpptrace REQUIRED)
 elseif(${CMAKE_BUILD_TYPE} STREQUAL "Debug" OR ${CMAKE_BUILD_TYPE} STREQUAL "RelWithDebInfo")
@@ -36,7 +34,7 @@ find_package(imgui REQUIRED)
 
 if(VULKAN)
     find_package(VulkanHeaders REQUIRED)
-    if(${is_multi_config})
+    if(${IS_MULTI_CONFIG})
         find_package(vulkan-validationlayers REQUIRED)
     elseif(${CMAKE_BUILD_TYPE} STREQUAL "Debug" OR ${CMAKE_BUILD_TYPE} STREQUAL "RelWithDebInfo")
         find_package(vulkan-validationlayers REQUIRED)

CMake/Package.cmake

@@ -1,9 +1,11 @@
-function(bigfoot_create_package_lib PackageName PackagePublicDependencies PackagePrivateDependencies PackageBigfootPublicDependencies PackageBigfootPrivateDependencies ParentFolder)
+function(bigfoot_create_package_lib PackagePublicDependencies PackagePrivateDependencies PackageBigfootPublicDependencies PackageBigfootPrivateDependencies ParentFolder)
-    project(${PackageName})
-    
     add_library(${PROJECT_NAME} STATIC)
     set_target_properties(${PROJECT_NAME} PROPERTIES LINKER_LANGUAGE CXX)
 
+    target_include_directories(${PROJECT_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/Include)
+
+    bigfoot_compile_flatbuffers("${PackageBigfootPublicDependencies}")
+
     # collect sources (reconfigure when files are added/removed)
     file(GLOB_RECURSE _BF_SOURCES
          CONFIGURE_DEPENDS
@@ -20,33 +22,25 @@ function(bigfoot_create_package_lib PackageName PackagePublicDependencies Packag
             ${_BF_SOURCES}
     )
 
-    target_include_directories(${PROJECT_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/Include)
+    target_link_libraries(${PROJECT_NAME} PUBLIC unordered_dense::unordered_dense EASTL::EASTL flatbuffers::flatbuffers rapidhash::rapidhash)
+    target_link_libraries(${PROJECT_NAME} PRIVATE ${CMAKE_DL_LIBS})
 
     target_link_libraries(${PROJECT_NAME} PUBLIC ${PackagePublicDependencies})
     target_link_libraries(${PROJECT_NAME} PRIVATE ${PackagePrivateDependencies})
-    target_link_libraries(${PROJECT_NAME} PUBLIC "$<LINK_LIBRARY:WHOLE_ARCHIVE,${PackageBigfootPublicDependencies}>")
+    target_link_libraries(${PROJECT_NAME} PUBLIC $<LINK_LIBRARY:WHOLE_ARCHIVE,${PackageBigfootPublicDependencies}>)
-    target_link_libraries(${PROJECT_NAME} PRIVATE "$<LINK_LIBRARY:WHOLE_ARCHIVE,${PackageBigfootPrivateDependencies}>")
+    target_link_libraries(${PROJECT_NAME} PRIVATE $<LINK_LIBRARY:WHOLE_ARCHIVE,${PackageBigfootPrivateDependencies}>)
-    target_link_libraries(${PROJECT_NAME} PRIVATE ${CMAKE_DL_LIBS})
-
-    target_link_options(${PROJECT_NAME} PRIVATE
-        $<$<CXX_COMPILER_ID:MSVC>:/INCREMENTAL:NO>)
-
-    target_compile_options(${PROJECT_NAME} PRIVATE
-        $<$<CXX_COMPILER_ID:MSVC>:/W4 /WX /D_HAS_EXCEPTIONS=0 /GR- /Zc:__cplusplus /fp:fast>
-        $<$<NOT:$<CXX_COMPILER_ID:MSVC>>:-Wall -Wextra -Wpedantic -Werror -fno-exceptions -fno-rtti -ffast-math -fno-strict-aliasing>)
 
     source_group(TREE ${CMAKE_CURRENT_SOURCE_DIR} PREFIX Src FILES ${_BF_SOURCES})
 
     set_target_properties(${PROJECT_NAME} PROPERTIES FOLDER Bigfoot/${ParentFolder})
-    set_target_properties(${PROJECT_NAME} PROPERTIES UNITY_BUILD ${UNITY_BUILD})
 endfunction()
 
-function(bigfoot_create_package_tests PackageName ParentFolder)
+function(bigfoot_create_package_tests ParentFolder BigfootDependencies)
-    project(${PackageName}Tests)
-
     add_executable(${PROJECT_NAME})
     set_target_properties(${PROJECT_NAME} PROPERTIES LINKER_LANGUAGE CXX)
 
+    bigfoot_compile_flatbuffers("${BigfootDependencies}")
+
     file(GLOB_RECURSE _BF_TEST_SOURCES
          CONFIGURE_DEPENDS
          ${CMAKE_CURRENT_SOURCE_DIR}/*.h
@@ -63,23 +57,37 @@ function(bigfoot_create_package_tests PackageName ParentFolder)
 
     target_include_directories(${PROJECT_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/Include)
 
-    target_link_libraries(${PROJECT_NAME} PRIVATE "$<LINK_LIBRARY:WHOLE_ARCHIVE,${PackageName}>")
+    target_link_libraries(${PROJECT_NAME} PRIVATE $<LINK_LIBRARY:WHOLE_ARCHIVE,${PackageName}>)
     target_link_libraries(${PROJECT_NAME} PRIVATE gtest::gtest)
 
-    target_link_options(${PROJECT_NAME} PRIVATE
-        $<$<CXX_COMPILER_ID:MSVC>:/INCREMENTAL:NO>)
-
-    target_compile_options(${PROJECT_NAME} PRIVATE
-        $<$<CXX_COMPILER_ID:MSVC>:/W4 /WX /D_HAS_EXCEPTIONS=0 /GR- /Zc:__cplusplus /fp:fast>
-        $<$<NOT:$<CXX_COMPILER_ID:MSVC>>:-Wall -Wextra -Wpedantic -Werror -fno-exceptions -fno-rtti -ffast-math -fno-strict-aliasing>)
-
     include(GoogleTest)
     gtest_discover_tests(${PROJECT_NAME} XML_OUTPUT_DIR ${CMAKE_BINARY_DIR}/TestResults/)
 
     source_group(TREE ${CMAKE_CURRENT_SOURCE_DIR} PREFIX Src/ FILES ${_BF_TEST_SOURCES})
 
     set_target_properties(${PROJECT_NAME} PROPERTIES FOLDER Tests/Bigfoot/${ParentFolder})
-    set_target_properties(${PROJECT_NAME} PROPERTIES UNITY_BUILD ${UNITY_BUILD})
 
-    bigfoot_setup_dependencies(${PROJECT_NAME} "Tests/Bigfoot")
+    ##################COPY FIXTURE FOLDER###################
+
+    if(NOT EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/Fixture)
+        file(MAKE_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/Fixture)
+    endif()
+
+    # Track all fixture files
+    file(GLOB_RECURSE FIXTURE_FILES
+            CONFIGURE_DEPENDS
+            ${CMAKE_CURRENT_SOURCE_DIR}/Fixture/*
+    )
+
+    add_custom_target(${PROJECT_NAME}Fixture
+            COMMAND ${CMAKE_COMMAND} -E remove_directory $<TARGET_FILE_DIR:${PROJECT_NAME}>/Fixture
+            COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_CURRENT_SOURCE_DIR}/Fixture $<TARGET_FILE_DIR:${PROJECT_NAME}>/Fixture
+            DEPENDS ${FIXTURE_FILES}
+            COMMENT "Copying Fixture folder for ${PROJECT_NAME}"
+    )
+
+    add_dependencies(${PROJECT_NAME} ${PROJECT_NAME}Fixture)
+
+    set_target_properties(${PROJECT_NAME}Fixture PROPERTIES FOLDER UtilityTargets/Tests/Bigfoot/${ParentFolder})
+
 endfunction()

CMake/Utils.cmake

@@ -1,14 +1,14 @@
-function(bigfoot_create_logger PackageName)
+function(bigfoot_create_logger)
-    set(LOGGER_FILENAME ${PackageName}Logger)
+    set(LOGGER_FILENAME ${PROJECT_NAME}Logger)
-    string(TOUPPER ${PackageName}_Logger LOGGER_NAME)
+    string(TOUPPER ${PROJECT_NAME}_Logger LOGGER_NAME)
     string(TOUPPER ${LOGGER_FILENAME} LOGGER_FILENAME_UPPER)
-    configure_file( ${CMAKE_SOURCE_DIR}/Bigfoot/Sources/Utils/Include/Utils/TargetLogger.generated.hpp.in
+    configure_file( ${CMAKE_SOURCE_DIR}/Bigfoot/Sources/System/Include/System/Log/TargetLogger_generated.hpp.in
-                    ${CMAKE_CURRENT_SOURCE_DIR}/Include/${PackageName}/${LOGGER_FILENAME}.generated.hpp
+                    ${CMAKE_CURRENT_SOURCE_DIR}/Include/${PROJECT_NAME}/${LOGGER_FILENAME}_generated.hpp
                     @ONLY)
 endfunction()
 
-function(bigfoot_create_bigfile PackageName ParentFolder)
+function(bigfoot_create_bigfile ParentFolder)
-    set(OUTPUT_PATH_BIGFILE "${CMAKE_CURRENT_BINARY_DIR}/${PackageName}-bigfile.db")
+    set(OUTPUT_PATH_BIGFILE "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/${PROJECT_NAME}-bigfile.db")
     get_filename_component(OUTPUT_PATH_BIGFILE_ABSOLUTE ${OUTPUT_PATH_BIGFILE} ABSOLUTE)
     get_filename_component(OUTPUT_PATH_BIGFILE_DIRECTORY ${OUTPUT_PATH_BIGFILE_ABSOLUTE} DIRECTORY)
 
@@ -16,28 +16,47 @@ function(bigfoot_create_bigfile PackageName ParentFolder)
         OUTPUT ${OUTPUT_PATH_BIGFILE_ABSOLUTE}.bftimestamp ${OUTPUT_PATH_BIGFILE_ABSOLUTE}
         DEPENDS ${CMAKE_SOURCE_DIR}/Bigfoot/Sources/Engine/BigFile/BigFileSchema.sql
         COMMAND ${CMAKE_COMMAND} -E make_directory ${OUTPUT_PATH_BIGFILE_DIRECTORY}
-        COMMAND sqlite3 ${OUTPUT_PATH_BIGFILE_ABSOLUTE} < ${CMAKE_SOURCE_DIR}/Bigfoot/Sources/Engine/BigFile/BigFileSchema.sql
+        COMMAND ${SQLITE3_EXECUTABLE} ${OUTPUT_PATH_BIGFILE_ABSOLUTE} < ${CMAKE_SOURCE_DIR}/Bigfoot/Sources/Engine/BigFile/BigFileSchema.sql
         COMMAND ${CMAKE_COMMAND} -E touch ${OUTPUT_PATH_BIGFILE_ABSOLUTE}.bftimestamp
         COMMENT "Creating Bigfile ${OUTPUT_PATH_BIGFILE_ABSOLUTE}"
     )
     list(APPEND BIGFILE_SOURCES ${OUTPUT_PATH_BIGFILE_ABSOLUTE}.bftimestamp)
 
-    add_custom_target(${PackageName}BigFile ALL DEPENDS ${BIGFILE_SOURCES})
+    add_custom_target(${PROJECT_NAME}BigFile ALL DEPENDS ${BIGFILE_SOURCES})
-    set_target_properties(${PackageName}BigFile PROPERTIES FOLDER UtilityTargets/${ParentFolder})
+    set_target_properties(${PROJECT_NAME}BigFile PROPERTIES FOLDER UtilityTargets/${ParentFolder})
+    add_dependencies(${PROJECT_NAME}BigFile ${PROJECT_NAME})
     
-    target_sources(${PackageName}BigFile PRIVATE ${BIGFILE_SOURCES})
+    target_sources(${PROJECT_NAME}BigFile PRIVATE ${BIGFILE_SOURCES})
 
-    string(TOUPPER ${PackageName} BIGFILE_NAME)
+    string(TOUPPER ${PROJECT_NAME} BIGFILE_NAME)
-    set(BIGFILE_LOCATION ${OUTPUT_PATH_BIGFILE_ABSOLUTE})
+    set(BIGFILE_LOCATION "./${PROJECT_NAME}-bigfile.db")
-    configure_file( ${CMAKE_SOURCE_DIR}/Bigfoot/Sources/Engine/Include/Engine/BigFile/BigFileInfo.generated.hpp.in
+    configure_file( ${CMAKE_SOURCE_DIR}/Bigfoot/Sources/Engine/Include/Engine/BigFile/BigFileInfo_generated.hpp.in
-                    ${CMAKE_CURRENT_SOURCE_DIR}/Include/${PackageName}/BigFileInfo.generated.hpp
+                    ${CMAKE_CURRENT_SOURCE_DIR}/Include/${PROJECT_NAME}/BigFileInfo_generated.hpp
                     @ONLY)
 endfunction()
 
-function(bigfoot_compile_flatbuffers Source IncludeFolders)
+function(bigfoot_compile_flatbuffers BigfootDependencies)
-    file(GLOB_RECURSE SOURCES ${Source}/*.fbs)
+    set(IncludeFolders "")
 
-    foreach(SOURCE_FILE ${SOURCES})
+    get_target_property(CurrentTargetDependencyInclude ${PROJECT_NAME} INCLUDE_DIRECTORIES)
+    if(CurrentTargetDependencyInclude)
+        list(APPEND IncludeFolders ${CurrentTargetDependencyInclude})
+    endif()
+    
+    foreach(Dependency IN LISTS BigfootDependencies)
+        get_target_property(DependencyInclude ${Dependency} INCLUDE_DIRECTORIES)
+        if(DependencyInclude)
+            list(APPEND IncludeFolders ${DependencyInclude})
+        endif()
+    endforeach()
+
+    set(IncludeFlags "")
+    foreach(folder IN LISTS IncludeFolders)
+        list(APPEND IncludeFlags -I "${folder}")
+    endforeach()
+
+    file(GLOB_RECURSE SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/Include/*.fbs")
+    foreach(SOURCE_FILE IN LISTS SOURCES)
         get_filename_component(SOURCE_DIRECTORY ${SOURCE_FILE} DIRECTORY)
 
         set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS ${SOURCE_FILE})
@@ -45,96 +64,82 @@ function(bigfoot_compile_flatbuffers Source IncludeFolders)
         execute_process(
             COMMAND ${FLATBUFFERS_FLATC_EXECUTABLE}
                     --cpp
-            -I ${IncludeFolders}
+                    ${IncludeFlags}
                     --keep-prefix
-            --scoped-enums
+                    --filename-ext "hpp"
-            --gen-name-strings
+                    --reflect-types
-            --gen-object-api
-            --gen-compare
-            --force-empty
-            --no-cpp-direct-copy
-            --cpp-str-flex-ctor
                     --cpp-std c++17
                     --reflect-names
+                    --gen-name-strings
+                    --gen-object-api
+                    --cpp-str-flex-ctor
+                    --no-cpp-direct-copy
+                    --force-empty
+                    --cpp-ptr-type "eastl::unique_ptr"
+                    --cpp-str-type "eastl::string"
+                    --cpp-include "EASTL/unique_ptr.h"
+                    --cpp-include "EASTL/string.h"
                     -o "${SOURCE_DIRECTORY}"
                     "${SOURCE_FILE}" 
         )
     endforeach()
 endfunction()
 
-function(bigfoot_setup_dependencies Target ParentFolder)
+function(bigfoot_setup_dependencies ParentFolder)
     set(CONAN_DEPLOYER_DIR "${CMAKE_SOURCE_DIR}/build/full_deploy/host")
 
     if(EXISTS ${CONAN_DEPLOYER_DIR})
         if(CMAKE_SYSTEM_NAME STREQUAL "Windows")
-            file(GLOB_RECURSE all_binaries ${CONAN_DEPLOYER_DIR}/*mimalloc*.dll)
+            file(GLOB_RECURSE SHARED_BINARIES ${CONAN_DEPLOYER_DIR}/*mimalloc*.dll)
         elseif(CMAKE_SYSTEM_NAME STREQUAL "Linux")
-            file(GLOB_RECURSE all_binaries ${CONAN_DEPLOYER_DIR}/*mimalloc*.so*)
+            file(GLOB_RECURSE SHARED_BINARIES ${CONAN_DEPLOYER_DIR}/*mimalloc*.so*)
         endif()
 
-        if(NOT all_binaries STREQUAL "")
+        if(${IS_MULTI_CONFIG})
-            if(${is_multi_config})
             foreach(CONFIG ${CMAKE_CONFIGURATION_TYPES})   
-                    if(CMAKE_SYSTEM_NAME STREQUAL "Windows")
+                foreach(file ${SHARED_BINARIES})
-                        foreach(file ${all_binaries})
                     if(file MATCHES "/${CONFIG}/")
-                                list(APPEND shared_binaries_${CONFIG} ${file})
+                        list(APPEND SHARED_BINARIES_${CONFIG} ${file})
                     endif()
                 endforeach()
-                    elseif(CMAKE_SYSTEM_NAME STREQUAL "Linux")
-                        foreach(file ${all_binaries})
-                            if(file MATCHES "/${CONFIG}/")
-                                list(APPEND shared_binaries_${CONFIG} ${file})
-                            endif()
-                        endforeach()
-                    endif()
             endforeach()
 
-                add_custom_target(${Target}CopySharedBinaries
+            add_custom_target(${PROJECT_NAME}CopySharedBinaries
-                        ALL DEPENDS all_binaries
+                    ALL DEPENDS SHARED_BINARIES
-                        COMMAND ${CMAKE_COMMAND} -E make_directory $<TARGET_FILE_DIR:${Target}>
+                    COMMAND ${CMAKE_COMMAND} -E make_directory $<TARGET_FILE_DIR:${PROJECT_NAME}>
-                        COMMAND ${CMAKE_COMMAND} -E $<IF:$<CONFIG:Debug>,copy_if_different,true> ${shared_binaries_Debug} $<TARGET_FILE_DIR:${Target}>
+                    COMMAND ${CMAKE_COMMAND} -E $<IF:$<CONFIG:Debug>,copy_if_different,true> ${SHARED_BINARIES_Debug} $<TARGET_FILE_DIR:${PROJECT_NAME}>
-                        COMMAND ${CMAKE_COMMAND} -E $<IF:$<CONFIG:Release>,copy_if_different,true> ${shared_binaries_Release} $<TARGET_FILE_DIR:${Target}>
+                    COMMAND ${CMAKE_COMMAND} -E $<IF:$<CONFIG:Release>,copy_if_different,true> ${SHARED_BINARIES_Release} $<TARGET_FILE_DIR:${PROJECT_NAME}>
-                        COMMAND ${CMAKE_COMMAND} -E $<IF:$<CONFIG:RelWithDebInfo>,copy_if_different,true> ${shared_binaries_RelWithDebInfo} $<TARGET_FILE_DIR:${Target}>
+                    COMMAND ${CMAKE_COMMAND} -E $<IF:$<CONFIG:RelWithDebInfo>,copy_if_different,true> ${SHARED_BINARIES_RelWithDebInfo} $<TARGET_FILE_DIR:${PROJECT_NAME}>
-                        COMMENT "Copy shared binaries"
+                    COMMENT "Copy shared binaries for ${PROJECT_NAME}"
             )
-                add_dependencies(${Target} ${Target}CopySharedBinaries)
+            add_dependencies(${PROJECT_NAME} ${PROJECT_NAME}CopySharedBinaries)
-                set_target_properties(${Target}CopySharedBinaries PROPERTIES FOLDER UtilityTargets/${ParentFolder})
+            set_target_properties(${PROJECT_NAME}CopySharedBinaries PROPERTIES FOLDER UtilityTargets/${ParentFolder})
 
         else()
-                if(CMAKE_SYSTEM_NAME STREQUAL "Windows")
+            foreach(file ${SHARED_BINARIES})
-                    foreach(file ${all_binaries})
                 if(file MATCHES "/${CMAKE_BUILD_TYPE}/")
-                            list(APPEND shared_binaries_${CMAKE_BUILD_TYPE} ${file})
+                    list(APPEND SHARED_BINARIES_${CMAKE_BUILD_TYPE} ${file})
                 endif()
             endforeach()
-                elseif(CMAKE_SYSTEM_NAME STREQUAL "Linux")
-                    foreach(file ${all_binaries})
-                        if(file MATCHES "/${CMAKE_BUILD_TYPE}/")
-                            list(APPEND shared_binaries_${CMAKE_BUILD_TYPE} ${file})
-                        endif()
-                    endforeach()
-                endif()
 
-                add_custom_target(${Target}CopySharedBinaries ALL
+            add_custom_target(${PROJECT_NAME}CopySharedBinaries ALL
-                        DEPENDS ${shared_binaries_${CMAKE_BUILD_TYPE}}
+                    DEPENDS ${SHARED_BINARIES_${CMAKE_BUILD_TYPE}}
-                        COMMAND ${CMAKE_COMMAND} -E make_directory $<TARGET_FILE_DIR:${Target}>
+                    COMMAND ${CMAKE_COMMAND} -E make_directory $<TARGET_FILE_DIR:${PROJECT_NAME}>
-                        COMMAND ${CMAKE_COMMAND} -E copy_if_different ${shared_binaries_${CMAKE_BUILD_TYPE}} $<TARGET_FILE_DIR:${Target}>
+                    COMMAND ${CMAKE_COMMAND} -E copy_if_different ${SHARED_BINARIES_${CMAKE_BUILD_TYPE}} $<TARGET_FILE_DIR:${PROJECT_NAME}>
-                        COMMENT "Copy shared binaries"
+                    COMMENT "Copy shared binaries for ${PROJECT_NAME}"
             )
-                add_dependencies(${Target} ${Target}CopySharedBinaries)
+            add_dependencies(${PROJECT_NAME} ${PROJECT_NAME}CopySharedBinaries)
-                set_target_properties(${Target}CopySharedBinaries PROPERTIES FOLDER UtilityTargets/${ParentFolder})
+            set_target_properties(${PROJECT_NAME}CopySharedBinaries PROPERTIES FOLDER UtilityTargets/${ParentFolder})
-            endif()
         endif()
     endif()
 
     if(CMAKE_SYSTEM_NAME STREQUAL "Windows")
-        add_custom_command(
+        add_custom_target(${PROJECT_NAME}PatchMinject ALL
-                TARGET ${Target}
+            COMMAND ${MINJECT_EXECUTABLE} -i -f $<TARGET_FILE:${PROJECT_NAME}>
-                POST_BUILD
+            COMMENT "Patching ${PROJECT_NAME} to ensure mimalloc dynamic override"
-                COMMAND ${CMAKE_SOURCE_DIR}/Vendor/Tools/Mimalloc2.2.4/minject.exe -i -f $<TARGET_FILE:${Target}>
-                COMMENT "Patching ${Target} to ensure mimalloc dynamic override"
         )
+        add_dependencies(${PROJECT_NAME}PatchMinject ${PROJECT_NAME})
+        set_target_properties(${PROJECT_NAME}PatchMinject PROPERTIES FOLDER "UtilityTargets/${ParentFolder}")
     endif()
 
 endfunction()

CMakeLists.txt

@@ -1,5 +1,7 @@
 cmake_minimum_required(VERSION 3.24)
 
+string(REPLACE "/EHsc" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+
 project(Bigfoot VERSION 0.1.0
                 DESCRIPTION "The Bigfoot engine"
                 LANGUAGES CXX)
@@ -9,17 +11,14 @@ set(CMAKE_CXX_STANDARD_REQUIRED True)
 
 set(CMAKE_POLICY_DEFAULT_CMP0077 NEW)
 
-get_property(is_multi_config GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
+get_property(IS_MULTI_CONFIG GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
 set(CMAKE_CONFIGURATION_TYPES "Release;RelWithDebInfo;Debug" CACHE STRING "" FORCE)
 
 option(BUILD_TESTS OFF)
-option(SAMPLE_APP OFF)
 option(TRACY ON)
-option(UNITY_BUILD ON)
 option(BUILD_TOOLS ON)
 option(VULKAN ON)
 option(BUILD_BENCHMARKS OFF)
-option(RENDER_DOC ON)
 
 set(AUTO_GENERATED_COMMENT "// AUTO-GENERATED DO NOT TOUCH")
 
@@ -27,12 +26,9 @@ include(${CMAKE_SOURCE_DIR}/CMake/FindDependencies.cmake)
 include(${CMAKE_SOURCE_DIR}/CMake/Utils.cmake)
 include(${CMAKE_SOURCE_DIR}/CMake/Package.cmake)
 
-find_program(CCACHE_PROGRAM ccache)
-if(CCACHE_PROGRAM)
-    set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE "${CCACHE_PROGRAM}")
-endif()
-
 find_program(FLATBUFFERS_FLATC_EXECUTABLE NAMES flatc)
+find_program(SQLITE3_EXECUTABLE NAMES sqlite3)
+find_program(MINJECT_EXECUTABLE NAMES minject)
 
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 set(CMAKE_OPTIMIZE_DEPENDENCIES 1)
@@ -45,13 +41,6 @@ add_compile_definitions(
     $<$<CONFIG:Release>:BIGFOOT_OPTIMIZED>
     $<$<CONFIG:Debug,RelWithDebInfo>:BIGFOOT_NOT_OPTIMIZED>)
 
-if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
-    add_compile_definitions(
-            $<$<CONFIG:RelWithDebInfo>:_LIBCPP_HARDENING_MODE=_LIBCPP_HARDENING_MODE_EXTENSIVE>
-            $<$<CONFIG:Debug>:_LIBCPP_HARDENING_MODE=_LIBCPP_HARDENING_MODE_DEBUG>)
-endif()
-#TODO: MSVC equivalent
-
 if(BUILD_TESTS)
     enable_testing()
 endif()

README.md

@@ -1,21 +1,3 @@
-
-<div align="center">
-
-[![Maintainability Rating](https://sonarcloud.io/api/project_badges/measure?project=bigfootdev_bigfoot&metric=sqale_rating&token=a71406a36f0a21eca9d5ef489c7b2e6a362c2627)](https://sonarcloud.io/summary/new_code?id=bigfootdev_bigfoot)
-[![Reliability Rating](https://sonarcloud.io/api/project_badges/measure?project=bigfootdev_bigfoot&metric=reliability_rating&token=a71406a36f0a21eca9d5ef489c7b2e6a362c2627)](https://sonarcloud.io/summary/new_code?id=bigfootdev_bigfoot)
-[![Security Rating](https://sonarcloud.io/api/project_badges/measure?project=bigfootdev_bigfoot&metric=security_rating&token=a71406a36f0a21eca9d5ef489c7b2e6a362c2627)](https://sonarcloud.io/summary/new_code?id=bigfootdev_bigfoot)
-[![Coverage](https://sonarcloud.io/api/project_badges/measure?project=bigfootdev_bigfoot&metric=coverage&token=a71406a36f0a21eca9d5ef489c7b2e6a362c2627)](https://sonarcloud.io/summary/new_code?id=bigfootdev_bigfoot)
-[![Bugs](https://sonarcloud.io/api/project_badges/measure?project=bigfootdev_bigfoot&metric=bugs&token=a71406a36f0a21eca9d5ef489c7b2e6a362c2627)](https://sonarcloud.io/summary/new_code?id=bigfootdev_bigfoot)
-[![Code Smells](https://sonarcloud.io/api/project_badges/measure?project=bigfootdev_bigfoot&metric=code_smells&token=a71406a36f0a21eca9d5ef489c7b2e6a362c2627)](https://sonarcloud.io/summary/new_code?id=bigfootdev_bigfoot)
-[![Vulnerabilities](https://sonarcloud.io/api/project_badges/measure?project=bigfootdev_bigfoot&metric=vulnerabilities&token=a71406a36f0a21eca9d5ef489c7b2e6a362c2627)](https://sonarcloud.io/summary/new_code?id=bigfootdev_bigfoot)
-[![Technical Debt](https://sonarcloud.io/api/project_badges/measure?project=bigfootdev_bigfoot&metric=sqale_index&token=a71406a36f0a21eca9d5ef489c7b2e6a362c2627)](https://sonarcloud.io/summary/new_code?id=bigfootdev_bigfoot)
-[![Lines of Code](https://sonarcloud.io/api/project_badges/measure?project=bigfootdev_bigfoot&metric=ncloc&token=a71406a36f0a21eca9d5ef489c7b2e6a362c2627)](https://sonarcloud.io/summary/new_code?id=bigfootdev_bigfoot)
-[![Duplicated Lines (%)](https://sonarcloud.io/api/project_badges/measure?project=bigfootdev_bigfoot&metric=duplicated_lines_density&token=a71406a36f0a21eca9d5ef489c7b2e6a362c2627)](https://sonarcloud.io/summary/new_code?id=bigfootdev_bigfoot)
-
-[![Quality gate](https://sonarcloud.io/api/project_badges/quality_gate?project=bigfootdev_bigfoot&token=a71406a36f0a21eca9d5ef489c7b2e6a362c2627)](https://sonarcloud.io/summary/new_code?id=bigfootdev_bigfoot)
-
-</div>
-
 # Bigfoot
 
 A multiplatform 3D game engine

conanfile.py

@@ -7,7 +7,7 @@ required_conan_version = ">=1.33.0"
 
 class Bigfoot(ConanFile):
     name = "bigfoot"
-    homepage = "https://gitlab.com/bigfootdev/bigfoot"
+    homepage = "https://git.romainboullard.com/BigfootDev/Bigfoot"
     description = "Bigfoot is a 3D game engine written in C++"
     topics = ("game engine", "3d")
     license = "MIT"
@@ -18,28 +18,20 @@ class Bigfoot(ConanFile):
     options = {
         "shared": [True, False],
         "fPIC": [True, False],
-        "unity_build": [True, False],
         "build_tests": [True, False],
-        "sample_app": [True, False],
         "tracy": [True, False],
         "build_tools": [True, False],
         "vulkan": [True, False],
         "build_benchmarks": [True, False],
-        "build_benchmarks_lto": [True, False],
-        "render_doc": [True, False]
         }
     default_options = {
         "shared": False,
         "fPIC": True,
-        "unity_build": True,
         "build_tests": False,
-        "sample_app": False,
         "tracy": False,
         "build_tools": True,
         "vulkan": True,
         "build_benchmarks": False,
-        "build_benchmarks_lto": True,
-        "render_doc": False
         }
     
     generators = "CMakeDeps"
@@ -67,52 +59,49 @@ class Bigfoot(ConanFile):
 
         if(self.options.build_benchmarks):
             self.options["benchmark"].enable_exceptions = False
-            if(self.options.build_benchmarks_lto):
             self.options["benchmark"].enable_lto = True
 
     def requirements(self):
-        self.requires("eastl/3.27.00", transitive_headers=True)
+        self.requires("eastl/3.27.01@bigfootdev/main", transitive_headers=True)
-        self.requires("unordered_dense/4.7.0", transitive_headers=True)
+        self.requires("unordered_dense/4.8.1@bigfootdev/main", transitive_headers=True)
-        self.requires("mimalloc/2.2.4", transitive_headers=True)
+        self.requires("mimalloc/3.1.5@bigfootdev/main", transitive_headers=True)
-        self.requires("magic_enum/0.9.7", transitive_headers=True)
         self.requires("stduuid/1.2.3", transitive_headers=True)
-        self.requires("sqlite3/3.50.4", transitive_headers=True)
+        self.requires("sqlite3/3.51.0@bigfootdev/main", transitive_headers=True)
-        self.requires("cli11/2.5.0")
+        self.requires("cli11/2.6.0")
-        self.requires("xxhash/0.8.3", transitive_headers=True)
+        self.requires("rapidhash/3.0@bigfootdev/main", transitive_headers=True)
         self.requires("effolkronium-random/1.5.0", transitive_headers=True)
-        self.requires("zeus_expected/1.3.0", transitive_headers=True)
+        self.requires("flatbuffers/25.12.19@bigfootdev/main", transitive_headers=True)
-        self.requires("flatbuffers/25.9.23", transitive_headers=True)
 
         if(self.settings.build_type == "RelWithDebInfo" or self.settings.build_type == "Debug"):
-            self.requires("quill/10.0.1", transitive_headers=True)
+            self.requires("quill/11.0.2", transitive_headers=True)
             self.requires("cpptrace/1.0.4", transitive_headers=True)
 
         if(self.options.tracy):
             self.requires("tracy/0.12.2", transitive_headers=True)
 
         self.requires("glm/1.0.1", transitive_headers=True)
-        self.requires("lodepng/cci.20250727", transitive_headers=True)
+        self.requires("lodepng/cci.20250727@bigfootdev/main", transitive_headers=True)
-        self.requires("imgui/1.92.4-docking", transitive_headers=True)
+        self.requires("imgui/1.92.5-docking", transitive_headers=True)
 
         if(self.options.vulkan):
             self.requires("vulkan-headers/1.4.313.0")
             if(self.settings.build_type == "RelWithDebInfo" or self.settings.build_type == "Debug"):
-                self.requires("vulkan-validationlayers/1.4.313.0")
+                self.requires("vulkan-validationlayers/1.4.313.0@bigfootdev/main")
-            self.requires("vulkan-memory-allocator/3.3.0")
+            self.requires("vulkan-memory-allocator/3.3.0@bigfootdev/main")
 
-        if(self.options.sample_app or self.options.build_tests or self.options.build_benchmarks):
+        if(self.options.build_tests or self.options.build_benchmarks):
             self.requires("glfw/3.4")
 
         if(self.options.build_tests):
             self.test_requires("gtest/1.17.0")
-            self.test_requires("pixelmatch-cpp17/1.0.3")
+            self.test_requires("pixelmatch-cpp17/1.0.3@bigfootdev/main")
 
         if(self.options.build_tools):
             self.requires("spirv-cross/1.4.313.0")
-            self.requires("shaderc/2025.3")
+            self.requires("shaderc/2025.3@bigfootdev/main")
             self.requires("stb/cci.20240531", override=True)
-            self.requires("assimp/5.4.3")
+            self.requires("assimp/6.0.2")
-            self.requires("meshoptimizer/0.25")
+            self.requires("meshoptimizer/1.0@bigfootdev/main")
             self.requires("libsquish/1.15")
 
         if(self.options.build_benchmarks):
@@ -121,14 +110,11 @@ class Bigfoot(ConanFile):
     def generate(self):
         tc = CMakeToolchain(self)
         
-        tc.variables["UNITY_BUILD"] = self.options.unity_build
         tc.variables["BUILD_TESTS"] = self.options.build_tests
         tc.variables["TRACY"] = self.options.tracy
         tc.variables["BUILD_TOOLS"] = self.options.build_tools
         tc.variables["VULKAN"] = self.options.vulkan
         tc.variables["BUILD_BENCHMARKS"] = self.options.build_benchmarks
-        tc.variables["RENDER_DOC"] = self.options.render_doc
-        tc.variables["SAMPLE_APP"] = self.options.sample_app
 
         tc.generate()
 

format.bat

@@ -1,30 +1,71 @@
 @echo off
-REM Variable that will hold the name of the clang-format command
+SETLOCAL ENABLEDELAYEDEXPANSION
+
+REM =========================
+REM Variables
+REM =========================
 SET FMT=clang-format
+SET MODE=
+SET EXIT_CODE=0
 
-REM Function to format files
+REM =========================
-:format
+REM Parse arguments
-for /r %%f in (*.h *.m *.mm *.c *.cpp) do (
+REM =========================
-    echo %%~nxf | findstr /i "_generated.h$" >nul
+:parse_args
-    if errorlevel 1 (
+IF "%~1"=="" GOTO end_parse_args
-        echo format %%f
+IF "%~1"=="--check" (
-        %FMT% -i "%%f"
+    SET MODE=check
+) ELSE IF "%~1"=="--fix" (
+    SET MODE=fix
+) ELSE (
+    REM Accumulate directories
+    SET DIRS=!DIRS! "%~1"
 )
-)
+SHIFT
-echo ~~~ %1 Done ~~~
+GOTO parse_args
-exit /b
+:end_parse_args
 
-REM Check if argument is provided
+IF "%MODE%"=="" (
-if "%1"=="" (
+    ECHO Usage: %~nx0 --check|--fix <directory> [<directory> ...]
-    echo Please provide a directory as an argument.
+    EXIT /B 1
-    exit /b
 )
 
-REM Check if directory exists
+IF "%DIRS%"=="" (
-if not exist "%1" (
+    ECHO Please provide at least one directory.
-    echo %1 is not a valid directory.
+    EXIT /B 1
-    exit /b
 )
 
-cd %1
+REM =========================
-call :format
+REM Iterate over directories
+REM =========================
+FOR %%D IN (%DIRS%) DO (
+    IF NOT EXIST "%%~D" (
+        ECHO %%~D is not a valid directory.
+        SET EXIT_CODE=1
+        GOTO :continue_dirs
+    )
+
+    REM Recursively find source files
+    FOR /R "%%~D" %%F IN (*.h *.hpp *.c *.cpp *.m *.mm) DO (
+        SET FILE=%%F
+        REM Skip *_generated* files
+        ECHO !FILE! | FINDSTR /I "_generated" >nul
+        IF ERRORLEVEL 1 (
+            IF "%MODE%"=="fix" (
+                ECHO Formatting !FILE!
+                %FMT% -i "!FILE!"
+            ) ELSE (
+                ECHO Checking !FILE!
+                %FMT% --dry-run --Werror "!FILE!" 2>nul
+                IF ERRORLEVEL 1 (
+                    REM clang-format will already print diagnostics
+                    SET EXIT_CODE=1
+                )
+            )
+        )
+    )
+
+    :continue_dirs
+)
+
+EXIT /B %EXIT_CODE%

format.sh

@@ -1,31 +1,68 @@
 #!/bin/bash
+set -euo pipefail
 
-# Variable that will hold the name of the clang-format command
 FMT="clang-format"
+MODE=""
+DIRS=()
+EXIT_CODE=0
 
-# Function to format files
+# =========================
-format() {
+# Parse arguments
-    for f in $(find "$1" \( -name '*.h' -or -name '*.m' -or -name '*.mm' -or -name '*.c' -or -name '*.cpp' \)); do
+# =========================
-        # Skip *_generated.h files
+for arg in "$@"; do
-        if [[ "$f" == *_generated.h ]]; then
+    case "$arg" in
+        --check)
+            MODE="check"
+            ;;
+        --fix)
+            MODE="fix"
+            ;;
+        *)
+            DIRS+=("$arg")
+            ;;
+    esac
+done
+
+# Ensure mode is set
+if [[ -z "$MODE" ]]; then
+    echo "Usage: $0 --check|--fix <directory> [<directory> ...]"
+    exit 1
+fi
+
+# Ensure at least one directory
+if [[ ${#DIRS[@]} -eq 0 ]]; then
+    echo "Please provide at least one directory."
+    exit 1
+fi
+
+# =========================
+# Process directories
+# =========================
+for DIR in "${DIRS[@]}"; do
+    if [[ ! -d "$DIR" ]]; then
+        echo "$DIR is not a valid directory."
+        EXIT_CODE=1
         continue
     fi
-        echo "format ${f}"
+
-        ${FMT} -i "${f}"
+    # Find all source files safely (null-separated)
+    while IFS= read -r -d '' FILE; do
+        [[ "$FILE" == *_generated* ]] && continue
+
+        if [[ "$MODE" == "fix" ]]; then
+            echo "Formatting $FILE"
+            "$FMT" -i "$FILE"
+        else
+            echo "Checking $FILE"
+            # Check mode: clang-format diagnostic only
+            if ! "$FMT" --dry-run --Werror "$FILE"; then
+                # clang-format prints: file:line:col: error ...
+                EXIT_CODE=1
+            fi
+        fi
+    done < <(
+        find "$DIR" \( -name '*.h' -o -name '*.hpp' -o -name '*.c' -o -name '*.cpp' -o -name '*.m' -o -name '*.mm' \) -print0
+    )
 done
-    echo "~~~ $1 Done ~~~"
-}
 
-# Check if argument is provided
+exit $EXIT_CODE
-if [ -z "$1" ]; then
-    echo "Please provide a directory as an argument."
-    exit 1
-fi
-
-# Check if directory exists
-if [ ! -d "$1" ]; then
-    echo "$1 is not a valid directory."
-    exit 1
-fi
-
-format "$1"

generate_dependencies.bat

@@ -20,14 +20,14 @@ if "%~1"=="force" (
 )
 
 REM Add the remote
-conan remote add bigfootpackages https://conan.romainboullard.com/artifactory/api/conan/bigfootpackages
+conan remote add bigfootpackages https://conan.romainboullard.com/artifactory/api/conan/BigfootPackages
 
 REM Install the conan configuration
 conan config install https://git.romainboullard.com/BigfootDev/ConanProfiles.git
 
 REM Install dependencies with the specified build option
-conan install . --deployer=full_deploy --remote=bigfootpackages -pr:h=msvc -pr:b=msvc %build_option% -of build -s build_type=Release -o bigfoot/*:unity_build=False -o bigfoot/*:build_tests=True -o bigfoot/*:sample_app=True -o bigfoot/*:tracy=True -o bigfoot/*:build_tools=True -o bigfoot/*:vulkan=True -o bigfoot/*:build_benchmarks=True -o bigfoot/*:build_benchmarks_lto=True -o bigfoot/*:render_doc=True
+conan install . --deployer=full_deploy --remote=bigfootpackages -pr:h=msvc -pr:b=msvc %build_option% -of build -s build_type=Release -o bigfoot/*:build_tests=True -o bigfoot/*:tracy=True -o bigfoot/*:build_tools=True -o bigfoot/*:vulkan=True -o bigfoot/*:build_benchmarks=True
-conan install . --deployer=full_deploy --remote=bigfootpackages -pr:h=msvc -pr:b=msvc %build_option% -of build -s build_type=RelWithDebInfo -o bigfoot/*:unity_build=False -o bigfoot/*:build_tests=True -o bigfoot/*:sample_app=True -o bigfoot/*:tracy=True -o bigfoot/*:build_tools=True -o bigfoot/*:vulkan=True -o bigfoot/*:build_benchmarks=True -o bigfoot/*:build_benchmarks_lto=True -o bigfoot/*:render_doc=True
+conan install . --deployer=full_deploy --remote=bigfootpackages -pr:h=msvcd -pr:b=msvcd %build_option% -of build -s build_type=RelWithDebInfo -o bigfoot/*:build_tests=True -o bigfoot/*:tracy=True -o bigfoot/*:build_tools=True -o bigfoot/*:vulkan=True -o bigfoot/*:build_benchmarks=True
-conan install . --deployer=full_deploy --remote=bigfootpackages -pr:h=msvc -pr:b=msvc %build_option% -of build -s build_type=Debug -o bigfoot/*:unity_build=False -o bigfoot/*:build_tests=True -o bigfoot/*:sample_app=True -o bigfoot/*:tracy=True -o bigfoot/*:build_tools=True -o bigfoot/*:vulkan=True -o bigfoot/*:build_benchmarks=True -o bigfoot/*:build_benchmarks_lto=True -o bigfoot/*:render_doc=True
+conan install . --deployer=full_deploy --remote=bigfootpackages -pr:h=msvcd -pr:b=msvcd %build_option% -of build -s build_type=Debug -o bigfoot/*:build_tests=True -o bigfoot/*:tracy=True -o bigfoot/*:build_tools=True -o bigfoot/*:vulkan=True -o bigfoot/*:build_benchmarks=True
 
 endlocal

generate_dependencies.sh

@@ -7,20 +7,20 @@ if [ -z "$1" ]; then
 fi
 
 # Add the remote
-conan remote add bigfootpackages https://conan.romainboullard.com/artifactory/api/conan/bigfootpackages
+conan remote add bigfootpackages https://conan.romainboullard.com/artifactory/api/conan/BigfootPackages
 
 # Install the conan configuration
 conan config install https://git.romainboullard.com/BigfootDev/ConanProfiles.git
 
 # Set the build option based on the argument
 if [ "$1" == "force" ]; then
-    conan install . --deployer=full_deploy --deployer-folder=build --remote=bigfootpackages -pr:h=clang -pr:b=clang --build='*' -of build -s build_type=Release -o bigfoot/*:unity_build=True -o bigfoot/*:build_tests=True -o bigfoot/*:sample_app=True -o bigfoot/*:tracy=True -o bigfoot/*:build_tools=True -o bigfoot/*:vulkan=True -o bigfoot/*:build_benchmarks=True -o bigfoot/*:build_benchmarks_lto=True -o bigfoot/*:render_doc=True
+    conan install . --deployer=full_deploy --remote=bigfootpackages -pr:h=clang -pr:b=clang --build='*' -of build -s build_type=Release -o bigfoot/*:build_tests=True -o bigfoot/*:tracy=True -o bigfoot/*:build_tools=True -o bigfoot/*:vulkan=True -o bigfoot/*:build_benchmarks=True
-    conan install . --deployer=full_deploy --deployer-folder=build --remote=bigfootpackages -pr:h=clang -pr:b=clang --build='*' -of build -s build_type=RelWithDebInfo -o bigfoot/*:unity_build=True -o bigfoot/*:build_tests=True -o bigfoot/*:sample_app=True -o bigfoot/*:tracy=True -o bigfoot/*:build_tools=True -o bigfoot/*:vulkan=True -o bigfoot/*:build_benchmarks=True -o bigfoot/*:build_benchmarks_lto=True -o bigfoot/*:render_doc=True
+    conan install . --deployer=full_deploy --remote=bigfootpackages -pr:h=clangd -pr:b=clangd --build='*' -of build -s build_type=RelWithDebInfo -o bigfoot/*:build_tests=True -o bigfoot/*:tracy=True -o bigfoot/*:build_tools=True -o bigfoot/*:vulkan=True -o bigfoot/*:build_benchmarks=True
-    conan install . --deployer=full_deploy --deployer-folder=build --remote=bigfootpackages -pr:h=clang -pr:b=clang --build='*' -of build -s build_type=Debug -o bigfoot/*:unity_build=True -o bigfoot/*:build_tests=True -o bigfoot/*:sample_app=True -o bigfoot/*:tracy=True -o bigfoot/*:build_tools=True -o bigfoot/*:vulkan=True -o bigfoot/*:build_benchmarks=True -o bigfoot/*:build_benchmarks_lto=True -o bigfoot/*:render_doc=True
+    conan install . --deployer=full_deploy --remote=bigfootpackages -pr:h=clangd -pr:b=clangd --build='*' -of build -s build_type=Debug -o bigfoot/*:build_tests=True -o bigfoot/*:tracy=True -o bigfoot/*:build_tools=True -o bigfoot/*:vulkan=True -o bigfoot/*:build_benchmarks=True
 elif [ "$1" == "missing" ]; then
-    conan install . --deployer=full_deploy --deployer-folder=build --remote=bigfootpackages -pr:h=clang -pr:b=clang --build=missing -of build -s build_type=Release -o bigfoot/*:unity_build=True -o bigfoot/*:build_tests=True -o bigfoot/*:sample_app=True -o bigfoot/*:tracy=True -o bigfoot/*:build_tools=True -o bigfoot/*:vulkan=True -o bigfoot/*:build_benchmarks=True -o bigfoot/*:build_benchmarks_lto=True -o bigfoot/*:render_doc=True
+    conan install . --deployer=full_deploy --remote=bigfootpackages -pr:h=clang -pr:b=clang --build=missing -of build -s build_type=Release -o bigfoot/*:build_tests=True -o bigfoot/*:tracy=True -o bigfoot/*:build_tools=True -o bigfoot/*:vulkan=True -o bigfoot/*:build_benchmarks=True
-    conan install . --deployer=full_deploy --deployer-folder=build --remote=bigfootpackages -pr:h=clang -pr:b=clang --build=missing -of build -s build_type=RelWithDebInfo -o bigfoot/*:unity_build=True -o bigfoot/*:build_tests=True -o bigfoot/*:sample_app=True -o bigfoot/*:tracy=True -o bigfoot/*:build_tools=True -o bigfoot/*:vulkan=True -o bigfoot/*:build_benchmarks=True -o bigfoot/*:build_benchmarks_lto=True -o bigfoot/*:render_doc=True
+    conan install . --deployer=full_deploy --remote=bigfootpackages -pr:h=clangd -pr:b=clangd --build=missing -of build -s build_type=RelWithDebInfo -o bigfoot/*:build_tests=True -o bigfoot/*:tracy=True -o bigfoot/*:build_tools=True -o bigfoot/*:vulkan=True -o bigfoot/*:build_benchmarks=True
-    conan install . --deployer=full_deploy --deployer-folder=build --remote=bigfootpackages -pr:h=clang -pr:b=clang --build=missing -of build -s build_type=Debug -o bigfoot/*:unity_build=True -o bigfoot/*:build_tests=True -o bigfoot/*:sample_app=True -o bigfoot/*:tracy=True -o bigfoot/*:build_tools=True -o bigfoot/*:vulkan=True -o bigfoot/*:build_benchmarks=True -o bigfoot/*:build_benchmarks_lto=True -o bigfoot/*:render_doc=True
+    conan install . --deployer=full_deploy --remote=bigfootpackages -pr:h=clangd -pr:b=clangd --build=missing -of build -s build_type=Debug -o bigfoot/*:build_tests=True -o bigfoot/*:tracy=True -o bigfoot/*:build_tools=True -o bigfoot/*:vulkan=True -o bigfoot/*:build_benchmarks=True
 else
     echo "Invalid argument: $1"
     echo "Usage: $0 [force|missing]"

sonar-project.properties

@@ -1,10 +0,0 @@
-sonar.projectKey=bigfootdev_bigfoot
-sonar.organization=bigfootdev
-sonar.projectName=Bigfoot
-sonar.projectVersion=0.1.0
-sonar.sources=Bigfoot/Sources
-sonar.tests=Bigfoot/Tests
-sonar.sourceEncoding=UTF-8
-
-sonar.exclusions= \
-    Bigfoot/Sources/Engine/BigFile/BigFileSchema.sql

sonarqube.sh

@@ -1,15 +0,0 @@
-#!/bin/sh
-
-mkdir SonarqubeResult
-
-mkdir SonarqubeResult/UnitTests
-mkdir SonarqubeResult/UnitTests/Merged
-mkdir SonarqubeResult/UnitTests/Merged/CPPUnit
-./build/Debug/Bigfoot/Tests/System/SystemTests --gtest_output="xml:SonarqubeResult/UnitTests/SystemTests.xml"
-./build/Debug/Bigfoot/Tests/Utils/UtilsTests --gtest_output="xml:SonarqubeResult/UnitTests/UtilsTests.xml"
-./build/Debug/Bigfoot/Tests/Engine/EngineTests --gtest_output="xml:SonarqubeResult/UnitTests/EngineTests.xml"
-python3 merge_junit_results.py SonarqubeResult/UnitTests SonarqubeResult/UnitTests/Merged/tests.xml
-python3 convert_junit_to_cppunit.py SonarqubeResult/UnitTests/Merged/tests.xml SonarqubeResult/UnitTests/Merged/CPPUnit/cppunit.xml
-
-mkdir SonarqubeResult/CoverageReport
-gcovr --filter Bigfoot/Sources/ --gcov-ignore-parse-errors negative_hits.warn --exclude-lines-by-pattern '.*ASSERT*.' --sonarqube  SonarqubeResult/CoverageReport/coverage.xml --html-nested SonarqubeResult/CoverageReport/coverage.html