static void cleanup_vulkan()
{
vkDestroyDescriptorPool(g_Device, g_DescriptorPool, g_Allocator);
for (int i = 0; i < IMGUI_VK_QUEUED_FRAMES; i++)
{
vkDestroyFence(g_Device, g_Fence[i], g_Allocator);
vkFreeCommandBuffers(g_Device, g_CommandPool[i], 1, &g_CommandBuffer[i]);
vkDestroyCommandPool(g_Device, g_CommandPool[i], g_Allocator);
vkDestroySemaphore(g_Device, g_PresentCompleteSemaphore[i], g_Allocator);
vkDestroySemaphore(g_Device, g_RenderCompleteSemaphore[i], g_Allocator);
}
for (uint32_t i = 0; i < g_BackBufferCount; i++)
{
vkDestroyImageView(g_Device, g_BackBufferView[i], g_Allocator);
vkDestroyFramebuffer(g_Device, g_Framebuffer[i], g_Allocator);
}
vkDestroyRenderPass(g_Device, g_RenderPass, g_Allocator);
vkDestroySwapchainKHR(g_Device, g_Swapchain, g_Allocator);
vkDestroySurfaceKHR(g_Instance, g_Surface, g_Allocator);
#ifdef IMGUI_VULKAN_DEBUG_REPORT
// get the proc address of the function pointer, required for used extensions
auto vkDestroyDebugReportCallbackEXT = (PFN_vkDestroyDebugReportCallbackEXT)vkGetInstanceProcAddr(g_Instance, "vkDestroyDebugReportCallbackEXT");
vkDestroyDebugReportCallbackEXT(g_Instance, g_Debug_Report, g_Allocator);
#endif // IMGUI_VULKAN_DEBUG_REPORT
vkDestroyDevice(g_Device, g_Allocator);
vkDestroyInstance(g_Instance, g_Allocator);
}
VKAppInstance::~VKAppInstance()
{
if(m_instance != VK_NULL_HANDLE)
{
vkDestroyInstance(m_instance, nullptr);
}
}
VulkanCommon::~VulkanCommon() {
if( Vulkan.Device != VK_NULL_HANDLE ) {
vkDeviceWaitIdle( Vulkan.Device );
for( size_t i = 0; i < Vulkan.SwapChain.Images.size(); ++i ) {
if( Vulkan.SwapChain.Images[i].ImageView != VK_NULL_HANDLE ) {
vkDestroyImageView( GetDevice(), Vulkan.SwapChain.Images[i].ImageView, nullptr );
}
}
if( Vulkan.SwapChain.Handle != VK_NULL_HANDLE ) {
vkDestroySwapchainKHR( Vulkan.Device, Vulkan.SwapChain.Handle, nullptr );
}
vkDestroyDevice( Vulkan.Device, nullptr );
}
if( Vulkan.PresentationSurface != VK_NULL_HANDLE ) {
vkDestroySurfaceKHR( Vulkan.Instance, Vulkan.PresentationSurface, nullptr );
}
if( Vulkan.Instance != VK_NULL_HANDLE ) {
vkDestroyInstance( Vulkan.Instance, nullptr );
}
if( VulkanLibrary ) {
#if defined(VK_USE_PLATFORM_WIN32_KHR)
FreeLibrary( VulkanLibrary );
#elif defined(VK_USE_PLATFORM_XCB_KHR) || defined(VK_USE_PLATFORM_XLIB_KHR)
dlclose( VulkanLibrary );
#endif
}
}
void RHIRoot::Destroy()
{
#if _DEBUG
FreeDebugCallback(Instance);
#endif
vkDestroyInstance(Instance, nullptr);
VKLOG(Info, "RHIRoot: Destroy Instance.");
}
PluginRenderVulkan::~PluginRenderVulkan()
{
log().log() << "PluginRenderVulkan stop...\n";
if (m_instanceIsValid)
{
vkDestroyInstance(m_instance, nullptr);
}
}
Wasabi::~Wasabi() {
if (WindowComponent)
WindowComponent->Cleanup();
W_SAFE_DELETE(SoundComponent);
W_SAFE_DELETE(WindowComponent);
vkDestroyInstance(vkInstance, nullptr);
}
void Win32CleanShutdown(HWND window) {
g_Running = false;
vkDestroySurfaceKHR(VKInstance, surface, NULL);
vkDestroyInstance(VKInstance, NULL);
vkDestroyDevice(device_handle, NULL);
ReleaseDC(window, g_WindowDC);
PostQuitMessage(0);
}
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);
}
VulkanExampleBase::~VulkanExampleBase()
{
// Clean up Vulkan resources
swapChain.cleanup();
if (descriptorPool != VK_NULL_HANDLE)
{
vkDestroyDescriptorPool(device, descriptorPool, nullptr);
}
if (setupCmdBuffer != VK_NULL_HANDLE)
{
vkFreeCommandBuffers(device, cmdPool, 1, &setupCmdBuffer);
}
destroyCommandBuffers();
vkDestroyRenderPass(device, renderPass, nullptr);
for (uint32_t i = 0; i < frameBuffers.size(); i++)
{
vkDestroyFramebuffer(device, frameBuffers[i], nullptr);
}
for (auto& shaderModule : shaderModules)
{
vkDestroyShaderModule(device, shaderModule, nullptr);
}
vkDestroyImageView(device, depthStencil.view, nullptr);
vkDestroyImage(device, depthStencil.image, nullptr);
vkFreeMemory(device, depthStencil.mem, nullptr);
vkDestroyPipelineCache(device, pipelineCache, nullptr);
if (textureLoader)
{
delete textureLoader;
}
vkDestroyCommandPool(device, cmdPool, nullptr);
vkDestroySemaphore(device, semaphores.presentComplete, nullptr);
vkDestroySemaphore(device, semaphores.renderComplete, nullptr);
vkDestroyDevice(device, nullptr);
if (enableValidation)
{
vkDebug::freeDebugCallback(instance);
}
vkDestroyInstance(instance, nullptr);
#if defined(__linux)
#if defined(__ANDROID__)
// todo : android cleanup (if required)
#else
xcb_destroy_window(connection, window);
xcb_disconnect(connection);
#endif
#endif
}
void Instance::destroy()
{
if (instance)
{
vkDestroyInstance(instance, nullptr);
instance = VK_NULL_HANDLE;
}
}
void Environment::TearDown() {
// destroy devices first
for (std::vector<Device *>::iterator it = devs_.begin(); it != devs_.end(); it++)
delete *it;
devs_.clear();
if (inst)
vkDestroyInstance(inst, NULL);
}
VulkanContext::~VulkanContext()
{
if (m_device != VK_NULL_HANDLE)
vkDestroyDevice(m_device, nullptr);
if (m_debug_report_callback != VK_NULL_HANDLE)
DisableDebugReports();
vkDestroyInstance(m_instance, nullptr);
}
// Used by run_loader_tests.sh to test for layer insertion.
TEST(CreateInstance, LayerPresent)
{
char const*const names[] = {"VK_LAYER_LUNARG_parameter_validation"}; // Temporary required due to MSVC bug.
auto const info = VK::InstanceCreateInfo().
enabledLayerCount(1).
ppEnabledLayerNames(names);
VkInstance instance = VK_NULL_HANDLE;
VkResult result = vkCreateInstance(info, VK_NULL_HANDLE, &instance);
ASSERT_EQ(result, VK_SUCCESS);
vkDestroyInstance(instance, nullptr);
}
void VkContext::Destroy() {
vkDeviceWaitIdle(dev);
// Free command buffers
if (drawCmdBuffers.size() > 0) {
vkFreeCommandBuffers(dev, cmdPool, (u32)drawCmdBuffers.size(),
&drawCmdBuffers[0]);
}
// Destroy command pools
vkDestroyCommandPool(dev, cmdPool, nullptr);
// Destroy semaphores
vkDestroySemaphore(dev, acquireCompleteSemaphore, nullptr);
vkDestroySemaphore(dev, renderCompleteSemaphore, nullptr);
// Destroy swapchain image views
for (u32 i = 0; i < swapchainImageViews.size(); i++) {
vkDestroyImageView(dev, swapchainImageViews[i], nullptr);
}
// Destroy swapchain
if (swapchain) {
vkDestroySwapchainKHR(dev, swapchain, nullptr);
}
// Destroy surface
if (surf) {
vkDestroySurfaceKHR(instance, surf, nullptr);
}
// Destroy device
if (dev) {
vkDestroyDevice(dev, nullptr);
}
#ifdef VOXL_DEBUG
// Destroy debug report callback
if (msgCallback != VK_NULL_HANDLE) {
vkDestroyDebugReportCallbackEXT(instance, msgCallback, nullptr);
}
#endif
// Destroy instance
if (instance) {
vkDestroyInstance(instance, nullptr);
}
// Terminate GLFW
glfwTerminate();
}
static void CleanupVulkan()
{
ImGui_ImplVulkanH_WindowData* wd = &g_WindowData;
ImGui_ImplVulkanH_DestroyWindowData(g_Instance, g_Device, wd, g_Allocator);
vkDestroyDescriptorPool(g_Device, g_DescriptorPool, g_Allocator);
#ifdef IMGUI_VULKAN_DEBUG_REPORT
// Remove the debug report callback
auto vkDestroyDebugReportCallbackEXT = (PFN_vkDestroyDebugReportCallbackEXT)vkGetInstanceProcAddr(g_Instance, "vkDestroyDebugReportCallbackEXT");
vkDestroyDebugReportCallbackEXT(g_Instance, g_DebugReport, g_Allocator);
#endif // IMGUI_VULKAN_DEBUG_REPORT
vkDestroyDevice(g_Device, g_Allocator);
vkDestroyInstance(g_Instance, g_Allocator);
}
void VideoBackend::InitBackendInfo()
{
VulkanContext::PopulateBackendInfo(&g_Config);
if (LoadVulkanLibrary())
{
VkInstance temp_instance = VulkanContext::CreateVulkanInstance(false, false, false);
if (temp_instance)
{
if (LoadVulkanInstanceFunctions(temp_instance))
{
VulkanContext::GPUList gpu_list = VulkanContext::EnumerateGPUs(temp_instance);
VulkanContext::PopulateBackendInfoAdapters(&g_Config, gpu_list);
if (!gpu_list.empty())
{
// Use the selected adapter, or the first to fill features.
size_t device_index = static_cast<size_t>(g_Config.iAdapter);
if (device_index >= gpu_list.size())
device_index = 0;
VkPhysicalDevice gpu = gpu_list[device_index];
VkPhysicalDeviceProperties properties;
vkGetPhysicalDeviceProperties(gpu, &properties);
VkPhysicalDeviceFeatures features;
vkGetPhysicalDeviceFeatures(gpu, &features);
VulkanContext::PopulateBackendInfoFeatures(&g_Config, gpu, properties, features);
VulkanContext::PopulateBackendInfoMultisampleModes(&g_Config, gpu, properties);
}
}
vkDestroyInstance(temp_instance, nullptr);
}
else
{
PanicAlert("Failed to create Vulkan instance.");
}
UnloadVulkanLibrary();
}
else
{
PanicAlert("Failed to load Vulkan library.");
}
}
Tutorial01::~Tutorial01() {
if( Vulkan.Device != VK_NULL_HANDLE ) {
vkDeviceWaitIdle( Vulkan.Device );
vkDestroyDevice( Vulkan.Device, nullptr );
}
if( Vulkan.Instance != VK_NULL_HANDLE ) {
vkDestroyInstance( Vulkan.Instance, nullptr );
}
if( VulkanLibrary ) {
#if defined(VK_USE_PLATFORM_WIN32_KHR)
FreeLibrary( VulkanLibrary );
#elif defined(VK_USE_PLATFORM_XCB_KHR) || defined(VK_USE_PLATFORM_XLIB_KHR)
dlclose( VulkanLibrary );
#endif
}
}
void cleanup() {
vkDestroyPipelineLayout(device, pipelineLayout, nullptr);
vkDestroyRenderPass(device, renderPass, nullptr);
for (auto imageView : swapChainImageViews) {
vkDestroyImageView(device, imageView, nullptr);
}
vkDestroySwapchainKHR(device, swapChain, nullptr);
vkDestroyDevice(device, nullptr);
DestroyDebugReportCallbackEXT(instance, callback, nullptr);
vkDestroySurfaceKHR(instance, surface, nullptr);
vkDestroyInstance(instance, nullptr);
glfwDestroyWindow(window);
glfwTerminate();
}
Context::~Context()
{
vkDestroyCommandPool(kDevice, kCmdPool, NULL);
vkDestroyDevice(kDevice, NULL);
if (enableValidationLayers) {
auto func = (PFN_vkDestroyDebugReportCallbackEXT)
vkGetInstanceProcAddr(kInstance, "vkDestroyDebugReportCallbackEXT");
if (func == nullptr) {
throw std::runtime_error("Could not load vkDestroyDebugReportCallbackEXT");
}
func(kInstance, kDebugReportCallback, NULL);
}
kShaders.clear();
vkDestroyInstance(kInstance, NULL);
return;
}
C9::~C9()
{
if (mPhysicalDevices != nullptr)
{
delete[] mPhysicalDevices;
}
#ifdef _DEBUG
if(mCallback != VK_NULL_HANDLE)
{
vkDestroyDebugReportCallbackEXT(mInstance, mCallback, nullptr);
}
#endif
if (mInstance != VK_NULL_HANDLE)
{
vkDestroyInstance(mInstance, nullptr);
}
}
/** Please see header for specification */
Anvil::Instance::~Instance()
{
Anvil::ObjectTracker::get()->unregister_object(Anvil::OBJECT_TYPE_INSTANCE,
this);
destroy();
if (m_instance != VK_NULL_HANDLE)
{
lock();
{
vkDestroyInstance(m_instance,
nullptr /* pAllocator */);
}
unlock();
m_instance = VK_NULL_HANDLE;
}
}
void shutdown() {
on_window_resize_listener = static_cast<size_t >(-1);
if (vk_globals::device != nullptr) {
vkDeviceWaitIdle(vk_globals::device);
shutdown_swap_chain();
vkDestroyDevice(vk_globals::device, nullptr);
vk_globals::device = nullptr;
}
if (vk_globals::surface != nullptr) {
vkDestroySurfaceKHR(vk_globals::instance, vk_globals::surface, nullptr);
}
if (vk_globals::instance != nullptr) {
vkDestroyInstance(vk_globals::instance, nullptr);
}
}
static void
gst_vulkan_instance_finalize (GObject * object)
{
GstVulkanInstance *instance = GST_VULKAN_INSTANCE (object);
if (instance->priv->opened) {
if (instance->dbgDestroyDebugReportCallback)
instance->dbgDestroyDebugReportCallback (instance->instance,
instance->msg_callback, NULL);
g_free (instance->physical_devices);
}
instance->priv->opened = FALSE;
if (instance->instance)
vkDestroyInstance (instance->instance, NULL);
instance->instance = NULL;
G_OBJECT_CLASS (parent_class)->finalize (object);
}
TEST(LX435, InstanceCreateInfoConst)
{
VkInstanceCreateInfo const info =
{
VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
nullptr,
0,
nullptr,
0,
nullptr,
0,
nullptr
};
VkInstance instance = VK_NULL_HANDLE;
VkResult result = vkCreateInstance(&info, VK_NULL_HANDLE, &instance);
EXPECT_EQ(result, VK_SUCCESS);
vkDestroyInstance(instance, nullptr);
}
//int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR pCmdLine, int nCmdShow)
int main(int argc, char *argv[])
{
VkInstance vk_instance = VK_NULL_HANDLE;
VkDevice device = VK_NULL_HANDLE;
SwapChain swap_chain;
DrawCommandBuffer command_buffer;
VkCommandPool swap_chain_command_pool = VK_NULL_HANDLE;
VkCommandPool draw_command_pool = VK_NULL_HANDLE;
if (VkResult err = init_Vulkan(vk_instance, &device, &command_buffer, &swap_chain))
{
print_vk_error_code("Unable to initialize Vulkan: ", err);
return 1;
}
// Swap chain command pool
create_command_pool(device, swap_chain.queue_family_idx, &swap_chain_command_pool);
if (swap_chain.queue_family_idx == command_buffer.queue_family_idx)
{
draw_command_pool = swap_chain_command_pool;
}
else
{
create_command_pool(device, command_buffer.queue_family_idx, &draw_command_pool);
}
uint32_t w = 800;
uint32_t h = 600;
setup(device, swap_chain_command_pool, swap_chain, &w, &h);
//while (true)
{
// clear screen
// swap chain
}
vkDestroyDevice(device, nullptr);
vkDestroyInstance(vk_instance, nullptr);
return 0;
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Main
//
int main()
{
if( createWindow() )
{
if( initVkInstance( "vulkan_test", "lamp_engine" ) )
{
getDevicesList();
if( findSupportedQueue() && createDevice() )
{
if( initCommandBuffers() )
{
if( initSwapChains() )
{
ShowWindow( ghWnd, true );
// Start loop
MSG msg;
while( !gClose && GetMessage( &msg, NULL, 0, 0 ) > 0 )
{
TranslateMessage( &msg );
DispatchMessage( &msg );
}
}
vkFreeCommandBuffers( gDevice, gCmdPool, 1, &gCmd );
vkDestroyCommandPool( gDevice, gCmdPool, nullptr );
}
vkDestroyDevice( gDevice, nullptr );
}
vkDestroyInstance( gInstance, nullptr );
}
}
system("PAUSE");
return 0;
}
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);
}
VulkanBase::~VulkanBase() {
swapChain.cleanup();
vkDestroyDescriptorPool(device, descriptorPool, nullptr);
if (setupCmdBuffer != VK_NULL_HANDLE)
vkFreeCommandBuffers(device, cmdPool, 1, &setupCmdBuffer);
destroyCommandBuffers();
vkDestroyRenderPass(device, renderPass, nullptr);
for (uint32_t i = 0; i < frameBuffers.size(); i++)
vkDestroyFramebuffer(device, frameBuffers[i], nullptr);
for (auto& shaderModule : shaderModules)
vkDestroyShaderModule(device, shaderModule, nullptr);
vkDestroyImageView(device, depthStencil.view, nullptr);
vkDestroyImage(device, depthStencil.image, nullptr);
vkFreeMemory(device, depthStencil.mem, nullptr);
vkDestroyPipelineCache(device, pipelineCache, nullptr);
if (textureLoader)
delete textureLoader;
vkDestroyCommandPool(device, cmdPool, nullptr);
vkDestroySemaphore(device, semaphores.presentComplete, nullptr);
vkDestroySemaphore(device, semaphores.renderComplete, nullptr);
vkDestroyDevice(device, nullptr);
if (enableValidation)
vkDebug::freeDebugCallback(instance);
vkDestroyInstance(instance, nullptr);
}
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);
}
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;
}