Setup device and queue

main.cpp

@@ -10,7 +10,7 @@ namespace PB::Renderer
         if (!GLFWManager::Cleanup())
             std::exit(EXIT_FAILURE);
 
-        if (VulkanManager::Cleanup())
+        if (!VulkanManager::Cleanup())
             std::exit(EXIT_FAILURE);
 
         std::exit(code);
@@ -30,20 +30,8 @@ int main()
         return -1;
 
     /* Runs Vulkan initialisation functions */
-    if (const std::optional<VkInstance> instance = VulkanManager::Init(); !instance)
+    if (!VulkanManager::InitAll(window))
-    {
-        GLFWManager::Cleanup();
-    }
-
-    if (const std::optional<VkSurfaceKHR> surface = VulkanManager::CreateSurface(window); !surface)
-    {
         CleanupAllAndExit(EXIT_FAILURE);
-    }
-
-    if (!VulkanManager::PickPhysicalDevice())
-    {
-        CleanupAllAndExit(EXIT_FAILURE);
-    }
 
     /* Polls window events whilst it is still open */
     while (!glfwWindowShouldClose(window))

src/managers/VulkanManager.cpp

@@ -8,6 +8,28 @@ namespace PB::Renderer
     VkPhysicalDevice VulkanManager::s_PhysicalDevice = VK_NULL_HANDLE;
     QueueFamilyIndices VulkanManager::s_QueueIndices;
 
+    VkDevice VulkanManager::s_Device = VK_NULL_HANDLE;
+
+    VkQueue VulkanManager::s_GraphicsQueue = VK_NULL_HANDLE;
+    VkQueue VulkanManager::s_PresentQueue = VK_NULL_HANDLE;
+
+    bool VulkanManager::InitAll(GLFWwindow* window)
+    {
+        if (const std::optional<VkInstance> instance = VulkanManager::Init(); !instance)
+            return false;
+
+        if (const std::optional<VkSurfaceKHR> surface = VulkanManager::CreateSurface(window); !surface)
+            return false;
+
+        if (!VulkanManager::PickPhysicalDevice())
+            return false;
+
+        if (!VulkanManager::CreateLogicalDevice())
+            return false;
+
+        return true;
+    }
+
     std::optional<VkInstance> VulkanManager::Init()
     {
         /* Stops multi initialisation */
@@ -140,7 +162,7 @@ namespace PB::Renderer
         std::vector<VkQueueFamilyProperties> queueFamilies(queueFamilyCount);
         vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyCount, queueFamilies.data());
 
-        int index = -1;
+        int index = 0;
         for (const auto& family : queueFamilies)
         {
             if (family.queueFlags & VK_QUEUE_GRAPHICS_BIT)
@@ -187,6 +209,53 @@ namespace PB::Renderer
 
     }
 
+    bool VulkanManager::CreateLogicalDevice()
+    {
+        std::set<uint32_t> uniqueQueueFamilies =
+        {
+            s_QueueIndices.graphicsFamily.value(),
+            s_QueueIndices.presentFamily.value()
+        };
+
+        std::vector<VkDeviceQueueCreateInfo> queueCreateInfos;
+        float queuePriority = 1.0f;
+
+        for (uint32_t queueFamily : uniqueQueueFamilies)
+        {
+            VkDeviceQueueCreateInfo queueCreateInfo{};
+            queueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
+            queueCreateInfo.queueFamilyIndex = queueFamily;
+            queueCreateInfo.queueCount = 1;
+            queueCreateInfo.pQueuePriorities = &queuePriority;
+            queueCreateInfos.push_back(queueCreateInfo);
+        }
+
+        VkPhysicalDeviceFeatures deviceFeatures{};
+
+        const std::vector<const char*> extensions = {
+            VK_KHR_SWAPCHAIN_EXTENSION_NAME
+        };
+
+        VkDeviceCreateInfo createInfo{};
+        createInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
+        createInfo.queueCreateInfoCount = static_cast<uint32_t>(queueCreateInfos.size());
+        createInfo.pQueueCreateInfos = queueCreateInfos.data();
+        createInfo.pEnabledFeatures = &deviceFeatures;
+        createInfo.enabledExtensionCount = static_cast<uint32_t>(extensions.size());
+        createInfo.ppEnabledExtensionNames = extensions.data();
+
+        if (vkCreateDevice(s_PhysicalDevice, &createInfo, nullptr, &s_Device))
+        {
+            std::cout << "Failed to create logical device" << std::endl;
+            return false;
+        }
+
+        vkGetDeviceQueue(s_Device, s_QueueIndices.graphicsFamily.value(), 0, &s_GraphicsQueue);
+        vkGetDeviceQueue(s_Device, s_QueueIndices.presentFamily.value(), 0, &s_PresentQueue);
+
+        return true;
+    }
+
     bool VulkanManager::Cleanup()
     {
         if (s_Surface != std::nullopt)

src/managers/VulkanManager.h

@@ -18,11 +18,13 @@ namespace PB::Renderer
     class VulkanManager
     {
         public:
+            static bool InitAll(GLFWwindow* window);
             static std::optional<VkInstance> Init();
             static bool Cleanup();
 
             static std::optional<VkSurfaceKHR> CreateSurface(GLFWwindow* window);
             static bool PickPhysicalDevice();
+            static bool CreateLogicalDevice();
 
         private:
             static bool IsDeviceSuitable(VkPhysicalDevice device, VkSurfaceKHR surface);
@@ -34,5 +36,10 @@ namespace PB::Renderer
 
             static VkPhysicalDevice s_PhysicalDevice;
             static QueueFamilyIndices s_QueueIndices;
+
+            static VkDevice s_Device;
+
+            static VkQueue s_GraphicsQueue;
+            static VkQueue s_PresentQueue;
     };
 }