void VulkanWrapper::VWGraphicInstance::CreateSuitablePhysicalDevice(VWGraphicAdapter* _adapter)
{
uint32_t deviceCount = 0;
vkEnumeratePhysicalDevices(_adapter->GetInstanceAdapter(), &deviceCount, nullptr);
if (deviceCount == 0) {
throw std::runtime_error("failed to find GPUs with Vulkan support!");
}
std::vector<VkPhysicalDevice> devices(deviceCount);
vkEnumeratePhysicalDevices(_adapter->GetInstanceAdapter(), &deviceCount, devices.data());
for (const auto& device : devices)
{
if (VWSwapChain::IsDeviceSuitable(device, this, m_Surface))
{
m_PhysicalDevice = device;
break;
}
}
if (m_PhysicalDevice == VK_NULL_HANDLE) {
throw std::runtime_error("failed to find a suitable GPU!");
}
}
virtual void SetUp() {
VkResult err;
this->app_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
this->app_info.pNext = NULL;
this->app_info.pApplicationName = "base";
this->app_info.applicationVersion = 1;
this->app_info.pEngineName = "unittest";
this->app_info.engineVersion = 1;
this->app_info.apiVersion = VK_API_VERSION_1_0;
VkInstanceCreateInfo inst_info = {};
inst_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
inst_info.pNext = NULL;
inst_info.pApplicationInfo = &app_info;
inst_info.enabledLayerCount = 0;
inst_info.ppEnabledLayerNames = NULL;
inst_info.enabledExtensionCount = 0;
inst_info.ppEnabledExtensionNames = NULL;
err = vkCreateInstance(&inst_info, NULL, &this->inst);
ASSERT_VK_SUCCESS(err);
err = vkEnumeratePhysicalDevices(this->inst, &this->gpu_count, NULL);
ASSERT_VK_SUCCESS(err);
ASSERT_LE(this->gpu_count, ARRAY_SIZE(objs)) << "Too many GPUs";
err = vkEnumeratePhysicalDevices(this->inst, &this->gpu_count, objs);
ASSERT_VK_SUCCESS(err);
ASSERT_GE(this->gpu_count, (uint32_t) 1) << "No GPU available";
this->m_device = new vk_testing::Device(objs[0]);
this->m_device->init();
}
void chose_physical_device()
{
uint32_t deviceCount = 0;
vkEnumeratePhysicalDevices(instance, &deviceCount, nullptr);
if(deviceCount == 0)
{
cerr<<"no device with vulkan support found"<<endl;
return;
}
std::vector<VkPhysicalDevice> devices(deviceCount);
vkEnumeratePhysicalDevices(instance, &deviceCount, devices.data());
if(!select_device(devices, physical_device))
{
cerr<<"no suitable device found"<<endl;
return;
}
VkPhysicalDeviceProperties deviceProperties;
vkGetPhysicalDeviceProperties(physical_device, &deviceProperties);
cout << "chosen device:" << deviceProperties.deviceName << endl;
}
bool Tutorial01::CreateDevice() {
uint32_t num_devices = 0;
if( (vkEnumeratePhysicalDevices( Vulkan.Instance, &num_devices, nullptr ) != VK_SUCCESS) ||
(num_devices == 0) ) {
std::cout << "Error occurred during physical devices enumeration!" << std::endl;
return false;
}
std::vector<VkPhysicalDevice> physical_devices( num_devices );
if( vkEnumeratePhysicalDevices( Vulkan.Instance, &num_devices, physical_devices.data() ) != VK_SUCCESS ) {
std::cout << "Error occurred during physical devices enumeration!" << std::endl;
return false;
}
VkPhysicalDevice selected_physical_device = VK_NULL_HANDLE;
uint32_t selected_queue_family_index = UINT32_MAX;
for( uint32_t i = 0; i < num_devices; ++i ) {
if( CheckPhysicalDeviceProperties( physical_devices[i], selected_queue_family_index ) ) {
selected_physical_device = physical_devices[i];
break;
}
}
if( selected_physical_device == VK_NULL_HANDLE ) {
std::cout << "Could not select physical device based on the chosen properties!" << std::endl;
return false;
}
std::vector<float> queue_priorities = { 1.0f };
VkDeviceQueueCreateInfo queue_create_info = {
VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, // VkStructureType sType
nullptr, // const void *pNext
0, // VkDeviceQueueCreateFlags flags
selected_queue_family_index, // uint32_t queueFamilyIndex
static_cast<uint32_t>(queue_priorities.size()), // uint32_t queueCount
queue_priorities.data() // const float *pQueuePriorities
};
VkDeviceCreateInfo device_create_info = {
VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, // VkStructureType sType
nullptr, // const void *pNext
0, // VkDeviceCreateFlags flags
1, // uint32_t queueCreateInfoCount
&queue_create_info, // const VkDeviceQueueCreateInfo *pQueueCreateInfos
0, // uint32_t enabledLayerCount
nullptr, // const char * const *ppEnabledLayerNames
0, // uint32_t enabledExtensionCount
nullptr, // const char * const *ppEnabledExtensionNames
nullptr // const VkPhysicalDeviceFeatures *pEnabledFeatures
};
if( vkCreateDevice( selected_physical_device, &device_create_info, nullptr, &Vulkan.Device ) != VK_SUCCESS ) {
std::cout << "Could not create Vulkan device!" << std::endl;
return false;
}
Vulkan.QueueFamilyIndex = selected_queue_family_index;
return true;
}
TEST(WrapObjects, Insert)
{
VkInstance instance = VK_NULL_HANDLE;
VkResult result = vkCreateInstance(VK::InstanceCreateInfo(), VK_NULL_HANDLE, &instance);
ASSERT_EQ(result, VK_SUCCESS);
uint32_t physicalCount = 0;
result = vkEnumeratePhysicalDevices(instance, &physicalCount, nullptr);
ASSERT_EQ(result, VK_SUCCESS);
ASSERT_GT(physicalCount, 0u);
std::unique_ptr<VkPhysicalDevice[]> physical(new VkPhysicalDevice[physicalCount]);
result = vkEnumeratePhysicalDevices(instance, &physicalCount, physical.get());
ASSERT_EQ(result, VK_SUCCESS);
ASSERT_GT(physicalCount, 0u);
for(uint32_t p = 0; p < physicalCount; ++p)
{
uint32_t familyCount = 0;
vkGetPhysicalDeviceQueueFamilyProperties(physical[p], &familyCount, nullptr);
ASSERT_EQ(result, VK_SUCCESS);
ASSERT_GT(familyCount, 0u);
std::unique_ptr<VkQueueFamilyProperties[]> family(new VkQueueFamilyProperties[familyCount]);
vkGetPhysicalDeviceQueueFamilyProperties(physical[p], &familyCount, family.get());
ASSERT_EQ(result, VK_SUCCESS);
ASSERT_GT(familyCount, 0u);
for(uint32_t q = 0; q < familyCount; ++q)
{
if(~family[q].queueFlags & VK_QUEUE_GRAPHICS_BIT)
{
continue;
}
float const priorities[] = {0.0f}; // Temporary required due to MSVC bug.
VkDeviceQueueCreateInfo const queueInfo[1]
{
VK::DeviceQueueCreateInfo().
queueFamilyIndex(q).
queueCount(1).
pQueuePriorities(priorities)
};
auto const deviceInfo = VK::DeviceCreateInfo().
queueCreateInfoCount(1).
pQueueCreateInfos(queueInfo);
VkDevice device;
result = vkCreateDevice(physical[p], deviceInfo, nullptr, &device);
ASSERT_EQ(result, VK_SUCCESS);
vkDestroyDevice(device, nullptr);
}
}
vkDestroyInstance(instance, nullptr);
}
void Renderer::_InitDevice()
{
{
uint32_t gpu_count = 0;
vkEnumeratePhysicalDevices( _instance, &gpu_count, nullptr );
std::vector<VkPhysicalDevice> gpu_list( gpu_count );
vkEnumeratePhysicalDevices( _instance, &gpu_count, gpu_list.data() );
_gpu = gpu_list[ 0 ];
vkGetPhysicalDeviceProperties( _gpu, &_gpu_properties );
}
{
uint32_t family_count = 0;
vkGetPhysicalDeviceQueueFamilyProperties( _gpu, &family_count, nullptr );
std::vector<VkQueueFamilyProperties> family_property_list( family_count );
vkGetPhysicalDeviceQueueFamilyProperties( _gpu, &family_count, family_property_list.data() );
bool found = false;
for( uint32_t i=0; i < family_count; ++i ) {
if( family_property_list[ i ].queueFlags & VK_QUEUE_GRAPHICS_BIT ) {
found = true;
_graphics_family_index = i;
}
}
if( !found ) {
assert( 0 && "Vulkan ERROR: Queue family supporting graphics not found." );
std::exit( -1 );
}
}
float queue_priorities[] { 1.0f };
VkDeviceQueueCreateInfo device_queue_create_info {};
device_queue_create_info.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
device_queue_create_info.queueFamilyIndex = _graphics_family_index;
device_queue_create_info.queueCount = 1;
device_queue_create_info.pQueuePriorities = queue_priorities;
VkDeviceCreateInfo device_create_info {};
device_create_info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
device_create_info.queueCreateInfoCount = 1;
device_create_info.pQueueCreateInfos = &device_queue_create_info;
device_create_info.enabledLayerCount = _device_layers.size();
device_create_info.ppEnabledLayerNames = _device_layers.data();
device_create_info.enabledExtensionCount = _device_extensions.size();
device_create_info.ppEnabledExtensionNames = _device_extensions.data();
ErrorCheck( vkCreateDevice( _gpu, &device_create_info, nullptr, &_device ) );
vkGetDeviceQueue( _device, _graphics_family_index, 0, &_queue );
}
RHIDevice* VulkanInstance::createDevice(unsigned int physicalDevice)
{
// Query vulkan for number of physical devices.
unsigned int numOfPhysicalDevices = 0;
VKR_VK_VERIFY(Fatal, vkEnumeratePhysicalDevices(m_instance,
&numOfPhysicalDevices,
nullptr));
// Query again with an array to hold the devices.
std::vector<VkPhysicalDevice> physicalDevices(numOfPhysicalDevices);
VKR_VK_VERIFY(Fatal, vkEnumeratePhysicalDevices(m_instance,
&numOfPhysicalDevices,
physicalDevices.data()));
return new VulkanDevice(physicalDevices[physicalDevice], std::vector<const char*>(), std::vector<const char*>());
}
/** Enumerates and caches all available physical devices. */
void Anvil::Instance::enumerate_physical_devices()
{
std::vector<VkPhysicalDevice> devices;
uint32_t n_physical_devices = 0;
VkResult result = VK_ERROR_INITIALIZATION_FAILED;
ANVIL_REDUNDANT_VARIABLE(result);
/* Retrieve physical device handles */
result = vkEnumeratePhysicalDevices(m_instance,
&n_physical_devices,
nullptr); /* pPhysicalDevices */
anvil_assert_vk_call_succeeded(result);
if (n_physical_devices == 0)
{
fprintf(stderr,"No physical devices reported for the Vulkan instance");
fflush (stderr);
anvil_assert_fail();
}
devices.resize(n_physical_devices);
result = vkEnumeratePhysicalDevices(m_instance,
&n_physical_devices,
&devices[0]);
anvil_assert_vk_call_succeeded(result);
/* Fill out internal physical device descriptors */
for (unsigned int n_physical_device = 0;
n_physical_device < n_physical_devices;
++n_physical_device)
{
std::unique_ptr<Anvil::PhysicalDevice> new_physical_device_ptr;
new_physical_device_ptr = Anvil::PhysicalDevice::create(this,
n_physical_device,
devices[n_physical_device]);
m_physical_devices.push_back(
std::move(new_physical_device_ptr)
);
}
}
VkResult Device::create()
{
VkResult result = VK_SUCCESS;
uint32_t physCount = 0;
result = vkEnumeratePhysicalDevices(vk::getInstance(), &physCount, nullptr);
if (result != VK_SUCCESS || physCount == 0)
{
return result;
}
physCount = 1;
result = vkEnumeratePhysicalDevices(vk::getInstance(), &physCount, &m_physicalDevice);
if (result != VK_SUCCESS)
{
return result;
}
float queuePriorities[1] = { 0.0f };
VkDeviceQueueCreateInfo deviceQueueCreateInfo = {};
deviceQueueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
deviceQueueCreateInfo.flags = 0;
deviceQueueCreateInfo.queueFamilyIndex = 0;
deviceQueueCreateInfo.queueCount = 1;
deviceQueueCreateInfo.pQueuePriorities = queuePriorities;
const char* enabledExtensionNames[] = { VK_KHR_SWAPCHAIN_EXTENSION_NAME };
VkDeviceCreateInfo deviceCreateInfo = {};
deviceCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
deviceCreateInfo.flags = 0;
deviceCreateInfo.queueCreateInfoCount = 1;
deviceCreateInfo.pQueueCreateInfos = &deviceQueueCreateInfo;
deviceCreateInfo.enabledLayerCount = 0;
deviceCreateInfo.ppEnabledLayerNames = nullptr;
deviceCreateInfo.enabledExtensionCount = 1;
deviceCreateInfo.ppEnabledExtensionNames = enabledExtensionNames;
deviceCreateInfo.pEnabledFeatures = nullptr;
return vkCreateDevice(m_physicalDevice, &deviceCreateInfo, nullptr, &m_device);
}
void getDevicesList()
{
vkEnumeratePhysicalDevices( gInstance, &gDeviceCount, gDevices );
std::cout << "Device list:\n";
for( u32 i = 0; i < gDeviceCount; ++i )
{
VkPhysicalDeviceProperties properties;
vkGetPhysicalDeviceProperties( gDevices[i], &properties );
std::cout << "\t" << properties.deviceName << std::endl;
}
}
// TODO: Rewrite to find first device supporting all required extensions
bool VkContext::GetPhysicalDevice() {
u32 deviceCount = 1;
CheckVkResult(vkEnumeratePhysicalDevices(instance, &deviceCount, &physDev));
if (deviceCount == 0) {
std::cout << "No Vulkan GPU found" << std::endl;
return false;
}
return true;
}
void Renderer::_InitDevice()
{
uint32_t deviceCount = 0;
VkResult result = vkEnumeratePhysicalDevices(instance, &deviceCount, NULL);
if (result != VK_SUCCESS) {
fprintf(stderr, "Failed to query the number of physical devices present: %d\n", result);
abort();
}
// There has to be at least one device present
if (deviceCount == 0) {
fprintf(stderr, "Couldn't detect any device present with Vulkan support: %d\n", result);
abort();
}
// Get the physical devices
std::vector<VkPhysicalDevice> physicalDevices(deviceCount);
result = vkEnumeratePhysicalDevices(instance, &deviceCount, &physicalDevices[0]);
if (result != VK_SUCCESS) {
fprintf(stderr, "Faied to enumerate physical devices present: %d\n", result);
abort();
}
// Enumerate all physical devices
VkPhysicalDeviceProperties deviceProperties;
for (uint32_t i = 0; i < deviceCount; i++) {
memset(&deviceProperties, 0, sizeof deviceProperties);
vkGetPhysicalDeviceProperties(physicalDevices[i], &deviceProperties);
printf("Driver Version: %d\n", deviceProperties.driverVersion);
printf("Device Name: %s\n", deviceProperties.deviceName);
printf("Device Type: %d\n", deviceProperties.deviceType);
printf("API Version: %d.%d.%d\n",
// See note below regarding this:
(deviceProperties.apiVersion >> 22) & 0x3FF,
(deviceProperties.apiVersion >> 12) & 0x3FF,
(deviceProperties.apiVersion & 0xFFF));
}
}
void pickPhysicalDevice() {
uint32_t deviceCount = 0;
vkEnumeratePhysicalDevices(instance, &deviceCount, nullptr);
if (deviceCount == 0) {
throw std::runtime_error("failed to find GPUs with Vulkan support!");
}
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("failed to find a suitable GPU!");
}
}
VulkanContext::GPUList VulkanContext::EnumerateGPUs(VkInstance instance)
{
u32 gpu_count = 0;
VkResult res = vkEnumeratePhysicalDevices(instance, &gpu_count, nullptr);
if (res != VK_SUCCESS)
{
LOG_VULKAN_ERROR(res, "vkEnumeratePhysicalDevices failed: ");
return {};
}
GPUList gpus;
gpus.resize(gpu_count);
res = vkEnumeratePhysicalDevices(instance, &gpu_count, gpus.data());
if (res != VK_SUCCESS)
{
LOG_VULKAN_ERROR(res, "vkEnumeratePhysicalDevices failed: ");
return {};
}
return gpus;
}
TEST(EnumerateDeviceExtensionProperties, DeviceExtensionEnumerated)
{
VkInstance instance = VK_NULL_HANDLE;
VkResult result = vkCreateInstance(VK::InstanceCreateInfo(), VK_NULL_HANDLE, &instance);
ASSERT_EQ(result, VK_SUCCESS);
uint32_t physicalCount = 0;
result = vkEnumeratePhysicalDevices(instance, &physicalCount, nullptr);
ASSERT_EQ(result, VK_SUCCESS);
ASSERT_GT(physicalCount, 0u);
std::unique_ptr<VkPhysicalDevice[]> physical(new VkPhysicalDevice[physicalCount]);
result = vkEnumeratePhysicalDevices(instance, &physicalCount, physical.get());
ASSERT_EQ(result, VK_SUCCESS);
ASSERT_GT(physicalCount, 0u);
for(uint32_t p = 0; p < physicalCount; ++p)
{
uint32_t count = 0u;
result = vkEnumerateDeviceExtensionProperties(physical[p], nullptr, &count, nullptr);
ASSERT_EQ(result, VK_SUCCESS);
std::unique_ptr<VkExtensionProperties[]> properties(new VkExtensionProperties[count]);
result = vkEnumerateDeviceExtensionProperties(physical[p], nullptr, &count, properties.get());
ASSERT_EQ(result, VK_SUCCESS);
ASSERT_NE(std::find_if(
&properties[0],
&properties[count],
[](VkExtensionProperties const& properties)
{
return strcmp(properties.extensionName, "VK_KHR_swapchain") == 0;
}),
&properties[count]);
}
vkDestroyInstance(instance, nullptr);
}
bool Instance::EnumeratePhysicalDevices(std::vector<VkPhysicalDevice>* devices)
{
NazaraAssert(devices, "Invalid device vector");
// First, query physical device count
UInt32 deviceCount = 0; // Remember, Nz::UInt32 is a typedef on uint32_t
m_lastErrorCode = vkEnumeratePhysicalDevices(m_instance, &deviceCount, nullptr);
if (m_lastErrorCode != VkResult::VK_SUCCESS || deviceCount == 0)
{
NazaraError("Failed to query physical device count");
return false;
}
// Now we can get the list of the available physical device
devices->resize(deviceCount);
m_lastErrorCode = vkEnumeratePhysicalDevices(m_instance, &deviceCount, devices->data());
if (m_lastErrorCode != VkResult::VK_SUCCESS)
{
NazaraError("Failed to query physical devices");
return false;
}
return true;
}
TEST(EnumerateDeviceExtensionProperties, PropertyCountLessThanAvailable)
{
VkInstance instance = VK_NULL_HANDLE;
VkResult result = vkCreateInstance(VK::InstanceCreateInfo(), VK_NULL_HANDLE, &instance);
ASSERT_EQ(result, VK_SUCCESS);
uint32_t physicalCount = 0;
result = vkEnumeratePhysicalDevices(instance, &physicalCount, nullptr);
ASSERT_EQ(result, VK_SUCCESS);
ASSERT_GT(physicalCount, 0u);
std::unique_ptr<VkPhysicalDevice[]> physical(new VkPhysicalDevice[physicalCount]);
result = vkEnumeratePhysicalDevices(instance, &physicalCount, physical.get());
ASSERT_EQ(result, VK_SUCCESS);
ASSERT_GT(physicalCount, 0u);
for(uint32_t p = 0; p < physicalCount; ++p)
{
uint32_t count = 0u;
result = vkEnumerateDeviceExtensionProperties(physical[p], nullptr, &count, nullptr);
ASSERT_EQ(result, VK_SUCCESS);
// We need atleast two for the test to be relevant.
if(count < 2u)
{
continue;
}
std::unique_ptr<VkExtensionProperties[]> properties(new VkExtensionProperties[count]);
count = 1;
result = vkEnumerateDeviceExtensionProperties(physical[p], nullptr, &count, properties.get());
ASSERT_EQ(result, VK_INCOMPLETE);
}
vkDestroyInstance(instance, nullptr);
}
void RHIRoot::Initialize(const char * appName, bool debug)
{
vkCreateInstance = reinterpret_cast<PFN_vkCreateInstance>(dynlib::GetVulkanLib().ResolveEntry("vkCreateInstance"));
vkDestroyInstance = reinterpret_cast<PFN_vkDestroyInstance>(dynlib::GetVulkanLib().ResolveEntry("vkDestroyInstance"));
vkEnumeratePhysicalDevices = reinterpret_cast<PFN_vkEnumeratePhysicalDevices>(dynlib::GetVulkanLib().ResolveEntry("vkEnumeratePhysicalDevices"));
vkEnumerateInstanceLayerProperties = (PFN_vkEnumerateInstanceLayerProperties)dynlib::GetVulkanLib().ResolveEntry("vkEnumerateInstanceLayerProperties");
vkEnumerateInstanceExtensionProperties = (PFN_vkEnumerateInstanceExtensionProperties)dynlib::GetVulkanLib().ResolveEntry("vkEnumerateInstanceExtensionProperties");
vkGetPhysicalDeviceProperties = (PFN_vkGetPhysicalDeviceProperties)dynlib::GetVulkanLib().ResolveEntry("vkGetPhysicalDeviceProperties");
vkGetPhysicalDeviceMemoryProperties = (PFN_vkGetPhysicalDeviceMemoryProperties)dynlib::GetVulkanLib().ResolveEntry("vkGetPhysicalDeviceMemoryProperties");
vkGetPhysicalDeviceQueueFamilyProperties = (PFN_vkGetPhysicalDeviceQueueFamilyProperties)dynlib::GetVulkanLib().ResolveEntry("vkGetPhysicalDeviceQueueFamilyProperties");
vkCreateDevice = (PFN_vkCreateDevice)dynlib::GetVulkanLib().ResolveEntry("vkCreateDevice");
EnumLayers();
VkResult err = CreateInstance(debug, appName);
if (err == VK_ERROR_INCOMPATIBLE_DRIVER) {
VKLOG(Error, "Cannot find a compatible Vulkan installable client driver: vkCreateInstance Failure");
}
else if (err == VK_ERROR_EXTENSION_NOT_PRESENT) {
VKLOG(Error, "Cannot find a specified extension library: vkCreateInstance Failure");
}
else {
K3D_VK_VERIFY(err);
}
uint32_t gpuCount = 0;
K3D_VK_VERIFY(vkEnumeratePhysicalDevices(Instance, &gpuCount, nullptr));
VKLOG(Info, "RHIRoot::Initializer Device Count : %u .", gpuCount);
std::vector<VkPhysicalDevice> deviceList(gpuCount);
err = vkEnumeratePhysicalDevices(Instance, &gpuCount, deviceList.data());
VkPhysicalDeviceProperties physicalDeviceProperties = {};
vkGetPhysicalDeviceProperties(deviceList[0], &physicalDeviceProperties);
VKLOG(Info, "Vulkan First Device: %s", physicalDeviceProperties.deviceName);
PhysicalDevices.swap(deviceList);
}
bool VulkanDevice::Init(VulkanInstance * vulkanInstance, HWND hwnd)
{
VkResult result;
// GPU
uint32_t numGPUs = 0;
vkEnumeratePhysicalDevices(vulkanInstance->GetInstance(), &numGPUs, VK_NULL_HANDLE);
if (numGPUs == 0)
{
gLogManager->AddMessage("ERROR: No GPUs found!");
return false;
}
std::vector<VkPhysicalDevice> pGPUs(numGPUs);
vkEnumeratePhysicalDevices(vulkanInstance->GetInstance(), &numGPUs, pGPUs.data());
gpu = pGPUs[0];
vkGetPhysicalDeviceProperties(gpu, &gpuProperties);
vkGetPhysicalDeviceMemoryProperties(gpu, &memoryProperties);
gLogManager->AddMessage("Rendering with: " + std::string(gpuProperties.deviceName));
// Queue family
uint32_t numQueueFamily = 0;
vkGetPhysicalDeviceQueueFamilyProperties(gpu, &numQueueFamily, VK_NULL_HANDLE);
if (numQueueFamily == 0)
{
gLogManager->AddMessage("ERROR: No Queue Families were found!");
return false;
}
queueFamiliyProperties.resize(numQueueFamily);
vkGetPhysicalDeviceQueueFamilyProperties(gpu, &numQueueFamily, queueFamiliyProperties.data());
// Surface
VkWin32SurfaceCreateInfoKHR win32SurfaceCI{};
win32SurfaceCI.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR;
win32SurfaceCI.hinstance = GetModuleHandle(NULL);
win32SurfaceCI.hwnd = hwnd;
result = vkCreateWin32SurfaceKHR(vulkanInstance->GetInstance(), &win32SurfaceCI, VK_NULL_HANDLE, &surface);
if (result != VK_SUCCESS)
{
gLogManager->AddMessage("ERROR: Couldn't create Win32 Surface!");
return false;
}
VkBool32 * supportsPresent = new VkBool32[queueFamiliyProperties.size()];
for (uint32_t i = 0; i < queueFamiliyProperties.size(); i++)
vkGetPhysicalDeviceSurfaceSupportKHR(gpu, i, surface, &supportsPresent[i]);
graphicsQueueFamilyIndex = UINT32_MAX;
for (uint32_t i = 0; i < queueFamiliyProperties.size(); i++)
{
if ((queueFamiliyProperties[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) != 0)
{
if (supportsPresent[i] == VK_TRUE)
{
graphicsQueueFamilyIndex = i;
break;
}
}
}
delete[] supportsPresent;
if (graphicsQueueFamilyIndex == UINT32_MAX)
{
gLogManager->AddMessage("ERROR: Couldn't find a graphics queue family index!");
return false;
}
uint32_t numFormats;
result = vkGetPhysicalDeviceSurfaceFormatsKHR(gpu, surface, &numFormats, VK_NULL_HANDLE);
if (result != VK_SUCCESS)
{
gLogManager->AddMessage("ERROR: Couldn't get surface formats!");
return false;
}
VkSurfaceFormatKHR * pSurfaceFormats = new VkSurfaceFormatKHR[numFormats];
result = vkGetPhysicalDeviceSurfaceFormatsKHR(gpu, surface, &numFormats, pSurfaceFormats);
if (numFormats == 1 && pSurfaceFormats[0].format == VK_FORMAT_UNDEFINED)
format = VK_FORMAT_B8G8R8A8_UNORM;
else
format = pSurfaceFormats[0].format;
// Device queue
float pQueuePriorities[] = { 1.0f };
VkDeviceQueueCreateInfo deviceQueueCI{};
deviceQueueCI.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
deviceQueueCI.queueCount = 1;
deviceQueueCI.queueFamilyIndex = graphicsQueueFamilyIndex;
deviceQueueCI.pQueuePriorities = pQueuePriorities;
VkPhysicalDeviceFeatures deviceFeatures{};
deviceFeatures.shaderClipDistance = VK_TRUE;
deviceFeatures.shaderCullDistance = VK_TRUE;
deviceFeatures.geometryShader = VK_TRUE;
deviceFeatures.shaderTessellationAndGeometryPointSize = VK_TRUE;
deviceFeatures.fillModeNonSolid = VK_TRUE;
// Device
VkDeviceCreateInfo deviceCI{};
deviceCI.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
deviceCI.queueCreateInfoCount = 1;
deviceCI.pQueueCreateInfos = &deviceQueueCI;
deviceCI.enabledExtensionCount = (uint32_t)deviceExtensions.size();
deviceCI.ppEnabledExtensionNames = deviceExtensions.data();
deviceCI.pEnabledFeatures = &deviceFeatures;
result = vkCreateDevice(gpu, &deviceCI, VK_NULL_HANDLE, &device);
if (result != VK_SUCCESS)
{
gLogManager->AddMessage("ERROR: vkCreateDevice() failed!");
return false;
}
vkGetDeviceQueue(device, graphicsQueueFamilyIndex, 0, &deviceQueue);
return true;
}
VkResult VulkanContext::CreateInstance(const CreateInfo &info) {
if (!vkCreateInstance) {
init_error_ = "Vulkan not loaded - can't create instance";
return VK_ERROR_INITIALIZATION_FAILED;
}
flags_ = info.flags;
// List extensions to try to enable.
instance_extensions_enabled_.push_back(VK_KHR_SURFACE_EXTENSION_NAME);
#ifdef _WIN32
instance_extensions_enabled_.push_back(VK_KHR_WIN32_SURFACE_EXTENSION_NAME);
#elif defined(__ANDROID__)
instance_extensions_enabled_.push_back(VK_KHR_ANDROID_SURFACE_EXTENSION_NAME);
#else
#if defined(VK_USE_PLATFORM_XLIB_KHR)
if (IsInstanceExtensionAvailable(VK_KHR_XLIB_SURFACE_EXTENSION_NAME)) {
instance_extensions_enabled_.push_back(VK_KHR_XLIB_SURFACE_EXTENSION_NAME);
}
#endif
//#if defined(VK_USE_PLATFORM_XCB_KHR)
// instance_extensions_enabled_.push_back(VK_KHR_XCB_SURFACE_EXTENSION_NAME);
//#endif
//#if defined(VK_USE_PLATFORM_MIR_KHR)
// instance_extensions_enabled_.push_back(VK_KHR_MIR_SURFACE_EXTENSION_NAME);
//#endif
#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
if (IsInstanceExtensionAvailable(VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME)) {
instance_extensions_enabled_.push_back(VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME);
}
#endif
#endif
if (flags_ & VULKAN_FLAG_VALIDATE) {
if (IsInstanceExtensionAvailable(VK_EXT_DEBUG_REPORT_EXTENSION_NAME)) {
for (size_t i = 0; i < ARRAY_SIZE(validationLayers); i++) {
instance_layer_names_.push_back(validationLayers[i]);
device_layer_names_.push_back(validationLayers[i]);
}
instance_extensions_enabled_.push_back(VK_EXT_DEBUG_REPORT_EXTENSION_NAME);
} else {
ELOG("Validation layer extension not available - not enabling Vulkan validation.");
flags_ &= ~VULKAN_FLAG_VALIDATE;
}
}
// Validate that all the instance extensions we ask for are actually available.
for (auto ext : instance_extensions_enabled_) {
if (!IsInstanceExtensionAvailable(ext))
WLOG("WARNING: Does not seem that instance extension '%s' is available. Trying to proceed anyway.", ext);
}
VkApplicationInfo app_info{ VK_STRUCTURE_TYPE_APPLICATION_INFO };
app_info.pApplicationName = info.app_name;
app_info.applicationVersion = info.app_ver;
app_info.pEngineName = info.app_name;
// Let's increment this when we make major engine/context changes.
app_info.engineVersion = 2;
app_info.apiVersion = VK_API_VERSION_1_0;
VkInstanceCreateInfo inst_info{ VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO };
inst_info.flags = 0;
inst_info.pApplicationInfo = &app_info;
inst_info.enabledLayerCount = (uint32_t)instance_layer_names_.size();
inst_info.ppEnabledLayerNames = instance_layer_names_.size() ? instance_layer_names_.data() : nullptr;
inst_info.enabledExtensionCount = (uint32_t)instance_extensions_enabled_.size();
inst_info.ppEnabledExtensionNames = instance_extensions_enabled_.size() ? instance_extensions_enabled_.data() : nullptr;
#if SIMULATE_VULKAN_FAILURE == 2
VkResult res = VK_ERROR_INCOMPATIBLE_DRIVER;
#else
VkResult res = vkCreateInstance(&inst_info, nullptr, &instance_);
#endif
if (res != VK_SUCCESS) {
if (res == VK_ERROR_LAYER_NOT_PRESENT) {
WLOG("Validation on but layers not available - dropping layers");
// Drop the validation layers and try again.
instance_layer_names_.clear();
device_layer_names_.clear();
inst_info.enabledLayerCount = 0;
inst_info.ppEnabledLayerNames = nullptr;
res = vkCreateInstance(&inst_info, nullptr, &instance_);
if (res != VK_SUCCESS)
ELOG("Failed to create instance even without validation: %d", res);
} else {
ELOG("Failed to create instance : %d", res);
}
}
if (res != VK_SUCCESS) {
init_error_ = "Failed to create Vulkan instance";
return res;
}
VulkanLoadInstanceFunctions(instance_);
if (!CheckLayers(instance_layer_properties_, instance_layer_names_)) {
WLOG("CheckLayers for instance failed");
// init_error_ = "Failed to validate instance layers";
// return;
}
uint32_t gpu_count = 1;
#if SIMULATE_VULKAN_FAILURE == 3
gpu_count = 0;
#else
res = vkEnumeratePhysicalDevices(instance_, &gpu_count, nullptr);
#endif
if (gpu_count <= 0) {
ELOG("Vulkan driver found but no supported GPU is available");
init_error_ = "No Vulkan physical devices found";
vkDestroyInstance(instance_, nullptr);
instance_ = nullptr;
return VK_ERROR_INITIALIZATION_FAILED;
}
assert(gpu_count > 0);
physical_devices_.resize(gpu_count);
res = vkEnumeratePhysicalDevices(instance_, &gpu_count, physical_devices_.data());
if (res != VK_SUCCESS) {
init_error_ = "Failed to enumerate physical devices";
vkDestroyInstance(instance_, nullptr);
instance_ = nullptr;
return res;
}
return VK_SUCCESS;
}
// Create the base Vulkan objects needed by the GrVkGpu object
const GrVkBackendContext* GrVkBackendContext::Create(uint32_t* presentQueueIndexPtr,
bool(*canPresent)(VkInstance, VkPhysicalDevice, uint32_t queueIndex)) {
VkPhysicalDevice physDev;
VkDevice device;
VkInstance inst;
VkResult err;
const VkApplicationInfo app_info = {
VK_STRUCTURE_TYPE_APPLICATION_INFO, // sType
nullptr, // pNext
"vktest", // pApplicationName
0, // applicationVersion
"vktest", // pEngineName
0, // engineVerison
kGrVkMinimumVersion, // apiVersion
};
GrVkExtensions extensions;
extensions.initInstance(kGrVkMinimumVersion);
SkTArray<const char*> instanceLayerNames;
SkTArray<const char*> instanceExtensionNames;
uint32_t extensionFlags = 0;
#ifdef ENABLE_VK_LAYERS
for (size_t i = 0; i < SK_ARRAY_COUNT(kDebugLayerNames); ++i) {
if (extensions.hasInstanceLayer(kDebugLayerNames[i])) {
instanceLayerNames.push_back(kDebugLayerNames[i]);
}
}
if (extensions.hasInstanceExtension(VK_EXT_DEBUG_REPORT_EXTENSION_NAME)) {
instanceExtensionNames.push_back(VK_EXT_DEBUG_REPORT_EXTENSION_NAME);
extensionFlags |= kEXT_debug_report_GrVkExtensionFlag;
}
#endif
if (extensions.hasInstanceExtension(VK_KHR_SURFACE_EXTENSION_NAME)) {
instanceExtensionNames.push_back(VK_KHR_SURFACE_EXTENSION_NAME);
extensionFlags |= kKHR_surface_GrVkExtensionFlag;
}
if (extensions.hasInstanceExtension(VK_KHR_SWAPCHAIN_EXTENSION_NAME)) {
instanceExtensionNames.push_back(VK_KHR_SWAPCHAIN_EXTENSION_NAME);
extensionFlags |= kKHR_swapchain_GrVkExtensionFlag;
}
#ifdef SK_BUILD_FOR_WIN
if (extensions.hasInstanceExtension(VK_KHR_WIN32_SURFACE_EXTENSION_NAME)) {
instanceExtensionNames.push_back(VK_KHR_WIN32_SURFACE_EXTENSION_NAME);
extensionFlags |= kKHR_win32_surface_GrVkExtensionFlag;
}
#elif SK_BUILD_FOR_ANDROID
if (extensions.hasInstanceExtension(VK_KHR_ANDROID_SURFACE_EXTENSION_NAME)) {
instanceExtensionNames.push_back(VK_KHR_ANDROID_SURFACE_EXTENSION_NAME);
extensionFlags |= kKHR_android_surface_GrVkExtensionFlag;
}
#elif SK_BUILD_FOR_UNIX
if (extensions.hasInstanceExtension(VK_KHR_XLIB_SURFACE_EXTENSION_NAME)) {
instanceExtensionNames.push_back(VK_KHR_XLIB_SURFACE_EXTENSION_NAME);
extensionFlags |= kKHR_xlib_surface_GrVkExtensionFlag;
}
#endif
const VkInstanceCreateInfo instance_create = {
VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, // sType
nullptr, // pNext
0, // flags
&app_info, // pApplicationInfo
(uint32_t) instanceLayerNames.count(), // enabledLayerNameCount
instanceLayerNames.begin(), // ppEnabledLayerNames
(uint32_t) instanceExtensionNames.count(), // enabledExtensionNameCount
instanceExtensionNames.begin(), // ppEnabledExtensionNames
};
err = vkCreateInstance(&instance_create, nullptr, &inst);
if (err < 0) {
SkDebugf("vkCreateInstance failed: %d\n", err);
return nullptr;
}
uint32_t gpuCount;
err = vkEnumeratePhysicalDevices(inst, &gpuCount, nullptr);
if (err) {
SkDebugf("vkEnumeratePhysicalDevices failed: %d\n", err);
vkDestroyInstance(inst, nullptr);
return nullptr;
}
SkASSERT(gpuCount > 0);
// Just returning the first physical device instead of getting the whole array.
// TODO: find best match for our needs
gpuCount = 1;
err = vkEnumeratePhysicalDevices(inst, &gpuCount, &physDev);
if (err) {
SkDebugf("vkEnumeratePhysicalDevices failed: %d\n", err);
vkDestroyInstance(inst, nullptr);
return nullptr;
}
// query to get the initial queue props size
uint32_t queueCount;
vkGetPhysicalDeviceQueueFamilyProperties(physDev, &queueCount, nullptr);
SkASSERT(queueCount >= 1);
SkAutoMalloc queuePropsAlloc(queueCount * sizeof(VkQueueFamilyProperties));
// now get the actual queue props
VkQueueFamilyProperties* queueProps = (VkQueueFamilyProperties*)queuePropsAlloc.get();
vkGetPhysicalDeviceQueueFamilyProperties(physDev, &queueCount, queueProps);
// iterate to find the graphics queue
uint32_t graphicsQueueIndex = queueCount;
for (uint32_t i = 0; i < queueCount; i++) {
if (queueProps[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
graphicsQueueIndex = i;
break;
}
}
SkASSERT(graphicsQueueIndex < queueCount);
// iterate to find the present queue, if needed
uint32_t presentQueueIndex = graphicsQueueIndex;
if (presentQueueIndexPtr && canPresent) {
for (uint32_t i = 0; i < queueCount; i++) {
if (canPresent(inst, physDev, i)) {
presentQueueIndex = i;
break;
}
}
SkASSERT(presentQueueIndex < queueCount);
*presentQueueIndexPtr = presentQueueIndex;
}
extensions.initDevice(kGrVkMinimumVersion, inst, physDev);
SkTArray<const char*> deviceLayerNames;
SkTArray<const char*> deviceExtensionNames;
#ifdef ENABLE_VK_LAYERS
for (size_t i = 0; i < SK_ARRAY_COUNT(kDebugLayerNames); ++i) {
if (extensions.hasDeviceLayer(kDebugLayerNames[i])) {
deviceLayerNames.push_back(kDebugLayerNames[i]);
}
}
#endif
if (extensions.hasDeviceExtension(VK_KHR_SWAPCHAIN_EXTENSION_NAME)) {
deviceExtensionNames.push_back(VK_KHR_SWAPCHAIN_EXTENSION_NAME);
extensionFlags |= kKHR_swapchain_GrVkExtensionFlag;
}
if (extensions.hasDeviceExtension("VK_NV_glsl_shader")) {
deviceExtensionNames.push_back("VK_NV_glsl_shader");
extensionFlags |= kNV_glsl_shader_GrVkExtensionFlag;
}
// query to get the physical device properties
VkPhysicalDeviceFeatures deviceFeatures;
vkGetPhysicalDeviceFeatures(physDev, &deviceFeatures);
// this looks like it would slow things down,
// and we can't depend on it on all platforms
deviceFeatures.robustBufferAccess = VK_FALSE;
uint32_t featureFlags = 0;
if (deviceFeatures.geometryShader) {
featureFlags |= kGeometryShader_GrVkFeatureFlag;
}
if (deviceFeatures.dualSrcBlend) {
featureFlags |= kDualSrcBlend_GrVkFeatureFlag;
}
if (deviceFeatures.sampleRateShading) {
featureFlags |= kSampleRateShading_GrVkFeatureFlag;
}
float queuePriorities[1] = { 0.0 };
// Here we assume no need for swapchain queue
// If one is needed, the client will need its own setup code
const VkDeviceQueueCreateInfo queueInfo[2] = {
{
VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, // sType
nullptr, // pNext
0, // VkDeviceQueueCreateFlags
graphicsQueueIndex, // queueFamilyIndex
1, // queueCount
queuePriorities, // pQueuePriorities
},
{
VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, // sType
nullptr, // pNext
0, // VkDeviceQueueCreateFlags
presentQueueIndex, // queueFamilyIndex
1, // queueCount
queuePriorities, // pQueuePriorities
}
};
uint32_t queueInfoCount = (presentQueueIndex != graphicsQueueIndex) ? 2 : 1;
const VkDeviceCreateInfo deviceInfo = {
VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, // sType
nullptr, // pNext
0, // VkDeviceCreateFlags
queueInfoCount, // queueCreateInfoCount
queueInfo, // pQueueCreateInfos
(uint32_t) deviceLayerNames.count(), // layerCount
deviceLayerNames.begin(), // ppEnabledLayerNames
(uint32_t) deviceExtensionNames.count(), // extensionCount
deviceExtensionNames.begin(), // ppEnabledExtensionNames
&deviceFeatures // ppEnabledFeatures
};
err = vkCreateDevice(physDev, &deviceInfo, nullptr, &device);
if (err) {
SkDebugf("CreateDevice failed: %d\n", err);
vkDestroyInstance(inst, nullptr);
return nullptr;
}
VkQueue queue;
vkGetDeviceQueue(device, graphicsQueueIndex, 0, &queue);
GrVkBackendContext* ctx = new GrVkBackendContext();
ctx->fInstance = inst;
ctx->fPhysicalDevice = physDev;
ctx->fDevice = device;
ctx->fQueue = queue;
ctx->fGraphicsQueueIndex = graphicsQueueIndex;
ctx->fMinAPIVersion = kGrVkMinimumVersion;
ctx->fExtensions = extensionFlags;
ctx->fFeatures = featureFlags;
ctx->fInterface.reset(GrVkCreateInterface(inst, device, extensionFlags));
return ctx;
}
C9::C9()
: mGpuCount(0),
mPhysicalDevices(nullptr),
mReferenceCount(0),
mInstance(VK_NULL_HANDLE),
mLayerProperties(nullptr),
mLayerPropertyCount(0),
mValidationPresent(false),
mResult(VK_SUCCESS),
mOptionDescriptions("Allowed options")
{
//Setup configuration & logging.
mOptionDescriptions.add_options()
("LogFile", boost::program_options::value<std::string>(), "The location of the log file.");
boost::program_options::store(boost::program_options::parse_config_file<char>("SchaeferGL.conf", mOptionDescriptions), mOptions);
boost::program_options::notify(mOptions);
if (mOptions.count("LogFile"))
{
boost::log::add_file_log(mOptions["LogFile"].as<std::string>());
}
else
{
boost::log::add_file_log("SchaeferGL.log");
}
//Continue instance setup.
mResult = vkEnumerateInstanceLayerProperties(&mLayerPropertyCount, nullptr);
if (mResult != VK_SUCCESS)
{
BOOST_LOG_TRIVIAL(fatal) << "C9::C9 vkEnumerateInstanceLayerProperties failed with return code of " << mResult;
return;
}
else
{
BOOST_LOG_TRIVIAL(info) << "C9::C9 vkEnumerateInstanceLayerProperties found " << mLayerPropertyCount << " layers.";
}
mLayerProperties = new VkLayerProperties[mLayerPropertyCount];
mResult = vkEnumerateInstanceLayerProperties(&mLayerPropertyCount, mLayerProperties);
if (mResult == VK_SUCCESS)
{
for (size_t i = 0; i < mLayerPropertyCount; i++)
{
if (strcmp(mLayerProperties[i].layerName,"VK_LAYER_LUNARG_standard_validation")==0)
{
mValidationPresent = true;
}
BOOST_LOG_TRIVIAL(info) << "C9::C9 vkEnumerateInstanceLayerProperties - layerName: " << mLayerProperties[i].layerName;
}
}
mExtensionNames.push_back("VK_KHR_surface");
mExtensionNames.push_back("VK_KHR_win32_surface");
#ifdef _DEBUG
mExtensionNames.push_back("VK_EXT_debug_report");
mLayerExtensionNames.push_back("VK_LAYER_LUNARG_standard_validation");
#endif // _DEBUG
// initialize the VkApplicationInfo structure
VkApplicationInfo app_info = {};
app_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
app_info.pNext = nullptr;
app_info.pApplicationName = APP_SHORT_NAME;
app_info.applicationVersion = 1;
app_info.pEngineName = APP_SHORT_NAME;
app_info.engineVersion = 1;
app_info.apiVersion = 0; // VK_API_VERSION;
// initialize the VkInstanceCreateInfo structure
VkInstanceCreateInfo inst_info =
{
VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, // VkStructureType sType;
NULL, // const void* pNext;
0, // VkInstanceCreateFlags flags;
&app_info, // const VkApplicationInfo* pApplicationInfo;
mLayerExtensionNames.size(), // uint32_t enabledLayerNameCount;
mLayerExtensionNames.size()>0 ? mLayerExtensionNames.data() : nullptr,// const char* const* ppEnabledLayerNames;
mExtensionNames.size(), // uint32_t enabledExtensionNameCount;
mExtensionNames.size()>0 ? mExtensionNames.data() : nullptr, // const char* const* ppEnabledExtensionNames;
};
//Get an instance handle.
if (VK_SUCCESS == vkCreateInstance(&inst_info, NULL, &mInstance))
{
#ifdef _DEBUG
/* Load VK_EXT_debug_report entry points in debug builds */
vkCreateDebugReportCallbackEXT = reinterpret_cast<PFN_vkCreateDebugReportCallbackEXT>(vkGetInstanceProcAddr(mInstance, "vkCreateDebugReportCallbackEXT"));
vkDebugReportMessageEXT = reinterpret_cast<PFN_vkDebugReportMessageEXT>(vkGetInstanceProcAddr(mInstance, "vkDebugReportMessageEXT"));
vkDestroyDebugReportCallbackEXT = reinterpret_cast<PFN_vkDestroyDebugReportCallbackEXT>(vkGetInstanceProcAddr(mInstance, "vkDestroyDebugReportCallbackEXT"));
VkDebugReportCallbackCreateInfoEXT callbackCreateInfo = {};
callbackCreateInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT;
callbackCreateInfo.pNext = nullptr;
callbackCreateInfo.flags = VK_DEBUG_REPORT_ERROR_BIT_EXT | VK_DEBUG_REPORT_WARNING_BIT_EXT | VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT;
callbackCreateInfo.pfnCallback = &DebugReportCallback;
callbackCreateInfo.pUserData = nullptr;
/* Register the callback */
mResult = vkCreateDebugReportCallbackEXT(mInstance, &callbackCreateInfo, nullptr, &mCallback);
if (mResult != VK_SUCCESS)
{
BOOST_LOG_TRIVIAL(fatal) << "C9::C9 vkCreateDebugReportCallbackEXT failed with return code of " << mResult;
return;
}
else
{
BOOST_LOG_TRIVIAL(info) << "C9::C9 vkCreateDebugReportCallbackEXT succeeded.";
}
#endif
//Fetch an array of available physical devices.
mResult = vkEnumeratePhysicalDevices(mInstance, &mGpuCount, NULL);
if (mResult != VK_SUCCESS)
{
BOOST_LOG_TRIVIAL(fatal) << "C9::C9 vkEnumeratePhysicalDevices failed with return code of " << mResult;
return;
}
else
{
BOOST_LOG_TRIVIAL(info) << "There were " << mGpuCount << " physical devices found.";
}
if (mGpuCount > 0)
{
mPhysicalDevices = new VkPhysicalDevice[mGpuCount]();
mResult = vkEnumeratePhysicalDevices(mInstance, &mGpuCount, mPhysicalDevices);
if (mResult != VK_SUCCESS)
{
BOOST_LOG_TRIVIAL(fatal) << "C9::C9 vkEnumeratePhysicalDevices failed with return code of " << mResult;
return;
}
}
else
{
BOOST_LOG_TRIVIAL(fatal) << "No phyuscial devices were found.";
}
}
else
{
BOOST_LOG_TRIVIAL(fatal) << "C9::C9 vkCreateInstance failed.";
return;
}
}
void vulkan_choose_physical_device(ReaperRoot& root, VulkanBackend& backend, PhysicalDeviceInfo& physicalDeviceInfo)
{
uint32_t deviceCount = 0;
Assert(vkEnumeratePhysicalDevices(backend.instance, &deviceCount, nullptr) == VK_SUCCESS);
Assert(deviceCount > 0);
log_debug(root, "vulkan: enumerating {} physical devices", deviceCount);
std::vector<VkPhysicalDevice> availableDevices(deviceCount);
Assert(vkEnumeratePhysicalDevices(backend.instance, &deviceCount, &availableDevices[0]) == VK_SUCCESS,
"error occurred during physical devices enumeration");
uint32_t selected_queue_family_index = UINT32_MAX;
uint32_t selected_present_queue_family_index = UINT32_MAX;
// Duplicated two times TODO merge
std::vector<const char*> extensions = {VK_KHR_SWAPCHAIN_EXTENSION_NAME};
VkPhysicalDevice chosenPhysicalDevice = VK_NULL_HANDLE;
for (auto& device : availableDevices)
{
if (vulkan_check_physical_device(root.renderer->window,
device,
backend.presentInfo.surface,
extensions,
selected_queue_family_index,
selected_present_queue_family_index))
{
chosenPhysicalDevice = device;
break;
}
}
Assert(chosenPhysicalDevice != VK_NULL_HANDLE, "could not select physical device based on the chosen properties");
physicalDeviceInfo.graphicsQueueIndex = selected_queue_family_index;
physicalDeviceInfo.presentQueueIndex = selected_present_queue_family_index;
vkGetPhysicalDeviceMemoryProperties(chosenPhysicalDevice, &physicalDeviceInfo.memory);
// re-fetch device infos TODO avoid
VkPhysicalDeviceProperties physicalDeviceProperties;
vkGetPhysicalDeviceProperties(chosenPhysicalDevice, &physicalDeviceProperties);
log_info(root, "vulkan: selecting device '{}'", physicalDeviceProperties.deviceName);
log_debug(root, "- type = {}", vulkan_physical_device_type_name(physicalDeviceProperties.deviceType));
uint32_t apiVersion = physicalDeviceProperties.apiVersion;
uint32_t driverVersion = physicalDeviceProperties.driverVersion;
log_debug(root,
"- api version = {}.{}.{}",
VK_VERSION_MAJOR(apiVersion),
VK_VERSION_MINOR(apiVersion),
VK_VERSION_PATCH(apiVersion));
log_debug(root,
"- driver version = {}.{}.{}",
VK_VERSION_MAJOR(driverVersion),
VK_VERSION_MINOR(driverVersion),
VK_VERSION_PATCH(driverVersion));
log_debug(root,
"- memory type count = {}, memory heap count = {}",
physicalDeviceInfo.memory.memoryTypeCount,
physicalDeviceInfo.memory.memoryHeapCount);
for (u32 i = 0; i < physicalDeviceInfo.memory.memoryHeapCount; ++i)
{
VkMemoryHeap& heap = physicalDeviceInfo.memory.memoryHeaps[i];
log_debug(root, "- heap {}: available size = {}, flags = {}", i, heap.size, heap.flags);
}
backend.physicalDevice = chosenPhysicalDevice;
}
static void SetupVulkan(const char** extensions, uint32_t extensions_count)
{
VkResult err;
// Create Vulkan Instance
{
VkInstanceCreateInfo create_info = {};
create_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
create_info.enabledExtensionCount = extensions_count;
create_info.ppEnabledExtensionNames = extensions;
#ifdef IMGUI_VULKAN_DEBUG_REPORT
// Enabling multiple validation layers grouped as LunarG standard validation
const char* layers[] = { "VK_LAYER_LUNARG_standard_validation" };
create_info.enabledLayerCount = 1;
create_info.ppEnabledLayerNames = layers;
// Enable debug report extension (we need additional storage, so we duplicate the user array to add our new extension to it)
const char** extensions_ext = (const char**)malloc(sizeof(const char*) * (extensions_count + 1));
memcpy(extensions_ext, extensions, extensions_count * sizeof(const char*));
extensions_ext[extensions_count] = "VK_EXT_debug_report";
create_info.enabledExtensionCount = extensions_count + 1;
create_info.ppEnabledExtensionNames = extensions_ext;
// Create Vulkan Instance
err = vkCreateInstance(&create_info, g_Allocator, &g_Instance);
check_vk_result(err);
free(extensions_ext);
// Get the function pointer (required for any extensions)
auto vkCreateDebugReportCallbackEXT = (PFN_vkCreateDebugReportCallbackEXT)vkGetInstanceProcAddr(g_Instance, "vkCreateDebugReportCallbackEXT");
IM_ASSERT(vkCreateDebugReportCallbackEXT != NULL);
// Setup the debug report callback
VkDebugReportCallbackCreateInfoEXT debug_report_ci = {};
debug_report_ci.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT;
debug_report_ci.flags = VK_DEBUG_REPORT_ERROR_BIT_EXT | VK_DEBUG_REPORT_WARNING_BIT_EXT | VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT;
debug_report_ci.pfnCallback = debug_report;
debug_report_ci.pUserData = NULL;
err = vkCreateDebugReportCallbackEXT(g_Instance, &debug_report_ci, g_Allocator, &g_DebugReport);
check_vk_result(err);
#else
// Create Vulkan Instance without any debug feature
err = vkCreateInstance(&create_info, g_Allocator, &g_Instance);
check_vk_result(err);
#endif
}
// Select GPU
{
uint32_t gpu_count;
err = vkEnumeratePhysicalDevices(g_Instance, &gpu_count, NULL);
check_vk_result(err);
VkPhysicalDevice* gpus = (VkPhysicalDevice*)malloc(sizeof(VkPhysicalDevice) * gpu_count);
err = vkEnumeratePhysicalDevices(g_Instance, &gpu_count, gpus);
check_vk_result(err);
// If a number >1 of GPUs got reported, you should find the best fit GPU for your purpose
// e.g. VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU if available, or with the greatest memory available, etc.
// for sake of simplicity we'll just take the first one, assuming it has a graphics queue family.
g_PhysicalDevice = gpus[0];
free(gpus);
}
// Select graphics queue family
{
uint32_t count;
vkGetPhysicalDeviceQueueFamilyProperties(g_PhysicalDevice, &count, NULL);
VkQueueFamilyProperties* queues = (VkQueueFamilyProperties*)malloc(sizeof(VkQueueFamilyProperties) * count);
vkGetPhysicalDeviceQueueFamilyProperties(g_PhysicalDevice, &count, queues);
for (uint32_t i = 0; i < count; i++)
if (queues[i].queueFlags & VK_QUEUE_GRAPHICS_BIT)
{
g_QueueFamily = i;
break;
}
free(queues);
IM_ASSERT(g_QueueFamily != -1);
}
// Create Logical Device (with 1 queue)
{
int device_extension_count = 1;
const char* device_extensions[] = { "VK_KHR_swapchain" };
const float queue_priority[] = { 1.0f };
VkDeviceQueueCreateInfo queue_info[1] = {};
queue_info[0].sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
queue_info[0].queueFamilyIndex = g_QueueFamily;
queue_info[0].queueCount = 1;
queue_info[0].pQueuePriorities = queue_priority;
VkDeviceCreateInfo create_info = {};
create_info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
create_info.queueCreateInfoCount = sizeof(queue_info) / sizeof(queue_info[0]);
create_info.pQueueCreateInfos = queue_info;
create_info.enabledExtensionCount = device_extension_count;
create_info.ppEnabledExtensionNames = device_extensions;
err = vkCreateDevice(g_PhysicalDevice, &create_info, g_Allocator, &g_Device);
check_vk_result(err);
vkGetDeviceQueue(g_Device, g_QueueFamily, 0, &g_Queue);
}
// Create Descriptor Pool
{
VkDescriptorPoolSize pool_sizes[] =
{
{ VK_DESCRIPTOR_TYPE_SAMPLER, 1000 },
{ VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1000 },
{ VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, 1000 },
{ VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 1000 },
{ VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, 1000 },
{ VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, 1000 },
{ VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1000 },
{ VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1000 },
{ VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, 1000 },
{ VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, 1000 },
{ VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, 1000 }
};
VkDescriptorPoolCreateInfo pool_info = {};
pool_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
pool_info.flags = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT;
pool_info.maxSets = 1000 * IM_ARRAYSIZE(pool_sizes);
pool_info.poolSizeCount = (uint32_t)IM_ARRAYSIZE(pool_sizes);
pool_info.pPoolSizes = pool_sizes;
err = vkCreateDescriptorPool(g_Device, &pool_info, g_Allocator, &g_DescriptorPool);
check_vk_result(err);
}
}
// Devices
void Renderer::_InitDevice() {
{
uint32_t gpu_count = 0;
// Read number of GPU's
vkEnumeratePhysicalDevices(_instance, &gpu_count, nullptr);
std::vector<VkPhysicalDevice> gpu_list(gpu_count);
// Populate list
vkEnumeratePhysicalDevices(_instance, &gpu_count, gpu_list.data());
_gpu = gpu_list[0]; // Get the first available list
vkGetPhysicalDeviceProperties(_gpu, &_gpu_properties);
vkGetPhysicalDeviceMemoryProperties(_gpu, &_gpu_memory_properties);
}
{
uint32_t family_count = 0;
// Read number of GPU queue family properties
vkGetPhysicalDeviceQueueFamilyProperties(_gpu, &family_count, nullptr);
std::vector<VkQueueFamilyProperties> family_property_list(family_count);
// Populate list
vkGetPhysicalDeviceQueueFamilyProperties(_gpu, &family_count, family_property_list.data());
// Find the graphics family
bool found = false;
for (uint32_t i = 0; i < family_count; ++i) {
if (family_property_list[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
found = true;
_graphics_family_index = i;
}
}
if (!found) {
assert(0 && "Vulkan ERROR: Queue family supporting graphics not found.");
std::exit(-1);
}
}
// Instance Layers
{
uint32_t layer_count = 0;
// Read the number of layers
vkEnumerateInstanceLayerProperties(&layer_count, nullptr);
std::vector<VkLayerProperties> layer_property_list(layer_count);
// Populate list
vkEnumerateInstanceLayerProperties(&layer_count, layer_property_list.data());
#if BUILD_ENABLE_VULKAN_RUNTIME_DEBUG
std::cout << "Instance layers: \n";
for (auto &i : layer_property_list) {
std::cout << " " << i.layerName << "\t\t | " << i.description << std::endl;
}
std::cout << std::endl;
#endif
}
// Instance Extensions
{
uint32_t extension_count = 0;
// Read the number of extensions
vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, nullptr);
std::vector<VkExtensionProperties> extension_property_list(extension_count);
// Populate list
vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, extension_property_list.data());
#if BUILD_ENABLE_VULKAN_RUNTIME_DEBUG
std::cout << "Instance extensions: \n";
for (auto &i : extension_property_list) {
std::cout << " " << i.extensionName << "\t\t | " << i.specVersion << std::endl;
}
std::cout << std::endl;
#endif
}
// Device Layers
{
uint32_t layer_count = 0;
// Read the number of layers
vkEnumerateDeviceLayerProperties(_gpu, &layer_count, nullptr);
std::vector<VkLayerProperties> layer_property_list(layer_count);
// Populate list
vkEnumerateDeviceLayerProperties(_gpu, &layer_count, layer_property_list.data());
#if BUILD_ENABLE_VULKAN_RUNTIME_DEBUG
std::cout << "Device layers: \n";
for (auto &i : layer_property_list) {
std::cout << " " << i.layerName << "\t\t | " << i.description << std::endl;
}
std::cout << std::endl;
#endif
}
// Device Extensions
{
uint32_t extension_count = 0;
// Read the number of extensions
vkEnumerateDeviceExtensionProperties(_gpu, nullptr, &extension_count, nullptr);
std::vector<VkExtensionProperties> extension_property_list(extension_count);
// Populate list
vkEnumerateDeviceExtensionProperties(_gpu, nullptr, &extension_count, extension_property_list.data());
#if BUILD_ENABLE_VULKAN_RUNTIME_DEBUG
std::cout << "Device extensions: \n";
for (auto &i : extension_property_list) {
std::cout << " " << i.extensionName << "\t\t | " << i.specVersion << std::endl;
}
std::cout << std::endl;
#endif
}
float queue_priorities[] {1.0f};
VkDeviceQueueCreateInfo device_queue_create_info {};
device_queue_create_info.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
device_queue_create_info.queueFamilyIndex = _graphics_family_index;
device_queue_create_info.queueCount = 1;
device_queue_create_info.pQueuePriorities = queue_priorities;
VkDeviceCreateInfo device_create_info = {};
device_create_info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
device_create_info.queueCreateInfoCount = 1;
device_create_info.pQueueCreateInfos = &device_queue_create_info;
device_create_info.enabledLayerCount = (uint32_t) _device_layer_list.size();
device_create_info.ppEnabledLayerNames = _device_layer_list.data();
device_create_info.enabledExtensionCount = (uint32_t) _device_extension_list.size();
device_create_info.ppEnabledExtensionNames = _device_extension_list.data();
ErrorCheck(vkCreateDevice(_gpu, &device_create_info, nullptr, &_device));
vkGetDeviceQueue(_device, _graphics_family_index, 0, &_queue);
}
int main(int argc, char** argv) {
g_validationLayers = std::vector<const char*> {
"VK_LAYER_LUNARG_mem_tracker",
"VK_LAYER_GOOGLE_unique_objects",
};
// Init GLFW
{
// Handle GLFW errors
glfwSetErrorCallback([](int error, const char* description) {
std::cout << "GLFW error: " << error << " - " << description << std::endl;
});
// Initialize GLFW
if (!glfwInit())
error("Cannot initialize GLFW.");
// Check Vulkan support
if (!glfwVulkanSupported())
error("Cannot find compatible Vulkan client driver.");
}
// Get Validation layers
{
uint32_t numInstanceLayers = 0;
// Get numInstanceLayers
if (vkEnumerateInstanceLayerProperties(&numInstanceLayers, nullptr))
error("Vulkan: Could not enumerate instance layer properties.");
if (numInstanceLayers > 0) {
std::vector<VkLayerProperties> instanceLayers(numInstanceLayers);
if (vkEnumerateInstanceLayerProperties(&numInstanceLayers, instanceLayers.data()))
error("Vulkan: Could not enumerate instance layer properties.");
// Print layers:
std::cout << "Validation layers: " << std::endl;
for (int i = 0; i < numInstanceLayers; ++i) {
std::cout << "\t" << instanceLayers[i].layerName << std::endl;
std::cout << "\t\t" << instanceLayers[i].description << std::endl;
std::cout << std::endl;
}
std::cout << std::endl;
}
else
std::cout << "No validation layers found!" << std::endl;
// TODO: Check Layers
}
// Check instance extensions
{
int numRequiredExtensions;
const char** requiredExtensions;
// Get required extensions from GLFW
{
requiredExtensions = glfwGetRequiredInstanceExtensions((int*)&numRequiredExtensions);
if (numRequiredExtensions > 0) {
// Write to global g_extensions
for (int i = 0; i < numRequiredExtensions; ++i)
g_extensions.push_back(requiredExtensions[i]);
// Print
std::cout << "Required Instance Extensions(GLFW):" << std::endl;
for (int i = 0; i < numRequiredExtensions; ++i) {
std::cout << "\t" << requiredExtensions[i] << std::endl;
}
std::cout << std::endl;
}
// TODO: Check extensions
}
// Get Instance extensions
{
VkResult err;
uint32_t numInstanceExtensions;
err = vkEnumerateInstanceExtensionProperties(nullptr, &numInstanceExtensions, nullptr);
if (numInstanceExtensions > 0) {
std::vector<VkExtensionProperties> instanceExtensions(numInstanceExtensions);
err = vkEnumerateInstanceExtensionProperties(NULL, &numInstanceExtensions, instanceExtensions.data());
// Print
std::cout << "Instance Extensions: " << std::endl;
for (int i = 0; i < numInstanceExtensions; ++i) {
std::cout << "\t" <<instanceExtensions[i].extensionName << std::endl;
std::cout << "\t\t" << instanceExtensions[i].specVersion << std::endl;
std::cout << std::endl;
}
std::cout << std::endl;
}
// TODO: Check instance extensions(with required instance extensions)
}
}
// Create Vulkan Instance
{
VkApplicationInfo app;
{
app.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
app.pNext = nullptr;
app.pApplicationName = "Vulkan test 1";
app.applicationVersion = 0;
app.pEngineName = "Vulkan test 1";
app.engineVersion = 0;
app.apiVersion = VK_API_VERSION;
}
VkInstanceCreateInfo instanceInfo;
{
instanceInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
instanceInfo.pNext = nullptr;
instanceInfo.pApplicationInfo = &app;
instanceInfo.enabledLayerCount = g_validationLayers.size();
instanceInfo.ppEnabledLayerNames = g_validationLayers.data();
instanceInfo.enabledExtensionCount = g_extensions.size();
instanceInfo.ppEnabledExtensionNames = g_extensions.data();
}
// TODO: Aligned allocators
VkAllocationCallbacks allocator;
{
allocator.pUserData = nullptr;
allocator.pfnAllocation = [](void* pUserData, size_t size, size_t alignment, VkSystemAllocationScope allocationScope)->void* {
return malloc(size);
};
allocator.pfnFree = [](void* pUserData, void* pMemory) {
free(pMemory);
};
allocator.pfnReallocation = [](void* pUserData, void *pOriginal, size_t size, size_t alignment, VkSystemAllocationScope allocationScope) {
free(pOriginal);
return malloc(size);
};
allocator.pfnInternalAllocation = nullptr;
allocator.pfnInternalFree = nullptr;
allocator.pfnReallocation = nullptr;
}
// Create vulkan instance
VkResult vkError = vkCreateInstance(&instanceInfo, &allocator, &g_vkInstance);
// Handle errors
switch (vkError) {
case VK_ERROR_INCOMPATIBLE_DRIVER:
error("Drivers do not support vulkan. Drivers could be outdated.");
break;
case VK_ERROR_EXTENSION_NOT_PRESENT:
error("Cannot find specified extension.");
break;
case VK_SUCCESS:
// Succes! (prevent default from catching success as error)
std::cout << "Vulkan instance created!" << std::endl;
break;
default:
error("Could not create vulkan Instance. Drivers could be outdated.");
break;
}
}
// Look for GPU device
{
uint32_t numGPUs;
VkResult vkError = vkEnumeratePhysicalDevices(g_vkInstance, &numGPUs, nullptr);
if (numGPUs < 0)
error("vkEnumeratePhysicalDevices could not find any GPU devices.");
if (vkError)
error("vkEnumeratePhysicalDevices could not enumerate GPU devices.");
if (numGPUs > 0) {
std::vector<VkPhysicalDevice> physicalDevices(numGPUs);
if (vkEnumeratePhysicalDevices(g_vkInstance, &numGPUs, physicalDevices.data()))
error("vkEnumeratePhysicalDevices could not enumerate GPU devices.");
g_vkGPU = physicalDevices[0];
std::cout << numGPUs << " GPUs found!" << std::endl;
}
}
// Get queue properties
{
uint32_t numQueues;
vkGetPhysicalDeviceProperties(g_vkGPU, &g_vkGPUProperties);
vkGetPhysicalDeviceQueueFamilyProperties(g_vkGPU, &numQueues, nullptr);
if (numQueues == 0)
error("vkGetPhysicalDeviceQueueFamilyProperties could not find any queues.");
g_vkQueueProperties = std::vector<VkQueueFamilyProperties>(numQueues);
vkGetPhysicalDeviceQueueFamilyProperties(g_vkGPU, &numQueues, g_vkQueueProperties.data());
}
// Look for device layers (Unecessary code that does nothing)
{
uint32_t numDeviceLayers;
if (vkEnumerateDeviceLayerProperties(g_vkGPU, &numDeviceLayers, nullptr))
error("vkEnumerateDeviceLayerProperties failed!");
if (numDeviceLayers > 0) {
std::vector<VkLayerProperties> deviceLayers(numDeviceLayers);
if (vkEnumerateDeviceLayerProperties(g_vkGPU, &numDeviceLayers, deviceLayers.data()))
error("vkEnumerateDeviceLayerProperties failed!");
// TODO: Check device layers.
}
}
// Look for device extensions (swapchain extension)
{
uint32_t numDeviceExtensions;
bool extensionSwapChainFound = false;
if (vkEnumerateDeviceExtensionProperties(g_vkGPU, nullptr, &numDeviceExtensions, nullptr))
error("vkEnumerateDeviceExtensionProperties failed!");
if (numDeviceExtensions > 0) {
std::vector<VkExtensionProperties> deviceExtensions(numDeviceExtensions);
if (vkEnumerateDeviceExtensionProperties(g_vkGPU, nullptr, &numDeviceExtensions, deviceExtensions.data()))
error("vkEnumerateDeviceExtensionProperties failed!");
// Search for swapchain extension
for (VkExtensionProperties extension : deviceExtensions) {
if (!strcmp(extension.extensionName, VK_KHR_SWAPCHAIN_EXTENSION_NAME))
extensionSwapChainFound = true;
}
// Print
std::cout << std::endl << "Extensions:" << std::endl;
for (VkExtensionProperties extension : deviceExtensions) {
std::cout << extension.extensionName << "(" << extension.specVersion << ")" << std::endl;
}
std::cout << std::endl;
}
if (!extensionSwapChainFound)
error("Failed to find the " VK_KHR_SWAPCHAIN_EXTENSION_NAME " extension!");
}
// TODO: Validate
// Get instance function adresses
{
GET_INSTANCE_PROC_ADDR(g_vkInstance, GetPhysicalDeviceSurfaceCapabilitiesKHR);
GET_INSTANCE_PROC_ADDR(g_vkInstance, GetPhysicalDeviceSurfaceFormatsKHR);
GET_INSTANCE_PROC_ADDR(g_vkInstance, GetPhysicalDeviceSurfacePresentModesKHR);
GET_INSTANCE_PROC_ADDR(g_vkInstance, GetPhysicalDeviceSurfaceSupportKHR);
GET_INSTANCE_PROC_ADDR(g_vkInstance, CreateSwapchainKHR);
GET_INSTANCE_PROC_ADDR(g_vkInstance, DestroySwapchainKHR);
GET_INSTANCE_PROC_ADDR(g_vkInstance, GetSwapchainImagesKHR);
GET_INSTANCE_PROC_ADDR(g_vkInstance, AcquireNextImageKHR);
GET_INSTANCE_PROC_ADDR(g_vkInstance, QueuePresentKHR);
}
// Create window
{
glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
g_window = glfwCreateWindow(g_width, g_height, "Vulkan test", NULL, NULL);
if (!g_window)
error("Could not create window!");
glfwSetWindowRefreshCallback(g_window, [](GLFWwindow* window) {
// TODO: draw();
});
glfwSetFramebufferSizeCallback(g_window, [](GLFWwindow* window, int width, int height) {
g_width = width;
g_height = height;
// TODO: resize();
});
}
// Init swapchain
{
glfwCreateWindowSurface(g_vkInstance, g_window, nullptr, &g_vkSurface);
std::vector<VkBool32> supportsPresent(g_vkQueueProperties.size());
for (uint32_t i = 0; i < g_vkQueueProperties.size(); ++i)
g_vkFPGetPhysicalDeviceSurfaceSupportKHR(g_vkGPU, i, g_vkSurface, &supportsPresent[i]);
uint32_t graphicsQueueNodeIndex = UINT32_MAX;
uint32_t presentQueueNodeIndex = UINT32_MAX;
for (uint32_t i = 0; i < g_vkQueueProperties.size(); ++i) {
if (graphicsQueueNodeIndex == UINT32_MAX) {
graphicsQueueNodeIndex = i;
}
if (supportsPresent[i] == VK_TRUE) {
graphicsQueueNodeIndex = i;
presentQueueNodeIndex = i;
break;
}
}
//if (presentQueueNodeIndex == UINT32_MAX) {
// for (uint32_t i = 0; i < g_vkQueueProperties.size(); ++i) {
// if (supportsPresent[i] == VK_TRUE) {
// presentQueueNodeIndex = i;
// }
// }
//}
if (graphicsQueueNodeIndex == UINT32_MAX || presentQueueNodeIndex == UINT32_MAX)
error("Could not find a graphics and a present queue.");
if (graphicsQueueNodeIndex != presentQueueNodeIndex)
error("Could not find a common graphics and present queue.");
g_vkGraphicsQueueNodeIndex = graphicsQueueNodeIndex;
//TODO: init device
{
float queuePriotities = 0.f;
VkDeviceQueueCreateInfo queue;
{
queue.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
queue.pNext = NULL;
queue.queueFamilyIndex = g_vkGraphicsQueueNodeIndex;
queue.queueCount = 1;
queue.pQueuePriorities = &queuePriotities;
}
}
//vkGetDeviceQueue(g_vkDevice, g_vkGraphicsQueueNodeIndex, 0, g_vkQueue);
}
std::cin.get();
return 0;
}
Context::Context()
{
if(!loadVulkanLibrary())
{
CV_Error(Error::StsError, "loadVulkanLibrary failed");
return;
}
else if (!loadVulkanEntry())
{
CV_Error(Error::StsError, "loadVulkanEntry failed");
return;
}
else if (!loadVulkanGlobalFunctions())
{
CV_Error(Error::StsError, "loadVulkanGlobalFunctions failed");
return;
}
// create VkInstance, VkPhysicalDevice
std::vector<const char *> enabledExtensions;
if (enableValidationLayers)
{
uint32_t layerCount;
vkEnumerateInstanceLayerProperties(&layerCount, NULL);
std::vector<VkLayerProperties> layerProperties(layerCount);
vkEnumerateInstanceLayerProperties(&layerCount, layerProperties.data());
bool foundLayer = false;
for (VkLayerProperties prop : layerProperties)
{
if (strcmp("VK_LAYER_LUNARG_standard_validation", prop.layerName) == 0)
{
foundLayer = true;
break;
}
}
if (!foundLayer)
{
throw std::runtime_error("Layer VK_LAYER_LUNARG_standard_validation not supported\n");
}
kEnabledLayers.push_back("VK_LAYER_LUNARG_standard_validation");
uint32_t extensionCount;
vkEnumerateInstanceExtensionProperties(nullptr, &extensionCount, NULL);
std::vector<VkExtensionProperties> extensionProperties(extensionCount);
vkEnumerateInstanceExtensionProperties(nullptr, &extensionCount, extensionProperties.data());
bool foundExtension = false;
for (VkExtensionProperties prop : extensionProperties)
{
if (strcmp(VK_EXT_DEBUG_REPORT_EXTENSION_NAME, prop.extensionName) == 0)
{
foundExtension = true;
break;
}
}
if (!foundExtension) {
throw std::runtime_error("Extension VK_EXT_DEBUG_REPORT_EXTENSION_NAME not supported\n");
}
enabledExtensions.push_back(VK_EXT_DEBUG_REPORT_EXTENSION_NAME);
}
VkApplicationInfo applicationInfo = {};
applicationInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
applicationInfo.pApplicationName = "VkCom Library";
applicationInfo.applicationVersion = 0;
applicationInfo.pEngineName = "vkcom";
applicationInfo.engineVersion = 0;
applicationInfo.apiVersion = VK_API_VERSION_1_0;;
VkInstanceCreateInfo createInfo = {};
createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
createInfo.flags = 0;
createInfo.pApplicationInfo = &applicationInfo;
// Give our desired layers and extensions to vulkan.
createInfo.enabledLayerCount = kEnabledLayers.size();
createInfo.ppEnabledLayerNames = kEnabledLayers.data();
createInfo.enabledExtensionCount = enabledExtensions.size();
createInfo.ppEnabledExtensionNames = enabledExtensions.data();
VK_CHECK_RESULT(vkCreateInstance(&createInfo, NULL, &kInstance));
if (!loadVulkanFunctions(kInstance))
{
CV_Error(Error::StsError, "loadVulkanFunctions failed");
return;
}
if (enableValidationLayers && vkCreateDebugReportCallbackEXT)
{
VkDebugReportCallbackCreateInfoEXT createInfo = {};
createInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT;
createInfo.flags = VK_DEBUG_REPORT_ERROR_BIT_EXT |
VK_DEBUG_REPORT_WARNING_BIT_EXT |
VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT;
createInfo.pfnCallback = &debugReportCallbackFn;
// Create and register callback.
VK_CHECK_RESULT(vkCreateDebugReportCallbackEXT(kInstance, &createInfo,
NULL, &kDebugReportCallback));
}
// find physical device
uint32_t deviceCount;
vkEnumeratePhysicalDevices(kInstance, &deviceCount, NULL);
if (deviceCount == 0)
{
throw std::runtime_error("could not find a device with vulkan support");
}
std::vector<VkPhysicalDevice> devices(deviceCount);
vkEnumeratePhysicalDevices(kInstance, &deviceCount, devices.data());
for (VkPhysicalDevice device : devices)
{
if (true)
{
kPhysicalDevice = device;
break;
}
}
kQueueFamilyIndex = getComputeQueueFamilyIndex();
// create device, queue, command pool
VkDeviceQueueCreateInfo queueCreateInfo = {};
queueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
queueCreateInfo.queueFamilyIndex = kQueueFamilyIndex;
queueCreateInfo.queueCount = 1; // create one queue in this family. We don't need more.
float queuePriorities = 1.0; // we only have one queue, so this is not that imporant.
queueCreateInfo.pQueuePriorities = &queuePriorities;
VkDeviceCreateInfo deviceCreateInfo = {};
// Specify any desired device features here. We do not need any for this application, though.
VkPhysicalDeviceFeatures deviceFeatures = {};
deviceCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
deviceCreateInfo.enabledLayerCount = kEnabledLayers.size();
deviceCreateInfo.ppEnabledLayerNames = kEnabledLayers.data();
deviceCreateInfo.pQueueCreateInfos = &queueCreateInfo;
deviceCreateInfo.queueCreateInfoCount = 1;
deviceCreateInfo.pEnabledFeatures = &deviceFeatures;
VK_CHECK_RESULT(vkCreateDevice(kPhysicalDevice, &deviceCreateInfo, NULL, &kDevice));
// Get a handle to the only member of the queue family.
vkGetDeviceQueue(kDevice, kQueueFamilyIndex, 0, &kQueue);
// create command pool
VkCommandPoolCreateInfo commandPoolCreateInfo = {};
commandPoolCreateInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
commandPoolCreateInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
// the queue family of this command pool. All command buffers allocated from this command pool,
// must be submitted to queues of this family ONLY.
commandPoolCreateInfo.queueFamilyIndex = kQueueFamilyIndex;
VK_CHECK_RESULT(vkCreateCommandPool(kDevice, &commandPoolCreateInfo, NULL, &kCmdPool));
}
gboolean
gst_vulkan_instance_open (GstVulkanInstance * instance, GError ** error)
{
VkExtensionProperties *instance_extensions;
char *extension_names[64]; /* FIXME: make dynamic */
VkLayerProperties *instance_layers;
uint32_t instance_extension_count = 0;
uint32_t enabled_extension_count = 0;
uint32_t instance_layer_count = 0;
uint32_t enabled_layer_count = 0;
gchar **enabled_layers;
VkResult err;
GST_OBJECT_LOCK (instance);
if (instance->priv->opened) {
GST_OBJECT_UNLOCK (instance);
return TRUE;
}
/* Look for validation layers */
err = vkEnumerateInstanceLayerProperties (&instance_layer_count, NULL);
if (gst_vulkan_error_to_g_error (err, error,
"vKEnumerateInstanceLayerProperties") < 0)
goto error;
instance_layers = g_new0 (VkLayerProperties, instance_layer_count);
err =
vkEnumerateInstanceLayerProperties (&instance_layer_count,
instance_layers);
if (gst_vulkan_error_to_g_error (err, error,
"vKEnumerateInstanceLayerProperties") < 0) {
g_free (instance_layers);
goto error;
}
/* TODO: allow outside selection */
_check_for_all_layers (G_N_ELEMENTS (instance_validation_layers),
instance_validation_layers, instance_layer_count, instance_layers,
&enabled_layer_count, &enabled_layers);
g_free (instance_layers);
err =
vkEnumerateInstanceExtensionProperties (NULL, &instance_extension_count,
NULL);
if (gst_vulkan_error_to_g_error (err, error,
"vkEnumerateInstanceExtensionProperties") < 0) {
g_strfreev (enabled_layers);
goto error;
}
GST_DEBUG_OBJECT (instance, "Found %u extensions", instance_extension_count);
memset (extension_names, 0, sizeof (extension_names));
instance_extensions =
g_new0 (VkExtensionProperties, instance_extension_count);
err =
vkEnumerateInstanceExtensionProperties (NULL, &instance_extension_count,
instance_extensions);
if (gst_vulkan_error_to_g_error (err, error,
"vkEnumerateInstanceExtensionProperties") < 0) {
g_strfreev (enabled_layers);
g_free (instance_extensions);
goto error;
}
{
GstVulkanDisplayType display_type;
gboolean swapchain_ext_found = FALSE;
gboolean winsys_ext_found = FALSE;
const gchar *winsys_ext_name;
display_type = gst_vulkan_display_choose_type (instance);
winsys_ext_name =
gst_vulkan_display_type_to_extension_string (display_type);
if (!winsys_ext_name) {
GST_WARNING_OBJECT (instance, "No window system extension enabled");
winsys_ext_found = TRUE; /* Don't error out completely */
}
/* TODO: allow outside selection */
for (uint32_t i = 0; i < instance_extension_count; i++) {
GST_TRACE_OBJECT (instance, "checking instance extension %s",
instance_extensions[i].extensionName);
if (!g_strcmp0 (VK_KHR_SURFACE_EXTENSION_NAME,
instance_extensions[i].extensionName)) {
swapchain_ext_found = TRUE;
extension_names[enabled_extension_count++] =
(gchar *) VK_KHR_SURFACE_EXTENSION_NAME;
}
if (!g_strcmp0 (VK_EXT_DEBUG_REPORT_EXTENSION_NAME,
instance_extensions[i].extensionName)) {
extension_names[enabled_extension_count++] =
(gchar *) VK_EXT_DEBUG_REPORT_EXTENSION_NAME;
}
if (!g_strcmp0 (winsys_ext_name, instance_extensions[i].extensionName)) {
winsys_ext_found = TRUE;
extension_names[enabled_extension_count++] = (gchar *) winsys_ext_name;
}
g_assert (enabled_extension_count < 64);
}
if (!swapchain_ext_found) {
g_set_error (error, GST_VULKAN_ERROR, VK_ERROR_INITIALIZATION_FAILED,
"vkEnumerateInstanceExtensionProperties failed to find the required "
"\"" VK_KHR_SURFACE_EXTENSION_NAME "\" extension");
g_strfreev (enabled_layers);
g_free (instance_extensions);
goto error;
}
if (!winsys_ext_found) {
g_set_error (error, GST_VULKAN_ERROR, VK_ERROR_INITIALIZATION_FAILED,
"vkEnumerateInstanceExtensionProperties failed to find the required "
"\"%s\" window system extension", winsys_ext_name);
g_strfreev (enabled_layers);
g_free (instance_extensions);
goto error;
}
}
{
VkApplicationInfo app = { 0, };
VkInstanceCreateInfo inst_info = { 0, };
app.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
app.pNext = NULL;
app.pApplicationName = APP_SHORT_NAME;
app.applicationVersion = 0;
app.pEngineName = APP_SHORT_NAME;
app.engineVersion = 0;
app.apiVersion = VK_API_VERSION_1_0;
inst_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
inst_info.pNext = NULL;
inst_info.pApplicationInfo = &app;
#if 0
inst_info.enabledLayerCount = enabled_layer_count;
inst_info.ppEnabledLayerNames = (const char *const *) enabled_layers;
#else
inst_info.enabledLayerCount = 0;
inst_info.ppEnabledLayerNames = NULL;
#endif
inst_info.enabledExtensionCount = enabled_extension_count;
inst_info.ppEnabledExtensionNames = (const char *const *) extension_names;
err = vkCreateInstance (&inst_info, NULL, &instance->instance);
if (gst_vulkan_error_to_g_error (err, error, "vkCreateInstance") < 0) {
g_strfreev (enabled_layers);
g_free (instance_extensions);
goto error;
}
}
g_free (instance_extensions);
g_strfreev (enabled_layers);
err =
vkEnumeratePhysicalDevices (instance->instance,
&instance->n_physical_devices, NULL);
if (gst_vulkan_error_to_g_error (err, error,
"vkEnumeratePhysicalDevices") < 0)
goto error;
g_assert (instance->n_physical_devices > 0);
instance->physical_devices =
g_new0 (VkPhysicalDevice, instance->n_physical_devices);
err =
vkEnumeratePhysicalDevices (instance->instance,
&instance->n_physical_devices, instance->physical_devices);
if (gst_vulkan_error_to_g_error (err, error,
"vkEnumeratePhysicalDevices") < 0)
goto error;
instance->dbgCreateDebugReportCallback = (PFN_vkCreateDebugReportCallbackEXT)
gst_vulkan_instance_get_proc_address (instance,
"vkCreateDebugReportCallbackEXT");
if (!instance->dbgCreateDebugReportCallback) {
g_set_error (error, GST_VULKAN_ERROR, VK_ERROR_INITIALIZATION_FAILED,
"Failed to retreive vkCreateDebugReportCallback");
goto error;
}
instance->dbgDestroyDebugReportCallback =
(PFN_vkDestroyDebugReportCallbackEXT)
gst_vulkan_instance_get_proc_address (instance,
"vkDestroyDebugReportCallbackEXT");
if (!instance->dbgDestroyDebugReportCallback) {
g_set_error (error, GST_VULKAN_ERROR, VK_ERROR_INITIALIZATION_FAILED,
"Failed to retreive vkDestroyDebugReportCallback");
goto error;
}
instance->dbgReportMessage = (PFN_vkDebugReportMessageEXT)
gst_vulkan_instance_get_proc_address (instance,
"vkDebugReportMessageEXT");
if (!instance->dbgReportMessage) {
g_set_error (error, GST_VULKAN_ERROR, VK_ERROR_INITIALIZATION_FAILED,
"Failed to retreive vkDebugReportMessage");
goto error;
}
{
VkDebugReportCallbackCreateInfoEXT info = { 0, };
info.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT;
info.pNext = NULL;
info.flags =
VK_DEBUG_REPORT_ERROR_BIT_EXT | VK_DEBUG_REPORT_WARNING_BIT_EXT |
VK_DEBUG_REPORT_INFORMATION_BIT_EXT | VK_DEBUG_REPORT_DEBUG_BIT_EXT |
VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT;
info.pfnCallback = (PFN_vkDebugReportCallbackEXT) _gst_vk_debug_callback;
info.pUserData = NULL;
err =
instance->dbgCreateDebugReportCallback (instance->instance, &info, NULL,
&instance->msg_callback);
if (gst_vulkan_error_to_g_error (err, error,
"vkCreateDebugReportCallback") < 0)
goto error;
}
instance->priv->opened = TRUE;
GST_OBJECT_UNLOCK (instance);
return TRUE;
error:
{
GST_OBJECT_UNLOCK (instance);
return FALSE;
}
}
void VulkanExampleBase::initVulkan(bool enableValidation)
{
VkResult err;
// Vulkan instance
err = createInstance(enableValidation);
if (err)
{
vkTools::exitFatal("Could not create Vulkan instance : \n" + vkTools::errorString(err), "Fatal error");
}
#if defined(__ANDROID__)
loadVulkanFunctions(instance);
#endif
// Physical device
uint32_t gpuCount = 0;
// Get number of available physical devices
err = vkEnumeratePhysicalDevices(instance, &gpuCount, nullptr);
assert(!err);
assert(gpuCount > 0);
// Enumerate devices
std::vector<VkPhysicalDevice> physicalDevices(gpuCount);
err = vkEnumeratePhysicalDevices(instance, &gpuCount, physicalDevices.data());
if (err)
{
vkTools::exitFatal("Could not enumerate phyiscal devices : \n" + vkTools::errorString(err), "Fatal error");
}
// Note :
// This example will always use the first physical device reported,
// change the vector index if you have multiple Vulkan devices installed
// and want to use another one
physicalDevice = physicalDevices[0];
// Find a queue that supports graphics operations
uint32_t graphicsQueueIndex = 0;
uint32_t queueCount;
vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queueCount, NULL);
assert(queueCount >= 1);
std::vector<VkQueueFamilyProperties> queueProps;
queueProps.resize(queueCount);
vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queueCount, queueProps.data());
for (graphicsQueueIndex = 0; graphicsQueueIndex < queueCount; graphicsQueueIndex++)
{
if (queueProps[graphicsQueueIndex].queueFlags & VK_QUEUE_GRAPHICS_BIT)
break;
}
assert(graphicsQueueIndex < queueCount);
// Vulkan device
std::array<float, 1> queuePriorities = { 0.0f };
VkDeviceQueueCreateInfo queueCreateInfo = {};
queueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
queueCreateInfo.queueFamilyIndex = graphicsQueueIndex;
queueCreateInfo.queueCount = 1;
queueCreateInfo.pQueuePriorities = queuePriorities.data();
err = createDevice(queueCreateInfo, enableValidation);
assert(!err);
// Store properties (including limits) and features of the phyiscal device
// So examples can check against them and see if a feature is actually supported
vkGetPhysicalDeviceProperties(physicalDevice, &deviceProperties);
vkGetPhysicalDeviceFeatures(physicalDevice, &deviceFeatures);
#if defined(__ANDROID__)
LOGD(deviceProperties.deviceName);
#endif
// Gather physical device memory properties
vkGetPhysicalDeviceMemoryProperties(physicalDevice, &deviceMemoryProperties);
// Get the graphics queue
vkGetDeviceQueue(device, graphicsQueueIndex, 0, &queue);
// Find a suitable depth format
VkBool32 validDepthFormat = vkTools::getSupportedDepthFormat(physicalDevice, &depthFormat);
assert(validDepthFormat);
swapChain.connect(instance, physicalDevice, device);
// Create synchronization objects
VkSemaphoreCreateInfo semaphoreCreateInfo = vkTools::initializers::semaphoreCreateInfo();
// Create a semaphore used to synchronize image presentation
// Ensures that the image is displayed before we start submitting new commands to the queu
err = vkCreateSemaphore(device, &semaphoreCreateInfo, nullptr, &semaphores.presentComplete);
assert(!err);
// Create a semaphore used to synchronize command submission
// Ensures that the image is not presented until all commands have been sumbitted and executed
err = vkCreateSemaphore(device, &semaphoreCreateInfo, nullptr, &semaphores.renderComplete);
assert(!err);
// Set up submit info structure
// Semaphores will stay the same during application lifetime
// Command buffer submission info is set by each example
submitInfo = vkTools::initializers::submitInfo();
submitInfo.pWaitDstStageMask = &submitPipelineStages;
submitInfo.waitSemaphoreCount = 1;
submitInfo.pWaitSemaphores = &semaphores.presentComplete;
submitInfo.signalSemaphoreCount = 1;
submitInfo.pSignalSemaphores = &semaphores.renderComplete;
}
int main(){
printf("This code initializes a Vulkan device");
/**
Steps required
1. Create Vulkan Instance
2. Enumerate the GPUs
3. Query Queues on the GPU (Queues represent on what 'channels' will the data process, query the queue
for COMPUTE type queue or GRAPHICS type queue
4. Create a queue priority
5. Create a device with information from 2, 3 and 4
**/
/** 1. Create Vulkan Instance **/
VkApplicationInfo appInfo = {};
appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
appInfo.pNext = NULL;
appInfo.pApplicationName = APP_SHORT_NAME;
appInfo.applicationVersion = 1;
appInfo.pEngineName = APP_SHORT_NAME;
appInfo.engineVersion = 1;
appInfo.apiVersion = VK_API_VERSION;
VkInstanceCreateInfo icInfo = {};
icInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
icInfo.pNext = NULL;
icInfo.flags = 0;
icInfo.pApplicationInfo = & appInfo;
icInfo.enabledExtensionCount = 0;
icInfo.ppEnabledExtensionNames = NULL;
icInfo.enabledLayerCount = 0;
icInfo.enabledLayerCount = NULL;
VkInstance instance;
VkResult res;
res = vkCreateInstance(&icInfo, NULL, &instance);
if(res == VK_ERROR_INCOMPATIBLE_DRIVER){
printf("Cannot find a Vulkan Compatible ICD\n");
exit(-1);
} else if(res){
printf("Some error occured\n");
exit(-1);
}
printf("Yay! Vulkan is initialized\n");
/** 2. Enumerate the GPUs **/
uint32_t gpuCount = 0;
res = vkEnumeratePhysicalDevices(instance, &gpuCount, NULL);
printf("found %d gpus\n", gpuCount);
VkPhysicalDevice* gpus = new VkPhysicalDevice[gpuCount];
printf("Listing gpus...\n", gpuCount);
res = vkEnumeratePhysicalDevices(instance, &gpuCount, gpus);
while(++idx < gpuCount){
VkPhysicalDeviceProperties props= {};
vkGetPhysicalDeviceProperties(gpus[idx], &props);
printf("%d-%d-%d-%d-%s\n", props.apiVersion, props.driverVersion, props.vendorID, props.deviceID, props.deviceName);
}
/** 3. Query for the supported queues **/
/** From renderdocs vulkan
Command buffers are submitted to a VkQueue.
The notion of queues are how work becomes serialised to be passed to the GPU.
A VkPhysicalDevice (remember way back? The GPU handle) can report a number of queue families with different capabilities.
e.g. a graphics queue family and a compute-only queue family.
When you create your device you ask for a certain number of queues from each family, and then you can enumerate them
from the device after creation with vkGetDeviceQueue().
**/
uint32_t queue_count = 0;
vkGetPhysicalDeviceQueueFamilyProperties(gpus[0], &queue_count, NULL);
if(queue_count <= 0){
printf("No Queues found.. aborting\n");
exit(-1);
}
VkQueueFamilyProperties* queue_props = new VkQueueFamilyProperties[queue_count];
vkGetPhysicalDeviceQueueFamilyProperties(gpus[0], &queue_count, queue_props);
float queue_priorities[1] = {0.0}; /** 4. Create a queue priority **/
VkDeviceQueueCreateInfo qi = {};
qi.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
qi.pNext = NULL;
qi.queueCount = 1;
qi.pQueuePriorities = queue_priorities;
idx = -1;
while(++idx < queue_count){
if(queue_props[idx].queueFlags & VK_QUEUE_GRAPHICS_BIT){ //Look for a queue that has Graphics capabilities
qi.queueFamilyIndex = idx;
break;
}
}
/** 5. Create a device with information from 2, 3 and 4 **/
VkDeviceCreateInfo dci = {};
dci.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
dci.pNext = NULL;
dci.queueCreateInfoCount = 1;
dci.pQueueCreateInfos = &qi;
dci.enabledExtensionCount = 0;
dci.ppEnabledExtensionNames = NULL;
dci.enabledLayerCount = 0;
dci.ppEnabledLayerNames = NULL;
dci.pEnabledFeatures = NULL;
VkDevice device;
res = vkCreateDevice(gpus[0], &dci, NULL, &device);
if(res){
printf("There was a problem creating the device");
exit(-1);
}
/** All's great, first thing lets create a command buffer **/
VkCommandPoolCreateInfo cpci = {};
cpci.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
cpci.pNext = NULL;
cpci.queueFamilyIndex = qi.queueFamilyIndex;
cpci.flags = 0;
VkCommandPool cp;
res = vkCreateCommandPool(device, &cpci, NULL, &cp);
if(res){
printf("There was a problem creating a command pool");
exit(-1);
}
/** Create a command buffer from the command pool **/
VkCommandBufferAllocateInfo cbai = {};
cbai.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
cbai.pNext = NULL;
cbai.commandPool = cp;
cbai.commandBufferCount = 1;
cbai.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
VkCommandBuffer* commandBuffer = new VkCommandBuffer[1]; //single command
res = vkAllocateCommandBuffers(device, &cbai, commandBuffer);
if(res){
printf("There was a problem creating a command buffer");
exit(-1);
}
/** no, we never leave the crap behind **/
vkFreeCommandBuffers(device, cp, 1, commandBuffer);
vkDestroyCommandPool(device, cp, NULL);
vkDestroyDevice(device, NULL);
printf("Device created");
vkDestroyInstance(instance, NULL);
delete[] gpus;
return 0;
}
