Creating a swapchain

Hello_triangle/main.cpp

@@ -1,6 +1,6 @@
 /*
     Following the vulkan tutorial on :
-    https://vulkan-tutorial.com/en/Drawing_a_triangle/Presentation/Window_surface
+   https://vulkan-tutorial.com/en/Drawing_a_triangle/Presentation/Swap_chain
 */
 
 #define GLFW_INCLUDE_VULKAN
@@ -8,6 +8,9 @@
 #include <iostream>
 #include <stdexcept>
 #include <cstdlib>
+#include <cstdint>
+#include <limits>
+#include <algorithm>
 #include <vector>
 #include <cstring>
 #include <optional>
@@ -21,6 +24,10 @@ const std::vector<const char*> validationLayers ={
     "VK_LAYER_KHRONOS_validation"
 };
 
+const std::vector<const char*> deviceExtensions = {
+    VK_KHR_SWAPCHAIN_EXTENSION_NAME
+};
+
 #ifdef NDEBUG  
     const bool enableValidationLayers = false;
 # else
@@ -47,6 +54,17 @@ class HelloTriangleApplication{
         VkDevice device;
         VkQueue graphicsQueue;
         VkQueue  presentQueue;
+        VkSwapchainKHR swapChain;
+        std::vector<VkImage> swapChainImages;
+        VkFormat swapChainImageFormat;
+        VkExtent2D swapChainExtent;
+
+        struct SwapChainSupportDetails {
+            VkSurfaceCapabilitiesKHR capabilities;
+            std::vector<VkSurfaceFormatKHR> formats;
+            std::vector<VkPresentModeKHR> presentModes;
+        };
+
 
         void initWindow() {
             glfwInit();
@@ -63,6 +81,7 @@ class HelloTriangleApplication{
             createSurface();
             pickPhysicalDevice();
             createLogicalDevice();
+            createSwapChain();
 
         }
 
@@ -83,7 +102,7 @@ class HelloTriangleApplication{
             float queuePriority = 1.0f;
             for (uint32_t queueFamily : uniqueQueueFamilies) {
                 VkDeviceQueueCreateInfo queueCreateInfo{};
-                queueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
+                queueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
                 queueCreateInfo.queueFamilyIndex = queueFamily;
                 queueCreateInfo.queueCount = 1;
                 queueCreateInfo.pQueuePriorities = &queuePriority;
@@ -102,11 +121,15 @@ class HelloTriangleApplication{
 
             createInfo.pEnabledFeatures = &deviceFeatures;
 
-            createInfo.enabledExtensionCount = 0;
+            createInfo.enabledExtensionCount = static_cast<uint32_t>(deviceExtensions.size());
+
+            createInfo.ppEnabledExtensionNames = deviceExtensions.data();
+
             if (enableValidationLayers) {
                 createInfo.enabledLayerCount = static_cast<uint32_t>(validationLayers.size());
                 createInfo.ppEnabledLayerNames = validationLayers.data();
-            } else{
+            }
+            else {
                 createInfo.enabledLayerCount = 0;
             }
 
@@ -119,6 +142,67 @@ class HelloTriangleApplication{
             vkGetDeviceQueue(device, indices.presentFamily.value(), 0, &presentQueue);
         }
 
+
+        void createSwapChain() {
+            SwapChainSupportDetails swapChainSupport = querySwapChainSupport(physicalDevice);
+
+            VkSurfaceFormatKHR surfaceFormat = chooseSwapSurfaceFormat(swapChainSupport.formats);
+            VkPresentModeKHR presentMode = chooseSwapPresentMode(swapChainSupport.presentModes);
+            VkExtent2D extent = chooseSwapExtent(swapChainSupport.capabilities);
+
+            uint32_t imageCount = swapChainSupport.capabilities.minImageCount + 1;
+            if (swapChainSupport.capabilities.maxImageCount > 0 && imageCount > swapChainSupport.capabilities.maxImageCount) {
+                imageCount = swapChainSupport.capabilities.maxImageCount;
+            }
+
+            VkSwapchainCreateInfoKHR createInfo{};
+            createInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
+            createInfo.surface = surface;
+
+            createInfo.minImageCount = imageCount;
+            createInfo.imageFormat = surfaceFormat.format;
+            createInfo.imageColorSpace = surfaceFormat.colorSpace;
+            createInfo.imageExtent = extent;
+            createInfo.imageArrayLayers = 1;
+            createInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+
+            QueueFamilyIndices indices = findQueueFamilies(physicalDevice);
+            uint32_t queueFamilyIndices[] = { indices.graphicsFamily.value(), indices.presentFamily.value()};
+
+            if (indices.graphicsFamily != indices.presentFamily) {
+                createInfo.imageSharingMode = VK_SHARING_MODE_CONCURRENT;
+                createInfo.queueFamilyIndexCount = 2;
+                createInfo.pQueueFamilyIndices = queueFamilyIndices;
+            }
+            else {
+                createInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
+                createInfo.queueFamilyIndexCount = 0;
+                createInfo.pQueueFamilyIndices = nullptr;
+            }
+
+
+            createInfo.preTransform = swapChainSupport.capabilities.currentTransform;
+            createInfo.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
+            createInfo.presentMode = presentMode;
+            createInfo.clipped = VK_TRUE;
+
+            createInfo.oldSwapchain = VK_NULL_HANDLE;
+
+            if (vkCreateSwapchainKHR(device, &createInfo, nullptr, &swapChain)!= VK_SUCCESS ) {
+                throw std::runtime_error("failed to create swap chain!");
+            }
+
+
+            vkGetSwapchainImagesKHR(device, swapChain, &imageCount, nullptr);
+            swapChainImages.resize(imageCount);
+            vkGetSwapchainImagesKHR(device, swapChain, &imageCount, swapChainImages.data());
+
+
+            swapChainImageFormat = surfaceFormat.format;
+            swapChainExtent = extent;
+
+        }
+
         void pickPhysicalDevice() {
             uint32_t deviceCount = 0;
             vkEnumeratePhysicalDevices(instance, &deviceCount, nullptr);
@@ -143,16 +227,24 @@ class HelloTriangleApplication{
         }
 
         bool isDeviceSuitable(VkPhysicalDevice device) {
+
+            QueueFamilyIndices indices = findQueueFamilies(device);
+            bool extensionSupported = checkDeviceExtensionSupport(device);
+
             VkPhysicalDeviceProperties deviceProperties;
             vkGetPhysicalDeviceProperties(device, &deviceProperties);
 
             VkPhysicalDeviceFeatures deviceFeatures;
             vkGetPhysicalDeviceFeatures(device, &deviceFeatures);
 
+            bool swapChainAdequate = false;
+            if (extensionSupported) {
+                SwapChainSupportDetails swapChainSupport = querySwapChainSupport(device);
+                swapChainAdequate = !swapChainSupport.formats.empty() && !swapChainSupport.presentModes.empty();
+            }
 
-            QueueFamilyIndices indices = findQueueFamilies(device);
 
-            return indices.isComplete();
+            return indices.isComplete() && extensionSupported && swapChainAdequate;
         }
 
         struct QueueFamilyIndices {
@@ -202,11 +294,37 @@ class HelloTriangleApplication{
             return indices;
         }
 
+        SwapChainSupportDetails querySwapChainSupport(VkPhysicalDevice device) {
+            SwapChainSupportDetails details;
+
+            vkGetPhysicalDeviceSurfaceCapabilitiesKHR(device, surface, &details.capabilities);
+
+            uint32_t formatCount;
+            vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &formatCount, nullptr);
+
+            if (formatCount != 0) {
+                details.formats.resize(formatCount);
+                vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &formatCount, details.formats.data());
+            }
+
+            uint32_t presentModeCount;
+            vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &presentModeCount, nullptr);
+
+            if (presentModeCount != 0) {
+                details.presentModes.resize(presentModeCount);
+                vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &presentModeCount, details.presentModes.data());
+            }
+
+            return details;
+        }
+
+
         VkResult CreateDebugUtilsMessengerEXT(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pDebugMessenger) {
             auto func = (PFN_vkCreateDebugUtilsMessengerEXT)vkGetInstanceProcAddr(instance, "vkCreateDebugUtilsMessengerEXT");
             if (func != nullptr) {
                 return func(instance, pCreateInfo, pAllocator, pDebugMessenger);
-            } else {
+            }
+            else {
                 return VK_ERROR_EXTENSION_NOT_PRESENT;
             }
         }
@@ -248,6 +366,23 @@ class HelloTriangleApplication{
 
         }
 
+        bool checkDeviceExtensionSupport(VkPhysicalDevice device) {
+            uint32_t extensionCount;
+            vkEnumerateDeviceExtensionProperties(device, nullptr, &extensionCount, nullptr);
+
+            std::vector<VkExtensionProperties> availableExtensions(extensionCount);
+            vkEnumerateDeviceExtensionProperties(device, nullptr, &extensionCount, availableExtensions.data());
+
+            std::set < std::string> requiredExtensions(deviceExtensions.begin(), deviceExtensions.end());
+
+            for (const auto& extension : availableExtensions) {
+                requiredExtensions.erase(extension.extensionName);
+            }
+
+            return requiredExtensions.empty();
+        }
+
+
         std::vector<const char*> getRequiredExtensions() {
             uint32_t glfwExtensionCount = 0;
             const char** glfwExtensions;
@@ -287,7 +422,8 @@ class HelloTriangleApplication{
                 populateDebugMessengerCreateInfo(debugcreateinfo);
                 createInfo.pNext = (VkDebugUtilsMessengerCreateInfoEXT*)&debugcreateinfo;
 
-            } else{
+            }
+            else {
                 createInfo.enabledLayerCount = 0;
                 createInfo.pNext = nullptr;
             }
@@ -300,7 +436,8 @@ class HelloTriangleApplication{
             if (enableValidationLayers) {
                 createInfo.enabledLayerCount = static_cast<uint32_t> (validationLayers.size());
                 createInfo.ppEnabledLayerNames = validationLayers.data();
-            } else{
+            }
+            else {
                 createInfo.enabledLayerCount = 0;
             }
 
@@ -315,6 +452,45 @@ class HelloTriangleApplication{
 
         }
 
+        VkSurfaceFormatKHR chooseSwapSurfaceFormat(const std::vector<VkSurfaceFormatKHR>& availableFormats) {
+            for (const auto& availableFormat : availableFormats) {
+                if (availableFormat.format == VK_FORMAT_B8G8R8A8_SRGB && availableFormat.colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR) {
+                    return availableFormat;
+                }
+            }
+
+            return availableFormats[0];
+        }
+
+        VkPresentModeKHR chooseSwapPresentMode(const std::vector<VkPresentModeKHR>& availablePresentModes) {
+            for (const auto& availablePresentMode : availablePresentModes) {
+                if (availablePresentMode == VK_PRESENT_MODE_MAILBOX_KHR) {
+                    return availablePresentMode;
+                }
+            }
+            return VK_PRESENT_MODE_FIFO_KHR;
+        }
+
+        VkExtent2D chooseSwapExtent(const VkSurfaceCapabilitiesKHR& capabilities) {
+            if (capabilities.currentExtent.width != std::numeric_limits<uint32_t>::max()) {
+                return capabilities.currentExtent;
+            }
+            else {
+                int width, height;
+                glfwGetFramebufferSize(window, &width, &height);
+
+                VkExtent2D actualExtent = {
+                    static_cast<uint32_t>(width),
+                    static_cast<uint32_t>(height)
+                };
+
+                actualExtent.width = std::clamp(actualExtent.width, capabilities.minImageExtent.width, capabilities.maxImageExtent.width);
+                actualExtent.height = std::clamp(actualExtent.width, capabilities.minImageExtent.height, capabilities.minImageExtent.height);
+
+                return actualExtent;
+            }
+        }
+
         void mainLoop(){
                 while (!glfwWindowShouldClose(window)){
                     glfwPollEvents();
@@ -322,6 +498,8 @@ class HelloTriangleApplication{
         }
 
         void cleanup(){
+            vkDestroySwapchainKHR(device, swapChain, nullptr);
+
             vkDestroyDevice(device, nullptr);
             if(enableValidationLayers){
                 DestroyDebugUtilsMessengerEXT(instance, debugMessenger, nullptr);