From 1f314a6087b276ad8b2680ecb18f43dfe77df595 Mon Sep 17 00:00:00 2001 From: Steven Le Rouzic Date: Fri, 31 Jan 2025 00:31:01 +0100 Subject: Make gpu module --- hk21/game/BUILD.bazel | 2 + hk21/game/gpu.cpp | 195 ++++++++++++++++++++++++++++++++++++++++++ hk21/game/gpu.hpp | 23 +++++ hk21/game/main.cpp | 86 ++----------------- hk21/vulkan_loader/fns.hpp | 3 +- hk21/vulkan_loader/loader.cpp | 4 +- 6 files changed, 231 insertions(+), 82 deletions(-) create mode 100644 hk21/game/gpu.cpp create mode 100644 hk21/game/gpu.hpp (limited to 'hk21') 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 +#include +#include + +#include + +#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 create_instance() +{ + asl::buffer instance_extensions; + asl::buffer 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(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(layers.size()), + .ppEnabledLayerNames = layers.data(), + .enabledExtensionCount = static_cast(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 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> init(SDL_Window* window) +{ + auto instance = create_instance(); + ASL_TRY(instance); + + auto surface = create_surface(window, instance.value()); + ASL_TRY(surface); + + // asl::buffer device_extensions; + // device_extensions.push(VK_KHR_SWAPCHAIN_EXTENSION_NAME); + + return asl::make_box(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 +#include + +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> 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 -#include #include #include #include -#include -#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 instance_extensions; - asl::buffer device_extensions; - asl::buffer 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(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(layers.size()), - .ppEnabledLayerNames = layers.data(), - .enabledExtensionCount = static_cast(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(); } -- cgit