Compare commits

..

No commits in common. "master" and "v0.1" have entirely different histories.
master ... v0.1

6 changed files with 8 additions and 282 deletions

View File

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

View File

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

View File

@ -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

View File

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

View File

@ -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;
}
}
}

View File

@ -7,97 +7,14 @@
// инициализация // инициализация
void Vulkan::init() void Vulkan::init()
{ {
createInstance(); // Создание экземпяра createInstance(); // Создание экземпяра Vulkan
// Расширения для устройства: имена задаются внутри фигурных скобок в кавычках
std::vector<const char*> deviceExtensions({});
selectPhysicalDevice(deviceExtensions); // Выбор физического устройства
createLogicalDevice(deviceExtensions); // Создание физического устройства
} }
// завершение работы // завершение работы
void Vulkan::destroy() 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() void Vulkan::createInstance()
@ -130,158 +47,10 @@ void Vulkan::createInstance()
createInfo.enabledExtensionCount = static_cast<uint32_t>(extensions.size()); createInfo.enabledExtensionCount = static_cast<uint32_t>(extensions.size());
createInfo.ppEnabledExtensionNames = extensions.data(); 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 // Создание экземпляра Vulkan
VkResult result = vkCreateInstance(&createInfo, nullptr, &instance); VkResult result = vkCreateInstance(&createInfo, nullptr, &instance);
if (result != VK_SUCCESS) if (result != VK_SUCCESS)
{ // Отправим исключение в случае ошибок создания экземпляра { // Отправим исключение в случае ошибок создания экземпляра Vulkan
throw std::runtime_error("Instance create error"); 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);
}