Продолжим работу с приложением на GLFW из прошлой темы и рассмотрим, как настроить цепочку буферов:
#define GLFW_INCLUDE_VULKAN
#include <GLFW/glfw3.h>
#include <iostream>
#include <stdexcept>
#include <vector>
#include <cstring>
#include <cstdlib>
#include <set>
#include <cstdint> // для uint32_t
#include <limits> // для std::numeric_limits
#include <algorithm> // для std::clamp
const uint32_t WIDTH = 300;
const uint32_t HEIGHT = 250;
// структура для проверки возможностей поверхности
struct SwapChainSupportDetails {
VkSurfaceCapabilitiesKHR capabilities; // возможности поверхности
std::vector<VkSurfaceFormatKHR> formats; // доступные форматы
std::vector<VkPresentModeKHR> presentModes; // доступные режимы представления
};
// структура для хранения индексов семейств очередей
struct QueueFamilyIndices {
uint32_t graphicsFamilyIndex;
uint32_t presentFamilyIndex;
VkBool32 graphicsSupport;
VkBool32 presentSupport;
bool isComplete() {
return graphicsSupport && presentSupport;
}
};
class HelloApplication {
public:
void run() {
initWindow();
initVulkan();
mainLoop();
cleanup();
}
private:
GLFWwindow* window;
VkInstance instance;
VkSurfaceKHR surface; // поверхность рисования
// физическое устройство
VkPhysicalDevice physicalDevice = VK_NULL_HANDLE;
// логическре устройство
VkDevice device;
VkQueue graphicsQueue; // графическая очередь
VkQueue presentQueue; // очередь представления
VkSwapchainKHR swapChain; // цепочка буферов
// создаем окно
void initWindow() {
glfwInit();
glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
glfwWindowHint(GLFW_RESIZABLE, GLFW_FALSE);
window = glfwCreateWindow(WIDTH, HEIGHT, "METANIT.COM", nullptr, nullptr);
}
// инициализация всех аспектов Vulkan
void initVulkan() {
createInstance(); // создание VkInstance
createSurface(); // создание поверхности рисования
selectPhysicalDevice(); // выбор физического устройства
createLogicalDevice(); // создание логического устройства
}
// установка формата изображений
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) {
// если текущая ширина не указана как максимальное значение для uint32_t
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.height, capabilities.minImageExtent.height, capabilities.maxImageExtent.height);
return actualExtent;
}
}
void mainLoop() {
while (!glfwWindowShouldClose(window)) {
glfwWaitEvents();
}
}
void cleanup() {
// удаляем цепочку буферов
vkDestroySwapchainKHR(device, swapChain, nullptr);
// удаляем логическое устройство
vkDestroyDevice(device, nullptr);
// удаляем поверхность
vkDestroySurfaceKHR(instance, surface, nullptr);
// удаляем объект VkInstance
vkDestroyInstance(instance, nullptr);
glfwDestroyWindow(window);
glfwTerminate();
}
// создание VkInstance
void createInstance() {
VkInstanceCreateInfo createInfo{};
createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
uint32_t glfwExtensionCount = 0;
const char** glfwExtensions;
// получаем расширения для GLFW
glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionCount);
// устанавливаем расширения для VkInstance
createInfo.enabledExtensionCount = glfwExtensionCount;
createInfo.ppEnabledExtensionNames = glfwExtensions;
if (vkCreateInstance(&createInfo, nullptr, &instance) != VK_SUCCESS) {
throw std::runtime_error("Не удалось создать VkInstance!");
}
}
// создаем поверхность
void createSurface() {
if (glfwCreateWindowSurface(instance, window, nullptr, &surface) != VK_SUCCESS) {
throw std::runtime_error("Не удалось создать поверхность для рисования!");
}
}
// проверка поддержки цепочки буферов
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;
}
// выбираем физическое устройство
void selectPhysicalDevice() {
uint32_t deviceCount = 0;
vkEnumeratePhysicalDevices(instance, &deviceCount, nullptr);
if (deviceCount == 0) {
throw std::runtime_error("Подходящее устройство GPU отсутствует!");
}
std::vector<VkPhysicalDevice> devices(deviceCount);
vkEnumeratePhysicalDevices(instance, &deviceCount, devices.data());
// выбираем первое подходящее устройство
for (const auto& device : devices) {
if (isDeviceSuitable(device)) {
physicalDevice = device;
break;
}
}
if (physicalDevice == VK_NULL_HANDLE) {
throw std::runtime_error("Подходящее устройство GPU отсутствует!");
}
}
// создание логического устройства
void createLogicalDevice() {
// получаем обе очереди
QueueFamilyIndices indices = findQueueFamilies(physicalDevice);
std::vector<VkDeviceQueueCreateInfo> queueCreateInfos;
// набор для индексов семейств очередей, если они совпадают, то остается только один индекс
std::set<uint32_t> uniqueQueueFamilies = {
indices.graphicsFamilyIndex,
indices.presentFamilyIndex
};
float queuePriority = 1.0f;
// проходим по всем индексам семейств очередей и создаем для каждого индекса структуру VkDeviceQueueCreateInfo
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);
}
VkDeviceCreateInfo createInfo{};
createInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
// устанавливаем обе очереди для создания устройства
createInfo.queueCreateInfoCount = static_cast<uint32_t>(queueCreateInfos.size());
createInfo.pQueueCreateInfos = queueCreateInfos.data();
// подключаемые расширения
const std::vector<const char*> deviceExtensions = { VK_KHR_SWAPCHAIN_EXTENSION_NAME};
// подключаем расширения
// устанавливаем количество расширений
createInfo.enabledExtensionCount = static_cast<uint32_t>(deviceExtensions.size());
// устанавливаем сами расширения
createInfo.ppEnabledExtensionNames = deviceExtensions.data();
// устанавливаем поддерживаемые возможности
VkPhysicalDeviceFeatures deviceFeatures{};
createInfo.pEnabledFeatures = &deviceFeatures;
// создаем логическое устройство
if (vkCreateDevice(physicalDevice, &createInfo, nullptr, &device) != VK_SUCCESS) {
throw std::runtime_error("Не удалось создать логическое устройство!");
}
// создаем графическую очередь
vkGetDeviceQueue(device, indices.graphicsFamilyIndex, 0, &graphicsQueue);
// создаем очередь представления
vkGetDeviceQueue(device, indices.presentFamilyIndex, 0, &presentQueue);
}
// проверяем поддержку цепочки буферов
bool checkSwapchainExtensionSupport(VkPhysicalDevice device) {
uint32_t extensionCount;
// сначала получаем количество расширений
vkEnumerateDeviceExtensionProperties(device, nullptr, &extensionCount, nullptr);
// получаем все доступные расширения
std::vector<VkExtensionProperties> availableExtensions(extensionCount);
vkEnumerateDeviceExtensionProperties(device, nullptr, &extensionCount, availableExtensions.data());
std::string extensionName {VK_KHR_SWAPCHAIN_EXTENSION_NAME}; // строка, с которой сравниванием
for (const auto& extension : availableExtensions) {
// сравнение строк
if(extensionName == extension.extensionName) return true;
}
return false;
}
// проверка, является ли устройство подходящим
bool isDeviceSuitable(VkPhysicalDevice device) {
// получаем индексы графической очереди и очереди представления
QueueFamilyIndices indices = findQueueFamilies(device);
// если не поддерживаются графическая очередь и/или очередь представления
if(!indices.isComplete()) return false;
// если не поддерживаются расширения
if(!checkSwapchainExtensionSupport(device)) return false;
// получаем поддержку цепочки буферов
SwapChainSupportDetails swapChainSupport = querySwapChainSupport(device);
// считаем устройство подходящим, если поддерживается хотя бы один формат и хотя бы один режим представления
return !swapChainSupport.formats.empty() && !swapChainSupport.presentModes.empty();
}
// получаем индексы семейства очередей
QueueFamilyIndices findQueueFamilies(VkPhysicalDevice device) {
QueueFamilyIndices indices;
uint32_t queueFamilyCount = 0;
vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyCount, nullptr);
std::vector<VkQueueFamilyProperties> queueFamilies(queueFamilyCount);
vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyCount, queueFamilies.data());
int i = 0;
// проходим по всем очередям
for (const auto& queueFamily : queueFamilies) {
// получаем индекс семейства с графической очередью
if (queueFamily.queueFlags & VK_QUEUE_GRAPHICS_BIT) {
indices.graphicsFamilyIndex = i;
indices.graphicsSupport = true;
}
// смотрим, поддерживается ли очередь представления
vkGetPhysicalDeviceSurfaceSupportKHR(device, i, surface, &indices.presentSupport);
if (indices.presentSupport) indices.presentFamilyIndex = i;
if (indices.isComplete()) break; // если обе очереди установлены
i++;
}
return indices;
}
};
int main() {
HelloApplication app;
try {
app.run();
} catch (const std::exception& e) {
std::cerr << e.what() << std::endl;
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
Собственно для настройки цепочки буферов здесь определены три функции. Для выбора формата изображений определена функцию chooseSwapSurfaceFormat():
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];
}
В функцию передается набор поддерживаемых форматов, которые получены на этапе определения поддержки цепочки буферов. В данном случае перебираем все доступные для устройства форматы и проверяем поддержку формата sRGB. Если такой формат не поддерживается, то просто возвращаем первый попавшийся.
Для определения режима представления добавлена функция chooseSwapPresentMode():
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;
}
Здесь опять же предполагается, что в функцию будут передаваться поддерживаемые режимы представления. Приоритетным является режим
VK_PRESENT_MODE_MAILBOX_KHR. Причем если он не поддерживается, то выбираем VK_PRESENT_MODE_FIFO_KHR, поскольку VK_PRESENT_MODE_FIFO_KHR гарантировано поддерживается устройствами в отличие от других режимов.
В данном случае все три функции только определены и пока никак не используются, но на следующим этапе в следующей статье они будут применяться для создания цепочки буферов.
