Okay, I run vulkaninfo and for me all seems to be normal…
Because you have asked for the code:
Header-File:
#pragma once
//#include "vulkan/vulkan.hpp"
#include <iostream>
#define GLFW_INCLUDE_VULKAN
#include <GLFW/glfw3.h>
#include <vector>
class GraphicEngine
{
public:
GraphicEngine();
~GraphicEngine();
private:
VkInstance instance;
VkPhysicalDevice physicalDevice;
VkDevice device;
GLFWwindow *window;
VkSurfaceKHR surface;
void startGLFW();
void startVulkan();
void gameLoop();
void shutdownVulkan();
void shutdownGLFW();
void handleVulkanResult(VkResult result);
};
Code:
#include "pch.h"
#include "GraphicEngine.h"
#define ASSERT_VULKAN(val)\
if(val != VK_SUCCESS) {\
__debugbreak();\
}
GraphicEngine::GraphicEngine()
{
startGLFW();
startVulkan();
gameLoop();
shutdownVulkan();
shutdownGLFW();
}
GraphicEngine::~GraphicEngine()
{
}
void GraphicEngine::startGLFW()
{
glfwInit();
glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
glfwWindowHint(GLFW_RESIZABLE, GLFW_FALSE);
window = glfwCreateWindow(400, 300, "Universe Evolution", nullptr, nullptr);
}
void GraphicEngine::startVulkan()
{
//VkApplicationInfo create
VkApplicationInfo appInfo;
appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
appInfo.pNext = NULL;
appInfo.pApplicationName = "Universe Evolution";
appInfo.applicationVersion = VK_MAKE_VERSION(0, 0, 1);
appInfo.engineVersion = VK_MAKE_VERSION(0, 0, 1);
appInfo.apiVersion = VK_API_VERSION_1_1;
//get possible Layers
uint32_t amountOfLayers = 0;
vkEnumerateInstanceLayerProperties(&amountOfLayers, NULL);
VkLayerProperties *layers = new VkLayerProperties[amountOfLayers];
vkEnumerateInstanceLayerProperties(&amountOfLayers, layers);
std::cout << "Amount of Layers: " << amountOfLayers << std::endl;
for (int i = 0; i < amountOfLayers; i++)
{
std::cout << std::endl;
std::cout << "Name: " << layers[i].layerName << std::endl;
std::cout << "Spec-Version: " << layers[i].specVersion << std::endl;
std::cout << "Impl-Version: " << layers[i].implementationVersion << std::endl;
std::cout << "Description: " << layers[i].description << std::endl;
}
uint32_t amountOfExtensions = 0;
vkEnumerateInstanceExtensionProperties(NULL, &amountOfExtensions, NULL);
VkExtensionProperties *extensions = new VkExtensionProperties[amountOfExtensions];
vkEnumerateInstanceExtensionProperties(NULL, &amountOfExtensions, extensions);
std::cout << std::endl;
std::cout << "Amount of Extensions: " << amountOfExtensions << std::endl;
for (int i = 0; i < amountOfExtensions; i++)
{
std::cout << std::endl;
std::cout << "Name: " << extensions[i].extensionName << std::endl;
std::cout << "Spec-Version: " << extensions[i].specVersion << std::endl;
}
const std::vector<const char*> validationLayers = {
"VK_LAYER_LUNARG_standard_validation"
};
uint32_t amountOfGLFWExtensions = 0;
auto glfwExtensions = glfwGetRequiredInstanceExtensions(&amountOfExtensions);
//VkInstanceCreateInfo create
VkInstanceCreateInfo instanceCreateInfo;
instanceCreateInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
instanceCreateInfo.pNext = NULL;
instanceCreateInfo.flags = 0;
instanceCreateInfo.pApplicationInfo = &appInfo;
instanceCreateInfo.enabledLayerCount = validationLayers.size();
instanceCreateInfo.ppEnabledLayerNames = validationLayers.data();
instanceCreateInfo.enabledExtensionCount = amountOfGLFWExtensions;
instanceCreateInfo.ppEnabledExtensionNames = glfwExtensions;
//Vulkan Instance create
VkResult result = vkCreateInstance(&instanceCreateInfo, NULL, &instance);
//Fehlerbehandlung
if (result != VK_SUCCESS)
{
std::cerr << "Vulkan-Mistake at creating Instance of Vulkan" << result <<std::endl;
}
result = glfwCreateWindowSurface(instance, window, nullptr, &surface);
if (result != VK_SUCCESS)
{
std::cerr << "Vulkan-Mistake at creating VulkanWindowSurface: " << result << std::endl;
}
delete[] layers;
delete[] extensions;
//get amount of gpus
uint32_t amountOfPhysicalDevices = 0;
vkEnumeratePhysicalDevices(instance, &amountOfPhysicalDevices, NULL);
std::cout << "Amount of Graphic Cards: " << amountOfPhysicalDevices << std::endl;
//listing all physical devices
if (amountOfPhysicalDevices > 0)
{
VkPhysicalDevice * physicalDevices = new VkPhysicalDevice[amountOfPhysicalDevices];
vkEnumeratePhysicalDevices(instance, &amountOfPhysicalDevices, physicalDevices);
physicalDevice = physicalDevices[0];
//Possibility to get Features of PhysicalDevice
uint32_t amountOfQueueFamilies = 0;
vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &amountOfQueueFamilies, NULL);
VkQueueFamilyProperties* queueFamilyProperties = new VkQueueFamilyProperties[amountOfQueueFamilies];
//Properties of QueueFamilies:
std::cout << "Amount of Queue Families: " << amountOfQueueFamilies << std::endl;
for (int i = 0; i < amountOfQueueFamilies; i++)
{
std::cout << std::endl;
std::cout << "Queue-Familiy #" << i << std::endl;
std::cout << "VK_QUEUE_GRAPHICS_BIT " << ((queueFamilyProperties[i].queueFlags & VK_QUEUE_GRAPHICS_BIT)) << std::endl;
std::cout << "VK_QUEUE_COMPUTE_BIT " << ((queueFamilyProperties[i].queueFlags & VK_QUEUE_COMPUTE_BIT)) << std::endl;
std::cout << "VK_QUEUE_TRANSFER_BIT " << ((queueFamilyProperties[i].queueFlags & VK_QUEUE_TRANSFER_BIT)) << std::endl;
std::cout << "VK_QUEUE_SPARS_BINDING_BIT " << ((queueFamilyProperties[i].queueFlags & VK_QUEUE_SPARSE_BINDING_BIT)) << std::endl;
std::cout << "Amount Of Queues: " << queueFamilyProperties[i].queueCount << std::endl;
std::cout << "Timestamp Valid Bits: " << queueFamilyProperties[i].timestampValidBits << std::endl;
std::cout << "Min Image TimeStamp Granularity: " << queueFamilyProperties[i].minImageTransferGranularity.width << "," << queueFamilyProperties[i].minImageTransferGranularity.height << "," << queueFamilyProperties[i].minImageTransferGranularity.depth << std::endl;
}
VkSurfaceCapabilitiesKHR surfaceCapabilities;
vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, &surfaceCapabilities);
std::cout << "Surface capabilities: " << std::endl;
std::cout << "\tminImageCount: " << surfaceCapabilities.minImageCount << std::endl;
std::cout << "\tmaxImageCount: " << surfaceCapabilities.maxImageCount << std::endl;
std::cout << "\tcurrentExtent: " << surfaceCapabilities.currentExtent.width << "/" <<surfaceCapabilities.currentExtent.height << std::endl;
std::cout << "\tminImageExtent: " << surfaceCapabilities.minImageExtent.width << "/" << surfaceCapabilities.minImageExtent.height << std::endl;
std::cout << "\tmaxImageExtent: " << surfaceCapabilities.maxImageExtent.width << "/" << surfaceCapabilities.minImageExtent.height << std::endl;
std::cout << "\tmaxImageArrayLayers: " << surfaceCapabilities.maxImageArrayLayers << std::endl;
std::cout << "\tsupportedTransforms: " << surfaceCapabilities.supportedTransforms << std::endl;
std::cout << "\tcurrentTransform: " << surfaceCapabilities.currentTransform << std::endl;
std::cout << "\tsupportedCompositeAlpha: " << surfaceCapabilities.supportedCompositeAlpha << std::endl;
std::cout << "\tsupportedUsageFlags: " << surfaceCapabilities.supportedUsageFlags << std::endl;
const float queuePrios[] = { 1.0f };
VkDeviceQueueCreateInfo deviceQueueCreateInfo;
deviceQueueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
deviceQueueCreateInfo.pNext = NULL;
deviceQueueCreateInfo.flags = 0;
deviceQueueCreateInfo.queueFamilyIndex = 0; //TODO Pick best QueueFamilyIndex for my application -> What is best?
int amountOfQueues = 1;
if (queueFamilyProperties[0].queueCount >= amountOfQueues)
{
deviceQueueCreateInfo.queueCount = amountOfQueues;
}
else
{
deviceQueueCreateInfo.queueCount = queueFamilyProperties[0].queueCount;
}
deviceQueueCreateInfo.pQueuePriorities = queuePrios;
VkPhysicalDeviceFeatures usedFeatures = {};
VkDeviceCreateInfo deviceCreateInfo;
deviceCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
deviceCreateInfo.pNext = NULL;
deviceCreateInfo.flags = 0;
deviceCreateInfo.queueCreateInfoCount = 1;
deviceCreateInfo.pQueueCreateInfos = &deviceQueueCreateInfo;
deviceCreateInfo.enabledLayerCount = 0;
deviceCreateInfo.ppEnabledLayerNames = NULL;
deviceCreateInfo.enabledExtensionCount = 0;
deviceCreateInfo.ppEnabledExtensionNames = NULL;
deviceCreateInfo.pEnabledFeatures = &usedFeatures;
VkResult result = vkCreateDevice(physicalDevice, &deviceCreateInfo, NULL, &device); //TODO pick best device
if (result != VK_SUCCESS)
{
std::cerr << "Vulkan-Mistake at Creating logical Device" << std::endl;
}
VkQueue queue;
vkGetDeviceQueue(device, 0, 0, &queue);
delete[] physicalDevices;
delete[] queueFamilyProperties;
}
}
void GraphicEngine::gameLoop()
{
while (!glfwWindowShouldClose(window))
{
glfwPollEvents();
}
}
void GraphicEngine::shutdownVulkan()
{
vkDeviceWaitIdle(device);
vkDestroySurfaceKHR(instance, surface, nullptr);
vkDestroyDevice(device, NULL);
vkDestroyInstance(instance, NULL);
}
void GraphicEngine::shutdownGLFW()
{
glfwDestroyWindow(window);
}
The error while creating the surface cannot be the cause for the unnormal values at the queueFamilies. I think the bits of the graphic_bit, computing_bit should be 0 or 1 but not 2 or 4 as at my example.
But maybe I’ve made a little mistake in my code?