From 1f314a6087b276ad8b2680ecb18f43dfe77df595 Mon Sep 17 00:00:00 2001
From: Steven Le Rouzic <steven.lerouzic@gmail.com>
Date: Fri, 31 Jan 2025 00:31:01 +0100
Subject: Make gpu module
---
hk21/game/gpu.cpp | 195 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 195 insertions(+)
create mode 100644 hk21/game/gpu.cpp
(limited to 'hk21/game/gpu.cpp')
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
+
--
cgit