Vulkan device creation

4 files changed, 168 insertions, 9 deletions

diff --git a/hk21/game/gpu.cpp b/hk21/game/gpu.cpp
index c18093f..9122f83 100644
--- a/hk21/game/gpu.cpp
+++ b/hk21/game/gpu.cpp
@@ -74,13 +74,24 @@ class GpuImpl : public Gpu
 {

     bool m_destroyed{};

     

-    VkInstance     m_instance;

-    VkSurfaceKHR   m_surface;

+    VkInstance           m_instance;

+    VkSurfaceKHR         m_surface;

+    uint32_t             m_queue_family_index;

+    VkDevice             m_device;

+    VkQueue              m_queue;

 

 public:

-    GpuImpl(VkInstance instance, VkSurfaceKHR surface)

+    GpuImpl(

+        VkInstance instance,

+        VkSurfaceKHR surface,

+        uint32_t queue_family_index,

+        VkDevice device,

+        VkQueue queue)

         : m_instance{instance}

         , m_surface{surface}

+        , m_queue_family_index{queue_family_index}

+        , m_device{device}

+        , m_queue{queue}

     {}

 

     ASL_DELETE_COPY_MOVE(GpuImpl);

@@ -94,11 +105,16 @@ public:
     {

         ASL_ASSERT(!m_destroyed);

         m_destroyed = true;

+        vkDestroyDevice(m_device, VK_ALLOCATOR);

         vkDestroySurfaceKHR(m_instance, m_surface, VK_ALLOCATOR);

         vkDestroyInstance(m_instance, VK_ALLOCATOR);

     }

 };

 

+static uint32_t kTargetVersionMajor = 1;

+static uint32_t kTargetVersionMinor = 3;

+static uint32_t kTargetVersion = VK_MAKE_API_VERSION(0, kTargetVersionMajor, kTargetVersionMinor, 0); // NOLINT

+

 static asl::status_or<VkInstance> create_instance()

 {

     asl::buffer<const char*> instance_extensions;

@@ -127,7 +143,7 @@ static asl::status_or<VkInstance> create_instance()
     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)

+    if (vk_major != kTargetVersionMajor || vk_minor < kTargetVersionMinor)

     {

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

     }

@@ -139,7 +155,7 @@ static asl::status_or<VkInstance> create_instance()
         .applicationVersion   = 0,

         .pEngineName          = "Custom",

         .engineVersion        = 0,

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

+        .apiVersion           = kTargetVersion,

     };

 

     VkInstanceCreateInfo instance_create_info{

@@ -163,6 +179,8 @@ static asl::status_or<VkInstance> create_instance()
     status = vulkan_loader::load_instance(vkGetInstanceProcAddr, instance);

     ASL_TRY(status);

 

+    ASL_LOG_INFO("Vulkan instance created");

+

     return instance;

 }

 

@@ -177,6 +195,105 @@ static asl::status_or<VkSurfaceKHR> create_surface(SDL_Window* window, VkInstanc
     return surface;

 }

 

+struct PhysicalDeviceInfo

+{

+    VkPhysicalDevice physical_device;

+    uint32_t queue_family_index;

+};

+

+static asl::status_or<PhysicalDeviceInfo> find_physical_device(VkInstance instance)

+{

+    uint32_t count{};

+    asl::buffer<VkPhysicalDevice> physical_devices;

+    asl::buffer<VkQueueFamilyProperties> queue_family_prps;

+    

+    vkEnumeratePhysicalDevices(instance, &count, nullptr);

+    physical_devices.resize_zero(count);

+    VkResult res = vkEnumeratePhysicalDevices(instance, &count, physical_devices.data());

+    if (res != VK_SUCCESS)

+    {

+        return asl::runtime_error("Couldn't enumerate Vulkan physical devices: {}", res);

+    }

+

+    for (auto* physical_device: physical_devices)

+    {

+        VkPhysicalDeviceProperties prps;

+        vkGetPhysicalDeviceProperties(physical_device, &prps);

+

+        asl::string_view name{prps.deviceName, asl::strlen(prps.deviceName)};

+

+        if (prps.apiVersion < kTargetVersion)

+        {

+            ASL_LOG_INFO("Device {}: invalid supported Vulkan API version", name);

+            continue;

+        }

+

+        uint32_t queue_family_count{};

+        vkGetPhysicalDeviceQueueFamilyProperties(physical_device, &queue_family_count, nullptr);

+        queue_family_prps.resize_zero(queue_family_count);

+        vkGetPhysicalDeviceQueueFamilyProperties(physical_device, &queue_family_count, queue_family_prps.data());

+

+        static constexpr VkQueueFlags kWantedQueueFlags = VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT | VK_QUEUE_TRANSFER_BIT;

+

+        for (uint32_t queue_family_index = 0; queue_family_index < queue_family_count; ++queue_family_index)

+        {

+            if ((queue_family_prps[queue_family_index].queueFlags & kWantedQueueFlags) != kWantedQueueFlags) { continue; }

+            if (!SDL_Vulkan_GetPresentationSupport(instance, physical_device, queue_family_index)) { continue; }

+

+            ASL_LOG_INFO("Chosing device \"{}\" with queue family {}", name, queue_family_index);

+            return PhysicalDeviceInfo{ physical_device, queue_family_index };

+        }

+

+        ASL_LOG_INFO("Device {}: no valid queue found", name);

+    }

+

+    return asl::runtime_error("Couldn't find a valid Vulkan physical device");

+}

+

+static asl::status_or<VkDevice> create_device(VkPhysicalDevice physical_device, uint32_t queue_family_index)

+{

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

+    device_extensions.push(VK_KHR_SWAPCHAIN_EXTENSION_NAME);

+    

+    const float queue_priority = 1.0F;

+    

+    VkDeviceQueueCreateInfo queue_create_info{

+        .sType                    = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,

+        .pNext                    = nullptr,

+        .flags                    = 0,

+        .queueFamilyIndex         = queue_family_index,

+        .queueCount               = 1,

+        .pQueuePriorities         = &queue_priority,

+    };

+

+    VkDeviceCreateInfo create_info{

+        .sType                    = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,

+        .pNext                    = nullptr,

+        .flags                    = 0,

+        .queueCreateInfoCount     = 1,

+        .pQueueCreateInfos        = &queue_create_info,

+        .enabledLayerCount        = 0,

+        .ppEnabledLayerNames      = nullptr,

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

+        .ppEnabledExtensionNames  = device_extensions.data(),

+        .pEnabledFeatures         = nullptr,

+    };

+

+    VkDevice device{};

+    VkResult res = vkCreateDevice(physical_device, &create_info, VK_ALLOCATOR, &device);

+    if (res != VK_SUCCESS)

+    {

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

+    }

+

+    ASL_LOG_INFO("Vulkan device created");

+

+    auto status = vulkan_loader::load_device(device);

+    ASL_TRY(status);

+

+    return device;

+}

+

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

 {

     auto instance = create_instance();

@@ -185,10 +302,23 @@ asl::status_or<asl::box<Gpu>> init(SDL_Window* window)
     auto surface = create_surface(window, instance.value());

     ASL_TRY(surface);

 

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

-    // device_extensions.push(VK_KHR_SWAPCHAIN_EXTENSION_NAME);

+    auto physical_device_info = find_physical_device(instance.value());

+    ASL_TRY(physical_device_info);

+

+    auto device = create_device(

+        physical_device_info.value().physical_device,

+        physical_device_info.value().queue_family_index);

+    ASL_TRY(device);

+

+    VkQueue queue{};

+    vkGetDeviceQueue(device.value(), physical_device_info.value().queue_family_index, 0, &queue);

 

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

+    return asl::make_box<GpuImpl>(

+        instance.value(),

+        surface.value(),

+        physical_device_info.value().queue_family_index,

+        device.value(),

+        queue);

 };

 

 } // namespace gpu

diff --git a/hk21/vulkan_loader/api.hpp b/hk21/vulkan_loader/api.hpp
index c248737..06e447a 100644
--- a/hk21/vulkan_loader/api.hpp
+++ b/hk21/vulkan_loader/api.hpp
@@ -13,6 +13,7 @@
 #define FN(NAME) extern PFN_##NAME NAME;

 VULKAN_GLOBAL_FNS

 VULKAN_INSTANCE_FNS

+VULKAN_DEVICE_FNS

 #undef FN

 

 namespace vulkan_loader

@@ -20,6 +21,7 @@ namespace vulkan_loader
 

 asl::status load_global(PFN_vkGetInstanceProcAddr load_fn);

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

+asl::status load_device(VkDevice device);

 

 } // namespace vulkan_loader

 

diff --git a/hk21/vulkan_loader/fns.hpp b/hk21/vulkan_loader/fns.hpp
index ceb1105..09b6926 100644
--- a/hk21/vulkan_loader/fns.hpp
+++ b/hk21/vulkan_loader/fns.hpp
@@ -4,4 +4,13 @@
     

 #define VULKAN_INSTANCE_FNS \

     FN(vkDestroyInstance) \

-    FN(vkDestroySurfaceKHR)

+    FN(vkDestroySurfaceKHR) \

+    FN(vkEnumeratePhysicalDevices) \

+    FN(vkGetPhysicalDeviceProperties) \

+    FN(vkGetPhysicalDeviceQueueFamilyProperties) \

+    FN(vkCreateDevice) \

+    FN(vkGetDeviceProcAddr)

+

+#define VULKAN_DEVICE_FNS \

+    FN(vkDestroyDevice) \

+    FN(vkGetDeviceQueue)

diff --git a/hk21/vulkan_loader/loader.cpp b/hk21/vulkan_loader/loader.cpp
index 2a58cd9..4b2b6d6 100644
--- a/hk21/vulkan_loader/loader.cpp
+++ b/hk21/vulkan_loader/loader.cpp
@@ -3,6 +3,7 @@
 #define FN(NAME) PFN_##NAME NAME;

 VULKAN_GLOBAL_FNS

 VULKAN_INSTANCE_FNS

+VULKAN_DEVICE_FNS

 #undef FN

 

 asl::status vulkan_loader::load_global(PFN_vkGetInstanceProcAddr load_fn)

@@ -43,3 +44,20 @@ VULKAN_INSTANCE_FNS
     return has_errors ? asl::runtime_error("Couldn't load Vulkan instance functions") : asl::ok();

 }

 

+asl::status vulkan_loader::load_device(VkDevice device)

+{

+    bool has_errors = false;

+    

+#define FN(NAME) \

+    NAME = asl::bit_cast<PFN_##NAME>(vkGetDeviceProcAddr(device, #NAME)); \

+    if (NAME == nullptr) \

+    { \

+        ASL_ASSERT(NAME != nullptr); \

+        has_errors = true; \

+    }

+VULKAN_DEVICE_FNS

+#undef FN

+

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

+}

+