288 lines
12 KiB
C++
288 lines
12 KiB
C++
#include "vk.h"
|
||
|
||
#include <iostream>
|
||
#include <vector>
|
||
#include <stdexcept>
|
||
|
||
// инициализация
|
||
void Vulkan::init()
|
||
{
|
||
createInstance(); // Создание экземпяра
|
||
// Расширения для устройства: имена задаются внутри фигурных скобок в кавычках
|
||
std::vector<const char*> deviceExtensions({});
|
||
selectPhysicalDevice(deviceExtensions); // Выбор физического устройства
|
||
createLogicalDevice(deviceExtensions); // Создание физического устройства
|
||
}
|
||
|
||
// завершение работы
|
||
void Vulkan::destroy()
|
||
{
|
||
vkDestroyDevice(logicalDevice, nullptr); // Уничтожение логического устройства
|
||
vkDestroyInstance(instance, nullptr); // Уничтожение экземпляра Vulkan
|
||
}
|
||
|
||
#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()
|
||
{
|
||
// Структура с данными о приложении
|
||
VkApplicationInfo appInfo{};
|
||
appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
|
||
appInfo.pApplicationName = "Vulkan Notes";
|
||
appInfo.applicationVersion = VK_MAKE_VERSION(1, 0, 0);
|
||
appInfo.pEngineName = "No Engine";
|
||
appInfo.engineVersion = VK_MAKE_VERSION(1, 0, 0);
|
||
appInfo.apiVersion = VK_API_VERSION_1_0;
|
||
|
||
// Структура с данными
|
||
VkInstanceCreateInfo createInfo{};
|
||
createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
|
||
createInfo.pApplicationInfo = &appInfo;
|
||
|
||
// Расширения для glfw
|
||
uint32_t glfwExtensionCount = 0;
|
||
const char** glfwExtensions;
|
||
glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionCount);
|
||
// Инициализируем вектор расширений тем, что требуется для glfw
|
||
std::vector<const char*> extensions(glfwExtensions, glfwExtensions + glfwExtensionCount);
|
||
|
||
// Подключение других расширений
|
||
// extensions.push_back(ИМЯ_РАСШИРЕНИЯ);
|
||
|
||
// Запишем данные об используемых расширениях в структуру
|
||
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)
|
||
{ // Отправим исключение в случае ошибок создания экземпляра
|
||
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);
|
||
}
|