.vscode/settings.json

@@ -40,7 +40,6 @@
         "sstream": "cpp",
         "stdexcept": "cpp",
         "streambuf": "cpp",
-        "typeinfo": "cpp",
+        "typeinfo": "cpp"
-        "cstring": "cpp"
     }
 }

README.md

@@ -1,4 +1,4 @@
 # 02
 
 Вторая заметка по Vulkan API - инициализация.
-https://rekovalev.site/vulkan-api-2-init/
+https://rekovalev.site/blog/2022/02/04/vulkan-api-2-init/

include/PhysicalDevice.h

@@ -1,19 +0,0 @@
-#ifndef PHYSICALDEVICE_H
-#define PHYSICALDEVICE_H
-
-#include <vulkan/vulkan.h>
-
-#include <vector>
-
-typedef struct _PhysicalDevice
-{
-    VkPhysicalDevice device; // устройство
-    VkPhysicalDeviceProperties properties; // параметры 
-    VkPhysicalDeviceFeatures features; // функции 
-    VkPhysicalDeviceMemoryProperties memory; // память
-    std::vector<VkQueueFamilyProperties> queueFamilyProperties; // семейства очередей
-
-    uint32_t pickQueueFamily(VkQueueFlags);
-} PhysicalDevice;
-
-#endif // PHYSICALDEVICE_H

include/vk.h

@@ -4,8 +4,6 @@
 #include <vulkan/vulkan.h>
 #include <GLFW/glfw3.h>
 
-#include "PhysicalDevice.h"
-
 class Vulkan
 {
     public:
@@ -13,19 +11,14 @@ class Vulkan
         void destroy(); // завершение работы
     private:
         VkInstance instance; // Экземпляр Vulkan
-        PhysicalDevice physicalDevice; // Физическое устройство
-        VkDevice logicalDevice; // логическое устройство
-        VkQueue graphicalQueue; // очередь для работы с графикой
         // Структура для хранения флагов
         struct 
         {
-            const bool VALIDATION = true; // Использование слоев проверки
+            const bool VALIDATION = 1; // Использование слоев проверки
         } states;
 
         
         void createInstance(); // Создание экземпяра Vulkan
-        void selectPhysicalDevice(std::vector<const char*> &deviceExtensions); // Выбор физического устройства
-        void createLogicalDevice(std::vector<const char*> &deviceExtensions); // Создание логического устройства
 };
 
 #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

@@ -7,97 +7,14 @@
 // инициализация 
 void Vulkan::init()
 {
-    createInstance(); // Создание экземпяра 
+    createInstance(); // Создание экземпяра Vulkan
-    // Расширения для устройства: имена задаются внутри фигурных скобок в кавычках
-    std::vector<const char*> deviceExtensions({});
-    selectPhysicalDevice(deviceExtensions); // Выбор физического устройства
-    createLogicalDevice(deviceExtensions); // Создание физического устройства
 }
 
 // завершение работы
 void Vulkan::destroy()
 {
-    vkDestroyDevice(logicalDevice, nullptr); // Уничтожение логического устройства
+    // Уничтожение экземпляра Vulkan
-    vkDestroyInstance(instance, nullptr); // Уничтожение экземпляра Vulkan
+    vkDestroyInstance(instance, nullptr); 
-}
-
-#include <cstring>
-// Проверка слоев на доступность. Возвращает true, если все слои доступны
-// по ссылке заполняет вектор недоступных слоев
-bool checkValidationLayerSupport(std::vector <const char*> requestedLayers, std::vector <const char*> & unavailableLayers)
-{
-    bool layerAvailable; // флаг доступности слоя для цикла
-
-    // Первым вызовом определим кол-во доступных слоев
-    uint32_t layerCount;
-    vkEnumerateInstanceLayerProperties(&layerCount, nullptr);
-
-    // Вторым вызовом запишем в вектор доступные слои
-    std::vector<VkLayerProperties> availableLayers(layerCount);
-    vkEnumerateInstanceLayerProperties(&layerCount, availableLayers.data());
-
-    // Цикл по запрошенным слоям
-    for (const char* layerName : requestedLayers) 
-    {
-       layerAvailable = false;
-
-        // Цикл по доступным слоям
-        for (const auto& layerProperties : availableLayers) 
-        {
-            // Сравнение строк
-            if (strcmp(layerName, layerProperties.layerName) == 0) 
-            {
-                layerAvailable = true;
-                break;
-            }
-        }
-
-        // Если слой не найден то заносим в массив недоступных
-        if (!layerAvailable) {
-            unavailableLayers.push_back(layerName);
-        }
-    }
-
-    return unavailableLayers.size() == 0;
-}
-
-// Проверка слоев устройства на доступность. Возвращает true, если все слои доступны
-// по ссылке заполняет вектор недоступных слоев
-bool checkDeviceLayerSupport(VkPhysicalDevice physicalDevice, std::vector <const char*> requestedLayers, std::vector <const char*> & unavailableLayers)
-{
-    bool layerAvailable; // флаг доступности слоя для цикла
-
-    // Первым вызовом определим кол-во доступных слоев
-    uint32_t layerCount;
-    vkEnumerateDeviceLayerProperties(physicalDevice, &layerCount, nullptr);
-
-    // Вторым вызовом запишем в вектор доступные слои
-    std::vector<VkLayerProperties> availableLayers(layerCount);
-    vkEnumerateDeviceLayerProperties(physicalDevice, &layerCount, availableLayers.data());
-
-    // Цикл по запрошенным слоям
-    for (const char* layerName : requestedLayers) 
-    {
-       layerAvailable = false;
-
-        // Цикл по доступным слоям
-        for (const auto& layerProperties : availableLayers) 
-        {
-            // Сравнение строк
-            if (strcmp(layerName, layerProperties.layerName) == 0) 
-            {
-                layerAvailable = true;
-                break;
-            }
-        }
-
-        // Если слой не найден то заносим в массив недоступных
-        if (!layerAvailable) {
-            unavailableLayers.push_back(layerName);
-        }
-    }
-
-    return unavailableLayers.size() == 0;
 }
 
 void Vulkan::createInstance()
@@ -130,158 +47,10 @@ void Vulkan::createInstance()
     createInfo.enabledExtensionCount = static_cast<uint32_t>(extensions.size());
     createInfo.ppEnabledExtensionNames = extensions.data();
     
-    // Подключение слоев
-    std::vector<const char*> validationLayers = {
-        "VK_LAYER_KHRONOS_validation"
-    };
-
-    if (states.VALIDATION) 
-    {
-        createInfo.enabledLayerCount = static_cast<uint32_t>(validationLayers.size());
-        createInfo.ppEnabledLayerNames = validationLayers.data();
-    }
-
-    // Проверим доступность слоев
-    std::vector<const char*> unavailableLayers;
-    if (!checkValidationLayerSupport(validationLayers, unavailableLayers))
-    {
-        std::cout << "Запрошены недоступные слои:\n";
-        // Цикл по недоступным слоям
-        for (const char* layer : unavailableLayers) 
-            std::cout << layer << "\n";  
-        // Отправим исключение об отсутствующем слое 
-        throw std::runtime_error("Requested layer unavailable");
-    }
-
     // Создание экземпляра Vulkan
     VkResult result = vkCreateInstance(&createInfo, nullptr, &instance);
     if (result != VK_SUCCESS) 
-    { // Отправим исключение в случае ошибок создания экземпляра 
+    { // Отправим исключение в случае ошибок создания экземпляра Vulkan
         throw std::runtime_error("Instance create error");
     }
-}
+}
-
-#include <algorithm>
-// Выбор физического устройства на основании требований
-PhysicalDevice selectPhysicalDeviceByProperties(std::vector<VkPhysicalDevice> & devices, std::vector<const char*> &requestedExtensions)
-{
-    int i;
-    PhysicalDevice result; // физическое устройство (PhysicalDevice.h)
-    for (const auto& device : devices) 
-    {
-        // Запомним устройство
-        result.device = device;
-        // Получаем данные
-        vkGetPhysicalDeviceProperties(device, &result.properties);
-        vkGetPhysicalDeviceFeatures(device, &result.features);
-        vkGetPhysicalDeviceMemoryProperties(device, &result.memory);
-        
-        // Данные по семействам очередей    
-        uint32_t queueFamilyPropertiesCount = 0;
-        vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyPropertiesCount, nullptr);
-        result.queueFamilyProperties.resize(queueFamilyPropertiesCount);
-        vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyPropertiesCount, result.queueFamilyProperties.data());
-
-        // Данные по расширениям    
-        uint32_t extensionsCount = 0;
-        vkEnumerateDeviceExtensionProperties(device, nullptr, &extensionsCount, nullptr);
-        std::vector<VkExtensionProperties> extensions(extensionsCount);
-        vkEnumerateDeviceExtensionProperties(device, nullptr, &extensionsCount, extensions.data());
-
-        int availableExtensionsCount = 0;
-        // подсчитаем совпадающие расширения
-        for (auto extension1 : requestedExtensions)
-            for (auto extension2 : extensions)
-                if (strcmp(extension1, extension2.extensionName) == 0)
-                {
-                    availableExtensionsCount++;
-                    break;
-                }
-            
-
-        // Производим оценку
-        if (availableExtensionsCount == requestedExtensions.size()
-        &&  result.features.geometryShader
-        &&  4000 < result.memory.memoryHeaps[0].size / 1000 / 1000)
-            return result;
-    }
-    // Если устройство не найдено - вернем пустую структуру
-    return PhysicalDevice();
-}
-
-// Выбор физического устройства
-void Vulkan::selectPhysicalDevice(std::vector<const char*> &deviceExtensions)
-{
-    // Узнаем количество доступных устройств
-    uint32_t deviceCount = 0;
-    vkEnumeratePhysicalDevices(instance, &deviceCount, nullptr);
-
-    // Проверка на отсутствие физических устройств
-    if (deviceCount == 0)
-    {
-        throw std::runtime_error("Unable to find physical devices");
-    }
-
-    // Создадим вектор нужного размера и заполним его данными
-    std::vector<VkPhysicalDevice> devices(deviceCount);
-    vkEnumeratePhysicalDevices(instance, &deviceCount, devices.data());
-
-    // Выбор физического устройства на основании требований
-    physicalDevice = selectPhysicalDeviceByProperties(devices, deviceExtensions);
-
-    // Если не удалось выбрать подходящее требованием устройство - выдадим исключение
-    if (!physicalDevice.device) 
-    {
-        throw std::runtime_error("failed to find a suitable GPU!");
-    }
-}
-
-void Vulkan::createLogicalDevice(std::vector<const char*> &deviceExtensions)
-{
-    // Приоритеты очередей
-    float priority[1] = {1};
-    // Данные о необходимых очередях
-    VkDeviceQueueCreateInfo queueCreateInfo{};
-    queueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
-    queueCreateInfo.queueFamilyIndex = physicalDevice.pickQueueFamily(VK_QUEUE_GRAPHICS_BIT);
-    queueCreateInfo.queueCount = 1;
-    queueCreateInfo.pQueuePriorities = priority; 
-    
-    // слои для логического устройства
-    std::vector<const char*> layers; 
-    // Подключение других слоев
-    // layers.push_back(ИМЯ_СЛОЯ);
-
-    // Проверим доступность слоев
-    std::vector<const char*> unavailableLayers;
-    if (!checkDeviceLayerSupport(physicalDevice.device, layers, unavailableLayers))
-    {
-        std::cout << "Запрошены недоступные слои:\n";
-        // Цикл по недоступным слоям
-        for (const char* layer : unavailableLayers) 
-            std::cout << layer << "\n";  
-        // Отправим исключение об отсутствующем слое 
-        throw std::runtime_error("Requested layer unavailable");
-    }
-
-    // Данные о создаваемом логическом устройстве
-    VkDeviceCreateInfo createInfo{};
-    createInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
-    createInfo.pQueueCreateInfos = &queueCreateInfo;
-    createInfo.queueCreateInfoCount = 1;
-    createInfo.enabledExtensionCount = deviceExtensions.size();
-    createInfo.ppEnabledExtensionNames = deviceExtensions.data();
-    createInfo.enabledLayerCount = layers.size();
-    createInfo.ppEnabledLayerNames = layers.data();
-    createInfo.pEnabledFeatures = nullptr;//&physicalDevice.features;
-
-    // Создание логического устройства
-    if (vkCreateDevice(physicalDevice.device, &createInfo, nullptr, &logicalDevice) != VK_SUCCESS)
-    {
-        // Отправим исключение в случае ошибок создания лог. устройства 
-        throw std::runtime_error("failed to create logical device!");
-    }
-
-    // Получим дескриптор очереди логического устройства
-    vkGetDeviceQueue(logicalDevice, queueCreateInfo.queueFamilyIndex, 0, &graphicalQueue);
-}