460nm/hk21
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Make gpu module

Browse Source
This commit is contained in:
Steven Le Rouzic
2025-01-31 00:31:01 +01:00
parent d3e00990b8
commit 1f314a6087
7 changed files with 232 additions and 83 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
MODULE.bazel
View File

@ -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/",
)

2
hk21/game/BUILD.bazel
View File

@ -2,6 +2,8 @@ cc_binary(
name = "game",
srcs = [
"main.cpp",
"gpu.cpp",
"gpu.hpp",
],
deps = [
"@asl//asl",

195
hk21/game/gpu.cpp Normal file
View File

@ -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

23
hk21/game/gpu.hpp Normal file
View File

@ -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

86
hk21/game/main.cpp
View File

@ -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;
auto gpu_opt = gpu::init(window);
if (!gpu_opt.ok())
{
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);
ASL_LOG_ERROR("Couldn't initialize GPU: {}", gpu_opt);
return 1;
}
auto gpu = ASL_MOVE(gpu_opt).value();
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)
{
ASL_LOG_ERROR("Incompatible Vulkan version: {}.{}", vk_major, vk_minor);
return 1;
}
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();

3
hk21/vulkan_loader/fns.hpp
View File

@ -3,4 +3,5 @@
FN(vkCreateInstance)
#define VULKAN_INSTANCE_FNS \
FN(vkDestroyInstance)
FN(vkDestroyInstance) \
FN(vkDestroySurfaceKHR)

4
hk21/vulkan_loader/loader.cpp
View File

@ -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();
}