mirror of
https://github.com/opus-tango/IntroductionToVulkan.git
synced 2026-03-20 12:05:20 +00:00
Changed folder structure and refactored CMakeLists.txt file.
This commit is contained in:
Pawel Lapinski
870
Project/Tutorials/02/Tutorial02.cpp
Normal file
870
Project/Tutorials/02/Tutorial02.cpp
Normal file
@@ -0,0 +1,870 @@
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// Copyright 2017 Intel Corporation
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License"); you may not
|
||||
// use this file except in compliance with the License. You may obtain a copy
|
||||
// of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
||||
// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
||||
// License for the specific language governing permissions and limitations
|
||||
// under the License.
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include "Tutorial02.h"
|
||||
#include "VulkanFunctions.h"
|
||||
|
||||
namespace ApiWithoutSecrets {
|
||||
|
||||
Tutorial02::Tutorial02() :
|
||||
VulkanLibrary(),
|
||||
Window(),
|
||||
Vulkan() {
|
||||
}
|
||||
|
||||
bool Tutorial02::PrepareVulkan( OS::WindowParameters parameters ) {
|
||||
Window = parameters;
|
||||
|
||||
if( !LoadVulkanLibrary() ) {
|
||||
return false;
|
||||
}
|
||||
if( !LoadExportedEntryPoints() ) {
|
||||
return false;
|
||||
}
|
||||
if( !LoadGlobalLevelEntryPoints() ) {
|
||||
return false;
|
||||
}
|
||||
if( !CreateInstance() ) {
|
||||
return false;
|
||||
}
|
||||
if( !LoadInstanceLevelEntryPoints() ) {
|
||||
return false;
|
||||
}
|
||||
if( !CreatePresentationSurface() ) {
|
||||
return false;
|
||||
}
|
||||
if( !CreateDevice() ) {
|
||||
return false;
|
||||
}
|
||||
if( !LoadDeviceLevelEntryPoints() ) {
|
||||
return false;
|
||||
}
|
||||
if( !GetDeviceQueue() ) {
|
||||
return false;
|
||||
}
|
||||
if( !CreateSemaphores() ) {
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool Tutorial02::LoadVulkanLibrary() {
|
||||
#if defined(VK_USE_PLATFORM_WIN32_KHR)
|
||||
VulkanLibrary = LoadLibrary( "vulkan-1.dll" );
|
||||
#elif defined(VK_USE_PLATFORM_XCB_KHR) || defined(VK_USE_PLATFORM_XLIB_KHR)
|
||||
VulkanLibrary = dlopen( "libvulkan.so.1", RTLD_NOW );
|
||||
#endif
|
||||
|
||||
if( VulkanLibrary == nullptr ) {
|
||||
std::cout << "Could not load Vulkan library!" << std::endl;
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool Tutorial02::LoadExportedEntryPoints() {
|
||||
#if defined(VK_USE_PLATFORM_WIN32_KHR)
|
||||
#define LoadProcAddress GetProcAddress
|
||||
#elif defined(VK_USE_PLATFORM_XCB_KHR) || defined(VK_USE_PLATFORM_XLIB_KHR)
|
||||
#define LoadProcAddress dlsym
|
||||
#endif
|
||||
|
||||
#define VK_EXPORTED_FUNCTION( fun ) \
|
||||
if( !(fun = (PFN_##fun)LoadProcAddress( VulkanLibrary, #fun )) ) { \
|
||||
std::cout << "Could not load exported function: " << #fun << "!" << std::endl; \
|
||||
return false; \
|
||||
}
|
||||
|
||||
#include "ListOfFunctions.inl"
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool Tutorial02::LoadGlobalLevelEntryPoints() {
|
||||
#define VK_GLOBAL_LEVEL_FUNCTION( fun ) \
|
||||
if( !(fun = (PFN_##fun)vkGetInstanceProcAddr( nullptr, #fun )) ) { \
|
||||
std::cout << "Could not load global level function: " << #fun << "!" << std::endl; \
|
||||
return false; \
|
||||
}
|
||||
|
||||
#include "ListOfFunctions.inl"
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool Tutorial02::CreateInstance() {
|
||||
uint32_t extensions_count = 0;
|
||||
if( (vkEnumerateInstanceExtensionProperties( nullptr, &extensions_count, nullptr ) != VK_SUCCESS) ||
|
||||
(extensions_count == 0) ) {
|
||||
std::cout << "Error occurred during instance extensions enumeration!" << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
std::vector<VkExtensionProperties> available_extensions( extensions_count );
|
||||
if( vkEnumerateInstanceExtensionProperties( nullptr, &extensions_count, &available_extensions[0] ) != VK_SUCCESS ) {
|
||||
std::cout << "Error occurred during instance extensions enumeration!" << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
std::vector<const char*> extensions = {
|
||||
VK_KHR_SURFACE_EXTENSION_NAME,
|
||||
#if defined(VK_USE_PLATFORM_WIN32_KHR)
|
||||
VK_KHR_WIN32_SURFACE_EXTENSION_NAME
|
||||
#elif defined(VK_USE_PLATFORM_XCB_KHR)
|
||||
VK_KHR_XCB_SURFACE_EXTENSION_NAME
|
||||
#elif defined(VK_USE_PLATFORM_XLIB_KHR)
|
||||
VK_KHR_XLIB_SURFACE_EXTENSION_NAME
|
||||
#endif
|
||||
};
|
||||
|
||||
for( size_t i = 0; i < extensions.size(); ++i ) {
|
||||
if( !CheckExtensionAvailability( extensions[i], available_extensions ) ) {
|
||||
std::cout << "Could not find instance extension named \"" << extensions[i] << "\"!" << std::endl;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
VkApplicationInfo application_info = {
|
||||
VK_STRUCTURE_TYPE_APPLICATION_INFO, // VkStructureType sType
|
||||
nullptr, // const void *pNext
|
||||
"API without Secrets: Introduction to Vulkan", // const char *pApplicationName
|
||||
VK_MAKE_VERSION( 1, 0, 0 ), // uint32_t applicationVersion
|
||||
"Vulkan Tutorial by Intel", // const char *pEngineName
|
||||
VK_MAKE_VERSION( 1, 0, 0 ), // uint32_t engineVersion
|
||||
VK_MAKE_VERSION( 1, 0, 0 ) // uint32_t apiVersion
|
||||
};
|
||||
|
||||
VkInstanceCreateInfo instance_create_info = {
|
||||
VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, // VkStructureType sType
|
||||
nullptr, // const void *pNext
|
||||
0, // VkInstanceCreateFlags flags
|
||||
&application_info, // const VkApplicationInfo *pApplicationInfo
|
||||
0, // uint32_t enabledLayerCount
|
||||
nullptr, // const char * const *ppEnabledLayerNames
|
||||
static_cast<uint32_t>(extensions.size()), // uint32_t enabledExtensionCount
|
||||
&extensions[0] // const char * const *ppEnabledExtensionNames
|
||||
};
|
||||
|
||||
if( vkCreateInstance( &instance_create_info, nullptr, &Vulkan.Instance ) != VK_SUCCESS ) {
|
||||
std::cout << "Could not create Vulkan instance!" << std::endl;
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool Tutorial02::CheckExtensionAvailability( const char *extension_name, const std::vector<VkExtensionProperties> &available_extensions ) {
|
||||
for( size_t i = 0; i < available_extensions.size(); ++i ) {
|
||||
if( strcmp( available_extensions[i].extensionName, extension_name ) == 0 ) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool Tutorial02::LoadInstanceLevelEntryPoints() {
|
||||
#define VK_INSTANCE_LEVEL_FUNCTION( fun ) \
|
||||
if( !(fun = (PFN_##fun)vkGetInstanceProcAddr( Vulkan.Instance, #fun )) ) { \
|
||||
std::cout << "Could not load instance level function: " << #fun << "!" << std::endl; \
|
||||
return false; \
|
||||
}
|
||||
|
||||
#include "ListOfFunctions.inl"
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool Tutorial02::CreatePresentationSurface() {
|
||||
#if defined(VK_USE_PLATFORM_WIN32_KHR)
|
||||
VkWin32SurfaceCreateInfoKHR surface_create_info = {
|
||||
VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR, // VkStructureType sType
|
||||
nullptr, // const void *pNext
|
||||
0, // VkWin32SurfaceCreateFlagsKHR flags
|
||||
Window.Instance, // HINSTANCE hinstance
|
||||
Window.Handle // HWND hwnd
|
||||
};
|
||||
|
||||
if( vkCreateWin32SurfaceKHR( Vulkan.Instance, &surface_create_info, nullptr, &Vulkan.PresentationSurface ) == VK_SUCCESS ) {
|
||||
return true;
|
||||
}
|
||||
|
||||
#elif defined(VK_USE_PLATFORM_XCB_KHR)
|
||||
VkXcbSurfaceCreateInfoKHR surface_create_info = {
|
||||
VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR, // VkStructureType sType
|
||||
nullptr, // const void *pNext
|
||||
0, // VkXcbSurfaceCreateFlagsKHR flags
|
||||
Window.Connection, // xcb_connection_t* connection
|
||||
Window.Handle // xcb_window_t window
|
||||
};
|
||||
|
||||
if( vkCreateXcbSurfaceKHR( Vulkan.Instance, &surface_create_info, nullptr, &Vulkan.PresentationSurface ) == VK_SUCCESS ) {
|
||||
return true;
|
||||
}
|
||||
|
||||
#elif defined(VK_USE_PLATFORM_XLIB_KHR)
|
||||
VkXlibSurfaceCreateInfoKHR surface_create_info = {
|
||||
VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR, // VkStructureType sType
|
||||
nullptr, // const void *pNext
|
||||
0, // VkXlibSurfaceCreateFlagsKHR flags
|
||||
Window.DisplayPtr, // Display *dpy
|
||||
Window.Handle // Window window
|
||||
};
|
||||
if( vkCreateXlibSurfaceKHR( Vulkan.Instance, &surface_create_info, nullptr, &Vulkan.PresentationSurface ) == VK_SUCCESS ) {
|
||||
return true;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
std::cout << "Could not create presentation surface!" << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
bool Tutorial02::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[0] ) != VK_SUCCESS ) {
|
||||
std::cout << "Error occurred during physical devices enumeration!" << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
uint32_t selected_graphics_queue_family_index = UINT32_MAX;
|
||||
uint32_t selected_present_queue_family_index = UINT32_MAX;
|
||||
|
||||
for( uint32_t i = 0; i < num_devices; ++i ) {
|
||||
if( CheckPhysicalDeviceProperties( physical_devices[i], selected_graphics_queue_family_index, selected_present_queue_family_index ) ) {
|
||||
Vulkan.PhysicalDevice = physical_devices[i];
|
||||
break;
|
||||
}
|
||||
}
|
||||
if( Vulkan.PhysicalDevice == VK_NULL_HANDLE ) {
|
||||
std::cout << "Could not select physical device based on the chosen properties!" << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
std::vector<VkDeviceQueueCreateInfo> queue_create_infos;
|
||||
std::vector<float> queue_priorities = { 1.0f };
|
||||
|
||||
queue_create_infos.push_back( {
|
||||
VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, // VkStructureType sType
|
||||
nullptr, // const void *pNext
|
||||
0, // VkDeviceQueueCreateFlags flags
|
||||
selected_graphics_queue_family_index, // uint32_t queueFamilyIndex
|
||||
static_cast<uint32_t>(queue_priorities.size()), // uint32_t queueCount
|
||||
&queue_priorities[0] // const float *pQueuePriorities
|
||||
} );
|
||||
|
||||
if( selected_graphics_queue_family_index != selected_present_queue_family_index ) {
|
||||
queue_create_infos.push_back( {
|
||||
VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, // VkStructureType sType
|
||||
nullptr, // const void *pNext
|
||||
0, // VkDeviceQueueCreateFlags flags
|
||||
selected_present_queue_family_index, // uint32_t queueFamilyIndex
|
||||
static_cast<uint32_t>(queue_priorities.size()), // uint32_t queueCount
|
||||
&queue_priorities[0] // const float *pQueuePriorities
|
||||
} );
|
||||
}
|
||||
|
||||
std::vector<const char*> extensions = {
|
||||
VK_KHR_SWAPCHAIN_EXTENSION_NAME
|
||||
};
|
||||
|
||||
VkDeviceCreateInfo device_create_info = {
|
||||
VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, // VkStructureType sType
|
||||
nullptr, // const void *pNext
|
||||
0, // VkDeviceCreateFlags flags
|
||||
static_cast<uint32_t>(queue_create_infos.size()), // uint32_t queueCreateInfoCount
|
||||
&queue_create_infos[0], // const VkDeviceQueueCreateInfo *pQueueCreateInfos
|
||||
0, // uint32_t enabledLayerCount
|
||||
nullptr, // const char * const *ppEnabledLayerNames
|
||||
static_cast<uint32_t>(extensions.size()), // uint32_t enabledExtensionCount
|
||||
&extensions[0], // const char * const *ppEnabledExtensionNames
|
||||
nullptr // const VkPhysicalDeviceFeatures *pEnabledFeatures
|
||||
};
|
||||
|
||||
if( vkCreateDevice( Vulkan.PhysicalDevice, &device_create_info, nullptr, &Vulkan.Device ) != VK_SUCCESS ) {
|
||||
std::cout << "Could not create Vulkan device!" << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
Vulkan.GraphicsQueueFamilyIndex = selected_graphics_queue_family_index;
|
||||
Vulkan.PresentQueueFamilyIndex = selected_present_queue_family_index;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool Tutorial02::CheckPhysicalDeviceProperties( VkPhysicalDevice physical_device, uint32_t &selected_graphics_queue_family_index, uint32_t &selected_present_queue_family_index ) {
|
||||
uint32_t extensions_count = 0;
|
||||
if( (vkEnumerateDeviceExtensionProperties( physical_device, nullptr, &extensions_count, nullptr ) != VK_SUCCESS) ||
|
||||
(extensions_count == 0) ) {
|
||||
std::cout << "Error occurred during physical device " << physical_device << " extensions enumeration!" << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
std::vector<VkExtensionProperties> available_extensions( extensions_count );
|
||||
if( vkEnumerateDeviceExtensionProperties( physical_device, nullptr, &extensions_count, &available_extensions[0] ) != VK_SUCCESS ) {
|
||||
std::cout << "Error occurred during physical device " << physical_device << " extensions enumeration!" << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
std::vector<const char*> device_extensions = {
|
||||
VK_KHR_SWAPCHAIN_EXTENSION_NAME
|
||||
};
|
||||
|
||||
for( size_t i = 0; i < device_extensions.size(); ++i ) {
|
||||
if( !CheckExtensionAvailability( device_extensions[i], available_extensions ) ) {
|
||||
std::cout << "Physical device " << physical_device << " doesn't support extension named \"" << device_extensions[i] << "\"!" << std::endl;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
VkPhysicalDeviceProperties device_properties;
|
||||
VkPhysicalDeviceFeatures device_features;
|
||||
|
||||
vkGetPhysicalDeviceProperties( physical_device, &device_properties );
|
||||
vkGetPhysicalDeviceFeatures( physical_device, &device_features );
|
||||
|
||||
uint32_t major_version = VK_VERSION_MAJOR( device_properties.apiVersion );
|
||||
|
||||
if( (major_version < 1) ||
|
||||
(device_properties.limits.maxImageDimension2D < 4096) ) {
|
||||
std::cout << "Physical device " << physical_device << " doesn't support required parameters!" << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
uint32_t queue_families_count = 0;
|
||||
vkGetPhysicalDeviceQueueFamilyProperties( physical_device, &queue_families_count, nullptr );
|
||||
if( queue_families_count == 0 ) {
|
||||
std::cout << "Physical device " << physical_device << " doesn't have any queue families!" << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
std::vector<VkQueueFamilyProperties> queue_family_properties( queue_families_count );
|
||||
std::vector<VkBool32> queue_present_support( queue_families_count );
|
||||
|
||||
vkGetPhysicalDeviceQueueFamilyProperties( physical_device, &queue_families_count, &queue_family_properties[0] );
|
||||
|
||||
uint32_t graphics_queue_family_index = UINT32_MAX;
|
||||
uint32_t present_queue_family_index = UINT32_MAX;
|
||||
|
||||
for( uint32_t i = 0; i < queue_families_count; ++i ) {
|
||||
vkGetPhysicalDeviceSurfaceSupportKHR( physical_device, i, Vulkan.PresentationSurface, &queue_present_support[i] );
|
||||
|
||||
if( (queue_family_properties[i].queueCount > 0) &&
|
||||
(queue_family_properties[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) ) {
|
||||
// Select first queue that supports graphics
|
||||
if( graphics_queue_family_index == UINT32_MAX ) {
|
||||
graphics_queue_family_index = i;
|
||||
}
|
||||
|
||||
// If there is queue that supports both graphics and present - prefer it
|
||||
if( queue_present_support[i] ) {
|
||||
selected_graphics_queue_family_index = i;
|
||||
selected_present_queue_family_index = i;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// We don't have queue that supports both graphics and present so we have to use separate queues
|
||||
for( uint32_t i = 0; i < queue_families_count; ++i ) {
|
||||
if( queue_present_support[i] ) {
|
||||
present_queue_family_index = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// If this device doesn't support queues with graphics and present capabilities don't use it
|
||||
if( (graphics_queue_family_index == UINT32_MAX) ||
|
||||
(present_queue_family_index == UINT32_MAX) ) {
|
||||
std::cout << "Could not find queue family with required properties on physical device " << physical_device << "!" << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
selected_graphics_queue_family_index = graphics_queue_family_index;
|
||||
selected_present_queue_family_index = present_queue_family_index;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool Tutorial02::LoadDeviceLevelEntryPoints() {
|
||||
#define VK_DEVICE_LEVEL_FUNCTION( fun ) \
|
||||
if( !(fun = (PFN_##fun)vkGetDeviceProcAddr( Vulkan.Device, #fun )) ) { \
|
||||
std::cout << "Could not load device level function: " << #fun << "!" << std::endl; \
|
||||
return false; \
|
||||
}
|
||||
|
||||
#include "ListOfFunctions.inl"
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool Tutorial02::GetDeviceQueue() {
|
||||
vkGetDeviceQueue( Vulkan.Device, Vulkan.GraphicsQueueFamilyIndex, 0, &Vulkan.GraphicsQueue );
|
||||
vkGetDeviceQueue( Vulkan.Device, Vulkan.PresentQueueFamilyIndex, 0, &Vulkan.PresentQueue );
|
||||
return true;
|
||||
}
|
||||
|
||||
bool Tutorial02::CreateSemaphores() {
|
||||
VkSemaphoreCreateInfo semaphore_create_info = {
|
||||
VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO, // VkStructureType sType
|
||||
nullptr, // const void* pNext
|
||||
0 // VkSemaphoreCreateFlags flags
|
||||
};
|
||||
|
||||
if( (vkCreateSemaphore( Vulkan.Device, &semaphore_create_info, nullptr, &Vulkan.ImageAvailableSemaphore ) != VK_SUCCESS) ||
|
||||
(vkCreateSemaphore( Vulkan.Device, &semaphore_create_info, nullptr, &Vulkan.RenderingFinishedSemaphore ) != VK_SUCCESS) ) {
|
||||
std::cout << "Could not create semaphores!" << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool Tutorial02::CreateSwapChain() {
|
||||
CanRender = false;
|
||||
|
||||
if( Vulkan.Device != VK_NULL_HANDLE ) {
|
||||
vkDeviceWaitIdle( Vulkan.Device );
|
||||
}
|
||||
|
||||
VkSurfaceCapabilitiesKHR surface_capabilities;
|
||||
if( vkGetPhysicalDeviceSurfaceCapabilitiesKHR( Vulkan.PhysicalDevice, Vulkan.PresentationSurface, &surface_capabilities ) != VK_SUCCESS ) {
|
||||
std::cout << "Could not check presentation surface capabilities!" << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
uint32_t formats_count;
|
||||
if( (vkGetPhysicalDeviceSurfaceFormatsKHR( Vulkan.PhysicalDevice, Vulkan.PresentationSurface, &formats_count, nullptr ) != VK_SUCCESS) ||
|
||||
(formats_count == 0) ) {
|
||||
std::cout << "Error occurred during presentation surface formats enumeration!" << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
std::vector<VkSurfaceFormatKHR> surface_formats( formats_count );
|
||||
if( vkGetPhysicalDeviceSurfaceFormatsKHR( Vulkan.PhysicalDevice, Vulkan.PresentationSurface, &formats_count, &surface_formats[0] ) != VK_SUCCESS ) {
|
||||
std::cout << "Error occurred during presentation surface formats enumeration!" << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
uint32_t present_modes_count;
|
||||
if( (vkGetPhysicalDeviceSurfacePresentModesKHR( Vulkan.PhysicalDevice, Vulkan.PresentationSurface, &present_modes_count, nullptr ) != VK_SUCCESS) ||
|
||||
(present_modes_count == 0) ) {
|
||||
std::cout << "Error occurred during presentation surface present modes enumeration!" << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
std::vector<VkPresentModeKHR> present_modes( present_modes_count );
|
||||
if( vkGetPhysicalDeviceSurfacePresentModesKHR( Vulkan.PhysicalDevice, Vulkan.PresentationSurface, &present_modes_count, &present_modes[0] ) != VK_SUCCESS ) {
|
||||
std::cout << "Error occurred during presentation surface present modes enumeration!" << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
uint32_t desired_number_of_images = GetSwapChainNumImages( surface_capabilities );
|
||||
VkSurfaceFormatKHR desired_format = GetSwapChainFormat( surface_formats );
|
||||
VkExtent2D desired_extent = GetSwapChainExtent( surface_capabilities );
|
||||
VkImageUsageFlags desired_usage = GetSwapChainUsageFlags( surface_capabilities );
|
||||
VkSurfaceTransformFlagBitsKHR desired_transform = GetSwapChainTransform( surface_capabilities );
|
||||
VkPresentModeKHR desired_present_mode = GetSwapChainPresentMode( present_modes );
|
||||
VkSwapchainKHR old_swap_chain = Vulkan.SwapChain;
|
||||
|
||||
if( static_cast<int>(desired_usage) == -1 ) {
|
||||
return false;
|
||||
}
|
||||
if( static_cast<int>(desired_present_mode) == -1 ) {
|
||||
return false;
|
||||
}
|
||||
if( (desired_extent.width == 0) || (desired_extent.height == 0) ) {
|
||||
// Current surface size is (0, 0) so we can't create a swap chain and render anything (CanRender == false)
|
||||
// But we don't wont to kill the application as this situation may occur i.e. when window gets minimized
|
||||
return true;
|
||||
}
|
||||
|
||||
VkSwapchainCreateInfoKHR swap_chain_create_info = {
|
||||
VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR, // VkStructureType sType
|
||||
nullptr, // const void *pNext
|
||||
0, // VkSwapchainCreateFlagsKHR flags
|
||||
Vulkan.PresentationSurface, // VkSurfaceKHR surface
|
||||
desired_number_of_images, // uint32_t minImageCount
|
||||
desired_format.format, // VkFormat imageFormat
|
||||
desired_format.colorSpace, // VkColorSpaceKHR imageColorSpace
|
||||
desired_extent, // VkExtent2D imageExtent
|
||||
1, // uint32_t imageArrayLayers
|
||||
desired_usage, // VkImageUsageFlags imageUsage
|
||||
VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode imageSharingMode
|
||||
0, // uint32_t queueFamilyIndexCount
|
||||
nullptr, // const uint32_t *pQueueFamilyIndices
|
||||
desired_transform, // VkSurfaceTransformFlagBitsKHR preTransform
|
||||
VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR, // VkCompositeAlphaFlagBitsKHR compositeAlpha
|
||||
desired_present_mode, // VkPresentModeKHR presentMode
|
||||
VK_TRUE, // VkBool32 clipped
|
||||
old_swap_chain // VkSwapchainKHR oldSwapchain
|
||||
};
|
||||
|
||||
if( vkCreateSwapchainKHR( Vulkan.Device, &swap_chain_create_info, nullptr, &Vulkan.SwapChain ) != VK_SUCCESS ) {
|
||||
std::cout << "Could not create swap chain!" << std::endl;
|
||||
return false;
|
||||
}
|
||||
if( old_swap_chain != VK_NULL_HANDLE ) {
|
||||
vkDestroySwapchainKHR( Vulkan.Device, old_swap_chain, nullptr );
|
||||
}
|
||||
|
||||
CanRender = true;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
uint32_t Tutorial02::GetSwapChainNumImages( VkSurfaceCapabilitiesKHR &surface_capabilities ) {
|
||||
// Set of images defined in a swap chain may not always be available for application to render to:
|
||||
// One may be displayed and one may wait in a queue to be presented
|
||||
// If application wants to use more images at the same time it must ask for more images
|
||||
uint32_t image_count = surface_capabilities.minImageCount + 1;
|
||||
if( (surface_capabilities.maxImageCount > 0) &&
|
||||
(image_count > surface_capabilities.maxImageCount) ) {
|
||||
image_count = surface_capabilities.maxImageCount;
|
||||
}
|
||||
return image_count;
|
||||
}
|
||||
|
||||
VkSurfaceFormatKHR Tutorial02::GetSwapChainFormat( std::vector<VkSurfaceFormatKHR> &surface_formats ) {
|
||||
// If the list contains only one entry with undefined format
|
||||
// it means that there are no preferred surface formats and any can be chosen
|
||||
if( (surface_formats.size() == 1) &&
|
||||
(surface_formats[0].format == VK_FORMAT_UNDEFINED) ) {
|
||||
return{ VK_FORMAT_R8G8B8A8_UNORM, VK_COLORSPACE_SRGB_NONLINEAR_KHR };
|
||||
}
|
||||
|
||||
// Check if list contains most widely used R8 G8 B8 A8 format
|
||||
// with nonlinear color space
|
||||
for( VkSurfaceFormatKHR &surface_format : surface_formats ) {
|
||||
if( surface_format.format == VK_FORMAT_R8G8B8A8_UNORM ) {
|
||||
return surface_format;
|
||||
}
|
||||
}
|
||||
|
||||
// Return the first format from the list
|
||||
return surface_formats[0];
|
||||
}
|
||||
|
||||
VkExtent2D Tutorial02::GetSwapChainExtent( VkSurfaceCapabilitiesKHR &surface_capabilities ) {
|
||||
// Special value of surface extent is width == height == -1
|
||||
// If this is so we define the size by ourselves but it must fit within defined confines
|
||||
if( surface_capabilities.currentExtent.width == -1 ) {
|
||||
VkExtent2D swap_chain_extent = { 640, 480 };
|
||||
if( swap_chain_extent.width < surface_capabilities.minImageExtent.width ) {
|
||||
swap_chain_extent.width = surface_capabilities.minImageExtent.width;
|
||||
}
|
||||
if( swap_chain_extent.height < surface_capabilities.minImageExtent.height ) {
|
||||
swap_chain_extent.height = surface_capabilities.minImageExtent.height;
|
||||
}
|
||||
if( swap_chain_extent.width > surface_capabilities.maxImageExtent.width ) {
|
||||
swap_chain_extent.width = surface_capabilities.maxImageExtent.width;
|
||||
}
|
||||
if( swap_chain_extent.height > surface_capabilities.maxImageExtent.height ) {
|
||||
swap_chain_extent.height = surface_capabilities.maxImageExtent.height;
|
||||
}
|
||||
return swap_chain_extent;
|
||||
}
|
||||
|
||||
// Most of the cases we define size of the swap_chain images equal to current window's size
|
||||
return surface_capabilities.currentExtent;
|
||||
}
|
||||
|
||||
VkImageUsageFlags Tutorial02::GetSwapChainUsageFlags( VkSurfaceCapabilitiesKHR &surface_capabilities ) {
|
||||
// Color attachment flag must always be supported
|
||||
// We can define other usage flags but we always need to check if they are supported
|
||||
if( surface_capabilities.supportedUsageFlags & VK_IMAGE_USAGE_TRANSFER_DST_BIT ) {
|
||||
return VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
|
||||
}
|
||||
std::cout << "VK_IMAGE_USAGE_TRANSFER_DST image usage is not supported by the swap chain!" << std::endl
|
||||
<< "Supported swap chain's image usages include:" << std::endl
|
||||
<< (surface_capabilities.supportedUsageFlags & VK_IMAGE_USAGE_TRANSFER_SRC_BIT ? " VK_IMAGE_USAGE_TRANSFER_SRC\n" : "")
|
||||
<< (surface_capabilities.supportedUsageFlags & VK_IMAGE_USAGE_TRANSFER_DST_BIT ? " VK_IMAGE_USAGE_TRANSFER_DST\n" : "")
|
||||
<< (surface_capabilities.supportedUsageFlags & VK_IMAGE_USAGE_SAMPLED_BIT ? " VK_IMAGE_USAGE_SAMPLED\n" : "")
|
||||
<< (surface_capabilities.supportedUsageFlags & VK_IMAGE_USAGE_STORAGE_BIT ? " VK_IMAGE_USAGE_STORAGE\n" : "")
|
||||
<< (surface_capabilities.supportedUsageFlags & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT ? " VK_IMAGE_USAGE_COLOR_ATTACHMENT\n" : "")
|
||||
<< (surface_capabilities.supportedUsageFlags & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT ? " VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT\n" : "")
|
||||
<< (surface_capabilities.supportedUsageFlags & VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT ? " VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT\n" : "")
|
||||
<< (surface_capabilities.supportedUsageFlags & VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT ? " VK_IMAGE_USAGE_INPUT_ATTACHMENT" : "")
|
||||
<< std::endl;
|
||||
return static_cast<VkImageUsageFlags>(-1);
|
||||
}
|
||||
|
||||
VkSurfaceTransformFlagBitsKHR Tutorial02::GetSwapChainTransform( VkSurfaceCapabilitiesKHR &surface_capabilities ) {
|
||||
// Sometimes images must be transformed before they are presented (i.e. due to device's orienation
|
||||
// being other than default orientation)
|
||||
// If the specified transform is other than current transform, presentation engine will transform image
|
||||
// during presentation operation; this operation may hit performance on some platforms
|
||||
// Here we don't want any transformations to occur so if the identity transform is supported use it
|
||||
// otherwise just use the same transform as current transform
|
||||
if( surface_capabilities.supportedTransforms & VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR ) {
|
||||
return VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
|
||||
} else {
|
||||
return surface_capabilities.currentTransform;
|
||||
}
|
||||
}
|
||||
|
||||
VkPresentModeKHR Tutorial02::GetSwapChainPresentMode( std::vector<VkPresentModeKHR> &present_modes ) {
|
||||
// FIFO present mode is always available
|
||||
// MAILBOX is the lowest latency V-Sync enabled mode (something like triple-buffering) so use it if available
|
||||
for( VkPresentModeKHR &present_mode : present_modes ) {
|
||||
if( present_mode == VK_PRESENT_MODE_MAILBOX_KHR ) {
|
||||
return present_mode;
|
||||
}
|
||||
}
|
||||
for( VkPresentModeKHR &present_mode : present_modes ) {
|
||||
if( present_mode == VK_PRESENT_MODE_FIFO_KHR ) {
|
||||
return present_mode;
|
||||
}
|
||||
}
|
||||
std::cout << "FIFO present mode is not supported by the swap chain!" << std::endl;
|
||||
return static_cast<VkPresentModeKHR>(-1);
|
||||
}
|
||||
|
||||
bool Tutorial02::OnWindowSizeChanged() {
|
||||
Clear();
|
||||
|
||||
if( !CreateSwapChain() ) {
|
||||
return false;
|
||||
}
|
||||
if( !CreateCommandBuffers() ) {
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool Tutorial02::CreateCommandBuffers() {
|
||||
VkCommandPoolCreateInfo cmd_pool_create_info = {
|
||||
VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, // VkStructureType sType
|
||||
nullptr, // const void* pNext
|
||||
0, // VkCommandPoolCreateFlags flags
|
||||
Vulkan.PresentQueueFamilyIndex // uint32_t queueFamilyIndex
|
||||
};
|
||||
|
||||
if( vkCreateCommandPool( Vulkan.Device, &cmd_pool_create_info, nullptr, &Vulkan.PresentQueueCmdPool ) != VK_SUCCESS ) {
|
||||
std::cout << "Could not create a command pool!" << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
uint32_t image_count = 0;
|
||||
if( (vkGetSwapchainImagesKHR( Vulkan.Device, Vulkan.SwapChain, &image_count, nullptr ) != VK_SUCCESS) ||
|
||||
(image_count == 0) ) {
|
||||
std::cout << "Could not get the number of swap chain images!" << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
Vulkan.PresentQueueCmdBuffers.resize( image_count );
|
||||
|
||||
VkCommandBufferAllocateInfo cmd_buffer_allocate_info = {
|
||||
VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, // VkStructureType sType
|
||||
nullptr, // const void* pNext
|
||||
Vulkan.PresentQueueCmdPool, // VkCommandPool commandPool
|
||||
VK_COMMAND_BUFFER_LEVEL_PRIMARY, // VkCommandBufferLevel level
|
||||
image_count // uint32_t bufferCount
|
||||
};
|
||||
if( vkAllocateCommandBuffers( Vulkan.Device, &cmd_buffer_allocate_info, &Vulkan.PresentQueueCmdBuffers[0] ) != VK_SUCCESS ) {
|
||||
std::cout << "Could not allocate command buffers!" << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
if( !RecordCommandBuffers() ) {
|
||||
std::cout << "Could not record command buffers!" << std::endl;
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool Tutorial02::RecordCommandBuffers() {
|
||||
uint32_t image_count = static_cast<uint32_t>(Vulkan.PresentQueueCmdBuffers.size());
|
||||
|
||||
std::vector<VkImage> swap_chain_images( image_count );
|
||||
if( vkGetSwapchainImagesKHR( Vulkan.Device, Vulkan.SwapChain, &image_count, &swap_chain_images[0] ) != VK_SUCCESS ) {
|
||||
std::cout << "Could not get swap chain images!" << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
VkCommandBufferBeginInfo cmd_buffer_begin_info = {
|
||||
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType
|
||||
nullptr, // const void *pNext
|
||||
VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT, // VkCommandBufferUsageFlags flags
|
||||
nullptr // const VkCommandBufferInheritanceInfo *pInheritanceInfo
|
||||
};
|
||||
|
||||
VkClearColorValue clear_color = {
|
||||
{ 1.0f, 0.8f, 0.4f, 0.0f }
|
||||
};
|
||||
|
||||
VkImageSubresourceRange image_subresource_range = {
|
||||
VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask
|
||||
0, // uint32_t baseMipLevel
|
||||
1, // uint32_t levelCount
|
||||
0, // uint32_t baseArrayLayer
|
||||
1 // uint32_t layerCount
|
||||
};
|
||||
|
||||
for( uint32_t i = 0; i < image_count; ++i ) {
|
||||
VkImageMemoryBarrier barrier_from_present_to_clear = {
|
||||
VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType
|
||||
nullptr, // const void *pNext
|
||||
VK_ACCESS_MEMORY_READ_BIT, // VkAccessFlags srcAccessMask
|
||||
VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask
|
||||
VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout oldLayout
|
||||
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout newLayout
|
||||
VK_QUEUE_FAMILY_IGNORED, // uint32_t srcQueueFamilyIndex
|
||||
VK_QUEUE_FAMILY_IGNORED, // uint32_t dstQueueFamilyIndex
|
||||
swap_chain_images[i], // VkImage image
|
||||
image_subresource_range // VkImageSubresourceRange subresourceRange
|
||||
};
|
||||
|
||||
VkImageMemoryBarrier barrier_from_clear_to_present = {
|
||||
VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType
|
||||
nullptr, // const void *pNext
|
||||
VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask
|
||||
VK_ACCESS_MEMORY_READ_BIT, // VkAccessFlags dstAccessMask
|
||||
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout
|
||||
VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, // VkImageLayout newLayout
|
||||
VK_QUEUE_FAMILY_IGNORED, // uint32_t srcQueueFamilyIndex
|
||||
VK_QUEUE_FAMILY_IGNORED, // uint32_t dstQueueFamilyIndex
|
||||
swap_chain_images[i], // VkImage image
|
||||
image_subresource_range // VkImageSubresourceRange subresourceRange
|
||||
};
|
||||
|
||||
vkBeginCommandBuffer( Vulkan.PresentQueueCmdBuffers[i], &cmd_buffer_begin_info );
|
||||
vkCmdPipelineBarrier( Vulkan.PresentQueueCmdBuffers[i], VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 0, nullptr, 1, &barrier_from_present_to_clear );
|
||||
|
||||
vkCmdClearColorImage( Vulkan.PresentQueueCmdBuffers[i], swap_chain_images[i], VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &clear_color, 1, &image_subresource_range );
|
||||
|
||||
vkCmdPipelineBarrier( Vulkan.PresentQueueCmdBuffers[i], VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, 0, nullptr, 0, nullptr, 1, &barrier_from_clear_to_present );
|
||||
if( vkEndCommandBuffer( Vulkan.PresentQueueCmdBuffers[i] ) != VK_SUCCESS ) {
|
||||
std::cout << "Could not record command buffers!" << std::endl;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void Tutorial02::Clear() {
|
||||
if( Vulkan.Device != VK_NULL_HANDLE ) {
|
||||
vkDeviceWaitIdle( Vulkan.Device );
|
||||
|
||||
if( (Vulkan.PresentQueueCmdBuffers.size() > 0) && (Vulkan.PresentQueueCmdBuffers[0] != VK_NULL_HANDLE) ) {
|
||||
vkFreeCommandBuffers( Vulkan.Device, Vulkan.PresentQueueCmdPool, static_cast<uint32_t>(Vulkan.PresentQueueCmdBuffers.size()), &Vulkan.PresentQueueCmdBuffers[0] );
|
||||
Vulkan.PresentQueueCmdBuffers.clear();
|
||||
}
|
||||
|
||||
if( Vulkan.PresentQueueCmdPool != VK_NULL_HANDLE ) {
|
||||
vkDestroyCommandPool( Vulkan.Device, Vulkan.PresentQueueCmdPool, nullptr );
|
||||
Vulkan.PresentQueueCmdPool = VK_NULL_HANDLE;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bool Tutorial02::Draw() {
|
||||
uint32_t image_index;
|
||||
VkResult result = vkAcquireNextImageKHR( Vulkan.Device, Vulkan.SwapChain, UINT64_MAX, Vulkan.ImageAvailableSemaphore, VK_NULL_HANDLE, &image_index );
|
||||
switch( result ) {
|
||||
case VK_SUCCESS:
|
||||
case VK_SUBOPTIMAL_KHR:
|
||||
break;
|
||||
case VK_ERROR_OUT_OF_DATE_KHR:
|
||||
return OnWindowSizeChanged();
|
||||
default:
|
||||
std::cout << "Problem occurred during swap chain image acquisition!" << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
VkPipelineStageFlags wait_dst_stage_mask = VK_PIPELINE_STAGE_TRANSFER_BIT;
|
||||
VkSubmitInfo submit_info = {
|
||||
VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType
|
||||
nullptr, // const void *pNext
|
||||
1, // uint32_t waitSemaphoreCount
|
||||
&Vulkan.ImageAvailableSemaphore, // const VkSemaphore *pWaitSemaphores
|
||||
&wait_dst_stage_mask, // const VkPipelineStageFlags *pWaitDstStageMask;
|
||||
1, // uint32_t commandBufferCount
|
||||
&Vulkan.PresentQueueCmdBuffers[image_index], // const VkCommandBuffer *pCommandBuffers
|
||||
1, // uint32_t signalSemaphoreCount
|
||||
&Vulkan.RenderingFinishedSemaphore // const VkSemaphore *pSignalSemaphores
|
||||
};
|
||||
|
||||
if( vkQueueSubmit( Vulkan.PresentQueue, 1, &submit_info, VK_NULL_HANDLE ) != VK_SUCCESS ) {
|
||||
return false;
|
||||
}
|
||||
|
||||
VkPresentInfoKHR present_info = {
|
||||
VK_STRUCTURE_TYPE_PRESENT_INFO_KHR, // VkStructureType sType
|
||||
nullptr, // const void *pNext
|
||||
1, // uint32_t waitSemaphoreCount
|
||||
&Vulkan.RenderingFinishedSemaphore, // const VkSemaphore *pWaitSemaphores
|
||||
1, // uint32_t swapchainCount
|
||||
&Vulkan.SwapChain, // const VkSwapchainKHR *pSwapchains
|
||||
&image_index, // const uint32_t *pImageIndices
|
||||
nullptr // VkResult *pResults
|
||||
};
|
||||
result = vkQueuePresentKHR( Vulkan.PresentQueue, &present_info );
|
||||
|
||||
switch( result ) {
|
||||
case VK_SUCCESS:
|
||||
break;
|
||||
case VK_ERROR_OUT_OF_DATE_KHR:
|
||||
case VK_SUBOPTIMAL_KHR:
|
||||
return OnWindowSizeChanged();
|
||||
default:
|
||||
std::cout << "Problem occurred during image presentation!" << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
Tutorial02::~Tutorial02() {
|
||||
Clear();
|
||||
|
||||
if( Vulkan.Device != VK_NULL_HANDLE ) {
|
||||
vkDeviceWaitIdle( Vulkan.Device );
|
||||
|
||||
if( Vulkan.ImageAvailableSemaphore != VK_NULL_HANDLE ) {
|
||||
vkDestroySemaphore( Vulkan.Device, Vulkan.ImageAvailableSemaphore, nullptr );
|
||||
}
|
||||
if( Vulkan.RenderingFinishedSemaphore != VK_NULL_HANDLE ) {
|
||||
vkDestroySemaphore( Vulkan.Device, Vulkan.RenderingFinishedSemaphore, nullptr );
|
||||
}
|
||||
if( Vulkan.SwapChain != VK_NULL_HANDLE ) {
|
||||
vkDestroySwapchainKHR( Vulkan.Device, Vulkan.SwapChain, 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
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace ApiWithoutSecrets
|
||||
Reference in New Issue
Block a user