Make gpu module

7 files changed, 232 insertions, 83 deletions

diff --git a/MODULE.bazel b/MODULE.bazel
index 6dfeb1b..141b761 100644
--- a/MODULE.bazel
+++ b/MODULE.bazel
@@ -15,7 +15,7 @@ bazel_dep(name = "sdl3_windows", version = "3.2.0")
 bazel_dep(name = "asl")

 git_override(

     module_name = "asl",

-    commit = "b3f2336e1b8f4410515344feb73d992d854c8282",

+    commit = "a89e72929ed047344e221f65542e763e3f6ac3de",

     remote = "https://git.stevenlr.com/460nm/asl.git/",

 )

 

diff --git a/hk21/game/BUILD.bazel b/hk21/game/BUILD.bazel
index 9aa2e2b..b2cca09 100644
--- a/hk21/game/BUILD.bazel
+++ b/hk21/game/BUILD.bazel
@@ -2,6 +2,8 @@ cc_binary(
     name = "game",

     srcs = [

         "main.cpp",

+        "gpu.cpp",

+        "gpu.hpp",

     ],

     deps = [

         "@asl//asl",

diff --git a/hk21/game/gpu.cpp b/hk21/game/gpu.cpp
new file mode 100644
index 0000000..c18093f
--- /dev/null
+++ b/hk21/game/gpu.cpp
@@ -0,0 +1,195 @@
+#include "hk21/game/gpu.hpp"

+

+#include <asl/buffer.hpp>

+#include <asl/log/log.hpp>

+#include <asl/format.hpp>

+

+#include <SDL3/SDL_vulkan.h>

+

+#include "hk21/vulkan_loader/api.hpp"

+

+#define VK_ALLOCATOR nullptr

+

+[[maybe_unused]] static void AslFormat(asl::Formatter& formatter, VkResult res)

+{

+    switch (res) // NOLINT

+    {

+    case VK_SUCCESS: formatter.write("VK_SUCCESS"); break;

+    case VK_NOT_READY: formatter.write("VK_NOT_READY"); break;

+    case VK_TIMEOUT: formatter.write("VK_TIMEOUT"); break;

+    case VK_EVENT_SET: formatter.write("VK_EVENT_SET"); break;

+    case VK_EVENT_RESET: formatter.write("VK_EVENT_RESET"); break;

+    case VK_INCOMPLETE: formatter.write("VK_INCOMPLETE"); break;

+    case VK_ERROR_OUT_OF_HOST_MEMORY: formatter.write("VK_ERROR_OUT_OF_HOST_MEMORY"); break;

+    case VK_ERROR_OUT_OF_DEVICE_MEMORY: formatter.write("VK_ERROR_OUT_OF_DEVICE_MEMORY"); break;

+    case VK_ERROR_INITIALIZATION_FAILED: formatter.write("VK_ERROR_INITIALIZATION_FAILED"); break;

+    case VK_ERROR_DEVICE_LOST: formatter.write("VK_ERROR_DEVICE_LOST"); break;

+    case VK_ERROR_MEMORY_MAP_FAILED: formatter.write("VK_ERROR_MEMORY_MAP_FAILED"); break;

+    case VK_ERROR_LAYER_NOT_PRESENT: formatter.write("VK_ERROR_LAYER_NOT_PRESENT"); break;

+    case VK_ERROR_EXTENSION_NOT_PRESENT: formatter.write("VK_ERROR_EXTENSION_NOT_PRESENT"); break;

+    case VK_ERROR_FEATURE_NOT_PRESENT: formatter.write("VK_ERROR_FEATURE_NOT_PRESENT"); break;

+    case VK_ERROR_INCOMPATIBLE_DRIVER: formatter.write("VK_ERROR_INCOMPATIBLE_DRIVER"); break;

+    case VK_ERROR_TOO_MANY_OBJECTS: formatter.write("VK_ERROR_TOO_MANY_OBJECTS"); break;

+    case VK_ERROR_FORMAT_NOT_SUPPORTED: formatter.write("VK_ERROR_FORMAT_NOT_SUPPORTED"); break;

+    case VK_ERROR_FRAGMENTED_POOL: formatter.write("VK_ERROR_FRAGMENTED_POOL"); break;

+    case VK_ERROR_UNKNOWN: formatter.write("VK_ERROR_UNKNOWN"); break;

+    case VK_ERROR_OUT_OF_POOL_MEMORY: formatter.write("VK_ERROR_OUT_OF_POOL_MEMORY"); break;

+    case VK_ERROR_INVALID_EXTERNAL_HANDLE: formatter.write("VK_ERROR_INVALID_EXTERNAL_HANDLE"); break;

+    case VK_ERROR_FRAGMENTATION: formatter.write("VK_ERROR_FRAGMENTATION"); break;

+    case VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS: formatter.write("VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS"); break;

+    case VK_PIPELINE_COMPILE_REQUIRED: formatter.write("VK_PIPELINE_COMPILE_REQUIRED"); break;

+    case VK_ERROR_NOT_PERMITTED: formatter.write("VK_ERROR_NOT_PERMITTED"); break;

+    case VK_ERROR_SURFACE_LOST_KHR: formatter.write("VK_ERROR_SURFACE_LOST_KHR"); break;

+    case VK_ERROR_NATIVE_WINDOW_IN_USE_KHR: formatter.write("VK_ERROR_NATIVE_WINDOW_IN_USE_KHR"); break;

+    case VK_SUBOPTIMAL_KHR: formatter.write("VK_SUBOPTIMAL_KHR"); break;

+    case VK_ERROR_OUT_OF_DATE_KHR: formatter.write("VK_ERROR_OUT_OF_DATE_KHR"); break;

+    case VK_ERROR_INCOMPATIBLE_DISPLAY_KHR: formatter.write("VK_ERROR_INCOMPATIBLE_DISPLAY_KHR"); break;

+    case VK_ERROR_VALIDATION_FAILED_EXT: formatter.write("VK_ERROR_VALIDATION_FAILED_EXT"); break;

+    case VK_ERROR_INVALID_SHADER_NV: formatter.write("VK_ERROR_INVALID_SHADER_NV"); break;

+    case VK_ERROR_IMAGE_USAGE_NOT_SUPPORTED_KHR: formatter.write("VK_ERROR_IMAGE_USAGE_NOT_SUPPORTED_KHR"); break;

+    case VK_ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR: formatter.write("VK_ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR"); break;

+    case VK_ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR: formatter.write("VK_ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR"); break;

+    case VK_ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR: formatter.write("VK_ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR"); break;

+    case VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR: formatter.write("VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR"); break;

+    case VK_ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR: formatter.write("VK_ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR"); break;

+    case VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT: formatter.write("VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT"); break;

+    case VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT: formatter.write("VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT"); break;

+    case VK_THREAD_IDLE_KHR: formatter.write("VK_THREAD_IDLE_KHR"); break;

+    case VK_THREAD_DONE_KHR: formatter.write("VK_THREAD_DONE_KHR"); break;

+    case VK_OPERATION_DEFERRED_KHR: formatter.write("VK_OPERATION_DEFERRED_KHR"); break;

+    case VK_OPERATION_NOT_DEFERRED_KHR: formatter.write("VK_OPERATION_NOT_DEFERRED_KHR"); break;

+    case VK_ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR: formatter.write("VK_ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR"); break;

+    case VK_ERROR_COMPRESSION_EXHAUSTED_EXT: formatter.write("VK_ERROR_COMPRESSION_EXHAUSTED_EXT"); break;

+    case VK_INCOMPATIBLE_SHADER_BINARY_EXT: formatter.write("VK_INCOMPATIBLE_SHADER_BINARY_EXT"); break;

+    case VK_PIPELINE_BINARY_MISSING_KHR: formatter.write("VK_PIPELINE_BINARY_MISSING_KHR"); break;

+    case VK_ERROR_NOT_ENOUGH_SPACE_KHR: formatter.write("VK_ERROR_NOT_ENOUGH_SPACE_KHR"); break;

+    default: formatter.write("Unknown Vulkan error"); break;

+    }

+}

+

+namespace gpu

+{

+

+class GpuImpl : public Gpu

+{

+    bool m_destroyed{};

+    

+    VkInstance     m_instance;

+    VkSurfaceKHR   m_surface;

+

+public:

+    GpuImpl(VkInstance instance, VkSurfaceKHR surface)

+        : m_instance{instance}

+        , m_surface{surface}

+    {}

+

+    ASL_DELETE_COPY_MOVE(GpuImpl);

+

+    ~GpuImpl() override

+    {

+        ASL_ASSERT(m_destroyed);

+    }

+    

+    void destroy() override

+    {

+        ASL_ASSERT(!m_destroyed);

+        m_destroyed = true;

+        vkDestroySurfaceKHR(m_instance, m_surface, VK_ALLOCATOR);

+        vkDestroyInstance(m_instance, VK_ALLOCATOR);

+    }

+};

+

+static asl::status_or<VkInstance> create_instance()

+{

+    asl::buffer<const char*> instance_extensions;

+    asl::buffer<const char*> layers;

+    {

+        uint32_t count = 0;

+        const char* const* extensions = SDL_Vulkan_GetInstanceExtensions(&count);

+        for (uint32_t i = 0; i < count; ++i)

+        {

+            instance_extensions.push(extensions[i]); // NOLINT(*-pointer-arithmetic)

+        }

+    }

+

+    layers.push("VK_LAYER_KHRONOS_validation");

+    layers.push("VK_LAYER_LUNARG_monitor");

+

+    instance_extensions.push(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);

+    

+    auto vkGetInstanceProcAddr = asl::bit_cast<PFN_vkGetInstanceProcAddr>(SDL_Vulkan_GetVkGetInstanceProcAddr());

+    auto status = vulkan_loader::load_global(vkGetInstanceProcAddr);

+    ASL_TRY(status);

+

+    uint32_t version{};

+    vkEnumerateInstanceVersion(&version);

+

+    uint32_t vk_major = VK_API_VERSION_MAJOR(version); // NOLINT

+    uint32_t vk_minor = VK_API_VERSION_MINOR(version); // NOLINT

+

+    if (vk_major != 1 || vk_minor < 3)

+    {

+        return asl::runtime_error("Incompatible Vulkan version: {}.{}", vk_major, vk_minor);

+    }

+    

+    VkApplicationInfo app_info{

+        .sType                = VK_STRUCTURE_TYPE_APPLICATION_INFO,

+        .pNext                = nullptr,

+        .pApplicationName     = "HK-21",

+        .applicationVersion   = 0,

+        .pEngineName          = "Custom",

+        .engineVersion        = 0,

+        .apiVersion           = VK_MAKE_API_VERSION(0, 1, 3, 0), // NOLINT

+    };

+

+    VkInstanceCreateInfo instance_create_info{

+        .sType                   = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,

+        .pNext                   = nullptr,

+        .flags                   = 0,

+        .pApplicationInfo        = &app_info,

+        .enabledLayerCount       = static_cast<uint32_t>(layers.size()),

+        .ppEnabledLayerNames     = layers.data(),

+        .enabledExtensionCount   = static_cast<uint32_t>(instance_extensions.size()),

+        .ppEnabledExtensionNames = instance_extensions.data(),

+    };

+

+    VkInstance instance{};

+    VkResult res = vkCreateInstance(&instance_create_info, VK_ALLOCATOR, &instance);

+    if (res != VK_SUCCESS)

+    {

+        return asl::runtime_error("Couldn't create Vulkan instance: {}", res);

+    }

+    

+    status = vulkan_loader::load_instance(vkGetInstanceProcAddr, instance);

+    ASL_TRY(status);

+

+    return instance;

+}

+

+static asl::status_or<VkSurfaceKHR> create_surface(SDL_Window* window, VkInstance instance)

+{

+    VkSurfaceKHR surface{};

+    if (!SDL_Vulkan_CreateSurface(window, instance, VK_ALLOCATOR, &surface))

+    {

+        return asl::runtime_error("Couldn't create Vulkan surface");

+    }

+

+    return surface;

+}

+

+asl::status_or<asl::box<Gpu>> init(SDL_Window* window)

+{

+    auto instance = create_instance();

+    ASL_TRY(instance);

+

+    auto surface = create_surface(window, instance.value());

+    ASL_TRY(surface);

+

+    // asl::buffer<const char*> device_extensions;

+    // device_extensions.push(VK_KHR_SWAPCHAIN_EXTENSION_NAME);

+

+    return asl::make_box<GpuImpl>(instance.value(), surface.value());

+};

+

+} // namespace gpu

+

diff --git a/hk21/game/gpu.hpp b/hk21/game/gpu.hpp
new file mode 100644
index 0000000..40a0973
--- /dev/null
+++ b/hk21/game/gpu.hpp
@@ -0,0 +1,23 @@
+#pragma once

+

+#include <asl/status_or.hpp>

+#include <asl/box.hpp>

+

+struct SDL_Window;

+

+namespace gpu

+{

+

+class Gpu

+{

+public:

+    Gpu() = default;

+    ASL_DELETE_COPY_MOVE(Gpu);

+    virtual ~Gpu() = default;

+

+    virtual void destroy() = 0;

+};

+

+asl::status_or<asl::box<Gpu>> init(SDL_Window* window);

+

+} // namespace gpu

diff --git a/hk21/game/main.cpp b/hk21/game/main.cpp
index 03bc77b..2a9414e 100644
--- a/hk21/game/main.cpp
+++ b/hk21/game/main.cpp
@@ -1,14 +1,9 @@
-#include <asl/print.hpp>

-#include <asl/buffer.hpp>

 #include <asl/log/log.hpp>

 

 #include <SDL3/SDL.h>

 #include <SDL3/SDL_main.h>

-#include <SDL3/SDL_vulkan.h>

 

-#include "hk21/vulkan_loader/api.hpp"

-

-#define VK_ALLOCATOR nullptr

+#include "hk21/game/gpu.hpp"

 

 int SDL_main(int /* argc */, char* /* argv */[])

 {

@@ -17,82 +12,14 @@ int SDL_main(int /* argc */, char* /* argv */[])
 

     SDL_ShowWindow(window);

 

-    asl::buffer<const char*> instance_extensions;

-    asl::buffer<const char*> device_extensions;

-    asl::buffer<const char*> layers;

-

-    {

-        uint32_t count = 0;

-        const char* const* extensions = SDL_Vulkan_GetInstanceExtensions(&count);

-        for (uint32_t i = 0; i < count; ++i)

-        {

-            instance_extensions.push(extensions[i]); // NOLINT(*-pointer-arithmetic)

-        }

-    }

-

-    layers.push("VK_LAYER_KHRONOS_validation");

-    layers.push("VK_LAYER_LUNARG_monitor");

-

-    instance_extensions.push(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);

-

-    device_extensions.push(VK_KHR_SWAPCHAIN_EXTENSION_NAME);

-    

-    auto vkGetInstanceProcAddr = asl::bit_cast<PFN_vkGetInstanceProcAddr>(SDL_Vulkan_GetVkGetInstanceProcAddr());

-    auto status = vulkan_loader::load_global(vkGetInstanceProcAddr);

-    if (!status.ok())

-    {

-        ASL_LOG_ERROR("Couldn't load global Vulkan functions: {}", status);

-        return 1;

-    }

-

-    uint32_t version{};

-    vkEnumerateInstanceVersion(&version);

-

-    uint32_t vk_major = VK_API_VERSION_MAJOR(version); // NOLINT

-    uint32_t vk_minor = VK_API_VERSION_MINOR(version); // NOLINT

-

-    if (vk_major != 1 || vk_minor < 3)

+    auto gpu_opt = gpu::init(window);

+    if (!gpu_opt.ok())

     {

-        ASL_LOG_ERROR("Incompatible Vulkan version: {}.{}", vk_major, vk_minor);

+        ASL_LOG_ERROR("Couldn't initialize GPU: {}", gpu_opt);

         return 1;

     }

+    auto gpu = ASL_MOVE(gpu_opt).value();

 

-    VkApplicationInfo app_info{

-        .sType                = VK_STRUCTURE_TYPE_APPLICATION_INFO,

-        .pNext                = nullptr,

-        .pApplicationName     = "HK-21",

-        .applicationVersion   = 0,

-        .pEngineName          = "Custom",

-        .engineVersion        = 0,

-        .apiVersion           = VK_MAKE_API_VERSION(0, 1, 3, 0), // NOLINT

-    };

-

-    VkInstanceCreateInfo instance_create_info{

-        .sType                   = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,

-        .pNext                   = nullptr,

-        .flags                   = 0,

-        .pApplicationInfo        = &app_info,

-        .enabledLayerCount       = static_cast<uint32_t>(layers.size()),

-        .ppEnabledLayerNames     = layers.data(),

-        .enabledExtensionCount   = static_cast<uint32_t>(instance_extensions.size()),

-        .ppEnabledExtensionNames = instance_extensions.data(),

-    };

-

-    VkInstance instance{};

-    VkResult res = vkCreateInstance(&instance_create_info, VK_ALLOCATOR, &instance);

-    if (res != VK_SUCCESS)

-    {

-        ASL_LOG_ERROR("Couldn't create Vulkan instance: {}", res);

-        return 1;

-    }

-    

-    status = vulkan_loader::load_instance(vkGetInstanceProcAddr, instance);

-    if (!status.ok())

-    {

-        ASL_LOG_ERROR("Couldn't load instance Vulkan functions: {}", status);

-        return 1;

-    }

-   

     bool running = true;

     while (running)

     {

@@ -108,7 +35,8 @@ int SDL_main(int /* argc */, char* /* argv */[])
         SDL_Delay(16);

     }

 

-    vkDestroyInstance(instance, VK_ALLOCATOR);

+    gpu->destroy();

+    

     SDL_DestroyWindow(window);

     SDL_Quit();

     

diff --git a/hk21/vulkan_loader/fns.hpp b/hk21/vulkan_loader/fns.hpp
index c0e8f85..ceb1105 100644
--- a/hk21/vulkan_loader/fns.hpp
+++ b/hk21/vulkan_loader/fns.hpp
@@ -3,4 +3,5 @@
     FN(vkCreateInstance)

     

 #define VULKAN_INSTANCE_FNS \

-    FN(vkDestroyInstance)

+    FN(vkDestroyInstance) \

+    FN(vkDestroySurfaceKHR)

diff --git a/hk21/vulkan_loader/loader.cpp b/hk21/vulkan_loader/loader.cpp
index c805fb1..2a58cd9 100644
--- a/hk21/vulkan_loader/loader.cpp
+++ b/hk21/vulkan_loader/loader.cpp
@@ -21,7 +21,7 @@ asl::status vulkan_loader::load_global(PFN_vkGetInstanceProcAddr load_fn)
 VULKAN_GLOBAL_FNS

 #undef FN

 

-    return has_errors ? asl::runtime_error() : asl::ok();

+    return has_errors ? asl::runtime_error("Couldn't load Vulkan global functions") : asl::ok();

 }

 

 asl::status vulkan_loader::load_instance(PFN_vkGetInstanceProcAddr load_fn, VkInstance instance)

@@ -40,6 +40,6 @@ asl::status vulkan_loader::load_instance(PFN_vkGetInstanceProcAddr load_fn, VkIn
 VULKAN_INSTANCE_FNS

 #undef FN

 

-    return has_errors ? asl::runtime_error() : asl::ok();

+    return has_errors ? asl::runtime_error("Couldn't load Vulkan instance functions") : asl::ok();

 }