Информация об изображениях списка показа

include/PhysicalDevice.h

@@ -12,8 +12,6 @@ typedef struct _PhysicalDevice
     VkPhysicalDeviceFeatures features; // функции 
     VkPhysicalDeviceMemoryProperties memory; // память
     std::vector<VkQueueFamilyProperties> queueFamilyProperties; // семейства очередей
-
-    uint32_t pickQueueFamily(VkQueueFlags);
 } PhysicalDevice;
 
 #endif // PHYSICALDEVICE_H

include/Queue.h

@@ -0,0 +1,13 @@
+#ifndef QUEUE_H
+#define QUEUE_H
+
+#include <vulkan/vulkan.h>
+
+typedef struct _Queue
+{
+    uint32_t index;
+    VkQueue descriptor;
+    VkQueueFamilyProperties properties;
+} Queue;
+
+#endif // QUEUE_H

include/Surface.h

@@ -0,0 +1,21 @@
+#ifndef SURFACE_H
+#define SURFACE_H
+
+#include <vulkan/vulkan.h>
+
+#include <vector>
+
+typedef struct _Surface
+{
+    VkSurfaceKHR surface; // Поверхность окна
+    VkSurfaceCapabilitiesKHR capabilities; // общая информация
+    std::vector<VkSurfaceFormatKHR> formats; // формат поверхности
+    std::vector<VkPresentModeKHR> presentModes; // режим показа
+    // Данные о списке показа
+    VkSurfaceFormatKHR selectedFormat; // выбранный формат поверхности
+    VkPresentModeKHR selectedPresentMode; // выбранный режим показа
+    VkExtent2D selectedExtent; // выбранное разрешение
+    uint32_t imageCount; // количество изображений
+} Surface;
+
+#endif // SURFACE_H

include/macroses.h

@@ -0,0 +1 @@
+#define CLAMP(min, value, max) (value > min) ? min : (max < value) ? max : value;

include/vk.h

@@ -5,6 +5,8 @@
 #include <GLFW/glfw3.h>
 
 #include "PhysicalDevice.h"
+#include "Surface.h"
+#include "Queue.h"
 
 class Vulkan
 {
@@ -15,8 +17,12 @@ class Vulkan
         VkInstance instance; // Экземпляр Vulkan
         PhysicalDevice physicalDevice; // Физическое устройство
         VkDevice logicalDevice; // логическое устройство
-        VkQueue graphicalQueue; // очередь для работы с графикой
-        VkSurfaceKHR surface; // Поверхность окна
+        Queue queue; // очередь
+        Surface surface; // Поверхность окна
+        VkSwapchainKHR swapChain; // Список показа
+        std::vector<VkImage> swapChainImages; // Изображения из списка показа
+        std::vector<VkImageView> swapChainImageViews; // Информация об изображениях из списка показа
+        
         // Структура для хранения флагов
         struct 
         {
@@ -26,8 +32,10 @@ class Vulkan
         
         void createInstance(); // Создание экземпяра Vulkan
         void selectPhysicalDevice(std::vector<const char*> &deviceExtensions); // Выбор физического устройства
+        void pickQueues(); // Выбор очередей
         void createLogicalDevice(std::vector<const char*> &deviceExtensions); // Создание логического устройства
         void createWindowSurface(GLFWwindow* window); // Создание поверхности окна
+        void createSwapchain(GLFWwindow* window); // Создание цепочки показа
 };  
 
 #endif // VK_H

src/PhysicalDevice.cpp

@@ -1,16 +0,0 @@
-#include "PhysicalDevice.h"
-
-// Возвращает индекс первой попавшейся очереди, соответствующей требуемым флагам
-uint32_t PhysicalDevice::pickQueueFamily(VkQueueFlags flags)
-{
-    // Цикл по параметрам семейств очередей
-    for (uint32_t index = 0; index < queueFamilyProperties.size(); index++) 
-    {
-        // Если очередь соответствует требованиям по возможностям очереди
-        if (queueFamilyProperties[index].queueFlags & flags) 
-        {
-            // возвращаем её индекс
-            return index;
-        }
-    }
-}

src/vk.cpp

@@ -4,21 +4,31 @@
 #include <vector>
 #include <stdexcept>
 
+#include "macroses.h"
+
 // инициализация 
 void Vulkan::init(GLFWwindow* window)
 {
     createInstance(); // Создание экземпяра 
     createWindowSurface(window); // Создание поверхности
     // Расширения для устройства: имена задаются внутри фигурных скобок в кавычках
-    std::vector<const char*> deviceExtensions({});
+    std::vector<const char*> deviceExtensions({"VK_KHR_swapchain"});
     selectPhysicalDevice(deviceExtensions); // Выбор физического устройства
     createLogicalDevice(deviceExtensions); // Создание физического устройства
+    createSwapchain(window); // Создание списка показа
 }
 
 // завершение работы
 void Vulkan::destroy()
 {
-    vkDestroySurfaceKHR(instance, surface, nullptr);
+    // Уничтожение информации о изображениях списка показа
+    for (auto & imageView : swapChainImageViews) 
+    {
+        vkDestroyImageView(logicalDevice, imageView, nullptr);
+    }
+    
+    vkDestroySwapchainKHR(logicalDevice, swapChain, nullptr); // уничтожение цепочки показа
+    vkDestroySurfaceKHR(instance, surface.surface, nullptr); // уничтожение поверхности
     vkDestroyDevice(logicalDevice, nullptr); // Уничтожение логического устройства
     vkDestroyInstance(instance, nullptr); // Уничтожение экземпляра Vulkan
 }
@@ -165,7 +175,7 @@ void Vulkan::createInstance()
 
 #include <algorithm>
 // Выбор физического устройства на основании требований
-PhysicalDevice selectPhysicalDeviceByProperties(std::vector<VkPhysicalDevice> & devices, std::vector<const char*> &requestedExtensions)
+PhysicalDevice selectPhysicalDeviceByProperties(std::vector<VkPhysicalDevice> & devices, Surface & surface, std::vector<const char*> &requestedExtensions)
 {
     int i;
     PhysicalDevice result; // физическое устройство (PhysicalDevice.h)
@@ -200,12 +210,38 @@ PhysicalDevice selectPhysicalDeviceByProperties(std::vector<VkPhysicalDevice> &
                     break;
                 }
             
+        // Получение информации о поверхности
+        VkSurfaceCapabilitiesKHR capabilities;
+        vkGetPhysicalDeviceSurfaceCapabilitiesKHR(device, surface.surface, &capabilities);
+
+        // Получение форматов поверхности
+        uint32_t formatCount;
+        vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface.surface, &formatCount, nullptr);
+        std::vector<VkSurfaceFormatKHR> formats(formatCount);
+        vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface.surface, &formatCount, formats.data());
+
+        // Получение данных о поддерживаемых режимах показа
+        uint32_t presentModeCount;
+        vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface.surface, &presentModeCount, nullptr);
+        std::vector<VkPresentModeKHR> presentModes(presentModeCount);
+        vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface.surface, &presentModeCount, presentModes.data());
+        
+        // Если есть форматы и режимы показа, то на данном устройстве можно создать список показа
+        bool swapchainSupport = formatCount && presentModeCount;
 
         // Производим оценку
         if (availableExtensionsCount == requestedExtensions.size()
         &&  result.features.geometryShader
-        &&  4000 < result.memory.memoryHeaps[0].size / 1000 / 1000)
+        &&  4000 < result.memory.memoryHeaps[0].size / 1000 / 1000
+        &&  swapchainSupport)
+        {
+            // Заполним данные о поверхности
+            surface.capabilities = capabilities;
+            surface.formats = formats;
+            surface.presentModes = presentModes;
+            // Вернем устройство
             return result;
+        }
     }
     // Если устройство не найдено - вернем пустую структуру
     return PhysicalDevice();
@@ -229,7 +265,7 @@ void Vulkan::selectPhysicalDevice(std::vector<const char*> &deviceExtensions)
     vkEnumeratePhysicalDevices(instance, &deviceCount, devices.data());
 
     // Выбор физического устройства на основании требований
-    physicalDevice = selectPhysicalDeviceByProperties(devices, deviceExtensions);
+    physicalDevice = selectPhysicalDeviceByProperties(devices, surface, deviceExtensions);
 
     // Если не удалось выбрать подходящее требованием устройство - выдадим исключение
     if (!physicalDevice.device) 
@@ -238,14 +274,39 @@ void Vulkan::selectPhysicalDevice(std::vector<const char*> &deviceExtensions)
     }
 }
 
+// Выбор очередей
+void Vulkan::pickQueues()
+{
+    queue.index = -1;
+    
+    for (int i = 0; i < physicalDevice.queueFamilyProperties.size(); i++)
+    {
+        // Проверка возможности вывода
+        VkBool32 presentSupport = false;
+        vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice.device, i, surface.surface, &presentSupport);
+        // Проверка поддержки очередью графических операций
+        if (physicalDevice.queueFamilyProperties[i].queueFlags & VK_QUEUE_GRAPHICS_BIT
+        &&  presentSupport) 
+        {
+            queue.index = i;
+            queue.properties = physicalDevice.queueFamilyProperties[i];
+            break;
+        }
+    }
+}
+
+// Создание логического устройства
 void Vulkan::createLogicalDevice(std::vector<const char*> &deviceExtensions)
 {
+    // Выберем очереди
+    pickQueues();
+
     // Приоритеты очередей
     float priority[1] = {1};
     // Данные о необходимых очередях
     VkDeviceQueueCreateInfo queueCreateInfo{};
     queueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
-    queueCreateInfo.queueFamilyIndex = physicalDevice.pickQueueFamily(VK_QUEUE_GRAPHICS_BIT);
+    queueCreateInfo.queueFamilyIndex = queue.index;
     queueCreateInfo.queueCount = 1;
     queueCreateInfo.pQueuePriorities = priority; 
 
@@ -285,14 +346,117 @@ void Vulkan::createLogicalDevice(std::vector<const char*> &deviceExtensions)
     }
 
     // Получим дескриптор очереди логического устройства
-    vkGetDeviceQueue(logicalDevice, queueCreateInfo.queueFamilyIndex, 0, &graphicalQueue);
+    vkGetDeviceQueue(logicalDevice, queueCreateInfo.queueFamilyIndex, 0, &queue.descriptor);
 }
 
 // Создание поверхности окна
 void Vulkan::createWindowSurface(GLFWwindow* window)
 {
-    if (glfwCreateWindowSurface(instance, window, nullptr, &surface) != VK_SUCCESS) 
+    if (glfwCreateWindowSurface(instance, window, nullptr, &surface.surface) != VK_SUCCESS) 
     {
         throw std::runtime_error("Unable to create window surface");
     }
 }
+
+// Создание цепочки показа
+void Vulkan::createSwapchain(GLFWwindow* window)
+{
+    // Выбор формата
+    surface.selectedFormat = surface.formats[0];
+    for (auto& format : surface.formats) 
+    {
+        if (format.format == VK_FORMAT_B8G8R8A8_SRGB 
+        &&  format.colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR) 
+        {
+            surface.selectedFormat = format;
+            break;
+        }
+    }
+
+    // Выбор режима показа
+    surface.selectedPresentMode = VK_PRESENT_MODE_FIFO_KHR;
+    for (auto& presentMode : surface.presentModes) 
+    {
+        if (presentMode == VK_PRESENT_MODE_MAILBOX_KHR)
+        {
+            surface.selectedPresentMode = presentMode;
+            break;
+        }
+    }
+
+    // Выбор разрешения изображений
+    // Разрешение окна 
+    int width, height;
+    glfwGetFramebufferSize(window, &width, &height);
+    // Выберем разрешение исходя из ограничений физического устройства
+    surface.selectedExtent.width = CLAMP(  surface.capabilities.minImageExtent.width
+                                    , width
+                                    , surface.capabilities.maxImageExtent.width
+                                );
+    surface.selectedExtent.height = CLAMP(  surface.capabilities.minImageExtent.height
+                                    , height
+                                    , surface.capabilities.maxImageExtent.height
+                                );
+
+    // Выбор количества изображений в списке показа
+    surface.imageCount = surface.capabilities.minImageCount + 1;
+    // Если есть ограничение по максимуму изображений - применим его
+    if (surface.capabilities.maxImageCount)
+        surface.imageCount %= surface.capabilities.maxImageCount;
+
+    // Заполнение данных о создаваемом списке показа
+    VkSwapchainCreateInfoKHR createInfo{};
+    createInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
+    createInfo.surface = surface.surface;
+    createInfo.minImageCount = surface.imageCount;
+    createInfo.imageFormat = surface.selectedFormat.format;
+    createInfo.imageColorSpace = surface.selectedFormat.colorSpace;
+    createInfo.imageExtent = surface.selectedExtent;
+    createInfo.imageArrayLayers = 1;
+    createInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+    createInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
+    createInfo.preTransform = surface.capabilities.currentTransform;
+    createInfo.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
+    createInfo.presentMode = surface.selectedPresentMode;
+    createInfo.clipped = VK_TRUE;
+    createInfo.oldSwapchain = VK_NULL_HANDLE;
+
+    // Создание списка показа
+    if (vkCreateSwapchainKHR(logicalDevice, &createInfo, nullptr, &swapChain) != VK_SUCCESS) 
+    {
+        throw std::runtime_error("Unable to create swap chain");
+    }
+
+    // Получение изображений списка показа
+    vkGetSwapchainImagesKHR(logicalDevice, swapChain, &surface.imageCount, nullptr);
+    swapChainImages.resize(surface.imageCount);
+    vkGetSwapchainImagesKHR(logicalDevice, swapChain, &surface.imageCount, swapChainImages.data());
+
+    // Зададим размер массива в соответствии с количеством изображений
+    swapChainImageViews.resize(swapChainImages.size());
+    // Для каждого изображения из списка показа
+    for (int i = 0; i < swapChainImages.size(); i++) 
+    {
+        // Заполним данные о создаваемом объекте VkImageView
+        VkImageViewCreateInfo createInfo{};
+        createInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
+        createInfo.image = swapChainImages[i];
+        createInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
+        createInfo.format = surface.selectedFormat.format;  
+        createInfo.components.r = VK_COMPONENT_SWIZZLE_IDENTITY;
+        createInfo.components.g = VK_COMPONENT_SWIZZLE_IDENTITY;
+        createInfo.components.b = VK_COMPONENT_SWIZZLE_IDENTITY;
+        createInfo.components.a = VK_COMPONENT_SWIZZLE_IDENTITY;
+        createInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+        createInfo.subresourceRange.baseMipLevel = 0;
+        createInfo.subresourceRange.levelCount = 1;
+        createInfo.subresourceRange.baseArrayLayer = 0;
+        createInfo.subresourceRange.layerCount = 1;
+
+        // Создание VkImageView
+        if (vkCreateImageView(logicalDevice, &createInfo, nullptr, &swapChainImageViews[i]) != VK_SUCCESS) 
+        {
+            throw std::runtime_error("Unable to create image views");
+        }
+    }
+}