Merge branch 'Development' of https://git.romainboullard.com/BigfootDev/Bigfoot into SonarQube-pass

2026-09-02 12:24:37 +02:00 · 2026-09-02 11:19:24 +02:00 · 2026-09-02 10:19:37 +02:00 · 2026-09-02 01:19:04 +02:00 · 2026-09-02 01:09:50 +02:00 · 2026-09-02 00:54:19 +02:00
216 changed files with 307 additions and 4179 deletions
@@ -121,72 +121,36 @@ SpaceInEmptyBlock: true
 PenaltyBreakAssignment: 200
 KeepEmptyLinesAtTheStartOfBlocks: false
 IncludeCategories:
-  - Regex:           '^<GraphicsCore/.*_generated\.h(pp)?>$'
-    Priority:        16
-  - Regex:           '^<GraphicsVulkan/.*_generated\.h(pp)?>$'
-    Priority:        17
-  - Regex:           '^<GraphicsInterface/.*_generated\.h(pp)?>$'
-    Priority:        18
-  - Regex:           '^<Engine/.*_generated\.h(pp)?>$'
-    Priority:        19
-  - Regex:           '^<System/.*_generated\.h(pp)?>$'
-    Priority:        20
-  - Regex:           '^<Utils/.*_generated\.h(pp)?>$'
-    Priority:        21
-  - Regex:           '^<SasquatchBaker/.*_generated\.h(pp)?>$'
-    Priority:        22
-  - Regex:           '^<EngineTests/.*_generated\.h(pp)?>$'
-    Priority:        23
-  - Regex:           '^<SystemTests/.*_generated\.h(pp)?>$'
-    Priority:        24
-  - Regex:           '^<UtilsTests/.*_generated\.h(pp)?>$'
-    Priority:        25
-  - Regex:           '^<AssetsForTesting/.*_generated\.h(pp)?>$'
-    Priority:        26
-  - Regex:           '^<SasquatchBakerTests/.*_generated\.h(pp)?>$'
-    Priority:        27
-  - Regex:           '^<EngineBenchmarks/.*_generated\.h(pp)?>$'
-    Priority:        28
-  - Regex:           '^<AssetsForBenchmarking/.*_generated\.h(pp)?>$'
-    Priority:        29
-  - Regex:           '^<SasquatchBakerBenchmarks/.*_generated\.h(pp)?>$'
-    Priority:        30
-  - Regex:           '^<GraphicsCore/'
-    Priority:        1
-  - Regex:           '^<GraphicsVulkan/'
-    Priority:        2
-  - Regex:           '^<GraphicsInterface/'
-    Priority:        3
  - Regex:           '^<Engine/'
-    Priority:        4
+    Priority:        1
  - Regex:           '^<System/'
-    Priority:        5
+    Priority:        2
  - Regex:           '^<Utils/'
-    Priority:        6
+    Priority:        3
  - Regex:           '^<SasquatchBaker/'
-    Priority:        7
+    Priority:        4
  - Regex:           '^<EngineTests/'
-    Priority:        8
+    Priority:        5
  - Regex:           '^<SystemTests/'
-    Priority:        9
+    Priority:        6
  - Regex:           '^<UtilsTests/'
-    Priority:        10
+    Priority:        7
  - Regex:           '^<AssetsForTesting/'
-    Priority:        11
+    Priority:        8
  - Regex:           '^<SasquatchBakerTests/'
-    Priority:        12
+    Priority:        9
  - Regex:           '^<EngineBenchmarks/'
-    Priority:        13
+    Priority:        10
  - Regex:           '^<AssetsForBenchmarking/'
-    Priority:        14
+    Priority:        11
  - Regex:           '^<SasquatchBakerBenchmarks/'
-    Priority:        15
+    Priority:        12
  - Regex:           '^<[a-zA-Z0-9_/]+\.h>'
-    Priority:        31
+    Priority:        13
  - Regex:           '^<[a-zA-Z0-9_/]+\.hpp>'
-    Priority:        31
+    Priority:        13
  - Regex:           '^<[a-zA-Z0-9_/]+>'
-    Priority:        32
+    Priority:        14
 MainIncludeChar: AngleBracket
 Macros:
  - 'BIGFOOT_OPTIMIZED_ONLY(x)=x'
@@ -15,16 +15,13 @@ jobs:

    strategy:
      matrix:
-        build_type:
-          - { value: "Debug", profile: "debug" }
-          - { value: "RelWithDebInfo", profile: "relwithdebinfo" }
-          - { value: "Release", profile: "release" }
+        build_type: ["Debug", "RelWithDebInfo", "Release"]
        unity_build: ["ON", "OFF"]
-        conan_profile: ["clang", "clang_asan"]
+        conan_profile: ["./ConanProfiles/host/clang", "./ConanProfiles/host/clang_asan"]
        variant:
          - { value: "True", name: "toolmode" }
          - { value: "False", name: "game" }
-    name: "Build & Test ${{ matrix.build_type.value }} with ${{ matrix.conan_profile }} (Unity Build: ${{ matrix.unity_build }}, Variant: ${{ matrix.variant.name }})"
+    name: "Build & Test ${{ matrix.build_type }} with ${{ matrix.conan_profile }} (Unity Build: ${{ matrix.unity_build }}, Variant: ${{ matrix.variant.name }})"
    steps:
      - name: Install Node.js
        run: apt-get update && apt-get install -y nodejs
@@ -36,17 +33,18 @@ jobs:

      - name: Build
        run: |
-            bash ./generate_bigfoot.sh missing ${{ matrix.build_type.value }} --profile=${{ matrix.conan_profile }} --variant=${{ matrix.variant.name }} --unity=${{ matrix.unity_build }} --tracy=False
-            . ./build-linux-${{ matrix.variant.name }}/build/${{ matrix.build_type.value }}/generators/conanbuild.sh
-            cmake --build build-linux-${{ matrix.variant.name }}/${{ matrix.build_type.value }} --parallel $(nproc)
-            . ./build-linux-${{ matrix.variant.name }}/build/${{ matrix.build_type.value }}/generators/deactivate_conanbuild.sh
+            conan install . --remote=bigfootpackages -pr:h=${{ matrix.conan_profile }} -pr:b=./ConanProfiles/build/clang  --build=missing -s build_type=${{ matrix.build_type }} -o bigfoot/*:build_tests=True -o bigfoot/*:build_benchmarks=True -o bigfoot/*:tracy=False -o bigfoot/*:vulkan=True -o bigfoot/*:toolmode=${{ matrix.variant.value }} -of build-${{ matrix.variant.name }}
+            . ./build-${{ matrix.variant.name }}/build/${{ matrix.build_type }}/generators/conanbuild.sh
+            cmake -S . -B ./build-${{ matrix.variant.name }}/${{ matrix.build_type }} --toolchain ./build-${{ matrix.variant.name }}/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.variant.name }}/${{ matrix.build_type }} --parallel $(nproc)
+            . ./build-${{ matrix.variant.name }}/build/${{ matrix.build_type }}/generators/deactivate_conanbuild.sh

      - name: Unit Tests
        run: |
-            cd ./build-linux-${{ matrix.variant.name }}/${{ matrix.build_type.value }}
-            . ../../build-linux-${{ matrix.variant.name }}/build/${{ matrix.build_type.value }}/generators/conanbuild.sh
-            weston-run ctest . --output-on-failure
-            . ../../build-linux-${{ matrix.variant.name }}/build/${{ matrix.build_type.value }}/generators/deactivate_conanbuild.sh
+            cd ./build-${{ matrix.variant.name }}/${{ matrix.build_type }}
+            . ../../build-${{ matrix.variant.name }}/build/${{ matrix.build_type }}/generators/conanbuild.sh
+            xvfb-run ctest . --output-on-failure
+            . ../../build-${{ matrix.variant.name }}/build/${{ matrix.build_type }}/generators/deactivate_conanbuild.sh

  clang-format:
    runs-on: ubuntu-latest
@@ -42,23 +42,24 @@ jobs:

      - name: Build
        run: |
-            bash ./generate_bigfoot.sh missing Debug --profile=clang_coverage --variant=${{ matrix.variant.name }} --tracy=False
-            . ./build-linux-${{ matrix.variant.name }}/build/Debug/generators/conanbuild.sh
-            cmake --build build-linux-${{ matrix.variant.name }}/Debug --parallel $(nproc)
-            . ./build-linux-${{ matrix.variant.name }}/build/Debug/generators/deactivate_conanbuild.sh
+            conan install . --remote=bigfootpackages -pr:h=./ConanProfiles/host/clang_coverage -pr:b=./ConanProfiles/build/clang  --build=missing -s build_type=Debug -o bigfoot/*:build_tests=True -o bigfoot/*:build_benchmarks=True -o bigfoot/*:tracy=False -o bigfoot/*:toolmode=${{ matrix.variant.value }} -o bigfoot/*:vulkan=True -of build-${{ matrix.variant.name }}
+            . ./build-${{ matrix.variant.name }}/build/Debug/generators/conanbuild.sh
+            cmake -S . -B ./build-${{ matrix.variant.name }}/Debug --toolchain ./build-${{ matrix.variant.name }}/build/Debug/generators/conan_toolchain.cmake -DCMAKE_BUILD_TYPE=Debug -G "Ninja"
+            cmake --build build-${{ matrix.variant.name }}/Debug --parallel $(nproc)
+            . ./build-${{ matrix.variant.name }}/build/Debug/generators/deactivate_conanbuild.sh

      - name: Run tests
        run: |
-            cd ./build-linux-${{ matrix.variant.name }}/Debug
-            . ../../build-linux-${{ matrix.variant.name }}/build/Debug/generators/conanbuild.sh
-            LLVM_PROFILE_FILE="%p.profraw%c" weston-run ctest --output-on-failure
-            . ../../build-linux-${{ matrix.variant.name }}/build/Debug/generators/deactivate_conanbuild.sh
+            cd ./build-${{ matrix.variant.name }}/Debug
+            . ../../build-${{ matrix.variant.name }}/build/Debug/generators/conanbuild.sh
+            LLVM_PROFILE_FILE="%p.profraw%c" xvfb-run ctest --output-on-failure
+            . ../../build-${{ matrix.variant.name }}/build/Debug/generators/deactivate_conanbuild.sh

      - name: Clang-Tidy
-        run: run-clang-tidy -p ./build-linux-${{ matrix.variant.name }}/Debug/ > tidy_result.txt
+        run: run-clang-tidy -p ./build-${{ matrix.variant.name }}/Debug/ > tidy_result.txt

      - name: Infer
-        run: infer run --compilation-database build-linux-${{ matrix.variant.name }}/Debug/compile_commands.json
+        run: infer run --compilation-database build-${{ matrix.variant.name }}/Debug/compile_commands.json

      - name: Generate coverage report
        shell: bash
@@ -68,8 +69,8 @@ jobs:
            # rejects outright ("Wrong major version"). Bypassing gcovr's JSON
            # path entirely: llvm-cov's lcov exporter is a separate, unaffected
            # code path, so merge -> export lcov -> convert lcov to Cobertura.
-            llvm-profdata merge -sparse $(find build-linux-${{ matrix.variant.name }}/Debug -name "*.profraw") -o merged.profdata
-            BINARIES=($(find build-linux-${{ matrix.variant.name }}/Debug -maxdepth 8 -type f -executable -iname "*Tests"))
+            llvm-profdata merge -sparse $(find build-${{ matrix.variant.name }}/Debug -name "*.profraw") -o merged.profdata
+            BINARIES=($(find build-${{ matrix.variant.name }}/Debug -maxdepth 8 -type f -executable -iname "*Tests"))
            OBJECT_ARGS=$(printf -- '-object %s ' "${BINARIES[@]:1}")
            llvm-cov export -format=lcov -instr-profile=merged.profdata "${BINARIES[0]}" $OBJECT_ARGS > coverage.lcov
            # lcov_cobertura isn't preinstalled on the image; inject it into
@@ -84,8 +85,8 @@ jobs:
            -Dsonar.projectKey=${{ matrix.variant.projectKey }}
            "-Dsonar.projectName=${{ matrix.variant.projectName }}"
            -Dsonar.projectVersion=${{ steps.version.outputs.version }}
-            -Dsonar.cxx.jsonCompilationDatabase=./build-linux-${{ matrix.variant.name }}/Debug/compile_commands.json
-            -Dsonar.cxx.xunit.reportPaths=build-linux-${{ matrix.variant.name }}/Debug/TestResults/*.xml
+            -Dsonar.cxx.jsonCompilationDatabase=./build-${{ matrix.variant.name }}/Debug/compile_commands.json
+            -Dsonar.cxx.xunit.reportPaths=build-${{ matrix.variant.name }}/Debug/TestResults/*.xml
            -Dsonar.qualitygate.wait=true
            ${{ github.event_name == 'pull_request' &&
                format('-Dsonar.pullrequest.key={0} -Dsonar.pullrequest.branch={1} -Dsonar.pullrequest.base={2} -Dsonar.analysis.sqbot={3}',
@@ -12,4 +12,6 @@ bigfoot_create_package_lib(
    "${PrivateDependencies}"
    "${BigfootPublicDependencies}"
    "${BigfootPrivateDependencies}"
-    "Bigfoot/Benchmarks")
+    "")
+
+set_target_properties(${PROJECT_NAME} PROPERTIES FOLDER Benchmarks/Bigfoot)
@@ -2,4 +2,6 @@ add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/AssetsForBenchmarking)

 add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/Engine)
 add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/Utils)
-add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/Graphics)
+if(${TOOLMODE})
+    add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/Tools)
+endif()
@@ -36,7 +36,7 @@ class ReferenceFixture: public benchmark::Fixture

    void TearDown(benchmark::State&) override
    {
-        SetActiveAssetLibrary(g_assetLibrary);
+        SetActiveAssetLibrary(&g_assetLibrary);
    }

    AssetLibrary m_library;
@@ -9,11 +9,11 @@
 #include <System/File/File.hpp>
 #include <System/UUID/UUID.hpp>

+#include <EngineBenchmarks/BigFileInfo_generated.hpp>
+
 #include <AssetsForBenchmarking/Asset/BenchmarkAsset.hpp>
 #include <AssetsForBenchmarking/Asset/BenchmarkAssetReferred.hpp>

-#include <EngineBenchmarks/BigFileInfo_generated.hpp>
-
 #include <EASTL/optional.h>
 #include <EASTL/span.h>
 #include <EASTL/vector.h>
@@ -2,13 +2,13 @@ get_filename_component(PackageName ${CMAKE_CURRENT_SOURCE_DIR} NAME)
 project(${PackageName}Benchmarks)

 bigfoot_create_package_benchmarks(
-    "Bigfoot/Benchmarks")
+    "")

 target_link_libraries(${PROJECT_NAME}
    PRIVATE
        effolkronium_random
        $<LINK_LIBRARY:WHOLE_ARCHIVE,AssetsForBenchmarking>)

-bigfoot_create_bigfile("Bigfoot/Benchmarks")
+bigfoot_create_bigfile("Benchmarks/Bigfoot")

 bigfoot_create_sasquatch_info()
@@ -9,11 +9,11 @@
 #include <System/File/File.hpp>
 #include <System/UUID/UUID.hpp>

+#include <EngineBenchmarks/SasquatchInfo_generated.hpp>
+
 #include <AssetsForBenchmarking/Asset/BenchmarkAsset.hpp>
 #include <AssetsForBenchmarking/Asset/BenchmarkAssetReferred.hpp>

-#include <EngineBenchmarks/SasquatchInfo_generated.hpp>
-
 #include <EASTL/optional.h>
 #include <EASTL/span.h>
 #include <EASTL/vector.h>
@@ -1,26 +0,0 @@
-/*********************************************************************
- * \file   main.cpp
- *
- * \author Romain BOULLARD
- * \date   September 2026
- *********************************************************************/
-#include <Utils/Log/LogMacros.hpp>
-#include <Utils/TargetMacros.h>
-
-#include <benchmark/benchmark.h>
-
-int main(int argc, char** argv)
-{
-    BIGFOOT_NOT_OPTIMIZED_ONLY(::Bigfoot::Singleton<::Bigfoot::Log>::Lifetime m_lifetime);
-
-    ::benchmark::Initialize(&argc, argv);
-    if (::benchmark::ReportUnrecognizedArguments(argc, argv))
-    {
-        return 1;
-    }
-
-    ::benchmark::RunSpecifiedBenchmarks();
-    ::benchmark::Shutdown();
-
-    return 0;
-}
@@ -1,4 +0,0 @@
-if(${VULKAN})
-    add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/GraphicsVulkan)
-    add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/GraphicsCore)
-endif()
@@ -1,5 +0,0 @@
-get_filename_component(PackageName ${CMAKE_CURRENT_SOURCE_DIR} NAME)
-project(${PackageName}Benchmarks)
-
-bigfoot_create_package_benchmarks(
-    "Bigfoot/Benchmarks/Graphics")
@@ -1,26 +0,0 @@
-/*********************************************************************
- * \file   main.cpp
- *
- * \author Romain BOULLARD
- * \date   September 2026
- *********************************************************************/
-#include <Utils/Log/LogMacros.hpp>
-#include <Utils/TargetMacros.h>
-
-#include <benchmark/benchmark.h>
-
-int main(int argc, char** argv)
-{
-    BIGFOOT_NOT_OPTIMIZED_ONLY(::Bigfoot::Singleton<::Bigfoot::Log>::Lifetime m_lifetime);
-
-    ::benchmark::Initialize(&argc, argv);
-    if (::benchmark::ReportUnrecognizedArguments(argc, argv))
-    {
-        return 1;
-    }
-
-    ::benchmark::RunSpecifiedBenchmarks();
-    ::benchmark::Shutdown();
-
-    return 0;
-}
@@ -1,5 +0,0 @@
-get_filename_component(PackageName ${CMAKE_CURRENT_SOURCE_DIR} NAME)
-project(${PackageName}Benchmarks)
-
-bigfoot_create_package_benchmarks(
-    "Bigfoot/Benchmarks/Graphics")
@@ -1,26 +0,0 @@
-/*********************************************************************
- * \file   main.cpp
- *
- * \author Romain BOULLARD
- * \date   September 2026
- *********************************************************************/
-#include <Utils/Log/LogMacros.hpp>
-#include <Utils/TargetMacros.h>
-
-#include <benchmark/benchmark.h>
-
-int main(int argc, char** argv)
-{
-    BIGFOOT_NOT_OPTIMIZED_ONLY(::Bigfoot::Singleton<::Bigfoot::Log>::Lifetime m_lifetime);
-
-    ::benchmark::Initialize(&argc, argv);
-    if (::benchmark::ReportUnrecognizedArguments(argc, argv))
-    {
-        return 1;
-    }
-
-    ::benchmark::RunSpecifiedBenchmarks();
-    ::benchmark::Shutdown();
-
-    return 0;
-}
@@ -2,10 +2,10 @@ get_filename_component(PackageName ${CMAKE_CURRENT_SOURCE_DIR} NAME)
 project(${PackageName}Benchmarks)

 bigfoot_create_package_benchmarks(
-    "Tools/Benchmarks")
+    "Tools")

 target_link_libraries(${PROJECT_NAME}
    PRIVATE
        $<LINK_LIBRARY:WHOLE_ARCHIVE,AssetsForBenchmarking>)

-bigfoot_create_bigfile("Tools/Benchmarks")
+bigfoot_create_bigfile("Benchmarks/Tools")
@@ -2,4 +2,4 @@ get_filename_component(PackageName ${CMAKE_CURRENT_SOURCE_DIR} NAME)
 project(${PackageName}Benchmarks)

 bigfoot_create_package_benchmarks(
-    "Bigfoot/Benchmarks")
+    "")
@@ -1,26 +0,0 @@
-/*********************************************************************
- * \file   main.cpp
- *
- * \author Romain BOULLARD
- * \date   September 2026
- *********************************************************************/
-#include <Utils/Log/LogMacros.hpp>
-#include <Utils/TargetMacros.h>
-
-#include <benchmark/benchmark.h>
-
-int main(int argc, char** argv)
-{
-    BIGFOOT_NOT_OPTIMIZED_ONLY(::Bigfoot::Singleton<::Bigfoot::Log>::Lifetime m_lifetime);
-
-    ::benchmark::Initialize(&argc, argv);
-    if (::benchmark::ReportUnrecognizedArguments(argc, argv))
-    {
-        return 1;
-    }
-
-    ::benchmark::RunSpecifiedBenchmarks();
-    ::benchmark::Shutdown();
-
-    return 0;
-}
@@ -1,5 +0,0 @@
-add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/GraphicsInterface)
-if(${VULKAN})
-    add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/GraphicsVulkan)
-endif()
-add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/GraphicsCore)
@@ -1,18 +0,0 @@
-get_filename_component(PackageName ${CMAKE_CURRENT_SOURCE_DIR} NAME)
-project(${PackageName})
-
-set(PublicDependencies)
-set(PrivateDependencies)
-set(BigfootPublicDependencies
-    GraphicsVulkan
-    Engine)
-set(BigfootPrivateDependencies)
-
-bigfoot_create_package_lib(
-    "${PublicDependencies}"
-    "${PrivateDependencies}"
-    "${BigfootPublicDependencies}"
-    "${BigfootPrivateDependencies}"
-    "Bigfoot/Libs/Graphics")
-
-bigfoot_create_logger()
@@ -1,71 +0,0 @@
-/*********************************************************************
- * \file   GraphicsContext.cpp
- *
- * \author Romain BOULLARD
- * \date   September 2026
- *********************************************************************/
-#include <GraphicsCore/GraphicsContext.hpp>
-
-#include <GraphicsCore/GraphicsCoreAssertHandler.hpp>
-
-namespace Bigfoot
-{
-GraphicsContext::GraphicsContext(const GraphicsContextCreateInfo& p_createInfo)
-{
-    m_instance = g_graphicsInstanceFactory->Create(p_createInfo.m_api,
-                                                   p_createInfo.m_applicationName,
-                                                   p_createInfo.m_applicationVersion);
-    CRITICAL_ASSERT(GraphicsCoreAssertHandler,
-                    m_instance != nullptr,
-                    "No graphics instance registered for GraphicsAPI '{}'",
-                    EnumNameGraphicsAPI(p_createInfo.m_api));
-
-    m_surface = g_graphicsSurfaceFactory->Create(p_createInfo.m_api, *m_instance, p_createInfo.m_surfaceCreateInfo);
-    CRITICAL_ASSERT(GraphicsCoreAssertHandler,
-                    m_surface != nullptr,
-                    "No graphics surface registered for GraphicsAPI '{}'",
-                    EnumNameGraphicsAPI(p_createInfo.m_api));
-
-    const DeviceCreateInfo deviceCreateInfo {p_createInfo.m_deviceNameHint, m_surface.get()};
-    m_device = g_graphicsDeviceFactory->Create(p_createInfo.m_api, *m_instance, deviceCreateInfo);
-    CRITICAL_ASSERT(GraphicsCoreAssertHandler,
-                    m_device != nullptr,
-                    "No graphics device registered for GraphicsAPI '{}'",
-                    EnumNameGraphicsAPI(p_createInfo.m_api));
-
-    const SwapchainCreateInfo swapchainCreateInfo {m_device.get(), m_surface.get(), p_createInfo.m_extent};
-    m_swapchain = g_graphicsSwapchainFactory->Create(p_createInfo.m_api, swapchainCreateInfo);
-    CRITICAL_ASSERT(GraphicsCoreAssertHandler,
-                    m_swapchain != nullptr,
-                    "No graphics swapchain registered for GraphicsAPI '{}'",
-                    EnumNameGraphicsAPI(p_createInfo.m_api));
-}
-
-/****************************************************************************************/
-
-GraphicsInstance& GraphicsContext::GetInstance() const
-{
-    return *m_instance;
-}
-
-/****************************************************************************************/
-
-GraphicsSurface& GraphicsContext::GetSurface() const
-{
-    return *m_surface;
-}
-
-/****************************************************************************************/
-
-GraphicsDevice& GraphicsContext::GetDevice() const
-{
-    return *m_device;
-}
-
-/****************************************************************************************/
-
-GraphicsSwapchain& GraphicsContext::GetSwapchain() const
-{
-    return *m_swapchain;
-}
-}   // namespace Bigfoot
@@ -1 +0,0 @@
-#include <GraphicsCore/GraphicsCoreAssertHandler.hpp>
@@ -1,128 +0,0 @@
-/*********************************************************************
- * \file   GraphicsContext.hpp
- *
- * \author Romain BOULLARD
- * \date   September 2026
- *********************************************************************/
-#ifndef BIGFOOT_GRAPHICSCORE_GRAPHICSCONTEXT_HPP
-#define BIGFOOT_GRAPHICSCORE_GRAPHICSCONTEXT_HPP
-#include <GraphicsInterface/GraphicsDevice.hpp>
-#include <GraphicsInterface/GraphicsInstance.hpp>
-#include <GraphicsInterface/GraphicsSurface.hpp>
-#include <GraphicsInterface/GraphicsSwapchain.hpp>
-
-#include <Utils/Version.hpp>
-
-#include <GraphicsInterface/GraphicsAPI_generated.hpp>
-
-#include <EASTL/string_view.h>
-#include <EASTL/unique_ptr.h>
-#include <glm/glm.hpp>
-
-namespace Bigfoot
-{
-struct GraphicsContextCreateInfo
-{
-    /**
-     * The graphics API to use
-     */
-    GraphicsAPI m_api = GraphicsAPI::Vulkan;
-
-    /**
-     * The name of the application
-     */
-    eastl::string_view m_applicationName;
-
-    /**
-     * The version of the application
-     */
-    Version m_applicationVersion;
-
-    /**
-     * The native window handles
-     */
-    SurfaceCreateInfo m_surfaceCreateInfo;
-
-    /**
-     * Pick a specific physical device by name.
-     */
-    eastl::string_view m_deviceNameHint;
-
-    /**
-     * The desired size of the swapchain images.
-     */
-    glm::uvec2 m_extent = {};
-};
-
-class GraphicsContext
-{
-  public:
-    /**
-     * Constructor.
-     *
-     * \param p_createInfo The create info
-     */
-    explicit GraphicsContext(const GraphicsContextCreateInfo& p_createInfo);
-
-    GraphicsContext(const GraphicsContext& p_context) = delete;
-    GraphicsContext(GraphicsContext&& p_context) = delete;
-
-    GraphicsContext& operator=(const GraphicsContext& p_context) = delete;
-    GraphicsContext& operator=(GraphicsContext&& p_context) = delete;
-
-    /**
-     * Get the graphics instance
-     *
-     * \return The graphics instance
-     */
-    [[nodiscard]]
-    GraphicsInstance& GetInstance() const;
-
-    /**
-     * Get the graphics surface
-     *
-     * \return The graphics surface
-     */
-    [[nodiscard]]
-    GraphicsSurface& GetSurface() const;
-
-    /**
-     * Get the graphics device
-     *
-     * \return The graphics device
-     */
-    [[nodiscard]]
-    GraphicsDevice& GetDevice() const;
-
-    /**
-     * Get the graphics swapchain
-     *
-     * \return The graphics swapchain
-     */
-    [[nodiscard]]
-    GraphicsSwapchain& GetSwapchain() const;
-
-  private:
-    /**
-     * The graphics instance.
-     */
-    eastl::unique_ptr<GraphicsInstance> m_instance;
-
-    /**
-     * The graphics surface.
-     */
-    eastl::unique_ptr<GraphicsSurface> m_surface;
-
-    /**
-     * The graphics device.
-     */
-    eastl::unique_ptr<GraphicsDevice> m_device;
-
-    /**
-     * The graphics swapchain.
-     */
-    eastl::unique_ptr<GraphicsSwapchain> m_swapchain;
-};
-}   // namespace Bigfoot
-
-#endif
@@ -1,20 +0,0 @@
-/*********************************************************************
- * \file   GraphicsCoreAssertHandler.hpp
- *
- * \author Romain BOULLARD
- * \date   September 2026
- *********************************************************************/
-#ifndef BIGFOOT_GRAPHICSCORE_GRAPHICSCOREASSERTHANDLER_HPP
-#define BIGFOOT_GRAPHICSCORE_GRAPHICSCOREASSERTHANDLER_HPP
-#include <Utils/Assert/AssertHandler.hpp>
-
-#include <GraphicsCore/GraphicsCoreLogger_generated.hpp>
-
-#ifdef BIGFOOT_NOT_OPTIMIZED
-
-namespace Bigfoot
-{
-using GraphicsCoreAssertHandler = AssertHandler<GRAPHICSCORE_LOGGER>;
-}   // namespace Bigfoot
-#endif
-#endif
@@ -1,21 +0,0 @@
-// AUTO-GENERATED DO NOT TOUCH
-
-/*********************************************************************
- * \file   GraphicsCoreLogger.generated.hpp
- *
- *********************************************************************/
-#ifndef BIGFOOT_GRAPHICSCORELOGGER_GENERATED_HPP
-#define BIGFOOT_GRAPHICSCORELOGGER_GENERATED_HPP
-#include <Utils/Log/LogMacros.hpp>
-
-#if defined BIGFOOT_NOT_OPTIMIZED
-
-namespace Bigfoot
-{
-/*
- * Logger
- */
-inline Log::LoggerInfo GRAPHICSCORE_LOGGER { .m_name = "GRAPHICSCORE_LOGGER", .m_level = LogLevel::Trace};
-}  // namespace Bigfoot
-#endif
-#endif
@@ -1,18 +0,0 @@
-get_filename_component(PackageName ${CMAKE_CURRENT_SOURCE_DIR} NAME)
-project(${PackageName})
-
-set(PublicDependencies
-    glm::glm)
-set(PrivateDependencies)
-set(BigfootPublicDependencies
-    Utils)
-set(BigfootPrivateDependencies)
-
-bigfoot_create_package_lib(
-    "${PublicDependencies}"
-    "${PrivateDependencies}"
-    "${BigfootPublicDependencies}"
-    "${BigfootPrivateDependencies}"
-    "Bigfoot/Libs/Graphics")
-
-bigfoot_create_logger()
@@ -1 +0,0 @@
-#include <GraphicsInterface/GraphicsInterfaceAssertHandler.hpp>
@@ -1,6 +0,0 @@
-namespace Bigfoot;
-
-enum GraphicsAPI: byte
-{
-    Vulkan
-}
@@ -1,71 +0,0 @@
-// automatically generated by the FlatBuffers compiler, do not modify
-
-
-#ifndef FLATBUFFERS_GENERATED_GRAPHICSAPI_BIGFOOT_H_
-#define FLATBUFFERS_GENERATED_GRAPHICSAPI_BIGFOOT_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");
-// Ensure the included flatbuffers.h is Bigfoot's fork - stock
-// flatbuffers (or a differently versioned Bigfoot fork) is not compatible.
-#ifndef FLATBUFFERS_BIGFOOT_VERSION
-#error "This file requires Bigfoot's flatbuffers fork - stock flatbuffers is not compatible"
-#endif
-static_assert(FLATBUFFERS_BIGFOOT_VERSION == 1,
-             "Non-compatible Bigfoot flatbuffers fork version included");
-
-#include "EASTL/unique_ptr.h"
-#include "EASTL/string.h"
-#include "EASTL/vector.h"
-
-namespace Bigfoot {
-
-enum class GraphicsAPI : int8_t {
-  Vulkan = 0,
-  MIN = Vulkan,
-  MAX = Vulkan
-};
-
-inline const GraphicsAPI (&EnumValuesGraphicsAPI())[1] {
-  static const GraphicsAPI values[] = {
-    GraphicsAPI::Vulkan
-  };
-  return values;
-}
-
-inline const char * const *EnumNamesGraphicsAPI() {
-  static const char * const names[2] = {
-    "Vulkan",
-    nullptr
-  };
-  return names;
-}
-
-inline const char *EnumNameGraphicsAPI(GraphicsAPI e) {
-  if (::flatbuffers::IsOutRange(e, GraphicsAPI::Vulkan, GraphicsAPI::Vulkan)) return "";
-  const size_t index = static_cast<size_t>(e);
-  return EnumNamesGraphicsAPI()[index];
-}
-
-inline const ::flatbuffers::TypeTable *GraphicsAPITypeTable() {
-  static const ::flatbuffers::TypeCode type_codes[] = {
-    { ::flatbuffers::ET_CHAR, 0, 0 }
-  };
-  static const ::flatbuffers::TypeFunction type_refs[] = {
-    Bigfoot::GraphicsAPITypeTable
-  };
-  static const ::flatbuffers::TypeTable tt = {
-    ::flatbuffers::ST_ENUM, 1, type_codes, type_refs, nullptr, nullptr, nullptr
-  };
-  return &tt;
-}
-
-}  // namespace Bigfoot
-
-#endif  // FLATBUFFERS_GENERATED_GRAPHICSAPI_BIGFOOT_H_
@@ -1,75 +0,0 @@
-/*********************************************************************
- * \file   GraphicsDevice.hpp
- *
- * \author Romain BOULLARD
- * \date   September 2026
- *********************************************************************/
-#ifndef BIGFOOT_GRAPHICSINTERFACE_GRAPHICSDEVICE_HPP
-#define BIGFOOT_GRAPHICSINTERFACE_GRAPHICSDEVICE_HPP
-#include <GraphicsInterface/GraphicsInstance.hpp>
-#include <GraphicsInterface/GraphicsQueue.hpp>
-#include <GraphicsInterface/GraphicsSurface.hpp>
-
-#include <Utils/Factory.hpp>
-#include <Utils/LazyGlobal.hpp>
-
-#include <GraphicsInterface/GraphicsAPI_generated.hpp>
-
-#include <EASTL/functional.h>
-#include <EASTL/string_view.h>
-#include <EASTL/unique_ptr.h>
-
-namespace Bigfoot
-{
-
-struct DeviceCreateInfo
-{
-    /**
-     * When empty, the most suitable discrete GPU is preferred.
-     */
-    eastl::string_view m_deviceNameHint;
-
-    /**
-     * The surface the device must be able to present to.
-     */
-    const GraphicsSurface* m_surface = nullptr;
-};
-
-class GraphicsDevice
-{
-  public:
-    virtual ~GraphicsDevice() = default;
-
-    /**
-     * Get a queue of the given type
-     *
-     * \param p_type The kind of work the queue should support
-     * \return The queue, or nullptr if the device has no queue of this type
-     */
-    [[nodiscard]]
-    virtual const GraphicsQueue* GetQueue(GraphicsQueueType p_type) const = 0;
-
-    GraphicsDevice(const GraphicsDevice& p_device) = delete;
-    GraphicsDevice(GraphicsDevice&& p_device) = delete;
-
-    GraphicsDevice& operator=(const GraphicsDevice& p_device) = delete;
-    GraphicsDevice& operator=(GraphicsDevice&& p_device) = delete;
-
-  protected:
-    GraphicsDevice() = default;
-};
-
-/****************************************************************************************/
-
-using GraphicsDeviceFactory =
-    Factory<GraphicsDevice,
-            GraphicsAPI,
-            eastl::function<eastl::unique_ptr<GraphicsDevice>(const GraphicsInstance&, const DeviceCreateInfo&)>>;
-
-/**
- * The global factory graphics libraries register themselves into, keyed by GraphicsAPI
- */
-inline LazyGlobal<GraphicsDeviceFactory> g_graphicsDeviceFactory;
-}   // namespace Bigfoot
-
-#endif
@@ -1,47 +0,0 @@
-/*********************************************************************
- * \file   GraphicsImage.hpp
- *
- * \author Romain BOULLARD
- * \date   September 2026
- *********************************************************************/
-#ifndef BIGFOOT_GRAPHICSINTERFACE_GRAPHICSIMAGE_HPP
-#define BIGFOOT_GRAPHICSINTERFACE_GRAPHICSIMAGE_HPP
-#include <GraphicsInterface/PixelFormat_generated.hpp>
-
-#include <glm/glm.hpp>
-
-namespace Bigfoot
-{
-class GraphicsImage
-{
-  public:
-    virtual ~GraphicsImage() = default;
-
-    /**
-     * Get the pixel format of the image
-     *
-     * \return The image format
-     */
-    [[nodiscard]]
-    virtual PixelFormat GetFormat() const = 0;
-
-    /**
-     * Get the size of the image
-     *
-     * \return The image extent, in pixels
-     */
-    [[nodiscard]]
-    virtual glm::uvec2 GetExtent() const = 0;
-
-    GraphicsImage(const GraphicsImage& p_image) = delete;
-    GraphicsImage(GraphicsImage&& p_image) = delete;
-
-    GraphicsImage& operator=(const GraphicsImage& p_image) = delete;
-    GraphicsImage& operator=(GraphicsImage&& p_image) = delete;
-
-  protected:
-    GraphicsImage() = default;
-};
-}   // namespace Bigfoot
-
-#endif
@@ -1,48 +0,0 @@
-/*********************************************************************
- * \file   GraphicsInstance.hpp
- *
- * \author Romain BOULLARD
- * \date   September 2026
- *********************************************************************/
-#ifndef BIGFOOT_GRAPHICSINTERFACE_GRAPHICSINSTANCE_HPP
-#define BIGFOOT_GRAPHICSINTERFACE_GRAPHICSINSTANCE_HPP
-#include <Utils/Factory.hpp>
-#include <Utils/LazyGlobal.hpp>
-#include <Utils/Version.hpp>
-
-#include <GraphicsInterface/GraphicsAPI_generated.hpp>
-
-#include <EASTL/functional.h>
-#include <EASTL/string_view.h>
-#include <EASTL/unique_ptr.h>
-
-namespace Bigfoot
-{
-class GraphicsInstance
-{
-  public:
-    virtual ~GraphicsInstance() = default;
-
-    GraphicsInstance(const GraphicsInstance& p_instance) = delete;
-    GraphicsInstance(GraphicsInstance&& p_instance) = delete;
-
-    GraphicsInstance& operator=(const GraphicsInstance& p_instance) = delete;
-    GraphicsInstance& operator=(GraphicsInstance&& p_instance) = delete;
-
-  protected:
-    GraphicsInstance() = default;
-};
-
-/****************************************************************************************/
-
-using GraphicsInstanceFactory =
-    Factory<GraphicsInstance,
-            GraphicsAPI,
-            eastl::function<eastl::unique_ptr<GraphicsInstance>(eastl::string_view, Version)>>;
-
-/****************************************************************************************/
-
-inline LazyGlobal<GraphicsInstanceFactory> g_graphicsInstanceFactory;
-}   // namespace Bigfoot
-
-#endif
@@ -1,20 +0,0 @@
-/*********************************************************************
- * \file   GraphicsInterfaceAssertHandler.hpp
- *
- * \author Romain BOULLARD
- * \date   September 2026
- *********************************************************************/
-#ifndef BIGFOOT_GRAPHICSINTERFACE_GRAPHICSINTERFACEASSERTHANDLER_HPP
-#define BIGFOOT_GRAPHICSINTERFACE_GRAPHICSINTERFACEASSERTHANDLER_HPP
-#include <Utils/Assert/AssertHandler.hpp>
-
-#include <GraphicsInterface/GraphicsInterfaceLogger_generated.hpp>
-
-#ifdef BIGFOOT_NOT_OPTIMIZED
-
-namespace Bigfoot
-{
-using GraphicsInterfaceAssertHandler = AssertHandler<GRAPHICSINTERFACE_LOGGER>;
-}   // namespace Bigfoot
-#endif
-#endif
@@ -1,21 +0,0 @@
-// AUTO-GENERATED DO NOT TOUCH
-
-/*********************************************************************
- * \file   GraphicsInterfaceLogger.generated.hpp
- *
- *********************************************************************/
-#ifndef BIGFOOT_GRAPHICSINTERFACELOGGER_GENERATED_HPP
-#define BIGFOOT_GRAPHICSINTERFACELOGGER_GENERATED_HPP
-#include <Utils/Log/LogMacros.hpp>
-
-#if defined BIGFOOT_NOT_OPTIMIZED
-
-namespace Bigfoot
-{
-/*
- * Logger
- */
-inline Log::LoggerInfo GRAPHICSINTERFACE_LOGGER { .m_name = "GRAPHICSINTERFACE_LOGGER", .m_level = LogLevel::Trace};
-}  // namespace Bigfoot
-#endif
-#endif
@@ -1,37 +0,0 @@
-/*********************************************************************
- * \file   GraphicsQueue.hpp
- *
- * \author Romain BOULLARD
- * \date   September 2026
- *********************************************************************/
-#ifndef BIGFOOT_GRAPHICSINTERFACE_GRAPHICSQUEUE_HPP
-#define BIGFOOT_GRAPHICSINTERFACE_GRAPHICSQUEUE_HPP
-#include <GraphicsInterface/GraphicsQueueType_generated.hpp>
-
-namespace Bigfoot
-{
-class GraphicsQueue
-{
-  public:
-    virtual ~GraphicsQueue() = default;
-
-    /**
-     * Get the kind of work this queue can be submitted
-     *
-     * \return The queue type
-     */
-    [[nodiscard]]
-    virtual GraphicsQueueType GetType() const = 0;
-
-    GraphicsQueue(const GraphicsQueue& p_queue) = delete;
-    GraphicsQueue(GraphicsQueue&& p_queue) = delete;
-
-    GraphicsQueue& operator=(const GraphicsQueue& p_queue) = delete;
-    GraphicsQueue& operator=(GraphicsQueue&& p_queue) = delete;
-
-  protected:
-    GraphicsQueue() = default;
-};
-}   // namespace Bigfoot
-
-#endif
@@ -1,9 +0,0 @@
-namespace Bigfoot;
-
-enum GraphicsQueueType: byte
-{
-    Graphics,
-    Compute,
-    Transfer,
-    Present
-}
@@ -1,83 +0,0 @@
-// automatically generated by the FlatBuffers compiler, do not modify
-
-
-#ifndef FLATBUFFERS_GENERATED_GRAPHICSQUEUETYPE_BIGFOOT_H_
-#define FLATBUFFERS_GENERATED_GRAPHICSQUEUETYPE_BIGFOOT_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");
-// Ensure the included flatbuffers.h is Bigfoot's fork - stock
-// flatbuffers (or a differently versioned Bigfoot fork) is not compatible.
-#ifndef FLATBUFFERS_BIGFOOT_VERSION
-#error "This file requires Bigfoot's flatbuffers fork - stock flatbuffers is not compatible"
-#endif
-static_assert(FLATBUFFERS_BIGFOOT_VERSION == 1,
-             "Non-compatible Bigfoot flatbuffers fork version included");
-
-#include "EASTL/unique_ptr.h"
-#include "EASTL/string.h"
-#include "EASTL/vector.h"
-
-namespace Bigfoot {
-
-enum class GraphicsQueueType : int8_t {
-  Graphics = 0,
-  Compute = 1,
-  Transfer = 2,
-  Present = 3,
-  MIN = Graphics,
-  MAX = Present
-};
-
-inline const GraphicsQueueType (&EnumValuesGraphicsQueueType())[4] {
-  static const GraphicsQueueType values[] = {
-    GraphicsQueueType::Graphics,
-    GraphicsQueueType::Compute,
-    GraphicsQueueType::Transfer,
-    GraphicsQueueType::Present
-  };
-  return values;
-}
-
-inline const char * const *EnumNamesGraphicsQueueType() {
-  static const char * const names[5] = {
-    "Graphics",
-    "Compute",
-    "Transfer",
-    "Present",
-    nullptr
-  };
-  return names;
-}
-
-inline const char *EnumNameGraphicsQueueType(GraphicsQueueType e) {
-  if (::flatbuffers::IsOutRange(e, GraphicsQueueType::Graphics, GraphicsQueueType::Present)) return "";
-  const size_t index = static_cast<size_t>(e);
-  return EnumNamesGraphicsQueueType()[index];
-}
-
-inline const ::flatbuffers::TypeTable *GraphicsQueueTypeTypeTable() {
-  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 }
-  };
-  static const ::flatbuffers::TypeFunction type_refs[] = {
-    Bigfoot::GraphicsQueueTypeTypeTable
-  };
-  static const ::flatbuffers::TypeTable tt = {
-    ::flatbuffers::ST_ENUM, 4, type_codes, type_refs, nullptr, nullptr, nullptr
-  };
-  return &tt;
-}
-
-}  // namespace Bigfoot
-
-#endif  // FLATBUFFERS_GENERATED_GRAPHICSQUEUETYPE_BIGFOOT_H_
@@ -1,70 +0,0 @@
-/*********************************************************************
- * \file   GraphicsSurface.hpp
- *
- * \author Romain BOULLARD
- * \date   September 2026
- *********************************************************************/
-#ifndef BIGFOOT_GRAPHICSINTERFACE_GRAPHICSSURFACE_HPP
-#define BIGFOOT_GRAPHICSINTERFACE_GRAPHICSSURFACE_HPP
-#include <GraphicsInterface/GraphicsInstance.hpp>
-
-#include <Utils/Factory.hpp>
-#include <Utils/LazyGlobal.hpp>
-#include <Utils/TargetMacros.h>
-
-#include <GraphicsInterface/GraphicsAPI_generated.hpp>
-
-#include <EASTL/functional.h>
-#include <EASTL/unique_ptr.h>
-
-#ifdef BIGFOOT_WINDOWS
-#include <Windows.h>
-#elif defined BIGFOOT_LINUX
-struct wl_display;
-struct wl_surface;
-#endif
-
-namespace Bigfoot
-{
-/**
- * The native window handles needed to create a GraphicsSurface
- */
-struct SurfaceCreateInfo
-{
-#ifdef BIGFOOT_WINDOWS
-    HWND m_windowHandle = nullptr;
-    HINSTANCE m_windowInstance = nullptr;
-#elif defined BIGFOOT_LINUX
-    wl_display* m_display = nullptr;
-    wl_surface* m_surface = nullptr;
-#endif
-};
-
-class GraphicsSurface
-{
-  public:
-    virtual ~GraphicsSurface() = default;
-
-    GraphicsSurface(const GraphicsSurface& p_surface) = delete;
-    GraphicsSurface(GraphicsSurface&& p_surface) = delete;
-
-    GraphicsSurface& operator=(const GraphicsSurface& p_surface) = delete;
-    GraphicsSurface& operator=(GraphicsSurface&& p_surface) = delete;
-
-  protected:
-    GraphicsSurface() = default;
-};
-
-/****************************************************************************************/
-
-using GraphicsSurfaceFactory =
-    Factory<GraphicsSurface,
-            GraphicsAPI,
-            eastl::function<eastl::unique_ptr<GraphicsSurface>(const GraphicsInstance&, const SurfaceCreateInfo&)>>;
-
-/****************************************************************************************/
-
-inline LazyGlobal<GraphicsSurfaceFactory> g_graphicsSurfaceFactory;
-}   // namespace Bigfoot
-
-#endif
@@ -1,89 +0,0 @@
-/*********************************************************************
- * \file   GraphicsSwapchain.hpp
- *
- * \author Romain BOULLARD
- * \date   September 2026
- *********************************************************************/
-#ifndef BIGFOOT_GRAPHICSINTERFACE_GRAPHICSSWAPCHAIN_HPP
-#define BIGFOOT_GRAPHICSINTERFACE_GRAPHICSSWAPCHAIN_HPP
-#include <GraphicsInterface/GraphicsDevice.hpp>
-#include <GraphicsInterface/GraphicsImage.hpp>
-#include <GraphicsInterface/GraphicsInstance.hpp>
-#include <GraphicsInterface/GraphicsSurface.hpp>
-
-#include <Utils/Factory.hpp>
-#include <Utils/LazyGlobal.hpp>
-
-#include <GraphicsInterface/GraphicsAPI_generated.hpp>
-
-#include <EASTL/functional.h>
-#include <EASTL/unique_ptr.h>
-#include <glm/glm.hpp>
-
-#include <cstdint>
-
-namespace Bigfoot
-{
-struct SwapchainCreateInfo
-{
-    /**
-     * The device to create the swapchain from. Must be able to present to m_surface.
-     */
-    const GraphicsDevice* m_device = nullptr;
-
-    /**
-     * The surface the swapchain will present to.
-     */
-    const GraphicsSurface* m_surface = nullptr;
-
-    /**
-     * The desired size of the swapchain images.
-     */
-    glm::uvec2 m_extent = {};
-};
-
-class GraphicsSwapchain
-{
-  public:
-    virtual ~GraphicsSwapchain() = default;
-
-    /**
-     * Get the number of images owned by the swapchain
-     *
-     * \return The image count
-     */
-    [[nodiscard]]
-    virtual std::uint32_t GetImageCount() const = 0;
-
-    /**
-     * Get one of the images owned by the swapchain
-     *
-     * \param p_index The index of the image to get.
-     * \return The image
-     */
-    [[nodiscard]]
-    virtual const GraphicsImage& GetImage(std::uint32_t p_index) const = 0;
-
-    GraphicsSwapchain(const GraphicsSwapchain& p_swapchain) = delete;
-    GraphicsSwapchain(GraphicsSwapchain&& p_swapchain) = delete;
-
-    GraphicsSwapchain& operator=(const GraphicsSwapchain& p_swapchain) = delete;
-    GraphicsSwapchain& operator=(GraphicsSwapchain&& p_swapchain) = delete;
-
-  protected:
-    GraphicsSwapchain() = default;
-};
-
-/****************************************************************************************/
-
-using GraphicsSwapchainFactory =
-    Factory<GraphicsSwapchain,
-            GraphicsAPI,
-            eastl::function<eastl::unique_ptr<GraphicsSwapchain>(const SwapchainCreateInfo&)>>;
-
-/****************************************************************************************/
-
-inline LazyGlobal<GraphicsSwapchainFactory> g_graphicsSwapchainFactory;
-}   // namespace Bigfoot
-
-#endif
@@ -1,12 +0,0 @@
-namespace Bigfoot;
-
-enum PixelFormat: byte
-{
-    Undefined,
-    R8G8B8A8Unorm,
-    R8G8B8A8Srgb,
-    B8G8R8A8Unorm,
-    B8G8R8A8Srgb,
-    A2B10G10R10UnormPack32,
-    R16G16B16A16Sfloat
-}
@@ -1,95 +0,0 @@
-// automatically generated by the FlatBuffers compiler, do not modify
-
-
-#ifndef FLATBUFFERS_GENERATED_PIXELFORMAT_BIGFOOT_H_
-#define FLATBUFFERS_GENERATED_PIXELFORMAT_BIGFOOT_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");
-// Ensure the included flatbuffers.h is Bigfoot's fork - stock
-// flatbuffers (or a differently versioned Bigfoot fork) is not compatible.
-#ifndef FLATBUFFERS_BIGFOOT_VERSION
-#error "This file requires Bigfoot's flatbuffers fork - stock flatbuffers is not compatible"
-#endif
-static_assert(FLATBUFFERS_BIGFOOT_VERSION == 1,
-             "Non-compatible Bigfoot flatbuffers fork version included");
-
-#include "EASTL/unique_ptr.h"
-#include "EASTL/string.h"
-#include "EASTL/vector.h"
-
-namespace Bigfoot {
-
-enum class PixelFormat : int8_t {
-  Undefined = 0,
-  R8G8B8A8Unorm = 1,
-  R8G8B8A8Srgb = 2,
-  B8G8R8A8Unorm = 3,
-  B8G8R8A8Srgb = 4,
-  A2B10G10R10UnormPack32 = 5,
-  R16G16B16A16Sfloat = 6,
-  MIN = Undefined,
-  MAX = R16G16B16A16Sfloat
-};
-
-inline const PixelFormat (&EnumValuesPixelFormat())[7] {
-  static const PixelFormat values[] = {
-    PixelFormat::Undefined,
-    PixelFormat::R8G8B8A8Unorm,
-    PixelFormat::R8G8B8A8Srgb,
-    PixelFormat::B8G8R8A8Unorm,
-    PixelFormat::B8G8R8A8Srgb,
-    PixelFormat::A2B10G10R10UnormPack32,
-    PixelFormat::R16G16B16A16Sfloat
-  };
-  return values;
-}
-
-inline const char * const *EnumNamesPixelFormat() {
-  static const char * const names[8] = {
-    "Undefined",
-    "R8G8B8A8Unorm",
-    "R8G8B8A8Srgb",
-    "B8G8R8A8Unorm",
-    "B8G8R8A8Srgb",
-    "A2B10G10R10UnormPack32",
-    "R16G16B16A16Sfloat",
-    nullptr
-  };
-  return names;
-}
-
-inline const char *EnumNamePixelFormat(PixelFormat e) {
-  if (::flatbuffers::IsOutRange(e, PixelFormat::Undefined, PixelFormat::R16G16B16A16Sfloat)) return "";
-  const size_t index = static_cast<size_t>(e);
-  return EnumNamesPixelFormat()[index];
-}
-
-inline const ::flatbuffers::TypeTable *PixelFormatTypeTable() {
-  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 },
-    { ::flatbuffers::ET_CHAR, 0, 0 }
-  };
-  static const ::flatbuffers::TypeFunction type_refs[] = {
-    Bigfoot::PixelFormatTypeTable
-  };
-  static const ::flatbuffers::TypeTable tt = {
-    ::flatbuffers::ST_ENUM, 7, type_codes, type_refs, nullptr, nullptr, nullptr
-  };
-  return &tt;
-}
-
-}  // namespace Bigfoot
-
-#endif  // FLATBUFFERS_GENERATED_PIXELFORMAT_BIGFOOT_H_
@@ -1,27 +0,0 @@
-get_filename_component(PackageName ${CMAKE_CURRENT_SOURCE_DIR} NAME)
-project(${PackageName})
-
-set(PublicDependencies
-    vulkan-headers::vulkan-headers
-    GPUOpen::VulkanMemoryAllocator)
-set(PrivateDependencies)
-set(BigfootPublicDependencies
-    GraphicsInterface)
-set(BigfootPrivateDependencies
-    Engine)
-
-bigfoot_create_package_lib(
-    "${PublicDependencies}"
-    "${PrivateDependencies}"
-    "${BigfootPublicDependencies}"
-    "${BigfootPrivateDependencies}"
-    "Bigfoot/Libs/Graphics")
-
-bigfoot_create_logger()
-
-target_compile_definitions(${PackageName}
-    PRIVATE VULKAN_HPP_NO_EXCEPTIONS
-    PRIVATE VULKAN_HPP_DISPATCH_LOADER_DYNAMIC=1
-    PRIVATE $<$<PLATFORM_ID:Windows>:VK_USE_PLATFORM_WIN32_KHR>
-    PRIVATE $<$<PLATFORM_ID:Linux>:VK_USE_PLATFORM_WAYLAND_KHR>
-    PUBLIC BIGFOOT_VULKAN)
@@ -1 +0,0 @@
-#include <GraphicsVulkan/GraphicsVulkanAssertHandler.hpp>
@@ -1,20 +0,0 @@
-/*********************************************************************
- * \file   GraphicsVulkanAssertHandler.hpp
- *
- * \author Romain BOULLARD
- * \date   September 2026
- *********************************************************************/
-#ifndef BIGFOOT_GRAPHICSVULKAN_GRAPHICSVULKANASSERTHANDLER_HPP
-#define BIGFOOT_GRAPHICSVULKAN_GRAPHICSVULKANASSERTHANDLER_HPP
-#include <Utils/Assert/AssertHandler.hpp>
-
-#include <GraphicsVulkan/GraphicsVulkanLogger_generated.hpp>
-
-#ifdef BIGFOOT_NOT_OPTIMIZED
-
-namespace Bigfoot
-{
-using GraphicsVulkanAssertHandler = AssertHandler<GRAPHICSVULKAN_LOGGER>;
-}   // namespace Bigfoot
-#endif
-#endif
@@ -1,21 +0,0 @@
-// AUTO-GENERATED DO NOT TOUCH
-
-/*********************************************************************
- * \file   GraphicsVulkanLogger.generated.hpp
- *
- *********************************************************************/
-#ifndef BIGFOOT_GRAPHICSVULKANLOGGER_GENERATED_HPP
-#define BIGFOOT_GRAPHICSVULKANLOGGER_GENERATED_HPP
-#include <Utils/Log/LogMacros.hpp>
-
-#if defined BIGFOOT_NOT_OPTIMIZED
-
-namespace Bigfoot
-{
-/*
- * Logger
- */
-inline Log::LoggerInfo GRAPHICSVULKAN_LOGGER { .m_name = "GRAPHICSVULKAN_LOGGER", .m_level = LogLevel::Trace};
-}  // namespace Bigfoot
-#endif
-#endif
@@ -1,80 +0,0 @@
-/*********************************************************************
- * \file   VulkanDevice.hpp
- *
- * \author Romain BOULLARD
- * \date   September 2026
- *********************************************************************/
-#ifndef BIGFOOT_GRAPHICSVULKAN_VULKANDEVICE_HPP
-#define BIGFOOT_GRAPHICSVULKAN_VULKANDEVICE_HPP
-#include <GraphicsVulkan/VulkanInclude.hpp>
-#include <GraphicsVulkan/VulkanInstance.hpp>
-#include <GraphicsVulkan/VulkanQueue.hpp>
-#include <GraphicsVulkan/VulkanSurface.hpp>
-
-#include <GraphicsInterface/GraphicsDevice.hpp>
-
-#include <EASTL/array.h>
-#include <EASTL/optional.h>
-#include <EASTL/string_view.h>
-
-namespace Bigfoot::Vulkan
-{
-class VulkanDevice final: public GraphicsDevice
-{
-  public:
-    /**
-     * Constructor.
-     *
-     * \param p_instance The instance to create the device from
-     * \param p_surface The surface the device must be able to present to. Can be null to create a device with no
-     *                  present queue
-     * \param p_deviceNameHint Pick a specific physical device by name.
-     */
-    VulkanDevice(const VulkanInstance& p_instance, const VulkanSurface* p_surface, eastl::string_view p_deviceNameHint);
-
-    ~VulkanDevice() override;
-
-    /**
-     * Get a queue of the given type
-     *
-     * \param p_type The kind of work the queue should support
-     * \return The queue, or nullptr if the device has no queue of this type
-     */
-    [[nodiscard]]
-    const GraphicsQueue* GetQueue(GraphicsQueueType p_type) const override;
-
-    /**
-     * Get the underlying Vulkan physical device handle
-     *
-     * \return The vk::PhysicalDevice handle
-     */
-    [[nodiscard]]
-    vk::PhysicalDevice GetPhysicalDeviceHandle() const;
-
-    /**
-     * Get the underlying Vulkan device handle
-     *
-     * \return The vk::Device handle
-     */
-    [[nodiscard]]
-    vk::Device GetHandle() const;
-
-  private:
-    /**
-     * The physical device this device was created from
-     */
-    vk::PhysicalDevice m_physicalDevice;
-
-    /**
-     * The logical device
-     */
-    vk::Device m_device;
-
-    /**
-     * The queues. A slot is empty if the device has no queue of that type
-     */
-    eastl::array<eastl::optional<VulkanQueue>, static_cast<size_t>(GraphicsQueueType::MAX) + 1> m_queues;
-};
-}   // namespace Bigfoot::Vulkan
-
-#endif
@@ -1,51 +0,0 @@
-/*********************************************************************
- * \file   VulkanFormatters.hpp
- *
- * \author Romain BOULLARD
- * \date   September 2026
- *********************************************************************/
-#ifndef BIGFOOT_GRAPHICSVULKAN_VULKANFORMATTERS_HPP
-#define BIGFOOT_GRAPHICSVULKAN_VULKANFORMATTERS_HPP
-#include <GraphicsVulkan/VulkanInclude.hpp>
-
-#include <Utils/TargetMacros.h>
-
-#include <fmt/format.h>
-
-template<>
-struct fmt::formatter<vk::Result>
-{
-    static constexpr auto parse(format_parse_context& ctx)
-    {
-        return ctx.begin();
-    }
-
-    static auto format(const vk::Result p_result, format_context& ctx)
-    {
-        return fmt::format_to(ctx.out(), "{}", vk::to_string(p_result));
-    }
-};
-
-#ifdef BIGFOOT_NOT_OPTIMIZED
-#include <quill/DeferredFormatCodec.h>
-
-template<>
-struct fmtquill::formatter<vk::Result>
-{
-    static constexpr auto parse(format_parse_context& ctx)
-    {
-        return ctx.begin();
-    }
-
-    static auto format(const vk::Result p_result, format_context& ctx)
-    {
-        return fmtquill::format_to(ctx.out(), "{}", vk::to_string(p_result));
-    }
-};
-
-template<>
-struct quill::Codec<vk::Result>: quill::DeferredFormatCodec<vk::Result>
-{
-};
-#endif
-#endif
@@ -1,75 +0,0 @@
-/*********************************************************************
- * \file   VulkanImage.hpp
- *
- * \author Romain BOULLARD
- * \date   September 2026
- *********************************************************************/
-#ifndef BIGFOOT_GRAPHICSVULKAN_VULKANIMAGE_HPP
-#define BIGFOOT_GRAPHICSVULKAN_VULKANIMAGE_HPP
-#include <GraphicsVulkan/VulkanInclude.hpp>
-
-#include <GraphicsInterface/GraphicsImage.hpp>
-
-namespace Bigfoot::Vulkan
-{
-class VulkanImage final: public GraphicsImage
-{
-  public:
-    /**
-     * Constructor
-     *
-     * \param p_image The underlying Vulkan image handle
-     * \param p_format The pixel format of the image
-     * \param p_extent The size of the image
-     */
-    VulkanImage(vk::Image p_image, PixelFormat p_format, vk::Extent2D p_extent);
-
-    VulkanImage(const VulkanImage& p_image) = delete;
-    VulkanImage(VulkanImage&& p_image) noexcept;
-
-    VulkanImage& operator=(const VulkanImage& p_image) = delete;
-    VulkanImage& operator=(VulkanImage&& p_image) noexcept;
-
-    /**
-     * Get the pixel format of the image
-     *
-     * \return The image format
-     */
-    [[nodiscard]]
-    PixelFormat GetFormat() const override;
-
-    /**
-     * Get the size of the image
-     *
-     * \return The image extent, in pixels
-     */
-    [[nodiscard]]
-    glm::uvec2 GetExtent() const override;
-
-    /**
-     * Get the underlying Vulkan image handle
-     *
-     * \return The vk::Image handle
-     */
-    [[nodiscard]]
-    vk::Image GetHandle() const;
-
-  private:
-    /**
-     * The vulkan image
-     */
-    vk::Image m_image;
-
-    /**
-     * The pixel format of the image
-     */
-    PixelFormat m_format;
-
-    /**
-     * The size of the image
-     */
-    vk::Extent2D m_extent;
-};
-}   // namespace Bigfoot::Vulkan
-
-#endif
@@ -1,13 +0,0 @@
-/*********************************************************************
- * \file   VulkanInclude.hpp
- *
- * \author Romain BOULLARD
- * \date   September 2026
- *********************************************************************/
-#ifndef BIGFOOT_GRAPHICSVULKAN_VULKANINCLUDE_HPP
-#define BIGFOOT_GRAPHICSVULKAN_VULKANINCLUDE_HPP
-#define VULKAN_HPP_ASSERT(result)
-#define VULKAN_HPP_ASSERT_ON_RESULT(result)
-#include <vulkan/vulkan.hpp>
-
-#endif
@@ -1,59 +0,0 @@
-/*********************************************************************
- * \file   VulkanInstance.hpp
- *
- * \author Romain BOULLARD
- * \date   September 2026
- *********************************************************************/
-#ifndef BIGFOOT_GRAPHICSVULKAN_VULKANINSTANCE_HPP
-#define BIGFOOT_GRAPHICSVULKAN_VULKANINSTANCE_HPP
-#include <GraphicsVulkan/VulkanInclude.hpp>
-
-#include <GraphicsInterface/GraphicsInstance.hpp>
-
-#include <Utils/TargetMacros.h>
-#include <Utils/Version.hpp>
-
-#include <EASTL/string_view.h>
-
-namespace Bigfoot::Vulkan
-{
-class VulkanInstance final: public GraphicsInstance
-{
-  public:
-    /**
-     * Constructor. Creates a vk::Instance
-     *
-     * \param p_applicationName The name of the application
-     * \param p_applicationVersion The version of the application
-     */
-    VulkanInstance(eastl::string_view p_applicationName, Version p_applicationVersion);
-
-    ~VulkanInstance() override;
-
-    /**
-     * Get the underlying Vulkan instance handle
-     *
-     * \return The vk::Instance handle
-     */
-    [[nodiscard]]
-    vk::Instance GetHandle() const;
-
-  private:
-    /**
-     * The vulkan loader.
-     */
-    vk::detail::DynamicLoader m_loader;
-
-    /**
-     * The vulkan instance.
-     */
-    vk::Instance m_instance;
-
-    /**
-     * The debug messenger (used for validation callbacks).
-     */
-    BIGFOOT_NOT_OPTIMIZED_ONLY(vk::DebugUtilsMessengerEXT m_debugMessenger;)
-};
-}   // namespace Bigfoot::Vulkan
-
-#endif
@@ -1,34 +0,0 @@
-/*********************************************************************
- * \file   VulkanPixelFormat.hpp
- *
- * \author Romain BOULLARD
- * \date   September 2026
- *********************************************************************/
-#ifndef BIGFOOT_GRAPHICSVULKAN_VULKANPIXELFORMAT_HPP
-#define BIGFOOT_GRAPHICSVULKAN_VULKANPIXELFORMAT_HPP
-#include <GraphicsVulkan/VulkanInclude.hpp>
-
-#include <GraphicsInterface/PixelFormat_generated.hpp>
-
-namespace Bigfoot::Vulkan
-{
-/**
- * Convert PixelFormat to its vk::Format equivalent
- *
- * \param p_format The format to convert
- * \return The equivalent vk::Format
- */
-[[nodiscard]]
-vk::Format ToVulkanFormat(PixelFormat p_format);
-
-/**
- * Convert a vk::Format to its PixelFormat equivalent
- *
- * \param p_format The format to convert
- * \return The equivalent PixelFormat
- */
-[[nodiscard]]
-PixelFormat FromVulkanFormat(vk::Format p_format);
-}   // namespace Bigfoot::Vulkan
-
-#endif
@@ -1,77 +0,0 @@
-/*********************************************************************
- * \file   VulkanQueue.hpp
- *
- * \author Romain BOULLARD
- * \date   September 2026
- *********************************************************************/
-#ifndef BIGFOOT_GRAPHICSVULKAN_VULKANQUEUE_HPP
-#define BIGFOOT_GRAPHICSVULKAN_VULKANQUEUE_HPP
-#include <GraphicsVulkan/VulkanInclude.hpp>
-
-#include <GraphicsInterface/GraphicsQueue.hpp>
-
-#include <cstdint>
-
-namespace Bigfoot::Vulkan
-{
-class VulkanQueue final: public GraphicsQueue
-{
-  public:
-    /**
-     * Constructor
-     *
-     * \param p_queue The underlying Vulkan queue handle
-     * \param p_familyIndex The queue family index this queue was retrieved from
-     * \param p_type The kind of work this queue can submit
-     */
-    VulkanQueue(vk::Queue p_queue, std::uint32_t p_familyIndex, GraphicsQueueType p_type);
-
-    VulkanQueue(const VulkanQueue& p_queue) = delete;
-    VulkanQueue(VulkanQueue&& p_queue) noexcept;
-
-    VulkanQueue& operator=(const VulkanQueue& p_queue) = delete;
-    VulkanQueue& operator=(VulkanQueue&& p_queue) noexcept;
-
-    /**
-     * Get the kind of work this queue can be submitted
-     *
-     * \return The queue type
-     */
-    [[nodiscard]]
-    GraphicsQueueType GetType() const override;
-
-    /**
-     * Get the underlying Vulkan queue handle
-     *
-     * \return The vk::Queue handle
-     */
-    [[nodiscard]]
-    vk::Queue GetHandle() const;
-
-    /**
-     * Get the index of the queue family this queue was retrieved from
-     *
-     * \return The queue family index
-     */
-    [[nodiscard]]
-    std::uint32_t GetFamilyIndex() const;
-
-  private:
-    /**
-     * The vulkn queue
-     */
-    vk::Queue m_queue;
-
-    /**
-     * The index of the queue family this queue was retrieved from
-     */
-    std::uint32_t m_familyIndex;
-
-    /**
-     * The kind of work this queue can submit
-     */
-    GraphicsQueueType m_type;
-};
-}   // namespace Bigfoot::Vulkan
-
-#endif
@@ -1,51 +0,0 @@
-/*********************************************************************
- * \file   VulkanSurface.hpp
- *
- * \author Romain BOULLARD
- * \date   September 2026
- *********************************************************************/
-#ifndef BIGFOOT_GRAPHICSVULKAN_VULKANSURFACE_HPP
-#define BIGFOOT_GRAPHICSVULKAN_VULKANSURFACE_HPP
-#include <GraphicsVulkan/VulkanInclude.hpp>
-#include <GraphicsVulkan/VulkanInstance.hpp>
-
-#include <GraphicsInterface/GraphicsSurface.hpp>
-
-namespace Bigfoot::Vulkan
-{
-class VulkanSurface final: public GraphicsSurface
-{
-  public:
-    /**
-     * Constructor.
-     * Creates a vk::SurfaceKHR for the given native window.
-     *
-     * \param p_instance The instance to create the surface from
-     * \param p_surfaceCreateInfo The native window handles to create the surface for
-     */
-    VulkanSurface(const VulkanInstance& p_instance, const SurfaceCreateInfo& p_surfaceCreateInfo);
-
-    ~VulkanSurface() override;
-
-    /**
-     * Get the underlying Vulkan surface handle
-     *
-     * \return The vk::SurfaceKHR handle
-     */
-    [[nodiscard]]
-    vk::SurfaceKHR GetHandle() const;
-
-  private:
-    /**
-     * The instance
-     */
-    const VulkanInstance& m_instance;
-
-    /**
-     * The surface
-     */
-    vk::SurfaceKHR m_surface;
-};
-}   // namespace Bigfoot::Vulkan
-
-#endif
@@ -1,88 +0,0 @@
-/*********************************************************************
- * \file   VulkanSwapchain.hpp
- *
- * \author Romain BOULLARD
- * \date   September 2026
- *********************************************************************/
-#ifndef BIGFOOT_GRAPHICSVULKAN_VULKANSWAPCHAIN_HPP
-#define BIGFOOT_GRAPHICSVULKAN_VULKANSWAPCHAIN_HPP
-#include <GraphicsVulkan/VulkanDevice.hpp>
-#include <GraphicsVulkan/VulkanImage.hpp>
-#include <GraphicsVulkan/VulkanInclude.hpp>
-#include <GraphicsVulkan/VulkanSurface.hpp>
-
-#include <GraphicsInterface/GraphicsSwapchain.hpp>
-
-#include <EASTL/span.h>
-#include <EASTL/vector.h>
-
-#include <cstdint>
-
-namespace Bigfoot::Vulkan
-{
-class VulkanSwapchain final: public GraphicsSwapchain
-{
-  public:
-    /**
-     * Constructor.
-     *
-     * \param p_device The device to create the swapchain from.
-     * \param p_surface The surface the swapchain will present to.
-     * \param p_extent The desired size of the swapchain images.
-     */
-    VulkanSwapchain(const VulkanDevice& p_device, const VulkanSurface& p_surface, glm::uvec2 p_extent);
-
-    ~VulkanSwapchain() override;
-
-    /**
-     * Get the number of images owned by the swapchain
-     *
-     * \return The image count
-     */
-    [[nodiscard]]
-    std::uint32_t GetImageCount() const override;
-
-    /**
-     * Get one of the images owned by the swapchain
-     *
-     * \param p_index The index of the image to get. Must be less than GetImageCount()
-     * \return The image
-     */
-    [[nodiscard]]
-    const GraphicsImage& GetImage(std::uint32_t p_index) const override;
-
-    /**
-     * Get the underlying Vulkan swapchain handle
-     *
-     * \return The vk::SwapchainKHR handle
-     */
-    [[nodiscard]]
-    vk::SwapchainKHR GetHandle() const;
-
-    /**
-     * Get the swapchain images
-     *
-     * \return The images owned by the swapchain
-     */
-    [[nodiscard]]
-    eastl::span<const VulkanImage> GetImages() const;
-
-  private:
-    /**
-     * The device the swapchain was created from
-     */
-    const VulkanDevice& m_device;
-
-    /**
-     * The swapchain
-     */
-    vk::SwapchainKHR m_swapchain;
-
-    /**
-     * The images owned by the swapchain
-     */
-    eastl::vector<VulkanImage> m_images;
-};
-}   // namespace Bigfoot::Vulkan
-
-#endif
@@ -1,352 +0,0 @@
-/*********************************************************************
- * \file   VulkanDevice.cpp
- *
- * \author Romain BOULLARD
- * \date   September 2026
- *********************************************************************/
-#include <GraphicsVulkan/VulkanDevice.hpp>
-
-#include <GraphicsVulkan/GraphicsVulkanAssertHandler.hpp>
-#include <GraphicsVulkan/VulkanFormatters.hpp>
-
-#include <Utils/String.hpp>
-#include <Utils/TargetMacros.h>
-
-#include <EASTL/algorithm.h>
-#include <EASTL/optional.h>
-#include <EASTL/span.h>
-#include <EASTL/vector.h>
-
-#include <bit>
-#include <cstdint>
-#include <span>
-#include <vector>
-
-namespace Bigfoot::Vulkan
-{
-[[nodiscard]]
-std::uint32_t GetPhysicalDeviceTypeRank(const vk::PhysicalDeviceType p_type)
-{
-    switch (p_type)
-    {
-    case vk::PhysicalDeviceType::eDiscreteGpu:
-        return 0;
-    case vk::PhysicalDeviceType::eIntegratedGpu:
-        return 1;
-    case vk::PhysicalDeviceType::eVirtualGpu:
-        return 2;
-    case vk::PhysicalDeviceType::eCpu:
-        return 3;
-    case vk::PhysicalDeviceType::eOther:
-    default:
-        return 4;
-    }
-}
-
-/****************************************************************************************/
-
-struct SelectedQueueFamilies
-{
-    eastl::optional<std::uint32_t> m_graphics;
-    eastl::optional<std::uint32_t> m_compute;
-    eastl::optional<std::uint32_t> m_transfer;
-    eastl::optional<std::uint32_t> m_present;
-};
-
-/****************************************************************************************/
-
-[[nodiscard]]
-eastl::optional<std::uint32_t> FindQueueFamily(const std::span<const vk::QueueFamilyProperties> p_families,
-                                               const vk::QueueFlagBits p_required)
-{
-    eastl::optional<std::uint32_t> best;
-    int bestBitCount = 0;
-
-    for (std::uint32_t index = 0; index < p_families.size(); ++index)
-    {
-        const vk::QueueFlags flags = p_families[index].queueFlags;
-        if (!(flags & p_required))
-        {
-            continue;
-        }
-
-        const int bitCount = std::popcount(static_cast<vk::QueueFlags::MaskType>(flags));
-        if (!best.has_value() || bitCount < bestBitCount)
-        {
-            best = index;
-            bestBitCount = bitCount;
-        }
-    }
-
-    return best;
-}
-
-/****************************************************************************************/
-
-[[nodiscard]]
-eastl::optional<std::uint32_t> FindPresentQueueFamily(const vk::PhysicalDevice p_physicalDevice,
-                                                      const vk::SurfaceKHR p_surface,
-                                                      const std::uint32_t p_familyCount,
-                                                      const eastl::optional<std::uint32_t> p_graphicsFamily)
-{
-    if (p_graphicsFamily.has_value())
-    {
-        const vk::ResultValue<vk::Bool32> support = p_physicalDevice.getSurfaceSupportKHR(*p_graphicsFamily, p_surface);
-        if (support.result == vk::Result::eSuccess && support.value)
-        {
-            return *p_graphicsFamily;
-        }
-    }
-
-    for (std::uint32_t index = 0; index < p_familyCount; ++index)
-    {
-        const vk::ResultValue<vk::Bool32> support = p_physicalDevice.getSurfaceSupportKHR(index, p_surface);
-        if (support.result == vk::Result::eSuccess && support.value)
-        {
-            return index;
-        }
-    }
-
-    return eastl::nullopt;
-}
-
-/****************************************************************************************/
-
-[[nodiscard]]
-SelectedQueueFamilies SelectQueueFamilies(const vk::PhysicalDevice p_physicalDevice, const vk::SurfaceKHR p_surface)
-{
-    const std::vector<vk::QueueFamilyProperties> families = p_physicalDevice.getQueueFamilyProperties();
-
-    SelectedQueueFamilies selected;
-    selected.m_graphics = FindQueueFamily(families, vk::QueueFlagBits::eGraphics);
-    selected.m_compute = FindQueueFamily(families, vk::QueueFlagBits::eCompute);
-    selected.m_transfer = FindQueueFamily(families, vk::QueueFlagBits::eTransfer);
-    if (!selected.m_transfer.has_value())
-    {
-        // Per the Vulkan spec, any queue family supporting Graphics or Compute implicitly supports
-        // Transfer even when it doesn't explicitly report the bit, so the graphics family always works.
-        selected.m_transfer = selected.m_graphics;
-    }
-
-    if (p_surface)
-    {
-        selected.m_present = FindPresentQueueFamily(p_physicalDevice,
-                                                    p_surface,
-                                                    static_cast<std::uint32_t>(families.size()),
-                                                    selected.m_graphics);
-    }
-
-    return selected;
-}
-
-/****************************************************************************************/
-
-[[nodiscard]]
-bool IsPhysicalDeviceSuitable(const SelectedQueueFamilies& p_families, const bool p_needsPresent)
-{
-    return p_families.m_graphics.has_value() && p_families.m_compute.has_value() &&
-           (!p_needsPresent || p_families.m_present.has_value());
-}
-
-/****************************************************************************************/
-
-struct PhysicalDeviceCandidate
-{
-    vk::PhysicalDevice m_handle;
-    vk::PhysicalDeviceProperties m_properties;
-    SelectedQueueFamilies m_queueFamilies;
-};
-
-/****************************************************************************************/
-
-[[nodiscard]]
-const PhysicalDeviceCandidate& SelectPhysicalDevice(const eastl::span<const PhysicalDeviceCandidate> p_candidates,
-                                                    const eastl::string_view p_deviceNameHint)
-{
-    if (!p_deviceNameHint.empty())
-    {
-        const auto it = eastl::find_if(p_candidates.begin(),
-                                       p_candidates.end(),
-                                       [p_deviceNameHint](const PhysicalDeviceCandidate& p_candidate)
-                                       {
-                                           return EqualNoCase(p_candidate.m_properties.deviceName.data(),
-                                                              p_deviceNameHint);
-                                       });
-        if (it != p_candidates.end())
-        {
-            return *it;
-        }
-
-        BIGFOOT_LOG_WARN(GRAPHICSVULKAN_LOGGER,
-                         "No Vulkan device matching hint '{}' found, falling back to automatic selection",
-                         p_deviceNameHint);
-    }
-
-    return *eastl::min_element(p_candidates.begin(),
-                               p_candidates.end(),
-                               [](const PhysicalDeviceCandidate& p_lhs, const PhysicalDeviceCandidate& p_rhs)
-                               {
-                                   return GetPhysicalDeviceTypeRank(p_lhs.m_properties.deviceType) <
-                                          GetPhysicalDeviceTypeRank(p_rhs.m_properties.deviceType);
-                               });
-}
-
-/****************************************************************************************/
-
-[[nodiscard]]
-eastl::optional<VulkanQueue> CreateQueue(const vk::Device p_device,
-                                         const eastl::optional<std::uint32_t> p_familyIndex,
-                                         const GraphicsQueueType p_type)
-{
-    if (!p_familyIndex.has_value())
-    {
-        return eastl::nullopt;
-    }
-
-    return VulkanQueue {p_device.getQueue(*p_familyIndex, 0), *p_familyIndex, p_type};
-}
-
-/****************************************************************************************/
-
-VulkanDevice::VulkanDevice(const VulkanInstance& p_instance,
-                           const VulkanSurface* p_surface,
-                           const eastl::string_view p_deviceNameHint)
-{
-    const vk::SurfaceKHR surfaceHandle = p_surface != nullptr ? p_surface->GetHandle() : vk::SurfaceKHR {};
-
-    const vk::ResultValue<std::vector<vk::PhysicalDevice>> physicalDevices = p_instance.GetHandle()
-                                                                                 .enumeratePhysicalDevices();
-    CRITICAL_ASSERT(GraphicsVulkanAssertHandler,
-                    physicalDevices.result == vk::Result::eSuccess,
-                    "({}) Failed to enumerate Vulkan physical devices",
-                    physicalDevices.result);
-
-    eastl::vector<PhysicalDeviceCandidate> candidates;
-    for (const vk::PhysicalDevice physicalDevice: physicalDevices.value)
-    {
-        SelectedQueueFamilies queueFamilies = SelectQueueFamilies(physicalDevice, surfaceHandle);
-        if (!IsPhysicalDeviceSuitable(queueFamilies, static_cast<bool>(surfaceHandle)))
-        {
-            continue;
-        }
-
-        candidates.push_back({physicalDevice, physicalDevice.getProperties(), eastl::move(queueFamilies)});
-    }
-    CRITICAL_ASSERT(GraphicsVulkanAssertHandler, !candidates.empty(), "No suitable Vulkan physical device found");
-
-    const PhysicalDeviceCandidate& selected = SelectPhysicalDevice(candidates, p_deviceNameHint);
-    m_physicalDevice = selected.m_handle;
-
-    BIGFOOT_LOG_INFO(GRAPHICSVULKAN_LOGGER,
-                     "Selected Vulkan physical device '{}' ({})",
-                     selected.m_properties.deviceName.data(),
-                     vk::to_string(selected.m_properties.deviceType));
-
-    eastl::vector<std::uint32_t> uniqueFamilies;
-    for (const eastl::optional<std::uint32_t> family: {selected.m_queueFamilies.m_graphics,
-                                                       selected.m_queueFamilies.m_compute,
-                                                       selected.m_queueFamilies.m_transfer,
-                                                       selected.m_queueFamilies.m_present})
-    {
-        if (family.has_value() &&
-            eastl::find(uniqueFamilies.begin(), uniqueFamilies.end(), *family) == uniqueFamilies.end())
-        {
-            uniqueFamilies.push_back(*family);
-        }
-    }
-
-    constexpr float queuePriority = 1.0f;
-    eastl::vector<vk::DeviceQueueCreateInfo> queueCreateInfos;
-    queueCreateInfos.reserve(uniqueFamilies.size());
-    for (const std::uint32_t family: uniqueFamilies)
-    {
-        queueCreateInfos.push_back({{}, family, 1u, &queuePriority});
-    }
-
-    eastl::vector<const char*> enabledExtensions;
-    if (surfaceHandle)
-    {
-        enabledExtensions.push_back(VK_KHR_SWAPCHAIN_EXTENSION_NAME);
-    }
-
-    const vk::DeviceCreateInfo deviceCreateInfo {{}, queueCreateInfos, {}, enabledExtensions};
-
-    vk::ResultValue<vk::Device> device {vk::Result::eSuccess, vk::Device {}};
-    {
-        BIGFOOT_LSAN_ONLY(const __lsan::ScopedDisabler lsanDisabler;)
-        device = m_physicalDevice.createDevice(deviceCreateInfo);
-    }
-    CRITICAL_ASSERT(GraphicsVulkanAssertHandler,
-                    device.result == vk::Result::eSuccess,
-                    "({}) Failed to create Vulkan device",
-                    device.result);
-    m_device = device.value;
-
-    m_queues[static_cast<size_t>(GraphicsQueueType::Graphics)] = CreateQueue(m_device,
-                                                                             selected.m_queueFamilies.m_graphics,
-                                                                             GraphicsQueueType::Graphics);
-    m_queues[static_cast<size_t>(GraphicsQueueType::Compute)] = CreateQueue(m_device,
-                                                                            selected.m_queueFamilies.m_compute,
-                                                                            GraphicsQueueType::Compute);
-    m_queues[static_cast<size_t>(GraphicsQueueType::Transfer)] = CreateQueue(m_device,
-                                                                             selected.m_queueFamilies.m_transfer,
-                                                                             GraphicsQueueType::Transfer);
-    m_queues[static_cast<size_t>(GraphicsQueueType::Present)] = CreateQueue(m_device,
-                                                                            selected.m_queueFamilies.m_present,
-                                                                            GraphicsQueueType::Present);
-}
-
-/****************************************************************************************/
-
-VulkanDevice::~VulkanDevice()
-{
-    m_device.destroy();
-}
-
-/****************************************************************************************/
-
-const GraphicsQueue* VulkanDevice::GetQueue(const GraphicsQueueType p_type) const
-{
-    const eastl::optional<VulkanQueue>& queue = m_queues[static_cast<size_t>(p_type)];
-    return queue.has_value() ? &*queue : nullptr;
-}
-
-/****************************************************************************************/
-
-vk::PhysicalDevice VulkanDevice::GetPhysicalDeviceHandle() const
-{
-    return m_physicalDevice;
-}
-
-/****************************************************************************************/
-
-vk::Device VulkanDevice::GetHandle() const
-{
-    return m_device;
-}
-
-/****************************************************************************************/
-
-[[nodiscard]]
-eastl::unique_ptr<GraphicsDevice> CreateVulkanDevice(const GraphicsInstance& p_instance,
-                                                     const DeviceCreateInfo& p_createInfo)
-{
-    return eastl::make_unique<VulkanDevice>(static_cast<const VulkanInstance&>(p_instance),
-                                            static_cast<const VulkanSurface*>(p_createInfo.m_surface),
-                                            p_createInfo.m_deviceNameHint);
-}
-
-/****************************************************************************************/
-
-[[nodiscard]]
-bool RegisterVulkanDeviceFactory()
-{
-    const bool inserted = g_graphicsDeviceFactory->Register(GraphicsAPI::Vulkan, &CreateVulkanDevice);
-    CRITICAL_ASSERT(GraphicsVulkanAssertHandler, inserted, "Failed to register the Vulkan graphics device factory");
-    return inserted;
-}
-
-/****************************************************************************************/
-
-const bool g_vulkanDeviceFactoryRegistered = RegisterVulkanDeviceFactory();
-}   // namespace Bigfoot::Vulkan
@@ -1,58 +0,0 @@
-/*********************************************************************
- * \file   VulkanImage.cpp
- *
- * \author Romain BOULLARD
- * \date   September 2026
- *********************************************************************/
-#include <GraphicsVulkan/VulkanImage.hpp>
-
-namespace Bigfoot::Vulkan
-{
-VulkanImage::VulkanImage(const vk::Image p_image, const PixelFormat p_format, const vk::Extent2D p_extent):
-    m_image(p_image),
-    m_format(p_format),
-    m_extent(p_extent)
-{
-}
-
-/****************************************************************************************/
-
-VulkanImage::VulkanImage(VulkanImage&& p_image) noexcept:
-    GraphicsImage(),
-    m_image(p_image.m_image),
-    m_format(p_image.m_format),
-    m_extent(p_image.m_extent)
-{
-}
-
-/****************************************************************************************/
-
-VulkanImage& VulkanImage::operator=(VulkanImage&& p_image) noexcept
-{
-    m_image = p_image.m_image;
-    m_format = p_image.m_format;
-    m_extent = p_image.m_extent;
-    return *this;
-}
-
-/****************************************************************************************/
-
-PixelFormat VulkanImage::GetFormat() const
-{
-    return m_format;
-}
-
-/****************************************************************************************/
-
-glm::uvec2 VulkanImage::GetExtent() const
-{
-    return {m_extent.width, m_extent.height};
-}
-
-/****************************************************************************************/
-
-vk::Image VulkanImage::GetHandle() const
-{
-    return m_image;
-}
-}   // namespace Bigfoot::Vulkan
@@ -1,189 +0,0 @@
-/*********************************************************************
- * \file   VulkanInstance.cpp
- *
- * \author Romain BOULLARD
- * \date   September 2026
- *********************************************************************/
-#include <GraphicsVulkan/VulkanInstance.hpp>
-
-#include <GraphicsVulkan/GraphicsVulkanAssertHandler.hpp>
-#include <GraphicsVulkan/VulkanFormatters.hpp>
-
-#include <Utils/TargetMacros.h>
-
-#include <Engine/EngineInfo_generated.hpp>
-
-#include <EASTL/algorithm.h>
-#include <EASTL/string.h>
-#include <EASTL/vector.h>
-
-#include <cstdint>
-#include <vector>
-
-VULKAN_HPP_DEFAULT_DISPATCH_LOADER_DYNAMIC_STORAGE
-
-namespace Bigfoot::Vulkan
-{
-[[nodiscard]]
-std::uint32_t ToVulkanVersion(const Bigfoot::Version p_version)
-{
-    return VK_MAKE_VERSION(p_version.GetMajor(), p_version.GetMinor(), p_version.GetPatch());
-}
-
-/****************************************************************************************/
-
-#ifdef BIGFOOT_NOT_OPTIMIZED
-vk::Bool32 VulkanDebugCallback(const vk::DebugUtilsMessageSeverityFlagBitsEXT p_severity,
-                               [[maybe_unused]] vk::DebugUtilsMessageTypeFlagsEXT p_type,
-                               const vk::DebugUtilsMessengerCallbackDataEXT* p_callbackData,
-                               [[maybe_unused]] void* p_userData)
-{
-    switch (p_severity)
-    {
-    case vk::DebugUtilsMessageSeverityFlagBitsEXT::eError:
-        BIGFOOT_LOG_ERROR(::Bigfoot::GRAPHICSVULKAN_LOGGER, "{}", p_callbackData->pMessage);
-        break;
-    case vk::DebugUtilsMessageSeverityFlagBitsEXT::eWarning:
-        BIGFOOT_LOG_WARN(::Bigfoot::GRAPHICSVULKAN_LOGGER, "{}", p_callbackData->pMessage);
-        break;
-    case vk::DebugUtilsMessageSeverityFlagBitsEXT::eInfo:
-        BIGFOOT_LOG_INFO(::Bigfoot::GRAPHICSVULKAN_LOGGER, "{}", p_callbackData->pMessage);
-        break;
-    case vk::DebugUtilsMessageSeverityFlagBitsEXT::eVerbose:
-    default:
-        BIGFOOT_LOG_TRACE(::Bigfoot::GRAPHICSVULKAN_LOGGER, "{}", p_callbackData->pMessage);
-        break;
-    }
-    return VK_FALSE;
-}
-#endif
-
-/****************************************************************************************/
-
-VulkanInstance::VulkanInstance(const eastl::string_view p_applicationName, const Version p_applicationVersion)
-{
-    const PFN_vkGetInstanceProcAddr getInstanceProcAddr = m_loader.getProcAddress<PFN_vkGetInstanceProcAddr>(
-        "vkGetInstanceProcAddr");
-    CRITICAL_ASSERT(GraphicsVulkanAssertHandler, getInstanceProcAddr != nullptr, "vkGetInstanceProcAddr not found!");
-
-    VULKAN_HPP_DEFAULT_DISPATCHER.init(getInstanceProcAddr);
-
-    const eastl::string applicationName {p_applicationName};
-    const vk::ApplicationInfo applicationInfo {applicationName.c_str(),
-                                               ToVulkanVersion(p_applicationVersion),
-                                               BIGFOOT_NAME.data(),
-                                               ToVulkanVersion(BIGFOOT_VERSION),
-                                               VK_API_VERSION_1_3};
-
-    eastl::vector<const char*> enabledLayers;
-    eastl::vector<const char*> enabledExtensions {
-      VK_KHR_SURFACE_EXTENSION_NAME,
-      BIGFOOT_WINDOWS_OR_LINUX(VK_KHR_WIN32_SURFACE_EXTENSION_NAME, VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME)};
-
-#ifdef BIGFOOT_NOT_OPTIMIZED
-    const vk::ResultValue<std::vector<vk::LayerProperties>> availableLayers = vk::enumerateInstanceLayerProperties();
-    CRITICAL_ASSERT(GraphicsVulkanAssertHandler,
-                    availableLayers.result == vk::Result::eSuccess,
-                    "({}) Failed to enumerate Vulkan instance layers",
-                    availableLayers.result);
-
-    const bool validationLayerAvailable = eastl::find_if(availableLayers.value.begin(),
-                                                         availableLayers.value.end(),
-                                                         [](const vk::LayerProperties& p_layer)
-                                                         {
-                                                             return eastl::string_view {p_layer.layerName.data()} ==
-                                                                    "VK_LAYER_KHRONOS_validation";
-                                                         }) != availableLayers.value.end();
-
-    if (validationLayerAvailable)
-    {
-        enabledLayers.push_back("VK_LAYER_KHRONOS_validation");
-        enabledExtensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
-    }
-    else
-    {
-        BIGFOOT_LOG_WARN(GRAPHICSVULKAN_LOGGER, "Vulkan validation layer requested but not available");
-    }
-#endif
-
-    const vk::InstanceCreateInfo instanceCreateInfo {{}, &applicationInfo, enabledLayers, enabledExtensions};
-
-    vk::ResultValue<vk::Instance> instance {vk::Result::eSuccess, vk::Instance {}};
-    {
-        BIGFOOT_LSAN_ONLY(const __lsan::ScopedDisabler lsanDisabler;)
-        instance = vk::createInstance(instanceCreateInfo);
-    }
-    CRITICAL_ASSERT(GraphicsVulkanAssertHandler,
-                    instance.result == vk::Result::eSuccess,
-                    "({}) Failed to create Vulkan instance",
-                    instance.result);
-    m_instance = instance.value;
-
-    VULKAN_HPP_DEFAULT_DISPATCHER.init(m_instance);
-
-#ifdef BIGFOOT_NOT_OPTIMIZED
-    if (validationLayerAvailable)
-    {
-        vk::DebugUtilsMessengerCreateInfoEXT messengerCreateInfo {};
-        messengerCreateInfo.messageSeverity = vk::DebugUtilsMessageSeverityFlagsEXT {
-          vk::DebugUtilsMessageSeverityFlagBitsEXT::eVerbose | vk::DebugUtilsMessageSeverityFlagBitsEXT::eInfo |
-          vk::DebugUtilsMessageSeverityFlagBitsEXT::eWarning | vk::DebugUtilsMessageSeverityFlagBitsEXT::eError};
-        messengerCreateInfo.messageType = vk::DebugUtilsMessageTypeFlagsEXT {
-          vk::DebugUtilsMessageTypeFlagBitsEXT::eGeneral | vk::DebugUtilsMessageTypeFlagBitsEXT::eValidation |
-          vk::DebugUtilsMessageTypeFlagBitsEXT::ePerformance};
-        messengerCreateInfo.pfnUserCallback = &VulkanDebugCallback;
-
-        const vk::ResultValue<vk::DebugUtilsMessengerEXT> messenger = m_instance.createDebugUtilsMessengerEXT(
-            messengerCreateInfo);
-        CRITICAL_ASSERT(GraphicsVulkanAssertHandler,
-                        messenger.result == vk::Result::eSuccess,
-                        "({}) Failed to create Vulkan debug messenger",
-                        messenger.result);
-        m_debugMessenger = messenger.value;
-    }
-#endif
-}
-
-/****************************************************************************************/
-
-VulkanInstance::~VulkanInstance()
-{
-#ifdef BIGFOOT_NOT_OPTIMIZED
-    if (m_debugMessenger)
-    {
-        m_instance.destroyDebugUtilsMessengerEXT(m_debugMessenger);
-    }
-#endif
-    m_instance.destroy();
-}
-
-/****************************************************************************************/
-
-vk::Instance VulkanInstance::GetHandle() const
-{
-    return m_instance;
-}
-
-/****************************************************************************************/
-
-[[nodiscard]]
-eastl::unique_ptr<GraphicsInstance> CreateVulkanInstance(const eastl::string_view p_applicationName,
-                                                         const Version p_applicationVersion)
-{
-    return eastl::make_unique<VulkanInstance>(p_applicationName, p_applicationVersion);
-}
-
-/****************************************************************************************/
-
-[[nodiscard]]
-bool RegisterVulkanInstanceFactory()
-{
-    const bool inserted = g_graphicsInstanceFactory->Register(GraphicsAPI::Vulkan, &CreateVulkanInstance);
-    CRITICAL_ASSERT(GraphicsVulkanAssertHandler, inserted, "Failed to register the Vulkan graphics instance factory");
-    return inserted;
-}
-
-/****************************************************************************************/
-
-const bool g_vulkanInstanceFactoryRegistered = RegisterVulkanInstanceFactory();
-}   // namespace Bigfoot::Vulkan
@@ -1,55 +0,0 @@
-/*********************************************************************
- * \file   VulkanPixelFormat.cpp
- *
- * \author Romain BOULLARD
- * \date   September 2026
- *********************************************************************/
-#include <GraphicsVulkan/VulkanPixelFormat.hpp>
-
-namespace Bigfoot::Vulkan
-{
-vk::Format ToVulkanFormat(const PixelFormat p_format)
-{
-    switch (p_format)
-    {
-    case PixelFormat::R8G8B8A8Unorm:
-        return vk::Format::eR8G8B8A8Unorm;
-    case PixelFormat::R8G8B8A8Srgb:
-        return vk::Format::eR8G8B8A8Srgb;
-    case PixelFormat::B8G8R8A8Unorm:
-        return vk::Format::eB8G8R8A8Unorm;
-    case PixelFormat::B8G8R8A8Srgb:
-        return vk::Format::eB8G8R8A8Srgb;
-    case PixelFormat::A2B10G10R10UnormPack32:
-        return vk::Format::eA2B10G10R10UnormPack32;
-    case PixelFormat::R16G16B16A16Sfloat:
-        return vk::Format::eR16G16B16A16Sfloat;
-    case PixelFormat::Undefined:
-    default:
-        return vk::Format::eUndefined;
-    }
-}
-
-/****************************************************************************************/
-
-PixelFormat FromVulkanFormat(const vk::Format p_format)
-{
-    switch (p_format)
-    {
-    case vk::Format::eR8G8B8A8Unorm:
-        return PixelFormat::R8G8B8A8Unorm;
-    case vk::Format::eR8G8B8A8Srgb:
-        return PixelFormat::R8G8B8A8Srgb;
-    case vk::Format::eB8G8R8A8Unorm:
-        return PixelFormat::B8G8R8A8Unorm;
-    case vk::Format::eB8G8R8A8Srgb:
-        return PixelFormat::B8G8R8A8Srgb;
-    case vk::Format::eA2B10G10R10UnormPack32:
-        return PixelFormat::A2B10G10R10UnormPack32;
-    case vk::Format::eR16G16B16A16Sfloat:
-        return PixelFormat::R16G16B16A16Sfloat;
-    default:
-        return PixelFormat::Undefined;
-    }
-}
-}   // namespace Bigfoot::Vulkan
@@ -1,58 +0,0 @@
-/*********************************************************************
- * \file   VulkanQueue.cpp
- *
- * \author Romain BOULLARD
- * \date   September 2026
- *********************************************************************/
-#include <GraphicsVulkan/VulkanQueue.hpp>
-
-namespace Bigfoot::Vulkan
-{
-VulkanQueue::VulkanQueue(const vk::Queue p_queue, const std::uint32_t p_familyIndex, const GraphicsQueueType p_type):
-    m_queue(p_queue),
-    m_familyIndex(p_familyIndex),
-    m_type(p_type)
-{
-}
-
-/****************************************************************************************/
-
-VulkanQueue::VulkanQueue(VulkanQueue&& p_queue) noexcept:
-    GraphicsQueue(),
-    m_queue(p_queue.m_queue),
-    m_familyIndex(p_queue.m_familyIndex),
-    m_type(p_queue.m_type)
-{
-}
-
-/****************************************************************************************/
-
-VulkanQueue& VulkanQueue::operator=(VulkanQueue&& p_queue) noexcept
-{
-    m_queue = p_queue.m_queue;
-    m_familyIndex = p_queue.m_familyIndex;
-    m_type = p_queue.m_type;
-    return *this;
-}
-
-/****************************************************************************************/
-
-GraphicsQueueType VulkanQueue::GetType() const
-{
-    return m_type;
-}
-
-/****************************************************************************************/
-
-vk::Queue VulkanQueue::GetHandle() const
-{
-    return m_queue;
-}
-
-/****************************************************************************************/
-
-std::uint32_t VulkanQueue::GetFamilyIndex() const
-{
-    return m_familyIndex;
-}
-}   // namespace Bigfoot::Vulkan
@@ -1,70 +0,0 @@
-/*********************************************************************
- * \file   VulkanSurface.cpp
- *
- * \author Romain BOULLARD
- * \date   September 2026
- *********************************************************************/
-#include <GraphicsVulkan/VulkanSurface.hpp>
-
-#include <GraphicsVulkan/GraphicsVulkanAssertHandler.hpp>
-#include <GraphicsVulkan/VulkanFormatters.hpp>
-
-namespace Bigfoot::Vulkan
-{
-VulkanSurface::VulkanSurface(const VulkanInstance& p_instance, const SurfaceCreateInfo& p_surfaceCreateInfo):
-    m_instance(p_instance)
-{
-#ifdef BIGFOOT_WINDOWS
-    const vk::Win32SurfaceCreateInfoKHR createInfo {{},
-                                                    p_surfaceCreateInfo.m_windowInstance,
-                                                    p_surfaceCreateInfo.m_windowHandle};
-    const vk::ResultValue<vk::SurfaceKHR> surface = m_instance.GetHandle().createWin32SurfaceKHR(createInfo);
-#elif defined BIGFOOT_LINUX
-    const vk::WaylandSurfaceCreateInfoKHR createInfo {{}, p_surfaceCreateInfo.m_display, p_surfaceCreateInfo.m_surface};
-    const vk::ResultValue<vk::SurfaceKHR> surface = m_instance.GetHandle().createWaylandSurfaceKHR(createInfo);
-#endif
-
-    CRITICAL_ASSERT(GraphicsVulkanAssertHandler,
-                    surface.result == vk::Result::eSuccess,
-                    "({}) Failed to create Vulkan surface",
-                    surface.result);
-    m_surface = surface.value;
-}
-
-/****************************************************************************************/
-
-VulkanSurface::~VulkanSurface()
-{
-    m_instance.GetHandle().destroySurfaceKHR(m_surface);
-}
-
-/****************************************************************************************/
-
-vk::SurfaceKHR VulkanSurface::GetHandle() const
-{
-    return m_surface;
-}
-
-/****************************************************************************************/
-
-[[nodiscard]]
-eastl::unique_ptr<GraphicsSurface> CreateVulkanSurface(const GraphicsInstance& p_instance,
-                                                       const SurfaceCreateInfo& p_surfaceCreateInfo)
-{
-    return eastl::make_unique<VulkanSurface>(static_cast<const VulkanInstance&>(p_instance), p_surfaceCreateInfo);
-}
-
-/****************************************************************************************/
-
-[[nodiscard]]
-bool RegisterVulkanSurfaceFactory()
-{
-    const bool inserted = g_graphicsSurfaceFactory->Register(GraphicsAPI::Vulkan, &CreateVulkanSurface);
-    CRITICAL_ASSERT(GraphicsVulkanAssertHandler, inserted, "Failed to register the Vulkan graphics surface factory");
-    return inserted;
-}
-
-/****************************************************************************************/
-
-const bool g_vulkanSurfaceFactoryRegistered = RegisterVulkanSurfaceFactory();
-}   // namespace Bigfoot::Vulkan
@@ -1,235 +0,0 @@
-/*********************************************************************
- * \file   VulkanSwapchain.cpp
- *
- * \author Romain BOULLARD
- * \date   September 2026
- *********************************************************************/
-#include <GraphicsVulkan/VulkanSwapchain.hpp>
-
-#include <GraphicsVulkan/GraphicsVulkanAssertHandler.hpp>
-#include <GraphicsVulkan/VulkanFormatters.hpp>
-#include <GraphicsVulkan/VulkanPixelFormat.hpp>
-#include <GraphicsVulkan/VulkanQueue.hpp>
-
-#include <EASTL/algorithm.h>
-#include <EASTL/vector.h>
-
-#include <cstdint>
-#include <limits>
-#include <span>
-#include <vector>
-
-namespace Bigfoot::Vulkan
-{
-[[nodiscard]]
-vk::SurfaceFormatKHR SelectSurfaceFormat(const std::span<const vk::SurfaceFormatKHR> p_formats)
-{
-    const auto it = eastl::find_if(p_formats.begin(),
-                                   p_formats.end(),
-                                   [](const vk::SurfaceFormatKHR& p_format)
-                                   {
-                                       return p_format.format == vk::Format::eB8G8R8A8Srgb &&
-                                              p_format.colorSpace == vk::ColorSpaceKHR::eSrgbNonlinear;
-                                   });
-
-    return it != p_formats.end() ? *it : p_formats.front();
-}
-
-/****************************************************************************************/
-
-[[nodiscard]]
-vk::PresentModeKHR SelectPresentMode(const std::span<const vk::PresentModeKHR> p_presentModes)
-{
-    const auto it = eastl::find(p_presentModes.begin(), p_presentModes.end(), vk::PresentModeKHR::eMailbox);
-
-    // eFifo is guaranteed by the spec to always be supported
-    return it != p_presentModes.end() ? *it : vk::PresentModeKHR::eFifo;
-}
-
-/****************************************************************************************/
-
-[[nodiscard]]
-vk::Extent2D SelectExtent(const vk::SurfaceCapabilitiesKHR& p_capabilities, const glm::uvec2 p_extent)
-{
-    constexpr std::uint32_t undefinedExtent = std::numeric_limits<std::uint32_t>::max();
-    if (p_capabilities.currentExtent.width != undefinedExtent)
-    {
-        return p_capabilities.currentExtent;
-    }
-
-    return {eastl::clamp(p_extent.x, p_capabilities.minImageExtent.width, p_capabilities.maxImageExtent.width),
-            eastl::clamp(p_extent.y, p_capabilities.minImageExtent.height, p_capabilities.maxImageExtent.height)};
-}
-
-/****************************************************************************************/
-
-[[nodiscard]]
-vk::CompositeAlphaFlagBitsKHR SelectCompositeAlpha(const vk::CompositeAlphaFlagsKHR p_supportedCompositeAlpha)
-{
-    for (const vk::CompositeAlphaFlagBitsKHR candidate: {vk::CompositeAlphaFlagBitsKHR::eOpaque,
-                                                         vk::CompositeAlphaFlagBitsKHR::ePreMultiplied,
-                                                         vk::CompositeAlphaFlagBitsKHR::ePostMultiplied,
-                                                         vk::CompositeAlphaFlagBitsKHR::eInherit})
-    {
-        if (p_supportedCompositeAlpha & candidate)
-        {
-            return candidate;
-        }
-    }
-
-    return vk::CompositeAlphaFlagBitsKHR::eOpaque;
-}
-
-/****************************************************************************************/
-
-VulkanSwapchain::VulkanSwapchain(const VulkanDevice& p_device,
-                                 const VulkanSurface& p_surface,
-                                 const glm::uvec2 p_extent):
-    m_device(p_device)
-{
-    const vk::PhysicalDevice physicalDevice = p_device.GetPhysicalDeviceHandle();
-    const vk::SurfaceKHR surface = p_surface.GetHandle();
-
-    const vk::ResultValue<vk::SurfaceCapabilitiesKHR> capabilities = physicalDevice.getSurfaceCapabilitiesKHR(surface);
-    CRITICAL_ASSERT(GraphicsVulkanAssertHandler,
-                    capabilities.result == vk::Result::eSuccess,
-                    "({}) Failed to get Vulkan surface capabilities",
-                    capabilities.result);
-
-    const vk::ResultValue<std::vector<vk::SurfaceFormatKHR>> formats = physicalDevice.getSurfaceFormatsKHR(surface);
-    CRITICAL_ASSERT(GraphicsVulkanAssertHandler,
-                    formats.result == vk::Result::eSuccess && !formats.value.empty(),
-                    "({}) Failed to get Vulkan surface formats",
-                    formats.result);
-
-    const vk::ResultValue<std::vector<vk::PresentModeKHR>> presentModes = physicalDevice.getSurfacePresentModesKHR(
-        surface);
-    CRITICAL_ASSERT(GraphicsVulkanAssertHandler,
-                    presentModes.result == vk::Result::eSuccess && !presentModes.value.empty(),
-                    "({}) Failed to get Vulkan surface present modes",
-                    presentModes.result);
-
-    const vk::SurfaceFormatKHR surfaceFormat = SelectSurfaceFormat(formats.value);
-    const vk::PresentModeKHR presentMode = SelectPresentMode(presentModes.value);
-    const vk::Extent2D extent = SelectExtent(capabilities.value, p_extent);
-
-    std::uint32_t imageCount = capabilities.value.minImageCount + 1;
-    if (capabilities.value.maxImageCount > 0)
-    {
-        imageCount = eastl::min(imageCount, capabilities.value.maxImageCount);
-    }
-
-    const auto* const graphicsQueue = static_cast<const VulkanQueue*>(p_device.GetQueue(GraphicsQueueType::Graphics));
-    const auto* const presentQueue = static_cast<const VulkanQueue*>(p_device.GetQueue(GraphicsQueueType::Present));
-    CRITICAL_ASSERT(GraphicsVulkanAssertHandler,
-                    graphicsQueue != nullptr && presentQueue != nullptr,
-                    "Cannot create a swapchain on a device with no graphics or present queue");
-
-    const bool sameQueueFamily = graphicsQueue->GetFamilyIndex() == presentQueue->GetFamilyIndex();
-
-    eastl::vector<std::uint32_t> queueFamilyIndices;
-    if (!sameQueueFamily)
-    {
-        queueFamilyIndices = {graphicsQueue->GetFamilyIndex(), presentQueue->GetFamilyIndex()};
-    }
-
-    const vk::SwapchainCreateInfoKHR swapchainCreateInfo {
-      {},
-      surface,
-      imageCount,
-      surfaceFormat.format,
-      surfaceFormat.colorSpace,
-      extent,
-      1,
-      vk::ImageUsageFlagBits::eColorAttachment,
-      sameQueueFamily ? vk::SharingMode::eExclusive : vk::SharingMode::eConcurrent,
-      queueFamilyIndices,
-      capabilities.value.currentTransform,
-      SelectCompositeAlpha(capabilities.value.supportedCompositeAlpha),
-      presentMode,
-      VK_TRUE};
-
-    const vk::ResultValue<vk::SwapchainKHR> swapchain = p_device.GetHandle().createSwapchainKHR(swapchainCreateInfo);
-    CRITICAL_ASSERT(GraphicsVulkanAssertHandler,
-                    swapchain.result == vk::Result::eSuccess,
-                    "({}) Failed to create Vulkan swapchain",
-                    swapchain.result);
-    m_swapchain = swapchain.value;
-
-    const vk::ResultValue<std::vector<vk::Image>> images = p_device.GetHandle().getSwapchainImagesKHR(m_swapchain);
-    CRITICAL_ASSERT(GraphicsVulkanAssertHandler,
-                    images.result == vk::Result::eSuccess,
-                    "({}) Failed to get Vulkan swapchain images",
-                    images.result);
-    const PixelFormat imageFormat = FromVulkanFormat(surfaceFormat.format);
-    m_images.reserve(images.value.size());
-    for (const vk::Image image: images.value)
-    {
-        m_images.emplace_back(image, imageFormat, extent);
-    }
-}
-
-/****************************************************************************************/
-
-VulkanSwapchain::~VulkanSwapchain()
-{
-    m_device.GetHandle().destroySwapchainKHR(m_swapchain);
-}
-
-/****************************************************************************************/
-
-std::uint32_t VulkanSwapchain::GetImageCount() const
-{
-    return static_cast<std::uint32_t>(m_images.size());
-}
-
-/****************************************************************************************/
-
-const GraphicsImage& VulkanSwapchain::GetImage(const std::uint32_t p_index) const
-{
-    CRITICAL_ASSERT(GraphicsVulkanAssertHandler,
-                    p_index < m_images.size(),
-                    "Swapchain image index {} out of range (swapchain has {} images)",
-                    p_index,
-                    m_images.size());
-    return m_images[p_index];
-}
-
-/****************************************************************************************/
-
-vk::SwapchainKHR VulkanSwapchain::GetHandle() const
-{
-    return m_swapchain;
-}
-
-/****************************************************************************************/
-
-eastl::span<const VulkanImage> VulkanSwapchain::GetImages() const
-{
-    return {m_images.data(), m_images.size()};
-}
-
-/****************************************************************************************/
-
-[[nodiscard]]
-eastl::unique_ptr<GraphicsSwapchain> CreateVulkanSwapchain(const SwapchainCreateInfo& p_createInfo)
-{
-    return eastl::make_unique<VulkanSwapchain>(static_cast<const VulkanDevice&>(*p_createInfo.m_device),
-                                               static_cast<const VulkanSurface&>(*p_createInfo.m_surface),
-                                               p_createInfo.m_extent);
-}
-
-/****************************************************************************************/
-
-[[nodiscard]]
-bool RegisterVulkanSwapchainFactory()
-{
-    const bool inserted = g_graphicsSwapchainFactory->Register(GraphicsAPI::Vulkan, &CreateVulkanSwapchain);
-    CRITICAL_ASSERT(GraphicsVulkanAssertHandler, inserted, "Failed to register the Vulkan graphics swapchain factory");
-    return inserted;
-}
-
-/****************************************************************************************/
-
-const bool g_vulkanSwapchainFactoryRegistered = RegisterVulkanSwapchainFactory();
-}   // namespace Bigfoot::Vulkan
@@ -1,75 +0,0 @@
-/*********************************************************************
- * \file   Factory.hpp
- *
- * \author Romain BOULLARD
- * \date   September 2026
- *********************************************************************/
-#ifndef BIGFOOT_UTILS_FACTORY_HPP
-#define BIGFOOT_UTILS_FACTORY_HPP
-#include <EASTL/unique_ptr.h>
-#include <EASTL/utility.h>
-#include <ankerl/unordered_dense.h>
-
-namespace Bigfoot
-{
-template<class TYPE, class KEY, class CREATEFUNCTION>
-class Factory
-{
-  public:
-    /**
-     * Register a key inside the factory
-     *
-     * \param p_key The key
-     * \param p_function The create function
-     * \return True if the key has been registered, false if it was already registered
-     */
-    [[nodiscard]]
-    bool Register(const KEY p_key, CREATEFUNCTION&& p_function)
-    {
-        if (m_createFunctions.find(p_key) == m_createFunctions.end())
-        {
-            m_createFunctions.emplace(p_key, eastl::move(p_function));
-            return true;
-        }
-
-        return false;
-    }
-
-    /**
-     * Create an instance from the factory
-     *
-     * \param p_key The key to create. Needs to have been registered with Register()
-     * \param p_args Arguments for the creation
-     * \return The created instance. nullptr is returned if the key has not been registered
-     */
-    template<typename... ARGS>
-    [[nodiscard]]
-    eastl::unique_ptr<TYPE> Create(const KEY p_key, ARGS&&... p_args) const
-    {
-        if (const auto createFunction = m_createFunctions.find(p_key); createFunction != m_createFunctions.end())
-        {
-            return createFunction->second(eastl::forward<ARGS>(p_args)...);
-        }
-
-        return nullptr;
-    }
-
-    /**
-     * Remove a key and its associated create function from the factory
-     *
-     * \param p_key The key to remove
-     */
-    void Remove(const KEY p_key)
-    {
-        m_createFunctions.erase(p_key);
-    }
-
-  private:
-    /**
-     * The mapping between keys and create functions
-     */
-    ankerl::unordered_dense::map<KEY, CREATEFUNCTION> m_createFunctions;
-};
-}   // namespace Bigfoot
-
-#endif
@@ -1,40 +0,0 @@
-/*********************************************************************
- * \file   LazyGlobal.hpp
- *
- * \author Romain BOULLARD
- * \date   September 2026
- *********************************************************************/
-#ifndef BIGFOOT_UTILS_LAZYGLOBAL_HPP
-#define BIGFOOT_UTILS_LAZYGLOBAL_HPP
-#include <type_traits>
-
-namespace Bigfoot
-{
-template<class TYPE, class TAG = TYPE>
-    requires std::is_default_constructible_v<TYPE>
-class LazyGlobal
-{
-  public:
-    [[nodiscard]]
-    TYPE* operator->() const
-    {
-        return &Get();
-    }
-
-    [[nodiscard]]
-    operator TYPE*() const
-    {
-        return &Get();
-    }
-
-  private:
-    [[nodiscard]]
-    static TYPE& Get()
-    {
-        static TYPE instance;
-        return instance;
-    }
-};
-}   // namespace Bigfoot
-
-#endif
@@ -1,24 +0,0 @@
-/*********************************************************************
- * \file   String.hpp
- *
- * \author Romain BOULLARD
- * \date   September 2026
- *********************************************************************/
-#ifndef BIGFOOT_UTILS_STRING_HPP
-#define BIGFOOT_UTILS_STRING_HPP
-#include <EASTL/string_view.h>
-
-namespace Bigfoot
-{
-/**
- * Check if p_a and p_b are equal, ignoring case
- *
- * \param p_a The first string
- * \param p_b The second string
- * \return True if p_a and p_b are equal, false otherwise
- */
-[[nodiscard]]
-bool EqualNoCase(eastl::string_view p_a, eastl::string_view p_b);
-}   // namespace Bigfoot
-
-#endif
@@ -1,35 +0,0 @@
-/*********************************************************************
- * \file   String.cpp
- *
- * \author Romain BOULLARD
- * \date   September 2026
- *********************************************************************/
-#include <Utils/String.hpp>
-
-#include <EASTL/algorithm.h>
-
-#include <cctype>
-
-namespace Bigfoot
-{
-bool EqualNoCase(const eastl::string_view p_a, const eastl::string_view p_b)
-{
-    if (p_a.size() != p_b.size())
-    {
-        return false;
-    }
-
-    const auto toLower = [](const char p_character)
-    {
-        return static_cast<char>(std::tolower(static_cast<unsigned char>(p_character)));
-    };
-
-    return eastl::equal(p_a.begin(),
-                        p_a.end(),
-                        p_b.begin(),
-                        [&toLower](const char p_x, const char p_y)
-                        {
-                            return toLower(p_x) == toLower(p_y);
-                        });
-}
-}   // namespace Bigfoot
@@ -1,4 +1,6 @@
 add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/Utils)
 add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/System)
 add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/Engine)
-add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/Graphics)
+if(${TOOLMODE})
+    add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/Tools)
+endif()
@@ -21,4 +21,4 @@ bigfoot_create_package_lib(
    "${PrivateDependencies}"
    "${BigfootPublicDependencies}"
    "${BigfootPrivateDependencies}"
-    "Bigfoot/Libs")
+    "")
@@ -10,9 +10,8 @@
 #include <Engine/Asset/AssetConcepts.hpp>
 #include <Engine/Asset/AssetContainer.hpp>
 #include <Engine/Asset/AssetLibrary.hpp>
-#include <Engine/EngineAssertHandler.hpp>
-
 #include <Engine/Asset/Asset_generated.hpp>
+#include <Engine/EngineAssertHandler.hpp>

 #include <EASTL/span.h>
 #include <EASTL/vector.h>
@@ -6,10 +6,10 @@
 *********************************************************************/
 #ifndef BIGFOOT_ENGINE_ASSET_ASSETBASE_HPP
 #define BIGFOOT_ENGINE_ASSET_ASSETBASE_HPP
-#include <System/UUID/UUID.hpp>
-
 #include <Engine/Asset/Asset_generated.hpp>

+#include <System/UUID/UUID.hpp>
+
 #include <EASTL/span.h>
 #include <EASTL/vector.h>
 #include <ankerl/unordered_dense.h>
@@ -19,14 +19,13 @@
        return AssetType::GetTypeID();                                                                                 \
    }                                                                                                                  \
    AssetContainer<AssetType> g_containerFor##AssetName;                                                               \
-    bool RegisterAssetContainerFor##AssetName()                                                                        \
+    const bool g_insertedContainerFor##AssetName = []()                                                                \
    {                                                                                                                  \
-        const bool inserted = g_assetLibrary->Insert(&g_containerFor##AssetName);                                      \
+        const bool inserted = g_assetLibrary.Insert(&g_containerFor##AssetName);                                       \
        CRITICAL_ASSERT(EngineAssertHandler,                                                                           \
                        inserted,                                                                                      \
                        "AssetTypeID collision or duplicate registration for asset type '" #AssetName "'");            \
        return inserted;                                                                                               \
-    }                                                                                                                  \
-    const bool g_insertedContainerFor##AssetName = RegisterAssetContainerFor##AssetName();                             \
+    }();                                                                                                               \
    }
 #endif
@@ -10,8 +10,6 @@
 #include <Engine/Asset/AssetContainer.hpp>
 #include <Engine/Asset/AssetTypeID.hpp>

-#include <Utils/LazyGlobal.hpp>
-
 #include <ankerl/unordered_dense.h>

 namespace Bigfoot
@@ -111,44 +109,8 @@ class AssetLibrary
 /****************************************************************************************/

 // The global asset library for Bigfoot
-inline LazyGlobal<AssetLibrary> g_assetLibrary;
-
-class ActiveAssetLibrary
-{
-  public:
-    ActiveAssetLibrary& operator=(AssetLibrary* p_assetLibrary)
-    {
-        Get() = p_assetLibrary;
-        return *this;
-    }
-
-    [[nodiscard]]
-    AssetLibrary* operator->() const
-    {
-        return Get();
-    }
-
-    [[nodiscard]]
-    operator AssetLibrary*() const
-    {
-        return Get();
-    }
-
-  private:
-    /**
-     * Get the ActiveAssetLibrary
-     *
-     * \return The ActiveAssetLibrary
-     */
-    [[nodiscard]]
-    static AssetLibrary*& Get()
-    {
-        static AssetLibrary* activeLibrary = g_assetLibrary;
-        return activeLibrary;
-    }
-};
-
-inline ActiveAssetLibrary g_activeAssetLibrary;
+inline AssetLibrary g_assetLibrary;
+inline AssetLibrary* g_activeAssetLibrary = &g_assetLibrary;

 /****************************************************************************************/

@@ -6,10 +6,10 @@
 *********************************************************************/
 #ifndef BIGFOOT_ENGINE_ENGINEASSERTHANDLER_HPP
 #define BIGFOOT_ENGINE_ENGINEASSERTHANDLER_HPP
-#include <Utils/Assert/AssertHandler.hpp>
-
 #include <Engine/EngineLogger_generated.hpp>

+#include <Utils/Assert/AssertHandler.hpp>
+
 #ifdef BIGFOOT_NOT_OPTIMIZED

 namespace Bigfoot
@@ -15,7 +15,7 @@ namespace Bigfoot
 /*
 * Logger
 */
-inline Log::LoggerInfo ENGINE_LOGGER { .m_name = "ENGINE_LOGGER", .m_level = LogLevel::Trace};
+inline Log::LoggerInfo ENGINE_LOGGER { .m_name = "ENGINE_LOGGER", .m_level = Flat::LogLevel::Trace};
 }  // namespace Bigfoot
 #endif
 #endif
--- a/Show More
+++ b/Show More
				`@@ -1 +0,0 @@`
				`#include <GraphicsCore/GraphicsCoreAssertHandler.hpp>`
				`@@ -1 +0,0 @@`
				`#include <GraphicsInterface/GraphicsInterfaceAssertHandler.hpp>`
				`@@ -1 +0,0 @@`
				`#include <GraphicsVulkan/GraphicsVulkanAssertHandler.hpp>`